github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/provider/gce/environ_policy_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package gce_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	jc "github.com/juju/testing/checkers"
     9  	"github.com/juju/utils/arch"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/constraints"
    13  	"github.com/juju/juju/provider/gce"
    14  	"github.com/juju/juju/provider/gce/google"
    15  	"github.com/juju/juju/testing"
    16  )
    17  
    18  type environPolSuite struct {
    19  	gce.BaseSuite
    20  }
    21  
    22  var _ = gc.Suite(&environPolSuite{})
    23  
    24  func (s *environPolSuite) TestPrecheckInstance(c *gc.C) {
    25  	cons := constraints.Value{}
    26  	placement := ""
    27  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
    28  
    29  	c.Check(err, jc.ErrorIsNil)
    30  }
    31  
    32  func (s *environPolSuite) TestPrecheckInstanceAPI(c *gc.C) {
    33  	s.FakeConn.Zones = []google.AvailabilityZone{
    34  		google.NewZone("a-zone", google.StatusUp, "", ""),
    35  	}
    36  
    37  	cons := constraints.Value{}
    38  	placement := ""
    39  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
    40  	c.Assert(err, jc.ErrorIsNil)
    41  
    42  	c.Check(s.FakeConn.Calls, gc.HasLen, 0)
    43  }
    44  
    45  func (s *environPolSuite) TestPrecheckInstanceFullAPI(c *gc.C) {
    46  	s.FakeConn.Zones = []google.AvailabilityZone{
    47  		google.NewZone("home-zone", google.StatusUp, "", ""),
    48  	}
    49  
    50  	cons := constraints.MustParse("instance-type=n1-standard-1 arch=amd64 root-disk=1G")
    51  	placement := "zone=home-zone"
    52  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
    53  	c.Assert(err, jc.ErrorIsNil)
    54  
    55  	c.Check(s.FakeConn.Calls, gc.HasLen, 1)
    56  	c.Check(s.FakeConn.Calls[0].FuncName, gc.Equals, "AvailabilityZones")
    57  	c.Check(s.FakeConn.Calls[0].Region, gc.Equals, "home")
    58  }
    59  
    60  func (s *environPolSuite) TestPrecheckInstanceValidInstanceType(c *gc.C) {
    61  	cons := constraints.MustParse("instance-type=n1-standard-1")
    62  	placement := ""
    63  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
    64  
    65  	c.Check(err, jc.ErrorIsNil)
    66  }
    67  
    68  func (s *environPolSuite) TestPrecheckInstanceInvalidInstanceType(c *gc.C) {
    69  	cons := constraints.MustParse("instance-type=n1-standard-1.invalid")
    70  	placement := ""
    71  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
    72  
    73  	c.Check(err, gc.ErrorMatches, `.*invalid GCE instance type.*`)
    74  }
    75  
    76  func (s *environPolSuite) TestPrecheckInstanceDiskSize(c *gc.C) {
    77  	cons := constraints.MustParse("instance-type=n1-standard-1 root-disk=1G")
    78  	placement := ""
    79  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
    80  
    81  	c.Check(err, jc.ErrorIsNil)
    82  }
    83  
    84  func (s *environPolSuite) TestPrecheckInstanceUnsupportedArch(c *gc.C) {
    85  	cons := constraints.MustParse("instance-type=n1-standard-1 arch=i386")
    86  	placement := ""
    87  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
    88  
    89  	c.Check(err, jc.ErrorIsNil)
    90  }
    91  
    92  func (s *environPolSuite) TestPrecheckInstanceAvailZone(c *gc.C) {
    93  	s.FakeConn.Zones = []google.AvailabilityZone{
    94  		google.NewZone("a-zone", google.StatusUp, "", ""),
    95  	}
    96  
    97  	cons := constraints.Value{}
    98  	placement := "zone=a-zone"
    99  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
   100  
   101  	c.Check(err, jc.ErrorIsNil)
   102  }
   103  
   104  func (s *environPolSuite) TestPrecheckInstanceAvailZoneUnavailable(c *gc.C) {
   105  	s.FakeConn.Zones = []google.AvailabilityZone{
   106  		google.NewZone("a-zone", google.StatusDown, "", ""),
   107  	}
   108  
   109  	cons := constraints.Value{}
   110  	placement := "zone=a-zone"
   111  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
   112  
   113  	c.Check(err, gc.ErrorMatches, `.*availability zone "a-zone" is DOWN`)
   114  }
   115  
   116  func (s *environPolSuite) TestPrecheckInstanceAvailZoneUnknown(c *gc.C) {
   117  	s.FakeConn.Zones = []google.AvailabilityZone{
   118  		google.NewZone("home-zone", google.StatusUp, "", ""),
   119  	}
   120  
   121  	cons := constraints.Value{}
   122  	placement := "zone=a-zone"
   123  	err := s.Env.PrecheckInstance(testing.FakeDefaultSeries, cons, placement)
   124  
   125  	c.Check(err, jc.Satisfies, errors.IsNotFound)
   126  }
   127  
   128  func (s *environPolSuite) TestSupportedArchitectures(c *gc.C) {
   129  	s.FakeCommon.Arches = []string{arch.AMD64}
   130  
   131  	archList, err := s.Env.SupportedArchitectures()
   132  	c.Assert(err, jc.ErrorIsNil)
   133  
   134  	c.Check(archList, jc.SameContents, []string{arch.AMD64})
   135  }
   136  
   137  func (s *environPolSuite) TestConstraintsValidator(c *gc.C) {
   138  	s.FakeCommon.Arches = []string{arch.AMD64}
   139  
   140  	validator, err := s.Env.ConstraintsValidator()
   141  	c.Assert(err, jc.ErrorIsNil)
   142  
   143  	cons := constraints.MustParse("arch=amd64")
   144  	unsupported, err := validator.Validate(cons)
   145  	c.Assert(err, jc.ErrorIsNil)
   146  
   147  	c.Check(unsupported, gc.HasLen, 0)
   148  }
   149  
   150  func (s *environPolSuite) TestConstraintsValidatorEmpty(c *gc.C) {
   151  	validator, err := s.Env.ConstraintsValidator()
   152  	c.Assert(err, jc.ErrorIsNil)
   153  
   154  	unsupported, err := validator.Validate(constraints.Value{})
   155  	c.Assert(err, jc.ErrorIsNil)
   156  
   157  	c.Check(unsupported, gc.HasLen, 0)
   158  }
   159  
   160  func (s *environPolSuite) TestConstraintsValidatorUnsupported(c *gc.C) {
   161  	s.FakeCommon.Arches = []string{arch.AMD64}
   162  
   163  	validator, err := s.Env.ConstraintsValidator()
   164  	c.Assert(err, jc.ErrorIsNil)
   165  
   166  	cons := constraints.MustParse("arch=amd64 tags=foo virt-type=kvm")
   167  	unsupported, err := validator.Validate(cons)
   168  	c.Assert(err, jc.ErrorIsNil)
   169  
   170  	c.Check(unsupported, jc.SameContents, []string{"tags", "virt-type"})
   171  }
   172  
   173  func (s *environPolSuite) TestConstraintsValidatorVocabArch(c *gc.C) {
   174  	s.FakeCommon.Arches = []string{arch.AMD64}
   175  
   176  	validator, err := s.Env.ConstraintsValidator()
   177  	c.Assert(err, jc.ErrorIsNil)
   178  
   179  	cons := constraints.MustParse("arch=ppc64el")
   180  	_, err = validator.Validate(cons)
   181  
   182  	c.Check(err, gc.ErrorMatches, "invalid constraint value: arch=ppc64el\nvalid values are:.*")
   183  }
   184  
   185  func (s *environPolSuite) TestConstraintsValidatorVocabInstType(c *gc.C) {
   186  	validator, err := s.Env.ConstraintsValidator()
   187  	c.Assert(err, jc.ErrorIsNil)
   188  
   189  	cons := constraints.MustParse("instance-type=foo")
   190  	_, err = validator.Validate(cons)
   191  
   192  	c.Check(err, gc.ErrorMatches, "invalid constraint value: instance-type=foo\nvalid values are:.*")
   193  }
   194  
   195  func (s *environPolSuite) TestConstraintsValidatorVocabContainer(c *gc.C) {
   196  	validator, err := s.Env.ConstraintsValidator()
   197  	c.Assert(err, jc.ErrorIsNil)
   198  
   199  	cons := constraints.MustParse("container=lxc")
   200  	_, err = validator.Validate(cons)
   201  
   202  	c.Check(err, gc.ErrorMatches, "invalid constraint value: container=lxc\nvalid values are:.*")
   203  }
   204  
   205  func (s *environPolSuite) TestConstraintsValidatorConflicts(c *gc.C) {
   206  	s.FakeCommon.Arches = []string{arch.AMD64}
   207  
   208  	validator, err := s.Env.ConstraintsValidator()
   209  	c.Assert(err, jc.ErrorIsNil)
   210  
   211  	cons := constraints.MustParse("instance-type=n1-standard-1")
   212  	// We do not check arch or container since there is only one valid
   213  	// value for each and will always match.
   214  	consFallback := constraints.MustParse("cpu-cores=2 cpu-power=1000 mem=10000 tags=bar")
   215  	merged, err := validator.Merge(consFallback, cons)
   216  	c.Assert(err, jc.ErrorIsNil)
   217  
   218  	// tags is not supported, but we're not validating here...
   219  	expected := constraints.MustParse("instance-type=n1-standard-1 tags=bar")
   220  	c.Check(merged, jc.DeepEquals, expected)
   221  }
   222  
   223  func (s *environPolSuite) TestSupportNetworks(c *gc.C) {
   224  	isSupported := s.Env.SupportNetworks()
   225  
   226  	c.Check(isSupported, jc.IsFalse)
   227  }
   228  
   229  func (s *environPolSuite) TestSupportAddressAllocation(c *gc.C) {
   230  	isSupported, err := s.Env.SupportAddressAllocation("some-network")
   231  	c.Assert(err, jc.ErrorIsNil)
   232  
   233  	c.Check(isSupported, jc.IsFalse)
   234  }
   235  
   236  func (s *environPolSuite) TestSupportAddressAllocationEmpty(c *gc.C) {
   237  	isSupported, err := s.Env.SupportAddressAllocation("")
   238  	c.Assert(err, jc.ErrorIsNil)
   239  
   240  	c.Check(isSupported, jc.IsFalse)
   241  }