← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/provider/cloudsigma/environinstance_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/cloudsigma/environinstance_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package cloudsigma
 
5
 
 
6
import (
 
7
        "time"
 
8
 
 
9
        "github.com/altoros/gosigma/mock"
 
10
        "github.com/juju/errors"
 
11
        "github.com/juju/loggo"
 
12
        jc "github.com/juju/testing/checkers"
 
13
        "github.com/juju/version"
 
14
        gc "gopkg.in/check.v1"
 
15
 
 
16
        "github.com/juju/juju/cloudconfig/instancecfg"
 
17
        "github.com/juju/juju/environs"
 
18
        "github.com/juju/juju/environs/config"
 
19
        "github.com/juju/juju/environs/imagemetadata"
 
20
        "github.com/juju/juju/instance"
 
21
        "github.com/juju/juju/testing"
 
22
        "github.com/juju/juju/tools"
 
23
)
 
24
 
 
25
type environInstanceSuite struct {
 
26
        testing.BaseSuite
 
27
        cloud      environs.CloudSpec
 
28
        baseConfig *config.Config
 
29
}
 
30
 
 
31
var _ = gc.Suite(&environInstanceSuite{})
 
32
 
 
33
func (s *environInstanceSuite) SetUpSuite(c *gc.C) {
 
34
        s.BaseSuite.SetUpSuite(c)
 
35
 
 
36
        mock.Start()
 
37
 
 
38
        s.cloud = fakeCloudSpec()
 
39
        s.cloud.Endpoint = mock.Endpoint("")
 
40
 
 
41
        attrs := testing.Attrs{
 
42
                "name": "testname",
 
43
                "uuid": "f54aac3a-9dcd-4a0c-86b5-24091478478c",
 
44
        }
 
45
        s.baseConfig = newConfig(c, validAttrs().Merge(attrs))
 
46
}
 
47
 
 
48
func (s *environInstanceSuite) TearDownSuite(c *gc.C) {
 
49
        mock.Stop()
 
50
        s.BaseSuite.TearDownSuite(c)
 
51
}
 
52
 
 
53
func (s *environInstanceSuite) SetUpTest(c *gc.C) {
 
54
        s.BaseSuite.SetUpTest(c)
 
55
 
 
56
        ll := logger.LogLevel()
 
57
        logger.SetLogLevel(loggo.TRACE)
 
58
        s.AddCleanup(func(*gc.C) { logger.SetLogLevel(ll) })
 
59
 
 
60
        mock.Reset()
 
61
}
 
62
 
 
63
func (s *environInstanceSuite) TearDownTest(c *gc.C) {
 
64
        mock.Reset()
 
65
        s.BaseSuite.TearDownTest(c)
 
66
}
 
67
 
 
68
func (s *environInstanceSuite) createEnviron(c *gc.C, cfg *config.Config) environs.Environ {
 
69
        s.PatchValue(&findInstanceImage, func([]*imagemetadata.ImageMetadata) (*imagemetadata.ImageMetadata, error) {
 
70
                img := &imagemetadata.ImageMetadata{
 
71
                        Id: validImageId,
 
72
                }
 
73
                return img, nil
 
74
        })
 
75
        if cfg == nil {
 
76
                cfg = s.baseConfig
 
77
        }
 
78
 
 
79
        environ, err := environs.New(environs.OpenParams{
 
80
                Cloud:  s.cloud,
 
81
                Config: cfg,
 
82
        })
 
83
 
 
84
        c.Assert(err, gc.IsNil)
 
85
        c.Assert(environ, gc.NotNil)
 
86
        return environ
 
87
}
 
