← Back to branch summary

~abentley/juju-ci-tools/client-from-config-4

« back to all changes in this revision

Viewing changes to tests/test_assess_status_output.py

  • Committer: Martin Packman
  • Date: 2015-11-17 14:19:06 UTC
  • mto: This revision was merged to the branch mainline in revision 1155.
  • Revision ID: martin.packman@canonical.com-20151117141906-a4zmuqre72s7fyf1
Sample script for generating image streams for rackspace

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_assess_status_output.py
 
1
from status import (
 
2
    ErrNoStatus,
 
3
    StatusYamlParser,
 
4
    StatusJsonParser,
 
5
    StatusTabularParser
 
6
)
 
7
 
 
8
from unittest import TestCase
 
9
 
 
10
 
 
11
__metaclass__ = type
 
12
 
 
13
 
 
14
SAMPLE_YAML_OUTPUT = """environment: bogusec2
 
15
machines:
 
16
  "0":
 
17
    agent-state: started
 
18
    agent-version: 1.25-alpha1
 
19
    dns-name: 54.82.51.4
 
20
    instance-id: i-c0dadd10
 
21
    instance-state: running
 
22
    series: trusty
 
23
    hardware: arch=amd64 cpu-cores=1 cpu-power=100 mem=1740M """ \
 
24
    """root-disk=8192M availability-zone=us-east-1c
 
25
    state-server-member-status: has-vote
 
26
  "1":
 
27
    agent-state: started
 
28
    agent-version: 1.25-alpha1
 
29
    dns-name: 54.162.95.230
 
30
    instance-id: i-39280ac6
 
31
    instance-state: running
 
32
    series: trusty
 
33
    hardware: arch=amd64 cpu-cores=1 cpu-power=100 mem=1740M """\
 
34
    """root-disk=8192M availability-zone=us-east-1d
 
35
services:
 
36
  statusstresser:
 
37
    charm: local:trusty/statusstresser-1
 
38
    exposed: false
 
39
    service-status:
 
40
      current: active
 
41
      message: called in config-changed hook
 
42
      since: 12 Jun 2015 13:15:25-03:00
 
43
    units:
 
44
      statusstresser/0:
 
45
        workload-status:
 
46
          current: active
 
47
          message: called in config-changed hook
 
48
          since: 12 Jun 2015 13:15:25-03:00
 
49
        agent-status:
 
50
          current: idle
 
51
          since: 12 Jun 2015 14:33:08-03:00
 
52
          version: 1.25-alpha1
 
53
        agent-state: started
 
54
        agent-version: 1.25-alpha1
 
55
        machine: "1"
 
56
        public-address: 54.162.95.230
 
57
"""
 
58
# This could be replaced by a json.dumps({}) but the text is kept to
 
59
# make this test about status output as accurate as possible.
 
60
SAMPLE_JSON_OUTPUT = \
 
61
    """{"environment":"perritoec2","machines":{"0":{"agent-state":"""\
 
62
    """"started","agent-version":"1.25-alpha1","dns-name":"54.82.51.4","""\
 
63
    """"instance-id":"i-c0dadd10","instance-state":"running","""\
 
64
    """"series":"trusty","hardware":"arch=amd64 cpu-cores=1 cpu-power=100 """\
 
65
    """mem=1740M root-disk=8192M availability-zone=us-east-1c","""\
 
66
    """"state-server-member-status":"has-vote"},"1":{"agent-state":"""\
 
67
    """"started","agent-version":"1.25-alpha1","dns-name":"54.162.95.230","""\
 
68
    """"instance-id":"i-a7a2b377","instance-state":"running","""\
 
69
    """"series":"trusty","hardware":"arch=amd64 cpu-cores=1 cpu-power=300 """\
 
70
    """mem=3840M root-disk=8192M availability-zone=us-east-1c"}},"""\
 
71
    """"services":{"statusstresser":{"charm": """\
 
72
    """"local:trusty/statusstresser-1","exposed":false,"service-status":"""\
 
73
    """{"current":"active","message":"called in config-changed hook","""\
 
74
    """"since":"15 Jun 2015 20:56:29-03:00"},"""\
 
75
    """"units":{"statusstresser/0":{"workload-status":"""\
 
76
    """{"current":"active","message":"called in config-changed hook","""\
 
