Merge lp:~fgimenez/snappy/api-packages-test into lp:~snappy-dev/snappy/snappy-moved-to-github

[Federico Gimenez]

API 1.0/packages test

API 1.0/packages test

Besides the tests themselves these are the main things going on with the changes:

* The apiExerciser interface has been added, the suites for testing API resources should implement this interface and just call exerciseApi(). There are other interfaces for each http verb, depending on which ones are implemented the tests are executed differently.

* The apiInteraction type allows to describe how to test one api resource, when implementing an http verb interface the suites just need to return an array of those, each element has fields like responsePattern, responseObject (this is populated via json.Unmarshal if present), payload if needed (as a generic io.Reader), and, when there's an async call involved, waitResponsePattern and waitFunction

* A wait.ForFunction has been added to the wait package, for the previous functionality to work. The wait.ForCommand has been updated to use under covers ForFunction and the unit tests have been modified to prevent a delay that we were having.

* The functions used to build snaps have been moved to the build package.

[lp:~fgimenez/snappy/api-packages-test]

681. By Federico Gimenez on 2015-09-24

testing methods not allowed; payload as string

[Leo Arias (elopio)]

you are getting all fancy with interfaces and stuff in the tests :)
nice work.

I'm leaving some comments in the diff. The only big thing, in which maybe I am wrong, is the setUp and tearDown. We can talk about it tomorrow.

review: Needs Fixing

[lp:~fgimenez/snappy/api-packages-test]

682. By Federico Gimenez on 2015-09-28

Removed setup and teardown from the apiExerciser interface, using SetUpTest and TearDownTest fixtures from check; comments

[Federico Gimenez (fgimenez)]

Thanks for your comments Leo, they should be addressed now.

I'll try now to split this in several mp's to make it manageable

[Federico Gimenez (fgimenez)]

Ok, it's already split (order matters):

https://code.launchpad.net/~fgimenez/snappy/build-snap/+merge/272566
https://code.launchpad.net/~fgimenez/snappy/wait-for-function/+merge/272567
https://code.launchpad.net/~fgimenez/snappy/snapd-api-exerciser/+merge/272570
https://code.launchpad.net/~fgimenez/snappy/snapd-1_0-test/+merge/272574
https://code.launchpad.net/~fgimenez/snappy/snapd-1_0-packages-test/+merge/272576

Thanks!

Unmerged revisions

682. By Federico Gimenez on 2015-09-28

Removed setup and teardown from the apiExerciser interface, using SetUpTest and TearDownTest fixtures from check; comments

681. By Federico Gimenez on 2015-09-24

testing methods not allowed; payload as string

680. By Federico Gimenez on 2015-09-23

reverted image changes

679. By Federico Gimenez on 2015-09-23

doing the 404 check for each resource

678. By Federico Gimenez on 2015-09-23

some comments

677. By Federico Gimenez on 2015-09-23

moved package related types to the test file

676. By Federico Gimenez on 2015-09-23

/1.0/packages resource complete

675. By Federico Gimenez on 2015-09-23

/1.0 resource complete

674. By Federico Gimenez on 2015-09-23

interfaces definition; root and 404 complete

673. By Federico Gimenez on 2015-09-22

removed extra line

=== modified file '_integration-tests/tests/build_test.go'
--- _integration-tests/tests/build_test.go	2015-07-30 07:54:08 +0000
+++ _integration-tests/tests/build_test.go	2015-09-28 08:47:40 +0000
@@ -23,68 +23,61 @@
 	"fmt"
 	"os"
 	"os/exec"
