// SetUpSuite disables the snappy autopilot. It will run before all the // integration suites. func (s *SnappySuite) SetUpSuite(c *check.C) { 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 !IsInRebootProcess() { 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 := cli.ExecCommand(c, "sudo", "/usr/bin/snappy", "update") if output != "" { RebootWithMark(c, "setupsuite-update") } } } else if CheckRebootMark("setupsuite-update") { RemoveRebootMark(c) // Update was already executed. Update the config so it's not triggered again. Cfg.Update = false Cfg.Write() if Cfg.Rollback { cli.ExecCommand(c, "sudo", "snappy", "rollback", "ubuntu-core") RebootWithMark(c, "setupsuite-rollback") } } else if CheckRebootMark("setupsuite-rollback") { RemoveRebootMark(c) // Rollback was already executed. Update the config so it's not triggered again. Cfg.Rollback = false Cfg.Write() } }
func init() { c := &check.C{} // Workaround for bug https://bugs.launchpad.net/snappy/+bug/1498293 // TODO remove once the bug is fixed // originally added by elopio - 2015-09-30 to the rollback test, moved // here by --fgimenez - 2015-10-15 wait.ForFunction(c, "regular", partition.Mode) cli.ExecCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer") cli.ExecCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer") }
func (s *activateSuite) TestActivateBringsBinaryBack(c *check.C) { cli.ExecCommand(c, "sudo", "snappy", "deactivate", activateSnapName) cli.ExecCommand(c, "sudo", "snappy", "activate", activateSnapName) output := cli.ExecCommand(c, activateBinName) c.Assert(output, check.Equals, activateEchoOutput, check.Commentf("Wrong output from active snap binary")) list := cli.ExecCommand(c, "snappy", "list", "-v") c.Assert(list, check.Matches, activatedPattern) }
func (s *activateSuite) TestDeactivateRemovesBinary(c *check.C) { cli.ExecCommand(c, "sudo", "snappy", "deactivate", activateSnapName) defer cli.ExecCommand(c, "sudo", "snappy", "activate", activateSnapName) output, err := cli.ExecCommandErr(activateBinName) c.Assert(err, check.NotNil, check.Commentf("Deactivated snap binary did not exit with an error")) c.Assert(output, check.Not(check.Equals), activateEchoOutput, check.Commentf("Deactivated snap binary was not removed")) list := cli.ExecCommand(c, "snappy", "list", "-v") c.Assert(list, check.Matches, deActivatedPattern) }
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 != "" { cli.ExecCommand(c, "sudo", "sed", "-i", fmt.Sprintf(regex, value), file) } } // Leave the new file in the test log. cli.ExecCommand(c, "cat", file) }
func unInstallService(c *check.C, serviceName, basePath string) { partition.MakeWritable(c, basePath) defer partition.MakeReadonly(c, basePath) // Disable the service cli.ExecCommand(c, "sudo", "chroot", basePath, "systemctl", "disable", fmt.Sprintf("%s.service", serviceName)) // Remove the service file cli.ExecCommand(c, "sudo", "rm", fmt.Sprintf("%s%s/%s.service", basePath, baseSystemdPath, serviceName)) // Remove the requires symlink cli.ExecCommand(c, "sudo", "rm", fmt.Sprintf("%s%s/%s/%s.service", basePath, baseSystemdPath, systemdTargetRequiresDir, serviceName)) }
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 == common.BaseAltPartitionPath { partition.MakeWritable(c, basePath) defer partition.MakeReadonly(c, basePath) } cli.ExecCommand(c, "sudo", "mv", oldFilename, newFilename) if keepOld { cli.ExecCommand(c, "sudo", "touch", oldFilename) mode := getFileMode(c, newFilename) cli.ExecCommand(c, "sudo", "chmod", fmt.Sprintf("%o", mode), oldFilename) } }
func (s *initRAMFSSuite) SetUpTest(c *check.C) { s.SnappySuite.SetUpTest(c) if common.BeforeReboot() { bootDir := getCurrentBootDir(c) cli.ExecCommand(c, "cp", path.Join(bootDir, "initrd.img"), os.Getenv("ADT_ARTIFACTS")) } }
func (s *fanTestSuite) TestFanCommandCreatesFanBridge(c *check.C) { output := cli.ExecCommand(c, "ifconfig") expectedPattern := fmt.Sprintf("(?msi).*%s.*%s.*", s.fanName(), s.bridgeIP) c.Assert(output, check.Matches, expectedPattern, check.Commentf("Expected pattern %s not found in %s", expectedPattern, output)) }
func (s *initRAMFSSuite) TearDownTest(c *check.C) { s.SnappySuite.TearDownTest(c) if !common.IsInRebootProcess() { bootDir := getCurrentBootDir(c) cli.ExecCommand( c, "sudo", "mv", path.Join(os.Getenv("ADT_ARTIFACTS"), "initrd.img"), bootDir) } }
func (rcLocalCrash) set(c *check.C) { partition.MakeWritable(c, common.BaseAltPartitionPath) defer partition.MakeReadonly(c, common.BaseAltPartitionPath) targetFile := fmt.Sprintf("%s/etc/rc.local", common.BaseAltPartitionPath) cli.ExecCommand(c, "sudo", "chmod", "a+xw", targetFile) cli.ExecCommandToFile(c, targetFile, "sudo", "echo", "#!bin/sh\nprintf c > /proc/sysrq-trigger") }
func (s *fanTestSuite) configureDockerToUseBridge(c *check.C) { cfgFile := dockerCfgFile(c) cli.ExecCommand(c, "sudo", "sed", "-i", fmt.Sprintf(`s/DOCKER_OPTIONS=\"\"/DOCKER_OPTIONS=\"%s\"/`, s.dockerOptions()), cfgFile) restartDocker(c) }
func (s *fanTestSuite) removeBridgeFromDockerConf(c *check.C) { cfgFile := dockerCfgFile(c) cli.ExecCommand(c, "sudo", "sed", "-i", `s/DOCKER_OPTIONS=\".*\"/DOCKER_OPTIONS=\"\"/`, cfgFile) restartDocker(c) }
func (s *fanTestSuite) TestContainersInTheFanAreReachable(c *check.C) { setUpDocker(c) defer tearDownDocker(c) s.configureDockerToUseBridge(c) defer s.removeBridgeFromDockerConf(c) // spin up first container cli.ExecCommand(c, "docker", "run", "-d", "-t", baseContainer) // the first assigned IP in the fan will end with ".2" firstIPAddr := strings.TrimRight(s.bridgeIP, ".1") + ".2" // ping from a second container output := cli.ExecCommand(c, "docker", "run", "-t", baseContainer, "ping", firstIPAddr, "-c", "1") expectedPattern := "(?ms).*1 packets transmitted, 1 packets received, 0% packet loss.*" c.Assert(output, check.Matches, expectedPattern, check.Commentf("Expected pattern %s not found in %s", expectedPattern, output)) }
func (s *installAppSuite) TestCallSuccessfulBinaryFromInstalledSnap(c *check.C) { snapPath, err := build.LocalSnap(c, data.BasicBinariesSnapName) defer os.Remove(snapPath) c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err)) common.InstallSnap(c, snapPath) defer common.RemoveSnap(c, data.BasicBinariesSnapName) // Exec command does not fail. cli.ExecCommand(c, "basic-binaries.success") }
func (s *listSuite) TestListMustPrintCoreVersion(c *check.C) { listOutput := cli.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 *searchSuite) TestSearchFrameworkMustPrintMatch(c *check.C) { searchOutput := cli.ExecCommand(c, "snappy", "search", "hello-dbus-fwk") expected := "(?ms)" + "Name +Version +Summary *\n" + ".*" + "^hello-dbus-fwk +.* +hello-dbus-fwk *\n" + ".*" c.Assert(searchOutput, check.Matches, expected) }
func (s *helloWorldExampleSuite) TestCallHelloWorldBinary(c *check.C) { common.InstallSnap(c, "hello-world") s.AddCleanup(func() { common.RemoveSnap(c, "hello-world") }) echoOutput := cli.ExecCommand(c, "hello-world.echo") c.Assert(echoOutput, check.Equals, "Hello World!\n", check.Commentf("Wrong output from hello-world binary")) }
// GetCurrentVersion returns the version of the installed and active package. func GetCurrentVersion(c *check.C, packageName string) string { output := cli.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] }
func installService(c *check.C, serviceName, serviceCfg, basePath string) { partition.MakeWritable(c, basePath) defer partition.MakeReadonly(c, basePath) // Create service file serviceFile := fmt.Sprintf("%s%s/%s.service", basePath, baseSystemdPath, serviceName) cli.ExecCommand(c, "sudo", "chmod", "a+w", fmt.Sprintf("%s%s", basePath, baseSystemdPath)) cli.ExecCommandToFile(c, serviceFile, "sudo", "echo", serviceCfg) // Create requires directory requiresDirPart := fmt.Sprintf("%s/%s", baseSystemdPath, systemdTargetRequiresDir) requiresDir := fmt.Sprintf("%s%s", basePath, requiresDirPart) cli.ExecCommand(c, "sudo", "mkdir", "-p", requiresDir) // Symlink from the requires dir to the service file (with chroot for being // usable in the other partition) cli.ExecCommand(c, "sudo", "chroot", basePath, "ln", "-s", fmt.Sprintf("%s/%s.service", baseSystemdPath, serviceName), fmt.Sprintf("%s/%s.service", requiresDirPart, serviceName), ) }
func restartDocker(c *check.C) { dockerVersion := common.GetCurrentVersion(c, "docker") dockerService := fmt.Sprintf("docker_docker-daemon_%s.service", dockerVersion) cli.ExecCommand(c, "sudo", "systemctl", "restart", dockerService) // we need to wait until the socket is ready, an active systemctl status is not enough err := wait.ForActiveService(c, dockerService) c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err)) err = wait.ForCommand(c, `(?ms).*docker\.sock\s.*`, "ls", "/run") c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err)) }
func setUpDocker(c *check.C) { common.InstallSnap(c, "docker") dockerVersion := common.GetCurrentVersion(c, "docker") dockerService := fmt.Sprintf("docker_docker-daemon_%s.service", dockerVersion) err := wait.ForActiveService(c, dockerService) c.Assert(err, check.IsNil, check.Commentf("Error waiting for service: %s", err)) err = wait.ForCommand(c, `(?ms).*docker\.sock\s.*`, "ls", "/run") c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err)) cli.ExecCommand(c, "docker", "pull", baseContainer) }
func (s *configExampleSuite) TestPrintMessageFromConfig(c *check.C) { for _, t := range configTests { common.InstallSnap(c, t.snap+t.origin) defer common.RemoveSnap(c, t.snap) config := fmt.Sprintf(`config: %s: msg: | %s`, t.snap, t.message) configFile, err := ioutil.TempFile("", "snappy-cfg") defer func() { configFile.Close(); os.Remove(configFile.Name()) }() c.Assert(err, check.IsNil, check.Commentf("Error creating temp file: %s", err)) _, err = configFile.Write([]byte(config)) c.Assert(err, check.IsNil, check.Commentf("Error writing the conf to the temp file: %s", err)) cli.ExecCommand(c, "sudo", "snappy", "config", t.snap, configFile.Name()) output := cli.ExecCommand(c, t.snap+".hello") c.Assert(output, check.Equals, t.message, check.Commentf("Wrong message")) } }
func (s *infoSuite) TestInfoMustPrintInstalledFrameworks(c *check.C) { common.InstallSnap(c, "hello-dbus-fwk.canonical") s.AddCleanup(func() { common.RemoveSnap(c, "hello-dbus-fwk.canonical") }) infoOutput := cli.ExecCommand(c, "snappy", "info") expected := "(?ms)" + ".*" + "^frameworks: .*hello-dbus-fwk.*\n" + ".*" c.Assert(infoOutput, check.Matches, expected) }
func (s *initRAMFSSuite) TestFreeSpaceWithResize(c *check.C) { if common.BeforeReboot() { bootDir := getCurrentBootDir(c) writablePercent := "85" cli.ExecCommand( c, "sh", "-x", "_integration-tests/scripts/install-test-initramfs", bootDir, writablePercent) common.Reboot(c) } else if common.AfterReboot(c) { common.RemoveRebootMark(c) freeSpace := getFreeSpacePercent(c) c.Assert(freeSpace < 10, check.Equals, true, check.Commentf("The writable partition was not resized")) } }
func (s *fanTestSuite) TestDockerCreatesAContainerInsideTheFan(c *check.C) { setUpDocker(c) defer tearDownDocker(c) s.configureDockerToUseBridge(c) defer s.removeBridgeFromDockerConf(c) output := cli.ExecCommand(c, "docker", "run", "-t", baseContainer, "ifconfig") expectedIP := strings.TrimRight(s.bridgeIP, ".1") + ".2" expectedPattern := fmt.Sprintf("(?ms).*inet addr:%s.*", expectedIP) c.Assert(output, check.Matches, expectedPattern, check.Commentf("Expected pattern %s not found in %s", expectedPattern, output)) }
func (s *frameworkExampleSuite) TestFrameworkClient(c *check.C) { common.InstallSnap(c, "hello-dbus-fwk.canonical") defer common.RemoveSnap(c, "hello-dbus-fwk.canonical") common.InstallSnap(c, "hello-dbus-app.canonical") defer common.RemoveSnap(c, "hello-dbus-app.canonical") output := cli.ExecCommand(c, "hello-dbus-app.client") expected := "PASS\n" c.Assert(output, check.Equals, expected, check.Commentf("Expected output %s not found, %s", expected, output)) }
func (s *infoSuite) TestInfoMustPrintInstalledApps(c *check.C) { snapPath, err := build.LocalSnap(c, data.BasicSnapName) defer os.Remove(snapPath) c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err)) common.InstallSnap(c, snapPath) defer common.RemoveSnap(c, data.BasicSnapName) infoOutput := cli.ExecCommand(c, "snappy", "info") expected := "(?ms)" + ".*" + "^apps: .*" + data.BasicSnapName + "\\.sideload.*\n" c.Assert(infoOutput, check.Matches, expected) }
func (s *listSuite) TestListMustPrintAppVersion(c *check.C) { common.InstallSnap(c, "hello-world") s.AddCleanup(func() { common.RemoveSnap(c, "hello-world") }) listOutput := cli.ExecCommand(c, "snappy", "list") expected := "(?ms)" + "Name +Date +Version +Developer *\n" + ".*" + "^hello-world +.* +(\\d+)(\\.\\d+)* +.* +.* *\n" + ".*" c.Assert(listOutput, check.Matches, expected) }
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 { partition.MakeWritable(c, target) defer partition.MakeReadonly(c, target) // Back up the file. It will be restored during the test tear down. cli.ExecCommand(c, "cp", file, backup) replaceSystemImageValues(c, file, "", "", strconv.Itoa(newVersion)) } } }