launchpad.net/~rogpeppe/juju-core/500-errgo-fix@v0.0.0-20140213181702-000000002356/worker/machiner/machiner_test.go (about) 1 // Copyright 2013 Canonical Ltd. 2 // Licensed under the AGPLv3, see LICENCE file for details. 3 4 package machiner_test 5 6 import ( 7 "launchpad.net/errgo/errors" 8 gc "launchpad.net/gocheck" 9 "net" 10 stdtesting "testing" 11 "time" 12 13 "launchpad.net/juju-core/agent" 14 "launchpad.net/juju-core/instance" 15 "launchpad.net/juju-core/juju/testing" 16 "launchpad.net/juju-core/state" 17 "launchpad.net/juju-core/state/api" 18 apimachiner "launchpad.net/juju-core/state/api/machiner" 19 "launchpad.net/juju-core/state/api/params" 20 coretesting "launchpad.net/juju-core/testing" 21 "launchpad.net/juju-core/worker" 22 "launchpad.net/juju-core/worker/machiner" 23 ) 24 25 // worstCase is used for timeouts when timing out 26 // will fail the test. Raising this value should 27 // not affect the overall running time of the tests 28 // unless they fail. 29 const worstCase = 5 * time.Second 30 31 func TestPackage(t *stdtesting.T) { 32 coretesting.MgoTestPackage(t) 33 } 34 35 type MachinerSuite struct { 36 testing.JujuConnSuite 37 38 st *api.State 39 machinerState *apimachiner.State 40 machine *state.Machine 41 apiMachine *apimachiner.Machine 42 } 43 44 var _ = gc.Suite(&MachinerSuite{}) 45 46 func (s *MachinerSuite) SetUpTest(c *gc.C) { 47 s.JujuConnSuite.SetUpTest(c) 48 s.st, s.machine = s.OpenAPIAsNewMachine(c) 49 50 // Create the machiner API facade. 51 s.machinerState = s.st.Machiner() 52 c.Assert(s.machinerState, gc.NotNil) 53 54 // Get the machine through the facade. 55 var err error 56 s.apiMachine, err = s.machinerState.Machine(s.machine.Tag()) 57 c.Assert(err, gc.IsNil) 58 c.Assert(s.apiMachine.Tag(), gc.Equals, s.machine.Tag()) 59 } 60 61 func (s *MachinerSuite) waitMachineStatus(c *gc.C, m *state.Machine, expectStatus params.Status) { 62 timeout := time.After(worstCase) 63 for { 64 select { 65 case <-timeout: 66 c.Fatalf("timeout while waiting for machine status to change") 67 case <-time.After(10 * time.Millisecond): 68 status, _, _, err := m.Status() 69 c.Assert(err, gc.IsNil) 70 if status != expectStatus { 71 c.Logf("machine %q status is %s, still waiting", m, status) 72 continue 73 } 74 return 75 } 76 } 77 } 78 79 var _ worker.NotifyWatchHandler = (*machiner.Machiner)(nil) 80 81 type mockConfig struct { 82 agent.Config 83 tag string 84 } 85 86 func (mock *mockConfig) Tag() string { 87 return mock.tag 88 } 89 90 func agentConfig(tag string) agent.Config { 91 return &mockConfig{tag: tag} 92 } 93 94 func (s *MachinerSuite) TestNotFoundOrUnauthorized(c *gc.C) { 95 mr := machiner.NewMachiner(s.machinerState, agentConfig("eleventy-one")) 96 c.Assert(mr.Wait(), gc.Equals, worker.ErrTerminateAgent) 97 } 98 99 func (s *MachinerSuite) makeMachiner() worker.Worker { 100 return machiner.NewMachiner(s.machinerState, agentConfig(s.apiMachine.Tag())) 101 } 102 103 func (s *MachinerSuite) TestRunStop(c *gc.C) { 104 mr := s.makeMachiner() 105 c.Assert(worker.Stop(mr), gc.IsNil) 106 c.Assert(s.apiMachine.Refresh(), gc.IsNil) 107 c.Assert(s.apiMachine.Life(), gc.Equals, params.Alive) 108 } 109 110 func (s *MachinerSuite) TestStartSetsStatus(c *gc.C) { 111 status, info, _, err := s.machine.Status() 112 c.Assert(err, gc.IsNil) 113 c.Assert(status, gc.Equals, params.StatusPending) 114 c.Assert(info, gc.Equals, "") 115 116 mr := s.makeMachiner() 117 defer worker.Stop(mr) 118 119 s.waitMachineStatus(c, s.machine, params.StatusStarted) 120 } 121 122 func (s *MachinerSuite) TestSetsStatusWhenDying(c *gc.C) { 123 mr := s.makeMachiner() 124 defer worker.Stop(mr) 125 c.Assert(s.machine.Destroy(), gc.IsNil) 126 s.waitMachineStatus(c, s.machine, params.StatusStopped) 127 } 128 129 func (s *MachinerSuite) TestSetDead(c *gc.C) { 130 mr := s.makeMachiner() 131 defer worker.Stop(mr) 132 c.Assert(s.machine.Destroy(), gc.IsNil) 133 s.State.StartSync() 134 c.Assert(errors.Cause(mr.Wait()), gc.Equals, worker.ErrTerminateAgent) 135 c.Assert(s.machine.Refresh(), gc.IsNil) 136 c.Assert(s.machine.Life(), gc.Equals, state.Dead) 137 } 138 139 func (s *MachinerSuite) TestMachineAddresses(c *gc.C) { 140 s.PatchValue(machiner.InterfaceAddrs, func() ([]net.Addr, error) { 141 addrs := []net.Addr{ 142 &net.IPAddr{IP: net.IPv4(10, 0, 0, 1)}, 143 &net.IPAddr{IP: net.IPv4(127, 0, 0, 1)}, // loopback, ignored 144 &net.IPAddr{IP: net.IPv6loopback}, // loopback, ignored 145 &net.UnixAddr{}, // not IP, ignored 146 &net.IPNet{IP: net.ParseIP("2001:db8::1")}, 147 } 148 return addrs, nil 149 }) 150 mr := s.makeMachiner() 151 defer worker.Stop(mr) 152 c.Assert(s.machine.Destroy(), gc.IsNil) 153 s.State.StartSync() 154 c.Assert(errors.Cause(mr.Wait()), gc.Equals, worker.ErrTerminateAgent) 155 c.Assert(s.machine.Refresh(), gc.IsNil) 156 c.Assert(s.machine.MachineAddresses(), gc.DeepEquals, []instance.Address{ 157 instance.NewAddress("10.0.0.1"), 158 instance.NewAddress("2001:db8::1"), 159 }) 160 }