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  }