diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/test_policyhandler.py | 421 |
1 files changed, 364 insertions, 57 deletions
diff --git a/tests/test_policyhandler.py b/tests/test_policyhandler.py index 61ca00c..c90e521 100644 --- a/tests/test_policyhandler.py +++ b/tests/test_policyhandler.py @@ -18,44 +18,106 @@ # # ECOMP is a trademark and service mark of AT&T Intellectual Property. -import sys +import copy import json -import re import logging +import re +import sys +import time +import uuid from datetime import datetime -# import pytest +import pytest + +import cherrypy +from cherrypy.test.helper import CPWebCase from policyhandler.config import Config +from policyhandler.deploy_handler import DeployHandler +from policyhandler.discovery import DiscoveryClient +from policyhandler.onap.audit import (REQUEST_X_ECOMP_REQUESTID, Audit, + AuditHttpCode) +from policyhandler.policy_consts import (POLICY_BODY, POLICY_CONFIG, POLICY_ID, + POLICY_NAME, POLICY_VERSION) from policyhandler.policy_handler import LogWriter -from policyhandler.onap.audit import Audit -from policyhandler.policy_rest import PolicyRest, PolicyUtils -from policyhandler.policy_consts import POLICY_ID, POLICY_VERSION, POLICY_NAME, \ - POLICY_BODY, POLICY_CONFIG +from policyhandler.policy_receiver import (LOADED_POLICIES, POLICY_VER, + REMOVED_POLICIES, PolicyReceiver) +from policyhandler.policy_rest import PolicyRest +from policyhandler.policy_utils import PolicyUtils +from policyhandler.web_server import _PolicyWeb + +POLICY_HANDLER_VERSION = "2.0.0" + +class MonkeyHttpResponse(object): + """Monkey http reposne""" + def __init__(self, headers): + self.headers = headers or {} + +class MonkeyedResponse(object): + """Monkey response""" + def __init__(self, full_path, res_json, json_body=None, headers=None): + self.full_path = full_path + self.req_json = json_body or {} + self.status_code = 200 + self.request = MonkeyHttpResponse(headers) + self.res = res_json + self.text = json.dumps(self.res) + + def json(self): + """returns json of response""" + return self.res + + def raise_for_status(self): + """ignoring""" + pass + +def monkeyed_discovery(full_path): + """monkeypatch for get from consul""" + res_json = {} + if full_path == DiscoveryClient.CONSUL_SERVICE_MASK.format(Config.config["deploy_handler"]): + res_json = [{ + DiscoveryClient.SERVICE_ADDRESS: "1.1.1.1", + DiscoveryClient.SERVICE_PORT: "123" + }] + elif full_path == DiscoveryClient.CONSUL_KV_MASK.format(Config.get_system_name()): + res_json = copy.deepcopy(Settings.dicovered_config) + return MonkeyedResponse(full_path, res_json) + +@pytest.fixture() +def fix_discovery(monkeypatch): + """monkeyed discovery request.get""" + Settings.logger.info("setup fix_discovery") + monkeypatch.setattr('policyhandler.discovery.requests.get', monkeyed_discovery) + yield fix_discovery # provide the fixture value + Settings.logger.info("teardown fix_discovery") class Settings(object): """init all locals""" logger = None RUN_TS = datetime.utcnow().isoformat()[:-3] + 'Z' + dicovered_config = None @staticmethod def init(): """init locals""" Config.load_from_file() + + with open("etc_upload/config.json", 'r') as config_json: + Settings.dicovered_config = json.load(config_json) + Config.load_from_file("etc_upload/config.json") - Settings.logger = logging.getLogger("policy_handler") + Settings.logger = logging.getLogger("policy_handler.unit_test") sys.stdout = LogWriter(Settings.logger.info) sys.stderr = LogWriter(Settings.logger.error) + print "print ========== run_policy_handler ==========" Settings.logger.info("========== run_policy_handler ==========") - Audit.init(Config.get_system_name(), Config.LOGGER_CONFIG_FILE_PATH) + Audit.init(Config.get_system_name(), POLICY_HANDLER_VERSION, Config.LOGGER_CONFIG_FILE_PATH) Settings.logger.info("starting policy_handler with config:") Settings.logger.info(Audit.log_json_dumps(Config.config)) - PolicyRest._lazy_init() - Settings.init() class MonkeyPolicyBody(object): @@ -80,7 +142,7 @@ class MonkeyPolicyBody(object): POLICY_VERSION: this_ver, POLICY_CONFIG: json.dumps(config), "matchingConditions": { - "ECOMPName": "DCAE", + "ONAPName": "DCAE", "ConfigName": "alex_config_name" }, "responseAttributes": {}, @@ -95,19 +157,22 @@ class MonkeyPolicyBody(object): for key in policy_body_1.keys(): if key not in policy_body_2: return False - if isinstance(policy_body_1[key], dict): - return MonkeyPolicyBody.is_the_same_dict( - policy_body_1[key], policy_body_2[key]) - if (policy_body_1[key] is None and policy_body_2[key] is not None) \ - or (policy_body_1[key] is not None and policy_body_2[key] is None) \ - or (policy_body_1[key] != policy_body_2[key]): + + val_1 = policy_body_1[key] + val_2 = policy_body_2[key] + if isinstance(val_1, dict) \ + and not MonkeyPolicyBody.is_the_same_dict(val_1, val_2): + return False + if (val_1 is None and val_2 is not None) \ + or (val_1 is not None and val_2 is None) \ + or (val_1 != val_2): return False return True class MonkeyPolicyEngine(object): """pretend this is the policy-engine""" _scope_prefix = Config.config["scope_prefixes"][0] - LOREM_IPSUM = """Lorem ipsum dolor sit amet consectetur""".split() + LOREM_IPSUM = """Lorem ipsum dolor sit amet consectetur ametist""".split() _policies = [] @staticmethod @@ -115,18 +180,19 @@ class MonkeyPolicyEngine(object): """init static vars""" MonkeyPolicyEngine._policies = [ MonkeyPolicyBody.create_policy_body( - MonkeyPolicyEngine._scope_prefix + policy_id, policy_version) + MonkeyPolicyEngine._scope_prefix + policy_id, policy_index + 1) for policy_id in MonkeyPolicyEngine.LOREM_IPSUM - for policy_version in range(1, 1 + MonkeyPolicyEngine.LOREM_IPSUM.index(policy_id))] + for policy_index in range(1 + MonkeyPolicyEngine.LOREM_IPSUM.index(policy_id))] + Settings.logger.info("MonkeyPolicyEngine._policies: %s", + json.dumps(MonkeyPolicyEngine._policies)) @staticmethod def get_config(policy_name): """find policy the way the policy-engine finds""" if not policy_name: return [] - if policy_name[-2:] == ".*": - policy_name = policy_name[:-2] - return [policy for policy in MonkeyPolicyEngine._policies + return [copy.deepcopy(policy) + for policy in MonkeyPolicyEngine._policies if re.match(policy_name, policy[POLICY_NAME])] @staticmethod @@ -135,49 +201,290 @@ class MonkeyPolicyEngine(object): return MonkeyPolicyEngine._scope_prefix \ + MonkeyPolicyEngine.LOREM_IPSUM[policy_index % len(MonkeyPolicyEngine.LOREM_IPSUM)] -MonkeyPolicyEngine.init() + @staticmethod + def gen_policy_latest(policy_index): + """generate the policy response by policy_index = version - 1""" + policy_id = MonkeyPolicyEngine.get_policy_id(policy_index) + expected_policy = { + POLICY_ID : policy_id, + POLICY_BODY : MonkeyPolicyBody.create_policy_body(policy_id, policy_index + 1) + } + return policy_id, PolicyUtils.parse_policy_config(expected_policy) -class MonkeyHttpResponse(object): - """Monkey http reposne""" - def __init__(self, headers): - self.headers = headers or {} + @staticmethod + def gen_all_policies_latest(): + """generate all latest policies""" + return dict( + MonkeyPolicyEngine.gen_policy_latest(policy_index) + for policy_index in range(len(MonkeyPolicyEngine.LOREM_IPSUM)) + ) -class MonkeyedResponse(object): - """Monkey response""" - def __init__(self, full_path, json_body, headers): - self.full_path = full_path - self.req_json = json_body or {} - self.status_code = 200 - self.request = MonkeyHttpResponse(headers) - self.req_policy_name = self.req_json.get(POLICY_NAME) - self.res = MonkeyPolicyEngine.get_config(self.req_policy_name) - self.text = json.dumps(self.res) + @staticmethod + def gen_policies_latest(match_to_policy_name): + """generate all latest policies""" + return dict( + (k, v) + for k, v in MonkeyPolicyEngine.gen_all_policies_latest().iteritems() + if re.match(match_to_policy_name, k) + ) - def json(self): - """returns json of response""" - return self.res +MonkeyPolicyEngine.init() -def monkeyed_policy_rest_post(full_path, json={}, headers={}): +def monkeyed_policy_rest_post(full_path, json=None, headers=None): """monkeypatch for the POST to policy-engine""" - return MonkeyedResponse(full_path, json, headers) + res_json = MonkeyPolicyEngine.get_config(json.get(POLICY_NAME)) + return MonkeyedResponse(full_path, res_json, json, headers) + +@pytest.fixture() +def fix_pdp_post(monkeypatch): + """monkeyed request /getConfig to PDP""" + Settings.logger.info("setup fix_pdp_post") + PolicyRest._lazy_init() + monkeypatch.setattr('policyhandler.policy_rest.PolicyRest._requests_session.post', + monkeyed_policy_rest_post) + yield fix_pdp_post # provide the fixture value + Settings.logger.info("teardown fix_pdp_post") + +def monkeyed_deploy_handler(full_path, json=None, headers=None): + """monkeypatch for deploy_handler""" + return MonkeyedResponse(full_path, {}, json, headers) -def test_get_policy_latest(monkeypatch): +@pytest.fixture() +def fix_deploy_handler(monkeypatch, fix_discovery): + """monkeyed discovery request.get""" + Settings.logger.info("setup fix_deploy_handler") + DeployHandler._lazy_init() + monkeypatch.setattr('policyhandler.deploy_handler.DeployHandler._requests_session.post', + monkeyed_deploy_handler) + yield fix_deploy_handler # provide the fixture value + Settings.logger.info("teardown fix_deploy_handler") + +def monkeyed_cherrypy_engine_exit(): + """monkeypatch for deploy_handler""" + Settings.logger.info("monkeyed_cherrypy_engine_exit()") + +@pytest.fixture() +def fix_cherrypy_engine_exit(monkeypatch): + """monkeyed cherrypy.engine.exit()""" + Settings.logger.info("setup fix_cherrypy_engine_exit") + monkeypatch.setattr('policyhandler.web_server.cherrypy.engine.exit', + monkeyed_cherrypy_engine_exit) + yield fix_cherrypy_engine_exit # provide the fixture value + Settings.logger.info("teardown fix_cherrypy_engine_exit") + +class MonkeyedWebSocket(object): + """Monkey websocket""" + on_message = None + + @staticmethod + def send_notification(updated_indexes): + """fake notification through the web-socket""" + if not MonkeyedWebSocket.on_message: + return + message = { + LOADED_POLICIES : [ + {POLICY_NAME: "{0}.{1}.xml".format( + MonkeyPolicyEngine.get_policy_id(policy_index), policy_index + 1), + POLICY_VER: str(policy_index + 1)} + for policy_index in updated_indexes or [] + ], + REMOVED_POLICIES : [] + } + message = json.dumps(message) + Settings.logger.info("send_notification: %s", message) + MonkeyedWebSocket.on_message(None, message) + + @staticmethod + def enableTrace(yes_no): + """ignore""" + pass + + class MonkeyedSocket(object): + """Monkey websocket""" + def __init__(self): + self.connected = True + + class WebSocketApp(object): + """Monkeyed WebSocketApp""" + def __init__(self, web_socket_url, on_message=None, on_close=None, on_error=None): + self.web_socket_url = web_socket_url + self.on_message = MonkeyedWebSocket.on_message = on_message + self.on_close = on_close + self.on_error = on_error + self.sock = MonkeyedWebSocket.MonkeyedSocket() + Settings.logger.info("MonkeyedWebSocket for: %s", self.web_socket_url) + + def run_forever(self): + """forever in the loop""" + while self.sock.connected: + Settings.logger.info("MonkeyedWebSocket sleep...") + time.sleep(5) + Settings.logger.info("MonkeyedWebSocket exit") + + def close(self): + """close socket""" + self.sock.connected = False + +@pytest.fixture() +def fix_policy_receiver_websocket(monkeypatch): + """monkeyed websocket for policy_receiver""" + Settings.logger.info("setup fix_policy_receiver_websocket") + monkeypatch.setattr('policyhandler.policy_receiver.websocket', MonkeyedWebSocket) + yield fix_policy_receiver_websocket # provide the fixture value + Settings.logger.info("teardown fix_policy_receiver_websocket") + +def test_get_policy_latest(fix_pdp_post): """test /policy_latest/<policy-id>""" - monkeypatch.setattr('policyhandler.policy_rest.PolicyRest._requests_session.post', \ - monkeyed_policy_rest_post) - policy_index = 3 - policy_id = MonkeyPolicyEngine.get_policy_id(policy_index) - expected_policy = { - POLICY_ID : policy_id, - POLICY_BODY : MonkeyPolicyBody.create_policy_body(policy_id, policy_index) - } - expected_policy = PolicyUtils.parse_policy_config(expected_policy) + policy_id, expected_policy = MonkeyPolicyEngine.gen_policy_latest(3) audit = Audit(req_message="get /policy_latest/{0}".format(policy_id or "")) - policy_latest = PolicyRest.get_latest_policy((audit, policy_id)) or {} + policy_latest = PolicyRest.get_latest_policy((audit, policy_id, None, None)) or {} audit.audit_done(result=json.dumps(policy_latest)) - Settings.logger.info("expected_policy: {0}".format(json.dumps(expected_policy))) - Settings.logger.info("policy_latest: {0}".format(json.dumps(policy_latest))) + Settings.logger.info("expected_policy: %s", json.dumps(expected_policy)) + Settings.logger.info("policy_latest: %s", json.dumps(policy_latest)) assert MonkeyPolicyBody.is_the_same_dict(policy_latest, expected_policy) assert MonkeyPolicyBody.is_the_same_dict(expected_policy, policy_latest) + +def test_healthcheck(): + """test /healthcheck""" + audit = Audit(req_message="get /healthcheck") + audit.metrics_start("test /healthcheck") + time.sleep(0.1) + + audit.metrics("test /healthcheck") + health = Audit.health() or {} + audit.audit_done(result=json.dumps(health)) + + Settings.logger.info("healthcheck: %s", json.dumps(health)) + assert bool(health) + +def test_healthcheck_with_error(): + """test /healthcheck""" + audit = Audit(req_message="get /healthcheck") + audit.metrics_start("test /healthcheck") + time.sleep(0.2) + audit.error("error from test_healthcheck_with_error") + audit.fatal("fatal from test_healthcheck_with_error") + audit.debug("debug from test_healthcheck_with_error") + audit.warn("debug from test_healthcheck_with_error") + audit.info_requested("debug from test_healthcheck_with_error") + if audit.is_success(): + audit.set_http_status_code(AuditHttpCode.DATA_NOT_FOUND_ERROR.value) + audit.set_http_status_code(AuditHttpCode.SERVER_INTERNAL_ERROR.value) + audit.metrics("test /healthcheck") + + health = Audit.health() or {} + audit.audit_done(result=json.dumps(health)) + + Settings.logger.info("healthcheck: %s", json.dumps(health)) + assert bool(health) + +@pytest.mark.usefixtures("fix_pdp_post") +class WebServerTest(CPWebCase): + """testing the web-server - runs tests in alphabetical order of method names""" + def setup_server(): + """setup the web-server""" + cherrypy.tree.mount(_PolicyWeb(), '/') + + setup_server = staticmethod(setup_server) + + def test_web_healthcheck(self): + """test /healthcheck""" + result = self.getPage("/healthcheck") + Settings.logger.info("healthcheck result: %s", result) + Settings.logger.info("got healthcheck: %s", self.body) + self.assertStatus('200 OK') + + def test_web_policy_latest(self): + """test /policy_latest/<policy-id>""" + policy_id, expected_policy = MonkeyPolicyEngine.gen_policy_latest(3) + + self.getPage("/policy_latest/{0}".format(policy_id or "")) + self.assertStatus('200 OK') + + policy_latest = json.loads(self.body) + + Settings.logger.info("policy_latest: %s", self.body) + Settings.logger.info("expected_policy: %s", json.dumps(expected_policy)) + assert MonkeyPolicyBody.is_the_same_dict(policy_latest, expected_policy) + assert MonkeyPolicyBody.is_the_same_dict(expected_policy, policy_latest) + + def test_web_all_policies_latest(self): + """test GET /policies_latest""" + expected_policies = MonkeyPolicyEngine.gen_all_policies_latest() + + result = self.getPage("/policies_latest") + Settings.logger.info("result: %s", result) + Settings.logger.info("body: %s", self.body) + self.assertStatus('200 OK') + + policies_latest = json.loads(self.body) + self.assertIn("valid_policies", policies_latest) + policies_latest = policies_latest["valid_policies"] + + Settings.logger.info("policies_latest: %s", json.dumps(policies_latest)) + Settings.logger.info("expected_policies: %s", json.dumps(expected_policies)) + assert MonkeyPolicyBody.is_the_same_dict(policies_latest, expected_policies) + assert MonkeyPolicyBody.is_the_same_dict(expected_policies, policies_latest) + + def test_web_policies_latest(self): + """test POST /policies_latest with policyName""" + match_to_policy_name = Config.config["scope_prefixes"][0] + "amet.*" + expected_policies = MonkeyPolicyEngine.gen_policies_latest(match_to_policy_name) + + body = json.dumps({POLICY_NAME: match_to_policy_name}) + result = self.getPage("/policies_latest", method='POST', + body=body, + headers=[ + (REQUEST_X_ECOMP_REQUESTID, str(uuid.uuid4())), + ("Content-Type", "application/json"), + ('Content-Length', str(len(body))) + ]) + Settings.logger.info("result: %s", result) + Settings.logger.info("body: %s", self.body) + self.assertStatus('200 OK') + + policies_latest = json.loads(self.body) + + Settings.logger.info("policies_latest: %s", json.dumps(policies_latest)) + Settings.logger.info("expected_policies: %s", json.dumps(expected_policies)) + assert MonkeyPolicyBody.is_the_same_dict(policies_latest, expected_policies) + assert MonkeyPolicyBody.is_the_same_dict(expected_policies, policies_latest) + + @pytest.mark.usefixtures( + "fix_deploy_handler", + "fix_policy_receiver_websocket", + "fix_cherrypy_engine_exit") + def test_zzz_run_policy_handler(self): + """test run policy handler""" + Settings.logger.info("start policy handler") + audit = Audit(req_message="start policy handler") + PolicyReceiver.run(audit) + + Settings.logger.info("sleep before send_notification...") + time.sleep(2) + + MonkeyedWebSocket.send_notification([1, 3, 5]) + Settings.logger.info("sleep after send_notification...") + time.sleep(3) + + Settings.logger.info("sleep before shutdown...") + time.sleep(1) + result = self.getPage("/shutdown") + Settings.logger.info("shutdown result: %s", result) + self.assertStatus('200 OK') + Settings.logger.info("got shutdown: %s", self.body) + time.sleep(1) + + # @pytest.mark.usefixtures("fix_deploy_handler", "fix_policy_receiver_websocket") + # def test_zzz_web_catch_up(self): + # """test /catch_up""" + # Settings.logger.info("start policy handler") + # audit = Audit(req_message="start policy handler") + # PolicyReceiver.run(audit) + # time.sleep(5) + # result = self.getPage("/catch_up") + # Settings.logger.info("catch_up result: %s", result) + # self.assertStatus('200 OK') + # Settings.logger.info("got catch_up: %s", self.body) |