Merge lp:~elopio/snappy/15.04-backport-integration into lp:~snappy-dev/snappy/15.04-deprecated

[Leo Arias]

Backported the integration tests.

Huge branch! But you don't need to check everything, as it's just a copy from trunk. Run the tests and we are good to go.

[Leo Arias (elopio)]

Work in progress because we want to land this after the current release. But this is working, ready to be tested.

[Federico Gimenez (fgimenez)]

Thanks for this Leo, leaving my approval here

review: Approve (tested)

[Federico Gimenez (fgimenez)]

There's a problem with the gocheck dependency, the installed package name doesn't match the import name [1]. We should modify also dependencies.tsv.

Thanks!

[1] http://10.55.61.165:8080/job/snappy-integration-tests-canonistack-1504-edge/14/console

[Leo Arias (elopio)]

@Federico, I backported the gocheck update because we need a newer version than the one that's in launchpad. It's a prerequisite of this branch.

[Federico Gimenez (fgimenez)]

Ok, tested and working, thanks!

review: Approve

=== added directory '_integration-tests'
=== added file '_integration-tests/README.md'
--- _integration-tests/README.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/README.md	2015-08-02 12:28:52 +0000
@@ -0,0 +1,117 @@
+# Integration testing for snappy
+
+## Requirements
+
+ *  autopkgtest (>= 3.15.1)
+
+    Get the latest autopkgtest deb from
+    https://packages.debian.org/sid/all/autopkgtest/download
+
+ *  Internet access in the test bed.
+
+## Setting up the project
+
+First you need to set up the GOPATH, get the snappy sources and the
+dependencies as explained in the `README.md` that is located at the root of the
+branch.
+
+## Testing a virtual machine
+
+You can execute the full integration suite in a local virtual machine with:
+
+    go run _integration-tests/main.go
+
+The test runner will create the snappy images with `ubuntu-device-flash`, so it
+will ask for your password to run this command with `sudo`.
+
+You can also especify more options to customize the image being created, including
+the release, the channel and the revision to use. This parameters will be passed
+to `ubuntu-device-flash`:
+
+    go run _integration-tests/main.go -release 15.04 -channel stable -revision 3
+
+The default values are suited to testing the most recent version, `rolling` for
+release, `edge` for channel and an empty revision, which picks the latest
+available.
+
+## Testing snappy from a branch
+
+With the --snappy-from-branch flag, the snappy CLI command will be compiled
+from the current branch, copied to the test bed and used during the integration
+tests:
+
+    go run _integration-tests/main.go --snappy-from-branch
+
+You can use this flag to test in a remote machine too.
+
+## Filtering the tests to run
+
+With the --filter flag you can select the tests to run. For instance you can
+pass MyTestSuite, MyTestSuite.FirstCustomTest or MyTestSuite.*CustomTest:
+
+    go run _integration-tests/main.go --filter MyTestSuite.FirstCustomTest
+
+## Testing a remote machine
+
+You can execute the integration suite in a remote snappy machine with:
+
+    go run _integration-tests/main.go --ip {testbed-ip} --port {testbed-port} \
+    --arch {testbed-arch}
+
+The test runner will use `ssh-copy-id` to send your identity file to the
+testbed, so it will ask for the password of the ubuntu user in the test bed.
+
+When running in a remote machine, the test runner assumes the test bed is in
+the latest rolling edge version, and it will skip all the tests that
+require a different version. See the following section for instructions for
+setting up a BeagleBone Black as the test bed.
+
+## Testing a BeagleBone Black
+
+First flash the latest 15.04 edge version into the sd card
+(replacing /dev/sdX with the path to your card):
+
+    sudo ubuntu-device-flash core 15.04 --channel edge --oem beagleblack \
+    --developer-mode --enable-ssh -o ubuntu-15.04-edge-armhf-bbb.img
+
+    sudo dd if=ubuntu-15.04-edge-armhf-bbb.img of=/dev/sdX bs=32M
+    sync
+
+Then boot the board with the sd card, make sure that it is connected to the
+same network as the test runner host, and find the {beaglebone-ip}.
+
+Run the tests with:
+
+    go run _integration-tests/main.go --ip {beaglebone-ip} --arch arm
+
+## Testing an update
+
+With the --update flag you can flash an old image, update to the latest and
+then run the whole suite on the updated system. The release, the channel and
+the revision flags specify the image that will be flashed, and the
+target-release and target-channel flags specify the values to be used in the
+update if they are different from the flashed values.
+
+For example, to update from 15.04 edge -1 to the latest and then run the
+integration tests:
+
+    go run _integration-tests/main.go --snappy-from-branch \
+    --release=15.04 --revision=-1 --update
+
+To update from 15.04 alpha to 15.04 edge and then run the integration tests:
+
+    go run _integration-tests/main.go --snappy-from-branch \
+    --release=15.04 --channel=alpha \
+    --update --target-channel=edge
+
+## Testing a rollback
+
+With the --rollback flag you can flash an old image, update to the latest,
+rollback again to the old image and then run the whole suite on the rolled
+back system. You should use the release, channel, revision, target-release and
+target-channel flags as when testing an update.
+
+For example, to test a rollback from latest 15.04 edge to 15.04 edge -1:
+
+    go run _integration-tests/main.go \
+    --release=15.04 --revision=-1 --rollback

=== added directory '_integration-tests/data'
=== added directory '_integration-tests/data/snaps'
=== added directory '_integration-tests/data/snaps/basic'
=== added directory '_integration-tests/data/snaps/basic/meta'
=== added file '_integration-tests/data/snaps/basic/meta/package.yaml'
--- _integration-tests/data/snaps/basic/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic/meta/package.yaml	2015-08-02 12:28:52 +0000
@@ -0,0 +1,4 @@
+name: basic
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png

=== added file '_integration-tests/data/snaps/basic/meta/readme.md'
--- _integration-tests/data/snaps/basic/meta/readme.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic/meta/readme.md	2015-08-02 12:28:52 +0000
@@ -0,0 +1,3 @@
+Basic snap
+
+A basic buildable snap

=== added file '_integration-tests/data/snaps/basic/meta/snappy64.png'
Binary files _integration-tests/data/snaps/basic/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/basic/meta/snappy64.png	2015-08-02 12:28:52 +0000 differ
=== added directory '_integration-tests/data/snaps/missing-readme'
=== added directory '_integration-tests/data/snaps/missing-readme/meta'
=== added file '_integration-tests/data/snaps/missing-readme/meta/package.yaml'
--- _integration-tests/data/snaps/missing-readme/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/missing-readme/meta/package.yaml	2015-08-02 12:28:52 +0000
@@ -0,0 +1,4 @@
+name: missing-readme
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png

=== added file '_integration-tests/data/snaps/missing-readme/meta/snappy64.png'
Binary files _integration-tests/data/snaps/missing-readme/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/missing-readme/meta/snappy64.png	2015-08-02 12:28:52 +0000 differ
=== added directory '_integration-tests/data/snaps/wrong-yaml'
=== added directory '_integration-tests/data/snaps/wrong-yaml/meta'
=== added file '_integration-tests/data/snaps/wrong-yaml/meta/package.yaml'
--- _integration-tests/data/snaps/wrong-yaml/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/wrong-yaml/meta/package.yaml	2015-08-02 12:28:52 +0000
@@ -0,0 +1,5 @@
+# This is an invalid yaml, there's a missing colon after the 'name' field
+name wrong-yaml
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png

=== added file '_integration-tests/data/snaps/wrong-yaml/meta/readme.md'
--- _integration-tests/data/snaps/wrong-yaml/meta/readme.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/wrong-yaml/meta/readme.md	2015-08-02 12:28:52 +0000
@@ -0,0 +1,3 @@
+Wrong metadata snap
+
+A snap with an invalid meta/package.yaml

=== added file '_integration-tests/data/snaps/wrong-yaml/meta/snappy64.png'
Binary files _integration-tests/data/snaps/wrong-yaml/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/wrong-yaml/meta/snappy64.png	2015-08-02 12:28:52 +0000 differ
=== added directory '_integration-tests/data/tpl'
=== added file '_integration-tests/data/tpl/control'
--- _integration-tests/data/tpl/control	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/tpl/control	2015-08-02 12:28:52 +0000
@@ -0,0 +1,4 @@
+{{ $filter := .Filter }}
+{{ $test := .Test }}
+Test-Command: ./_integration-tests/reboot-wrapper {{ $test }} {{ if $filter }}-gocheck.f {{ $filter }}{{ end }}
+Restrictions: allow-stderr