77
    """"since":"15 Jun 2015 20:56:29-03:00"},"agent-status":"""\
 
78
    """{"current":"idle","since":"15 Jun 2015 20:56:41-03:00","""\
 
79
    """"version":"1.25-alpha1"},"agent-state":"started","agent-version":"""\
 
80
    """"1.25-alpha1","machine":"1","public-address":"54.162.95.230"}}}}}"""
 
81
 
 
82
SAMPLE_TABULAR_OUTPUT = """[Services]
 
83
NAME           STATUS EXPOSED CHARM
 
84
statusstresser active false   local:trusty/statusstresser-1
 
85
 
 
86
[Units]
 
87
ID               WORKLOAD-STATE AGENT-STATE VERSION     MACHINE PORTS """\
 
88
"""PUBLIC-ADDRESS MESSAGE
 
89
statusstresser/0 active         idle        1.25-alpha1 1             """\
 
90
"""54.162.95.230  called in config-changed hook
 
91
 
 
92
[Machines]
 
93
ID         STATE   VERSION     DNS            INS-ID     SERIES HARDWARE
 
94
0          started 1.25-alpha1 54.82.51.4     i-c0dadd10 trusty arch=amd64 """\
 
95
    """cpu-cores=1 cpu-power=100 mem=1740M root-disk=8192M """\
 
96
    """availability-zone=us-east-1c
 
97
1          started 1.25-alpha1 54.162.95.230  i-39280ac6 trusty arch=amd64 """\
 
98
    """cpu-cores=1 cpu-power=100 mem=1740M root-disk=8192M """\
 
99
    """availability-zone=us-east-1d"""
 
100
 
 
101
 
 
102
class ReducedTestStatus:
 
103
 
 
104
    def test_assert_machine_ids(self):
 
105
        self.parser.assert_machines_ids(["0", "1"])
 
106
 
 
107
    def test_assert_machine_ids_failed(self):
 
108
        with self.assertRaises(AssertionError):
 
109
            self.parser.assert_machines_ids(["0", "1", "2"])
 
110
 
 
111
    def test_assert_machine_len(self):
 
112
        self.parser.assert_machines_len(2)
 
113
 
 
114
    def test_assert_machine_len_failed(self):
 
115
        with self.assertRaises(AssertionError):
 
116
            self.parser.assert_machines_len(3)
 
117
 
 
118
    def test_machine_agent_state_valid(self):
 
119
        self.parser.assert_machine_agent_state("0", "started")
 
120
 
 
121
    def test_machine_agent_state_failed(self):
 
122
        with self.assertRaises(AssertionError):
 
123
            self.parser.assert_machine_agent_state("0", "stopped")
 
124
 
 
125
    def test_machine_agent_state_error(self):
 
126
        with self.assertRaises(AssertionError):
 
127
            self.parser.assert_machine_agent_state("3", "stopped")
 
128
 
 
129
    def test_assert_machine_agent_version(self):
 
130
        self.parser.assert_machine_agent_version("0", "1.25-alpha1")
 
131
 
 
132
    def test_assert_machine_agent_version_failed(self):
 
133
        with self.assertRaises(AssertionError):
 
134
            self.parser.assert_machine_agent_version("0", "1.25-alpha2")
 
135
 
 
136
    def test_assert_machine_agent_version_error(self):
 
137
        with self.assertRaises(AssertionError):
 
138
            self.parser.assert_machine_agent_version("5", "1.25-alpha1")
 
139
 
 
140
    def test_assert_machine_dns_name(self):
 
141
        self.parser.assert_machine_dns_name("0", "54.82.51.4")
 
142
 
 
143
    def test_assert_machine_dns_name_failed(self):
 
144
        with self.assertRaises(AssertionError):
 
145
            self.parser.assert_machine_dns_name("0", "54.82.51.5")
 
146
 
 
147
    def test_assert_machine_dns_name_error(self):
 
148
        with self.assertRaises(AssertionError):
 
149
            self.parser.assert_machine_dns_name("3", "54.82.51.4")
 
150
 
 
151
    def test_assert_machine_instance_id(self):
 
152
        self.parser.assert_machine_instance_id("0", "i-c0dadd10")
 
153
 
 
154
    def test_assert_machine_instance_id_failed(self):
 
155
        with self.assertRaises(AssertionError):
 
