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 14:22:11 +0000
+++ _integration-tests/main.go	2015-07-15 23:45:01 +0000
@@ -20,8 +20,10 @@
 package main
 
 import (
+	"encoding/json"
 	"flag"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"os"
 	"path/filepath"
@@ -40,13 +42,14 @@
 	defaultChannel = "edge"
 	defaultSSHPort = 22
 	defaultGoArm   = "7"
-	tplOutputDir   = "_integration-tests/data/output/"
+	dataOutputDir  = "_integration-tests/data/output/"
 	controlTpl     = "_integration-tests/data/tpl/control"
 )
 
 var (
 	commonSSHOptions   = []string{"---", "ssh"}
-	controlFile        = filepath.Join(tplOutputDir, "control")
+	configFileName     = filepath.Join(dataOutputDir, "testconfig.json")
+	controlFile        = filepath.Join(dataOutputDir, "control")
 	testPackagesLatest = []string{"latest", "failover"}
 	testPackageUpdate  = []string{"update"}
 	testPackages       = append(testPackagesLatest, testPackageUpdate...)
@@ -63,6 +66,26 @@
 	buildTests(arch)
 }
 
+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 == "" {
@@ -161,7 +184,6 @@
 		log.Fatalf("Error reading adt-run control template %s", controlTpl)
 	}
 
-	utils.PrepareTargetDir(tplOutputDir)
 	outputFile, err := os.Create(controlFile)
 	if err != nil {
 		log.Fatalf("Error creating control file %s", controlFile)
@@ -218,12 +240,24 @@
 			"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.")
 	)
 
 	flag.Parse()
 
 	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 == "" {

=== removed file '_integration-tests/tests/01_test_info'
--- _integration-tests/tests/01_test_info	2015-06-15 15:36:29 +0000
+++ _integration-tests/tests/01_test_info	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-test() {
-    test_regexp "^release: ubuntu-core/.*/(edge|stable)" $SNAPPY info
-    test_regexp "^frameworks: ($framework|)*$" $SNAPPY info
-}

=== removed file '_integration-tests/tests/10_test_info_has_stuff'
--- _integration-tests/tests/10_test_info_has_stuff	2015-06-16 06:05:14 +0000
+++ _integration-tests/tests/10_test_info_has_stuff	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-test() {
-    test_regexp "^release: ubuntu-core/.*/(edge|stable)" $SNAPPY info
-    test_regexp "^frameworks: $framework" $SNAPPY info
-}

=== modified file '_integration-tests/tests/common/common.go'
--- _integration-tests/tests/common/common.go	2015-07-15 16:12:25 +0000
+++ _integration-tests/tests/common/common.go	2015-07-15 23:45:01 +0000
@@ -39,6 +39,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 +52,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()
+	}
 }
 
 // SetUpTest handles reboots and stores version information. It will run before
@@ -112,6 +127,59 @@
 	s.cleanupHandlers = append(s.cleanupHandlers, f)
 }
 
+func (s *SnappySuite) 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 switchSsytemImageConf(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")
 }
@@ -170,15 +238,12 @@
 
 // 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) {
+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
-	if output == "" {
-		c.Log("There is no update available.")
-		CallFakeUpdate(c)
-	}
+	return output != ""
 }
 
 // CallFakeUpdate calls snappy update after faking the current version
@@ -191,11 +256,11 @@
 func fakeAvailableUpdate(c *check.C) {
 	c.Log("Faking an available update...")
 	currentVersion := GetCurrentUbuntuCoreVersion(c)
-	switchChannelVersion(c, currentVersion, currentVersion-1)
+	switchChanelVersionWithBackup(c, currentVersion, currentVersion-1)
 	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 +271,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, "", "", newVersion)
 		}
 	}
 }

=== added file '_integration-tests/tests/latest/info_test.go'
--- _integration-tests/tests/latest/info_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/latest/info_test.go	2015-07-15 23:45:01 +0000
@@ -0,0 +1,74 @@
+// -*- 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 (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+
+	. "../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")
+
+	config := readConfig(c)
+	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)
+}

=== 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-15 23:45:01 +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-15 23:45:01 +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"