github.com/Pankov404/juju@v0.0.0-20150703034450-be266991dceb/provider/gce/google/instance_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package google_test
     5  
     6  import (
     7  	jc "github.com/juju/testing/checkers"
     8  	"google.golang.org/api/compute/v1"
     9  	gc "gopkg.in/check.v1"
    10  
    11  	"github.com/juju/juju/provider/gce/google"
    12  )
    13  
    14  type instanceSuite struct {
    15  	google.BaseSuite
    16  }
    17  
    18  var _ = gc.Suite(&instanceSuite{})
    19  
    20  func (s *instanceSuite) TestNewInstance(c *gc.C) {
    21  	inst := google.NewInstanceRaw(&s.RawInstanceFull, &s.InstanceSpec)
    22  
    23  	c.Check(inst.ID, gc.Equals, "spam")
    24  	c.Check(inst.ZoneName, gc.Equals, "a-zone")
    25  	c.Check(inst.Status(), gc.Equals, google.StatusRunning)
    26  	c.Check(inst.Metadata(), jc.DeepEquals, s.Metadata)
    27  	c.Check(inst.Addresses(), jc.DeepEquals, s.Addresses)
    28  	spec := google.GetInstanceSpec(inst)
    29  	c.Check(spec, jc.DeepEquals, &s.InstanceSpec)
    30  }
    31  
    32  func (s *instanceSuite) TestNewInstanceNoSpec(c *gc.C) {
    33  	inst := google.NewInstanceRaw(&s.RawInstanceFull, nil)
    34  
    35  	spec := google.GetInstanceSpec(inst)
    36  	c.Check(spec, gc.IsNil)
    37  }
    38  
    39  func (s *instanceSuite) TestInstanceRootDiskGB(c *gc.C) {
    40  	size := s.Instance.RootDiskGB()
    41  
    42  	c.Check(size, gc.Equals, uint64(15))
    43  }
    44  
    45  func (s *instanceSuite) TestInstanceRootDiskGBNilSpec(c *gc.C) {
    46  	inst := google.Instance{}
    47  	size := inst.RootDiskGB()
    48  
    49  	c.Check(size, gc.Equals, uint64(0))
    50  }
    51  
    52  func (s *instanceSuite) TestInstanceStatus(c *gc.C) {
    53  	status := s.Instance.Status()
    54  
    55  	c.Check(status, gc.Equals, google.StatusRunning)
    56  }
    57  
    58  func (s *instanceSuite) TestInstanceStatusDown(c *gc.C) {
    59  	s.Instance.InstanceSummary.Status = google.StatusDown
    60  	status := s.Instance.Status()
    61  
    62  	c.Check(status, gc.Equals, google.StatusDown)
    63  }
    64  
    65  func (s *instanceSuite) TestInstanceRefresh(c *gc.C) {
    66  	s.FakeConn.Instance = &s.RawInstanceFull
    67  
    68  	specBefore := google.GetInstanceSpec(&s.Instance)
    69  	err := s.Instance.Refresh(s.Conn)
    70  	c.Assert(err, jc.ErrorIsNil)
    71  	specAfter := google.GetInstanceSpec(&s.Instance)
    72  
    73  	c.Check(s.Instance.ID, gc.Equals, "spam")
    74  	c.Check(s.Instance.ZoneName, gc.Equals, "a-zone")
    75  	c.Check(s.Instance.Status(), gc.Equals, google.StatusRunning)
    76  	c.Check(s.Instance.Metadata(), jc.DeepEquals, s.Metadata)
    77  	c.Check(s.Instance.Addresses(), jc.DeepEquals, s.Addresses)
    78  	c.Check(specAfter, gc.Equals, specBefore)
    79  }
    80  
    81  func (s *instanceSuite) TestInstanceRefreshAPI(c *gc.C) {
    82  	s.FakeConn.Instance = &s.RawInstanceFull
    83  
    84  	err := s.Instance.Refresh(s.Conn)
    85  	c.Assert(err, jc.ErrorIsNil)
    86  
    87  	c.Check(s.FakeConn.Calls, gc.HasLen, 1)
    88  	c.Check(s.FakeConn.Calls[0].FuncName, gc.Equals, "GetInstance")
    89  	c.Check(s.FakeConn.Calls[0].ProjectID, gc.Equals, "spam")
    90  	c.Check(s.FakeConn.Calls[0].ZoneName, gc.Equals, "a-zone")
    91  	c.Check(s.FakeConn.Calls[0].ID, gc.Equals, "spam")
    92  }
    93  
    94  func (s *instanceSuite) TestInstanceAddresses(c *gc.C) {
    95  	addresses := s.Instance.Addresses()
    96  
    97  	c.Check(addresses, jc.DeepEquals, s.Addresses)
    98  }
    99  
   100  func (s *instanceSuite) TestInstanceMetadata(c *gc.C) {
   101  	metadata := s.Instance.Metadata()
   102  
   103  	c.Check(metadata, jc.DeepEquals, map[string]string{"eggs": "steak"})
   104  }
   105  
   106  func (s *instanceSuite) TestFormatAuthorizedKeys(c *gc.C) {
   107  	formatted, err := google.FormatAuthorizedKeys("abcd", "john")
   108  	c.Assert(err, jc.ErrorIsNil)
   109  
   110  	c.Check(formatted, gc.Equals, "john:abcd\n")
   111  }
   112  
   113  func (s *instanceSuite) TestFormatAuthorizedKeysEmpty(c *gc.C) {
   114  	_, err := google.FormatAuthorizedKeys("", "john")
   115  
   116  	c.Check(err, gc.ErrorMatches, "empty rawAuthorizedKeys")
   117  }
   118  
   119  func (s *instanceSuite) TestFormatAuthorizedKeysNoUser(c *gc.C) {
   120  	_, err := google.FormatAuthorizedKeys("abcd", "")
   121  
   122  	c.Check(err, gc.ErrorMatches, "empty user")
   123  }
   124  
   125  func (s *instanceSuite) TestFormatAuthorizedKeysMultiple(c *gc.C) {
   126  	formatted, err := google.FormatAuthorizedKeys("abcd\ndcba\nqwer", "john")
   127  	c.Assert(err, jc.ErrorIsNil)
   128  
   129  	c.Check(formatted, gc.Equals, "john:abcd\njohn:dcba\njohn:qwer\n")
   130  }
   131  
   132  func (s *instanceSuite) TestPackMetadata(c *gc.C) {
   133  	expected := compute.Metadata{Items: []*compute.MetadataItems{{
   134  		Key:   "spam",
   135  		Value: "eggs",
   136  	}}}
   137  	data := map[string]string{"spam": "eggs"}
   138  	packed := google.PackMetadata(data)
   139  
   140  	c.Check(packed, jc.DeepEquals, &expected)
   141  }
   142  
   143  func (s *instanceSuite) TestUnpackMetadata(c *gc.C) {
   144  	expected := map[string]string{"spam": "eggs"}
   145  	packed := compute.Metadata{Items: []*compute.MetadataItems{{
   146  		Key:   "spam",
   147  		Value: "eggs",
   148  	}}}
   149  	data := google.UnpackMetadata(&packed)
   150  
   151  	c.Check(data, jc.DeepEquals, expected)
   152  }
   153  
   154  func (s *instanceSuite) TestFormatMachineType(c *gc.C) {
   155  	resolved := google.FormatMachineType("a-zone", "spam")
   156  
   157  	c.Check(resolved, gc.Equals, "zones/a-zone/machineTypes/spam")
   158  }