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) }