88
 
 
89
func (s *environInstanceSuite) TestInstances(c *gc.C) {
 
90
        env := s.createEnviron(c, nil)
 
91
 
 
92
        instances, err := env.AllInstances()
 
93
        c.Assert(instances, gc.NotNil)
 
94
        c.Assert(err, gc.IsNil)
 
95
        c.Check(instances, gc.HasLen, 0)
 
96
 
 
97
        uuid0 := addTestClientServer(c, jujuMetaInstanceServer, "f54aac3a-9dcd-4a0c-86b5-24091478478c")
 
98
        uuid1 := addTestClientServer(c, jujuMetaInstanceController, "f54aac3a-9dcd-4a0c-86b5-24091478478c")
 
99
        addTestClientServer(c, jujuMetaInstanceServer, "other-model")
 
100
        addTestClientServer(c, jujuMetaInstanceController, "other-model")
 
101
 
 
102
        instances, err = env.AllInstances()
 
103
        c.Assert(instances, gc.NotNil)
 
104
        c.Assert(err, gc.IsNil)
 
105
        c.Check(instances, gc.HasLen, 2)
 
106
 
 
107
        ids := []instance.Id{instance.Id(uuid0), instance.Id(uuid1)}
 
108
        instances, err = env.Instances(ids)
 
109
        c.Assert(instances, gc.NotNil)
 
110
        c.Assert(err, gc.IsNil)
 
111
        c.Check(instances, gc.HasLen, 2)
 
112
 
 
113
        ids = append(ids, instance.Id("fake-instance"))
 
114
        instances, err = env.Instances(ids)
 
115
        c.Assert(instances, gc.NotNil)
 
116
        c.Assert(errors.Cause(err), gc.Equals, environs.ErrPartialInstances)
 
117
        c.Check(instances, gc.HasLen, 3)
 
118
        c.Check(instances[0], gc.NotNil)
 
119
        c.Check(instances[1], gc.NotNil)
 
120
        c.Check(instances[2], gc.IsNil)
 
121
 
 
122
        err = env.StopInstances(ids...)
 
123
        c.Assert(err, gc.ErrorMatches, "404 Not Found.*")
 
124
 
 
125
        instances, err = env.Instances(ids)
 
126
        c.Assert(instances, gc.NotNil)
 
127
        c.Assert(errors.Cause(err), gc.Equals, environs.ErrNoInstances)
 
128
        c.Check(instances, gc.HasLen, 3)
 
129
        c.Check(instances[0], gc.IsNil)
 
130
        c.Check(instances[1], gc.IsNil)
 
131
        c.Check(instances[2], gc.IsNil)
 
132
}
 
133
 
 
134
func (s *environInstanceSuite) TestInstancesFail(c *gc.C) {
 
135
 
 
136
        newClientFunc := newClient
 
137
        s.PatchValue(&newClient, func(spec environs.CloudSpec, uuid string) (*environClient, error) {
 
138
                spec.Endpoint = "https://0.1.2.3:2000/api/2.0/"
 
139
                cli, err := newClientFunc(spec, uuid)
 
140
                if cli != nil {
 
141
                        cli.conn.ConnectTimeout(10 * time.Millisecond)
 
142
                }
 
143
                return cli, err
 
144
        })
 
145
 
 
146
        environ := s.createEnviron(c, nil)
 
147
 
 
148
        instances, err := environ.AllInstances()
 
149
        c.Assert(instances, gc.IsNil)
 
150
        c.Assert(err, gc.NotNil)
 
151
 
 
152
        instances, err = environ.Instances([]instance.Id{instance.Id("123"), instance.Id("321")})
 
153
        c.Assert(instances, gc.IsNil)
 
154
        c.Assert(err, gc.NotNil)
 
155
}
 
156
 
 
157
func (s *environInstanceSuite) TestStartInstanceError(c *gc.C) {
 
158
        environ := s.createEnviron(c, nil)
 
159
 
 
160
        res, err := environ.StartInstance(environs.StartInstanceParams{})
 
161
        c.Check(res, gc.IsNil)
 
162
        c.Check(err, gc.ErrorMatches, "instance configuration is nil")
 
163
 
 
164
        toolsVal := &tools.Tools{
 
165
                Version: version.Binary{
 
166
                        Series: "trusty",
 
167
                },
 
168
                URL: "https://0.1.2.3:2000/x.y.z.tgz",
 
169
        }
 
170
 
 
171
        res, err = environ.StartInstance(environs.StartInstanceParams{
 
172
                InstanceConfig: &instancecfg.InstanceConfig{},
 
173
        })
 
174
        c.Check(res, gc.IsNil)
 
175
        c.Check(err, gc.ErrorMatches, "tools not found")
 
176
 
 
177
        icfg := &instancecfg.InstanceConfig{}
 
178
        err = icfg.SetTools(tools.List{toolsVal})
 
179
        c.Assert(err, jc.ErrorIsNil)
 
180
        res, err = environ.StartInstance(environs.StartInstanceParams{
 
181
                Tools:          tools.List{toolsVal},
 
182
                InstanceConfig: icfg,
 
183
        })
 
184
        c.Check(res, gc.IsNil)
 
185
        c.Check(err, gc.ErrorMatches, "cannot make user data: series \"\" not valid")
 
186
}