=== added file '_integration-tests/main.go'
--- _integration-tests/main.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/main.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,105 @@
+// -*- 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 main
+
+import (
+	"flag"
+	"log"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"launchpad.net/snappy/_integration-tests/testutils"
+	"launchpad.net/snappy/_integration-tests/testutils/autopkgtest"
+	"launchpad.net/snappy/_integration-tests/testutils/build"
+	"launchpad.net/snappy/_integration-tests/testutils/config"
+	"launchpad.net/snappy/_integration-tests/testutils/image"
+)
+
+const (
+	baseDir        = "/tmp/snappy-test"
+	defaultRelease = "rolling"
+	defaultChannel = "edge"
+	defaultSSHPort = 22
+	dataOutputDir  = "_integration-tests/data/output/"
+)
+
+var configFileName = filepath.Join(dataOutputDir, "testconfig.json")
+
+func main() {
+	var (
+		useSnappyFromBranch = flag.Bool("snappy-from-branch", false,
+			"If this flag is used, snappy will be compiled from this branch, copied to the testbed and used for the tests. Otherwise, the snappy installed with the image will be used.")
+		arch = flag.String("arch", "",
+			"Architecture of the test bed. Defaults to use the same architecture as the host.")
+		testbedIP = flag.String("ip", "",
+			"IP of the testbed. If no IP is passed, a virtual machine will be created for the test.")
+		testbedPort = flag.Int("port", defaultSSHPort,
+			"SSH port of the testbed. Defaults to use port "+strconv.Itoa(defaultSSHPort))
+		testFilter = flag.String("filter", "",
+			"Suites or tests to run, for instance MyTestSuite, MyTestSuite.FirstCustomTest or MyTestSuite.*CustomTest")
+		imgRelease = flag.String("release", defaultRelease,
+			"Release of the image to be built, defaults to "+defaultRelease)
+		imgChannel = flag.String("channel", defaultChannel,
+			"Channel of the image to be built, defaults to "+defaultChannel)
+		imgRevision = flag.String("revision", "",
+			"Revision of the image to be built (can be relative to the latest available revision in the given release and channel as in -1), defaults to the empty string")
+		update = flag.Bool("update", false,
+			"If this flag is used, the image will be updated before running the tests.")
+		targetRelease = flag.String("target-release", "",
+			"If the update flag is used, the image will be updated to this release before running the tests.")
+		targetChannel = flag.String("target-channel", "",
+			"If the update flag is used, the image will be updated to this channel before running the tests.")
+		rollback = flag.Bool("rollback", false,
+			"If this flag is used, the image will be updated and then rolled back before running the tests.")
+	)
+
+	flag.Parse()
+
+	build.Assets(*useSnappyFromBranch, *arch)
+
+	// TODO: generate the files out of the source tree. --elopio - 2015-07-15
+	testutils.PrepareTargetDir(dataOutputDir)
+	defer os.RemoveAll(dataOutputDir)
+
+	remoteTestbed := *testbedIP != ""
+
+	// TODO: pass the config as arguments to the test binaries.
+	// --elopio - 2015-07-15
+	cfg := config.NewConfig(
+		configFileName, *imgRelease, *imgChannel, *targetRelease, *targetChannel,
+		remoteTestbed, *update, *rollback)
+	cfg.Write()
+
+	rootPath := testutils.RootPath()
+
+	test := autopkgtest.NewAutopkgtest(rootPath, baseDir, *testFilter, build.IntegrationTestName)
+	if !remoteTestbed {
+		img := image.NewImage(*imgRelease, *imgChannel, *imgRevision, baseDir)
+
+		if imagePath, err := img.UdfCreate(); err == nil {
+			test.AdtRunLocal(imagePath)
+		} else {
+			log.Panic(err.Error())
+		}
+	} else {
+		test.AdtRunRemote(*testbedIP, *testbedPort)
+	}
+}

=== added file '_integration-tests/reboot-wrapper'
--- _integration-tests/reboot-wrapper	1970-01-01 00:00:00 +0000
+++ _integration-tests/reboot-wrapper	2015-08-02 12:28:52 +0000
@@ -0,0 +1,35 @@
+#!/bin/sh
+
+# 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/>.
+
+# This runs the $1 go test binary and reboots if necessary.
+
+set -e
+
+TEST=$1
+NEEDS_REBOOT=/tmp/needs-reboot
+
+export PATH=$(pwd)/_integration-tests/bin:$PATH
+
+# shift to remove the test binary name (first argument) and be able to pass the rest
+# of them to it
+shift
+${TEST} -check.vv -test.outputdir=$ADT_ARTIFACTS-$ADT_REBOOT_MARK "$@"
+
+if [ -e ${NEEDS_REBOOT} ]; then
+    mark=`cat ${NEEDS_REBOOT}`
+    echo "Rebooting..."
+    sudo /tmp/autopkgtest-reboot "$mark"
+fi

=== added directory '_integration-tests/tests'
=== added file '_integration-tests/tests/apt_test.go'
--- _integration-tests/tests/apt_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/apt_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,39 @@
+// -*- 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 (
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&aptSuite{})
+
+type aptSuite struct {
+	SnappySuite
+}
+
+func (s *aptSuite) TestAptGetMustPrintError(c *check.C) {
+	aptOutput := ExecCommand(c, "apt-get", "update")
+
+	expected := "Ubuntu Core does not use apt-get, see 'snappy --help'!\n"
+	c.Assert(aptOutput, check.Equals, expected)
+}

=== added file '_integration-tests/tests/base_test.go'
--- _integration-tests/tests/base_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/base_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,29 @@
+// -*- 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 (
+	"testing"
+
+	. "gopkg.in/check.v1"
+)
+
+// Hook up gocheck into the "go test" runner.
+func Test(t *testing.T) { TestingT(t) }

=== added file '_integration-tests/tests/build_test.go'
--- _integration-tests/tests/build_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/build_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,90 @@
+// -*- 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 (
+	"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{})
+
+type buildSuite struct {
+	SnappySuite
+}
+
+func buildSnap(c *C, snapPath string) string {
+	return ExecCommand(c, "snappy", "build", snapPath)
+}
+
+func (s *buildSuite) TestBuildBasicSnapOnSnappy(c *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)
+
+	// install built snap and check output
+	installOutput := InstallSnap(c, snapName)
+	defer RemoveSnap(c, basicSnapName)
+	expected = "(?ms)" +
+		"Installing " + snapName + "\n" +
+		".*Signature check failed, but installing anyway as requested\n" +
+		"Name +Date +Version +Developer \n" +
+		".*\n" +
+		basicSnapName + " +.* +.* +sideload  \n" +
+		".*\n"
+
+	c.Check(installOutput, 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) {
+	// build wrong snap and check output
+	cmd := exec.Command("snappy", "build", fmt.Sprintf("%s/%s", baseSnapPath, testName))
+	echoOutput, err := cmd.CombinedOutput()
+	c.Assert(err, NotNil, Commentf("%s should not be built", testName))
+
+	c.Assert(string(echoOutput), Matches, expected)
+}

=== added file '_integration-tests/tests/failover_rclocal_crash_test.go'
--- _integration-tests/tests/failover_rclocal_crash_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_rclocal_crash_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,54 @@
+// -*- 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 (
+	"fmt"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+type rcLocalCrash struct{}
+
+func (rcLocalCrash) set(c *check.C) {
+	MakeWritable(c, BaseAltPartitionPath)
+	defer MakeReadonly(c, BaseAltPartitionPath)
+	targetFile := fmt.Sprintf("%s/etc/rc.local", BaseAltPartitionPath)
+	ExecCommand(c, "sudo", "chmod", "a+xw", targetFile)
+	ExecCommandToFile(c, targetFile,
+		"sudo", "echo", "#!bin/sh\nprintf c > /proc/sysrq-trigger")
+}
+
+func (rcLocalCrash) unset(c *check.C) {
+	MakeWritable(c, BaseAltPartitionPath)
+	defer MakeReadonly(c, BaseAltPartitionPath)
+	ExecCommand(c, "sudo", "rm", fmt.Sprintf("%s/etc/rc.local", BaseAltPartitionPath))
+}
+
+/*
+TODO: uncomment when bug https://bugs.launchpad.net/snappy/+bug/1476129 is fixed
+(fgimenez 20150728)
+
+func (s *failoverSuite) TestRCLocalCrash(c *check.C) {
+	commonFailoverTest(c, rcLocalCrash{})
+}
+*/

=== added file '_integration-tests/tests/failover_systemd_loop_test.go'
--- _integration-tests/tests/failover_systemd_loop_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_systemd_loop_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,114 @@
+// -*- 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 (
+	"fmt"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+const (
+	deadlockService = `[Unit]
+Before=sysinit.target
+DefaultDependencies=no
+
+[Service]
+Type=oneshot
+ExecStartPre=-/bin/sh -c "echo 'DEBUG: $(date): deadlocked system' >/dev/console"
+ExecStartPre=-/bin/sh -c "echo 'DEBUG: $(date): deadlocked system' >/dev/ttyS0"
+ExecStart=/bin/systemctl start deadlock.service
+RemainAfterExit=yes
+
+[Install]
+RequiredBy=sysinit.target
+`
+	rebootService = `[Unit]
+DefaultDependencies=no
+Description=Hack to force reboot if booting did not finish after 20s
+
+[Service]
+Type=oneshot
+ExecStartPre=/bin/sleep 20
+ExecStart=-/bin/sh -c 'if ! systemctl is-active default.target; then wall "EMERGENCY REBOOT"; reboot -f; fi'
+
+[Install]
+RequiredBy=sysinit.target
+`
+	baseSystemdPath          = "/lib/systemd/system"
+	systemdTargetRequiresDir = "sysinit.target.requires"
+)
+
+type systemdDependencyLoop struct{}
+
+func (systemdDependencyLoop) set(c *check.C) {
+	installService(c, "deadlock", deadlockService, BaseAltPartitionPath)
+	installService(c, "emerg-reboot", rebootService, BaseAltPartitionPath)
+}
+
+func (systemdDependencyLoop) unset(c *check.C) {
+	unInstallService(c, "deadlock", BaseAltPartitionPath)
+	unInstallService(c, "emerg-reboot", BaseAltPartitionPath)
+}
+
+func installService(c *check.C, serviceName, serviceCfg, basePath string) {
+	MakeWritable(c, basePath)
+	defer MakeReadonly(c, basePath)
+
+	// Create service file
+	serviceFile := fmt.Sprintf("%s%s/%s.service", basePath, baseSystemdPath, serviceName)
+	ExecCommand(c, "sudo", "chmod", "a+w", fmt.Sprintf("%s%s", basePath, baseSystemdPath))
+	ExecCommandToFile(c, serviceFile, "sudo", "echo", serviceCfg)
+
+	// Create requires directory
+	requiresDirPart := fmt.Sprintf("%s/%s", baseSystemdPath, systemdTargetRequiresDir)
+	requiresDir := fmt.Sprintf("%s%s", basePath, requiresDirPart)
+	ExecCommand(c, "sudo", "mkdir", "-p", requiresDir)
+
+	// Symlink from the requires dir to the service file (with chroot for being
+	// usable in the other partition)
+	ExecCommand(c, "sudo", "chroot", basePath, "ln", "-s",
+		fmt.Sprintf("%s/%s.service", baseSystemdPath, serviceName),
+		fmt.Sprintf("%s/%s.service", requiresDirPart, serviceName),
+	)
+}
+
+func unInstallService(c *check.C, serviceName, basePath string) {
+	MakeWritable(c, basePath)
+	defer MakeReadonly(c, basePath)
+
+	// Disable the service
+	ExecCommand(c, "sudo", "chroot", basePath,
+		"systemctl", "disable", fmt.Sprintf("%s.service", serviceName))
+
+	// Remove the service file
+	ExecCommand(c, "sudo", "rm",
+		fmt.Sprintf("%s%s/%s.service", basePath, baseSystemdPath, serviceName))
+
+	// Remove the requires symlink
+	ExecCommand(c, "sudo", "rm",
+		fmt.Sprintf("%s%s/%s/%s.service", basePath, baseSystemdPath, systemdTargetRequiresDir, serviceName))
+}
+
+func (s *failoverSuite) TestSystemdDependencyLoop(c *check.C) {
+	commonFailoverTest(c, systemdDependencyLoop{})
+}

