1
diff --git a/juju_verify/utils/unit.py b/juju_verify/utils/unit.py
2
index 05a9785..f672b20 100644
3
--- a/juju_verify/utils/unit.py
4
+++ b/juju_verify/utils/unit.py
5
@@ -64,6 +64,12 @@ def run_action_on_units(
6
64
    return result_map
64
    return result_map
7
65
65
8
66
66
9
67
def run_action_on_unit(unit: Unit, action: str, **params: str) -> Any:
10
68
    """Run Juju action on single unit, returning the result."""
11
69
    results = run_action_on_units([unit], action=action, **params)
12
70
    return results[unit.entity_id]
13
71
14
72
15
67
def parse_charm_name(charm_url: str) -> str:
73
def parse_charm_name(charm_url: str) -> str:
16
68
    """Parse charm name from full charm url.
74
    """Parse charm name from full charm url.
17
69
75
18
diff --git a/juju_verify/verifiers/__init__.py b/juju_verify/verifiers/__init__.py
19
index 4400e0f..3908db2 100644
20
--- a/juju_verify/verifiers/__init__.py
21
+++ b/juju_verify/verifiers/__init__.py
22
@@ -28,6 +28,7 @@ from juju_verify.verifiers.base import BaseVerifier
23
28
from juju_verify.verifiers.ceph import CephOsd
28
from juju_verify.verifiers.ceph import CephOsd
24
29
from juju_verify.verifiers.nova_compute import NovaCompute
29
from juju_verify.verifiers.nova_compute import NovaCompute
25
30
from juju_verify.verifiers.result import Result
30
from juju_verify.verifiers.result import Result
26
31
from juju_verify.verifiers.neutron_gateway import NeutronGateway
27
31
32
28
32
logger = logging.getLogger(__name__)
33
logger = logging.getLogger(__name__)
29
33
34
30
@@ -35,6 +36,7 @@ logger = logging.getLogger(__name__)
31
35
SUPPORTED_CHARMS = {
36
SUPPORTED_CHARMS = {
32
36
    'nova-compute': NovaCompute,
37
    'nova-compute': NovaCompute,
33
37
    'ceph-osd': CephOsd,
38
    'ceph-osd': CephOsd,
34
39
    'neutron-gateway': NeutronGateway,
35
38
}
40
}
36
39
41
37
40
42
38
diff --git a/juju_verify/verifiers/neutron_gateway.py b/juju_verify/verifiers/neutron_gateway.py
39
41
new file mode 100644
43
new file mode 100644
40
index 0000000..d818ef0
41
--- /dev/null
42
+++ b/juju_verify/verifiers/neutron_gateway.py
43
@@ -0,0 +1,159 @@
44
1
# Copyright 2021 Canonical Limited.
45
2
#
46
3
# This file is part of juju-verify.
47
4
#
48
5
# juju-verify is free software: you can redistribute it and/or modify it under
49
6
# the terms of the GNU General Public License as published by the Free Software
50
7
# Foundation, either version 3 of the License, or (at your option) any later
51
8
# version.
52
9
#
53
10
# juju-verify is distributed in the hope that it will be useful, but WITHOUT
54
11
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
55
12
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
56
13
# details.
57
14
#
58
15
# You should have received a copy of the GNU General Public License along with
59
16
# this program. If not, see https://www.gnu.org/licenses/.
60
17
"""neutron-gateway verification."""
61
18
import json
62
19
from typing import Dict, List
63
20
64
21
from juju.unit import Unit
65
22
66
23
from juju_verify.verifiers.base import BaseVerifier, Result
67
24
from juju_verify.verifiers.result import aggregate_results
68
25
from juju_verify.utils.action import data_from_action
69
26
from juju_verify.utils.unit import run_action_on_unit
70
27
71
28
72
29
def get_unit_hostname(unit: Unit) -> str:
73
30
    """Return name of the host on which the unit is running."""
74
31
    get_hostname_action = run_action_on_unit(unit, "node-name")
75
32
    hostname = data_from_action(get_hostname_action, "node-name")
76
33
    return hostname
77
34
78
35
79
36
def get_unit_resource_list(unit: Unit, get_resource_action_name: str) -> List[dict]:
80
37
    """Given a get resource action, return the relevant resources on the unit."""
81
38
    get_resource_action = run_action_on_unit(unit, get_resource_action_name)
82
39
    action_name_res = NeutronGateway.action_name_result_map[get_resource_action_name]
83
40
    resource_list_json = data_from_action(get_resource_action, action_name_res)
84
41
    resource_list = json.loads(resource_list_json)
85
42
    return resource_list
86
43
87
44
88
45
class NeutronGateway(BaseVerifier):
89
46
    """Implementation of verification checks for the neutron-gateway charm."""
90
47
91
48
    NAME = 'neutron-gateway'
92
49
    action_name_result_map = {"get-status-routers": "router-list",
93
50
                              "get-status-dhcp": "dhcp-networks",
94
51
                              "get-status-lb": "load-balancers"}
95
52
    action_name_failure_string_map = {"get-status-routers": ("The following routers are "
96
53
                                                             "non-redundant: {}."),
97
54
                                      "get-status-dhcp": ("The following DHCP networks "
98
55
                                                          "are non-redundant: {}"),
99
56
                                      "get-status-lb": ("The following LBaasV2 LBs were "
100
57
                                                        "found: {}. LBaasV2 does not "
101
58
                                                        "offer HA.")}
102
59
103
60
    def __init__(self, units: List[Unit]) -> None:
104
61
        """Neutron Gateway verifier constructor."""
105
62
        super().__init__(units)
106
63
        self.cache_action_resource_list_map: Dict[str, List] = {}
107
64
108
65
    def get_all_ngw_units(self) -> List[Unit]:
109
66
        """Get all neutron-gateway units, including those not being shutdown."""
110
67
        application_name = NeutronGateway.NAME
111
68
        for rel in self.model.relations:
112
69
            if rel.matches("{}:cluster".format(application_name)):
113
70
                application = rel.applications.pop()
114
71
                all_ngw_units = application.units
115
72
        return all_ngw_units
116
73
117
74
    def get_resource_list(self, get_resource_action_name: str) -> List[dict]:
118
75
        """Given a get resource action, return matching resources from all units."""
119
76
        try:
120
77
            return self.cache_action_resource_list_map[get_resource_action_name]
121
78
        except KeyError:
122
79
            pass
123
80
124
81
        resource_list = []
125
82
        shutdown_hostname_list = [get_unit_hostname(unit) for unit in self.units]
126
83
127
84
        for unit in self.get_all_ngw_units():
128
85
            hostname = get_unit_hostname(unit)
129
86
            host_resource_list = get_unit_resource_list(unit,
130
87
                                                        get_resource_action_name)
131
88
132
89
            # add host metadata to resource
133
90
            for resource in host_resource_list:
134
91
                resource["host"] = hostname
135
92
                resource["juju-entity-id"] = unit.entity_id
136
93
                resource["shutdown"] = False
137
94
138
95
                if hostname in shutdown_hostname_list:
139
96
                    resource["shutdown"] = True
140
97
141
98
                resource_list.append(resource)
142
99
143
100
        self.cache_action_resource_list_map[get_resource_action_name] = resource_list
144
101
        return resource_list
145
102
146
103
    def get_shutdown_resource_list(self, get_resource_action_name: str) -> List[dict]:
147
104
        """Return a list of resources matching action that are going to be shutdown."""
148
105
        res_list = self.get_resource_list(get_resource_action_name)
149
106
        return [r for r in res_list if r["shutdown"] and r["status"] == "ACTIVE"]
150
107
151
108
    def get_online_resource_list(self, get_resource_action_name: str) -> List[dict]:
152
109
        """Return a list of resources matching action, that will remain online."""
153
110
        res_list = self.get_resource_list(get_resource_action_name)
154
111
        return [r for r in res_list if not r["shutdown"] and r["status"] == "ACTIVE"]
155
112
156
113
    def check_non_redundant_resource(self, action_name: str) -> Result:
157
114
        """Check that there are no non-redundant resources matching the resource type."""
158
115
        result = Result(True)
159
116
        shutdown_resource_list = self.get_shutdown_resource_list(action_name)
160
117
        redundant_resource_list = self.get_online_resource_list(action_name)
161
118
162
119
        shutdown_resource_set = set(r["id"] for r in shutdown_resource_list)
163
120
        redundant_resource_set = set(r["id"] for r in redundant_resource_list)
164
121
        non_redundant_list = shutdown_resource_set - redundant_resource_set
165
122
        if non_redundant_list:
166
123
            result.success = False
167
124
            failure_string = NeutronGateway.action_name_failure_string_map[action_name]
168
125
            result.reason = failure_string.format(", ".join(non_redundant_list))
169
126
        return result
170
127
171
128
    def warn_router_ha(self) -> Result:
172
129
        """Warn that HA routers should be manually failed over."""
173
130
        action_name = "get-status-routers"
174
131
        result = Result(True)
175
132
        shutdown_resource_list = self.get_shutdown_resource_list(action_name)
176
133
177
134
        router_failover_err_list = []
178
135
        for router in shutdown_resource_list:
179
136
            if router["ha"]:
180
137
                _id = router["id"]
181
138
                entity_id = router["juju-entity-id"]
182
139
                host = router["host"]
183
140
                error_string = "{} (on {}, hostname: {})".format(_id, entity_id, host)
184
141
                router_failover_err_list.append(error_string)
185
142
186
143
        if router_failover_err_list:
187
144
            error_string = ("It's recommended that you manually failover the following "
188
145
                            "routers: {}")
189
146
            result.reason = error_string.format(", ".join(router_failover_err_list))
190
147
191
148
        return result
192
149
193
150
    def verify_reboot(self) -> Result:
194
151
        """Verify that it's safe to reboot selected neutron-gateway units."""
195
152
        return self.verify_shutdown()
196
153
197
154
    def verify_shutdown(self) -> Result:
198
155
        """Verify that it's safe to shutdown selected neutron-gateway units."""
199
156
        return aggregate_results(self.warn_router_ha(),
200
157
                                 self.check_non_redundant_resource("get-status-routers"),
201
158
                                 self.check_non_redundant_resource("get-status-dhcp"),
202
159
                                 self.check_non_redundant_resource("get-status-lb"))
203
diff --git a/tests/unit/verifiers/test_neutron_gateway.py b/tests/unit/verifiers/test_neutron_gateway.py
204
0
new file mode 100644
160
new file mode 100644
205
index 0000000..4aeb48d
206
--- /dev/null
207
+++ b/tests/unit/verifiers/test_neutron_gateway.py
208
@@ -0,0 +1,310 @@
209
1
# Copyright 2021 Canonical Limited.
210
2
#
211
3
# This file is part of juju-verify.
212
4
#
213
5
# juju-verify is free software: you can redistribute it and/or modify it under
214
6
# the terms of the GNU General Public License as published by the Free Software
215
7
# Foundation, either version 3 of the License, or (at your option) any later
216
8
# version.
217
9
#
218
10
# juju-verify is distributed in the hope that it will be useful, but WITHOUT
219
11
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
220
12
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
221
13
# details.
222
14
#
223
15
# You should have received a copy of the GNU General Public License along with
224
16
# this program. If not, see https://www.gnu.org/licenses/.
225
17
"""NeutronGateway verifier class test suite."""
226
18
import json
227
19
from unittest import mock
228
20
from unittest.mock import MagicMock
229
21
230
22
from juju.unit import Unit
231
23
232
24
from juju_verify.verifiers import NeutronGateway
233
25
from juju_verify.verifiers.neutron_gateway import get_unit_hostname
234
26
from juju_verify.verifiers.neutron_gateway import get_unit_resource_list
235
27
236
28
all_ngw_units = []
237
29
for i in range(3):
238
30
    ngw = MagicMock()
239
31
    ngw.entity_id = "neutron-gateway/{}".format(i)
240
32
    all_ngw_units.append(ngw)
241
33
242
34
mock_data = [
243
35
    {
244
36
        "host": "host0",
245
37
        "shutdown": True,
246
38
        "unit": all_ngw_units[0],
247
39
        "routers": [{"id": "router0", "ha": False, "status": "ACTIVE"},
248
40
                    {"id": "router1", "ha": False, "status": "ACTIVE"}]
249
41
    },
250
42
    {
251
43
        "host": "host1",
252
44
        "shutdown": False,
253
45
        "unit": all_ngw_units[1],
254
46
        "routers": [{"id": "router2", "ha": False, "status": "ACTIVE"}],
255
47
    },
256
48
    {
257
49
        "host": "host2",
258
50
        "shutdown": False,
259
51
        "unit": all_ngw_units[2],
260
52
        "routers": [{"id": "router3", "ha": False, "status": "ACTIVE"},
261
53
                    {"id": "router4", "ha": False, "status": "ACTIVE"}],
262
54
    },
263
55
]
264
56
265
57
all_ngw_host_names = [h["host"] for h in mock_data]
266
58
267
59
model = MagicMock()
268
60
269
61
270
62
def get_ngw_verifier():
271
63
    """Get new NeutronGateway verifier (used for applying changes in shutdown list)."""
272
64
    return NeutronGateway([Unit(h["unit"].entity_id, model)
273
65
                           for h in mock_data if h["shutdown"]])
274
66
275
67
276
68
def get_resource_lists():
277
69
    """Get all routers in mock data."""
278
70
    return [h["routers"] for h in mock_data]
279
71
280
72
281
73
def get_shutdown_host_name_list():
282
74
    """Get all hostnames of all hosts being shutdown."""
283
75
    return [h["host"] for h in mock_data if h["shutdown"]]
284
76
285
77
286
78
def set_router_status(routerid, status):
287
79
    """Set status of given router id in mock data."""
288
80
    for host in mock_data:
289
81
        for router in host["routers"]:
290
82
            if router["id"] == routerid:
291
83
                router["status"] = status
292
84
293
85
294
86
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_resource_list")
295
87
@mock.patch("juju_verify.verifiers.neutron_gateway.NeutronGateway.get_all_ngw_units")
296
88
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_hostname")
297
89
def test_get_resource_list(mock_get_unit_hostname,
298
90
                           mock_get_all_ngw_units,
299
91
                           mock_get_unit_resource_list):
300
92
    """Test list of resources returned by get_resource_list."""
301
93
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
302
94
                                          all_ngw_host_names)
