← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/provider/gce/google/instance_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/provider/gce/google/instance_test.go
 
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) TestInstanceAddresses(c *gc.C) {
 
66
        addresses := s.Instance.Addresses()
 
67
 
 
68
        c.Check(addresses, jc.DeepEquals, s.Addresses)
 
69
}
 
70
 
 
71
func (s *instanceSuite) TestInstanceMetadata(c *gc.C) {
 
72
        metadata := s.Instance.Metadata()
 
73
 
 
74
        c.Check(metadata, jc.DeepEquals, map[string]string{"eggs": "steak"})
 
75
}
 
76
 
 
77
func (s *instanceSuite) TestFormatAuthorizedKeys(c *gc.C) {
 
78
        formatted, err := google.FormatAuthorizedKeys("abcd", "john")
 
79
        c.Assert(err, jc.ErrorIsNil)
 
80
 
 
81
        c.Check(formatted, gc.Equals, "john:abcd\n")
 
82
}
 
83
 
 
84
func (s *instanceSuite) TestFormatAuthorizedKeysEmpty(c *gc.C) {
 
85
        _, err := google.FormatAuthorizedKeys("", "john")
 
86
 
 
87
        c.Check(err, gc.ErrorMatches, "empty rawAuthorizedKeys")
 
88
}
 
89
 
 
90
func (s *instanceSuite) TestFormatAuthorizedKeysNoUser(c *gc.C) {
 
91
        _, err := google.FormatAuthorizedKeys("abcd", "")
 
92
 
 
93
        c.Check(err, gc.ErrorMatches, "empty user")
 
94
}
 
95
 
 
96
func (s *instanceSuite) TestFormatAuthorizedKeysMultiple(c *gc.C) {
 
97
        formatted, err := google.FormatAuthorizedKeys("abcd\ndcba\nqwer", "john")
 
98
        c.Assert(err, jc.ErrorIsNil)
 
99
 
 
100
        c.Check(formatted, gc.Equals, "john:abcd\njohn:dcba\njohn:qwer\n")
 
101
}
 
102
 
 
103
func (s *instanceSuite) TestPackMetadata(c *gc.C) {
 
104
        expected := compute.Metadata{Items: []*compute.MetadataItems{{
 
105
                Key:   "spam",
 
106
                Value: "eggs",
 
107
        }}}
 
108
        data := map[string]string{"spam": "eggs"}
 
109
        packed := google.PackMetadata(data)
 
110
 
 
111
        c.Check(packed, jc.DeepEquals, &expected)
 
112
}
 
113
 
 
114
func (s *instanceSuite) TestUnpackMetadata(c *gc.C) {
 
115
        expected := map[string]string{"spam": "eggs"}
 
116
        packed := compute.Metadata{Items: []*compute.MetadataItems{{
 
117
                Key:   "spam",
 
118
                Value: "eggs",
 
119
        }}}
 
120
        data := google.UnpackMetadata(&packed)
 
121
 
 
122
        c.Check(data, jc.DeepEquals, expected)
 
123
}
 
124
 
 
125
func (s *instanceSuite) TestFormatMachineType(c *gc.C) {
 
126
        resolved := google.FormatMachineType("a-zone", "spam")
 
127
 
 
128
        c.Check(resolved, gc.Equals, "zones/a-zone/machineTypes/spam")
 
129
}