-
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
-
-	. "gopkg.in/check.v1"
-)
-
-const (
-	baseSnapPath          = "_integration-tests/data/snaps"
-	basicSnapName         = "basic"
-	wrongYamlSnapName     = "wrong-yaml"
-	missingReadmeSnapName = "missing-readme"
-)
-
-var _ = Suite(&buildSuite{})
+	"path/filepath"
+
+	"launchpad.net/snappy/_integration-tests/testutils/build"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+
+	"gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&buildSuite{})
 
 type buildSuite struct {
-	SnappySuite
-}
-
-func buildSnap(c *C, snapPath string) string {
-	return ExecCommand(c, "snappy", "build", snapPath)
-}
-
-func (s *buildSuite) TestBuildBasicSnapOnSnappy(c *C) {
+	common.SnappySuite
+}
+
+func (s *buildSuite) TestBuildBasicSnapOnSnappy(c *check.C) {
 	// build basic snap and check output
-	snapPath := baseSnapPath + "/" + basicSnapName
-	buildOutput := buildSnap(c, snapPath)
-	snapName := basicSnapName + "_1.0_all.snap"
-	expected := fmt.Sprintf("Generated '%s' snap\n", snapName)
-	c.Check(buildOutput, Equals, expected)
-	defer os.Remove(snapPath + "/" + snapName)
+	snapPath, err := build.LocalSnap(c, build.BasicSnapName)
+	defer os.Remove(snapPath)
+	c.Assert(err, check.IsNil)
+
+	snapName := filepath.Base(snapPath)
 
 	// install built snap and check output
-	installOutput := InstallSnap(c, snapName)
-	defer RemoveSnap(c, basicSnapName)
-	expected = "(?ms)" +
+	installOutput := common.InstallSnap(c, snapName)
+	defer common.RemoveSnap(c, build.BasicSnapName)
+	expected := "(?ms)" +
 		"Installing " + snapName + "\n" +
 		".*Signature check failed, but installing anyway as requested\n" +
 		"Name +Date +Version +Developer \n" +
 		".*\n" +
-		basicSnapName + " +.* +.* +sideload  \n" +
+		build.BasicSnapName + " +.* +.* +sideload  \n" +
 		".*\n"
 
-	c.Check(installOutput, Matches, expected)
+	c.Check(installOutput, check.Matches, expected)
 
 	// teardown, remove snap file
-	c.Assert(os.Remove(snapName), IsNil, Commentf("Error removing %s", snapName))
-}
-
-func (s *buildSuite) TestBuildWrongYamlSnapOnSnappy(c *C) {
-	commonWrongTest(c, wrongYamlSnapName, "(?msi).*Can not parse.*yaml: line 2: mapping values are not allowed in this context.*")
-}
-
-func (s *buildSuite) TestBuildMissingReadmeSnapOnSnappy(c *C) {
-	commonWrongTest(c, missingReadmeSnapName, ".*readme.md: no such file or directory\n")
-}
-
-func commonWrongTest(c *C, testName, expected string) {
+	c.Assert(os.Remove(snapName), check.IsNil,
+		check.Commentf("Error removing %s", snapName))
+}
+
+func (s *buildSuite) TestBuildWrongYamlSnapOnSnappy(c *check.C) {
+	commonWrongTest(c, build.WrongYamlSnapName,
+		"(?msi).*Can not parse.*yaml: line 2: mapping values are not allowed in this context.*")
+}
+
+func (s *buildSuite) TestBuildMissingReadmeSnapOnSnappy(c *check.C) {
+	commonWrongTest(c, build.MissingReadmeSnapName,
+		".*readme.md: no such file or directory\n")
+}
+
+func commonWrongTest(c *check.C, testName, expected string) {
 	// build wrong snap and check output
-	cmd := exec.Command("snappy", "build", fmt.Sprintf("%s/%s", baseSnapPath, testName))
+	cmd := exec.Command("snappy", "build", fmt.Sprintf("%s/%s", build.BaseSnapPath, testName))
 	echoOutput, err := cmd.CombinedOutput()
-	c.Assert(err, NotNil, Commentf("%s should not be built", testName))
+	c.Assert(err, check.NotNil, check.Commentf("%s should not be built", testName))
 
-	c.Assert(string(echoOutput), Matches, expected)
+	c.Assert(string(echoOutput), check.Matches, expected)
 }

