func (s *MigrationBaseSuite) setRandSequenceValue(c *gc.C, name string) int {
var value int
var err error
count := rand.Intn(5) + 1
for i := 0; i < count; i++ {
value, err = state.Sequence(s.State, name)
c.Assert(err, jc.ErrorIsNil)
}
// The value stored in the doc is one higher than what it returns.
return value + 1
}
func (s *sequenceSuite) incAndCheck(c *gc.C, st *state.State, name string, expectedCount int) {
value, err := state.Sequence(st, name)
c.Assert(err, jc.ErrorIsNil)
c.Check(value, gc.Equals, expectedCount)
}
func (s *MigrationImportSuite) TestNewModel(c *gc.C) {
cons := constraints.MustParse("arch=amd64 mem=8G")
latestTools := version.MustParse("2.0.1")
s.setLatestTools(c, latestTools)
c.Assert(s.State.SetModelConstraints(cons), jc.ErrorIsNil)
machineSeq := s.setRandSequenceValue(c, "machine")
fooSeq := s.setRandSequenceValue(c, "application-foo")
s.State.SwitchBlockOn(state.ChangeBlock, "locked down")
original, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetAnnotations(original, testAnnotations)
c.Assert(err, jc.ErrorIsNil)
out, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
uuid := utils.MustNewUUID().String()
in := newModel(out, uuid, "new")
newModel, newSt, err := s.State.Import(in)
c.Assert(err, jc.ErrorIsNil)
defer newSt.Close()
c.Assert(newModel.Owner(), gc.Equals, original.Owner())
c.Assert(newModel.LatestToolsVersion(), gc.Equals, latestTools)
c.Assert(newModel.MigrationMode(), gc.Equals, state.MigrationModeImporting)
s.assertAnnotations(c, newSt, newModel)
originalConfig, err := original.Config()
c.Assert(err, jc.ErrorIsNil)
originalAttrs := originalConfig.AllAttrs()
newConfig, err := newModel.Config()
c.Assert(err, jc.ErrorIsNil)
newAttrs := newConfig.AllAttrs()
c.Assert(newAttrs["uuid"], gc.Equals, uuid)
c.Assert(newAttrs["name"], gc.Equals, "new")
// Now drop the uuid and name and the rest of the attributes should match.
delete(newAttrs, "uuid")
delete(newAttrs, "name")
delete(originalAttrs, "uuid")
delete(originalAttrs, "name")
c.Assert(newAttrs, jc.DeepEquals, originalAttrs)
newCons, err := newSt.ModelConstraints()
c.Assert(err, jc.ErrorIsNil)
// Can't test the constraints directly, so go through the string repr.
c.Assert(newCons.String(), gc.Equals, cons.String())
seq, err := state.Sequence(newSt, "machine")
c.Assert(err, jc.ErrorIsNil)
c.Assert(seq, gc.Equals, machineSeq)
seq, err = state.Sequence(newSt, "application-foo")
c.Assert(err, jc.ErrorIsNil)
c.Assert(seq, gc.Equals, fooSeq)
blocks, err := newSt.AllBlocks()
c.Assert(err, jc.ErrorIsNil)
c.Assert(blocks, gc.HasLen, 1)
c.Assert(blocks[0].Type(), gc.Equals, state.ChangeBlock)
c.Assert(blocks[0].Message(), gc.Equals, "locked down")
}
