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