156
            self.parser.assert_machine_instance_id("0", "i-c0dadd11")
 
157
 
 
158
    def test_assert_machine_instance_id_error(self):
 
159
        with self.assertRaises(AssertionError):
 
160
            self.parser.assert_machine_instance_id("3", "i-c0dadd10")
 
161
 
 
162
    def test_assert_machine_series(self):
 
163
        self.parser.assert_machine_series("0", "trusty")
 
164
 
 
165
    def test_assert_machine_series_failed(self):
 
166
        with self.assertRaises(AssertionError):
 
167
            self.parser.assert_machine_series("0", "utopic")
 
168
 
 
169
    def test_assert_machine_series_error(self):
 
170
        with self.assertRaises(AssertionError):
 
171
            self.parser.assert_machine_series("3", "trusty")
 
172
 
 
173
    def test_assert_machine_hardware(self):
 
174
        self.parser.assert_machine_hardware("0", "arch=amd64 cpu-cores=1 "
 
175
                                                 "cpu-power=100 mem=1740M "
 
176
                                                 "root-disk=8192M "
 
177
                                                 "availability-zone="
 
178
                                                 "us-east-1c")
 
179
 
 
180
    def test_assert_machine_hardware_failed(self):
 
181
        with self.assertRaises(AssertionError):
 
182
            self.parser.assert_machine_hardware("0", "arch=arm cpu-cores=1 "
 
183
                                                     "cpu-power=100 mem=1740M "
 
184
                                                     "root-disk=8192M "
 
185
                                                     "availability-zone="
 
186
                                                     "us-east-1c")
 
187
 
 
188
    def test_assert_machine_hardware_error(self):
 
189
        with self.assertRaises(AssertionError):
 
190
            self.parser.assert_machine_hardware("3", "arch=amd64 cpu-cores=1 "
 
191
                                                     "cpu-power=100 mem=1740M "
 
192
                                                     "root-disk=8192M "
 
193
                                                     "availability-zone="
 
194
                                                     "us-east-1c")
 
195
 
 
196
    def test_assert_service_charm(self):
 
197
        self.parser.assert_service_charm("statusstresser",
 
198
                                         "local:trusty/statusstresser-1")
 
199
 
 
200
    def test_assert_service_charm_failed(self):
 
201
        with self.assertRaises(AssertionError):
 
202
            self.parser.assert_service_charm("statusstresser",
 
203
                                             "local:trusty/statusstresser-2")
 
204
 
 
205
    def test_assert_service_charm_error(self):
 
206
        with self.assertRaises(AssertionError):
 
207
            self.parser.assert_service_charm("statusrelaxer",
 
208
                                             "local:trusty/statusstresser-1")
 
209
 
 
210
    def test_assert_service_exposed(self):
 
211
        self.parser.assert_service_exposed("statusstresser", False)
 
212
 
 
213
    def test_assert_service_exposed_failed(self):
 
214
        with self.assertRaises(AssertionError):
 
215
            self.parser.assert_service_exposed("statusstresser", True)
 
216
 
 
217
    def test_assert_service_exposed_error(self):
 
218
        with self.assertRaises(AssertionError):
 
219
            self.parser.assert_service_exposed("statusrelaxer", False)
 
220
 
 
221
    def test_assert_unit_public_address(self):
 
222
        self.parser.assert_unit_public_address("statusstresser/0",
 
223
                                               "54.162.95.230")
 
224
 
 
225
    def test_assert_unit_public_address_failed(self):
 
226
        with self.assertRaises(AssertionError):
 
227
            self.parser.assert_unit_public_address("statusstresser/0",
 
228
                                                   "54.162.95.231")
 
229
 
 
230
    def test_assert_unit_public_address_error(self):
 
231
        with self.assertRaises(AssertionError):
 
232
            self.parser.assert_unit_public_address("statusrelaxer/0",
 
233
                                                   "54.162.95.230")
 
234
 
 
235
 
 
236
class BaseTestStatus(ReducedTestStatus):
 
237
 
 
238
    def test_assert_machine_member_status(self):
 
239
        self.parser.assert_machine_member_status("0", "has-vote")
 
240
 
 
241
    def test_assert_machine_member_status_failed(self):
 
242
        with self.assertRaises(AssertionError):
 
243
            self.parser.assert_machine_member_status("0", "not-voting")
 