=== added file '_integration-tests/tests/failover_test.go'
--- _integration-tests/tests/failover_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,58 @@
+// -*- 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 (
+	check "gopkg.in/check.v1"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+)
+
+var _ = check.Suite(&failoverSuite{})
+
+type failoverSuite struct {
+	SnappySuite
+}
+
+// The types that implement this interface can be used in the test logic
+type failer interface {
+	// Sets the failure conditions
+	set(c *check.C)
+	// Unsets the failure conditions
+	unset(c *check.C)
+}
+
+// This is the logic common to all the failover tests. Each of them has define a
+// type implementing the failer interface and call this function with an instance
+// of it
+func commonFailoverTest(c *check.C, f failer) {
+	currentVersion := GetCurrentUbuntuCoreVersion(c)
+
+	if AfterReboot(c) {
+		RemoveRebootMark(c)
+		f.unset(c)
+		c.Assert(GetSavedVersion(c), check.Equals, currentVersion)
+	} else {
+		SetSavedVersion(c, currentVersion-1)
+		CallFakeUpdate(c)
+		f.set(c)
+		Reboot(c)
+	}
+}

=== added file '_integration-tests/tests/failover_zero_size_file_test.go'
--- _integration-tests/tests/failover_zero_size_file_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_zero_size_file_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,258 @@
+// -*- 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 (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+const (
+	origBootFilenamePattern    = "boot/%s%s*"
+	origSystemdFilenamePattern = "lib/systemd/%s%s"
+	kernelFilename             = "vmlinuz"
+	initrdFilename             = "initrd"
+	systemdFilename            = "systemd"
+	destFilenamePrefix         = "snappy-selftest-"
+	bootBase                   = "/boot"
+	ubootDir                   = bootBase + "/uboot"
+	grubDir                    = bootBase + "/grub"
+	ubootConfigFile            = ubootDir + "/snappy-system.txt"
+	grubConfigFile             = grubDir + "/grubenv"
+)
+
+type zeroSizeKernel struct{}
+type zeroSizeInitrd struct{}
+type zeroSizeSystemd struct{}
+
+func (zeroSizeKernel) set(c *check.C) {
+	commonSet(c, BaseAltPartitionPath, origBootFilenamePattern, kernelFilename)
+}
+
+func (zeroSizeKernel) unset(c *check.C) {
+	commonUnset(c, BaseAltPartitionPath, origBootFilenamePattern, kernelFilename)
+}
+
+func (zeroSizeInitrd) set(c *check.C) {
+	if classicKernelFiles(c) {
+		commonSet(c, BaseAltPartitionPath, origBootFilenamePattern, initrdFilename)
+	} else {
+		boot := bootSystem(c)
+		dir := bootDirectory(boot)
+		bootFileNamePattern := newKernelFilenamePattern(c, boot, true)
+		commonSet(c, dir, bootFileNamePattern, initrdFilename)
+	}
+}
+
+func (zeroSizeInitrd) unset(c *check.C) {
+	if classicKernelFiles(c) {
+		commonUnset(c, BaseAltPartitionPath, origBootFilenamePattern, initrdFilename)
+	} else {
+		boot := bootSystem(c)
+		dir := bootDirectory(boot)
+		bootFileNamePattern := newKernelFilenamePattern(c, boot, false)
+		commonUnset(c, dir, bootFileNamePattern, initrdFilename)
+	}
+}
+
+func (zeroSizeSystemd) set(c *check.C) {
+	commonSet(c, BaseAltPartitionPath, origSystemdFilenamePattern, systemdFilename)
+}
+
+func (zeroSizeSystemd) unset(c *check.C) {
+	commonUnset(c, BaseAltPartitionPath, origSystemdFilenamePattern, systemdFilename)
+}
+
+func commonSet(c *check.C, baseOtherPath, origPattern, filename string) {
+	filenamePattern := fmt.Sprintf(origPattern, "", filename)
+	completePattern := filepath.Join(
+		baseOtherPath,
+		filenamePattern)
+	oldFilename := getSingleFilename(c, completePattern)
+	filenameSuffix := fmt.Sprintf(
+		strings.Replace(origPattern, "*", "", 1), destFilenamePrefix, filepath.Base(oldFilename))
+	newFilename := fmt.Sprintf(
+		"%s/%s", baseOtherPath, filenameSuffix)
+
+	renameFile(c, baseOtherPath, oldFilename, newFilename, true)
+}
+
+func commonUnset(c *check.C, baseOtherPath, origPattern, filename string) {
+	completePattern := filepath.Join(
+		baseOtherPath,
+		fmt.Sprintf(origPattern, destFilenamePrefix, filename))
+	oldFilename := getSingleFilename(c, completePattern)
+	newFilename := strings.Replace(oldFilename, destFilenamePrefix, "", 1)
+
+	renameFile(c, baseOtherPath, oldFilename, newFilename, false)
+}
+
+func renameFile(c *check.C, basePath, oldFilename, newFilename string, keepOld bool) {
+	// Only need to make writable and revert for BaseAltPartitionPath,
+	// kernel files' boot directory is writable
+	if basePath == BaseAltPartitionPath {
+		MakeWritable(c, basePath)
+		defer MakeReadonly(c, basePath)
+	}
+
+	ExecCommand(c, "sudo", "mv", oldFilename, newFilename)
+
+	if keepOld {
+		ExecCommand(c, "sudo", "touch", oldFilename)
+		mode := getFileMode(c, newFilename)
+		ExecCommand(c, "sudo", "chmod", fmt.Sprintf("%o", mode), oldFilename)
+	}
+}
+
+func getFileMode(c *check.C, filePath string) os.FileMode {
+	info, err := os.Stat(filePath)
+	c.Check(err, check.IsNil, check.Commentf("Error getting Stat of %s", filePath))
+
+	return info.Mode()
+}
+
+func getSingleFilename(c *check.C, pattern string) string {
+	matches, err := filepath.Glob(pattern)
+
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", err))
+	c.Assert(len(matches), check.Equals, 1,
+		check.Commentf("%d files matching %s, 1 expected", len(matches), pattern))
+
+	return matches[0]
+}
+
+func classicKernelFiles(c *check.C) bool {
+	initrdClassicFilenamePattern := fmt.Sprintf("/boot/%s*-generic", initrdFilename)
+	matches, err := filepath.Glob(initrdClassicFilenamePattern)
+
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", err))
+
+	return len(matches) == 1
+}
+
+func bootSystem(c *check.C) string {
+	matches, err := filepath.Glob(bootBase + "/grub")
+
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", err))
+
+	if len(matches) == 1 {
+		return "grub"
+	}
+	return "uboot"
+}
+
+func bootDirectory(bootSystem string) string {
+	if bootSystem == "grub" {
+		return grubDir
+	}
+	return ubootDir
+}
+
+func bootConfigFile(bootSystem string) string {
+	if bootSystem == "grub" {
+		return grubConfigFile
+	}
+	return ubootConfigFile
+}
+
+func currentPartition(c *check.C, bootSystem string) (partition string) {
+	bootConfigFile := bootConfigFile(bootSystem)
+	file, err := os.Open(bootConfigFile)
+
+	c.Assert(err, check.IsNil,
+		check.Commentf("Error reading boot config file %s", bootConfigFile))
+
+	defer file.Close()
+
+	reader := bufio.NewReader(file)
+	scanner := bufio.NewScanner(reader)
+
+	scanner.Split(bufio.ScanLines)
+
+	for scanner.Scan() {
+		if strings.HasPrefix(scanner.Text(), "snappy_ab") {
+			fields := strings.Split(scanner.Text(), "=")
+			if len(fields) > 1 {
+				if bootSystem == "grub" {
+					partition = fields[1]
+				} else {
+					partition = otherPart(fields[1])
+				}
+			}
+			return
+		}
+	}
+	return
+}
+
+func otherPart(current string) string {
+	if current == "a" {
+		return "b"
+	}
+	return "a"
+}
+
+// newKernelFilenamePattern returns the filename pattern to modify files
+// in the partition declared in the boot config file.
+//
+// After the update, the config file is already changed to point to the new partition.
+// If we are on a and update, the config file would point to b
+// and this function would return "b/%s%s*"
+// If we are not in an update process (ie. we are unsetting the failover conditions)
+// we want to change the files in the other partition
+func newKernelFilenamePattern(c *check.C, bootSystem string, afterUpdate bool) string {
+	var actualPartition string
+	partition := currentPartition(c, bootSystem)
+	if afterUpdate {
+		actualPartition = partition
+	} else {
+		actualPartition = otherPart(partition)
+	}
+	return filepath.Join(actualPartition, "%s%s*")
+}
+
+/*
+TODO: uncomment when bug https://bugs.launchpad.net/snappy/+bug/1467553 is fixed
+(fgimenez 20150729)
+
+func (s *failoverSuite) TestZeroSizeKernel(c *check.C) {
+	commonFailoverTest(c, zeroSizeKernel{})
+}
+*/
+
+func (s *failoverSuite) TestZeroSizeInitrd(c *check.C) {
+	// Skip if on uboot due to https://bugs.launchpad.net/snappy/+bug/1480248
+	// (fgimenez 20150731)
+	if bootSystem(c) == "uboot" {
+		c.Skip("Failover for empty initrd not working in uboot")
+	}
+	commonFailoverTest(c, zeroSizeInitrd{})
+}
+
+func (s *failoverSuite) TestZeroSizeSystemd(c *check.C) {
+	commonFailoverTest(c, zeroSizeSystemd{})
+}

