func (s *frameworkExampleSuite) TestFrameworkClient(c *check.C) {
common.InstallSnap(c, "hello-dbus-fwk.canonical/edge")
defer common.RemoveSnap(c, "hello-dbus-fwk.canonical")
common.InstallSnap(c, "hello-dbus-app.canonical/edge")
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 *serviceSuite) TearDownTest(c *check.C) {
if !common.IsInRebootProcess() {
common.RemoveSnap(c, data.BasicServiceSnapName)
}
// run cleanup last
s.SnappySuite.TearDownTest(c)
}
func (s *installAppSuite) TestInstallFromStoreMetadata(c *check.C) {
common.InstallSnap(c, "hello-world/edge")
defer common.RemoveSnap(c, "hello-world")
output := cli.ExecCommand(c, "snappy", "info", "hello-world")
c.Check(string(output), check.Matches, "(?ms)^channel: edge")
}
func (s *serviceSuite) TearDownTest(c *check.C) {
if !common.NeedsReboot() && common.CheckRebootMark("") {
common.RemoveSnap(c, data.BasicServiceSnapName)
}
// run cleanup last
s.SnappySuite.TearDownTest(c)
}
func (s *purgeSuite) TestPurgeReturnsErrorForNotRemovedPackage(c *check.C) {
defer common.RemoveSnap(c, data.BasicSnapName)
_, err := cli.ExecCommandErr("sudo", "snappy", "purge", snap)
c.Assert(err, check.NotNil)
_, err = os.Stat(snapDataPath)
c.Assert(err, check.IsNil)
}
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 *installAppSuite) TestCallFailBinaryFromInstalledSnap(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)
_, err = cli.ExecCommandErr("basic-binaries.fail")
c.Assert(err, check.NotNil, check.Commentf("The binary did not fail"))
}
func (s *purgeSuite) TestPurgeRemovesDataForDeactivatedNotRemovedPackage(c *check.C) {
defer common.RemoveSnap(c, data.BasicSnapName)
_, err := cli.ExecCommandErr("sudo", "snappy", "deactivate", snap)
c.Assert(err, check.IsNil)
_, err = cli.ExecCommandErr("sudo", "snappy", "purge", snap)
c.Assert(err, check.IsNil)
_, err = os.Stat(snapDataPath)
c.Assert(os.IsNotExist(err), check.Equals, true)
}
func (s *snapdTestSuite) TearDownTest(c *check.C) {
s.SnappySuite.TearDownTest(c)
proc := s.cmd.Process
if proc != nil {
proc.Kill()
}
cli.ExecCommand(c, "sudo", "systemctl", "start", "ubuntu-snappy.snapd.socket")
common.RemoveSnap(c, httpClientSnap)
}
func (s *helloWorldExampleSuite) TestCallHelloWorldBinary(c *check.C) {
common.InstallSnap(c, "hello-world/edge")
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"))
}
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 *pythonWebserverExampleSuite) TestNetworkingServiceMustBeStarted(c *check.C) {
baseAppName := "xkcd-webserver"
appName := baseAppName + ".canonical"
common.InstallSnap(c, appName+"/edge")
defer common.RemoveSnap(c, appName)
err := wait.ForServerOnPort(c, "tcp", 80)
c.Assert(err, check.IsNil, check.Commentf("Error waiting for server: %s", err))
resp, err := http.Get("http://localhost")
c.Assert(err, check.IsNil, check.Commentf("Error getting the http resource: %s", err))
c.Check(resp.Status, check.Equals, "200 OK", check.Commentf("Wrong reply status"))
c.Assert(resp.Proto, check.Equals, "HTTP/1.0", check.Commentf("Wrong reply protocol"))
}
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 (s *installAppSuite) TestInstallAppMustPrintPackageInformation(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))
installOutput := common.InstallSnap(c, snapPath)
defer common.RemoveSnap(c, data.BasicSnapName)
expected := "(?ms)" +
"Name +Version +Developer\n" +
".*" +
"^basic +.* *\n" +
".*"
c.Assert(installOutput, check.Matches, expected)
}
func (s *licensedExampleSuite) TestAcceptLicenseMustInstallSnap(c *check.C) {
cmd := exec.Command("sudo", "snappy", "install", "licensed.canonical/edge")
f, err := pty.Start(cmd)
c.Assert(err, check.IsNil, check.Commentf("Error starting pty: %s", err))
defer common.RemoveSnap(c, "licensed.canonical")
s.assertLicense(c, f)
// Accept the license.
_, err = f.Write([]byte("y\n"))
c.Assert(err, check.IsNil, check.Commentf("Error writing to pty: %s", err))
cmd.Wait()
c.Assert(s.isSnapInstalled(c), check.Equals, true, check.Commentf("The snap was not installed"))
}
func (s *purgeSuite) TestPurgeRemovesDataFromRemovedPackage(c *check.C) {
common.RemoveSnap(c, data.BasicSnapName)
versionSnapDataPath, err := getVersionSnapDataPath(snap)
c.Assert(err, check.IsNil)
_, err = os.Stat(versionSnapDataPath)
c.Assert(err, check.IsNil)
_, err = cli.ExecCommandErr("sudo", "snappy", "purge", snap)
c.Assert(err, check.IsNil)
_, err = os.Stat(versionSnapDataPath)
c.Assert(os.IsNotExist(err), check.Equals, true)
}
func (s *goWebserverExampleSuite) TestGetRootPathMustPrintMessage(c *check.C) {
appName := "go-example-webserver"
common.InstallSnap(c, appName+"/edge")
defer common.RemoveSnap(c, appName)
err := wait.ForServerOnPort(c, "tcp6", 8081)
c.Assert(err, check.IsNil, check.Commentf("Error waiting for server: %s", err))
resp, err := http.Get("http://localhost:8081/")
defer resp.Body.Close()
c.Assert(err, check.IsNil, check.Commentf("Error getting the http resource: %s", err))
c.Check(resp.Status, check.Equals, "200 OK", check.Commentf("Wrong reply status"))
body, err := ioutil.ReadAll(resp.Body)
c.Assert(err, check.IsNil, check.Commentf("Error reading the reply body: %s", err))
c.Assert(string(body), check.Equals, "Hello World\n", check.Commentf("Wrong reply body"))
}
func (s *installFrameworkSuite) TestInstallFrameworkMustPrintPackageInformation(c *check.C) {
snapPath, err := build.LocalSnap(c, data.BasicFrameworkSnapName)
defer os.Remove(snapPath)
c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
installOutput := common.InstallSnap(c, snapPath)
defer common.RemoveSnap(c, data.BasicFrameworkSnapName)
expected := "(?ms)" +
fmt.Sprintf("Installing %s\n", snapPath) +
"Name +Date +Version +Developer \n" +
".*" +
"^basic-framework +.* +.* +sideload *\n" +
".*"
c.Assert(installOutput, check.Matches, expected)
}
func (s *purgeSuite) TestPurgeHonoursInstalledFlagForNotRemovedPackage(c *check.C) {
defer common.RemoveSnap(c, data.BasicSnapName)
dataFile := filepath.Join(snapDataPath, "data")
_, err := cli.ExecCommandErr("sudo", "touch", dataFile)
c.Assert(err, check.IsNil)
_, err = cli.ExecCommandErr("sudo", "snappy", "purge", snap, "--installed")
c.Assert(err, check.IsNil)
_, err = os.Stat(dataFile)
c.Assert(os.IsNotExist(err), check.Equals, true, check.Commentf("Error %v instead of os.IsNotExist", err))
_, err = os.Stat(snapDataPath)
c.Assert(err, check.IsNil)
}
func (s *installDesktopAppSuite) TestInstallsDesktopFile(c *check.C) {
c.Skip("port to snapd")
snapPath, err := build.LocalSnap(c, data.BasicDesktopSnapName)
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.BasicDesktopSnapName)
content, err := ioutil.ReadFile(filepath.Join(dirs.SnapDesktopFilesDir, "basic-desktop_echo.desktop"))
c.Assert(err, check.IsNil)
c.Assert(string(content), testutil.Contains, `[Desktop Entry]
Name=Echo
Comment=It echos stuff
Exec=/snap/bin/basic-desktop.echo
`)
}
// Test that there is a proper message if autoupdate runs in the
// background
func (s *autoupdateMsgSuite) TestAutoUpdateMessageIsPrinted(c *check.C) {
cli.ExecCommand(c, "sudo", "systemctl", "start", "snappy-autopilot")
// do not pollute the other tests with the now installed hello-world
s.AddCleanup(func() {
common.RemoveSnap(c, "hello-world")
})
// FIXME: risk of race
// (i.e. systemctl start finishes before install runs)
snappyOutput, _ := exec.Command("sudo", "snappy", "install", "hello-world").CombinedOutput()
expected := "(?ms)" +
".*" +
"^Snappy is updating your system.*\n" +
".*"
c.Assert(string(snappyOutput), check.Matches, expected)
}
func (s *buildSuite) TestBuildBasicSnapOnSnappy(c *check.C) {
// build basic snap and check output
snapPath, err := build.LocalSnap(c, data.BasicSnapName)
defer os.Remove(snapPath)
c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
// install built snap and check output
installOutput := common.InstallSnap(c, snapPath)
defer common.RemoveSnap(c, data.BasicSnapName)
expected := "(?ms)" +
"Installing " + snapPath + "\n" +
"Name +Date +Version +Developer \n" +
".*" +
data.BasicSnapName + " +.* +.* +sideload \n" +
".*"
c.Check(installOutput, check.Matches, expected)
}
func (s *helloWorldExampleSuite) TestCallHelloWorldEvilMustPrintPermissionDeniedError(c *check.C) {
common.InstallSnap(c, "hello-world/edge")
s.AddCleanup(func() {
common.RemoveSnap(c, "hello-world")
})
echoOutput, err := cli.ExecCommandErr("hello-world.evil")
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" +
"/snaps/hello-world.canonical/.*/bin/evil: \\d+: " +
"/snaps/hello-world.canonical/.*/bin/evil: " +
"cannot create /var/tmp/myevil.txt: Permission denied\n"
c.Assert(string(echoOutput), check.Matches, expected)
}
func (s *licensedExampleSuite) TestAcceptLicenseMustInstallSnap(c *check.C) {
c.Skip("port to snapd")
cmds := []string{"sudo", "snappy", "install", "licensed.canonical/edge"}
cmdsCover, err := cli.AddOptionsToCommand(cmds)
c.Assert(err, check.IsNil, check.Commentf("Error adding coverage options, %q", err))
cmd := exec.Command(cmdsCover[0], cmdsCover[1:]...)
f, err := pty.Start(cmd)
c.Assert(err, check.IsNil, check.Commentf("Error starting pty: %s", err))
defer common.RemoveSnap(c, "licensed.canonical")
s.assertLicense(c, f)
// Accept the license.
_, err = f.Write([]byte("y\n"))
c.Assert(err, check.IsNil, check.Commentf("Error writing to pty: %s", err))
cmd.Wait()
c.Assert(s.isSnapInstalled(c), check.Equals, true, check.Commentf("The snap was not installed"))
}
func (s *configExampleSuite) TestPrintMessageFromConfig(c *check.C) {
for _, t := range configTests {
common.InstallSnap(c, t.snap+t.origin+"/edge")
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 *activateSuite) TearDownTest(c *check.C) {
os.Remove(s.snapPath)
common.RemoveSnap(c, activateSnapName)
s.SnappySuite.TearDownTest(c)
}
func (s *snapdTestSuite) TearDownTest(c *check.C) {
s.SnappySuite.TearDownTest(c)
common.RemoveSnap(c, httpClientSnap)
}
func (s *hwAssignSuite) TearDownTest(c *check.C) {
s.SnappySuite.TearDownTest(c)
os.Remove(s.snapPath)
common.RemoveSnap(c, snapName)
}
func (s *snapd20SnapsTestSuite) TearDownTest(c *check.C) {
s.snapdTestSuite.TearDownTest(c)
os.Remove(s.snapPath)
common.RemoveSnap(c, data.BasicConfigSnapName)
}