Merge lp:~elopio/snappy/15.04_to_rolling-3 into lp:~snappy-dev/snappy/snappy-moved-to-github

[Leo Arias]

[lp:~elopio/snappy/15.04_to_rolling-3]

588. By Leo Arias on 2015-07-16

Fixed the regexps.

589. By Leo Arias on 2015-07-16

Various fixes.

590. By Leo Arias on 2015-07-16

Updated comments and logs.

591. By Leo Arias on 2015-07-16

Merge

592. By Leo Arias on 2015-07-16

Better not replace the version yet.

593. By Leo Arias on 2015-07-16

Reverted the last change.

594. By Leo Arias on 2015-07-16

Only execute the setup if there is no reboot in progress.

595. By Leo Arias on 2015-07-16

Added a comment to Config.

596. By Leo Arias on 2015-07-16

Use the installed snappy for the update.

597. By Leo Arias on 2015-07-17

Moved the update tests to the latest package.

598. By Leo Arias on 2015-07-17

Renamed the latest package to cmd.

599. By Leo Arias on 2015-07-21

Added the isInRebootProcess method.

600. By Leo Arias on 2015-07-21

Use a map for the regex.

601. By Leo Arias on 2015-07-21

Moved the examples from run-checks to the README.

602. By Leo Arias on 2015-07-21

Merged with trunk.

603. By Leo Arias on 2015-07-21

Renamed the packages.

Unmerged revisions

=== modified file '_integration-tests/main.go'
--- _integration-tests/main.go	2015-07-15 15:53:51 +0000
+++ _integration-tests/main.go	2015-07-16 00:24:47 +0000
@@ -64,6 +64,7 @@
 		buildSnappyCLI(arch)
 	}
 	buildTests(arch)
+<<<<<<< TREE
 }
 
 func writeTestConfig(release, channel string) {
@@ -88,6 +89,38 @@
 
 	// Run the tests on the latest rolling edge image.
 	if imageName, err := img.UdfCreate(); err == nil {
+=======
+}
+
+func writeTestConfig(release, channel, targetRelease, targetChannel string) {
+	fmt.Println("Writing test config...")
+	testConfig := map[string]string{
+		"release": release,
+		"channel": channel,
+	}
+	if targetRelease != "" {
+		testConfig["targetRelease"] = targetRelease
+	}
+	if targetChannel != "" {
+		testConfig["targetChannel"] = targetChannel
+	}
+	fmt.Println(testConfig)
+	encoded, err := json.Marshal(testConfig)
+	if err != nil {
+		log.Fatalf("Error encoding the test config: %v", testConfig)
+	}
+	ioutil.WriteFile(configFileName, encoded, 0644)
+}
+
+func setupAndRunLocalTests(rootPath, testFilter string, img image.Image) {
+	var includeShell bool
+	if testFilter == "" {
+		includeShell = true
+	}
+
+	// Run the tests on the latest rolling edge image.
+	if imageName, err := img.UdfCreate(); err == nil {
+>>>>>>> MERGE-SOURCE
 		adtRun(rootPath, testFilter, testPackages,
 			kvmSSHOptions(imageName), includeShell)
 	}
@@ -228,16 +261,30 @@
 			"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")
+<<<<<<< TREE
+		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")
+=======
+		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")
+		targetRelease = flag.String("target-release", "",
+			"If specified, the image will be updated to this release before running the tests.")
+		targetChannel = flag.String("target-channel", "",
+			"If specified, the image will be updated to this channel before running the tests.")
+>>>>>>> MERGE-SOURCE
 	)
 
 	flag.Parse()
 
+<<<<<<< TREE
 	buildAssets(*useSnappyFromBranch, *arch)
 
 	// TODO: generate the files out of the source tree. --elopio - 2015-07-15
@@ -257,4 +304,25 @@
 	} else {
 		setupAndRunRemoteTests(rootPath, *testFilter, *testbedIP, *testbedPort)
 	}