=== added file '_integration-tests/tests/snapd_1_0_packages_test.go'
--- _integration-tests/tests/snapd_1_0_packages_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/snapd_1_0_packages_test.go	2015-09-28 08:47:40 +0000
@@ -0,0 +1,97 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"os"
+
+	"launchpad.net/snappy/_integration-tests/testutils/build"
+
+	"gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&snapd10PackagesTestSuite{})
+
+type pkgsResponse struct {
+	Result pkgContainer
+	response
+}
+
+type pkgContainer struct {
+	Packages pkgItems
+	Paging   map[string]interface{}
+}
+
+type pkgItems map[string]pkgItem
+
+type pkgItem struct {
+	Description   string
+	DownloadSize  string `json:"download_size"`
+	Icon          string
+	InstalledSize string `json:"installed_size"`
+	Name          string
+	Origin        string
+	Resource      string
+	Status        string
+	Type          string
+	Vendor        string
+	Version       string
+}
+
+type snapd10PackagesTestSuite struct {
+	snapdTestSuite
+	snapPath string
+}
+
+func (s *snapd10PackagesTestSuite) SetUpTest(c *check.C) {
+	s.snapdTestSuite.SetUpTest(c)
+	var err error
+	s.snapPath, err = build.LocalSnap(c, build.BasicSnapName)
+	c.Assert(err, check.IsNil)
+
+}
+
+func (s *snapd10PackagesTestSuite) TearDownTest(c *check.C) {
+	s.snapdTestSuite.TearDownTest(c)
+	os.Remove(s.snapPath)
+}
+
+func (s *snapd10PackagesTestSuite) resource() string {
+	return baseURL + "/1.0/packages"
+}
+
+func (s *snapd10PackagesTestSuite) TestResource(c *check.C) {
+	exerciseAPI(c, s)
+}
+
+func (s *snapd10PackagesTestSuite) getInteractions() apiInteractions {
+	return []apiInteraction{{
+		responseObject: &pkgsResponse{}}}
+}
+
+func (s *snapd10PackagesTestSuite) postInteractions() apiInteractions {
+	return []apiInteraction{{
+		payload:     s.snapPath,
+		waitPattern: `(?U){.*,"status":"active".*"status":"OK","status_code":200,"type":"sync"}`,
+		waitFunction: func() (string, error) {
+			output, err := genericRequest(s.resource()+"/"+build.BasicSnapName+".sideload", "GET", nil)
+			return string(output), err
+		}}}
+}

=== added file '_integration-tests/tests/snapd_1_0_test.go'
--- _integration-tests/tests/snapd_1_0_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/snapd_1_0_test.go	2015-09-28 08:47:40 +0000
@@ -0,0 +1,41 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import "gopkg.in/check.v1"
+
+var _ = check.Suite(&snapd10TestSuite{})
+
+type snapd10TestSuite struct {
+	snapdTestSuite
+}
+
+func (s *snapd10TestSuite) TestResource(c *check.C) {
+	exerciseAPI(c, s)
+}
+
+func (s *snapd10TestSuite) resource() string {
+	return baseURL + "/1.0"
+}
+
+func (s *snapd10TestSuite) getInteractions() apiInteractions {
+	return []apiInteraction{{
+		responsePattern: `(?U){"result":{"api_compat":"0","default_channel":".*","flavor":".*","release":".*"},"status":"OK","status_code":200,"type":"sync"}`}}
+}

=== added file '_integration-tests/tests/snapd_root_test.go'
--- _integration-tests/tests/snapd_root_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/snapd_root_test.go	2015-09-28 08:47:40 +0000
@@ -0,0 +1,41 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import "gopkg.in/check.v1"
+
+var _ = check.Suite(&snapdRootTestSuite{})
+
+type snapdRootTestSuite struct {
+	snapdTestSuite
+}
+
+func (s *snapdRootTestSuite) TestResource(c *check.C) {
+	exerciseAPI(c, s)
+}
+
+func (s *snapdRootTestSuite) resource() string {
+	return baseURL + "/"
+}
+
+func (s *snapdRootTestSuite) getInteractions() apiInteractions {
+	return []apiInteraction{{
+		responsePattern: `(?U){"result":\[".*"\],"status":"OK","status_code":200,"type":"sync"}`}}
+}

=== modified file '_integration-tests/tests/snapd_test.go'
--- _integration-tests/tests/snapd_test.go	2015-09-15 16:07:54 +0000
+++ _integration-tests/tests/snapd_test.go	2015-09-28 08:47:40 +0000
@@ -20,10 +20,15 @@
 package tests
 
 import (
+	"encoding/json"
+	"io"
 	"io/ioutil"
+	"log"
 	"net/http"
+	"os"
 	"os/exec"
 	"strconv"
+	"strings"
 
 	"launchpad.net/snappy/_integration-tests/testutils/common"
 	"launchpad.net/snappy/_integration-tests/testutils/wait"
@@ -32,7 +37,10 @@
 )
 
 // make sure that there are no collisions
-const port = "9999"
+const (
+	port    = "9999"
+	baseURL = "http://127.0.0.1:" + port
+)
 
 var _ = check.Suite(&snapdTestSuite{})
 
@@ -43,7 +51,7 @@
 
 func (s *snapdTestSuite) SetUpTest(c *check.C) {
 	s.SnappySuite.SetUpTest(c)
-	s.cmd = exec.Command("/lib/systemd/systemd-activate",
+	s.cmd = exec.Command("sudo", "/lib/systemd/systemd-activate",
 		"-l", "0.0.0.0:"+port, "snapd")
 
 	s.cmd.Start()
@@ -62,34 +70,177 @@
 	}
 }
 
