Merge lp:~kyrofa/unity-scope-snappy/libertine_parser into lp:~unity-api-team/unity-scope-snappy/trunk

[Kyle Fazzari]

Add Libertine JSON parser.

Add Libertine JSON parser.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:35
http://jenkins.qa.ubuntu.com/job/unity-scope-snappy-ci/138/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scope-snappy-wily-amd64-ci/95
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scope-snappy-wily-armhf-ci/92
        deb: http://jenkins.qa.ubuntu.com/job/unity-scope-snappy-wily-armhf-ci/92/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scope-snappy-wily-i386-ci/92

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scope-snappy-ci/138/rebuild

review: Approve (continuous-integration)

Unmerged revisions

35. By Kyle Fazzari on 2015-07-30

Add Libertine JSON parser.

34. By Kyle Fazzari on 2015-07-28

Add basic launcher scope with debian packaging and integration tests.

=== modified file 'Makefile'
--- Makefile	2015-07-30 15:00:59 +0000
+++ Makefile	2015-07-30 15:00:59 +0000
@@ -5,8 +5,9 @@
 GOFMT=gofmt -w
 
 TOP_PACKAGE := launchpad.net/unity-scope-snappy
-EXECUTABLES := launcher store package-management-daemon
-PACKAGES_TO_TEST := package-management-daemon/daemon \
+EXECUTABLES := launcher package-management-daemon store
+PACKAGES_TO_TEST := libertine \
+                    package-management-daemon/daemon \
                     store/actions \
                     store/packages \
                     store/packages/fakes \

=== added directory 'libertine'
=== added directory 'libertine/configuration'
=== added file 'libertine/configuration/application.go'
--- libertine/configuration/application.go	1970-01-01 00:00:00 +0000
+++ libertine/configuration/application.go	2015-07-30 15:00:59 +0000
@@ -0,0 +1,6 @@
+package configuration
+
+type Application struct {
+	Status string `json:"appStatus"`
+	Name string `json:"packageName"`
+}

=== added file 'libertine/configuration/configuration.go'
--- libertine/configuration/configuration.go	1970-01-01 00:00:00 +0000
+++ libertine/configuration/configuration.go	2015-07-30 15:00:59 +0000
@@ -0,0 +1,6 @@
+package configuration
+
+type Configuration struct {
+	DefaultContainer string
+	ContainerList []Container
+}

=== added file 'libertine/configuration/container.go'
--- libertine/configuration/container.go	1970-01-01 00:00:00 +0000
+++ libertine/configuration/container.go	2015-07-30 15:00:59 +0000
@@ -0,0 +1,9 @@
+package configuration
+
+type Container struct {
+	Id string
+	Name string
+	Image string
+	InstallStatus string
+	InstalledApps []Application
+}

=== added directory 'libertine/fakes'
=== added file 'libertine/fakes/fake_reader.go'
--- libertine/fakes/fake_reader.go	1970-01-01 00:00:00 +0000
+++ libertine/fakes/fake_reader.go	2015-07-30 15:00:59 +0000
@@ -0,0 +1,15 @@
+package fakes
+
+import "fmt"
+
+type FakeReader struct {
+	Error bool
+}
+
+func (fake FakeReader) Read(p []byte) (n int, err error) {
+	if fake.Error {
+		return 0, fmt.Errorf("Failed at user request")
+	}
+
+	return 1, nil
+}

=== added file 'libertine/parser.go'
--- libertine/parser.go	1970-01-01 00:00:00 +0000
+++ libertine/parser.go	2015-07-30 15:00:59 +0000
@@ -0,0 +1,41 @@
+package libertine
+
+import (
+	"fmt"
+	"launchpad.net/unity-scope-snappy/libertine/configuration"
+	"encoding/json"
+	"io"
+	"io/ioutil"
+	"os"
+)
+
+type Parser struct {
+	configuration configuration.Configuration
+}
+
+// ParseFile opens up the given JSON file path and parses it.
+//
+// It assumes that the given file was written by Libertine.
+func (parser *Parser) ParseFile(filePath string) error {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return fmt.Errorf(`Unable to open "%s": %s`, filePath, err)
+	}
+
+	return parser.Parse(file)
+}
+
+// Parse parses the given Libertine JSON.
+func (parser *Parser) Parse(reader io.Reader) error {
+	bytes, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return fmt.Errorf("Unable to read: %s", err)
+	}
+
+	err = json.Unmarshal(bytes, &parser.configuration)
+	if err != nil {
+		return fmt.Errorf(`Unable to parse: %s`, err)
+	}
+
+	return nil
+}

=== added file 'libertine/parser_test.go'
--- libertine/parser_test.go	1970-01-01 00:00:00 +0000
+++ libertine/parser_test.go	2015-07-30 15:00:59 +0000
@@ -0,0 +1,101 @@
+package libertine
+
+import (
+	"launchpad.net/unity-scope-snappy/libertine/fakes"
+	"os"
+	"io"
+	"io/ioutil"
+	"strings"
+	"testing"
+)
+
+var (
+	jsonString string
+	jsonReader io.Reader
+)
+
+func setup() {
+	jsonString = `{
+		"containerList": [
+			{
+				"id": "wily",
+				"image": "wily",
+				"installStatus": "new",
+				"installedApps": [
+					{
+					"appStatus": "new",
+					"packageName": "foo"
+					}
+				],
+				"name": "Ubuntu 'Wily Werewolf'"
+			}
+		],
+		"defaultContainer": "wily"
+	}`
+	jsonReader = strings.NewReader(jsonString)
+}
+
+func setupInvalid() {
+	jsonString = `{
+		"containerList": "bar"
+	}`
+	jsonReader = strings.NewReader(jsonString)
+}
+
+// Test typical ParseFile usage.
+func TestParseFile(t *testing.T) {
+	setup()
+
+	file, err := ioutil.TempFile("", "unity-scope-snappy")
+	if err != nil { panic(err) }
+	defer os.Remove(file.Name())
+	ioutil.WriteFile(file.Name(), []byte(jsonString), 0644)
+
+	var parser Parser
+	err = parser.ParseFile(file.Name())
+	if err != nil {
+		t.Errorf("Unexpected error parsing file: %s", err)
+	}
+}
+
+// Test that ParseFile handles an invalid file path
+func TestParseFile_invalidFilePath(t *testing.T) {
+	var parser Parser
+	err := parser.ParseFile("/foo/bar/baz")
+	if err == nil {
+		t.Error("Expected an error due to invalid file path")
+	}
+}
+
+// Test typical Parse usage.
+func TestParse(t *testing.T) {
+	setup()
+
+	var parser Parser
+	err := parser.Parse(jsonReader)
+	if err != nil {
+		t.Errorf("Unexpected error while parsing: %s", err)
+	}
+}
+
+// Test that Parse handles parsing invalid JSON
+func TestParse_invalidJson(t *testing.T) {
+	setupInvalid()
+
+	var parser Parser
+	err := parser.Parse(jsonReader)
+	if err == nil {
+		t.Error("Expected an error due to invalid JSON")
+	}
+}
+
+// Test that Parse handles an error while reading
+func TestParse_readError(t *testing.T) {
+	reader := fakes.FakeReader{Error: true}
+
+	var parser Parser
+	err := parser.Parse(reader)
+	if err == nil {
+		t.Error("Expected an error due to read error")
+	}
+}