303
95
    mock_get_all_ngw_units.return_value = all_ngw_units
304
96
    mock_get_unit_resource_list.side_effect = get_resource_lists()
305
97
306
98
    ngw_verifier = get_ngw_verifier()
307
99
    router_list = ngw_verifier.get_resource_list("get-status-routers")
308
100
309
101
    router_count = 0
310
102
    for host in mock_data:
311
103
        router_count += len(host["routers"])
312
104
    assert len(router_list) == router_count
313
105
314
106
315
107
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_resource_list")
316
108
@mock.patch("juju_verify.verifiers.neutron_gateway.NeutronGateway.get_all_ngw_units")
317
109
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_hostname")
318
110
def test_get_shutdown_resource_list(mock_get_unit_hostname,
319
111
                                    mock_get_all_ngw_units,
320
112
                                    mock_get_unit_resource_list):
321
113
    """Test validity of list of resources to be shutdown."""
322
114
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
323
115
                                          all_ngw_host_names)
324
116
    mock_get_all_ngw_units.return_value = all_ngw_units
325
117
    mock_get_unit_resource_list.side_effect = get_resource_lists()
326
118
327
119
    ngw_verifier = get_ngw_verifier()
328
120
329
121
    router_shutdown_count = 0
330
122
    for host in mock_data:
