func (ovs *overlordSuite) TestNew(c *C) {
restore := patch.Mock(42, nil)
defer restore()
o, err := overlord.New()
c.Assert(err, IsNil)
c.Check(o, NotNil)
c.Check(o.SnapManager(), NotNil)
c.Check(o.AssertManager(), NotNil)
c.Check(o.InterfaceManager(), NotNil)
c.Check(o.DeviceManager(), NotNil)
s := o.State()
c.Check(s, NotNil)
c.Check(o.Engine().State(), Equals, s)
s.Lock()
defer s.Unlock()
var patchLevel int
s.Get("patch-level", &patchLevel)
c.Check(patchLevel, Equals, 42)
// store is setup
sto := snapstate.Store(s)
c.Check(sto, FitsTypeOf, &store.Store{})
}
func (ovs *overlordSuite) TestNewWithPatches(c *C) {
p := func(s *state.State) error {
s.Set("patched", true)
return nil
}
patch.Mock(1, map[int]func(*state.State) error{1: p})
fakeState := []byte(fmt.Sprintf(`{"data":{"patch-level":0}}`))
err := ioutil.WriteFile(dirs.SnapStateFile, fakeState, 0600)
c.Assert(err, IsNil)
o, err := overlord.New()
c.Assert(err, IsNil)
state := o.State()
c.Assert(err, IsNil)
state.Lock()
defer state.Unlock()
var level int
err = state.Get("patch-level", &level)
c.Assert(err, IsNil)
c.Check(level, Equals, 1)
var b bool
err = state.Get("patched", &b)
c.Assert(err, IsNil)
c.Check(b, Equals, true)
}
func (s *patchSuite) TestNoDowngrade(c *C) {
restore := patch.Mock(2, nil)
defer restore()
st := state.New(nil)
st.Lock()
st.Set("patch-level", 3)
st.Unlock()
err := patch.Apply(st)
c.Assert(err, ErrorMatches, `cannot downgrade: snapd is too old for the current system state \(patch level 3\)`)
}
func (s *patchSuite) TestNothingToDo(c *C) {
restore := patch.Mock(2, nil)
defer restore()
st := state.New(nil)
st.Lock()
st.Set("patch-level", 2)
st.Unlock()
err := patch.Apply(st)
c.Assert(err, IsNil)
}
func (s *patchSuite) TestMissing(c *C) {
restore := patch.Mock(3, map[int]func(*state.State) error{
3: func(s *state.State) error { return nil },
})
defer restore()
st := state.New(nil)
st.Lock()
st.Set("patch-level", 1)
st.Unlock()
err := patch.Apply(st)
c.Assert(err, ErrorMatches, `cannot upgrade: snapd is too new for the current system state \(patch level 1\)`)
}
func (s *patchSuite) TestInit(c *C) {
restore := patch.Mock(2, nil)
defer restore()
st := state.New(nil)
patch.Init(st)
st.Lock()
defer st.Unlock()
var patchLevel int
err := st.Get("patch-level", &patchLevel)
c.Assert(err, IsNil)
c.Check(patchLevel, Equals, 2)
}
func (s *patchSuite) TestError(c *C) {
p12 := func(st *state.State) error {
var n int
st.Get("n", &n)
st.Set("n", n+1)
return nil
}
p23 := func(st *state.State) error {
var n int
st.Get("n", &n)
st.Set("n", n*10)
return fmt.Errorf("boom")
}
p34 := func(st *state.State) error {
var n int
st.Get("n", &n)
st.Set("n", n*100)
return nil
}
restore := patch.Mock(3, map[int]func(*state.State) error{
2: p12,
3: p23,
4: p34,
})
defer restore()
st := state.New(nil)
st.Lock()
st.Set("patch-level", 1)
st.Unlock()
err := patch.Apply(st)
c.Assert(err, ErrorMatches, `cannot patch system state from level 2 to 3: boom`)
st.Lock()
defer st.Unlock()
var level int
err = st.Get("patch-level", &level)
c.Assert(err, IsNil)
c.Check(level, Equals, 2)
var n int
err = st.Get("n", &n)
c.Assert(err, IsNil)
c.Check(n, Equals, 10)
}
func (s *patchSuite) TestApply(c *C) {
p12 := func(st *state.State) error {
var n int
st.Get("n", &n)
st.Set("n", n+1)
return nil
}
p23 := func(st *state.State) error {
var n int
st.Get("n", &n)
st.Set("n", n*10)
return nil
}
restore := patch.Mock(3, map[int]func(*state.State) error{
2: p12,
3: p23,
})
defer restore()
st := state.New(nil)
st.Lock()
st.Set("patch-level", 1)
st.Unlock()
err := patch.Apply(st)
c.Assert(err, IsNil)
st.Lock()
defer st.Unlock()
var level int
err = st.Get("patch-level", &level)
c.Assert(err, IsNil)
c.Check(level, Equals, 3)
var n int
err = st.Get("n", &n)
c.Assert(err, IsNil)
c.Check(n, Equals, 10)
}
