func (s *kernelTestSuite) SetUpTest(c *C) {
dirs.SetRootDir(c.MkDir())
s.bootloader = newMockBootloader(c.MkDir())
findBootloader = func() (partition.Bootloader, error) {
return s.bootloader, nil
}
}
func (t *CreateTestSuite) SetUpTest(c *C) {
t.BaseTest.SetUpTest(c)
dirs.SetRootDir(c.MkDir())
// mock the chroot handler
origRunInChroot := runInChroot
t.AddCleanup(func() { runInChroot = origRunInChroot })
runInChroot = func(chroot string, cmd ...string) error {
t.runInChroot = append(t.runInChroot, cmd)
return nil
}
// create some content for the webserver
r := makeMockLxdTarball(c)
t.AddCleanup(func() { r.Close() })
t.imageReader = r
// ensure getgrnam is called
getgrnamOrig := getgrnam
getgrnam = func(name string) (osutil.Group, error) {
t.getgrnamCalled = append(t.getgrnamCalled, name)
return osutil.Group{}, nil
}
t.AddCleanup(func() { getgrnam = getgrnamOrig })
}
func (s *SnapTestSuite) SetUpTest(c *C) {
s.secbase = policy.SecBase
s.tempdir = c.MkDir()
dirs.SetRootDir(s.tempdir)
policy.SecBase = filepath.Join(s.tempdir, "security")
os.MkdirAll(dirs.SnapServicesDir, 0755)
os.MkdirAll(dirs.SnapSeccompDir, 0755)
os.MkdirAll(dirs.SnapSnapsDir, 0755)
release.Override(release.Release{Flavor: "core", Series: "15.04"})
// create a fake systemd environment
os.MkdirAll(filepath.Join(dirs.SnapServicesDir, "multi-user.target.wants"), 0755)
systemd.SystemctlCmd = func(cmd ...string) ([]byte, error) {
return []byte("ActiveState=inactive\n"), nil
}
// fake udevadm
runUdevAdm = func(args ...string) error {
return nil
}
// do not attempt to hit the real store servers in the tests
nowhereURI, _ := url.Parse("")
s.storeCfg = &store.SnapUbuntuStoreConfig{
SearchURI: nowhereURI,
BulkURI: nowhereURI,
}
storeConfig = s.storeCfg
}
func (s *apiSuite) SetUpTest(c *check.C) {
dirs.SetRootDir(c.MkDir())
s.parts = nil
s.err = nil
s.vars = nil
}
func (s *FirstBootTestSuite) SetUpTest(c *C) {
tempdir := c.MkDir()
dirs.SetRootDir(tempdir)
stampFile = filepath.Join(c.MkDir(), "stamp")
// mock the world!
makeMockSecurityEnv(c)
runAppArmorParser = mockRunAppArmorParser
systemd.SystemctlCmd = func(cmd ...string) ([]byte, error) {
return []byte("ActiveState=inactive\n"), nil
}
err := os.MkdirAll(filepath.Join(tempdir, "etc", "systemd", "system", "multi-user.target.wants"), 0755)
c.Assert(err, IsNil)
configMyApp := make(SystemConfig)
configMyApp["hostname"] = "myhostname"
s.gadgetConfig = make(SystemConfig)
s.gadgetConfig["myapp"] = configMyApp
s.globs = globs
globs = nil
s.ethdir = ethdir
ethdir = c.MkDir()
s.ifup = ifup
ifup = "/bin/true"
getGadget = s.getGadget
newPartMap = s.newPartMap
s.m = nil
s.e = nil
s.partMap = nil
s.partMapErr = nil
}
func (s *appArmorSuite) TestUnloadRemovesCachedProfile(c *C) {
cmd := testutil.MockCommand(c, "apparmor_parser", "")
defer cmd.Restore()
dirs.SetRootDir(c.MkDir())
defer dirs.SetRootDir("")
err := os.MkdirAll(dirs.AppArmorCacheDir, 0755)
c.Assert(err, IsNil)
fname := filepath.Join(dirs.AppArmorCacheDir, "profile")
ioutil.WriteFile(fname, []byte("blob"), 0600)
err = apparmor.UnloadProfile("profile")
c.Assert(err, IsNil)
_, err = os.Stat(fname)
c.Check(os.IsNotExist(err), Equals, true)
}
func (s *ServiceActorSuite) SetUpTest(c *C) {
// force UTC timezone, for reproducible timestamps
os.Setenv("TZ", "")
dirs.SetRootDir(c.MkDir())
// TODO: this mkdir hack is so enable doesn't fail; remove when enable is the same as the rest
c.Assert(os.MkdirAll(filepath.Join(dirs.GlobalRootDir, "/etc/systemd/system/multi-user.target.wants"), 0755), IsNil)
systemd.SystemctlCmd = s.myRun
systemd.JournalctlCmd = s.myJctl
_, err := makeInstalledMockSnap(dirs.GlobalRootDir, `name: hello-app
version: 1.09
services:
- name: svc1
start: bin/hello
`)
c.Assert(err, IsNil)
f, err := makeInstalledMockSnap(dirs.GlobalRootDir, `name: hello-app
version: 1.10
services:
- name: svc1
start: bin/hello
`)
c.Assert(err, IsNil)
c.Assert(makeSnapActive(f), IsNil)
s.i = 0
s.argses = nil
s.errors = nil
s.outs = nil
s.j = 0
s.jsvcs = nil
s.jouts = nil
s.jerrs = nil
s.pb = &MockProgressMeter{}
}
func (s *interfaceManagerSuite) TearDownTest(c *C) {
if s.privateMgr != nil {
s.privateMgr.Stop()
}
dirs.SetRootDir("")
s.restoreBackends()
}
func (s *PartitionTestSuite) SetUpTest(c *C) {
dirs.SetRootDir(c.MkDir())
err := os.MkdirAll((&grub{}).Dir(), 0755)
c.Assert(err, IsNil)
err = os.MkdirAll((&uboot{}).Dir(), 0755)
c.Assert(err, IsNil)
}
func (s *SnapfsTestSuite) SetUpTest(c *C) {
// mocks
aaClickHookCmd = "/bin/true"
dirs.SetRootDir(c.MkDir())
// ensure we use the right builder func (snapfs)
snapBuilderFunc = BuildSnapfsSnap
}
func (s *apiSuite) SetUpTest(c *check.C) {
dirs.SetRootDir(c.MkDir())
c.Assert(os.MkdirAll(filepath.Dir(dirs.SnapLockFile), 0755), check.IsNil)
s.parts = nil
s.err = nil
s.vars = nil
}
func (s *ServiceActorSuite) TestFindServicesNoPackagesNoPattern(c *C) {
// tricky way of hiding the installed package ;)
dirs.SetRootDir(c.MkDir())
actor, err := FindServices("", "", s.pb)
c.Check(err, IsNil)
c.Assert(actor, NotNil)
c.Check(actor.(*serviceActor).svcs, HasLen, 0)
}
func (s *interfaceManagerSuite) SetUpTest(c *C) {
dirs.SetRootDir(c.MkDir())
state := state.New(nil)
s.state = state
s.privateMgr = nil
s.extraIfaces = nil
s.secBackend = &interfaces.TestSecurityBackend{}
s.restoreBackends = ifacestate.MockSecurityBackends([]interfaces.SecurityBackend{s.secBackend})
}
func (s *undoTestSuite) SetUpTest(c *C) {
dirs.SetRootDir(c.MkDir())
err := os.MkdirAll(filepath.Join(dirs.GlobalRootDir, "etc", "systemd", "system", "multi-user.target.wants"), 0755)
c.Assert(err, IsNil)
systemd.SystemctlCmd = func(cmd ...string) ([]byte, error) {
return []byte("ActiveState=inactive\n"), nil
}
}
func (cs *clientSuite) SetUpTest(c *check.C) {
cs.cli = client.New(nil)
cs.cli.SetDoer(cs)
cs.err = nil
cs.rsp = ""
cs.req = nil
cs.header = nil
cs.status = http.StatusOK
dirs.SetRootDir(c.MkDir())
}
func init() {
// init the global directories at startup
root := os.Getenv("SNAPPY_GLOBAL_ROOT")
if root == "" {
root = "/"
}
dirs.SetRootDir(root)
// we don't need to care for the error here to take into account when
// initialized on a non snappy system
release.Setup(dirs.GlobalRootDir)
}
func (s *BuildTestSuite) SetUpTest(c *C) {
s.BaseTest.SetUpTest(c)
// chdir into a tempdir
pwd, err := os.Getwd()
c.Assert(err, IsNil)
s.AddCleanup(func() { os.Chdir(pwd) })
err = os.Chdir(c.MkDir())
c.Assert(err, IsNil)
// use fake root
dirs.SetRootDir(c.MkDir())
}
func (s *backendSuite) SetUpTest(c *C) {
// Isolate this test to a temporary directory
s.rootDir = c.MkDir()
dirs.SetRootDir(s.rootDir)
// Prepare a directory for DBus configuration files.
// NOTE: Normally this is a part of the OS snap.
err := os.MkdirAll(dirs.SnapBusPolicyDir, 0700)
c.Assert(err, IsNil)
// Create a fresh repository for each test
s.repo = interfaces.NewRepository()
s.iface = &interfaces.TestInterface{InterfaceName: "iface"}
err = s.repo.AddInterface(s.iface)
c.Assert(err, IsNil)
}
func (s *SnapTestSuite) SetUpTest(c *C) {
s.secbase = policy.SecBase
s.tempdir = c.MkDir()
newPartition = func() (p partition.Interface) {
return new(MockPartition)
}
dirs.SetRootDir(s.tempdir)
policy.SecBase = filepath.Join(s.tempdir, "security")
os.MkdirAll(dirs.SnapServicesDir, 0755)
os.MkdirAll(dirs.SnapSeccompDir, 0755)
release.Override(release.Release{Flavor: "core", Series: "15.04"})
dirs.ClickSystemHooksDir = filepath.Join(s.tempdir, "/usr/share/click/hooks")
os.MkdirAll(dirs.ClickSystemHooksDir, 0755)
// create a fake systemd environment
os.MkdirAll(filepath.Join(dirs.SnapServicesDir, "multi-user.target.wants"), 0755)
// we may not have debsig-verify installed (and we don't need it
// for the unittests)
clickdeb.VerifyCmd = "true"
systemd.SystemctlCmd = func(cmd ...string) ([]byte, error) {
return []byte("ActiveState=inactive\n"), nil
}
// fake "du"
duCmd = makeFakeDuCommand(c)
// fake udevadm
runUdevAdm = func(args ...string) error {
return nil
}
// do not attempt to hit the real store servers in the tests
storeSearchURI, _ = url.Parse("")
storeDetailsURI, _ = url.Parse("")
storeBulkURI, _ = url.Parse("")
aaExec = filepath.Join(s.tempdir, "aa-exec")
err := ioutil.WriteFile(aaExec, []byte(mockAaExecScript), 0755)
c.Assert(err, IsNil)
runAppArmorParser = mockRunAppArmorParser
makeMockSecurityEnv(c)
}
func (s *purgeSuite) SetUpTest(c *C) {
s.tempdir = c.MkDir()
dirs.SetRootDir(s.tempdir)
os.MkdirAll(dirs.SnapMetaDir, 0755)
os.MkdirAll(filepath.Join(dirs.SnapServicesDir, "multi-user.target.wants"), 0755)
systemd.SystemctlCmd = func(cmd ...string) ([]byte, error) {
return []byte("ActiveState=inactive\n"), nil
}
dirs.SnapSeccompDir = c.MkDir()
dirs.SnapAppArmorDir = c.MkDir()
runAppArmorParser = mockRunAppArmorParser
makeMockSecurityEnv(c)
}
func (s *PartitionTestSuite) SetUpTest(c *C) {
s.tempdir = c.MkDir()
runLsblk = mockRunLsblkDualSnappy
// custom mount target
mountTarget = c.MkDir()
// global roto
dirs.SetRootDir(s.tempdir)
err := os.MkdirAll(bootloaderGrubDir(), 0755)
c.Assert(err, IsNil)
err = os.MkdirAll(bootloaderUbootDir(), 0755)
c.Assert(err, IsNil)
c.Assert(mounts, DeepEquals, mountEntryArray(nil))
}
func (s *backendSuite) SetUpTest(c *C) {
// Isolate this test to a temporary directory
s.rootDir = c.MkDir()
dirs.SetRootDir(s.rootDir)
// Mock away any real udev interaction
s.udevadmCmd = testutil.MockCommand(c, "udevadm", "")
// Prepare a directory for udev rules
// NOTE: Normally this is a part of the OS snap.
err := os.MkdirAll(dirs.SnapUdevRulesDir, 0700)
c.Assert(err, IsNil)
// Create a fresh repository for each test
s.repo = interfaces.NewRepository()
s.iface = &interfaces.TestInterface{InterfaceName: "iface"}
err = s.repo.AddInterface(s.iface)
c.Assert(err, IsNil)
}
func (s *lightweightSuite) SetUpTest(c *check.C) {
s.d = c.MkDir()
dirs.SetRootDir(s.d)
s.MkInstalled(c, snap.TypeApp, dirs.SnapSnapsDir, "foo", "bar", "1.0", true)
s.MkRemoved(c, "foo.bar", "0.9")
s.MkRemoved(c, "foo.baz", "0.8")
s.MkInstalled(c, snap.TypeFramework, dirs.SnapSnapsDir, "fmk", "", "123", false)
s.MkInstalled(c, snap.TypeFramework, dirs.SnapSnapsDir, "fmk", "", "120", true)
s.MkInstalled(c, snap.TypeFramework, dirs.SnapSnapsDir, "fmk", "", "119", false)
s.MkRemoved(c, "fmk", "12a1")
s.MkRemoved(c, "fmk2", "4.2.0ubuntu1")
s.MkInstalled(c, snap.TypeGadget, dirs.SnapSnapsDir, "a-gadget", "", "3", false)
}
func (s *backendSuite) SetUpTest(c *C) {
// Isolate this test to a temporary directory
s.rootDir = c.MkDir()
dirs.SetRootDir(s.rootDir)
// Prepare a directory for apparmor profiles.
// NOTE: Normally this is a part of the OS snap.
err := os.MkdirAll(dirs.SnapAppArmorDir, 0700)
c.Assert(err, IsNil)
err = os.MkdirAll(dirs.AppArmorCacheDir, 0700)
c.Assert(err, IsNil)
// Mock away any real apparmor interaction
s.parserCmd = testutil.MockCommand(c, "apparmor_parser", fakeAppArmorParser)
// Create a fresh repository for each test
s.repo = interfaces.NewRepository()
s.iface = &interfaces.TestInterface{InterfaceName: "iface"}
err = s.repo.AddInterface(s.iface)
c.Assert(err, IsNil)
}
func (s *SquashfsTestSuite) SetUpTest(c *C) {
s.BaseTest.SetUpTest(c)
dirs.SetRootDir(c.MkDir())
os.MkdirAll(filepath.Join(dirs.SnapServicesDir, "multi-user.target.wants"), 0755)
// ensure we do not run a real systemd
systemd.SystemctlCmd = func(cmd ...string) ([]byte, error) {
s.systemdCmds = append(s.systemdCmds, cmd)
return []byte("ActiveState=inactive\n"), nil
}
// mock the boot variable writing for the tests
s.bootloader = newMockBootloader(c.MkDir())
findBootloader = func() (partition.Bootloader, error) {
return s.bootloader, nil
}
s.AddCleanup(func() { findBootloader = partition.FindBootloader })
}
func ExamplePartBag() {
d, _ := ioutil.TempDir("", "test-xyzzy-")
defer os.RemoveAll(d)
dirs.SetRootDir(d)
os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "0.1"), 0755)
os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "0.2"), 0755)
os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "0.5"), 0755)
os.MkdirAll(filepath.Join(dirs.SnapDataDir, "baz", "0.4"), 0755)
os.MkdirAll(filepath.Join(dirs.SnapDataDir, "qux", "0.5"), 0755)
bags := lightweight.AllPartBags()
for _, k := range []string{"foo.bar", "baz"} {
bag := bags[k]
fmt.Printf("Found %d versions for %s, type %q: %s\n",
len(bag.Versions), bag.QualifiedName(), bag.Type, bag.Versions)
}
// Output:
// Found 3 versions for foo.bar, type "app": [0.5 0.2 0.1]
// Found 1 versions for baz, type "framework": [0.4]
}
func (s *snapmgrQuerySuite) SetUpTest(c *C) {
st := state.New(nil)
st.Lock()
defer st.Unlock()
s.st = st
dirs.SetRootDir(c.MkDir())
// Write a snap.yaml with fake name
dname := filepath.Join(snap.MountDir("name1", 11), "meta")
err := os.MkdirAll(dname, 0775)
c.Assert(err, IsNil)
fname := filepath.Join(dname, "snap.yaml")
err = ioutil.WriteFile(fname, []byte(`
name: name0
version: 1.1
description: |
Lots of text`), 0644)
c.Assert(err, IsNil)
dname = filepath.Join(snap.MountDir("name1", 12), "meta")
err = os.MkdirAll(dname, 0775)
c.Assert(err, IsNil)
fname = filepath.Join(dname, "snap.yaml")
err = ioutil.WriteFile(fname, []byte(`
name: name0
version: 1.2
description: |
Lots of text`), 0644)
c.Assert(err, IsNil)
snapstate.Set(st, "name1", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{
{OfficialName: "name1", Revision: 11, EditedSummary: "s11"},
{OfficialName: "name1", Revision: 12, EditedSummary: "s12"},
},
})
}
func (s *SystemdTestSuite) SetUpTest(c *C) {
dirs.SetRootDir(c.MkDir())
err := os.MkdirAll(dirs.SnapServicesDir, 0755)
c.Assert(err, IsNil)
// force UTC timezone, for reproducible timestamps
os.Setenv("TZ", "")
SystemctlCmd = s.myRun
s.i = 0
s.argses = nil
s.errors = nil
s.outs = nil
JournalctlCmd = s.myJctl
s.j = 0
s.jsvcs = nil
s.jouts = nil
s.jerrs = nil
s.rep = new(testreporter)
}
func (s *lightweightSuite) SetUpTest(c *check.C) {
s.d = c.MkDir()
dirs.SetRootDir(s.d)
s.MkInstalled(c, pkg.TypeApp, dirs.SnapAppsDir, "foo", "bar", "1.0", true)
s.MkRemoved(c, "foo.bar", "0.9")
s.MkRemoved(c, "foo.baz", "0.8")
s.MkInstalled(c, pkg.TypeFramework, dirs.SnapAppsDir, "fmk", "", "123", false)
s.MkInstalled(c, pkg.TypeFramework, dirs.SnapAppsDir, "fmk", "", "120", true)
s.MkInstalled(c, pkg.TypeFramework, dirs.SnapAppsDir, "fmk", "", "119", false)
s.MkRemoved(c, "fmk", "12a1")
s.MkRemoved(c, "fmk2", "4.2.0ubuntu1")
s.MkInstalled(c, pkg.TypeOem, dirs.SnapOemDir, "an-oem", "", "3", false)
newCoreRepo = func() repo {
// you can't ever have a removed systemimagepart, but for testing it'll do
return mockrepo{removed.New(snappy.SystemImagePartName, snappy.SystemImagePartOrigin, "1", pkg.TypeCore)}
}
}
func (s *FirstBootTestSuite) SetUpTest(c *C) {
tempdir := c.MkDir()
dirs.SetRootDir(tempdir)
os.MkdirAll(dirs.SnapSnapsDir, 0755)
stampFile = filepath.Join(c.MkDir(), "stamp")
// mock the world!
systemd.SystemctlCmd = func(cmd ...string) ([]byte, error) {
return []byte("ActiveState=inactive\n"), nil
}
err := os.MkdirAll(filepath.Join(tempdir, "etc", "systemd", "system", "multi-user.target.wants"), 0755)
c.Assert(err, IsNil)
configMyApp := make(legacygadget.SystemConfig)
configMyApp["hostname"] = "myhostname"
s.gadgetConfig = make(legacygadget.SystemConfig)
s.gadgetConfig["myapp"] = configMyApp
s.globs = globs
globs = nil
s.ethdir = ethdir
ethdir = c.MkDir()
s.ifup = ifup
ifup = "/bin/true"
getGadget = s.getGadget
newSnapMap = s.newSnapMap
newOverlord = s.newOverlord
s.fakeOverlord = &fakeOverlord{
configs: map[string]string{},
}
s.m = nil
s.e = nil
s.snapMap = nil
s.snapMapErr = nil
}