331
123
        if host["shutdown"]:
332
124
            router_shutdown_count += len(host["routers"])
333
125
334
126
    shutdown_routers = ngw_verifier.get_shutdown_resource_list("get-status-routers")
335
127
    assert len(shutdown_routers) == router_shutdown_count
336
128
337
129
    # test that inactive resources are not being listed as being shutdown
338
130
    set_router_status("router0", "NOTACTIVE")
339
131
340
132
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
341
133
                                          all_ngw_host_names)
342
134
    mock_get_all_ngw_units.return_value = all_ngw_units
343
135
    mock_get_unit_resource_list.side_effect = get_resource_lists()
344
136
345
137
    shutdown_routers = ngw_verifier.get_shutdown_resource_list("get-status-routers")
346
138
    assert len(shutdown_routers) == router_shutdown_count - 1
347
139
348
140
    # set router0 back to active
349
141
    set_router_status("router0", "ACTIVE")
350
142
351
143
352
144
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_resource_list")
353
145
@mock.patch("juju_verify.verifiers.neutron_gateway.NeutronGateway.get_all_ngw_units")
354
146
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_hostname")
355
147
def test_get_online_resource_list(mock_get_unit_hostname,
356
148
                                  mock_get_all_ngw_units,
357
149
                                  mock_get_unit_resource_list):
