f243bf7cb35e93d2c7a0d2c021145eca700dd8a6
[ric-plt/a1.git] / tests / test_controller.py
1 """
2 tests for controller
3 """
4 # ==================================================================================
5 #       Copyright (c) 2019-2020 Nokia
6 #       Copyright (c) 2018-2020 AT&T Intellectual Property.
7 #
8 #   Licensed under the Apache License, Version 2.0 (the "License");
9 #   you may not use this file except in compliance with the License.
10 #   You may obtain a copy of the License at
11 #
12 #          http://www.apache.org/licenses/LICENSE-2.0
13 #
14 #   Unless required by applicable law or agreed to in writing, software
15 #   distributed under the License is distributed on an "AS IS" BASIS,
16 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 #   See the License for the specific language governing permissions and
18 #   limitations under the License.
19 # ==================================================================================
20 import time
21 import json
22 from ricxappframe.rmr.rmr_mocks import rmr_mocks
23 from ricxappframe.xapp_sdl import SDLWrapper
24 from ricsdl.exceptions import RejectedByBackend, NotConnected, BackendError
25 from a1 import a1rmr, data
26
27 RCV_ID = "test_receiver"
28 ADM_CRTL_TID = 6660666
29 ADM_CTRL_IID = "admission_control_policy"
30 ADM_CTRL_POLICIES = "/a1-p/policytypes/{0}/policies".format(ADM_CRTL_TID)
31 ADM_CTRL_INSTANCE = ADM_CTRL_POLICIES + "/" + ADM_CTRL_IID
32 ADM_CTRL_INSTANCE_STATUS = ADM_CTRL_INSTANCE + "/status"
33 ADM_CTRL_TYPE = "/a1-p/policytypes/{0}".format(ADM_CRTL_TID)
34 ACK_MT = 20011
35
36
37 def _fake_dequeue():
38     """for monkeypatching with a good status"""
39     pay = json.dumps(
40         {"policy_type_id": ADM_CRTL_TID, "policy_instance_id": ADM_CTRL_IID, "handler_id": RCV_ID, "status": "OK"}
41     ).encode()
42     fake_msg = {"payload": pay, "message type": ACK_MT}
43     return [(fake_msg, None)]
44
45
46 def _fake_dequeue_none():
47     """for monkeypatching with no waiting messages"""
48     return []
49
50
51 def _fake_dequeue_deleted():
52     """for monkeypatching  with a DELETED status"""
53     new_msgs = []
54     good_pay = json.dumps(
55         {"policy_type_id": ADM_CRTL_TID, "policy_instance_id": ADM_CTRL_IID, "handler_id": RCV_ID, "status": "DELETED"}
56     ).encode()
57
58     # non existent type id
59     pay = json.dumps(
60         {"policy_type_id": 911, "policy_instance_id": ADM_CTRL_IID, "handler_id": RCV_ID, "status": "DELETED"}
61     ).encode()
62     fake_msg = {"payload": pay, "message type": ACK_MT}
63     new_msgs.append((fake_msg, None))
64
65     # bad instance id
66     pay = json.dumps(
67         {"policy_type_id": ADM_CRTL_TID, "policy_instance_id": "darkness", "handler_id": RCV_ID, "status": "DELETED"}
68     ).encode()
69     fake_msg = {"payload": pay, "message type": ACK_MT}
70     new_msgs.append((fake_msg, None))
71
72     # good body but bad message type
73     fake_msg = {"payload": good_pay, "message type": ACK_MT * 3}
74     new_msgs.append((fake_msg, None))
75
76     # insert a bad one with a malformed body to make sure we keep going
77     new_msgs.append(({"payload": "asdf", "message type": ACK_MT}, None))
78
79     # not even a json
80     new_msgs.append(("asdf", None))
81
82     # good
83     fake_msg = {"payload": good_pay, "message type": ACK_MT}
84     new_msgs.append((fake_msg, None))
85
86     return new_msgs
87
88
89 def _test_put_patch(monkeypatch):
90     rmr_mocks.patch_rmr(monkeypatch)
91     # assert that rmr bad states don't cause problems
92     monkeypatch.setattr("ricxappframe.rmr.rmr.rmr_send_msg", rmr_mocks.send_mock_generator(10))
93
94
95 def _no_ac(client):
96     # no type there yet
97     res = client.get(ADM_CTRL_TYPE)
98     assert res.status_code == 404
99
100     # no types at all
101     res = client.get("/a1-p/policytypes")
102     assert res.status_code == 200
103     assert res.json == []
104
105     # instance 404 because type not there yet
106     res = client.get(ADM_CTRL_POLICIES)
107     assert res.status_code == 404
108
109
110 def _put_ac_type(client, typedef):
111     _no_ac(client)
112
113     # put the type
114     res = client.put(ADM_CTRL_TYPE, json=typedef)
115     assert res.status_code == 201
116
117     # cant replace types
118     res = client.put(ADM_CTRL_TYPE, json=typedef)
119     assert res.status_code == 400
120
121     # type there now
122     res = client.get(ADM_CTRL_TYPE)
123     assert res.status_code == 200
124     assert res.json == typedef
125
126     # type in type list
127     res = client.get("/a1-p/policytypes")
128     assert res.status_code == 200
129     assert res.json == [ADM_CRTL_TID]
130
131     # instance 200 but empty list
132     res = client.get(ADM_CTRL_POLICIES)
133     assert res.status_code == 200
134     assert res.json == []
135
136
137 def _delete_ac_type(client):
138     res = client.delete(ADM_CTRL_TYPE)
139     assert res.status_code == 204
140
141     # cant get
142     res = client.get(ADM_CTRL_TYPE)
143     assert res.status_code == 404
144
145     # cant invoke delete on it again
146     res = client.delete(ADM_CTRL_TYPE)
147     assert res.status_code == 404
148
149     _no_ac(client)
150
151
152 def _put_ac_instance(client, monkeypatch, instancedef):
153     # no instance there yet
154     res = client.get(ADM_CTRL_INSTANCE)
155     assert res.status_code == 404
156     res = client.get(ADM_CTRL_INSTANCE_STATUS)
157     assert res.status_code == 404
158
159     # create a good instance
160     _test_put_patch(monkeypatch)
161     res = client.put(ADM_CTRL_INSTANCE, json=instancedef)
162     assert res.status_code == 202
163
164     # replace is allowed on instances
165     res = client.put(ADM_CTRL_INSTANCE, json=instancedef)
166     assert res.status_code == 202
167
168     # instance 200 and in list
169     res = client.get(ADM_CTRL_POLICIES)
170     assert res.status_code == 200
171     assert res.json == [ADM_CTRL_IID]
172
173
174 def _delete_instance(client):
175     # cant delete type until there are no instances
176     res = client.delete(ADM_CTRL_TYPE)
177     assert res.status_code == 400
178
179     # delete it
180     res = client.delete(ADM_CTRL_INSTANCE)
181     assert res.status_code == 202
182
183     # should be able to do multiple deletes until it's actually gone
184     res = client.delete(ADM_CTRL_INSTANCE)
185     assert res.status_code == 202
186
187
188 def _instance_is_gone(client, seconds_to_try=10):
189     for _ in range(seconds_to_try):
190         # idea here is that we have to wait for the seperate thread to process the event
191         try:
192             res = client.get(ADM_CTRL_INSTANCE_STATUS)
193             assert res.status_code == 404
194         except AssertionError:
195             time.sleep(1)
196
197     res = client.get(ADM_CTRL_INSTANCE_STATUS)
198     assert res.status_code == 404
199
200     # list still 200 but no instance
201     res = client.get(ADM_CTRL_POLICIES)
202     assert res.status_code == 200
203     assert res.json == []
204
205     # cant get instance
206     res = client.get(ADM_CTRL_INSTANCE)
207     assert res.status_code == 404
208
209
210 def _verify_instance_and_status(client, expected_instance, expected_status, expected_deleted, seconds_to_try=5):
211     # get the instance
212     res = client.get(ADM_CTRL_INSTANCE)
213     assert res.status_code == 200
214     assert res.json == expected_instance
215
216     for _ in range(seconds_to_try):
217         # idea here is that we have to wait for the seperate thread to process the event
218         res = client.get(ADM_CTRL_INSTANCE_STATUS)
219         assert res.status_code == 200
220         assert res.json["has_been_deleted"] == expected_deleted
221         try:
222             assert res.json["instance_status"] == expected_status
223             return
224         except AssertionError:
225             time.sleep(1)
226     assert res.json["instance_status"] == expected_status
227
228
229 # Module level Hack
230
231
232 def setup_module():
233     """module level setup"""
234
235     # swap sdl for the fake backend
236     data.SDL = SDLWrapper(use_fake_sdl=True)
237
238     def noop():
239         pass
240
241     # launch the thread with a fake init func and a patched rcv func; we will "repatch" later
242     a1rmr.start_rmr_thread(init_func_override=noop, rcv_func_override=_fake_dequeue_none)
243
244
245 # Actual Tests
246
247
248 def test_workflow(client, monkeypatch, adm_type_good, adm_instance_good):
249     """
250     test a full A1 workflow
251     """
252
253     # put type and instance
254     _put_ac_type(client, adm_type_good)
255     _put_ac_instance(client, monkeypatch, adm_instance_good)
256
257     """
258     we test the state transition diagram of all 5 states here;
259     1. not in effect, not deleted
260     2. in effect, not deleted
261     3. in effect, deleted
262     4. not in effect, deleted
263     5. gone (timeout expires)
264     """
265
266     # try a status get but we didn't get any ACKs yet to test NOT IN EFFECT
267     _verify_instance_and_status(client, adm_instance_good, "NOT IN EFFECT", False)
268
269     # now pretend we did get a good ACK
270     a1rmr.replace_rcv_func(_fake_dequeue)
271     _verify_instance_and_status(client, adm_instance_good, "IN EFFECT", False)
272
273     # delete the instance
274     _delete_instance(client)
275
276     # status after a delete, but there are no messages yet, should still return
277     _verify_instance_and_status(client, adm_instance_good, "IN EFFECT", True)
278
279     # now pretend we deleted successfully
280     a1rmr.replace_rcv_func(_fake_dequeue_deleted)
281
282     # status should be reflected first (before delete triggers)
283     _verify_instance_and_status(client, adm_instance_good, "NOT IN EFFECT", True)
284
285     # instance should be totally gone after a few seconds
286     _instance_is_gone(client)
287
288     # delete the type
289     _delete_ac_type(client)
290
291
292 def test_cleanup_via_t1(client, monkeypatch, adm_type_good, adm_instance_good):
293     """
294     create a type, create an instance, but no acks ever come in, delete instance
295     """
296     _put_ac_type(client, adm_type_good)
297
298     a1rmr.replace_rcv_func(_fake_dequeue_none)
299
300     _put_ac_instance(client, monkeypatch, adm_instance_good)
301
302     """
303     here we test the state transition diagram when it never goes into effect:
304     1. not in effect, not deleted
305     2. not in effect, deleted
306     3. gone (timeout expires)
307     """
308
309     _verify_instance_and_status(client, adm_instance_good, "NOT IN EFFECT", False)
310
311     # delete the instance
312     _delete_instance(client)
313
314     _verify_instance_and_status(client, adm_instance_good, "NOT IN EFFECT", True)
315
316     # instance should be totally gone after a few seconds
317     _instance_is_gone(client)
318
319     # delete the type
320     _delete_ac_type(client)
321
322
323 def test_bad_instances(client, monkeypatch, adm_type_good):
324     """
325     test various failure modes
326     """
327     # put the type (needed for some of the tests below)
328     rmr_mocks.patch_rmr(monkeypatch)
329     res = client.put(ADM_CTRL_TYPE, json=adm_type_good)
330     assert res.status_code == 201
331
332     # bad body
333     res = client.put(ADM_CTRL_INSTANCE, json={"not": "expected"})
334     assert res.status_code == 400
335
336     # bad media type
337     res = client.put(ADM_CTRL_INSTANCE, data="notajson")
338     assert res.status_code == 415
339
340     # delete a non existent instance
341     res = client.delete(ADM_CTRL_INSTANCE + "DARKNESS")
342     assert res.status_code == 404
343
344     # get a non existent instance
345     a1rmr.replace_rcv_func(_fake_dequeue)
346     res = client.get(ADM_CTRL_INSTANCE + "DARKNESS")
347     assert res.status_code == 404
348
349     # delete the type (as cleanup)
350     res = client.delete(ADM_CTRL_TYPE)
351     assert res.status_code == 204
352
353     # test 503 handlers
354
355     def monkey_set(ns, key, value):
356         # set a key override function that throws sdl errors on certain keys
357         if key == "a1.policy_type.111":
358             raise RejectedByBackend()
359         if key == "a1.policy_type.112":
360             raise NotConnected()
361         if key == "a1.policy_type.113":
362             raise BackendError()
363
364     monkeypatch.setattr("a1.data.SDL.set", monkey_set)
365
366     def create_alt_id(json, id):
367         """
368         Overwrites the json's policy type ID, attempts create and tests for 503
369         """
370         json['policy_type_id'] = id
371         url = "/a1-p/policytypes/{0}".format(id)
372         res = client.put(url, json=json)
373         assert res.status_code == 503
374
375     create_alt_id(adm_type_good, 111)
376     create_alt_id(adm_type_good, 112)
377     create_alt_id(adm_type_good, 113)
378
379
380 def test_illegal_types(client, adm_type_good):
381     """
382     Test illegal types
383     """
384     # below valid range
385     res = client.put("/a1-p/policytypes/0", json=adm_type_good)
386     assert res.status_code == 400
387     # ID mismatch
388     res = client.put("/a1-p/policytypes/1", json=adm_type_good)
389     assert res.status_code == 400
390     # above valid range
391     res = client.put("/a1-p/policytypes/2147483648", json=adm_type_good)
392     assert res.status_code == 400
393
394
395 def test_healthcheck(client):
396     """
397     test healthcheck
398     """
399     res = client.get("/a1-p/healthcheck")
400     assert res.status_code == 200
401
402
403 def teardown_module():
404     """module teardown"""
405     a1rmr.stop_rmr_thread()