-func (s *snapdTestSuite) TestServiceIsUp(c *check.C) {
-	resp, err := http.Get("http://127.0.0.1:" + port)
-	c.Assert(err, check.IsNil)
-	defer resp.Body.Close()
-
-	body, err := ioutil.ReadAll(resp.Body)
-	c.Assert(err, check.IsNil)
-
-	expected := `{"result":["/1.0"],"status":"OK","status_code":200,"type":"sync"}`
-	c.Assert(string(body), check.Equals, expected)
-}
-
-func (s *snapdTestSuite) TestResources(c *check.C) {
-	resources := []struct {
-		path        string
-		respPattern string
-	}{{"/", `(?U){"result":\[".*"\],"status":"OK","status_code":200,"type":"sync"}`},
-		{"/1.0", `(?U){"result":{"api_compat":"0","default_channel":".*","flavor":".*","release":".*"},"status":"OK","status_code":200,"type":"sync"}`},
-		{"/not-a-resource", `{"result":{},"status":"Not Found","status_code":404,"type":"error"}`}}
-
-	for _, resource := range resources {
-		resp, err := http.Get("http://127.0.0.1:" + port + resource.path)
-		c.Check(err, check.IsNil)
-		defer resp.Body.Close()
-
-		body, err := ioutil.ReadAll(resp.Body)
-		c.Check(err, check.IsNil)
-
-		c.Check(string(body), check.Matches, resource.respPattern)
-	}
+type response struct {
+	Result     interface{}
+	Status     string
+	Type       string
+	StatusCode int `json:"status_code"`
+}
+
+type asyncResponse struct {
+	Result asyncResult
+	response
+}
+
+type asyncResult struct {
+	CreatedAt string `json:"created_at"`
+	MayCancel bool   `json:"may_cancel"`
+	Output    string
+	Resource  string
+	Status    string
+	UpdatedAt string `json:"updated_at"`
+}
+
+// type for describing interactions with the api
+type apiInteraction struct {
+	// payload can describe a file path or be the content to be appended to the
+	// body of the request
+	payload string
+	// expected pattern for the response
+	responsePattern string
+	// expected structure of the response
+	responseObject interface{}
+	// for async request, the test will keep executing the waitFunction
+	// until the waitPattern is received or a timeout expires
+	waitPattern  string
+	waitFunction func() (string, error)
+}
+
+type apiInteractions []apiInteraction
+
+// all the api test suites must satisfy this interface
+type apiExerciser interface {
+	// returns the path of the resource to be tested, as in "/1.0/packages"
+	resource() string
+}
+
+// concrete interface for apis exercising GET
+type apiGetExerciser interface {
+	getInteractions() apiInteractions
+}
+
+// concrete interface for apis exercising POST
+type apiPostExerciser interface {
+	postInteractions() apiInteractions
+}
+
+// concrete interface for apis exercising PUT
+type apiPutExerciser interface {
+	putInteractions() apiInteractions
+}
+
+// concrete interface for apis exercising DELETE
+type apiDeleteExerciser interface {
+	deleteInteractions() apiInteractions
+}
+
+// this is the entry point for all the api tests
+func exerciseAPI(c *check.C, a apiExerciser) {
+	resource := a.resource()
+
+	do404(c, resource)
+
+	if getInstance, ok := a.(apiGetExerciser); ok {
+		doInteractions(c, resource, "GET", getInstance.getInteractions())
+	} else {
+		doMethodNotAllowed(c, resource, "GET")
+	}
+
+	if postInstance, ok := a.(apiPostExerciser); ok {
+		doInteractions(c, resource, "POST", postInstance.postInteractions())
+	} else {
+		doMethodNotAllowed(c, resource, "POST")
+	}
+
+	if putInstance, ok := a.(apiPutExerciser); ok {
+		doInteractions(c, resource, "PUT", putInstance.putInteractions())
+	} else {
+		doMethodNotAllowed(c, resource, "PUT")
+	}
+
+	if deleteInstance, ok := a.(apiDeleteExerciser); ok {
+		doInteractions(c, resource, "DELETE", deleteInstance.deleteInteractions())
+	} else {
+		doMethodNotAllowed(c, resource, "DELETE")
+	}
+}
+
+func doInteractions(c *check.C, resource, verb string, interactions apiInteractions) {
+	log.Printf("*** Exercising API for resource %s with verb %s", resource, verb)
+
+	for _, interaction := range interactions {
+		doInteraction(c, resource, verb, interaction)
+	}
+}
+
+// all the interactions are dispatched with this function
+func doInteraction(c *check.C, resource, verb string, interaction apiInteraction) {
+	log.Printf("** Trying interaction %v", interaction)
+
+	var (
+		payload io.Reader
+		err     error
+	)
+	if _, err = os.Stat(interaction.payload); os.IsNotExist(err) {
+		// The payload is not a file. Treat it as a string
+		payload = strings.NewReader(interaction.payload)
+	} else {
+		payload, err = os.Open(interaction.payload)
+		f, _ := payload.(*os.File)
+		defer f.Close()
+	}
+
+	body, err := genericRequest(resource, verb, payload)
+	c.Check(err, check.IsNil)
+
+	if interaction.responseObject == nil {
+		interaction.responseObject = &response{}
+	}
+	err = json.Unmarshal(body, interaction.responseObject)
+	c.Check(err, check.IsNil)
+
+	if interaction.responsePattern != "" {
+		c.Check(string(body), check.Matches, interaction.responsePattern)
+	}
+	if interaction.waitPattern != "" {
+		err = wait.ForFunction(c, interaction.waitPattern, interaction.waitFunction)
+		c.Check(err, check.IsNil)
+	}
+}
+
+func do404(c *check.C, resource string) {
+	doInteraction(c,
+		resource+"/not-a-resource",
+		"GET",
+		apiInteraction{
+			responsePattern: `{"result":{},"status":"Not Found","status_code":404,"type":"error"}`})
+}
+
+func doMethodNotAllowed(c *check.C, resource, verb string) {
+	doInteraction(c,
+		resource,
+		verb,
+		apiInteraction{
+			responsePattern: `{"result":{},"status":"Method Not Allowed","status_code":405,"type":"error"}`})
+}
+
+// this is the function which makes requests to the api
+func genericRequest(resource, verb string, payload io.Reader) (body []byte, err error) {
+	if file, ok := payload.(*os.File); ok {
+		defer file.Close()
+	}
+
+	req, err := http.NewRequest(verb, resource, payload)
+	if err != nil {
+		return
+	}
+	req.Header.Add("X-Allow-Unsigned", "1")
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+
+	if err != nil {
+		return
+	}
+	return ioutil.ReadAll(resp.Body)
 }

=== added file '_integration-tests/testutils/build/snap.go'
--- _integration-tests/testutils/build/snap.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/build/snap.go	2015-09-28 08:47:40 +0000
@@ -0,0 +1,71 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package build
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"gopkg.in/check.v1"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+)
+
+const (
+	// BaseSnapPath is the path for the snap sources used in testing
+	BaseSnapPath = "_integration-tests/data/snaps"
+	// BasicSnapName is the name of the basic snap
+	BasicSnapName = "basic"
+	// WrongYamlSnapName is the name of a snap with an invalid meta yaml
+	WrongYamlSnapName = "wrong-yaml"
+	// MissingReadmeSnapName is the name of a snap without readme
+	MissingReadmeSnapName = "missing-readme"
+
+	snapFilenameSufix = "_1.0_all.snap"
+)
+
+var (
+	// dependency aliasing
+	commonExecCommand = common.ExecCommand
+)
+
+func buildSnap(c *check.C, snapPath string) string {
+	return commonExecCommand(c, "snappy", "build", snapPath, "-o", snapPath)
+}
+
+// LocalSnap issues the command to build a snap and returns the path of the generated file
+func LocalSnap(c *check.C, snapName string) (snapPath string, err error) {
+	// build basic snap and check output
+	buildPath := buildPath(snapName)
+
+	buildOutput := buildSnap(c, buildPath)
+	snapName = snapName + snapFilenameSufix
+
+	path := filepath.Join(buildPath, snapName)
+	expected := fmt.Sprintf("Generated '%s' snap\n", path)
+	if buildOutput != expected {
+		return "", fmt.Errorf("Error building snap, expected output %s, obtained %s",
+			expected, buildOutput)
+	}
+	return path, nil
+}
+
+func buildPath(snap string) string {
+	return filepath.Join(BaseSnapPath, snap)
+}