358
150
    """Test validity of resources that will remain online."""
359
151
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
360
152
                                          all_ngw_host_names)
361
153
    mock_get_all_ngw_units.return_value = all_ngw_units
362
154
    mock_get_unit_resource_list.side_effect = get_resource_lists()
363
155
364
156
    ngw_verifier = get_ngw_verifier()
365
157
366
158
    router_online_count = 0
367
159
    for host in mock_data:
368
160
        if not host["shutdown"]:
369
161
            router_online_count += len(host["routers"])
370
162
371
163
    online_routers = ngw_verifier.get_online_resource_list("get-status-routers")
372
164
    assert len(online_routers) == router_online_count
373
165
374
166
    # test that NOT ACTIVE resources are not being listed as online/available
375
167
    set_router_status("router2", "NOTACTIVE")
376
168
377
169
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
378
170
                                          all_ngw_host_names)
379
171
    mock_get_all_ngw_units.return_value = all_ngw_units
380
172
    mock_get_unit_resource_list.side_effect = get_resource_lists()
381
173
382
174
    online_routers = ngw_verifier.get_online_resource_list("get-status-routers")
383
175
    assert len(online_routers) == router_online_count - 1
384
176
385
177
    # set router2 back to active
386
178
    set_router_status("router2", "ACTIVE")