+=======
+	buildAssets(*useSnappyFromBranch, *arch)
+
+	// TODO: generate the files out of the source tree. --elopio - 2015-07-15
+	utils.PrepareTargetDir(dataOutputDir)
+	defer os.RemoveAll(dataOutputDir)
+
+	// TODO: pass the config as arguments to the test binaries.
+	// --elopio - 2015-07-15
+	writeTestConfig(*imgRelease, *imgChannel, *targetRelease, *targetChannel)
+
+	rootPath := getRootPath()
+
+	if *testbedIP == "" {
+		img := image.NewImage(*imgRelease, *imgChannel, *imgRevision, baseDir)
+		setupAndRunLocalTests(rootPath, *testFilter, *img)
+
+	} else {
+		setupAndRunRemoteTests(rootPath, *testFilter, *testbedIP, *testbedPort)
+	}
+>>>>>>> MERGE-SOURCE
 }
 
=== modified file '_integration-tests/tests/common/common.go'
--- _integration-tests/tests/common/common.go	2015-07-16 00:12:27 +0000
+++ _integration-tests/tests/common/common.go	2015-07-16 00:24:47 +0000
@@ -20,6 +20,7 @@
 package common
 
 import (
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -39,6 +40,8 @@
 	channelCfgFile  = "/etc/system-image/channel.ini"
 )
 
+var Config map[string]string
+
 // SnappySuite is a structure used as a base test suite for all the snappy
 // integration tests.
 type SnappySuite struct {
@@ -50,6 +53,19 @@
 func (s *SnappySuite) SetUpSuite(c *check.C) {
 	ExecCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
 	ExecCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer")
+	if CheckRebootMark("") {
+		Config = readConfig(c)
+		targetRelease, _ := Config["targetRelease"]
+		targetChannel, _ := Config["targetChannel"]
+		if targetRelease != "" || targetChannel != "" {
+			switchSystemImageConf(c, targetRelease, targetChannel, "0")
+			if CallUpdate(c) {
+				RebootWithMark(c, c.TestName()+"-setupsuite-update")
+			}
+		}
+	} else if CheckRebootMark(c.TestName() + "-setupsuite-update") {
+		RemoveRebootMark(c)
+	}
 }
 
 // SetUpTest handles reboots and stores version information. It will run before
@@ -112,6 +128,59 @@
 	s.cleanupHandlers = append(s.cleanupHandlers, f)
 }
 