244
 
 
245
    def test_assert_machine_member_status_error(self):
 
246
        with self.assertRaises(AssertionError):
 
247
            self.parser.assert_machine_member_status("3", "has-vote")
 
248
 
 
249
    def test_assert_service_service_status(self):
 
250
        self.parser.assert_service_service_status("statusstresser",
 
251
                                                  {"current": "active",
 
252
                                                   "message": "called in "
 
253
                                                   "config-changed hook"})
 
254
 
 
255
    def test_assert_service_service_status_failed(self):
 
256
        with self.assertRaises(AssertionError):
 
257
            self.parser.assert_service_service_status("statusstresser",
 
258
                                                      {"current": "active",
 
259
                                                       "message": "another "
 
260
                                                       "message"})
 
261
 
 
262
    def test_assert_service_service_status_error(self):
 
263
        with self.assertRaises(AssertionError):
 
264
            self.parser.assert_service_service_status("statusrelaxer",
 
265
                                                      {"current": "active",
 
266
                                                       "message": "called in "
 
267
                                                       "config-changed hook"})
 
268
 
 
269
    def test_assert_unit_workload_status(self):
 
270
        self.parser.assert_unit_workload_status("statusstresser/0",
 
271
                                                {"current": "active",
 
272
                                                 "message": "called in "
 
273
                                                 "config-changed hook"})
 
274
 
 
275
    def test_assert_unit_workload_status_failed(self):
 
276
        with self.assertRaises(AssertionError):
 
277
            self.parser.assert_unit_workload_status("statusstresser/0",
 
278
                                                    {"current": "active",
 
279
                                                     "message": "another "
 
280
                                                     "message"})
 
281
 
 
282
    def test_assert_unit_workload_status_error(self):
 
283
        with self.assertRaises(AssertionError):
 
284
            self.parser.assert_unit_workload_status("statusrelaxer/0",
 
285
                                                    {"current": "active",
 
286
                                                     "message": "called in "
 
287
                                                     "config-changed hook"})
 
288
 
 
289
    def test_assert_unit_agent_status(self):
 
290
        self.parser.assert_unit_agent_status("statusstresser/0",
 
291
                                             {"current": "idle",
 
292
                                              "message": ""})
 
293
 
 
294
    def test_assert_unit_agent_status_failed(self):
 
295
        with self.assertRaises(AssertionError):
 
296
            self.parser.assert_unit_agent_status("statusstresser/0",
 
297
                                                 {"current": "idle",
 
298
                                                  "message": "an unexpected "
 
299
                                                  "message"})
 
300
 
 
301
    def test_assert_unit_agent_status_error(self):
 
302
        with self.assertRaises(AssertionError):
 
303
            self.parser.assert_unit_agent_status("statusrelaxer/0",
 
304
                                                 {"current": "idle",
 
305
                                                  "message": ""})
 
306
 
 
307
    def test_assert_unit_agent_state(self):
 
308
        self.parser.assert_unit_agent_state("statusstresser/0", "started")
 
309
 
 
310
    def test_assert_unit_agent_state_failed(self):
 
311
        with self.assertRaises(AssertionError):
 
312
            self.parser.assert_unit_agent_state("statusstresser/0", "stopped")
 
313
 
 
314
    def test_assert_unit_agent_state_error(self):
 
315
        with self.assertRaises(AssertionError):
 
316
            self.parser.assert_unit_agent_state("statusrelaxer/0", "started")
 
317
 
 
318
    def test_assert_unit_agent_version(self):
 
319
        self.parser.assert_unit_agent_version("statusstresser/0",
 
320
                                              "1.25-alpha1")
 
321
 
 
322
    def test_assert_unit_agent_version_failed(self):
 
323
        with self.assertRaises(AssertionError):
 
324
            self.parser.assert_unit_agent_version("statusstresser/0",
 
325
                                                  "1.25-alpha2")
 
326
 
 
327
    def test_assert_unit_agent_version_error(self):
 
328
        with self.assertRaises(AssertionError):
 
329
            self.parser.assert_unit_agent_version("statusrelaxer/0",
 
330
                                                  "1.25-alpha1")
 
331
 
 
332
    def test_assert_unit_machine(self):
 
333
        self.parser.assert_unit_machine("statusstresser/0", "1")
 