387
179
388
180
389
181
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_resource_list")
390
182
@mock.patch("juju_verify.verifiers.neutron_gateway.NeutronGateway.get_all_ngw_units")
391
183
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_hostname")
392
184
def test_check_non_redundant_resource(mock_get_unit_hostname,
393
185
                                      mock_get_all_ngw_units,
394
186
                                      mock_get_unit_resource_list):
395
187
    """Test validity of list of resources determined to not be redundant."""
396
188
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
397
189
                                          all_ngw_host_names)
398
190
    mock_get_all_ngw_units.return_value = all_ngw_units
399
191
    mock_get_unit_resource_list.side_effect = get_resource_lists()
400
192
401
193
    ngw_verifier = get_ngw_verifier()
402
194
403
195
    # host0 being shutdown, with no redundancy for its routers (router0, router1)
404
196
    result = ngw_verifier.check_non_redundant_resource("get-status-routers")
405
197
    assert result.success is False
406
198
407
199
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
408
200
                                          all_ngw_host_names)
409
201
    mock_get_all_ngw_units.return_value = all_ngw_units
410
202
    mock_get_unit_resource_list.side_effect = get_resource_lists()
411
203
412
204
    ngw_verifier = get_ngw_verifier()
413
205
414
206
    # add redundancy (but not HA) for router0, router1 onto non-shutdown hosts
415
207
    mock_data[1]["routers"].append({"id": "router0", "ha": False, "status": "ACTIVE"})
416
208
    mock_data[2]["routers"].append({"id": "router1", "ha": False, "status": "ACTIVE"})
417
209
    mock_get_unit_resource_list.side_effect = get_resource_lists()
418
210
    result = ngw_verifier.check_non_redundant_resource("get-status-routers")
419
211
    assert result.success
420
212
421
213
    # test setting redundant redundant router0 to NOTACTIVE will result in failure
422
214
    mock_data[1]["routers"][-1]["status"] = "NOTACTIVE"
423
215
    mock_get_unit_resource_list.side_effect = get_resource_lists()
424
216
    result = ngw_verifier.check_non_redundant_resource("get-status-routers")
425
217
    assert result.success is False
426
218
427
219
    # test shutdown host1, which will take down the redundant router0
428
220
    mock_data[1]["shutdown"] = True
429
221
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
430
222
                                          all_ngw_host_names)
431
223
    mock_get_all_ngw_units.return_value = all_ngw_units
432
224
    mock_get_unit_resource_list.side_effect = get_resource_lists()
433
225
434
226
    ngw_verifier = get_ngw_verifier()
435
227
    result = ngw_verifier.check_non_redundant_resource("get-status-routers")
436
228
    assert result.success is False
437
229
438
230
    # reset shutdown for next tests
439
231
    mock_data[1]["shutdown"] = False
440
232
441
233
442
234
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_resource_list")
443
235
@mock.patch("juju_verify.verifiers.neutron_gateway.NeutronGateway.get_all_ngw_units")
444
236
@mock.patch("juju_verify.verifiers.neutron_gateway.get_unit_hostname")
445
237
def test_warn_router_ha(mock_get_unit_hostname,
446
238
                        mock_get_all_ngw_units,
447
239
                        mock_get_unit_resource_list):