=== added file '_integration-tests/testutils/build/snap_test.go'
--- _integration-tests/testutils/build/snap_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/build/snap_test.go	2015-09-28 08:47:40 +0000
@@ -0,0 +1,82 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package build
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"gopkg.in/check.v1"
+)
+
+type snapBuildTestSuite struct {
+	execCalls       map[string]int
+	execReturnValue string
+	backExecCommand func(*check.C, ...string) string
+	defaultSnapName string
+}
+
+var _ = check.Suite(&snapBuildTestSuite{})
+
+func (s *snapBuildTestSuite) SetUpSuite(c *check.C) {
+	s.backExecCommand = commonExecCommand
+	commonExecCommand = s.fakeExecCommand
+	s.defaultSnapName = "mySnapName"
+}
+
+func (s *snapBuildTestSuite) TearDownSuite(c *check.C) {
+	commonExecCommand = s.backExecCommand
+}
+
+func (s *snapBuildTestSuite) SetUpTest(c *check.C) {
+	s.execCalls = make(map[string]int)
+	snapName := s.defaultSnapName + snapFilenameSufix
+	path := filepath.Join(buildPath(s.defaultSnapName), snapName)
+	s.execReturnValue = fmt.Sprintf("Generated '%s' snap\n", path)
+}
+
+func (s *snapBuildTestSuite) fakeExecCommand(c *check.C, args ...string) (output string) {
+	s.execCalls[strings.Join(args, " ")]++
+	return s.execReturnValue
+}
+
+func (s *snapBuildTestSuite) TestBuildPath(c *check.C) {
+	path := buildPath(s.defaultSnapName)
+
+	expected := buildPath(s.defaultSnapName)
+	c.Assert(path, check.Equals, expected)
+}
+
+func (s *snapBuildTestSuite) TestLocalSnapCallsExecCommand(c *check.C) {
+	_, err := LocalSnap(c, s.defaultSnapName)
+
+	c.Assert(err, check.IsNil)
+	path := buildPath(s.defaultSnapName)
+	c.Assert(s.execCalls["snappy build "+path+" -o "+path], check.Equals, 1)
+}
+
+func (s *snapBuildTestSuite) TestLocalSnapReturnsSnapPath(c *check.C) {
+	snapPath, err := LocalSnap(c, s.defaultSnapName)
+
+	c.Assert(err, check.IsNil)
+	expected := filepath.Join(buildPath(s.defaultSnapName), s.defaultSnapName+snapFilenameSufix)
+	c.Assert(snapPath, check.Equals, expected)
+}

