github.com/mhilton/juju-juju@v0.0.0-20150901100907-a94dd2c73455/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  	"github.com/juju/names"
     8  	jc "github.com/juju/testing/checkers"
     9  	gc "gopkg.in/check.v1"
    10  
    11  	"github.com/juju/juju/apiserver/common"
    12  	"github.com/juju/juju/apiserver/machine"
    13  	"github.com/juju/juju/apiserver/params"
    14  	apiservertesting "github.com/juju/juju/apiserver/testing"
    15  	"github.com/juju/juju/network"
    16  	"github.com/juju/juju/state"
    17  	"github.com/juju/juju/state/multiwatcher"
    18  	statetesting "github.com/juju/juju/state/testing"
    19  )
    20  
    21  type machinerSuite struct {
    22  	commonSuite
    23  
    24  	resources *common.Resources
    25  	machiner  *machine.MachinerAPI
    26  }
    27  
    28  var _ = gc.Suite(&machinerSuite{})
    29  
    30  func (s *machinerSuite) SetUpTest(c *gc.C) {
    31  	s.commonSuite.SetUpTest(c)
    32  
    33  	// Create the resource registry separately to track invocations to
    34  	// Register.
    35  	s.resources = common.NewResources()
    36  
    37  	// Create a machiner API for machine 1.
    38  	machiner, err := machine.NewMachinerAPI(
    39  		s.State,
    40  		s.resources,
    41  		s.authorizer,
    42  	)
    43  	c.Assert(err, jc.ErrorIsNil)
    44  	s.machiner = machiner
    45  }
    46  
    47  func (s *machinerSuite) TestMachinerFailsWithNonMachineAgentUser(c *gc.C) {
    48  	anAuthorizer := s.authorizer
    49  	anAuthorizer.Tag = names.NewUnitTag("ubuntu/1")
    50  	aMachiner, err := machine.NewMachinerAPI(s.State, s.resources, anAuthorizer)
    51  	c.Assert(err, gc.NotNil)
    52  	c.Assert(aMachiner, gc.IsNil)
    53  	c.Assert(err, gc.ErrorMatches, "permission denied")
    54  }
    55  
    56  func (s *machinerSuite) TestSetStatus(c *gc.C) {
    57  	err := s.machine0.SetStatus(state.StatusStarted, "blah", nil)
    58  	c.Assert(err, jc.ErrorIsNil)
    59  	err = s.machine1.SetStatus(state.StatusStopped, "foo", nil)
    60  	c.Assert(err, jc.ErrorIsNil)
    61  
    62  	args := params.SetStatus{
    63  		Entities: []params.EntityStatusArgs{
    64  			{Tag: "machine-1", Status: params.StatusError, Info: "not really"},
    65  			{Tag: "machine-0", Status: params.StatusStopped, Info: "foobar"},
    66  			{Tag: "machine-42", Status: params.StatusStarted, Info: "blah"},
    67  		}}
    68  	result, err := s.machiner.SetStatus(args)
    69  	c.Assert(err, jc.ErrorIsNil)
    70  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
    71  		Results: []params.ErrorResult{
    72  			{nil},
    73  			{apiservertesting.ErrUnauthorized},
    74  			{apiservertesting.ErrUnauthorized},
    75  		},
    76  	})
    77  
    78  	// Verify machine 0 - no change.
    79  	statusInfo, err := s.machine0.Status()
    80  	c.Assert(err, jc.ErrorIsNil)
    81  	c.Assert(statusInfo.Status, gc.Equals, state.StatusStarted)
    82  	c.Assert(statusInfo.Message, gc.Equals, "blah")
    83  	// ...machine 1 is fine though.
    84  	statusInfo, err = s.machine1.Status()
    85  	c.Assert(err, jc.ErrorIsNil)
    86  	c.Assert(statusInfo.Status, gc.Equals, state.StatusError)
    87  	c.Assert(statusInfo.Message, gc.Equals, "not really")
    88  }
    89  
    90  func (s *machinerSuite) TestLife(c *gc.C) {
    91  	err := s.machine1.EnsureDead()
    92  	c.Assert(err, jc.ErrorIsNil)
    93  	err = s.machine1.Refresh()
    94  	c.Assert(err, jc.ErrorIsNil)
    95  	c.Assert(s.machine1.Life(), gc.Equals, state.Dead)
    96  
    97  	args := params.Entities{Entities: []params.Entity{
    98  		{Tag: "machine-1"},
    99  		{Tag: "machine-0"},
   100  		{Tag: "machine-42"},
   101  	}}
   102  	result, err := s.machiner.Life(args)
   103  	c.Assert(err, jc.ErrorIsNil)
   104  	c.Assert(result, gc.DeepEquals, params.LifeResults{
   105  		Results: []params.LifeResult{
   106  			{Life: "dead"},
   107  			{Error: apiservertesting.ErrUnauthorized},
   108  			{Error: apiservertesting.ErrUnauthorized},
   109  		},
   110  	})
   111  }
   112  
   113  func (s *machinerSuite) TestEnsureDead(c *gc.C) {
   114  	c.Assert(s.machine0.Life(), gc.Equals, state.Alive)
   115  	c.Assert(s.machine1.Life(), gc.Equals, state.Alive)
   116  
   117  	args := params.Entities{Entities: []params.Entity{
   118  		{Tag: "machine-1"},
   119  		{Tag: "machine-0"},
   120  		{Tag: "machine-42"},
   121  	}}
   122  	result, err := s.machiner.EnsureDead(args)
   123  	c.Assert(err, jc.ErrorIsNil)
   124  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   125  		Results: []params.ErrorResult{
   126  			{nil},
   127  			{apiservertesting.ErrUnauthorized},
   128  			{apiservertesting.ErrUnauthorized},
   129  		},
   130  	})
   131  
   132  	err = s.machine0.Refresh()
   133  	c.Assert(err, jc.ErrorIsNil)
   134  	c.Assert(s.machine0.Life(), gc.Equals, state.Alive)
   135  	err = s.machine1.Refresh()
   136  	c.Assert(err, jc.ErrorIsNil)
   137  	c.Assert(s.machine1.Life(), gc.Equals, state.Dead)
   138  
   139  	// Try it again on a Dead machine; should work.
   140  	args = params.Entities{
   141  		Entities: []params.Entity{{Tag: "machine-1"}},
   142  	}
   143  	result, err = s.machiner.EnsureDead(args)
   144  	c.Assert(err, jc.ErrorIsNil)
   145  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   146  		Results: []params.ErrorResult{{nil}},
   147  	})
   148  
   149  	// Verify Life is unchanged.
   150  	err = s.machine1.Refresh()
   151  	c.Assert(err, jc.ErrorIsNil)
   152  	c.Assert(s.machine1.Life(), gc.Equals, state.Dead)
   153  }
   154  
   155  func (s *machinerSuite) TestSetMachineAddresses(c *gc.C) {
   156  	c.Assert(s.machine0.Addresses(), gc.HasLen, 0)
   157  	c.Assert(s.machine1.Addresses(), gc.HasLen, 0)
   158  
   159  	addresses := network.NewAddresses("127.0.0.1", "8.8.8.8")
   160  
   161  	args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{
   162  		{Tag: "machine-1", Addresses: params.FromNetworkAddresses(addresses)},
   163  		{Tag: "machine-0", Addresses: params.FromNetworkAddresses(addresses)},
   164  		{Tag: "machine-42", Addresses: params.FromNetworkAddresses(addresses)},
   165  	}}
   166  
   167  	result, err := s.machiner.SetMachineAddresses(args)
   168  	c.Assert(err, jc.ErrorIsNil)
   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, jc.ErrorIsNil)
   179  
   180  	expectedAddresses := network.NewAddresses("8.8.8.8", "127.0.0.1")
   181  	c.Assert(s.machine1.MachineAddresses(), gc.DeepEquals, expectedAddresses)
   182  	err = s.machine0.Refresh()
   183  	c.Assert(err, jc.ErrorIsNil)
   184  	c.Assert(s.machine0.MachineAddresses(), gc.HasLen, 0)
   185  }
   186  
   187  func (s *machinerSuite) TestSetEmptyMachineAddresses(c *gc.C) {
   188  	// Set some addresses so we can ensure they are removed.
   189  	addresses := network.NewAddresses("127.0.0.1", "8.8.8.8")
   190  	args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{
   191  		{Tag: "machine-1", Addresses: params.FromNetworkAddresses(addresses)},
   192  	}}
   193  	result, err := s.machiner.SetMachineAddresses(args)
   194  	c.Assert(err, jc.ErrorIsNil)
   195  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   196  		Results: []params.ErrorResult{
   197  			{nil},
   198  		},
   199  	})
   200  	err = s.machine1.Refresh()
   201  	c.Assert(err, jc.ErrorIsNil)
   202  	c.Assert(s.machine1.MachineAddresses(), gc.HasLen, 2)
   203  
   204  	args.MachineAddresses[0].Addresses = nil
   205  	result, err = s.machiner.SetMachineAddresses(args)
   206  	c.Assert(err, jc.ErrorIsNil)
   207  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   208  		Results: []params.ErrorResult{
   209  			{nil},
   210  		},
   211  	})
   212  
   213  	err = s.machine1.Refresh()
   214  	c.Assert(err, jc.ErrorIsNil)
   215  	c.Assert(s.machine1.MachineAddresses(), gc.HasLen, 0)
   216  }
   217  
   218  func (s *machinerSuite) TestJobs(c *gc.C) {
   219  	args := params.Entities{Entities: []params.Entity{
   220  		{Tag: "machine-1"},
   221  		{Tag: "machine-0"},
   222  		{Tag: "machine-42"},
   223  	}}
   224  
   225  	result, err := s.machiner.Jobs(args)
   226  	c.Assert(err, jc.ErrorIsNil)
   227  	c.Assert(result, gc.DeepEquals, params.JobsResults{
   228  		Results: []params.JobsResult{
   229  			{Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits}},
   230  			{Error: apiservertesting.ErrUnauthorized},
   231  			{Error: apiservertesting.ErrUnauthorized},
   232  		},
   233  	})
   234  }
   235  
   236  func (s *machinerSuite) TestWatch(c *gc.C) {
   237  	c.Assert(s.resources.Count(), gc.Equals, 0)
   238  
   239  	args := params.Entities{Entities: []params.Entity{
   240  		{Tag: "machine-1"},
   241  		{Tag: "machine-0"},
   242  		{Tag: "machine-42"},
   243  	}}
   244  	result, err := s.machiner.Watch(args)
   245  	c.Assert(err, jc.ErrorIsNil)
   246  	c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
   247  		Results: []params.NotifyWatchResult{
   248  			{NotifyWatcherId: "1"},
   249  			{Error: apiservertesting.ErrUnauthorized},
   250  			{Error: apiservertesting.ErrUnauthorized},
   251  		},
   252  	})
   253  
   254  	// Verify the resource was registered and stop when done
   255  	c.Assert(s.resources.Count(), gc.Equals, 1)
   256  	c.Assert(result.Results[0].NotifyWatcherId, gc.Equals, "1")
   257  	resource := s.resources.Get("1")
   258  	defer statetesting.AssertStop(c, resource)
   259  
   260  	// Check that the Watch has consumed the initial event ("returned" in
   261  	// the Watch call)
   262  	wc := statetesting.NewNotifyWatcherC(c, s.State, resource.(state.NotifyWatcher))
   263  	wc.AssertNoChange()
   264  }