def test_get_codes(mock_database, caplog, case_data: CaseDataGetter):
(
test_data,
code,
key,
expected_result,
expected_result_count,
expected_logger_message,
) = case_data.get()
# Set up test data
insert_test_data(test_data=test_data)
# Run test function
db = boto3.resource("dynamodb")
result = code_generator.get_codes(database=db, code=code, key=key)
assert len(result) == expected_result_count
if expected_result_count == 0:
with caplog.at_level(logging.INFO):
assert expected_logger_message in caplog.text
for row in result:
assert isinstance(row["active"], bool)
if code:
assert code == row["code"]
if key:
assert key["lpa"] == row["lpa"]
assert key["actor"] == row["actor"]
remove_test_data(test_data)
def test_update_codes_by_key(mock_database, case_data: CaseDataGetter):
test_data, key, code, status, expected_result = case_data.get()
before_test_data = insert_test_data(test_data=test_data)
# Set some expectations
should_get_updated = [r["code"] for r in before_test_data if r["active"] != status]
status_should_be = status
last_updated_date_should_be = date_formatter(datetime.datetime.now())
# Run test function
db = boto3.resource("dynamodb")
test_result = update_codes(database=db, key=key, code=code, status=status)
# Test db contents after function
after_test_data = get_codes(database=db, key=key, code=code)
for row in after_test_data:
assert isinstance(row["active"], bool)
assert row["active"] == status_should_be
if row["code"] in should_get_updated:
assert row["last_updated_date"] == last_updated_date_should_be
assert test_result == expected_result
remove_test_data(test_data)
def test_checklist_put(server, case_data: CaseDataGetter):
(
test_data,
test_headers,
test_report_id,
test_checklist_id,
test_case_ref,
expected_response_status_code,
expected_response_data,
) = case_data.get()
with server.app_context():
print(f"test_case_ref: {test_case_ref}")
print(f"test_report_id: {test_report_id}")
print(f"test_data: {test_data}")
r = requests.put(
f"{server.url}/clients/{test_case_ref}/reports/"
f"{test_checklist_id}/checklists/{test_checklist_id}",
headers=test_headers,
data=json.dumps(test_data),
)
assert r.status_code == expected_response_status_code
assert r.json() == expected_response_data
def test_supporting_docs_errors(server, case_data: CaseDataGetter):
(
test_data,
test_headers,
test_report_id,
test_case_ref,
expected_response_status_code,
expected_response_data,
) = case_data.get()
with server.app_context():
print(f"test_case_ref: {test_case_ref}")
print(f"test_report_id: {test_report_id}")
print(f"test_data: {test_data}")
r = requests.post(
f"{server.url}/clients/{test_case_ref}/reports/"
f"{test_report_id}/supportingdocuments",
headers=test_headers,
data=json.dumps(test_data),
)
assert r.status_code == expected_response_status_code
if r.status_code in [400]:
assert r.json()["body"]["error"]["code"] == expected_response_data
def test_post(mock_database, mock_generate_code, case_data: CaseDataGetter):
test_data, data, expected_result, expected_status_code = case_data.get()
result, status_code = handle_create(data=data)
assert result == expected_result
assert status_code == expected_status_code
if expected_result["codes"] is not None:
remove_test_data(expected_result["codes"])
def test_validate_payload(case_data: CaseDataGetter):
body, case_ref, report_id, expected_result = case_data.get()
path_params = {"caseref": case_ref, "id": report_id}
event = build_aws_event(event_body=json.dumps(body),
event_path_parementers=path_params,
as_json=False)
valid_event, errors = validate_event(event)
assert valid_event == expected_result[0]
assert sorted(errors) == sorted(expected_result[1])
def test_post(mock_database, case_data: CaseDataGetter):
test_data, data, expected_result, expected_status_code = case_data.get()
# Set up test data
insert_test_data(test_data=test_data)
result, status_code = handle_validate(data=data)
assert result == expected_result
assert status_code == expected_status_code
remove_test_data(test_data)
def test_submit_errors(monkeypatch, case_data: CaseDataGetter):
(data, method, endpoint, url_params, expected_responses) = case_data.get()
status_code, response = new_submit_document_to_sirius(
data=data, method=method, endpoint=endpoint, url_params=url_params)
print(f"status_code: {status_code}")
print(f"response: {response}")
assert (any(message in response
for message in expected_responses[status_code]) is True)
def test_check_code_unique(mock_database, caplog, case_data: CaseDataGetter):
test_data, code, logger_message, expected_result = case_data.get()
insert_test_data(test_data=test_data)
db = boto3.resource("dynamodb")
result = check_code_unique(database=db, code=code)
assert result == expected_result
with caplog.at_level(logging.INFO):
assert logger_message in caplog.text
remove_test_data(test_data)
def test_data(mock_database, mock_generate_code, case_data: CaseDataGetter):
test_data, data, expected_result, expected_status_code = case_data.get()
insert_test_data(test_data=test_data)
codes_created, status_code = handle_create(data=data)
for i, item in enumerate(data):
try:
lpa = data["lpas"][i]["lpa"]
actor = data["lpas"][i]["actor"]
dob = data["lpas"][i]["dob"]
except KeyError:
assert codes_created == expected_result
assert status_code == expected_status_code
break
if "" not in [lpa, actor, dob]:
db = boto3.resource("dynamodb")
table = db.Table(lpa_codes_table())
query_result = table.query(
IndexName="key_index",
KeyConditionExpression=Key("lpa").eq(lpa) & Key("actor").eq(actor),
)
print(f"query_result: {query_result}")
for item in query_result["Items"]:
if item["code"] == test_constants["DEFAULT_CODE"]:
assert item["dob"] == dob
assert item["active"] is True
assert item["status_details"] == "Generated"
assert item["last_updated_date"] == test_constants["TODAY_ISO"]
assert item["generated_date"] == test_constants["TODAY_ISO"]
assert item["expiry_date"] == test_constants["EXPIRY_DATE"]
else:
assert item["active"] is False
assert item["status_details"] == "Superseded"
else:
assert codes_created == expected_result
break
if expected_result["codes"] is not None:
remove_test_data(expected_result["codes"] + test_data)
else:
remove_test_data(test_data)
def test_new_format_sirius_response(case_data: CaseDataGetter):
(
sirius_response_code,
sirius_response,
api_response_code,
api_response,
) = case_data.get()
formatted_status_code, formatted_response_text = format_sirius_success(
sirius_response_code, sirius_response)
assert formatted_response_text == api_response
assert formatted_status_code == api_response_code
def test_get_codes_broken(
mock_database,
mock_generate_code,
broken_get_code,
caplog,
case_data: CaseDataGetter,
):
test_data, data, expected_result, expected_status_code = case_data.get()
result, status_code = handle_create(data=data)
assert status_code == 500
with caplog.at_level(logging.ERROR):
assert "get_codes" in caplog.text
def test_submit_success(monkeypatch, case_data: CaseDataGetter):
(
data,
method,
endpoint,
url_params,
expected_status_code,
expected_response,
) = case_data.get()
status_code, response = new_submit_document_to_sirius(
data=data, method=method, endpoint=endpoint, url_params=url_params)
assert response == expected_response
def test_bad_payload(case_data: CaseDataGetter, test_config):
(url, method, payload, expected_status_code) = case_data.get(test_config)
status, response = send_a_request(url=url,
method=method,
payload=payload,
test_config=test_config)
assert status == expected_status_code
response_data = json.loads(response)
if "errors" in response_data:
for error in response_data["errors"]:
assert error["code"] == "OPGDATA-API-INVALIDREQUEST"
else:
assert response_data["body"]["error"][
"code"] == "OPGDATA-API-INVALIDREQUEST"
def test_new_format_sirius_response_error(caplog, case_data: CaseDataGetter):
(
sirius_response_code,
sirius_response,
error_details,
api_response_code,
api_response,
) = case_data.get()
formatted_status_code, formatted_response_text = handle_sirius_error(
sirius_response_code, sirius_response, error_details)
print(f"formatted_response_text: {formatted_response_text}")
assert formatted_response_text == api_response
assert formatted_status_code == api_response_code
with caplog.at_level(logging.ERROR):
assert api_response in caplog.text
def test_submit_env_vars_broken(monkeypatch, case_data: CaseDataGetter):
(
data,
method,
endpoint,
url_params,
env_var,
expected_status_code,
expected_response,
) = case_data.get()
if env_var:
monkeypatch.delenv(env_var)
status_code, response = new_submit_document_to_sirius(
data=data, method=method, endpoint=endpoint, url_params=url_params)
assert response == expected_response
def test_post(mock_database, case_data: CaseDataGetter):
(
test_data,
data,
expected_result,
expected_last_updated_date,
expected_status_code,
) = case_data.get()
# Set up test data
insert_test_data(test_data=test_data)
# Perform revoke & check return
result, status_code = handle_revoke(data=data)
assert result == expected_result
assert status_code == expected_status_code
# Check the data after revoke has been performed
db = boto3.resource("dynamodb")
after_revoke = code_generator.get_codes(database=db, code=data["code"])
if after_revoke:
lpa = after_revoke[0]["lpa"]
actor = after_revoke[0]["actor"]
db = boto3.resource("dynamodb")
table = db.Table(lpa_codes_table())
query_result = table.query(
IndexName="key_index",
KeyConditionExpression=Key("lpa").eq(lpa) & Key("actor").eq(actor),
)
row_data = query_result["Items"][0]
if data["code"] == row_data["code"]:
assert row_data["last_updated_date"] == expected_last_updated_date
assert row_data["status_details"] in [
"Revoked",
"Superseded",
]
assert row_data["active"] is False
remove_test_data(test_data)
def test_custom_errors(server, case_data: CaseDataGetter):
(
test_url,
test_headers,
test_data,
test_method,
expected_response_status_code,
expected_response_data,
) = case_data.get()
test_url = test_url["url"]
with server.app_context():
if test_method == "NOT POST":
r = requests.get(url=f"{server.url}/{test_url}")
elif test_method == "PUT":
data = test_data
r = requests.put(
f"{server.url}/clients/{test_url}",
headers=test_headers,
data=data,
)
else:
data = test_data
r = requests.post(
f"{server.url}/clients/{test_url}",
headers=test_headers,
data=data,
)
print(f"r.text: {r.text}")
assert r.status_code == expected_response_status_code
assert r.json()["body"]["error"]["code"] == expected_response_data