+func readConfig(c *check.C) map[string]string {
+	b, err := ioutil.ReadFile("_integration-tests/data/output/testconfig.json")
+	c.Assert(
+		err, check.IsNil, check.Commentf("Failed to read test config: %v", err))
+
+	var decoded map[string]string
+	err = json.Unmarshal(b, &decoded)
+	c.Assert(
+		err, check.IsNil, check.Commentf("Failed to decode test config: %v", err))
+	return decoded
+}
+
+func switchSystemImageConf(c *check.C, release, channel, version string) {
+	targets := []string{"/", BaseOtherPath}
+	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...")
+	regex := []string{}
+	if release != "" {
+		regex = append(regex,
+			fmt.Sprintf(
+				`s#channel: ubuntu-core/.*/\(.*\)#channel: ubuntu-core/%s/\1#`,
+				release))
+	}
+	if channel != "" {
+		regex = append(regex,
+			fmt.Sprintf(
+				`s#channel: ubuntu-core/\(.*\)/.*#channel: ubuntu-core/\1/%s#`,
+				channel))
+	}
+	if version != "" {
+		regex = append(regex,
+			fmt.Sprintf(
+				`s/build_number: .*/build_number: %s/`,
+				version))
+	}
+	for i := range regex {
+		ExecCommand(c,
+			"sudo", "sed", "-i", regex[i], 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")
 }
@@ -168,17 +237,28 @@
 	return version
 }
 
-// CallUpdate executes an snappy update. If there is no update available, the
-// channel version will be modified to fake an update.
-func CallUpdate(c *check.C) {
+// CallUpdate executes an snappy update. It returns true if an update was
+// installed and it is waiting for a reboot to be activated.
+func CallUpdate(c *check.C) bool {
 	c.Log("Calling snappy update...")
 	output := ExecCommand(c, "sudo", "snappy", "update")
 	// XXX Instead of trying the update, we should have a command to tell us
 	// if there is an available update. --elopio - 2015-07-01
+<<<<<<< TREE
 	if output == "" {
 		c.Log("There is no update available.")
 		CallFakeUpdate(c)
 	}
+=======
+	return output != ""
+}
+
+// CallFakeUpdate calls snappy update after faking the current version
+func CallFakeUpdate(c *check.C) {
+	c.Log("Preparing fake and calling update.")
+	fakeAvailableUpdate(c)
+	ExecCommand(c, "sudo", "snappy", "update")
+>>>>>>> MERGE-SOURCE
 }
 
 // CallFakeUpdate calls snappy update after faking the current version
@@ -190,12 +270,17 @@
 
 func fakeAvailableUpdate(c *check.C) {
 	c.Log("Faking an available update...")
+<<<<<<< TREE
 	currentVersion := GetCurrentUbuntuCoreVersion(c)
 	switchChannelVersion(c, currentVersion, currentVersion-1)
+=======
+	currentVersion := GetCurrentUbuntuCoreVersion(c)
+	switchChannelVersionWithBackup(c, currentVersion-1)
+>>>>>>> MERGE-SOURCE
 	SetSavedVersion(c, currentVersion-1)
 }
 
-func switchChannelVersion(c *check.C, oldVersion, newVersion int) {
+func switchChannelVersionWithBackup(c *check.C, newVersion int) {
 	m := make(map[string]string)
 	m["/"] = channelCfgBackupFile()
 	m[BaseOtherPath] = channelCfgOtherBackupFile()
@@ -206,12 +291,7 @@
 			defer MakeReadonly(c, target)
 			// Back up the file. It will be restored during the test tear down.
 			ExecCommand(c, "cp", file, backup)
-			ExecCommand(c,
-				"sudo", "sed", "-i",
-				fmt.Sprintf(
-					"s/build_number: %d/build_number: %d/g",
-					oldVersion, newVersion),
-				file)
+			replaceSystemImageValues(c, file, "", "", strconv.Itoa(newVersion))
 		}
 	}
 }
 
=== modified file '_integration-tests/tests/latest/info_test.go'
--- _integration-tests/tests/latest/info_test.go	2015-07-15 15:18:22 +0000
+++ _integration-tests/tests/latest/info_test.go	2015-07-16 00:24:47 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 // -*- Mode: Go; indent-tabs-mode: t -*-
 
 /*
@@ -84,3 +85,76 @@
 		".*"
 	c.Assert(infoOutput, check.Matches, expected)
 }
+=======
+// -*- 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 latest
+
+import (
+	"fmt"
+
+	. "../common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&infoSuite{})
+
+type infoSuite struct {
+	SnappySuite
+}
+
+func (s *infoSuite) TestInfoMustPrintReleaseAndChannel(c *check.C) {
+	infoOutput := ExecCommand(c, "snappy", "info")
+
+	expected := "(?ms)" +
+		fmt.Sprintf("^release: ubuntu-core/%s/%s\n", Config["release"], Config["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)
+}
+>>>>>>> MERGE-SOURCE
 
=== modified file '_integration-tests/tests/update/update_test.go'
--- _integration-tests/tests/update/update_test.go	2015-07-14 15:16:59 +0000
+++ _integration-tests/tests/update/update_test.go	2015-07-16 00:24:47 +0000
@@ -41,7 +41,7 @@
 // be up-to-date after running this test.
 func (s *updateSuite) TestUpdateToSameReleaseAndChannel(c *C) {
 	if BeforeReboot() {
-		CallUpdate(c)
+		CallFakeUpdate(c)
 		Reboot(c)
 	} else if AfterReboot(c) {
 		RemoveRebootMark(c)
 
=== modified file 'run-checks'
--- run-checks	2015-07-08 15:50:31 +0000
+++ run-checks	2015-07-16 00:24:47 +0000
@@ -76,8 +76,12 @@
 
 # integration suite in kvm
 if which adt-run >/dev/null 2>&1; then
-    echo "Running integration tests"
+    echo "Running integration tests on rolling edge"
     go run _integration-tests/main.go --snappy-from-branch
+    echo "Update from rolling edge -1 and run the integration tests"
+    go run _integration-tests/main.go --snappy-from-branch --revision=-1 --target-release=rolling --target-channel=edge
+    echo "Update from 15.04 edge to rolling edge and run the integration tests"
+    go run _integration-tests/main.go --snappy-from-branch --release=15.04 --channel=edge --target-release=rolling --target-channel=edge
 fi
 
 echo "All good, what could possibly go wrong"