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) 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) TestCheckSnapCheckCallbackOK(c *C) {
const yaml = `name: foo
version: 1.0`
si := &snap.SideInfo{
SnapID: "snap-id",
}
var openSnapFile = func(path string, si *snap.SideInfo) (*snap.Info, snap.Container, error) {
info := snaptest.MockInfo(c, yaml, si)
return info, nil, nil
}
r1 := snapstate.MockOpenSnapFile(openSnapFile)
defer r1()
checkCbCalled := false
checkCb := func(st *state.State, s, cur *snap.Info, flags snapstate.Flags) error {
c.Assert(s.Name(), Equals, "foo")
c.Assert(s.SnapID, Equals, "snap-id")
checkCbCalled = true
return nil
}
r2 := snapstate.MockCheckSnapCallbacks([]snapstate.CheckSnapCallback{checkCb})
defer r2()
err := snapstate.CheckSnap(s.st, "snap-path", si, nil, snapstate.Flags{})
c.Check(err, IsNil)
c.Check(checkCbCalled, Equals, true)
}
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 *checkSnapSuite) TestCheckSnapInstallProvidedAssumes(c *C) {
const yaml = `name: foo
version: 1.0
assumes: [common-data-dir]`
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()
err = snapstate.CheckSnap(s.st, "snap-path", nil, nil, snapstate.Flags{})
c.Check(err, IsNil)
}
func (s *checkSnapSuite) TestCheckSnapInstallMissingAssumes(c *C) {
const yaml = `name: foo
version: 1.0
assumes: [f1, f2]`
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()
err = snapstate.CheckSnap(s.st, "snap-path", nil, nil, snapstate.Flags{})
c.Check(err, ErrorMatches, `snap "foo" assumes unsupported features: f1, f2.*`)
}
func (s *checkSnapSuite) TestCheckSnapErrorOnDevModeDisallowed(c *C) {
const yaml = `name: hello
version: 1.10
confinement: devmode
`
info, err := snap.InfoFromSnapYaml([]byte(yaml))
c.Assert(err, IsNil)
var openSnapFile = func(path string, si *snap.SideInfo) (*snap.Info, snap.Container, error) {
c.Check(path, Equals, "snap-path")
c.Check(si, IsNil)
return info, nil, nil
}
restore := snapstate.MockOpenSnapFile(openSnapFile)
defer restore()
err = snapstate.CheckSnap(s.st, "snap-path", nil, nil, snapstate.Flags{})
c.Assert(err, ErrorMatches, ".* requires devmode or confinement override")
}
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 (s *checkSnapSuite) TestCheckSnapErrorOnUnsupportedArchitecture(c *C) {
const yaml = `name: hello
version: 1.10
architectures:
- yadayada
- blahblah
`
info, err := snap.InfoFromSnapYaml([]byte(yaml))
c.Assert(err, IsNil)
var openSnapFile = func(path string, si *snap.SideInfo) (*snap.Info, snap.Container, error) {
c.Check(path, Equals, "snap-path")
c.Check(si, IsNil)
return info, nil, nil
}
restore := snapstate.MockOpenSnapFile(openSnapFile)
defer restore()
err = snapstate.CheckSnap(s.st, "snap-path", nil, nil, snapstate.Flags{})
errorMsg := fmt.Sprintf(`snap "hello" supported architectures (yadayada, blahblah) are incompatible with this system (%s)`, arch.UbuntuArchitecture())
c.Assert(err.Error(), Equals, errorMsg)
}
func (s *checkSnapSuite) TestCheckSnapCheckCallbackFail(c *C) {
const yaml = `name: foo
version: 1.0`
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()
fail := errors.New("bad snap")
checkCb := func(st *state.State, s, cur *snap.Info, flags snapstate.Flags) error {
return fail
}
r2 := snapstate.MockCheckSnapCallbacks(nil)
defer r2()
snapstate.AddCheckSnapCallback(checkCb)
err = snapstate.CheckSnap(s.st, "snap-path", nil, nil, snapstate.Flags{})
c.Check(err, Equals, fail)
}