=== added file '_integration-tests/tests/info_test.go'
--- _integration-tests/tests/info_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/info_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,79 @@
+// -*- 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 (
+	"fmt"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&infoSuite{})
+
+type infoSuite struct {
+	SnappySuite
+}
+
+func (s *infoSuite) TestInfoMustPrintReleaseAndChannel(c *check.C) {
+	// skip test when having a remote testbed (we can't know which the
+	// release and channels are)
+	if Cfg.RemoteTestbed {
+		c.Skip(fmt.Sprintf(
+			"Skipping %s while testing in remote testbed",
+			c.TestName()))
+	}
+
+	infoOutput := ExecCommand(c, "snappy", "info")
+
+	expected := "(?ms)" +
+		fmt.Sprintf("^release: ubuntu-core/%s/%s\n", Cfg.Release, Cfg.Channel) +
+		".*"
+
+	c.Assert(infoOutput, check.Matches, expected)
+}
+
+func (s *infoSuite) TestInfoMustPrintInstalledApps(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+	infoOutput := ExecCommand(c, "snappy", "info")
+
+	expected := "(?ms)" +
+		".*" +
+		"^apps: .*hello-world.*\n"
+	c.Assert(infoOutput, check.Matches, expected)
+}
+
+func (s *infoSuite) TestInfoMustPrintInstalledFrameworks(c *check.C) {
+	InstallSnap(c, "hello-dbus-fwk.canonical")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-dbus-fwk.canonical")
+	})
+	infoOutput := ExecCommand(c, "snappy", "info")
+
+	expected := "(?ms)" +
+		".*" +
+		"^frameworks: .*hello-dbus-fwk.*\n" +
+		".*"
+	c.Assert(infoOutput, check.Matches, expected)
+}

=== added file '_integration-tests/tests/installApp_test.go'
--- _integration-tests/tests/installApp_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/installApp_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,128 @@
+// -*- 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 (
+	"fmt"
+	"net/http"
+	"os/exec"
+	"time"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&installAppSuite{})
+
+type installAppSuite struct {
+	SnappySuite
+}
+
+func (s *installAppSuite) TestInstallAppMustPrintPackageInformation(c *check.C) {
+	installOutput := InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+
+	expected := "(?ms)" +
+		"Installing hello-world\n" +
+		"Name +Date +Version +Developer \n" +
+		".*" +
+		"^hello-world +.* +.* +canonical \n" +
+		".*"
+
+	c.Assert(installOutput, check.Matches, expected)
+}
+
+func (s *installAppSuite) TestCallBinaryFromInstalledSnap(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+
+	echoOutput := ExecCommand(c, "hello-world.echo")
+
+	c.Assert(echoOutput, check.Equals, "Hello World!\n")
+}
+
+func (s *installAppSuite) TestCallBinaryWithPermissionDeniedMustPrintError(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+
+	cmd := exec.Command("hello-world.evil")
+	echoOutput, err := cmd.CombinedOutput()
+	c.Assert(err, check.NotNil, check.Commentf("hello-world.evil did not fail"))
+
+	expected := "" +
+		"Hello Evil World!\n" +
+		"This example demonstrates the app confinement\n" +
+		"You should see a permission denied error next\n" +
+		"/apps/hello-world.canonical/.*/bin/evil: \\d+: " +
+		"/apps/hello-world.canonical/.*/bin/evil: " +
+		"cannot create /var/tmp/myevil.txt: Permission denied\n"
+
+	c.Assert(string(echoOutput), check.Matches, expected)
+}
+
+func (s *installAppSuite) TestInfoMustPrintInstalledPackageInformation(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+
+	infoOutput := ExecCommand(c, "snappy", "info")
+
+	expected := "(?ms).*^apps: hello-world\n"
+	c.Assert(infoOutput, check.Matches, expected)
+}
+
+func (s *installAppSuite) TestAppNetworkingServiceMustBeStarted(c *check.C) {
+	baseAppName := "xkcd-webserver"
+	appName := baseAppName + ".canonical"
+	InstallSnap(c, appName)
+	s.AddCleanup(func() {
+		RemoveSnap(c, appName)
+	})
+
+	appVersion := GetCurrentVersion(c, baseAppName)
+	appService := fmt.Sprintf("%s_%s_%s.service", baseAppName, baseAppName, appVersion)
+
+	err := WaitForActiveService(c, appService)
+	c.Assert(err, check.IsNil)
+
+	time.Sleep(1 * time.Second)
+	resp, err := http.Get("http://localhost")
+	c.Assert(err, check.IsNil)
+	c.Check(resp.Status, check.Equals, "200 OK")
+	c.Assert(resp.Proto, check.Equals, "HTTP/1.0")
+}
+
+func (s *installAppSuite) TestInstallUnexistingAppMustPrintError(c *check.C) {
+	cmd := exec.Command("sudo", "snappy", "install", "unexisting.canonical")
+	output, err := cmd.CombinedOutput()
+
+	c.Assert(err, check.NotNil)
+	c.Assert(string(output), check.Equals,
+		"Installing unexisting.canonical\n"+
+			"unexisting.canonical failed to install: snappy package not found\n")
+}

=== added file '_integration-tests/tests/installFramework_test.go'
--- _integration-tests/tests/installFramework_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/installFramework_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,93 @@
+// -*- 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 (
+	"fmt"
+	"regexp"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&installFrameworkSuite{})
+
+type installFrameworkSuite struct {
+	SnappySuite
+}
+
+func (s *installFrameworkSuite) TearDownTest(c *check.C) {
+	if !NeedsReboot() && CheckRebootMark("") {
+		RemoveSnap(c, "docker")
+	}
+	// run cleanup last
+	s.SnappySuite.TearDownTest(c)
+}
+
+func isDockerServiceRunning(c *check.C) bool {
+	dockerVersion := GetCurrentVersion(c, "docker")
+	dockerService := fmt.Sprintf("docker_docker-daemon_%s.service", dockerVersion)
+
+	err := WaitForActiveService(c, dockerService)
+	c.Assert(err, check.IsNil)
+
+	statusOutput := ExecCommand(
+		c, "systemctl", "status",
+		dockerService)
+
+	expected := "(?ms)" +
+		".* docker_docker-daemon_.*\\.service .*\n" +
+		".*Loaded: loaded .*\n" +
+		".*Active: active \\(running\\) .*\n" +
+		".*"
+
+	matched, err := regexp.MatchString(expected, statusOutput)
+	c.Assert(err, check.IsNil)
+	return matched
+}
+
+func (s *installFrameworkSuite) TestInstallFrameworkMustPrintPackageInformation(c *check.C) {
+	installOutput := InstallSnap(c, "docker")
+
+	expected := "(?ms)" +
+		"Installing docker\n" +
+		"Name +Date +Version +Developer \n" +
+		".*" +
+		"^docker +.* +.* +canonical \n" +
+		".*"
+
+	c.Assert(installOutput, check.Matches, expected)
+}
+
+func (s *installFrameworkSuite) TestInstalledFrameworkServiceMustBeStarted(c *check.C) {
+	InstallSnap(c, "docker")
+	c.Assert(isDockerServiceRunning(c), check.Equals, true)
+}
+
+func (s *installFrameworkSuite) TestFrameworkServiceMustBeStartedAfterReboot(c *check.C) {
+	if BeforeReboot() {
+		InstallSnap(c, "docker")
+		Reboot(c)
+	} else if AfterReboot(c) {
+		RemoveRebootMark(c)
+		c.Assert(isDockerServiceRunning(c), check.Equals, true)
+	}
+}