=== modified file '_integration-tests/testutils/wait/wait.go'
--- _integration-tests/testutils/wait/wait.go	2015-09-04 07:41:30 +0000
+++ _integration-tests/testutils/wait/wait.go	2015-09-28 08:47:40 +0000
@@ -33,8 +33,11 @@
 	// dependency aliasing
 	execCommand = common.ExecCommand
 	// ForCommand dep alias
-	ForCommand     = forCommand
+	ForCommand = forCommand
+	// ForFunction dep alias
+	ForFunction    = forFunction
 	maxWaitRetries = 100
+	interval       = time.Duration(100)
 )
 
 // ForActiveService uses ForCommand to check for an active service
@@ -47,19 +50,27 @@
 	return ForCommand(c, fmt.Sprintf(`(?msU)^.*tcp.*0\.0\.0\.0:%d .*`, port), "netstat", "-tapn")
 }
 
-// forCommand keeps trying to execute the given command to get an output that
+// forCommand uses ForFunction to check for the execCommand output
+func forCommand(c *check.C, outputPattern string, cmds ...string) (err error) {
+	return ForFunction(c, outputPattern, func() (string, error) { return execCommand(c, cmds...), nil })
+}
+
+// forFunction keeps trying to execute the given function to get an output that
 // matches the given pattern until it is obtained or the maximun number of
 // retries is executed
