func (s *ReleaseTestSuite) TestOnClassic(c *C) {
reset := release.MockOnClassic(true)
defer reset()
c.Assert(release.OnClassic, Equals, true)
reset = release.MockOnClassic(false)
defer reset()
c.Assert(release.OnClassic, Equals, false)
}
func (s *kernelOSSuite) TestSetNextBootForKernel(c *C) {
restore := release.MockOnClassic(false)
defer restore()
info := &snap.Info{}
info.Type = snap.TypeKernel
info.RealName = "krnl"
info.Revision = snap.R(42)
err := boot.SetNextBoot(info)
c.Assert(err, IsNil)
c.Assert(s.bootloader.BootVars, DeepEquals, map[string]string{
"snap_try_kernel": "krnl_42.snap",
"snap_mode": "try",
})
s.bootloader.BootVars["snap_kernel"] = "krnl_40.snap"
s.bootloader.BootVars["snap_try_kernel"] = "krnl_42.snap"
c.Check(boot.KernelOrOsRebootRequired(info), Equals, true)
// simulate good boot
s.bootloader.BootVars["snap_kernel"] = "krnl_42.snap"
c.Check(boot.KernelOrOsRebootRequired(info), Equals, false)
}
func (s *SnapSuite) TestAutoImportAssertsNotImportedFromLoop(c *C) {
restore := release.MockOnClassic(false)
defer restore()
fakeAssertData := []byte("bad-assertion")
s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) {
// assertion is ignored, nothing is posted to this endpoint
panic("not reached")
})
fakeAssertsFn := filepath.Join(c.MkDir(), "auto-import.assert")
err := ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644)
c.Assert(err, IsNil)
mockMountInfoFmtWithLoop := `
24 0 8:18 / %s rw,relatime shared:1 - squashfs /dev/loop1 rw,errors=remount-ro,data=ordered`
content := fmt.Sprintf(mockMountInfoFmtWithLoop, filepath.Dir(fakeAssertsFn))
restore = snap.MockMountInfoPath(makeMockMountInfo(c, content))
defer restore()
rest, err := snap.Parser().ParseArgs([]string{"auto-import"})
c.Assert(err, IsNil)
c.Assert(rest, DeepEquals, []string{})
c.Check(s.Stdout(), Equals, "")
c.Check(s.Stderr(), Equals, "")
}
func (s *SnapSuite) TestAutoImportAssertsHappyNotOnClassic(c *C) {
restore := release.MockOnClassic(true)
defer restore()
fakeAssertData := []byte("my-assertion")
s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) {
c.Errorf("auto-import on classic is disabled, but something tried to do a %q with %s", r.Method, r.URL.Path)
})
fakeAssertsFn := filepath.Join(c.MkDir(), "auto-import.assert")
err := ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644)
c.Assert(err, IsNil)
mockMountInfoFmt := `
24 0 8:18 / %s rw,relatime shared:1 - ext4 /dev/sdb2 rw,errors=remount-ro,data=ordered`
content := fmt.Sprintf(mockMountInfoFmt, filepath.Dir(fakeAssertsFn))
restore = snap.MockMountInfoPath(makeMockMountInfo(c, content))
defer restore()
rest, err := snap.Parser().ParseArgs([]string{"auto-import"})
c.Assert(err, IsNil)
c.Assert(rest, DeepEquals, []string{})
c.Check(s.Stdout(), Equals, "")
c.Check(s.Stderr(), Equals, "auto-import is disabled on classic\n")
}
func (s *checkSnapSuite) TestCheckSnapGadgetNoPrior(c *C) {
reset := release.MockOnClassic(false)
defer reset()
st := state.New(nil)
st.Lock()
defer st.Unlock()
st.Set("seeded", true)
const yaml = `name: gadget
type: gadget
version: 1
`
info, err := snap.InfoFromSnapYaml([]byte(yaml))
c.Assert(err, IsNil)
var openSnapFile = func(path string, si *snap.SideInfo) (*snap.Info, snap.Container, error) {
return info, nil, nil
}
restore := snapstate.MockOpenSnapFile(openSnapFile)
defer restore()
st.Unlock()
err = snapstate.CheckSnap(st, "snap-path", nil, nil, snapstate.Flags{})
st.Lock()
c.Check(err, IsNil)
}
func (s *checkSnapSuite) TestCheckSnapGadgetCannotBeInstalledOnClassic(c *C) {
reset := release.MockOnClassic(true)
defer reset()
st := state.New(nil)
st.Lock()
defer st.Unlock()
const yaml = `name: gadget
type: gadget
version: 1
`
info, err := snap.InfoFromSnapYaml([]byte(yaml))
c.Assert(err, IsNil)
var openSnapFile = func(path string, si *snap.SideInfo) (*snap.Info, snap.Container, error) {
return info, nil, nil
}
restore := snapstate.MockOpenSnapFile(openSnapFile)
defer restore()
st.Unlock()
err = snapstate.CheckSnap(st, "snap-path", nil, nil, snapstate.Flags{})
st.Lock()
c.Check(err, ErrorMatches, "cannot install a gadget snap on classic")
}
func (s *checkSnapSuite) TestCheckSnapGadgetMissingPrior(c *C) {
err := os.MkdirAll(filepath.Dir(dirs.SnapFirstBootStamp), 0755)
c.Assert(err, IsNil)
err = ioutil.WriteFile(dirs.SnapFirstBootStamp, nil, 0644)
c.Assert(err, IsNil)
reset := release.MockOnClassic(false)
defer reset()
st := state.New(nil)
st.Lock()
defer st.Unlock()
const yaml = `name: gadget
type: gadget
version: 1
`
info, err := snap.InfoFromSnapYaml([]byte(yaml))
c.Assert(err, IsNil)
var openSnapFile = func(path string, si *snap.SideInfo) (*snap.Info, snap.Container, error) {
return info, nil, nil
}
restore := snapstate.MockOpenSnapFile(openSnapFile)
defer restore()
st.Unlock()
err = snapstate.CheckSnap(st, "snap-path", nil, 0)
st.Lock()
c.Check(err, ErrorMatches, "cannot find original gadget snap")
}
func (s *SnapSuite) TestAutoImportIntoSpoolUnhappyTooBig(c *C) {
restore := release.MockOnClassic(false)
defer restore()
dirs.SetRootDir(c.MkDir())
defer dirs.SetRootDir("")
l, err := logger.NewConsoleLog(s.stderr, 0)
c.Assert(err, IsNil)
logger.SetLogger(l)
// fake data is bigger than the default assertion limit
fakeAssertData := make([]byte, 641*1024)
// ensure we can not connect
snap.ClientConfig.BaseURL = "can-not-connect-to-this-url"
fakeAssertsFn := filepath.Join(c.MkDir(), "auto-import.assert")
err = ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644)
c.Assert(err, IsNil)
mockMountInfoFmt := `
24 0 8:18 / %s rw,relatime shared:1 - squashfs /dev/sc1 rw,errors=remount-ro,data=ordered`
content := fmt.Sprintf(mockMountInfoFmt, filepath.Dir(fakeAssertsFn))
restore = snap.MockMountInfoPath(makeMockMountInfo(c, content))
defer restore()
_, err = snap.Parser().ParseArgs([]string{"auto-import"})
c.Assert(err, ErrorMatches, "cannot queue .*, file size too big: 656384")
}
func (s *SnapSuite) TestAutoImportFromSpoolHappy(c *C) {
restore := release.MockOnClassic(false)
defer restore()
fakeAssertData := []byte("my-assertion")
n := 0
total := 2
s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) {
switch n {
case 0:
c.Check(r.Method, Equals, "POST")
c.Check(r.URL.Path, Equals, "/v2/assertions")
postData, err := ioutil.ReadAll(r.Body)
c.Assert(err, IsNil)
c.Check(postData, DeepEquals, fakeAssertData)
fmt.Fprintln(w, `{"type": "sync", "result": {"ready": true, "status": "Done"}}`)
n++
case 1:
c.Check(r.Method, Equals, "POST")
c.Check(r.URL.Path, Equals, "/v2/create-user")
postData, err := ioutil.ReadAll(r.Body)
c.Assert(err, IsNil)
c.Check(string(postData), Equals, `{"sudoer":true,"known":true}`)
fmt.Fprintln(w, `{"type": "sync", "result": [{"username": "******"}]}`)
n++
default:
c.Fatalf("unexpected request: %v (expected %d got %d)", r, total, n)
}
})
dirs.SetRootDir(c.MkDir())
defer dirs.SetRootDir("")
fakeAssertsFn := filepath.Join(dirs.SnapAssertsSpoolDir, "1234343")
err := os.MkdirAll(filepath.Dir(fakeAssertsFn), 0755)
c.Assert(err, IsNil)
err = ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644)
c.Assert(err, IsNil)
l, err := logger.NewConsoleLog(s.stderr, 0)
c.Assert(err, IsNil)
logger.SetLogger(l)
rest, err := snap.Parser().ParseArgs([]string{"auto-import"})
c.Assert(err, IsNil)
c.Assert(rest, DeepEquals, []string{})
c.Check(s.Stdout(), Equals, `created user "foo"`+"\n")
// matches because we may get a:
// "WARNING: cannot create syslog logger\n"
// in the output
c.Check(s.Stderr(), Matches, fmt.Sprintf("(?ms).*imported %s\n", fakeAssertsFn))
c.Check(n, Equals, total)
c.Check(osutil.FileExists(fakeAssertsFn), Equals, false)
}
func (s *SnapSuite) TestAutoImportAssertsHappy(c *C) {
restore := release.MockOnClassic(false)
defer restore()
fakeAssertData := []byte("my-assertion")
n := 0
total := 2
s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) {
switch n {
case 0:
c.Check(r.Method, Equals, "POST")
c.Check(r.URL.Path, Equals, "/v2/assertions")
postData, err := ioutil.ReadAll(r.Body)
c.Assert(err, IsNil)
c.Check(postData, DeepEquals, fakeAssertData)
fmt.Fprintln(w, `{"type": "sync", "result": {"ready": true, "status": "Done"}}`)
n++
case 1:
c.Check(r.Method, Equals, "POST")
c.Check(r.URL.Path, Equals, "/v2/create-user")
postData, err := ioutil.ReadAll(r.Body)
c.Assert(err, IsNil)
c.Check(string(postData), Equals, `{"sudoer":true,"known":true}`)
fmt.Fprintln(w, `{"type": "sync", "result": [{"username": "******"}]}`)
n++
default:
c.Fatalf("unexpected request: %v (expected %d got %d)", r, total, n)
}
})
fakeAssertsFn := filepath.Join(c.MkDir(), "auto-import.assert")
err := ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644)
c.Assert(err, IsNil)
mockMountInfoFmt := `
24 0 8:18 / %s rw,relatime shared:1 - ext4 /dev/sdb2 rw,errors=remount-ro,data=ordered`
content := fmt.Sprintf(mockMountInfoFmt, filepath.Dir(fakeAssertsFn))
restore = snap.MockMountInfoPath(makeMockMountInfo(c, content))
defer restore()
l, err := logger.NewConsoleLog(s.stderr, 0)
c.Assert(err, IsNil)
logger.SetLogger(l)
rest, err := snap.Parser().ParseArgs([]string{"auto-import"})
c.Assert(err, IsNil)
c.Assert(rest, DeepEquals, []string{})
c.Check(s.Stdout(), Equals, `created user "foo"`+"\n")
// matches because we may get a:
// "WARNING: cannot create syslog logger\n"
// in the output
c.Check(s.Stderr(), Matches, fmt.Sprintf("(?ms).*imported %s\n", fakeAssertsFn))
c.Check(n, Equals, total)
}
func (s *MprisInterfaceSuite) TestPermanentSlotAppArmorClassic(c *C) {
restore := release.MockOnClassic(true)
defer restore()
iface := &builtin.MprisInterface{}
snippet, err := iface.PermanentSlotSnippet(s.slot, interfaces.SecurityAppArmor)
c.Assert(err, IsNil)
c.Assert(snippet, Not(IsNil))
// verify classic rule present
c.Check(string(snippet), testutil.Contains, "# Allow unconfined clients to interact with the player on classic\n")
}
// 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 (s *DbusInterfaceSuite) TestPermanentSlotAppArmorSessionClassic(c *C) {
restore := release.MockOnClassic(true)
defer restore()
iface := &builtin.DbusInterface{}
snippet, err := iface.PermanentSlotSnippet(s.sessionSlot, interfaces.SecurityAppArmor)
c.Assert(err, IsNil)
c.Assert(snippet, Not(IsNil))
// verify classic rule
c.Check(string(snippet), testutil.Contains, "# allow us to respond to unconfined clients via \"org.test-session-slot{,.*}\"\n")
}
func (s *baseDeclSuite) TestInterimAutoConnectionHome(c *C) {
restore := release.MockOnClassic(true)
defer restore()
cand := s.connectCand(c, "home", "", "")
err := cand.CheckAutoConnect()
c.Check(err, IsNil)
release.OnClassic = false
err = cand.CheckAutoConnect()
c.Check(err, ErrorMatches, `auto-connection denied by slot rule of interface \"home\"`)
}
func (s *FirstBootTestSuite) TestFirstBootnableEther(c *C) {
release.MockOnClassic(false)
firstBootEnableFirstEtherRun := false
restore := boot.MockFirstbootInitialNetworkConfig(func() error {
firstBootEnableFirstEtherRun = true
return nil
})
defer restore()
c.Assert(boot.FirstBoot(), IsNil)
c.Assert(firstBootEnableFirstEtherRun, Equals, true)
}
func (s *InfoSnapYamlTestSuite) TestAddImplicitSlotsOnClassic(c *C) {
restore := release.MockOnClassic(true)
defer restore()
osYaml := []byte("name: ubuntu-core\ntype: os\n")
info, err := snap.InfoFromSnapYaml(osYaml)
c.Assert(err, IsNil)
snap.AddImplicitSlots(info)
c.Assert(info.Slots["unity7"].Interface, Equals, "unity7")
c.Assert(info.Slots["unity7"].Name, Equals, "unity7")
c.Assert(info.Slots["unity7"].Snap, Equals, info)
// Ensure that we have *some* implicit slots
c.Assert(len(info.Slots) > 10, Equals, true)
}
func (s *policySuite) TestOnClassicInstallation(c *C) {
r1 := release.MockOnClassic(false)
defer r1()
r2 := release.MockReleaseInfo(&release.ReleaseInfo)
defer r2()
tests := []struct {
distro string // "" => not classic
installYaml string
err string // "" => no error
}{
{"", `name: install-snap
slots:
install-slot-on-classic-distros:`, `installation not allowed by "install-slot-on-classic-distros" slot rule.*`},
{"debian", `name: install-snap
slots:
install-slot-on-classic-distros:`, ""},
{"", `name: install-snap
plugs:
install-plug-on-classic-distros:`, `installation not allowed by "install-plug-on-classic-distros" plug rule.*`},
{"debian", `name: install-snap
plugs:
install-plug-on-classic-distros:`, ""},
}
for _, t := range tests {
if t.distro == "" {
release.OnClassic = false
} else {
release.OnClassic = true
release.ReleaseInfo = release.OS{
ID: t.distro,
}
}
installSnap := snaptest.MockInfo(c, t.installYaml, nil)
cand := policy.InstallCandidate{
Snap: installSnap,
BaseDeclaration: s.baseDecl,
}
err := cand.Check()
if t.err == "" {
c.Check(err, IsNil)
} else {
c.Check(err, ErrorMatches, t.err)
}
}
}
func (bs *bootedSuite) SetUpTest(c *C) {
dirs.SetRootDir(c.MkDir())
err := os.MkdirAll(filepath.Dir(dirs.SnapStateFile), 0755)
c.Assert(err, IsNil)
// booted is not running on classic
release.MockOnClassic(false)
bs.bootloader = boottest.NewMockBootloader("mock", c.MkDir())
bs.bootloader.BootVars["snap_core"] = "ubuntu-core_2.snap"
bs.bootloader.BootVars["snap_kernel"] = "canonical-pc-linux_2.snap"
partition.ForceBootloader(bs.bootloader)
ovld, err := overlord.New()
c.Assert(err, IsNil)
bs.overlord = ovld
}
func (s *kernelOSSuite) TestSetNextBootForKernelForTheSameKernel(c *C) {
restore := release.MockOnClassic(false)
defer restore()
info := &snap.Info{}
info.Type = snap.TypeKernel
info.RealName = "krnl"
info.Revision = snap.R(40)
s.bootloader.BootVars["snap_kernel"] = "krnl_40.snap"
err := boot.SetNextBoot(info)
c.Assert(err, IsNil)
c.Assert(s.bootloader.BootVars, DeepEquals, map[string]string{
"snap_kernel": "krnl_40.snap",
})
}
func (s *kernelOSSuite) TestSetNextBootForCore(c *C) {
restore := release.MockOnClassic(false)
defer restore()
info := &snap.Info{}
info.Type = snap.TypeOS
info.RealName = "core"
info.Revision = snap.R(100)
err := boot.SetNextBoot(info)
c.Assert(err, IsNil)
c.Assert(s.bootloader.BootVars, DeepEquals, map[string]string{
"snap_try_core": "core_100.snap",
"snap_mode": "try",
})
c.Check(boot.KernelOrOsRebootRequired(info), Equals, true)
}
func (s *policySuite) TestSlotOnClassicCheckConnection(c *C) {
r1 := release.MockOnClassic(false)
defer r1()
r2 := release.MockReleaseInfo(&release.ReleaseInfo)
defer r2()
tests := []struct {
distro string // "" => not classic
iface string
err string // "" => no error
}{
{"ubuntu", "slot-on-classic-true", ""},
{"", "slot-on-classic-true", `connection not allowed by slot rule of interface "slot-on-classic-true"`},
{"", "slot-on-classic-false", ""},
{"ubuntu", "slot-on-classic-false", "connection not allowed.*"},
{"ubuntu", "slot-on-classic-distros", ""},
{"debian", "slot-on-classic-distros", ""},
{"", "slot-on-classic-distros", "connection not allowed.*"},
{"other", "slot-on-classic-distros", "connection not allowed.*"},
}
for _, t := range tests {
if t.distro == "" {
release.OnClassic = false
} else {
release.OnClassic = true
release.ReleaseInfo = release.OS{
ID: t.distro,
}
}
cand := policy.ConnectCandidate{
Plug: s.plugSnap.Plugs[t.iface],
Slot: s.slotSnap.Slots[t.iface],
BaseDeclaration: s.baseDecl,
}
err := cand.Check()
if t.err == "" {
c.Check(err, IsNil)
} else {
c.Check(err, ErrorMatches, t.err)
}
}
}
func (ms *mgrsSuite) TestInstallKernelSnapUpdatesBootloader(c *C) {
bootloader := boottest.NewMockBootloader("mock", c.MkDir())
partition.ForceBootloader(bootloader)
defer partition.ForceBootloader(nil)
restore := release.MockOnClassic(false)
defer restore()
const packageKernel = `
name: krnl
version: 4.0-1
type: kernel`
files := [][]string{
{"kernel.img", "I'm a kernel"},
{"initrd.img", "...and I'm an initrd"},
{"meta/kernel.yaml", "version: 4.2"},
}
snapPath := snaptest.MakeTestSnapWithFiles(c, packageKernel, files)
st := ms.o.State()
st.Lock()
defer st.Unlock()
ts, err := snapstate.InstallPath(st, &snap.SideInfo{RealName: "krnl"}, snapPath, "", 0)
c.Assert(err, IsNil)
chg := st.NewChange("install-snap", "...")
chg.AddAll(ts)
st.Unlock()
err = ms.o.Settle()
st.Lock()
c.Assert(err, IsNil)
c.Assert(chg.Status(), Equals, state.DoneStatus, Commentf("install-snap change failed with: %v", chg.Err()))
c.Assert(bootloader.BootVars, DeepEquals, map[string]string{
"snap_try_kernel": "krnl_x1.snap",
"snap_mode": "try",
})
}
func (s *checkSnapSuite) TestCheckSnapKernelAdditionProhibitedBySnapID(c *C) {
reset := release.MockOnClassic(false)
defer reset()
st := state.New(nil)
st.Lock()
defer st.Unlock()
si := &snap.SideInfo{RealName: "kernel", Revision: snap.R(2), SnapID: "kernel-id"}
snaptest.MockSnap(c, `
name: kernel
type: kernel
version: 1
`, si)
snapstate.Set(st, "kernel", &snapstate.SnapState{
SnapType: "kernel",
Active: true,
Sequence: []*snap.SideInfo{si},
Current: si.Revision,
})
const yaml = `name: zkernel
type: kernel
version: 2
`
info, err := snap.InfoFromSnapYaml([]byte(yaml))
info.SnapID = "zkernel-id"
c.Assert(err, IsNil)
var openSnapFile = func(path string, si *snap.SideInfo) (*snap.Info, snap.Container, error) {
return info, nil, nil
}
restore := snapstate.MockOpenSnapFile(openSnapFile)
defer restore()
st.Unlock()
err = snapstate.CheckSnap(st, "snap-path", nil, nil, snapstate.Flags{})
st.Lock()
c.Check(err, ErrorMatches, "cannot replace kernel snap with a different one")
}
func (s *checkSnapSuite) TestCheckSnapGadgetUpdateLocal(c *C) {
reset := release.MockOnClassic(false)
defer reset()
st := state.New(nil)
st.Lock()
defer st.Unlock()
si := &snap.SideInfo{RealName: "gadget", Revision: snap.R(2)}
snaptest.MockSnap(c, `
name: gadget
type: gadget
version: 1
`, si)
snapstate.Set(st, "gadget", &snapstate.SnapState{
SnapType: "gadget",
Active: true,
Sequence: []*snap.SideInfo{si},
Current: si.Revision,
})
const yaml = `name: gadget
type: gadget
version: 2
`
info, err := snap.InfoFromSnapYaml([]byte(yaml))
// no SnapID => local!
c.Assert(err, IsNil)
var openSnapFile = func(path string, si *snap.SideInfo) (*snap.Info, snap.Container, error) {
return info, nil, nil
}
restore := snapstate.MockOpenSnapFile(openSnapFile)
defer restore()
st.Unlock()
err = snapstate.CheckSnap(st, "snap-path", nil, nil, snapstate.Flags{})
st.Lock()
c.Check(err, IsNil)
}
func (bs *bootedSuite) SetUpTest(c *C) {
dirs.SetRootDir(c.MkDir())
err := os.MkdirAll(filepath.Dir(dirs.SnapStateFile), 0755)
c.Assert(err, IsNil)
// booted is not running on classic
release.MockOnClassic(false)
bs.bootloader = boottest.NewMockBootloader("mock", c.MkDir())
bs.bootloader.BootVars["snap_core"] = "core_2.snap"
bs.bootloader.BootVars["snap_kernel"] = "canonical-pc-linux_2.snap"
partition.ForceBootloader(bs.bootloader)
bs.fakeBackend = &fakeSnappyBackend{}
bs.state = state.New(nil)
bs.snapmgr, err = snapstate.Manager(bs.state)
c.Assert(err, IsNil)
bs.snapmgr.AddForeignTaskHandlers(bs.fakeBackend)
snapstate.SetSnapManagerBackend(bs.snapmgr, bs.fakeBackend)
}
func (s *SnapSuite) TestAutoImportIntoSpool(c *C) {
restore := release.MockOnClassic(false)
defer restore()
dirs.SetRootDir(c.MkDir())
defer dirs.SetRootDir("")
l, err := logger.NewConsoleLog(s.stderr, 0)
c.Assert(err, IsNil)
logger.SetLogger(l)
fakeAssertData := []byte("good-assertion")
// ensure we can not connect
snap.ClientConfig.BaseURL = "can-not-connect-to-this-url"
fakeAssertsFn := filepath.Join(c.MkDir(), "auto-import.assert")
err = ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644)
c.Assert(err, IsNil)
mockMountInfoFmt := `
24 0 8:18 / %s rw,relatime shared:1 - squashfs /dev/sc1 rw,errors=remount-ro,data=ordered`
content := fmt.Sprintf(mockMountInfoFmt, filepath.Dir(fakeAssertsFn))
restore = snap.MockMountInfoPath(makeMockMountInfo(c, content))
defer restore()
rest, err := snap.Parser().ParseArgs([]string{"auto-import"})
c.Assert(err, IsNil)
c.Assert(rest, DeepEquals, []string{})
c.Check(s.Stdout(), Equals, "")
// matches because we may get a:
// "WARNING: cannot create syslog logger\n"
// in the output
c.Check(s.Stderr(), Matches, "(?ms).*queuing for later.*\n")
files, err := ioutil.ReadDir(dirs.SnapAssertsSpoolDir)
c.Assert(err, IsNil)
c.Check(files, HasLen, 1)
c.Check(files[0].Name(), Equals, "iOkaeet50rajLvL-0Qsf2ELrTdn3XIXRIBlDewcK02zwRi3_TJlUOTl9AaiDXmDn.assert")
}
func (ms *mgrsSuite) TestInstallCoreSnapUpdatesBootloader(c *C) {
bootloader := boottest.NewMockBootloader("mock", c.MkDir())
partition.ForceBootloader(bootloader)
defer partition.ForceBootloader(nil)
restore := release.MockOnClassic(false)
defer restore()
const packageOS = `
name: core
version: 16.04-1
type: os
`
snapPath := makeTestSnap(c, packageOS)
st := ms.o.State()
st.Lock()
defer st.Unlock()
ts, err := snapstate.InstallPath(st, &snap.SideInfo{RealName: "core"}, snapPath, "", 0)
c.Assert(err, IsNil)
chg := st.NewChange("install-snap", "...")
chg.AddAll(ts)
st.Unlock()
err = ms.o.Settle()
st.Lock()
c.Assert(err, IsNil)
c.Assert(chg.Status(), Equals, state.DoneStatus, Commentf("install-snap change failed with: %v", chg.Err()))
c.Assert(bootloader.BootVars, DeepEquals, map[string]string{
"snap_try_core": "core_x1.snap",
"snap_mode": "try",
})
}
func (s *baseDeclSuite) TestConnectionOnClassic(c *C) {
restore := release.MockOnClassic(false)
defer restore()
all := builtin.Interfaces()
// connecting with these interfaces needs to be allowed on
// case-by-case basis when not on classic
noconnect := map[string]bool{
"modem-manager": true,
"network-manager": true,
"ofono": true,
"pulseaudio": true,
}
for _, onClassic := range []bool{true, false} {
release.OnClassic = onClassic
for _, iface := range all {
if !noconnect[iface.Name()] {
continue
}
expected := onClassic
comm := Commentf(iface.Name())
// check base declaration
cand := s.connectCand(c, iface.Name(), "", "")
err := cand.Check()
if expected {
c.Check(err, IsNil, comm)
} else {
c.Check(err, NotNil, comm)
}
}
}
}
func (s *linkSnapSuite) TestDoLinkSnapSuccessCoreRestarts(c *C) {
restore := release.MockOnClassic(true)
defer restore()
s.state.Lock()
si := &snap.SideInfo{
RealName: "core",
Revision: snap.R(33),
}
t := s.state.NewTask("link-snap", "test")
t.Set("snap-setup", &snapstate.SnapSetup{
SideInfo: si,
})
s.state.NewChange("dummy", "...").AddTask(t)
s.state.Unlock()
s.snapmgr.Ensure()
s.snapmgr.Wait()
s.state.Lock()
defer s.state.Unlock()
var snapst snapstate.SnapState
err := snapstate.Get(s.state, "core", &snapst)
c.Assert(err, IsNil)
typ, err := snapst.Type()
c.Check(err, IsNil)
c.Check(typ, Equals, snap.TypeOS)
c.Check(t.Status(), Equals, state.DoneStatus)
c.Check(s.stateBackend.restartRequested, Equals, true)
c.Check(t.Log(), HasLen, 1)
c.Check(t.Log()[0], Matches, `.*INFO Requested daemon restart\.`)
}
func (s *HomeInterfaceSuite) TestAutoConnectOnCore(c *C) {
restore := release.MockOnClassic(false)
defer restore()
iface := builtin.NewHomeInterface()
c.Check(iface.AutoConnect(), Equals, false)
}