=== added file '_integration-tests/tests/list_test.go'
--- _integration-tests/tests/list_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/list_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,78 @@
+// -*- 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 (
+	"fmt"
+	"os"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	"github.com/mvo5/goconfigparser"
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&listSuite{})
+
+type listSuite struct {
+	SnappySuite
+}
+
+func getVersionFromConfig(c *check.C) string {
+	cfg := goconfigparser.New()
+	f, err := os.Open("/etc/system-image/channel.ini")
+	c.Assert(err, check.IsNil,
+		check.Commentf("Error opening the config file: %v:", err))
+	defer f.Close()
+	err = cfg.Read(f)
+	c.Assert(err, check.IsNil,
+		check.Commentf("Error parsing the config file: %v", err))
+	version, err := cfg.Get("service", "build_number")
+	c.Assert(err, check.IsNil,
+		check.Commentf("Error getting the build number: %v", err))
+	return version
+}
+
+func (s *listSuite) TestListMustPrintCoreVersion(c *check.C) {
+	listOutput := ExecCommand(c, "snappy", "list")
+
+	expected := "(?ms)" +
+		"Name +Date +Version +Developer *\n" +
+		".*" +
+		fmt.Sprintf("^ubuntu-core +.* +%s +ubuntu *\n", getVersionFromConfig(c)) +
+		".*"
+	c.Assert(listOutput, check.Matches, expected)
+}
+
+func (s *listSuite) TestListMustPrintAppVersion(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+
+	listOutput := ExecCommand(c, "snappy", "list")
+	expected := "(?ms)" +
+		"Name +Date +Version +Developer *\n" +
+		".*" +
+		"^hello-world +.* +(\\d+)(\\.\\d+)* +.* +.* *\n" +
+		".*"
+
+	c.Assert(listOutput, check.Matches, expected)
+}

=== added file '_integration-tests/tests/rollback_test.go'
--- _integration-tests/tests/rollback_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/rollback_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,53 @@
+// -*- 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 (
+	"strconv"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&rollbackSuite{})
+
+type rollbackSuite struct {
+	SnappySuite
+}
+
+func (s *rollbackSuite) TestRollbackMustRebootToOtherVersion(c *check.C) {
+	if BeforeReboot() {
+		CallFakeUpdate(c)
+		Reboot(c)
+	} else if CheckRebootMark(c.TestName()) {
+		RemoveRebootMark(c)
+		currentVersion := GetCurrentUbuntuCoreVersion(c)
+		c.Assert(currentVersion > GetSavedVersion(c), check.Equals, true)
+		ExecCommand(c, "sudo", "snappy", "rollback", "ubuntu-core",
+			strconv.Itoa(GetSavedVersion(c)))
+		SetSavedVersion(c, currentVersion)
+		RebootWithMark(c, c.TestName()+"-rollback")
+	} else if CheckRebootMark(c.TestName() + "-rollback") {
+		RemoveRebootMark(c)
+		c.Assert(
+			GetCurrentUbuntuCoreVersion(c) < GetSavedVersion(c), check.Equals, true)
+	}
+}

=== added file '_integration-tests/tests/search_test.go'
--- _integration-tests/tests/search_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/search_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,44 @@
+// -*- 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 (
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	. "gopkg.in/check.v1"
+)
+
+var _ = Suite(&searchSuite{})
+
+type searchSuite struct {
+	SnappySuite
+}
+
+func (s *searchSuite) TestSearchFrameworkMustPrintMatch(c *C) {
+	searchOutput := ExecCommand(c, "snappy", "search", "hello-dbus-fwk")
+
+	expected := "(?ms)" +
+		"Name +Version +Summary *\n" +
+		".*" +
+		"^hello-dbus-fwk +.* +hello-dbus-fwk *\n" +
+		".*"
+
+	c.Assert(searchOutput, Matches, expected)
+}

=== added file '_integration-tests/tests/update_test.go'
--- _integration-tests/tests/update_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/update_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,51 @@
+// -*- 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 (
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&updateSuite{})
+
+type updateSuite struct {
+	SnappySuite
+}
+
+// Test that the update to the same release and channel must install a newer
+// version. If there is no update available, the channel version will be
+// modified to fake an update. If there is a version available, the image will
+// be up-to-date after running this test.
+func (s *updateSuite) TestUpdateToSameReleaseAndChannel(c *check.C) {
+	if BeforeReboot() {
+		updateOutput := CallFakeUpdate(c)
+		expected := "(?ms)" +
+			".*" +
+			"^Reboot to use .*ubuntu-core.\n"
+		c.Assert(updateOutput, check.Matches, expected)
+		Reboot(c)
+	} else if AfterReboot(c) {
+		RemoveRebootMark(c)
+		c.Assert(GetCurrentUbuntuCoreVersion(c) > GetSavedVersion(c),
+			check.Equals, true)
+	}
+}

=== added file '_integration-tests/tests/writablePaths_test.go'
--- _integration-tests/tests/writablePaths_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/writablePaths_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,106 @@
+// -*- 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 (
+	"bufio"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+const writablePathsListFile = "/etc/system-image/writable-paths"
+
+var _ = check.Suite(&writablePathsSuite{})
+
+type writablePathsSuite struct {
+	SnappySuite
+}
+
+var IsWritable check.Checker = &isWritable{}
+
+type isWritable struct {
+}
+
+func (is *isWritable) Info() *check.CheckerInfo {
+	return &check.CheckerInfo{Name: "IsWritable", Params: []string{"path"}}
+}
+
+func (is *isWritable) Check(params []interface{}, names []string) (result bool, error string) {
+	if path, ok := params[0].(string); ok {
+		filename := filepath.Join(path, "tmpfile")
+
+		cmd := exec.Command("sudo", "touch", filename)
+		rmCmd := exec.Command("sudo", "rm", filename)
+		defer rmCmd.Run()
+
+		if _, err := cmd.CombinedOutput(); err == nil {
+			result = true
+		} else {
+			error = fmt.Sprintf("Error creating file %s", filename)
+		}
+	} else {
+		error = fmt.Sprintf("First param of checker %v is of type %T and it should be a string", params[0], params[0])
+	}
+	return result, error
+}
+
+func (s *writablePathsSuite) TestWritablePathsAreWritable(c *check.C) {
+	for writablePath := range generateWritablePaths(c) {
+		c.Logf("Checking if %s is writable", writablePath)
+		c.Check(writablePath, IsWritable)
+	}
+}
+
+func generateWritablePaths(c *check.C) chan string {
+	ch := make(chan string)
+
+	go func() {
+		file, err := os.Open(writablePathsListFile)
+
+		c.Assert(err, check.IsNil,
+			check.Commentf("Error reading writable files list %s", writablePathsListFile))
+
+		defer file.Close()
+
+		reader := bufio.NewReader(file)
+		scanner := bufio.NewScanner(reader)
+
+		scanner.Split(bufio.ScanLines)
+
+		for scanner.Scan() {
+			fields := strings.Fields(scanner.Text())
+			if len(fields) > 0 && fields[0] != "#" {
+				if src, err := os.Stat(fields[0]); err == nil && src.IsDir() {
+					ch <- fields[0]
+				}
+			}
+		}
+		close(ch)
+	}()
+
+	return ch
+}

=== added directory '_integration-tests/testutils'
=== added directory '_integration-tests/testutils/autopkgtest'
=== added file '_integration-tests/testutils/autopkgtest/autopkgtest.go'
--- _integration-tests/testutils/autopkgtest/autopkgtest.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/autopkgtest/autopkgtest.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,111 @@
+// -*- 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 autopkgtest
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"text/template"
+
+	"log"
+
+	"launchpad.net/snappy/_integration-tests/testutils"
+)
+
+const (
+	controlTpl    = "_integration-tests/data/tpl/control"
+	dataOutputDir = "_integration-tests/data/output/"
+)
+
+var controlFile = filepath.Join(dataOutputDir, "control")
+
+// Autopkgtest is the type that knows how to call adt-run
+type Autopkgtest struct {
+	sourceCodePath      string // location of the source code on the host
+	testArtifactsPath   string // location of the test artifacts on the host
+	testFilter          string
+	integrationTestName string
+}
+
+// NewAutopkgtest is the Autopkgtest constructor
+func NewAutopkgtest(sourceCodePath, testArtifactsPath, testFilter, integrationTestName string) *Autopkgtest {
+	return &Autopkgtest{
+		sourceCodePath:      sourceCodePath,
+		testArtifactsPath:   testArtifactsPath,
+		testFilter:          testFilter,
+		integrationTestName: integrationTestName}
+}
+
+// AdtRunLocal starts a kvm running the image passed as argument and runs the
+// autopkgtests using it as the testbed.
+func (a *Autopkgtest) AdtRunLocal(imgPath string) {
+	// Run the tests on the latest rolling edge image.
+	a.adtRun(kvmSSHOptions(imgPath))
+}
+
+// AdtRunRemote runs the autopkgtests using a remote machine as the testbed.
+func (a *Autopkgtest) AdtRunRemote(testbedIP string, testbedPort int) {
+	testutils.ExecCommand("ssh-copy-id", "-p", strconv.Itoa(testbedPort),
+		"ubuntu@"+testbedIP)
+	a.adtRun(remoteTestbedSSHOptions(testbedIP, testbedPort))
+}
+
+func (a *Autopkgtest) adtRun(testbedOptions []string) {
+	a.createControlFile()
+
+	fmt.Println("Calling adt-run...")
+	outputDir := filepath.Join(a.testArtifactsPath, "output")
+	testutils.PrepareTargetDir(outputDir)
+
+	cmd := []string{
+		"adt-run", "-B",
+		"--setup-commands", "touch /run/autopkgtest_no_reboot.stamp",
+		"--override-control", controlFile,
+		"--built-tree", a.sourceCodePath,
+		"--output-dir", outputDir}
+
+	testutils.ExecCommand(append(cmd, testbedOptions...)...)
+}
+
+func (a *Autopkgtest) createControlFile() {
+	type controlData struct {
+		Filter string
+		Test   string
+	}
+
+	tpl, err := template.ParseFiles(controlTpl)
+	if err != nil {
+		log.Panicf("Error reading adt-run control template %s", controlTpl)
+	}
+
+	outputFile, err := os.Create(controlFile)
+	if err != nil {
+		log.Panicf("Error creating control file %s", controlFile)
+	}
+	defer outputFile.Close()
+
+	err = tpl.Execute(outputFile,
+		controlData{Test: a.integrationTestName, Filter: a.testFilter})
+	if err != nil {
+		log.Panicf("execution: %s", err)
+	}
+}

