def test_write_plates_file_success(existing_output_path, test_rows_data,
expected_test_output, logger_messages):
data_path = os.path.join("tmp", "data")
output_path = os.path.join(data_path, "TEST")
filename = "testing.csv"
shutil.rmtree(data_path, ignore_errors=True)
try:
if existing_output_path:
os.makedirs(output_path)
write_plates_file(test_rows_data, output_path, filename)
with open(os.path.join(output_path, filename), mode="r") as f:
saved_data = f.read()
assert saved_data == expected_test_output
finally:
shutil.rmtree(data_path, ignore_errors=True)
assert len(logger_messages.error) == 0
assert is_found_in_list("Writing to file", logger_messages.info)
assert is_found_in_list("Test data plates file written",
logger_messages.info)
assert is_found_in_list("testing.csv", logger_messages.info)
def test_write_plates_file_exception(test_rows_data, logger_messages):
output_path = os.path.join("tmp", "data", "TEST")
filename = "testing.csv"
with patch("builtins.open", side_effect=OSError(5,
"Unable to write file")):
with pytest.raises(OSError):
write_plates_file(test_rows_data, output_path, filename)
assert is_found_in_list("Exception", logger_messages.error)
assert is_found_in_list("Unable to write file", logger_messages.error)
def test_generate_endpoint_invalid_json(json, client, logger_messages):
response = client.post(ENDPOINT, json=json)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert "run_id" not in response.json
assert "plates" not in response.json
assert "status" not in response.json
assert "timestamp" in response.json
assert is_found_in_list(FLASK_ERROR_MISSING_PARAMETERS,
response.json["errors"])
assert is_found_in_list(FLASK_ERROR_MISSING_PARAMETERS,
logger_messages.error)
def test_get_run_doc_gets_the_doc_by_id(logger_messages, mongo_collection):
_, collection = mongo_collection
pending_id = insert_run(collection)
actual = get_run_doc(collection, pending_id)
expected = get_doc(collection, pending_id)
assert actual == expected
assert is_found_in_list("Getting Mongo document", logger_messages.info)
assert is_found_in_list(str(pending_id), logger_messages.info)
assert is_found_in_list("Found run", logger_messages.debug)
assert is_found_in_list(str(actual), logger_messages.debug)
def test_generate_endpoint_handles_CherrypickerDataError_exception(
client, logger_messages, process_mock):
test_error_message = "Test Error!"
test_error = CherrypickerDataError(test_error_message)
process_mock.side_effect = test_error
response = client.post(ENDPOINT, json={"run_id": "test_id"})
assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
assert "run_id" not in response.json
assert "plates" not in response.json
assert "status" not in response.json
assert "timestamp" in response.json
assert is_found_in_list(test_error_message, response.json["errors"])
assert is_found_in_list(test_error_message, logger_messages.error)
def test_generate_endpoint_handles_generic_exception(client, logger_messages,
process_mock):
test_error = ConnectionError()
process_mock.side_effect = test_error
response = client.post(ENDPOINT, json={"run_id": "test_id"})
assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
assert "run_id" not in response.json
assert "plates" not in response.json
assert "status" not in response.json
assert "timestamp" in response.json
assert is_found_in_list(FLASK_ERROR_UNEXPECTED, response.json["errors"])
assert is_found_in_list(type(test_error).__name__, response.json["errors"])
assert is_found_in_list(FLASK_ERROR_UNEXPECTED, logger_messages.error)
assert is_found_in_list(type(test_error).__name__, logger_messages.error)
def test_process_success(logger_messages, config):
pending_id = "000000000000000000000000"
mongo_client = Mock()
mongo_db = Mock()
mongo_collection = Mock()
with ExitStack() as stack:
mongo_client_context = Mock()
mongo_client_context.__enter__ = Mock(return_value=mongo_client)
mongo_client_context.__exit__ = Mock()
create_mongo_client = stack.enter_context(
patch("crawler.jobs.cherrypicker_test_data.create_mongo_client",
return_value=mongo_client_context))
get_mongo_db = stack.enter_context(
patch("crawler.jobs.cherrypicker_test_data.get_mongo_db",
return_value=mongo_db))
get_mongo_collection = stack.enter_context(
patch("crawler.jobs.cherrypicker_test_data.get_mongo_collection",
return_value=mongo_collection))
process_run = stack.enter_context(
patch("crawler.jobs.cherrypicker_test_data.process_run",
return_value=created_barcode_metadata))
barcode_meta = process(pending_id, config)
assert is_found_in_list("Begin generating", logger_messages.info)
create_mongo_client.assert_called_once_with(config)
get_mongo_db.assert_called_once_with(config, mongo_client)
get_mongo_collection.assert_called_once_with(
mongo_db, COLLECTION_CHERRYPICK_TEST_DATA)
process_run.assert_called_once_with(config, mongo_collection, pending_id)
assert barcode_meta == created_barcode_metadata
def test_generate_endpoint_success(client, logger_messages, process_mock):
process_mock.return_value = BARCODE_METADATA
test_run_id = "0123456789abcdef01234567"
response = client.post(ENDPOINT, json={"run_id": test_run_id})
assert response.status_code == HTTPStatus.OK
assert response.json["run_id"] == test_run_id
assert response.json["plates"] == BARCODE_METADATA
assert response.json["status"] == FIELD_STATUS_COMPLETED
assert "timestamp" in response.json
assert "errors" not in response.json
assert is_found_in_list("Generating test data", logger_messages.info)
def test_is_found_in_list_gives_correct_result(needle, haystack, expected):
assert is_found_in_list(needle, haystack) is expected
