github.com/cloudbase/juju-core@v0.0.0-20140504232958-a7271ac7912f/state/apiserver/machine/machiner_test.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package machine_test
     5  
     6  import (
     7  	gc "launchpad.net/gocheck"
     8  
     9  	"launchpad.net/juju-core/instance"
    10  	"launchpad.net/juju-core/state"
    11  	"launchpad.net/juju-core/state/api/params"
    12  	"launchpad.net/juju-core/state/apiserver/common"
    13  	"launchpad.net/juju-core/state/apiserver/machine"
    14  	apiservertesting "launchpad.net/juju-core/state/apiserver/testing"
    15  	statetesting "launchpad.net/juju-core/state/testing"
    16  )
    17  
    18  type machinerSuite struct {
    19  	commonSuite
    20  
    21  	resources *common.Resources
    22  	machiner  *machine.MachinerAPI
    23  }
    24  
    25  var _ = gc.Suite(&machinerSuite{})
    26  
    27  func (s *machinerSuite) SetUpTest(c *gc.C) {
    28  	s.commonSuite.SetUpTest(c)
    29  
    30  	// Create the resource registry separately to track invocations to
    31  	// Register.
    32  	s.resources = common.NewResources()
    33  
    34  	// Create a machiner API for machine 1.
    35  	machiner, err := machine.NewMachinerAPI(
    36  		s.State,
    37  		s.resources,
    38  		s.authorizer,
    39  	)
    40  	c.Assert(err, gc.IsNil)
    41  	s.machiner = machiner
    42  }
    43  
    44  func (s *machinerSuite) TestMachinerFailsWithNonMachineAgentUser(c *gc.C) {
    45  	anAuthorizer := s.authorizer
    46  	anAuthorizer.MachineAgent = false
    47  	aMachiner, err := machine.NewMachinerAPI(s.State, s.resources, anAuthorizer)
    48  	c.Assert(err, gc.NotNil)
    49  	c.Assert(aMachiner, gc.IsNil)
    50  	c.Assert(err, gc.ErrorMatches, "permission denied")
    51  }
    52  
    53  func (s *machinerSuite) TestSetStatus(c *gc.C) {
    54  	err := s.machine0.SetStatus(params.StatusStarted, "blah", nil)
    55  	c.Assert(err, gc.IsNil)
    56  	err = s.machine1.SetStatus(params.StatusStopped, "foo", nil)
    57  	c.Assert(err, gc.IsNil)
    58  
    59  	args := params.SetStatus{
    60  		Entities: []params.SetEntityStatus{
    61  			{Tag: "machine-1", Status: params.StatusError, Info: "not really"},
    62  			{Tag: "machine-0", Status: params.StatusStopped, Info: "foobar"},
    63  			{Tag: "machine-42", Status: params.StatusStarted, Info: "blah"},
    64  		}}
    65  	result, err := s.machiner.SetStatus(args)
    66  	c.Assert(err, gc.IsNil)
    67  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
    68  		Results: []params.ErrorResult{
    69  			{nil},
    70  			{apiservertesting.ErrUnauthorized},
    71  			{apiservertesting.ErrUnauthorized},
    72  		},
    73  	})
    74  
    75  	// Verify machine 0 - no change.
    76  	status, info, _, err := s.machine0.Status()
    77  	c.Assert(err, gc.IsNil)
    78  	c.Assert(status, gc.Equals, params.StatusStarted)
    79  	c.Assert(info, gc.Equals, "blah")
    80  	// ...machine 1 is fine though.
    81  	status, info, _, err = s.machine1.Status()
    82  	c.Assert(err, gc.IsNil)
    83  	c.Assert(status, gc.Equals, params.StatusError)
    84  	c.Assert(info, gc.Equals, "not really")
    85  }
    86  
    87  func (s *machinerSuite) TestLife(c *gc.C) {
    88  	err := s.machine1.EnsureDead()
    89  	c.Assert(err, gc.IsNil)
    90  	err = s.machine1.Refresh()
    91  	c.Assert(err, gc.IsNil)
    92  	c.Assert(s.machine1.Life(), gc.Equals, state.Dead)
    93  
    94  	args := params.Entities{Entities: []params.Entity{
    95  		{Tag: "machine-1"},
    96  		{Tag: "machine-0"},
    97  		{Tag: "machine-42"},
    98  	}}
    99  	result, err := s.machiner.Life(args)
   100  	c.Assert(err, gc.IsNil)
   101  	c.Assert(result, gc.DeepEquals, params.LifeResults{
   102  		Results: []params.LifeResult{
   103  			{Life: "dead"},
   104  			{Error: apiservertesting.ErrUnauthorized},
   105  			{Error: apiservertesting.ErrUnauthorized},
   106  		},
   107  	})
   108  }
   109  
   110  func (s *machinerSuite) TestEnsureDead(c *gc.C) {
   111  	c.Assert(s.machine0.Life(), gc.Equals, state.Alive)
   112  	c.Assert(s.machine1.Life(), gc.Equals, state.Alive)
   113  
   114  	args := params.Entities{Entities: []params.Entity{
   115  		{Tag: "machine-1"},
   116  		{Tag: "machine-0"},
   117  		{Tag: "machine-42"},
   118  	}}
   119  	result, err := s.machiner.EnsureDead(args)
   120  	c.Assert(err, gc.IsNil)
   121  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   122  		Results: []params.ErrorResult{
   123  			{nil},
   124  			{apiservertesting.ErrUnauthorized},
   125  			{apiservertesting.ErrUnauthorized},
   126  		},
   127  	})
   128  
   129  	err = s.machine0.Refresh()
   130  	c.Assert(err, gc.IsNil)
   131  	c.Assert(s.machine0.Life(), gc.Equals, state.Alive)
   132  	err = s.machine1.Refresh()
   133  	c.Assert(err, gc.IsNil)
   134  	c.Assert(s.machine1.Life(), gc.Equals, state.Dead)
   135  
   136  	// Try it again on a Dead machine; should work.
   137  	args = params.Entities{
   138  		Entities: []params.Entity{{Tag: "machine-1"}},
   139  	}
   140  	result, err = s.machiner.EnsureDead(args)
   141  	c.Assert(err, gc.IsNil)
   142  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   143  		Results: []params.ErrorResult{{nil}},
   144  	})
   145  
   146  	// Verify Life is unchanged.
   147  	err = s.machine1.Refresh()
   148  	c.Assert(err, gc.IsNil)
   149  	c.Assert(s.machine1.Life(), gc.Equals, state.Dead)
   150  }
   151  
   152  func (s *machinerSuite) TestSetMachineAddresses(c *gc.C) {
   153  	c.Assert(s.machine0.Addresses(), gc.HasLen, 0)
   154  	c.Assert(s.machine1.Addresses(), gc.HasLen, 0)
   155  
   156  	addresses := []instance.Address{
   157  		instance.NewAddress("127.0.0.1"),
   158  		instance.NewAddress("8.8.8.8"),
   159  	}
   160  
   161  	args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{
   162  		{Tag: "machine-1", Addresses: addresses},
   163  		{Tag: "machine-0", Addresses: addresses},
   164  		{Tag: "machine-42", Addresses: addresses},
   165  	}}
   166  
   167  	result, err := s.machiner.SetMachineAddresses(args)
   168  	c.Assert(err, gc.IsNil)
   169  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   170  		Results: []params.ErrorResult{
   171  			{nil},
   172  			{apiservertesting.ErrUnauthorized},
   173  			{apiservertesting.ErrUnauthorized},
   174  		},
   175  	})
   176  
   177  	err = s.machine1.Refresh()
   178  	c.Assert(err, gc.IsNil)
   179  	c.Assert(s.machine1.MachineAddresses(), gc.DeepEquals, addresses)
   180  	err = s.machine0.Refresh()
   181  	c.Assert(err, gc.IsNil)
   182  	c.Assert(s.machine0.MachineAddresses(), gc.HasLen, 0)
   183  }
   184  
   185  func (s *machinerSuite) TestWatch(c *gc.C) {
   186  	c.Assert(s.resources.Count(), gc.Equals, 0)
   187  
   188  	args := params.Entities{Entities: []params.Entity{
   189  		{Tag: "machine-1"},
   190  		{Tag: "machine-0"},
   191  		{Tag: "machine-42"},
   192  	}}
   193  	result, err := s.machiner.Watch(args)
   194  	c.Assert(err, gc.IsNil)
   195  	c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
   196  		Results: []params.NotifyWatchResult{
   197  			{NotifyWatcherId: "1"},
   198  			{Error: apiservertesting.ErrUnauthorized},
   199  			{Error: apiservertesting.ErrUnauthorized},
   200  		},
   201  	})
   202  
   203  	// Verify the resource was registered and stop when done
   204  	c.Assert(s.resources.Count(), gc.Equals, 1)
   205  	c.Assert(result.Results[0].NotifyWatcherId, gc.Equals, "1")
   206  	resource := s.resources.Get("1")
   207  	defer statetesting.AssertStop(c, resource)
   208  
   209  	// Check that the Watch has consumed the initial event ("returned" in
   210  	// the Watch call)
   211  	wc := statetesting.NewNotifyWatcherC(c, s.State, resource.(state.NotifyWatcher))
   212  	wc.AssertNoChange()
   213  }