=== added file '_integration-tests/testutils/autopkgtest/ssh.go'
--- _integration-tests/testutils/autopkgtest/ssh.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/autopkgtest/ssh.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,46 @@
+// -*- 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 autopkgtest
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+)
+
+var commonSSHOptions = []string{"---", "ssh"}
+
+func kvmSSHOptions(imagePath string) []string {
+	return append(
+		commonSSHOptions,
+		[]string{
+			"-s", "/usr/share/autopkgtest/ssh-setup/snappy",
+			"--", "-i", imagePath}...)
+}
+
+func remoteTestbedSSHOptions(testbedIP string, testbedPort int) []string {
+	options := []string{
+		"-H", testbedIP,
+		"-p", strconv.Itoa(testbedPort),
+		"-l", "ubuntu",
+		"-i", filepath.Join(os.Getenv("HOME"), ".ssh", "id_rsa"),
+		"--reboot"}
+	return append(commonSSHOptions, options...)
+}

=== added directory '_integration-tests/testutils/build'
=== added file '_integration-tests/testutils/build/build.go'
--- _integration-tests/testutils/build/build.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/build/build.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,76 @@
+// -*- 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"
+	"os"
+
+	"launchpad.net/snappy/_integration-tests/testutils"
+)
+
+const (
+	// IntegrationTestName is the name of the test binary.
+	IntegrationTestName = "integration.test"
+	defaultGoArm        = "7"
+	testsBinDir         = "_integration-tests/bin/"
+)
+
+// Assets builds the snappy and integration tests binaries for the target
+// architecture.
+func Assets(useSnappyFromBranch bool, arch string) {
+	testutils.PrepareTargetDir(testsBinDir)
+
+	if useSnappyFromBranch {
+		// FIXME We need to build an image that has the snappy from the branch
+		// installed. --elopio - 2015-06-25.
+		buildSnappyCLI(arch)
+	}
+	buildTests(arch)
+}
+
+func buildSnappyCLI(arch string) {
+	fmt.Println("Building snappy CLI...")
+	// On the root of the project we have a directory called snappy, so we
+	// output the binary for the tests in the tests directory.
+	goCall(arch, "build", "-o", testsBinDir+"snappy", "./cmd/snappy")
+}
+
+func buildTests(arch string) {
+	fmt.Println("Building tests...")
+
+	goCall(arch, "test", "-c", "./_integration-tests/tests")
+	// XXX Go test 1.3 does not have the output flag, so we move the
+	// binaries after they are generated.
+	os.Rename("tests.test", testsBinDir+IntegrationTestName)
+}
+
+func goCall(arch string, cmds ...string) {
+	if arch != "" {
+		defer os.Setenv("GOARCH", os.Getenv("GOARCH"))
+		os.Setenv("GOARCH", arch)
+		if arch == "arm" {
+			defer os.Setenv("GOARM", os.Getenv("GOARM"))
+			os.Setenv("GOARM", defaultGoArm)
+		}
+	}
+	goCmd := append([]string{"go"}, cmds...)
+	testutils.ExecCommand(goCmd...)
+}