334
 
 
335
    def test_assert_unit_machine_failed(self):
 
336
        with self.assertRaises(AssertionError):
 
337
            self.parser.assert_unit_machine("statusstresser/0", "2")
 
338
 
 
339
    def test_assert_unit_machine_error(self):
 
340
        with self.assertRaises(AssertionError):
 
341
            self.parser.assert_unit_machine("statusrelaxer/0", "1")
 
342
 
 
343
 
 
344
class TestStatusForYaml(TestCase, BaseTestStatus):
 
345
 
 
346
    def test_empty_yaml_fails(self):
 
347
        with self.assertRaises(ErrNoStatus):
 
348
            StatusYamlParser(yaml="")
 
349
 
 
350
    def setUp(self):
 
351
        self.parser = StatusYamlParser(yaml=SAMPLE_YAML_OUTPUT)
 
352
 
 
353
 
 
354
class TestStatusForJson(TestCase, BaseTestStatus):
 
355
 
 
356
    def test_empty_json_fails(self):
 
357
        with self.assertRaises(ErrNoStatus):
 
358
            StatusJsonParser(json_text="")
 
359
 
 
360
    def setUp(self):
 
361
        self.parser = StatusJsonParser(json_text=SAMPLE_JSON_OUTPUT)
 
362
 
 
363
 
 
364
class TestStatusTabular(TestCase, ReducedTestStatus):
 
365
 
 
366
    def test_empty_tabular_fails(self):
 
367
        with self.assertRaises(ErrNoStatus):
 
368
            StatusTabularParser("")
 
369
 
 
370
    def setUp(self):
 
371
        self.parser = StatusTabularParser(tabular_text=SAMPLE_TABULAR_OUTPUT)
 
372
 
 
373
    def test_assert_service_service_status(self):
 
374
        self.parser.assert_service_service_status("statusstresser",
 
375
                                                  {"current": "active",
 
376
                                                   "message": ""})
 
377
 
 
378
    def test_assert_service_service_status_failed(self):
 
379
        with self.assertRaises(AssertionError):
 
380
            self.parser.assert_service_service_status("statusstresser",
 
381
                                                      {"current": "active",
 
382
                                                       "message": "another "
 
383
                                                       "message"})
 
384
 
 
385
    def test_assert_service_service_status_error(self):
 
386
        with self.assertRaises(AssertionError):
 
387
            self.parser.assert_service_service_status("statusrelaxer",
 
388
                                                      {"current": "active",
 
389
                                                       "message": "called in "
 
390
                                                       "config-changed hook"})
 
391
 
 
392
    def test_assert_unit_workload_status(self):
 
393
        self.parser.assert_unit_workload_status("statusstresser/0",
 
394
                                                {"current": "active",
 
395
                                                 "message": "called in "
 
396
                                                 "config-changed hook"})
 
397
 
 
398
    def test_assert_unit_workload_status_failed(self):
 
399
        with self.assertRaises(AssertionError):
 
400
            self.parser.assert_unit_workload_status("statusstresser/0",
 
401
                                                    {"current": "active",
 
402
                                                     "message": "another "
 
403
                                                     "message"})
 
404
 
 
405
    def test_assert_unit_workload_status_error(self):
 
406
        with self.assertRaises(AssertionError):
 
407
            self.parser.assert_unit_workload_status("statusrelaxer/0",
 
408
                                                    {"current": "active",
 
409
                                                     "message": "called in "
 
410
                                                     "config-changed hook"})
 
411
 
 
412
    def test_assert_unit_agent_status(self):
 
413
        self.parser.assert_unit_agent_status("statusstresser/0",
 
414
                                             {"current": "idle",
 
415
                                              "message": ""})
 
416
 
 
417
    def test_assert_unit_agent_status_failed(self):
 
418
        with self.assertRaises(AssertionError):
 
419
            self.parser.assert_unit_agent_status("statusstresser/0",
 
420
                                                 {"current": "idle",
 
421
                                                  "message": "an unexpected "
 
422
                                                  "message"})
 
423
 
 
424
    def test_assert_unit_agent_status_error(self):
 
425
        with self.assertRaises(AssertionError):
 
426
            self.parser.assert_unit_agent_status("statusrelaxer/0",
 
427
                                                 {"current": "idle",
 
428
                                                  "message": ""})