~andrewjbeach/juju-ci-tools/make-local-patcher

« back to all changes in this revision

Viewing changes to tests/test_assess_status_output.py

  • Committer: John George
  • Date: 2015-01-14 22:03:47 UTC
  • mto: This revision was merged to the branch mainline in revision 798.
  • Revision ID: john.george@canonical.com-20150114220347-e8q5wezs1qg9a00u
Added support for setting the juju path, series and agent_url.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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": ""})