github.com/altoros/juju-vmware@v0.0.0-20150312064031-f19ae857ccca/apiserver/client/status_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package client_test
     5  
     6  import (
     7  	jc "github.com/juju/testing/checkers"
     8  	gc "gopkg.in/check.v1"
     9  
    10  	"github.com/juju/juju/apiserver/client"
    11  	"github.com/juju/juju/instance"
    12  	"github.com/juju/juju/state"
    13  	"github.com/juju/juju/testing/factory"
    14  )
    15  
    16  type statusSuite struct {
    17  	baseSuite
    18  }
    19  
    20  var _ = gc.Suite(&statusSuite{})
    21  
    22  func (s *statusSuite) addMachine(c *gc.C) *state.Machine {
    23  	machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
    24  	c.Assert(err, jc.ErrorIsNil)
    25  	return machine
    26  }
    27  
    28  // Complete testing of status functionality happens elsewhere in the codebase,
    29  // these tests just sanity-check the api itself.
    30  
    31  func (s *statusSuite) TestFullStatus(c *gc.C) {
    32  	machine := s.addMachine(c)
    33  	client := s.APIState.Client()
    34  	status, err := client.Status(nil)
    35  	c.Assert(err, jc.ErrorIsNil)
    36  	c.Check(status.EnvironmentName, gc.Equals, "dummyenv")
    37  	c.Check(status.Services, gc.HasLen, 0)
    38  	c.Check(status.Machines, gc.HasLen, 1)
    39  	c.Check(status.Networks, gc.HasLen, 0)
    40  	resultMachine, ok := status.Machines[machine.Id()]
    41  	if !ok {
    42  		c.Fatalf("Missing machine with id %q", machine.Id())
    43  	}
    44  	c.Check(resultMachine.Id, gc.Equals, machine.Id())
    45  	c.Check(resultMachine.Series, gc.Equals, machine.Series())
    46  }
    47  
    48  func (s *statusSuite) TestLegacyStatus(c *gc.C) {
    49  	machine := s.addMachine(c)
    50  	instanceId := "i-fakeinstance"
    51  	err := machine.SetProvisioned(instance.Id(instanceId), "fakenonce", nil)
    52  	c.Assert(err, jc.ErrorIsNil)
    53  	client := s.APIState.Client()
    54  	status, err := client.LegacyStatus()
    55  	c.Assert(err, jc.ErrorIsNil)
    56  	c.Check(status.Machines, gc.HasLen, 1)
    57  	resultMachine, ok := status.Machines[machine.Id()]
    58  	if !ok {
    59  		c.Fatalf("Missing machine with id %q", machine.Id())
    60  	}
    61  	c.Check(resultMachine.InstanceId, gc.Equals, instanceId)
    62  }
    63  
    64  var _ = gc.Suite(&statusUnitTestSuite{})
    65  
    66  type statusUnitTestSuite struct {
    67  	baseSuite
    68  	*factory.Factory
    69  }
    70  
    71  func (s *statusUnitTestSuite) SetUpTest(c *gc.C) {
    72  	s.baseSuite.SetUpTest(c)
    73  	// State gets reset per test, so must the factory.
    74  	s.Factory = factory.NewFactory(s.State)
    75  }
    76  
    77  func (s *statusUnitTestSuite) TestProcessMachinesWithOneMachineAndOneContainer(c *gc.C) {
    78  	host := s.MakeMachine(c, &factory.MachineParams{InstanceId: instance.Id("0")})
    79  	container := s.MakeMachineNested(c, host.Id(), nil)
    80  	machines := map[string][]*state.Machine{
    81  		host.Id(): {host, container},
    82  	}
    83  
    84  	statuses := client.ProcessMachines(machines)
    85  	c.Assert(statuses, gc.Not(gc.IsNil))
    86  
    87  	containerStatus := client.MakeMachineStatus(container)
    88  	c.Check(statuses[host.Id()].Containers[container.Id()].Id, gc.Equals, containerStatus.Id)
    89  }
    90  
    91  func (s *statusUnitTestSuite) TestProcessMachinesWithEmbeddedContainers(c *gc.C) {
    92  
    93  	host := s.MakeMachine(c, &factory.MachineParams{InstanceId: instance.Id("1")})
    94  	lxcHost := s.MakeMachineNested(c, host.Id(), nil)
    95  	machines := map[string][]*state.Machine{
    96  		host.Id(): {
    97  			host,
    98  			lxcHost,
    99  			s.MakeMachineNested(c, lxcHost.Id(), nil),
   100  			s.MakeMachineNested(c, host.Id(), nil),
   101  		},
   102  	}
   103  
   104  	statuses := client.ProcessMachines(machines)
   105  	c.Assert(statuses, gc.Not(gc.IsNil))
   106  
   107  	hostContainer := statuses[host.Id()].Containers
   108  	c.Check(hostContainer, gc.HasLen, 2)
   109  	c.Check(hostContainer[lxcHost.Id()].Containers, gc.HasLen, 1)
   110  }