func (s *copydataSuite) TestCopyDataDoUndoNoUserHomes(c *C) {
// this home dir path does not exist
oldSnapDataHomeGlob := dirs.SnapDataHomeGlob
defer func() { dirs.SnapDataHomeGlob = oldSnapDataHomeGlob }()
dirs.SnapDataHomeGlob = filepath.Join(s.tempdir, "no-such-home", "*", "snap")
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
s.populateData(c, snap.R(10))
// pretend we install a new version
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
// copy data
err := s.be.CopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
v2data := filepath.Join(dirs.SnapDataDir, "hello/20")
l, err := filepath.Glob(filepath.Join(v2data, "*"))
c.Assert(err, IsNil)
c.Assert(l, HasLen, 1)
err = s.be.UndoCopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
// now removed
_, err = os.Stat(v2data)
c.Assert(os.IsNotExist(err), Equals, true)
}
func (s *copydataSuite) TestCopyDataDoUndoABA(c *C) {
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
s.populateData(c, snap.R(10))
c.Check(s.populatedData("10"), Equals, "10\n")
// pretend we install a new version
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
// and write our own data to it
s.populateData(c, snap.R(20))
c.Check(s.populatedData("20"), Equals, "20\n")
// and now we pretend to refresh back to v1 (r10)
c.Check(s.be.CopySnapData(v1, v2, &s.nullProgress), IsNil)
// so v1 (r10) now has v2 (r20)'s data and we have trash
c.Check(s.populatedData("10"), Equals, "20\n")
c.Check(s.populatedData("10.old"), Equals, "10\n")
// but oh no! we have to undo it!
c.Check(s.be.UndoCopySnapData(v1, v2, &s.nullProgress), IsNil)
// so now v1 (r10) has v1 (r10)'s data and v2 (r20) has v2 (r20)'s data and we have no trash
c.Check(s.populatedData("10"), Equals, "10\n")
c.Check(s.populatedData("20"), Equals, "20\n")
c.Check(s.populatedData("10.old"), Equals, "")
}
func (s *copydataSuite) TestCopyDataDoIdempotent(c *C) {
// make sure that a retry wouldn't stumble on partial work
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
s.populateData(c, snap.R(10))
homedir := s.populateHomeData(c, "user1", snap.R(10))
// pretend we install a new version
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
// copy data
err := s.be.CopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
err = s.be.CopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
v2data := filepath.Join(dirs.SnapDataDir, "hello/20")
l, err := filepath.Glob(filepath.Join(v2data, "*"))
c.Assert(err, IsNil)
c.Assert(l, HasLen, 1)
v2HomeData := filepath.Join(homedir, "hello/20")
l, err = filepath.Glob(filepath.Join(v2HomeData, "*"))
c.Assert(err, IsNil)
c.Assert(l, HasLen, 1)
}
func (s *copydataSuite) TestCopyDataDoUndo(c *C) {
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
s.populateData(c, snap.R(10))
homedir := s.populateHomeData(c, "user1", snap.R(10))
// pretend we install a new version
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
// copy data
err := s.be.CopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
v2data := filepath.Join(dirs.SnapDataDir, "hello/20")
l, err := filepath.Glob(filepath.Join(v2data, "*"))
c.Assert(err, IsNil)
c.Assert(l, HasLen, 1)
v2HomeData := filepath.Join(homedir, "hello/20")
l, err = filepath.Glob(filepath.Join(v2HomeData, "*"))
c.Assert(err, IsNil)
c.Assert(l, HasLen, 1)
err = s.be.UndoCopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
// now removed
_, err = os.Stat(v2data)
c.Assert(os.IsNotExist(err), Equals, true)
_, err = os.Stat(v2HomeData)
c.Assert(os.IsNotExist(err), Equals, true)
}
func (s *copydataSuite) TestCopyDataUndoIdempotent(c *C) {
// make sure that a retry wouldn't stumble on partial work
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
s.populateData(c, snap.R(10))
homedir := s.populateHomeData(c, "user1", snap.R(10))
// pretend we install a new version
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
// copy data
err := s.be.CopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
v2data := filepath.Join(dirs.SnapDataDir, "hello/20")
err = s.be.UndoCopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
err = s.be.UndoCopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
// now removed
_, err = os.Stat(v2data)
c.Assert(os.IsNotExist(err), Equals, true)
v2HomeData := filepath.Join(homedir, "hello/20")
_, err = os.Stat(v2HomeData)
c.Assert(os.IsNotExist(err), Equals, true)
}
// ensure that even with no home dir there is no error and the
// system data gets copied
func (s *copydataSuite) TestCopyDataNoUserHomes(c *C) {
// this home dir path does not exist
oldSnapDataHomeGlob := dirs.SnapDataHomeGlob
defer func() { dirs.SnapDataHomeGlob = oldSnapDataHomeGlob }()
dirs.SnapDataHomeGlob = filepath.Join(s.tempdir, "no-such-home", "*", "snap")
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
err := s.be.CopySnapData(v1, nil, &s.nullProgress)
c.Assert(err, IsNil)
canaryDataFile := filepath.Join(v1.DataDir(), "canary.txt")
err = ioutil.WriteFile(canaryDataFile, []byte(""), 0644)
c.Assert(err, IsNil)
canaryDataFile = filepath.Join(v1.CommonDataDir(), "canary.common")
err = ioutil.WriteFile(canaryDataFile, []byte(""), 0644)
c.Assert(err, IsNil)
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
err = s.be.CopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
_, err = os.Stat(filepath.Join(v2.DataDir(), "canary.txt"))
c.Assert(err, IsNil)
_, err = os.Stat(filepath.Join(v2.CommonDataDir(), "canary.common"))
c.Assert(err, IsNil)
// sanity atm
c.Check(v1.DataDir(), Not(Equals), v2.DataDir())
c.Check(v1.CommonDataDir(), Equals, v2.CommonDataDir())
}
func (s *copydataSuite) TestCopyDataBails(c *C) {
oldSnapDataHomeGlob := dirs.SnapDataHomeGlob
defer func() { dirs.SnapDataHomeGlob = oldSnapDataHomeGlob }()
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
c.Assert(s.be.CopySnapData(v1, nil, &s.nullProgress), IsNil)
c.Assert(os.Chmod(v1.DataDir(), 0), IsNil)
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
err := s.be.CopySnapData(v2, v1, &s.nullProgress)
c.Check(err, ErrorMatches, "cannot copy .*")
}
func (s *copydataSuite) TestCopyData(c *C) {
homedir := filepath.Join(s.tempdir, "home", "user1", "snap")
homeData := filepath.Join(homedir, "hello/10")
err := os.MkdirAll(homeData, 0755)
c.Assert(err, IsNil)
homeCommonData := filepath.Join(homedir, "hello/common")
err = os.MkdirAll(homeCommonData, 0755)
c.Assert(err, IsNil)
canaryData := []byte("ni ni ni")
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
// just creates data dirs in this case
err = s.be.CopySnapData(v1, nil, &s.nullProgress)
c.Assert(err, IsNil)
canaryDataFile := filepath.Join(v1.DataDir(), "canary.txt")
err = ioutil.WriteFile(canaryDataFile, canaryData, 0644)
c.Assert(err, IsNil)
canaryDataFile = filepath.Join(v1.CommonDataDir(), "canary.common")
err = ioutil.WriteFile(canaryDataFile, canaryData, 0644)
c.Assert(err, IsNil)
err = ioutil.WriteFile(filepath.Join(homeData, "canary.home"), canaryData, 0644)
c.Assert(err, IsNil)
err = ioutil.WriteFile(filepath.Join(homeCommonData, "canary.common_home"), canaryData, 0644)
c.Assert(err, IsNil)
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
err = s.be.CopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, IsNil)
newCanaryDataFile := filepath.Join(dirs.SnapDataDir, "hello/20", "canary.txt")
content, err := ioutil.ReadFile(newCanaryDataFile)
c.Assert(err, IsNil)
c.Assert(content, DeepEquals, canaryData)
// ensure common data file is still there (even though it didn't get copied)
newCanaryDataFile = filepath.Join(dirs.SnapDataDir, "hello", "common", "canary.common")
content, err = ioutil.ReadFile(newCanaryDataFile)
c.Assert(err, IsNil)
c.Assert(content, DeepEquals, canaryData)
newCanaryDataFile = filepath.Join(homedir, "hello/20", "canary.home")
content, err = ioutil.ReadFile(newCanaryDataFile)
c.Assert(err, IsNil)
c.Assert(content, DeepEquals, canaryData)
// ensure home common data file is still there (even though it didn't get copied)
newCanaryDataFile = filepath.Join(homedir, "hello", "common", "canary.common_home")
content, err = ioutil.ReadFile(newCanaryDataFile)
c.Assert(err, IsNil)
c.Assert(content, DeepEquals, canaryData)
}
func (s *linkSuite) TestLinkDoUndoCurrentSymlink(c *C) {
const yaml = `name: hello
version: 1.0
`
info := snaptest.MockSnap(c, yaml, &snap.SideInfo{Revision: snap.R(11)})
err := s.be.LinkSnap(info)
c.Assert(err, IsNil)
mountDir := info.MountDir()
dataDir := info.DataDir()
currentActiveSymlink := filepath.Join(mountDir, "..", "current")
currentActiveDir, err := filepath.EvalSymlinks(currentActiveSymlink)
c.Assert(err, IsNil)
c.Assert(currentActiveDir, Equals, mountDir)
currentDataSymlink := filepath.Join(dataDir, "..", "current")
currentDataDir, err := filepath.EvalSymlinks(currentDataSymlink)
c.Assert(err, IsNil)
c.Assert(currentDataDir, Equals, dataDir)
// undo will remove the symlinks
err = s.be.UnlinkSnap(info, &s.nullProgress)
c.Assert(err, IsNil)
c.Check(osutil.FileExists(currentActiveSymlink), Equals, false)
c.Check(osutil.FileExists(currentDataSymlink), Equals, false)
}
func (s *interfaceManagerSuite) mockSnap(c *C, yamlText string) *snap.Info {
sideInfo := &snap.SideInfo{
Revision: snap.R(1),
}
snapInfo := snaptest.MockSnap(c, yamlText, "", sideInfo)
sideInfo.RealName = snapInfo.Name()
a, err := s.db.FindMany(asserts.SnapDeclarationType, map[string]string{
"snap-name": sideInfo.RealName,
})
if err == nil {
decl := a[0].(*asserts.SnapDeclaration)
snapInfo.SnapID = decl.SnapID()
sideInfo.SnapID = decl.SnapID()
} else if err == asserts.ErrNotFound {
err = nil
}
c.Assert(err, IsNil)
s.state.Lock()
defer s.state.Unlock()
// Put a side info into the state
snapstate.Set(s.state, snapInfo.Name(), &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{sideInfo},
Current: sideInfo.Revision,
})
return snapInfo
}
func (s *SnapSuite) TestSnapRunHookMissingHookIntegration(c *check.C) {
// mock installed snap
dirs.SetRootDir(c.MkDir())
defer func() { dirs.SetRootDir("/") }()
// Only create revision 42
snaptest.MockSnap(c, string(mockYaml), &snap.SideInfo{
Revision: snap.R(42),
})
// and mock the server
s.mockServer(c)
// redirect exec
called := false
restorer := snaprun.MockSyscallExec(func(arg0 string, args []string, envv []string) error {
called = true
return nil
})
defer restorer()
err := snaprun.SnapRunHook("snapname", "unset", "missing-hook")
c.Assert(err, check.IsNil)
c.Check(called, check.Equals, false)
}
func (s *apiSuite) mockSnap(c *C, yamlText string) *snap.Info {
if s.d == nil {
panic("call s.daemon(c) in your test first")
}
snapInfo := snaptest.MockSnap(c, yamlText, &snap.SideInfo{Revision: snap.R(1)})
snap.AddImplicitSlots(snapInfo)
st := s.d.overlord.State()
st.Lock()
defer st.Unlock()
// Put a side info into the state
snapstate.Set(st, snapInfo.Name(), &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{
{
RealName: snapInfo.Name(),
Revision: snapInfo.Revision,
SnapID: "ididid",
},
},
Current: snapInfo.Revision,
})
// Put the snap into the interface repository
repo := s.d.overlord.InterfaceManager().Repository()
err := repo.AddSnap(snapInfo)
c.Assert(err, IsNil)
return snapInfo
}
func (s *SnapSuite) TestSnapRunAppWithCommandIntegration(c *check.C) {
// mock installed snap
dirs.SetRootDir(c.MkDir())
defer func() { dirs.SetRootDir("/") }()
si := snaptest.MockSnap(c, string(mockYaml), &snap.SideInfo{
Revision: snap.R(42),
})
err := os.Symlink(si.MountDir(), filepath.Join(si.MountDir(), "../current"))
c.Assert(err, check.IsNil)
// redirect exec
execArg0 := ""
execArgs := []string{}
execEnv := []string{}
restorer := snaprun.MockSyscallExec(func(arg0 string, args []string, envv []string) error {
execArg0 = arg0
execArgs = args
execEnv = envv
return nil
})
defer restorer()
// and run it!
err = snaprun.SnapRunApp("snapname.app", "my-command", []string{"arg1", "arg2"})
c.Assert(err, check.IsNil)
c.Check(execArg0, check.Equals, filepath.Join(dirs.LibExecDir, "snap-confine"))
c.Check(execArgs, check.DeepEquals, []string{
filepath.Join(dirs.LibExecDir, "snap-confine"),
"snap.snapname.app",
filepath.Join(dirs.LibExecDir, "snap-exec"),
"--command=my-command", "snapname.app", "arg1", "arg2"})
c.Check(execEnv, testutil.Contains, "SNAP_REVISION=42")
}
func (s *SnapSuite) TestSnapRunHookUnsetRevisionIntegration(c *check.C) {
// mock installed snap
dirs.SetRootDir(c.MkDir())
defer func() { dirs.SetRootDir("/") }()
si := snaptest.MockSnap(c, string(mockYaml), &snap.SideInfo{
Revision: snap.R(42),
})
err := os.Symlink(si.MountDir(), filepath.Join(si.MountDir(), "../current"))
c.Assert(err, check.IsNil)
// redirect exec
execArg0 := ""
execArgs := []string{}
execEnv := []string{}
restorer := snaprun.MockSyscallExec(func(arg0 string, args []string, envv []string) error {
execArg0 = arg0
execArgs = args
execEnv = envv
return nil
})
defer restorer()
// Specifically pass "unset" which would use the active version.
_, err = snaprun.Parser().ParseArgs([]string{"run", "--hook=configure", "-r=unset", "snapname"})
c.Assert(err, check.IsNil)
c.Check(execArg0, check.Equals, filepath.Join(dirs.LibExecDir, "snap-confine"))
c.Check(execArgs, check.DeepEquals, []string{
filepath.Join(dirs.LibExecDir, "snap-confine"),
"snap.snapname.hook.configure",
filepath.Join(dirs.LibExecDir, "snap-exec"),
"--hook=configure", "snapname"})
c.Check(execEnv, testutil.Contains, "SNAP_REVISION=42")
}
func (s *snapExecSuite) TestSnapExecHookRealIntegration(c *C) {
// we need a lot of mocks
dirs.SetRootDir(c.MkDir())
oldOsArgs := os.Args
defer func() { os.Args = oldOsArgs }()
os.Setenv("SNAP_REVISION", "42")
defer os.Unsetenv("SNAP_REVISION")
canaryFile := filepath.Join(c.MkDir(), "canary.txt")
testSnap := snaptest.MockSnap(c, string(mockHookYaml), &snap.SideInfo{
Revision: snap.R("42"),
})
hookPath := filepath.Join("meta", "hooks", "configure")
hookPathAndContents := []string{hookPath, fmt.Sprintf(binaryTemplate, canaryFile)}
snaptest.PopulateDir(testSnap.MountDir(), [][]string{hookPathAndContents})
hookPath = filepath.Join(testSnap.MountDir(), hookPath)
c.Assert(os.Chmod(hookPath, 0755), IsNil)
// we can not use the real syscall.execv here because it would
// replace the entire test :)
syscallExec = actuallyExec
// run it
os.Args = []string{"snap-exec", "--hook=configure", "snapname"}
err := run()
c.Assert(err, IsNil)
output, err := ioutil.ReadFile(canaryFile)
c.Assert(err, IsNil)
c.Assert(string(output), Equals, "configure\n\n")
}
func (s *SnapSuite) setupGetTests(c *check.C) {
snaptest.MockSnap(c, string(basicYaml), &snap.SideInfo{
Revision: snap.R(42),
})
// and mock the server
s.mockGetConfigServer(c)
}
func (s *copydataSuite) TestCopyDataCopyFailure(c *C) {
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
s.populateData(c, snap.R(10))
// pretend we install a new version
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
defer testutil.MockCommand(c, "cp", "echo cp: boom; exit 3").Restore()
q := func(s string) string {
return regexp.QuoteMeta(strconv.Quote(s))
}
// copy data will fail
err := s.be.CopySnapData(v2, v1, &s.nullProgress)
c.Assert(err, ErrorMatches, fmt.Sprintf(`cannot copy %s to %s: .*: "cp: boom" \(3\)`, q(v1.DataDir()), q(v2.DataDir())))
}
func (s *gadgetYamlTestSuite) TestReadGadgetYamlMissingBootloader(c *C) {
info := snaptest.MockSnap(c, mockGadgetSnapYaml, &snap.SideInfo{Revision: snap.R(42)})
err := ioutil.WriteFile(filepath.Join(info.MountDir(), "meta", "gadget.yaml"), nil, 0644)
c.Assert(err, IsNil)
_, err = snap.ReadGadgetInfo(info)
c.Assert(err, ErrorMatches, "cannot read gadget snap details: bootloader not declared in any volume")
}
func (s *snapExecSuite) TestSnapExecHookMissingHookIntegration(c *C) {
dirs.SetRootDir(c.MkDir())
snaptest.MockSnap(c, string(mockHookYaml), &snap.SideInfo{
Revision: snap.R("42"),
})
err := snapExecHook("snapname", "42", "missing-hook")
c.Assert(err, NotNil)
c.Assert(err, ErrorMatches, "cannot find hook \"missing-hook\" in \"snapname\"")
}
// SetNextBoot should do nothing on classic LP: #1580403
func (s *kernelOSSuite) TestSetNextBootOnClassic(c *C) {
restore := release.MockOnClassic(true)
defer restore()
// Create a fake OS snap that we try to update
snapInfo := snaptest.MockSnap(c, "name: os\ntype: os", "SNAP", &snap.SideInfo{Revision: snap.R(42)})
err := boot.SetNextBoot(snapInfo)
c.Assert(err, IsNil)
c.Assert(s.bootloader.BootVars, HasLen, 0)
}
func (bs *bootedSuite) makeInstalledKernelOS(c *C, st *state.State) {
snaptest.MockSnap(c, "name: core\ntype: os\nversion: 1", osSI1)
snaptest.MockSnap(c, "name: core\ntype: os\nversion: 2", osSI2)
snapstate.Set(st, "core", &snapstate.SnapState{
SnapType: "os",
Active: true,
Sequence: []*snap.SideInfo{osSI1, osSI2},
Current: snap.R(2),
})
snaptest.MockSnap(c, "name: canonical-pc-linux\ntype: os\nversion: 1", kernelSI1)
snaptest.MockSnap(c, "name: canonical-pc-linux\ntype: os\nversion: 2", kernelSI2)
snapstate.Set(st, "canonical-pc-linux", &snapstate.SnapState{
SnapType: "kernel",
Active: true,
Sequence: []*snap.SideInfo{kernelSI1, kernelSI2},
Current: snap.R(2),
})
}
func (s *SnapSuite) TestSnapRunHookSpecificRevisionIntegration(c *check.C) {
// mock installed snap
dirs.SetRootDir(c.MkDir())
defer func() { dirs.SetRootDir("/") }()
// Create both revisions 41 and 42
snaptest.MockSnap(c, string(mockYaml), &snap.SideInfo{
Revision: snap.R(41),
})
snaptest.MockSnap(c, string(mockYaml), &snap.SideInfo{
Revision: snap.R(42),
})
// and mock the server
s.mockServer(c)
// redirect exec
execArg0 := ""
execArgs := []string{}
execEnv := []string{}
restorer := snaprun.MockSyscallExec(func(arg0 string, args []string, envv []string) error {
execArg0 = arg0
execArgs = args
execEnv = envv
return nil
})
defer restorer()
// Run a hook on revision 41
_, err := snaprun.Parser().ParseArgs([]string{"run", "--hook=apply-config", "-r=41", "snapname"})
c.Assert(err, check.IsNil)
c.Check(execArg0, check.Equals, "/usr/bin/ubuntu-core-launcher")
c.Check(execArgs, check.DeepEquals, []string{
"/usr/bin/ubuntu-core-launcher",
"snap.snapname.hook.apply-config",
"snap.snapname.hook.apply-config",
"/usr/lib/snapd/snap-exec",
"--hook=apply-config", "snapname"})
c.Check(execEnv, testutil.Contains, "SNAP_REVISION=41")
}
func (s *deviceMgrSuite) setupGadget(c *C, snapYaml string, snapContents string) {
sideInfoGadget := &snap.SideInfo{
RealName: "gadget",
Revision: snap.R(2),
}
snaptest.MockSnap(c, snapYaml, snapContents, sideInfoGadget)
snapstate.Set(s.state, "gadget", &snapstate.SnapState{
SnapType: "gadget",
Active: true,
Sequence: []*snap.SideInfo{sideInfoGadget},
Current: sideInfoGadget.Revision,
})
}
func (s *deviceMgrSuite) setupCore(c *C, name, snapYaml string, snapContents string) {
sideInfoCore := &snap.SideInfo{
RealName: name,
Revision: snap.R(3),
}
snaptest.MockSnap(c, snapYaml, snapContents, sideInfoCore)
snapstate.Set(s.state, name, &snapstate.SnapState{
SnapType: "os",
Active: true,
Sequence: []*snap.SideInfo{sideInfoCore},
Current: sideInfoCore.Revision,
})
}
func (s *gadgetYamlTestSuite) TestReadGadgetYamlInvalidBootloader(c *C) {
info := snaptest.MockSnap(c, mockGadgetSnapYaml, &snap.SideInfo{Revision: snap.R(42)})
mockGadgetYamlBroken := []byte(`
volumes:
name:
bootloader: silo
`)
err := ioutil.WriteFile(filepath.Join(info.MountDir(), "meta", "gadget.yaml"), mockGadgetYamlBroken, 0644)
c.Assert(err, IsNil)
_, err = snap.ReadGadgetInfo(info)
c.Assert(err, ErrorMatches, "cannot read gadget snap details: bootloader must be either grub or u-boot")
}
func (s *SnapSuite) TestSnapRunHookSpecificRevisionIntegration(c *check.C) {
// mock installed snap
dirs.SetRootDir(c.MkDir())
defer func() { dirs.SetRootDir("/") }()
// Create both revisions 41 and 42
snaptest.MockSnap(c, string(mockYaml), string(mockContents), &snap.SideInfo{
Revision: snap.R(41),
})
snaptest.MockSnap(c, string(mockYaml), string(mockContents), &snap.SideInfo{
Revision: snap.R(42),
})
// redirect exec
execArg0 := ""
execArgs := []string{}
execEnv := []string{}
restorer := snaprun.MockSyscallExec(func(arg0 string, args []string, envv []string) error {
execArg0 = arg0
execArgs = args
execEnv = envv
return nil
})
defer restorer()
// Run a hook on revision 41
_, err := snaprun.Parser().ParseArgs([]string{"run", "--hook=configure", "-r=41", "snapname"})
c.Assert(err, check.IsNil)
c.Check(execArg0, check.Equals, filepath.Join(dirs.LibExecDir, "snap-confine"))
c.Check(execArgs, check.DeepEquals, []string{
filepath.Join(dirs.LibExecDir, "snap-confine"),
"snap.snapname.hook.configure",
filepath.Join(dirs.LibExecDir, "snap-exec"),
"--hook=configure", "snapname"})
c.Check(execEnv, testutil.Contains, "SNAP_REVISION=41")
}
func (s *copydataSuite) TestCopyDataDoABA(c *C) {
v1 := snaptest.MockSnap(c, helloYaml1, helloContents, &snap.SideInfo{Revision: snap.R(10)})
s.populateData(c, snap.R(10))
c.Check(s.populatedData("10"), Equals, "10\n")
// pretend we install a new version
v2 := snaptest.MockSnap(c, helloYaml2, helloContents, &snap.SideInfo{Revision: snap.R(20)})
// and write our own data to it
s.populateData(c, snap.R(20))
c.Check(s.populatedData("20"), Equals, "20\n")
// and now we pretend to refresh back to v1 (r10)
c.Check(s.be.CopySnapData(v1, v2, &s.nullProgress), IsNil)
// so 10 now has 20's data
c.Check(s.populatedData("10"), Equals, "20\n")
// but we still have the trash
c.Check(s.populatedData("10.old"), Equals, "10\n")
// but cleanup cleans it up, huzzah
s.be.ClearTrashedData(v1)
c.Check(s.populatedData("10.old"), Equals, "")
}
func (s *binariesTestSuite) TestAddSnapBinariesAndRemove(c *C) {
info := snaptest.MockSnap(c, packageHello, &snap.SideInfo{Revision: snap.R(11)})
err := wrappers.AddSnapBinaries(info)
c.Assert(err, IsNil)
link := filepath.Join(s.tempdir, "/snap/bin/hello-snap.hello")
target, err := os.Readlink(link)
c.Assert(err, IsNil)
c.Check(target, Equals, "/usr/bin/snap")
err = wrappers.RemoveSnapBinaries(info)
c.Assert(err, IsNil)
c.Check(osutil.FileExists(link), Equals, false)
}
func (s *infoSuite) TestReadInfo(c *C) {
si := &snap.SideInfo{Revision: snap.R(42), EditedSummary: "esummary"}
snapInfo1 := snaptest.MockSnap(c, sampleYaml, sampleContents, si)
snapInfo2, err := snap.ReadInfo("sample", si)
c.Assert(err, IsNil)
c.Check(snapInfo2.Name(), Equals, "sample")
c.Check(snapInfo2.Revision, Equals, snap.R(42))
c.Check(snapInfo2.Summary(), Equals, "esummary")
c.Check(snapInfo2.Apps["app"].Command, Equals, "foo")
c.Check(snapInfo2, DeepEquals, snapInfo1)
}
func (s *SnapSuite) TestSnapSetIntegrationJson(c *check.C) {
// mock installed snap
dirs.SetRootDir(c.MkDir())
defer func() { dirs.SetRootDir("/") }()
snaptest.MockSnap(c, string(validApplyYaml), &snap.SideInfo{
Revision: snap.R(42),
})
// and mock the server
s.mockSetConfigServer(c, map[string]interface{}{"subkey": "value"})
// Set a config value for the active snap
_, err := snapset.Parser().ParseArgs([]string{"set", "snapname", `key={"subkey":"value"}`})
c.Assert(err, check.IsNil)
}
