func (s *MigrationExportSuite) assertMigrateApplications(c *gc.C, cons constraints.Value) {
application := s.Factory.MakeApplication(c, &factory.ApplicationParams{
Settings: map[string]interface{}{
"foo": "bar",
},
Constraints: cons,
})
err := application.UpdateLeaderSettings(&goodToken{}, map[string]string{
"leader": "true",
})
c.Assert(err, jc.ErrorIsNil)
err = application.SetMetricCredentials([]byte("sekrit"))
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetAnnotations(application, testAnnotations)
c.Assert(err, jc.ErrorIsNil)
s.primeStatusHistory(c, application, status.Active, addedHistoryCount)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
applications := model.Applications()
c.Assert(applications, gc.HasLen, 1)
exported := applications[0]
c.Assert(exported.Name(), gc.Equals, application.Name())
c.Assert(exported.Tag(), gc.Equals, application.ApplicationTag())
c.Assert(exported.Series(), gc.Equals, application.Series())
c.Assert(exported.Annotations(), jc.DeepEquals, testAnnotations)
c.Assert(exported.Settings(), jc.DeepEquals, map[string]interface{}{
"foo": "bar",
})
c.Assert(exported.LeadershipSettings(), jc.DeepEquals, map[string]interface{}{
"leader": "true",
})
c.Assert(exported.MetricsCredentials(), jc.DeepEquals, []byte("sekrit"))
constraints := exported.Constraints()
c.Assert(constraints, gc.NotNil)
c.Assert(constraints.Architecture(), gc.Equals, *cons.Arch)
c.Assert(constraints.Memory(), gc.Equals, *cons.Mem)
if cons.HasVirtType() {
c.Assert(constraints.VirtType(), gc.Equals, *cons.VirtType)
}
history := exported.StatusHistory()
c.Assert(history, gc.HasLen, expectedHistoryCount)
s.checkStatusHistory(c, history[:addedHistoryCount], status.Active)
}
func (s *MigrationExportSuite) assertMachinesMigrated(c *gc.C, cons constraints.Value) {
// Add a machine with an LXC container.
machine1 := s.Factory.MakeMachine(c, &factory.MachineParams{
Constraints: cons,
})
nested := s.Factory.MakeMachineNested(c, machine1.Id(), nil)
err := s.State.SetAnnotations(machine1, testAnnotations)
c.Assert(err, jc.ErrorIsNil)
s.primeStatusHistory(c, machine1, status.Started, addedHistoryCount)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
machines := model.Machines()
c.Assert(machines, gc.HasLen, 1)
exported := machines[0]
c.Assert(exported.Tag(), gc.Equals, machine1.MachineTag())
c.Assert(exported.Series(), gc.Equals, machine1.Series())
c.Assert(exported.Annotations(), jc.DeepEquals, testAnnotations)
constraints := exported.Constraints()
c.Assert(constraints, gc.NotNil)
c.Assert(constraints.Architecture(), gc.Equals, *cons.Arch)
c.Assert(constraints.Memory(), gc.Equals, *cons.Mem)
if cons.HasVirtType() {
c.Assert(constraints.VirtType(), gc.Equals, *cons.VirtType)
}
tools, err := machine1.AgentTools()
c.Assert(err, jc.ErrorIsNil)
exTools := exported.Tools()
c.Assert(exTools, gc.NotNil)
c.Assert(exTools.Version(), jc.DeepEquals, tools.Version)
history := exported.StatusHistory()
c.Assert(history, gc.HasLen, expectedHistoryCount)
s.checkStatusHistory(c, history[:addedHistoryCount], status.Started)
containers := exported.Containers()
c.Assert(containers, gc.HasLen, 1)
container := containers[0]
c.Assert(container.Tag(), gc.Equals, nested.MachineTag())
}