func (s *Suite) TestWatchFailure(c *gc.C) {
s.client.watchErr = errors.New("boom")
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
err = workertest.CheckKilled(c, w)
c.Check(err, gc.ErrorMatches, "setting up watcher: boom")
}
func (s *Suite) TestVALIDATION(c *gc.C) {
s.client.watcher.changes <- watcher.MigrationStatus{
MigrationId: "id",
Phase: migration.VALIDATION,
TargetAPIAddrs: addrs,
TargetCACert: caCert,
}
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
defer workertest.CleanKill(c, w)
s.waitForStubCalls(c, []string{
"Watch",
"Lockdown",
"API open",
"ValidateMigration",
"API close",
"Report",
})
s.stub.CheckCall(c, 2, "API open", &api.Info{
ModelTag: modelTag,
Tag: agentTag,
Password: agentPassword,
Addrs: addrs,
CACert: caCert,
})
s.stub.CheckCall(c, 5, "Report", "id", migration.VALIDATION, true)
}
func (s *Suite) TestClosedWatcherChannel(c *gc.C) {
close(s.client.watcher.changes)
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
err = workertest.CheckKilled(c, w)
c.Check(err, gc.ErrorMatches, "watcher channel closed")
}
func (s *Suite) checkNonRunningPhase(c *gc.C, phase migration.Phase) {
c.Logf("checking %s", phase)
s.stub.ResetCalls()
s.client.watcher.changes <- watcher.MigrationStatus{Phase: phase}
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
workertest.CheckAlive(c, w)
workertest.CleanKill(c, w)
s.stub.CheckCallNames(c, "Watch", "Unlock")
}
func (s *Suite) TestStartAndStop(c *gc.C) {
w, err := migrationminion.New(migrationminion.Config{
Facade: s.client,
Guard: s.guard,
Agent: s.agent,
})
c.Assert(err, jc.ErrorIsNil)
workertest.CleanKill(c, w)
s.stub.CheckCallNames(c, "Watch")
}
func (s *Suite) TestClosedWatcherChannel(c *gc.C) {
close(s.client.watcher.changes)
w, err := migrationminion.New(migrationminion.Config{
Facade: s.client,
Guard: s.guard,
Agent: s.agent,
})
c.Assert(err, jc.ErrorIsNil)
err = workertest.CheckKilled(c, w)
c.Check(err, gc.ErrorMatches, "watcher channel closed")
}
func (s *Suite) TestWatchFailure(c *gc.C) {
s.client.watchErr = errors.New("boom")
w, err := migrationminion.New(migrationminion.Config{
Facade: s.client,
Guard: s.guard,
Agent: s.agent,
})
c.Assert(err, jc.ErrorIsNil)
err = workertest.CheckKilled(c, w)
c.Check(err, gc.ErrorMatches, "setting up watcher: boom")
}
func (s *Suite) TestUnlockError(c *gc.C) {
s.client.watcher.changes <- watcher.MigrationStatus{
Phase: migration.NONE,
}
s.guard.unlockErr = errors.New("squish")
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
err = workertest.CheckKilled(c, w)
c.Check(err, gc.ErrorMatches, "squish")
s.stub.CheckCallNames(c, "Watch", "Unlock")
}
func checkNotValid(c *gc.C, config migrationminion.Config, expect string) {
check := func(err error) {
c.Check(err, gc.ErrorMatches, expect)
c.Check(err, jc.Satisfies, errors.IsNotValid)
}
err := config.Validate()
check(err)
worker, err := migrationminion.New(config)
c.Check(worker, gc.IsNil)
check(err)
}
func (s *Suite) TestNONE(c *gc.C) {
s.client.watcher.changes <- watcher.MigrationStatus{
Phase: migration.NONE,
}
w, err := migrationminion.New(migrationminion.Config{
Facade: s.client,
Guard: s.guard,
Agent: s.agent,
})
c.Assert(err, jc.ErrorIsNil)
workertest.CheckAlive(c, w)
workertest.CleanKill(c, w)
s.stub.CheckCallNames(c, "Watch", "Unlock")
}
func (s *Suite) TestLockdownError(c *gc.C) {
s.client.watcher.changes <- watcher.MigrationStatus{
Phase: migration.QUIESCE,
}
s.guard.lockdownErr = errors.New("squash")
w, err := migrationminion.New(migrationminion.Config{
Facade: s.client,
Guard: s.guard,
Agent: s.agent,
})
c.Assert(err, jc.ErrorIsNil)
err = workertest.CheckKilled(c, w)
c.Check(err, gc.ErrorMatches, "squash")
s.stub.CheckCallNames(c, "Watch", "Lockdown")
}
func (s *Suite) TestQUIESCE(c *gc.C) {
s.client.watcher.changes <- watcher.MigrationStatus{
MigrationId: "id",
Phase: migration.QUIESCE,
}
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
defer workertest.CleanKill(c, w)
s.waitForStubCalls(c, []string{
"Watch",
"Lockdown",
"Report",
})
s.stub.CheckCall(c, 2, "Report", "id", migration.QUIESCE, true)
}
func (s *Suite) TestVALIDATIONCantConnect(c *gc.C) {
s.client.watcher.changes <- watcher.MigrationStatus{
MigrationId: "id",
Phase: migration.VALIDATION,
}
s.config.APIOpen = func(*api.Info, api.DialOpts) (api.Connection, error) {
s.stub.AddCall("API open")
return nil, errors.New("boom")
}
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
defer workertest.CleanKill(c, w)
s.waitForStubCalls(c, []string{
"Watch",
"Lockdown",
"API open",
"Report",
})
s.stub.CheckCall(c, 3, "Report", "id", migration.VALIDATION, false)
}
func (s *Suite) TestSUCCESS(c *gc.C) {
s.client.watcher.changes <- watcher.MigrationStatus{
MigrationId: "id",
Phase: migration.SUCCESS,
TargetAPIAddrs: addrs,
TargetCACert: caCert,
}
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
select {
case <-s.agent.configChanged:
case <-time.After(coretesting.LongWait):
c.Fatal("timed out")
}
workertest.CleanKill(c, w)
c.Assert(s.agent.conf.addrs, gc.DeepEquals, addrs)
c.Assert(s.agent.conf.caCert, gc.DeepEquals, caCert)
s.stub.CheckCallNames(c, "Watch", "Lockdown", "Report")
s.stub.CheckCall(c, 2, "Report", "id", migration.SUCCESS, true)
}
func (s *Suite) TestVALIDATIONFail(c *gc.C) {
s.client.watcher.changes <- watcher.MigrationStatus{
MigrationId: "id",
Phase: migration.VALIDATION,
}
s.config.ValidateMigration = func(base.APICaller) error {
s.stub.AddCall("ValidateMigration")
return errors.New("boom")
}
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
defer workertest.CleanKill(c, w)
s.waitForStubCalls(c, []string{
"Watch",
"Lockdown",
"API open",
"ValidateMigration",
"API close",
"Report",
})
s.stub.CheckCall(c, 5, "Report", "id", migration.VALIDATION, false)
}
func (s *Suite) TestSUCCESS(c *gc.C) {
addrs := []string{"1.1.1.1:1", "9.9.9.9:9"}
s.client.watcher.changes <- watcher.MigrationStatus{
Phase: migration.SUCCESS,
TargetAPIAddrs: addrs,
TargetCACert: "top secret",
}
w, err := migrationminion.New(migrationminion.Config{
Facade: s.client,
Guard: s.guard,
Agent: s.agent,
})
c.Assert(err, jc.ErrorIsNil)
select {
case <-s.agent.configChanged:
case <-time.After(coretesting.LongWait):
c.Fatal("timed out waiting for config to be changed")
}
workertest.CleanKill(c, w)
c.Assert(s.agent.conf.addrs, gc.DeepEquals, addrs)
c.Assert(s.agent.conf.caCert, gc.DeepEquals, "top secret")
s.stub.CheckCallNames(c, "Watch", "Lockdown")
}
func (s *Suite) TestStartAndStop(c *gc.C) {
w, err := migrationminion.New(s.config)
c.Assert(err, jc.ErrorIsNil)
workertest.CleanKill(c, w)
s.stub.CheckCallNames(c, "Watch")
}
