← Back to branch summary

~juju-qa/ubuntu/trusty/juju/juju-1.25.8

« back to all changes in this revision

Viewing changes to src/github.com/altoros/gosigma/client_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-12-02 18:01:10 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161202180110-dl1helep8qfebmhx
Import upstream 1.25.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/altoros/gosigma/client_test.go
 
1
// Copyright 2014 ALTOROS
 
2
// Licensed under the AGPLv3, see LICENSE file for details.
 
3
 
 
4
package gosigma
 
5
 
 
6
import (
 
7
        "testing"
 
8
        "time"
 
9
 
 
10
        "github.com/altoros/gosigma/data"
 
11
        "github.com/altoros/gosigma/mock"
 
12
)
 
13
 
 
14
var mockEndpoint string
 
15
 
 
16
func init() {
 
17
        mock.Start()
 
18
        mockEndpoint = mock.Endpoint("")
 
19
}
 
20
 
 
21
func newDataServer() *data.Server {
 
22
        return &data.Server{
 
23
                Resource: data.Resource{URI: "uri", UUID: "uuid"},
 
24
                Meta:     map[string]string{"key1": "value1", "key2": "value2"},
 
25
                Name:     "name",
 
26
                Status:   "status",
 
27
        }
 
28
}
 
29
 
 
30
func createTestClient(t *testing.T) (*Client, error) {
 
31
        cli, err := NewClient(mockEndpoint, mock.TestUser, mock.TestPassword, nil)
 
32
        if err != nil {
 
33
                return nil, err
 
34
        }
 
35
 
 
36
        if *trace {
 
37
                cli.Logger(t)
 
38
        }
 
39
 
 
40
        return cli, nil
 
41
}
 
42
 
 
43
type testLog struct{ written int }
 
44
 
 
45
func (l *testLog) Log(args ...interface{})                 { l.written++ }
 
46
func (l *testLog) Logf(format string, args ...interface{}) { l.written++ }
 
47
 
 
48
func TestClientLogger(t *testing.T) {
 
49
        cli, err := NewClient("https://0.1.2.3:2000/api/2.0/", mock.TestUser, mock.TestPassword, nil)
 
50
        if err != nil || cli == nil {
 
51
                t.Error("NewClient() failed:", err, cli)
 
52
                return
 
53
        }
 
54
 
 
55
        var log testLog
 
56
        cli.Logger(&log)
 
57
 
 
58
        cli.ConnectTimeout(100 * time.Millisecond)
 
59
        cli.ReadWriteTimeout(100 * time.Millisecond)
 
60
 
 
61
        ssf, err := cli.Servers(false)
 
62
        if err == nil || ssf != nil {
 
63
                t.Error("Servers(false) returned valid result for unavailable endpoint")
 
64
                return
 
65
        }
 
66
 
 
67
        if log.written == 0 {
 
68
                t.Error("no writes to log")
 
69
        }
 
70
}
 
71
 
 
72
func TestClientTimeouts(t *testing.T) {
 
73
        cli, err := createTestClient(t)
 
74
        if err != nil || cli == nil {
 
75
                t.Error("NewClient() failed:", err, cli)
 
76
                return
 
77
        }
 
78
 
 
79
        cli.ConnectTimeout(100 * time.Millisecond)
 
80
        if v := cli.GetConnectTimeout(); v != 100*time.Millisecond {
 
81
                t.Error("ConnectTimeout check failed")
 
82
        }
 
83
 
 
84
        cli.ReadWriteTimeout(200 * time.Millisecond)
 
85
        if v := cli.GetReadWriteTimeout(); v != 200*time.Millisecond {
 
86
                t.Error("ReadWriteTimeout check failed")
 
87
        }
 
88
 
 
89
        cli.OperationTimeout(300 * time.Millisecond)
 
90
        if v := cli.GetOperationTimeout(); v != 300*time.Millisecond {
 
91
                t.Error("OperationTimeout check failed")
 
92
        }
 
93
}
 