448
240
    """Test existence of warning messages to manually failover HA routers when found."""
449
241
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
450
242
                                          all_ngw_host_names)
451
243
    mock_get_all_ngw_units.return_value = all_ngw_units
452
244
    mock_get_unit_resource_list.side_effect = get_resource_lists()
453
245
454
246
    ngw_verifier = get_ngw_verifier()
455
247
456
248
    result = ngw_verifier.warn_router_ha()
457
249
    # no HA to failover, lack of redundancy is detected by check_non_redundant_resource
458
250
    assert result.reason == ""
459
251
460
252
    # Find router0 set it to HA
461
253
    for host in mock_data:
462
254
        for router in host["routers"]:
463
255
            if router["id"] == "router0":
464
256
                router["ha"] = True
465
257
466
258
    mock_get_unit_hostname.side_effect = (get_shutdown_host_name_list() +
467
259
                                          all_ngw_host_names)
468
260
    mock_get_all_ngw_units.return_value = all_ngw_units
469
261
    mock_get_unit_resource_list.side_effect = get_resource_lists()
470
262
471
263
    ngw_verifier = get_ngw_verifier()
472
264
473
265
    result = ngw_verifier.warn_router_ha()
474
266
    # router is in HA, given instructions to failover
475
267
    assert result.reason
476
268
477
269
478
270
@mock.patch("juju_verify.verifiers.neutron_gateway.NeutronGateway.check_non_redundant_resource")  # noqa: E501 pylint: disable=C0301
479
271
@mock.patch("juju_verify.verifiers.neutron_gateway.NeutronGateway.warn_router_ha")
480
272
@mock.patch("juju_verify.verifiers.neutron_gateway.aggregate_results")
481
273
def test_verify_reboot_shutdown(mock_aggregate_results,
482
274
                                mock_warn_router_ha,
483
275
                                mock_check_non_redundant_resource):
484
276
    """Test that reboot/shutdown call appropriate checks."""
485
277
    ngw_verifier = get_ngw_verifier()
486
278
    ngw_verifier.verify_reboot()
487
279
    assert mock_check_non_redundant_resource.call_count == 3
488
280
    mock_warn_router_ha.assert_called_once()
489
281
    mock_aggregate_results.assert_called_once()
490
282
491
283
    mock_check_non_redundant_resource.reset_mock()
492
284
    mock_warn_router_ha.reset_mock()
493
285
    mock_aggregate_results.reset_mock()
494
286
495
287
    ngw_verifier.verify_shutdown()
496
288
    mock_warn_router_ha.assert_called_once()
497
289
    assert mock_check_non_redundant_resource.call_count == 3
498
290
    mock_aggregate_results.assert_called_once()
499
291
500
292
501
293
@mock.patch("juju_verify.verifiers.neutron_gateway.run_action_on_unit")
502
294
@mock.patch("juju_verify.verifiers.neutron_gateway.data_from_action")
503
295
def test_get_unit_hostname(mock_data_from_action, mock_run_action_on_unit):
504
296
    """Test getting remote Unit's hostname."""
505
297
    get_unit_hostname(all_ngw_units[0])
506
298
    mock_run_action_on_unit.assert_called_once()
507
299
    mock_data_from_action.assert_called_once()
508
300
509
301
510
302
@mock.patch("juju_verify.verifiers.neutron_gateway.run_action_on_unit")
511
303
@mock.patch("juju_verify.verifiers.neutron_gateway.data_from_action")
512
304
def test_get_unit_resource_list(mock_data_from_action, mock_run_action_on_unit):
513
305
    """Test Neutron agent resources are retrieved via Juju actions."""
514
306
    resource = {"routers": [{"id": "r1"}]}
515
307
    mock_data_from_action.return_value = json.dumps(resource)
516
308
    resource_list = get_unit_resource_list(all_ngw_units[0], "get-status-routers")
517
309
    mock_run_action_on_unit.assert_called_once()
518
310
    assert resource == resource_list
Reviewer	Review Type	Date Requested	Status
Martin Kalcok (community)		2021-03-22	Needs Fixing on 2021-03-26
Robert Gildein		2021-03-22	Needs Fixing on 2021-03-26
🤖 prod-jenkaas-bootstack (community)	continuous-integration		Needs Fixing on 2021-03-26
Review via email: mp+399961@code.launchpad.net