-func forCommand(c *check.C, outputPattern string, cmds ...string) (err error) {
-	output := execCommand(c, cmds...)
-
+func forFunction(c *check.C, outputPattern string, inputFunc func() (string, error)) (err error) {
 	re := regexp.MustCompile(outputPattern)
 
+	output, err := inputFunc()
+	if err != nil {
+		return
+	}
+
 	if match := re.FindString(output); match != "" {
 		return
 	}
 
-	checkInterval := time.Millisecond * 100
+	checkInterval := time.Millisecond * interval
 	var retries int
 
 	ticker := time.NewTicker(checkInterval)
@@ -68,7 +79,11 @@
 	for {
 		select {
 		case <-tickChan:
-			output = execCommand(c, cmds...)
+			output, err = inputFunc()
+			if err != nil {
+				ticker.Stop()
+				return
+			}
 			if match := re.FindString(output); match != "" {
 				ticker.Stop()
 				return
@@ -76,7 +91,7 @@
 			retries++
 			if retries >= maxWaitRetries {
 				ticker.Stop()
-				return fmt.Errorf("Pattern not found in command output")
+				return fmt.Errorf("Pattern not found in function output")
 			}
 		}
 	}

=== modified file '_integration-tests/testutils/wait/wait_test.go'
--- _integration-tests/testutils/wait/wait_test.go	2015-09-04 09:25:17 +0000
+++ _integration-tests/testutils/wait/wait_test.go	2015-09-28 08:47:40 +0000
@@ -28,111 +28,123 @@
 	"gopkg.in/check.v1"
 )
 
+const (
+	outputPattern = "myOutputPattern"
+)
+
 // Hook up check.v1 into the "go test" runner
 func Test(t *testing.T) { check.TestingT(t) }
 
 type waitTestSuite struct {
-	execCalls       map[string]int
-	execReturnValue string
-	backExecCommand func(*check.C, ...string) string
+	myFuncCalls       int
+	myFuncReturnValue string
+	myFuncError       bool
+
+	outputPattern string
 
 	initTime time.Time
 	delay    time.Duration
+
+	backInterval       time.Duration
+	backMaxWaitRetries int
 }
 
 var _ = check.Suite(&waitTestSuite{})
 
-func (s *waitTestSuite) SetUpSuite(c *check.C) {
-	s.backExecCommand = execCommand
-	execCommand = s.fakeExecCommand
-}
-
-func (s *waitTestSuite) TearDownSuite(c *check.C) {
-	execCommand = s.backExecCommand
-}
-
 func (s *waitTestSuite) SetUpTest(c *check.C) {
-	s.execCalls = make(map[string]int)
-	s.execReturnValue = ""
+	s.myFuncCalls = 0
+	s.myFuncReturnValue = outputPattern
+	s.myFuncError = false
+
+	s.backInterval = interval
+	s.backMaxWaitRetries = maxWaitRetries
+
 	// save the starting time to be able to measure delays
 	s.initTime = time.Now()
 	// reset delay, each test will set it up if needed
 	s.delay = 0
-}
-
-func (s *waitTestSuite) fakeExecCommand(c *check.C, args ...string) (output string) {
-	s.execCalls[strings.Join(args, " ")]++
+
+	interval = 1
+}
+
+func (s *waitTestSuite) TearDownTest(c *check.C) {
+	interval = s.backInterval
+	maxWaitRetries = s.backMaxWaitRetries
+}
+
+func (s *waitTestSuite) myFunc() (output string, err error) {
+	s.myFuncCalls++
 
 	// after the given delay (0 by default) this method will return the value specified at
-	// execReturnValue, before it all the calls will return an empty string
+	// myFuncReturnValue, before it all the calls will return an empty string
 	if time.Since(s.initTime) >= s.delay {
-		output = s.execReturnValue
+		output = s.myFuncReturnValue
+		if s.myFuncError {
+			err = fmt.Errorf("Error!")
+		}
 	}
-
 	return
 }
 
-func (s *waitTestSuite) TestForCommandExists(c *check.C) {
-	cmd := "mycommand"
-	outputPattern := "myOutput"
-	s.execReturnValue = "myOutput"
-
-	err := ForCommand(c, outputPattern, cmd)
+func (s *waitTestSuite) TestForFunctionExists(c *check.C) {
+	err := ForFunction(c, outputPattern, s.myFunc)
 
 	c.Assert(err, check.IsNil, check.Commentf("Got error %s", err))
 }
 
-func (s *waitTestSuite) TestForCommandCallsGivenCommand(c *check.C) {
-	cmd := []string{"mycmd", "mypar"}
-	outputPattern := "myOutput"
-	s.execReturnValue = "myOutput"
-
-	ForCommand(c, outputPattern, cmd...)
-
-	execCalls := s.execCalls["mycmd mypar"]
-
-	c.Assert(execCalls, check.Equals, 1,
-		check.Commentf("Expected 1 call to ExecCommand with 'mycmd mypar', got %d", execCalls))
-}
-
-func (s *waitTestSuite) TestForCommandFailsOnUnmatchedOutput(c *check.C) {
-	cmd := []string{"mycmd", "mypar"}
-	outputPattern := "myOutput"
-	s.execReturnValue = "anotherOutput"
-
-	backMaxWaitRetries := maxWaitRetries
-	defer func() { maxWaitRetries = backMaxWaitRetries }()
+func (s *waitTestSuite) TestForFunctionCallsGivenFunction(c *check.C) {
+	ForFunction(c, outputPattern, s.myFunc)
+
+	c.Assert(s.myFuncCalls, check.Equals, 1,
+		check.Commentf("Expected 1 call to ExecCommand with 'mycmd mypar', got %d", s.myFuncCalls))
+}
+
+func (s *waitTestSuite) TestForFunctionReturnsFunctionError(c *check.C) {
+	s.myFuncError = true
+
+	err := ForFunction(c, outputPattern, s.myFunc)
+
+	c.Assert(err, check.NotNil, check.Commentf("Didn't get expected error"))
+}
+
+func (s *waitTestSuite) TestForFunctionReturnsFunctionErrorOnRetry(c *check.C) {
+	s.myFuncError = true
+	s.delay = 1 * time.Millisecond
+
+	err := ForFunction(c, outputPattern, s.myFunc)
+
+	c.Assert(err, check.NotNil, check.Commentf("Didn't get expected error"))
+}
+
+func (s *waitTestSuite) TestForFunctionFailsOnUnmatchedOutput(c *check.C) {
 	maxWaitRetries = 0
 
-	err := ForCommand(c, outputPattern, cmd...)
+	s.myFuncReturnValue = "anotherPattern"
+	err := ForFunction(c, outputPattern, s.myFunc)
 
 	c.Assert(err, check.NotNil, check.Commentf("Didn't get expected error"))
 }
 
-func (s *waitTestSuite) TestForCommandRetriesCalls(c *check.C) {
-	cmd := []string{"mycmd", "mypar"}
-	outputPattern := "myOutput"
-	s.execReturnValue = "myOutput"
-
-	s.delay = 10 * time.Millisecond
-
-	err := ForCommand(c, outputPattern, cmd...)
+func (s *waitTestSuite) TestForFunctionRetriesCalls(c *check.C) {
+	maxWaitRetries = 2
+
+	s.delay = 2 * time.Millisecond
+
+	err := ForFunction(c, outputPattern, s.myFunc)
 
 	c.Assert(err, check.IsNil, check.Commentf("Got error %s", err))
+	c.Assert(s.myFuncCalls > 0, check.Equals, true)
 }
 
-func (s *waitTestSuite) TestForCommandHonoursMaxWaitRetries(c *check.C) {
-	cmd := []string{"mycmd", "mypar"}
-	outputPattern := "myOutput"
-
-	backMaxWaitRetries := maxWaitRetries
-	defer func() { maxWaitRetries = backMaxWaitRetries }()
+func (s *waitTestSuite) TestForFunctionHonoursMaxWaitRetries(c *check.C) {
 	maxWaitRetries = 3
 
-	ForCommand(c, outputPattern, cmd...)
+	s.myFuncReturnValue = "anotherPattern"
+
+	ForFunction(c, outputPattern, s.myFunc)
 
 	// the first call is not actually a retry
-	actualRetries := s.execCalls["mycmd mypar"] - 1
+	actualRetries := s.myFuncCalls - 1
 
 	c.Assert(actualRetries, check.Equals, maxWaitRetries,
 		check.Commentf("Actual number of retries %d does not match max retries %d",
@@ -170,3 +182,37 @@
 	expectedCalled := `ForCommand called with pattern '(?msU)^.*tcp.*0\.0\.0\.0:1234 .*' and cmds 'netstat -tapn'`
 	c.Assert(called, check.Equals, expectedCalled, check.Commentf("Expected call to ForCommand didn't happen"))
 }
+
+func (s *waitTestSuite) TestForCommandCallsForFunction(c *check.C) {
+	backForFunction := ForFunction
+	defer func() { ForFunction = backForFunction }()
+	var called string
+
+	ForFunction = func(c *check.C, pattern string, inputFunc func() (string, error)) (err error) {
+		called = fmt.Sprintf("ForFunction called with pattern '%s' and execCommand wrapper", pattern)
+		return
+	}
+
+	ForCommand(c, "pattern", "ls")
+
+	expectedCalled := `ForFunction called with pattern 'pattern' and execCommand wrapper`
+	c.Assert(called, check.Equals, expectedCalled, check.Commentf("Expected call to ForFunction didn't happen"))
+}
+
+func (s *waitTestSuite) TestForCommandUsesExecCommand(c *check.C) {
+	maxWaitRetries = 0
+
+	backExecCommand := execCommand
+	defer func() { execCommand = backExecCommand }()
+	var called string
+
+	execCommand = func(c *check.C, cmds ...string) (output string) {
+		called = fmt.Sprintf("execCommand called with cmds %s", cmds)
+		return
+	}
+
+	ForCommand(c, "pattern", "ls")
+
+	expectedCalled := `execCommand called with cmds [ls]`
+	c.Assert(called, check.Equals, expectedCalled, check.Commentf("Expected call to execCommand didn't happen"))
+}