94
 
 
95
func TestClientEmptyUUID(t *testing.T) {
 
96
        cli, err := createTestClient(t)
 
97
        if err != nil || cli == nil {
 
98
                t.Error("NewClient() failed:", err, cli)
 
99
                return
 
100
        }
 
101
 
 
102
        if _, err := cli.Server(""); err != errEmptyUUID {
 
103
                t.Error("Server('') must fail with errEmptyUUID")
 
104
        }
 
105
        if err := cli.StartServer("", nil); err != errEmptyUUID {
 
106
                t.Error("StartServer('') must fail with errEmptyUUID")
 
107
        }
 
108
        if err := cli.StopServer(""); err != errEmptyUUID {
 
109
                t.Error("StopServer('') must fail with errEmptyUUID")
 
110
        }
 
111
        if err := cli.RemoveServer("", RecurseAllDrives); err != errEmptyUUID {
 
112
                t.Error("RemoveServer('') must fail with errEmptyUUID")
 
113
        }
 
114
        if _, err := cli.Drive("", true); err != errEmptyUUID {
 
115
                t.Error("Drive('') must fail with errEmptyUUID")
 
116
        }
 
117
        if _, err := cli.Job(""); err != errEmptyUUID {
 
118
                t.Error("Job('') must fail with errEmptyUUID")
 
119
        }
 
120
        if _, err := cli.CloneDrive("", false, CloneParams{}, nil); err != errEmptyUUID {
 
121
                t.Error("CloneDrive('') must fail with errEmptyUUID")
 
122
        }
 
123
        if err := cli.RemoveDrive("", false); err != errEmptyUUID {
 
124
                t.Error("RemoveDrive('') must fail with errEmptyUUID")
 
125
        }
 
126
}
 
127
 
 
128
func TestClientEndpointUnavailableSoft(t *testing.T) {
 
129
        cli, err := NewClient(mockEndpoint+"1", mock.TestUser, mock.TestPassword, nil)
 
130
        if err != nil || cli == nil {
 
131
                t.Error("NewClient() failed:", err, cli)
 
132
                return
 
133
        }
 
134
 
 
135
        if *trace {
 
136
                cli.Logger(t)
 
137
        }
 
138
 
 
139
        ssf, err := cli.Servers(false)
 
140
        if err == nil || ssf != nil {
 
141
                t.Errorf("Servers(false) returned valid result for unavailable endpoint: %#v", ssf)
 
142
                return
 
143
        }
 
144
        t.Log("OK: Servers(false)", err)
 
145
 
 
146
        sst, err := cli.Servers(true)
 
147
        if err == nil || sst != nil {
 
148
                t.Errorf("Servers(true) returned valid result for unavailable endpoint: %#v", sst)
 
149
                return
 
150
        }
 
151
        t.Log("OK: Servers(true)", err)
 
152
 
 
153
        s, err := cli.Server("uuid")
 
154
        if err == nil {
 
155
                t.Errorf("Server() returned valid result with for unavailable endpoint: %#v", s)
 
156
                return
 
157
        }
 
158
        t.Log("OK, Server():", err)
 
159
 
 
160
        if _, err = cli.CreateServer(Components{}); err == nil {
 
161
                t.Error("CreateServer() returned valid result for unavailable endpoint")
 
162
                return
 
163
        }
 
164
        t.Log("OK, CreateServer():", err)
 
165
 
 
166
        err = cli.StartServer("uuid", nil)
 
167
        if err == nil {
 
168
                t.Error("StartServer() returned valid result for unavailable endpoint")
 
169
                return
 
170
        }
 
171
        t.Log("OK, StartServer():", err)
 
172
 
 
173
        err = cli.StopServer("uuid")
 
174
        if err == nil {
 
175
                t.Error("StopServer() returned valid result for unavailable endpoint")
 
176
                return
 
177
        }
 
178
        t.Log("OK, StopServer():", err)
 
179
 
 
180
        err = cli.RemoveServer("uuid", RecurseAllDrives)
 
181
        if err == nil {
 
182
                t.Error("RemoveServer() returned valid result for unavailable endpoint")
 
183
                return
 
184
        }
 
185
        t.Log("OK, RemoveServer():", err)
 
186
 
 
187
        dd, err := cli.Drives(false, false)
 
188
        if err == nil {
 
189
                t.Errorf("Drives(false) returned valid result for unavailable endpoint: %#v", dd)
 
190
                return
 
191
        }
 
192
        t.Log("OK, Drives(false):", err)
 
193
 
 
194
        d, err := cli.Drive("uuid", false)
 
195
        if err == nil {
 
196
                t.Errorf("Drive(false) returned valid result for unavailable endpoint: %#v", d)
 
197
                return
 
198
        }
 
199
        t.Log("OK, Drive(false):", err)
 
200
 
 
201
        cd, err := cli.CloneDrive("uuid", false, CloneParams{}, nil)
 
202
        if err == nil {
 
203
                t.Errorf("CloneDrive() returned valid result for unavailable endpoint: %#v", cd)
 
204
                return
 
205
        }
 
206
 
 
207
        err = cli.RemoveDrive("uuid", false)
 
208
        if err == nil {
 
209
                t.Error("RemoveDrive() returned valid result for unavailable endpoint")
 
210
                return
 
211
        }
 
212
 
 
213
        j, err := cli.Job("uuid")
 
214
        if err == nil {
 
215
                t.Errorf("Job() returned valid result for unavailable endpoint: %#v", j)
 
216
                return
 
217
        }
 
218
        t.Log("OK, Job():", err)
 
219
}
 