=== added directory '_integration-tests/testutils/common'
=== added file '_integration-tests/testutils/common/common.go'
--- _integration-tests/testutils/common/common.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/common/common.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,379 @@
+// -*- 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 common
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	check "gopkg.in/check.v1"
+
+	"launchpad.net/snappy/_integration-tests/testutils/config"
+)
+
+const (
+	// BaseAltPartitionPath is the path to the B system partition.
+	BaseAltPartitionPath = "/writable/cache/system"
+	needsRebootFile      = "/tmp/needs-reboot"
+	channelCfgFile       = "/etc/system-image/channel.ini"
+)
+
+// Cfg is a struct that contains the configuration values passed from the
+// host to the testbed.
+var Cfg *config.Config
+
+// SnappySuite is a structure used as a base test suite for all the snappy
+// integration tests.
+type SnappySuite struct {
+	cleanupHandlers []func()
+}
+
+// SetUpSuite disables the snappy autopilot. It will run before all the
+// integration suites.
+func (s *SnappySuite) SetUpSuite(c *check.C) {
+	ExecCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
+	ExecCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer")
+	if !isInRebootProcess() {
+		var err error
+		Cfg, err = config.ReadConfig(
+			"_integration-tests/data/output/testconfig.json")
+		c.Assert(err, check.IsNil, check.Commentf("Error reading config: %v", err))
+		if Cfg.Update || Cfg.Rollback {
+			switchSystemImageConf(c, Cfg.TargetRelease, Cfg.TargetChannel, "0")
+			// Always use the installed snappy because we are updating from an old
+			// image, so we should not use the snappy from the branch.
+			output := ExecCommand(c, "sudo", "/usr/bin/snappy", "update")
+			if output != "" {
+				RebootWithMark(c, "setupsuite-update")
+			}
+		}
+	} else if CheckRebootMark("setupsuite-update") {
+		RemoveRebootMark(c)
+		if Cfg.Rollback {
+			ExecCommand(c, "sudo", "snappy", "rollback", "ubuntu-core")
+			RebootWithMark(c, "setupsuite-rollback")
+		}
+	} else if CheckRebootMark("setupsuite-rollback") {
+		RemoveRebootMark(c)
+	}
+}
+
+// SetUpTest handles reboots and stores version information. It will run before
+// all the integration tests. Before running a test, it will save the
+// ubuntu-core version. If a reboot was requested by a previous test, it
+// will skip all the following tests. If the suite is being called after the
+// test bed was rebooted, it will resume the test that requested the reboot.
+func (s *SnappySuite) SetUpTest(c *check.C) {
+	if NeedsReboot() {
+		contents, err := ioutil.ReadFile(needsRebootFile)
+		c.Assert(err, check.IsNil, check.Commentf("Error reading needs-reboot file %v", err))
+		c.Skip(fmt.Sprintf("****** Skipped %s during reboot caused by %s",
+			c.TestName(), contents))
+	} else {
+		if CheckRebootMark("") {
+			c.Logf("****** Running %s", c.TestName())
+			SetSavedVersion(c, GetCurrentUbuntuCoreVersion(c))
+		} else {
+			if AfterReboot(c) {
+				c.Logf("****** Resuming %s after reboot", c.TestName())
+			} else {
+				c.Skip(fmt.Sprintf("****** Skipped %s after reboot caused by %s",
+					c.TestName(), os.Getenv("ADT_REBOOT_MARK")))
+			}
+		}
+	}
+	// clear slice
+	s.cleanupHandlers = nil
+}
+
+// TearDownTest cleans up the channel.ini files in case they were changed by
+// the test.
+// It also runs the cleanup handlers
+func (s *SnappySuite) TearDownTest(c *check.C) {
+	if !NeedsReboot() && CheckRebootMark("") {
+		// Only restore the channel config files if the reboot has been handled.
+		m := make(map[string]string)
+		m[channelCfgBackupFile()] = "/"
+		m[channelCfgOtherBackupFile()] = BaseAltPartitionPath
+		for backup, target := range m {
+			if _, err := os.Stat(backup); err == nil {
+				MakeWritable(c, target)
+				defer MakeReadonly(c, target)
+				original := filepath.Join(target, channelCfgFile)
+				c.Logf("Restoring %s...", original)
+				ExecCommand(c, "sudo", "mv", backup, original)
+			}
+		}
+	}
+
+	// run cleanup handlers and clear the slice
+	for _, f := range s.cleanupHandlers {
+		f()
+	}
+	s.cleanupHandlers = nil
+}
+
+// AddCleanup adds a new cleanup function to the test
+func (s *SnappySuite) AddCleanup(f func()) {
+	s.cleanupHandlers = append(s.cleanupHandlers, f)
+}
+
+func switchSystemImageConf(c *check.C, release, channel, version string) {
+	targets := []string{"/", BaseAltPartitionPath}
+	for _, target := range targets {
+		file := filepath.Join(target, channelCfgFile)
+		if _, err := os.Stat(file); err == nil {
+			MakeWritable(c, target)
+			defer MakeReadonly(c, target)
+			replaceSystemImageValues(c, file, release, channel, version)
+		}
+	}
+}
+
+func replaceSystemImageValues(c *check.C, file, release, channel, version string) {
+	c.Log("Switching the system image conf...")
+	replaceRegex := map[string]string{
+		release: `s#channel: ubuntu-core/.*/\(.*\)#channel: ubuntu-core/%s/\1#`,
+		channel: `s#channel: ubuntu-core/\(.*\)/.*#channel: ubuntu-core/\1/%s#`,
+		version: `s/build_number: .*/build_number: %s/`,
+	}
+	for value, regex := range replaceRegex {
+		if value != "" {
+			ExecCommand(c,
+				"sudo", "sed", "-i", fmt.Sprintf(regex, value), file)
+		}
+	}
+	// Leave the new file in the test log.
+	ExecCommand(c, "cat", file)
+}
+
+func channelCfgBackupFile() string {
+	return filepath.Join(os.Getenv("ADT_ARTIFACTS"), "channel.ini")
+}
+
+func channelCfgOtherBackupFile() string {
+	return filepath.Join(os.Getenv("ADT_ARTIFACTS"), "channel.ini.other")
+}
+
+// ExecCommand executes a shell command and returns a string with the output
+// of the command. In case of error, it will fail the test.
+func ExecCommand(c *check.C, cmds ...string) string {
+	fmt.Println(strings.Join(cmds, " "))
+	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
+	output, err := cmd.CombinedOutput()
+	stringOutput := string(output)
+	fmt.Print(stringOutput)
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", stringOutput))
+	return stringOutput
+}
+
+// ExecCommandToFile executes a shell command and saves the output of the
+// command to a file. In case of error, it will fail the test.
+func ExecCommandToFile(c *check.C, filename string, cmds ...string) {
+	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
+	outfile, err := os.Create(filename)
+	c.Assert(err, check.IsNil, check.Commentf("Error creating output file %s", filename))
+
+	defer outfile.Close()
+	cmd.Stdout = outfile
+
+	err = cmd.Run()
+	c.Assert(err, check.IsNil, check.Commentf("Error executing command '%v': %v", cmds, err))
+}
+
+// GetCurrentVersion returns the version of the installed and active package.
+func GetCurrentVersion(c *check.C, packageName string) string {
+	output := ExecCommand(c, "snappy", "list")
+	pattern := "(?mU)^" + packageName + " +(.*)$"
+	re := regexp.MustCompile(pattern)
+	match := re.FindStringSubmatch(string(output))
+	c.Assert(match, check.NotNil, check.Commentf("Version not found in %s", output))
+
+	// match is like "ubuntu-core   2015-06-18 93        ubuntu"
+	items := strings.Fields(match[0])
+	return items[2]
+}
+
+// GetCurrentUbuntuCoreVersion returns the version number of the installed and
+// active ubuntu-core.
+func GetCurrentUbuntuCoreVersion(c *check.C) int {
+	versionString := GetCurrentVersion(c, "ubuntu-core")
+	version, err := strconv.Atoi(versionString)
+	c.Assert(err, check.IsNil, check.Commentf("Error converting version to int %v", version))
+	return version
+}
+
+// CallFakeUpdate calls snappy update after faking the current version
+func CallFakeUpdate(c *check.C) string {
+	c.Log("Preparing fake and calling update.")
+	fakeAvailableUpdate(c)
+	return ExecCommand(c, "sudo", "snappy", "update")
+}
+
+func fakeAvailableUpdate(c *check.C) {
+	c.Log("Faking an available update...")
+	currentVersion := GetCurrentUbuntuCoreVersion(c)
+	switchChannelVersionWithBackup(c, currentVersion-1)
+	SetSavedVersion(c, currentVersion-1)
+}
+
+func switchChannelVersionWithBackup(c *check.C, newVersion int) {
+	m := make(map[string]string)
+	m["/"] = channelCfgBackupFile()
+	m[BaseAltPartitionPath] = channelCfgOtherBackupFile()
+	for target, backup := range m {
+		file := filepath.Join(target, channelCfgFile)
+		if _, err := os.Stat(file); err == nil {
+			MakeWritable(c, target)
+			defer MakeReadonly(c, target)
+			// Back up the file. It will be restored during the test tear down.
+			ExecCommand(c, "cp", file, backup)
+			replaceSystemImageValues(c, file, "", "", strconv.Itoa(newVersion))
+		}
+	}
+}
+
+// MakeWritable remounts a path with read and write permissions.
+func MakeWritable(c *check.C, path string) {
+	ExecCommand(c, "sudo", "mount", "-o", "remount,rw", path)
+}
+
+// MakeReadonly remounts a path with only read permissions.
+func MakeReadonly(c *check.C, path string) {
+	ExecCommand(c, "sudo", "mount", "-o", "remount,ro", path)
+}
+
+// Reboot requests a reboot using the test name as the mark.
+func Reboot(c *check.C) {
+	RebootWithMark(c, c.TestName())
+}
+
+// RebootWithMark requests a reboot using a specified mark.
+func RebootWithMark(c *check.C, mark string) {
+	c.Log("Preparing reboot with mark " + mark)
+	err := ioutil.WriteFile(needsRebootFile, []byte(mark), 0777)
+	c.Assert(err, check.IsNil, check.Commentf("Error writing needs-reboot file: %v", err))
+}
+
+// NeedsReboot returns True if a reboot has been requested by a test.
+func NeedsReboot() bool {
+	_, err := os.Stat(needsRebootFile)
+	return err == nil
+}
+
+// BeforeReboot returns True if the test is running before the test bed has
+// been rebooted, or after the test that requested the reboot handled it.
+func BeforeReboot() bool {
+	return CheckRebootMark("")
+}
+
+// AfterReboot returns True if the test is running after the test bed has been
+// rebooted.
+func AfterReboot(c *check.C) bool {
+	// $ADT_REBOOT_MARK contains the reboot mark, if we have rebooted it'll be the test name
+	return strings.HasPrefix(os.Getenv("ADT_REBOOT_MARK"), c.TestName())
+}
+
+// CheckRebootMark returns True if the reboot mark matches the string passed as
+// argument.
+func CheckRebootMark(mark string) bool {
+	return os.Getenv("ADT_REBOOT_MARK") == mark
+}
+
+func isInRebootProcess() bool {
+	return !CheckRebootMark("") || NeedsReboot()
+}
+
+// RemoveRebootMark removes the reboot mark to signal that the reboot has been
+// handled.
+func RemoveRebootMark(c *check.C) {
+	os.Setenv("ADT_REBOOT_MARK", "")
+}
+
+// SetSavedVersion saves a version number into a file so it can be used on
+// tests after reboots.
+func SetSavedVersion(c *check.C, version int) {
+	versionFile := getVersionFile()
+	err := ioutil.WriteFile(versionFile, []byte(strconv.Itoa(version)), 0777)
+	c.Assert(err, check.IsNil, check.Commentf("Error writing version file %s with %s", versionFile, version))
+}
+
+// GetSavedVersion returns the saved version number.
+func GetSavedVersion(c *check.C) int {
+	versionFile := getVersionFile()
+	contents, err := ioutil.ReadFile(versionFile)
+	c.Assert(err, check.IsNil, check.Commentf("Error reading version file %s", versionFile))
+
+	version, err := strconv.Atoi(string(contents))
+	c.Assert(err, check.IsNil, check.Commentf("Error converting version %v", contents))
+
+	return version
+}
+
+func getVersionFile() string {
+	return filepath.Join(os.Getenv("ADT_ARTIFACTS"), "version")
+}
+
+// InstallSnap executes the required command to install the specified snap
+func InstallSnap(c *check.C, packageName string) string {
+	return ExecCommand(c, "sudo", "snappy", "install", packageName, "--allow-unauthenticated")
+}
+
+// RemoveSnap executes the required command to remove the specified snap
+func RemoveSnap(c *check.C, packageName string) string {
+	return ExecCommand(c, "sudo", "snappy", "remove", packageName)
+}
+
+// WaitForActiveService keeps asking for the active state of the given service until
+// it is active or the maximun waiting time expires, in which case an error is returned
+func WaitForActiveService(c *check.C, serviceName string) error {
+	maxWait := time.Second * 10
+	checkInterval := time.Millisecond * 500
+
+	timer := time.NewTimer(maxWait)
+	timeChan := timer.C
+
+	ticker := time.NewTicker(checkInterval)
+	tickChan := ticker.C
+
+	for {
+		select {
+		case <-timeChan:
+			ticker.Stop()
+			journalctlOutput := ExecCommand(c, "sudo", "journalctl", "-u", serviceName)
+			return fmt.Errorf("Service %s not active after %s, journalctl output: %s",
+				serviceName, maxWait, journalctlOutput)
+		case <-tickChan:
+			statusOutput := ExecCommand(
+				c, "systemctl", "show", "-p", "ActiveState", serviceName)
+			if statusOutput == "ActiveState=active\n" {
+				timer.Stop()
+				return nil
+			}
+		}
+	}
+}

=== added file '_integration-tests/testutils/common/common_test.go'
--- _integration-tests/testutils/common/common_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/common/common_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,68 @@
+// -*- 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 common
+
+import (
+	"testing"
+
+	. "gopkg.in/check.v1"
+)
+
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { TestingT(t) }
+
+// testing a testsuite - thats so meta
+type MetaTestSuite struct {
+}
+
+var _ = Suite(&MetaTestSuite{})
+
+// test trivial cleanup
+func (m *MetaTestSuite) TestCleanupSimple(c *C) {
+	canary := "not-called"
+	s := SnappySuite{}
+
+	s.AddCleanup(func() {
+		canary = "was-called"
+	})
+	s.TearDownTest(c)
+
+	c.Assert(canary, Equals, "was-called")
+}
+
+// a mock method that takes a parameter
+func mockCleanupMethodWithParameters(s *string) {
+	*s = "was-called"
+}
+
+// test that whle AddCleanup() does not take any parameters itself,
+// functions that need parameters can be passed by creating an
+// anonymous function as a wrapper
+func (m *MetaTestSuite) TestCleanupWithParameters(c *C) {
+	canary := "not-called"
+	s := SnappySuite{}
+
+	s.AddCleanup(func() {
+		mockCleanupMethodWithParameters(&canary)
+	})
+	s.TearDownTest(c)
+
+	c.Assert(canary, Equals, "was-called")
+}

