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