220
 
 
221
func TestClientEndpointUnavailableHard(t *testing.T) {
 
222
        cli, err := NewClient("https://0.1.2.3:2000/api/2.0/", mock.TestUser, mock.TestPassword, nil)
 
223
        if err != nil || cli == nil {
 
224
                t.Error("NewClient() failed:", err, cli)
 
225
                return
 
226
        }
 
227
 
 
228
        if *trace {
 
229
                cli.Logger(t)
 
230
        }
 
231
 
 
232
        cli.ConnectTimeout(100 * time.Millisecond)
 
233
        cli.ReadWriteTimeout(100 * time.Millisecond)
 
234
 
 
235
        ssf, err := cli.Servers(false)
 
236
        if err == nil || ssf != nil {
 
237
                t.Error("Servers(false) returned valid result for unavailable endpoint")
 
238
                return
 
239
        }
 
240
        t.Log("OK: Servers(false)", err)
 
241
 
 
242
        sst, err := cli.Servers(true)
 
243
        if err == nil || sst != nil {
 
244
                t.Error("Servers(true) returned valid result for unavailable endpoint")
 
245
                return
 
246
        }
 
247
        t.Log("OK: Servers(true)", err)
 
248
 
 
249
        s, err := cli.Server("uuid")
 
250
        if err == nil {
 
251
                t.Errorf("Server() returned valid result for unavailable endpoint: %#v", s)
 
252
                return
 
253
        }
 
254
        t.Log("OK, Server():", err)
 
255
 
 
256
        if _, err = cli.CreateServer(Components{}); err == nil {
 
257
                t.Error("CreateServer() returned valid result for unavailable endpoint")
 
258
                return
 
259
        }
 
260
        t.Log("OK, CreateServer():", err)
 
261
 
 
262
        err = cli.StartServer("uuid", nil)
 
263
        if err == nil {
 
264
                t.Error("StartServer() returned valid result for unavailable endpoint")
 
265
                return
 
266
        }
 
267
        t.Log("OK, StartServer():", err)
 
268
 
 
269
        err = cli.StopServer("uuid")
 
270
        if err == nil {
 
271
                t.Error("StopServer() returned valid result for unavailable endpoint")
 
272
                return
 
273
        }
 
274
        t.Log("OK, StopServer():", err)
 
275
 
 
276
        err = cli.RemoveServer("uuid", RecurseAllDrives)
 
277
        if err == nil {
 
278
                t.Error("RemoveServer() returned valid result for unavailable endpoint")
 
279
                return
 
280
        }
 
281
        t.Log("OK, RemoveServer():", err)
 
282
 
 
283
        dd, err := cli.Drives(false, false)
 
284
        if err == nil {
 
285
                t.Errorf("Drives(false) returned valid result for unavailable endpoint: %#v", dd)
 
286
                return
 
287
        }
 
288
        t.Log("OK, Drives(false):", err)
 
289
 
 
290
        d, err := cli.Drive("uuid", false)
 
291
        if err == nil {
 
292
                t.Errorf("Drive(false) returned valid result for unavailable endpoint: %#v", d)
 
293
                return
 
294
        }
 
295
        t.Log("OK, Drive(false):", err)
 
296
 
 
297
        cd, err := cli.CloneDrive("uuid", false, CloneParams{}, nil)
 
298
        if err == nil {
 
299
                t.Errorf("CloneDrive() returned valid result for unavailable endpoint: %#v", cd)
 
300
                return
 
301
        }
 
302
 
 
303
        err = cli.RemoveDrive("uuid", false)
 
304
        if err == nil {
 
305
                t.Error("RemoveDrive() returned valid result for unavailable endpoint")
 
306
                return
 
307
        }
 
308
 
 
309
        j, err := cli.Job("uuid")
 
310
        if err == nil {
 
311
                t.Errorf("Job() returned valid result for unavailable endpoint: %#v", j)
 
312
                return
 
313
        }
 
314
        t.Log("OK, Job():", err)
 
315
}