=== added directory '_integration-tests/testutils/config'
=== added file '_integration-tests/testutils/config/config.go'
--- _integration-tests/testutils/config/config.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/config/config.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,75 @@
+// -*- 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 config
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+)
+
+// Config contains the values to pass to the test bed from the host.
+type Config struct {
+	FileName      string
+	Release       string
+	Channel       string
+	TargetRelease string
+	TargetChannel string
+	RemoteTestbed bool
+	Update        bool
+	Rollback      bool
+}
+
+// NewConfig is the Config constructor
+func NewConfig(fileName, release, channel, targetRelease, targetChannel string, remoteTestbed, update, rollback bool) *Config {
+	return &Config{
+		FileName: fileName, Release: release, Channel: channel,
+		TargetRelease: targetRelease, TargetChannel: targetChannel,
+		RemoteTestbed: remoteTestbed, Update: update, Rollback: rollback,
+	}
+}
+
+// Write writes the config to a file that will be copied to the test bed.
+func (cfg Config) Write() {
+	fmt.Println("Writing test config...")
+	fmt.Println(cfg)
+	encoded, err := json.Marshal(cfg)
+	if err != nil {
+		log.Panicf("Error encoding the test config: %v", err)
+	}
+	err = ioutil.WriteFile(cfg.FileName, encoded, 0644)
+	if err != nil {
+		log.Panicf("Error writing the test config: %v", err)
+	}
+}
+
+// ReadConfig the config from a file
+func ReadConfig(fileName string) (*Config, error) {
+	b, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		return nil, err
+	}
+	var decoded Config
+	if err = json.Unmarshal(b, &decoded); err != nil {
+		return nil, err
+	}
+	return &decoded, nil
+}

=== added file '_integration-tests/testutils/config/config.test'
Binary files _integration-tests/testutils/config/config.test	1970-01-01 00:00:00 +0000 and _integration-tests/testutils/config/config.test	2015-08-02 12:28:52 +0000 differ
=== added file '_integration-tests/testutils/config/config_test.go'
--- _integration-tests/testutils/config/config_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/config/config_test.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,121 @@
+// -*- 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 config
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	check "gopkg.in/check.v1"
+)
+
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { check.TestingT(t) }
+
+type ConfigSuite struct{}
+
+var _ = check.Suite(&ConfigSuite{})
+
+func testConfigFileName(c *check.C) string {
+	tmpDir, err := ioutil.TempDir("", "")
+	c.Assert(err, check.IsNil, check.Commentf(
+		"Error creating a temporary directory: %v", err))
+	return filepath.Join(tmpDir, "test.config")
+}
+
+func testConfigStruct(fileName string) *Config {
+	return NewConfig(
+		fileName,
+		"testrelease", "testchannel", "testtargetrelease", "testtargetchannel",
+		true, true, true)
+}
+func testConfigContents(fileName string) string {
+	return `{` +
+		fmt.Sprintf(`"FileName":"%s",`, fileName) +
+		`"Release":"testrelease",` +
+		`"Channel":"testchannel",` +
+		`"TargetRelease":"testtargetrelease",` +
+		`"TargetChannel":"testtargetchannel",` +
+		`"RemoteTestbed":true,` +
+		`"Update":true,` +
+		`"Rollback":true` +
+		`}`
+}
+
+func (s *ConfigSuite) TestWriteConfig(c *check.C) {
+	// Do not print to stdout.
+	devnull, err := os.Open(os.DevNull)
+	c.Assert(err, check.IsNil)
+	oldStdout := os.Stdout
+	os.Stdout = devnull
+	defer func() {
+		os.Stdout = oldStdout
+	}()
+	configFileName := testConfigFileName(c)
+
+	cfg := testConfigStruct(configFileName)
+	cfg.Write()
+
+	writtenConfig, err := ioutil.ReadFile(configFileName)
+	c.Assert(err, check.IsNil, check.Commentf("Error reading config: %v", err))
+	c.Assert(string(writtenConfig), check.Equals, testConfigContents(configFileName))
+}
+
+func (s *ConfigSuite) TestReadConfig(c *check.C) {
+	configFileName := testConfigFileName(c)
+
+	configContents := testConfigContents(configFileName)
+	ioutil.WriteFile(configFileName, []byte(configContents), 0644)
+
+	cfg, err := ReadConfig(configFileName)
+
+	c.Assert(err, check.IsNil, check.Commentf("Error reading config: %v", err))
+	c.Assert(cfg, check.DeepEquals, testConfigStruct(configFileName))
+}
+
+func (s *ConfigSuite) TestReadConfigLocalTestBed(c *check.C) {
+	configFileName := testConfigFileName(c)
+
+	configContents := `{` +
+		fmt.Sprintf(`"FileName":"%s",`, configFileName) +
+		`"Release":"testrelease",` +
+		`"Channel":"testchannel",` +
+		`"TargetRelease":"testtargetrelease",` +
+		`"TargetChannel":"testtargetchannel",` +
+		`"RemoteTestbed":false,` +
+		`"Update":true,` +
+		`"Rollback":true` +
+		`}`
+
+	ioutil.WriteFile(configFileName, []byte(configContents), 0644)
+
+	cfg, err := ReadConfig(configFileName)
+
+	testConfigStruct := NewConfig(
+		configFileName,
+		"testrelease", "testchannel", "testtargetrelease", "testtargetchannel",
+		false, true, true)
+
+	c.Assert(err, check.IsNil, check.Commentf("Error reading config: %v", err))
+	c.Assert(cfg, check.DeepEquals, testConfigStruct)
+}

=== added directory '_integration-tests/testutils/image'
=== added file '_integration-tests/testutils/image/image.go'
--- _integration-tests/testutils/image/image.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/image/image.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,86 @@
+// -*- 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 image
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"launchpad.net/snappy/_integration-tests/testutils"
+)
+
+// Image type encapsulates image actions
+type Image struct {
+	release  string
+	channel  string
+	revision string
+	baseDir  string
+}
+
+// NewImage is the Image constructor
+func NewImage(release, channel, revision, baseDir string) *Image {
+	return &Image{release: release, channel: channel, revision: revision, baseDir: baseDir}
+}
+
+// UdfCreate forms and executes the UDF command for creating the image
+func (img Image) UdfCreate() (string, error) {
+	fmt.Println("Creating image...")
+
+	imageDir := filepath.Join(img.baseDir, "image")
+
+	testutils.PrepareTargetDir(imageDir)
+
+	udfCommand := []string{"sudo", "ubuntu-device-flash", "--verbose"}
+
+	if img.revision != "" {
+		udfCommand = append(udfCommand, "--revision", img.revision)
+	}
+
+	imagePath := img.imagePath(imageDir)
+
+	coreOptions := []string{
+		"core", img.release,
+		"--output", imagePath,
+		"--channel", img.channel,
+		"--developer-mode",
+	}
+
+	err := testutils.ExecCommand(append(udfCommand, coreOptions...)...)
+
+	return imagePath, err
+}
+
+func (img Image) imagePath(imageDir string) string {
+	revisionTag := img.revision
+	if revisionTag == "" {
+		revisionTag = "latest"
+	}
+
+	imageName := strings.Join(
+		[]string{"snappy", img.release, img.channel, revisionTag}, "-") + ".img"
+
+	return filepath.Join(imageDir, imageName)
+}
+
+// SetRevision is the setter method for revision
+func (img Image) SetRevision(rev string) {
+	img.revision = rev
+}

=== added file '_integration-tests/testutils/testutils.go'
--- _integration-tests/testutils/testutils.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/testutils.go	2015-08-02 12:28:52 +0000
@@ -0,0 +1,61 @@
+// -*- 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 testutils
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+// PrepareTargetDir creates the given target directory, removing it previously if it didn't exist
+func PrepareTargetDir(targetDir string) {
+	if _, err := os.Stat(targetDir); err == nil {
+		// dir exists, remove it
+		os.RemoveAll(targetDir)
+	}
+	os.MkdirAll(targetDir, 0777)
+}
+
+// RootPath return the test current working directory.
+func RootPath() string {
+	dir, err := os.Getwd()
+	if err != nil {
+		log.Panic(err)
+	}
+	return dir
+}
+
+// ExecCommand executes the given command and pipes the results to os.Stdout and os.Stderr, returning the resulting error
+func ExecCommand(cmds ...string) error {
+	fmt.Println(strings.Join(cmds, " "))
+
+	cmd := exec.Command(cmds[0], cmds[1:]...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	err := cmd.Run()
+	if err != nil {
+		log.Panicf("Error while running %s: %s\n", cmd.Args, err)
+	}
+	return err
+}

=== modified file 'run-checks'
--- run-checks	2015-03-27 18:35:24 +0000
+++ run-checks	2015-08-02 12:28:52 +0000
@@ -13,7 +13,7 @@
 
 if [ -n "$fmt" ]; then
     echo "Formatting wrong in following files"
-    echo $fmt
+    echo "$fmt"
     exit 1
 fi
 
@@ -42,14 +42,30 @@
 # go vet
 echo Running vet
 go vet ./...
+go vet ./_integration-tests/tests/...
+go vet ./_integration-tests/testutils/...
 
 # golint
 echo Running lint
-lint=$(golint ./...)
+lint=$(golint ./... && golint ./_integration-tests/testutils/... && golint ./_integration-tests/tests/...)
 if [ -n "$lint" ]; then
     echo "Lint complains:"
-    echo $lint
+    echo "$lint"
     exit 1
 fi
 
+# integration tests
+echo Building the integration tests
+go build _integration-tests/main.go
+
+# the rabbit hole
+echo Running the tests for the integration testutils
+$goctest -v -cover ./_integration-tests/testutils/...
+
+# integration suite in kvm
+if which adt-run >/dev/null 2>&1; then
+    echo "Running integration tests on 15.04 edge"
+    go run _integration-tests/main.go --snappy-from-branch --release=15.04
+fi
+
 echo "All good, what could possibly go wrong"