github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/state/environcapability_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package state_test
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"github.com/juju/errors"
    10  	jc "github.com/juju/testing/checkers"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/environs/config"
    14  	"github.com/juju/juju/instance"
    15  	"github.com/juju/juju/state"
    16  )
    17  
    18  type EnvironCapabilitySuite struct {
    19  	ConnSuite
    20  	capability mockEnvironCapability
    21  }
    22  
    23  var _ = gc.Suite(&EnvironCapabilitySuite{})
    24  
    25  type mockEnvironCapability struct {
    26  	supportsUnitPlacementError error
    27  }
    28  
    29  func (p *mockEnvironCapability) SupportedArchitectures() ([]string, error) {
    30  	panic("unused")
    31  }
    32  
    33  func (p *mockEnvironCapability) SupportsUnitPlacement() error {
    34  	return p.supportsUnitPlacementError
    35  }
    36  
    37  func (s *EnvironCapabilitySuite) SetUpTest(c *gc.C) {
    38  	s.ConnSuite.SetUpTest(c)
    39  	s.capability = mockEnvironCapability{}
    40  	s.policy.GetEnvironCapability = func(*config.Config) (state.EnvironCapability, error) {
    41  		return &s.capability, nil
    42  	}
    43  }
    44  
    45  func (s *EnvironCapabilitySuite) addOneMachine(c *gc.C) (*state.Machine, error) {
    46  	return s.State.AddOneMachine(state.MachineTemplate{
    47  		Series: "quantal",
    48  		Jobs:   []state.MachineJob{state.JobHostUnits},
    49  	})
    50  }
    51  
    52  func (s *EnvironCapabilitySuite) addOneMachineWithInstanceId(c *gc.C) (*state.Machine, error) {
    53  	return s.State.AddOneMachine(state.MachineTemplate{
    54  		Series:     "quantal",
    55  		Jobs:       []state.MachineJob{state.JobHostUnits},
    56  		InstanceId: "i-rate",
    57  		Nonce:      "ya",
    58  	})
    59  }
    60  
    61  func (s *EnvironCapabilitySuite) addMachineInsideNewMachine(c *gc.C) error {
    62  	template := state.MachineTemplate{
    63  		Series: "quantal",
    64  		Jobs:   []state.MachineJob{state.JobHostUnits},
    65  	}
    66  	_, err := s.State.AddMachineInsideNewMachine(template, template, instance.LXC)
    67  	return err
    68  }
    69  
    70  func (s *EnvironCapabilitySuite) TestSupportsUnitPlacementAddMachine(c *gc.C) {
    71  	// Ensure that AddOneMachine fails when SupportsUnitPlacement returns an error.
    72  	s.capability.supportsUnitPlacementError = fmt.Errorf("no add-machine for you")
    73  	_, err := s.addOneMachine(c)
    74  	c.Assert(err, gc.ErrorMatches, ".*no add-machine for you")
    75  	err = s.addMachineInsideNewMachine(c)
    76  	c.Assert(err, gc.ErrorMatches, ".*no add-machine for you")
    77  	// If the policy's EnvironCapability method fails, that will be returned first.
    78  	s.policy.GetEnvironCapability = func(*config.Config) (state.EnvironCapability, error) {
    79  		return nil, fmt.Errorf("incapable of EnvironCapability")
    80  	}
    81  	_, err = s.addOneMachine(c)
    82  	c.Assert(err, gc.ErrorMatches, ".*incapable of EnvironCapability")
    83  }
    84  
    85  func (s *EnvironCapabilitySuite) TestSupportsUnitPlacementAddMachineInstanceId(c *gc.C) {
    86  	// Ensure that AddOneMachine with a non-empty InstanceId does not fail.
    87  	s.capability.supportsUnitPlacementError = fmt.Errorf("no add-machine for you")
    88  	_, err := s.addOneMachineWithInstanceId(c)
    89  	c.Assert(err, jc.ErrorIsNil)
    90  }
    91  
    92  func (s *EnvironCapabilitySuite) TestSupportsUnitPlacementUnitAssignment(c *gc.C) {
    93  	m, err := s.addOneMachine(c)
    94  	c.Assert(err, jc.ErrorIsNil)
    95  
    96  	charm := s.AddTestingCharm(c, "wordpress")
    97  	service := s.AddTestingService(c, "wordpress", charm)
    98  	unit, err := service.AddUnit()
    99  	c.Assert(err, jc.ErrorIsNil)
   100  
   101  	s.capability.supportsUnitPlacementError = fmt.Errorf("no unit placement for you")
   102  	err = unit.AssignToMachine(m)
   103  	c.Assert(err, gc.ErrorMatches, ".*no unit placement for you")
   104  
   105  	err = unit.AssignToNewMachine()
   106  	c.Assert(err, jc.ErrorIsNil)
   107  }
   108  
   109  func (s *EnvironCapabilitySuite) TestEnvironCapabilityUnimplemented(c *gc.C) {
   110  	var capabilityErr error
   111  	s.policy.GetEnvironCapability = func(*config.Config) (state.EnvironCapability, error) {
   112  		return nil, capabilityErr
   113  	}
   114  	_, err := s.addOneMachine(c)
   115  	c.Assert(err, gc.ErrorMatches, "cannot add a new machine: policy returned nil EnvironCapability without an error")
   116  	capabilityErr = errors.NotImplementedf("EnvironCapability")
   117  	_, err = s.addOneMachine(c)
   118  	c.Assert(err, jc.ErrorIsNil)
   119  }
   120  
   121  func (s *EnvironCapabilitySuite) TestSupportsUnitPlacementNoPolicy(c *gc.C) {
   122  	s.policy.GetEnvironCapability = func(*config.Config) (state.EnvironCapability, error) {
   123  		c.Errorf("should not have been invoked")
   124  		return nil, nil
   125  	}
   126  	state.SetPolicy(s.State, nil)
   127  	_, err := s.addOneMachine(c)
   128  	c.Assert(err, jc.ErrorIsNil)
   129  }