github.com/cloud-green/juju@v0.0.0-20151002100041-a00291338d3d/provider/gce/environ_broker_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  	"errors"
     8  
     9  	jc "github.com/juju/testing/checkers"
    10  	"github.com/juju/utils/arch"
    11  	jujuos "github.com/juju/utils/os"
    12  	gc "gopkg.in/check.v1"
    13  
    14  	"github.com/juju/juju/apiserver/params"
    15  	"github.com/juju/juju/environs/imagemetadata"
    16  	"github.com/juju/juju/environs/instances"
    17  	"github.com/juju/juju/environs/simplestreams"
    18  	"github.com/juju/juju/instance"
    19  	"github.com/juju/juju/network"
    20  	"github.com/juju/juju/provider/common"
    21  	"github.com/juju/juju/provider/gce"
    22  	"github.com/juju/juju/testing"
    23  )
    24  
    25  type environBrokerSuite struct {
    26  	gce.BaseSuite
    27  
    28  	hardware      *instance.HardwareCharacteristics
    29  	spec          *instances.InstanceSpec
    30  	ic            *instances.InstanceConstraint
    31  	imageMetadata []*imagemetadata.ImageMetadata
    32  	resolveInfo   *simplestreams.ResolveInfo
    33  }
    34  
    35  var _ = gc.Suite(&environBrokerSuite{})
    36  
    37  func (s *environBrokerSuite) SetUpTest(c *gc.C) {
    38  	s.BaseSuite.SetUpTest(c)
    39  
    40  	mem := uint64(3750)
    41  	amd64 := arch.AMD64
    42  	cpuCores := uint64(1)
    43  	rootDiskMB := uint64(5)
    44  	zoneName := "home-zone"
    45  
    46  	s.hardware = &instance.HardwareCharacteristics{
    47  		Arch:             &amd64,
    48  		Mem:              &mem,
    49  		CpuCores:         &cpuCores,
    50  		CpuPower:         instances.CpuPower(275),
    51  		RootDisk:         &rootDiskMB,
    52  		AvailabilityZone: &zoneName,
    53  	}
    54  	s.spec = &instances.InstanceSpec{
    55  		InstanceType: s.InstanceType,
    56  		Image: instances.Image{
    57  			Id:       "ubuntu-1404-trusty-v20141212",
    58  			Arch:     amd64,
    59  			VirtType: "kvm",
    60  		},
    61  	}
    62  	s.ic = &instances.InstanceConstraint{
    63  		Region:      "home",
    64  		Series:      "trusty",
    65  		Arches:      []string{amd64},
    66  		Constraints: s.StartInstArgs.Constraints,
    67  	}
    68  	s.imageMetadata = []*imagemetadata.ImageMetadata{{
    69  		Id:         "ubuntu-1404-trusty-v20141212",
    70  		Arch:       "amd64",
    71  		Version:    "14.04",
    72  		RegionName: "us-central1",
    73  		Endpoint:   "https://www.googleapis.com",
    74  		Stream:     "<stream>",
    75  		VirtType:   "kvm",
    76  	}}
    77  	s.resolveInfo = &simplestreams.ResolveInfo{
    78  		Source:    "",
    79  		Signed:    true,
    80  		IndexURL:  "",
    81  		MirrorURL: "",
    82  	}
    83  }
    84  
    85  func (s *environBrokerSuite) TestStartInstance(c *gc.C) {
    86  	s.FakeEnviron.Spec = s.spec
    87  	s.FakeEnviron.Inst = s.BaseInstance
    88  	s.FakeEnviron.Hwc = s.hardware
    89  
    90  	result, err := s.Env.StartInstance(s.StartInstArgs)
    91  
    92  	c.Assert(err, jc.ErrorIsNil)
    93  	c.Check(result.Instance, gc.DeepEquals, s.Instance)
    94  	c.Check(result.Hardware, gc.DeepEquals, s.hardware)
    95  }
    96  
    97  func (s *environBrokerSuite) TestStartInstanceOpensAPIPort(c *gc.C) {
    98  	s.FakeEnviron.Spec = s.spec
    99  	s.FakeEnviron.Inst = s.BaseInstance
   100  	s.FakeEnviron.Hwc = s.hardware
   101  
   102  	// Get the API port from the fake environment config used to
   103  	// "bootstrap".
   104  	envConfig := testing.FakeConfig()
   105  	apiPort, ok := envConfig["api-port"].(int)
   106  	c.Assert(ok, jc.IsTrue)
   107  	c.Assert(apiPort, gc.Not(gc.Equals), 0)
   108  
   109  	// When StateServingInfo is not nil, verify OpenPorts was called
   110  	// for the API port.
   111  	s.StartInstArgs.InstanceConfig.StateServingInfo = &params.StateServingInfo{
   112  		APIPort: apiPort,
   113  	}
   114  
   115  	result, err := s.Env.StartInstance(s.StartInstArgs)
   116  
   117  	c.Assert(err, jc.ErrorIsNil)
   118  	c.Check(result.Instance, gc.DeepEquals, s.Instance)
   119  	c.Check(result.Hardware, gc.DeepEquals, s.hardware)
   120  
   121  	called, calls := s.FakeConn.WasCalled("OpenPorts")
   122  	c.Check(called, gc.Equals, true)
   123  	c.Check(calls, gc.HasLen, 1)
   124  	c.Check(calls[0].FirewallName, gc.Equals, gce.GlobalFirewallName(s.Env))
   125  	expectPorts := []network.PortRange{{
   126  		FromPort: apiPort,
   127  		ToPort:   apiPort,
   128  		Protocol: "tcp",
   129  	}}
   130  	c.Check(calls[0].PortRanges, jc.DeepEquals, expectPorts)
   131  }
   132  
   133  func (s *environBrokerSuite) TestFinishInstanceConfig(c *gc.C) {
   134  	err := gce.FinishInstanceConfig(s.Env, s.StartInstArgs, s.spec)
   135  
   136  	c.Assert(err, jc.ErrorIsNil)
   137  	c.Check(s.StartInstArgs.InstanceConfig.Tools, gc.NotNil)
   138  }
   139  
   140  func (s *environBrokerSuite) TestBuildInstanceSpec(c *gc.C) {
   141  	s.FakeEnviron.Spec = s.spec
   142  
   143  	spec, err := gce.BuildInstanceSpec(s.Env, s.StartInstArgs)
   144  
   145  	c.Assert(err, jc.ErrorIsNil)
   146  	c.Check(spec.InstanceType, gc.DeepEquals, s.InstanceType)
   147  }
   148  
   149  func (s *environBrokerSuite) TestFindInstanceSpec(c *gc.C) {
   150  	s.FakeImages.Metadata = s.imageMetadata
   151  	s.FakeImages.ResolveInfo = s.resolveInfo
   152  
   153  	spec, err := gce.FindInstanceSpec(s.Env, s.Env.Config().ImageStream(), s.ic)
   154  
   155  	c.Assert(err, jc.ErrorIsNil)
   156  	c.Check(spec, gc.DeepEquals, s.spec)
   157  }
   158  
   159  func (s *environBrokerSuite) TestNewRawInstance(c *gc.C) {
   160  	s.FakeConn.Inst = s.BaseInstance
   161  	s.FakeCommon.AZInstances = []common.AvailabilityZoneInstances{{
   162  		ZoneName:  "home-zone",
   163  		Instances: []instance.Id{s.Instance.Id()},
   164  	}}
   165  
   166  	inst, err := gce.NewRawInstance(s.Env, s.StartInstArgs, s.spec)
   167  
   168  	c.Assert(err, jc.ErrorIsNil)
   169  	c.Check(inst, gc.DeepEquals, s.BaseInstance)
   170  }
   171  
   172  func (s *environBrokerSuite) TestGetMetadataUbuntu(c *gc.C) {
   173  	metadata, err := gce.GetMetadata(s.StartInstArgs, jujuos.Ubuntu)
   174  
   175  	c.Assert(err, jc.ErrorIsNil)
   176  	c.Check(metadata, gc.DeepEquals, s.UbuntuMetadata)
   177  
   178  }
   179  
   180  func (s *environBrokerSuite) TestGetMetadataWindows(c *gc.C) {
   181  	metadata, err := gce.GetMetadata(s.StartInstArgs, jujuos.Windows)
   182  
   183  	c.Assert(err, jc.ErrorIsNil)
   184  	c.Check(metadata["windows-startup-script-ps1"], gc.Equals, s.WindowsMetadata["windows-startup-script-ps1"])
   185  	c.Check(metadata["sysprep-specialize-script-ps1"], gc.Matches, s.WindowsMetadata["sysprep-specialize-script-ps1"])
   186  }
   187  
   188  func (s *environBrokerSuite) TestGetMetadataOSNotSupported(c *gc.C) {
   189  	metadata, err := gce.GetMetadata(s.StartInstArgs, jujuos.Arch)
   190  
   191  	c.Assert(metadata, gc.IsNil)
   192  	c.Assert(err, gc.ErrorMatches, "cannot pack metadata for os Arch on the gce provider")
   193  }
   194  
   195  var getDisksTests = []struct {
   196  	OS       jujuos.OSType
   197  	basePath string
   198  	error    error
   199  }{
   200  	{jujuos.Ubuntu, gce.UbuntuImageBasePath, nil},
   201  	{jujuos.Windows, gce.WindowsImageBasePath, nil},
   202  	{jujuos.Arch, "", errors.New("os Arch is not supported on the gce provider")},
   203  }
   204  
   205  func (s *environBrokerSuite) TestGetDisks(c *gc.C) {
   206  	for _, test := range getDisksTests {
   207  		diskSpecs, err := gce.GetDisks(s.spec, s.StartInstArgs.Constraints, test.OS)
   208  		if test.error != nil {
   209  			c.Assert(err, gc.Equals, err)
   210  		} else {
   211  			c.Assert(err, jc.ErrorIsNil)
   212  			c.Assert(diskSpecs, gc.HasLen, 1)
   213  
   214  			diskSpec := diskSpecs[0]
   215  
   216  			c.Check(diskSpec.SizeHintGB, gc.Equals, uint64(8))
   217  			c.Check(diskSpec.ImageURL, gc.Equals, test.basePath+s.spec.Image.Id)
   218  		}
   219  	}
   220  }
   221  
   222  func (s *environBrokerSuite) TestGetHardwareCharacteristics(c *gc.C) {
   223  	hwc := gce.GetHardwareCharacteristics(s.Env, s.spec, s.Instance)
   224  
   225  	c.Assert(hwc, gc.NotNil)
   226  	c.Check(*hwc.Arch, gc.Equals, "amd64")
   227  	c.Check(*hwc.AvailabilityZone, gc.Equals, "home-zone")
   228  	c.Check(*hwc.CpuCores, gc.Equals, uint64(1))
   229  	c.Check(*hwc.CpuPower, gc.Equals, uint64(275))
   230  	c.Check(*hwc.Mem, gc.Equals, uint64(3750))
   231  	c.Check(*hwc.RootDisk, gc.Equals, uint64(15360))
   232  }
   233  
   234  func (s *environBrokerSuite) TestAllInstances(c *gc.C) {
   235  	s.FakeEnviron.Insts = []instance.Instance{s.Instance}
   236  
   237  	insts, err := s.Env.AllInstances()
   238  	c.Assert(err, jc.ErrorIsNil)
   239  	c.Check(insts, jc.DeepEquals, []instance.Instance{s.Instance})
   240  }
   241  
   242  func (s *environBrokerSuite) TestStopInstances(c *gc.C) {
   243  	err := s.Env.StopInstances(s.Instance.Id())
   244  	c.Assert(err, jc.ErrorIsNil)
   245  
   246  	called, calls := s.FakeConn.WasCalled("RemoveInstances")
   247  	c.Check(called, gc.Equals, true)
   248  	c.Check(calls, gc.HasLen, 1)
   249  	c.Check(calls[0].Prefix, gc.Equals, "juju-2d02eeac-9dbb-11e4-89d3-123b93f75cba-machine-")
   250  	c.Check(calls[0].IDs, gc.DeepEquals, []string{"spam"})
   251  }