def test_put_variance(self, test_client, db_session, auth_headers):
"""Should return the updated variance record"""
variance = VarianceFactory()
approved_variance = VarianceFactory(approved=True)
data = {
'compliance_article_id': approved_variance.compliance_article_id,
'received_date': approved_variance.received_date,
'variance_application_status_code': approved_variance.variance_application_status_code,
'inspector_party_guid': approved_variance.inspector_party_guid,
'note': approved_variance.note,
'parties_notified_ind': True,
'issue_date': approved_variance.issue_date,
'expiry_date': approved_variance.expiry_date
}
put_resp = test_client.put(
f'/mines/{variance.mine_guid}/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'],
data=data)
put_data = json.loads(put_resp.data.decode())
assert put_resp.status_code == 200, put_resp.response
assert put_data['compliance_article_id'] == data['compliance_article_id']
assert put_data['received_date'] == data['received_date'].strftime('%Y-%m-%d')
assert put_data['variance_application_status_code'] == data['variance_application_status_code']
assert put_data['inspector_party_guid'] == str(data['inspector_party_guid'])
assert put_data['note'] == data['note']
assert put_data['parties_notified_ind'] == data['parties_notified_ind']
assert put_data['issue_date'] == data['issue_date'].strftime('%Y-%m-%d')
assert put_data['expiry_date'] == data['expiry_date'].strftime('%Y-%m-%d')
def test_get_variances_invalid_mine_guid(test_client, db_session,
auth_headers):
batch_size = 3
VarianceFactory.create_batch(size=batch_size)
get_resp = test_client.get(f'/mines/abc123/variances',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 400
def test_get_variances_invalid_mine_guid(self, test_client, db_session, auth_headers):
"""Should return a 400 when an invalid mine guid is provided"""
batch_size = 3
VarianceFactory.create_batch(size=batch_size)
get_resp = test_client.get(f'/mines/abc123/variances', headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 400
def test_get_variances_non_existent_mine_guid(self, test_client, db_session, auth_headers):
"""Should return a 404 when the provided mine guid does not exist"""
batch_size = 3
fake_guid = uuid.uuid4()
VarianceFactory.create_batch(size=batch_size)
get_resp = test_client.get(f'/mines/{fake_guid}/variances', headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 404
def test_get_variances_non_existent_mine_guid(test_client, db_session,
auth_headers):
batch_size = 3
fake_guid = uuid.uuid4()
VarianceFactory.create_batch(size=batch_size)
get_resp = test_client.get(f'/mines/{fake_guid}/variances',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 404
def test_get_variances_for_a_mine(test_client, db_session, auth_headers):
batch_size = 3
mine = MineFactory(minimal=True)
VarianceFactory.create_batch(size=batch_size, mine=mine)
VarianceFactory.create_batch(size=batch_size)
get_resp = test_client.get(f'/mines/{mine.mine_guid}/variances',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert len(get_data['records']) == batch_size
def test_get_variances_application_filter_by_major_mine(self, test_client, db_session, auth_headers):
"""Should filter variances by major vs regional mine"""
major_mine = MineFactory(major_mine_ind=True)
regional_mine = MineFactory(major_mine_ind=False)
VarianceFactory(mine=major_mine)
VarianceFactory(mine=regional_mine)
get_resp = test_client.get(f'/variances?major=f', headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert all(map(
lambda v: v['mine_name'] == regional_mine.mine_name,
get_data['records']))
def test_put_variance_application_with_expiry_date(test_client, db_session, auth_headers):
variance = VarianceFactory()
approved_variance = VarianceFactory(approved=True)
data = {
'expiry_date': approved_variance.expiry_date
}
put_resp = test_client.put(
f'/mines/{variance.mine_guid}/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'],
data=data)
put_data = json.loads(put_resp.data.decode())
assert put_resp.status_code == 400, put_resp.response
assert 'expiry' in put_data['message'].lower()
def test_post_approved_variance(test_client, db_session, auth_headers):
approved_variance = VarianceFactory(approved=True)
test_variance_data = {
'compliance_article_id': approved_variance.compliance_article_id,
'received_date': approved_variance.received_date,
'variance_application_status_code':
approved_variance.variance_application_status_code,
'inspector_party_guid': approved_variance.inspector_party_guid,
'note': 'Biggest mine yet',
'issue_date': approved_variance.issue_date,
'expiry_date': approved_variance.expiry_date
}
post_resp = test_client.post(
f'/mines/{approved_variance.mine_guid}/variances',
data=test_variance_data,
headers=auth_headers['full_auth_header'])
post_data = json.loads(post_resp.data.decode())
assert post_resp.status_code == 200, post_resp.response
assert post_data['compliance_article_id'] == test_variance_data[
'compliance_article_id']
assert post_data['received_date'] == test_variance_data[
'received_date'].strftime('%Y-%m-%d')
assert post_data['variance_application_status_code'] == test_variance_data[
'variance_application_status_code']
assert post_data['inspector_party_guid'] == str(
test_variance_data['inspector_party_guid'])
assert post_data['note'] == test_variance_data['note']
assert post_data['issue_date'] == test_variance_data[
'issue_date'].strftime('%Y-%m-%d')
assert post_data['expiry_date'] == test_variance_data[
'expiry_date'].strftime('%Y-%m-%d')
def test_variance_model_find_by_mine_guid_and_variance_guid(db_session):
variance = VarianceFactory()
fetched_variance = Variance.find_by_mine_guid_and_variance_guid(
variance.mine_guid, variance.variance_guid)
assert fetched_variance.mine_guid == variance.mine_guid
assert fetched_variance.variance_guid == variance.variance_guid
def test_get_variances_application_filter_by_compliance_code(self, test_client, db_session, auth_headers):
"""Should filter variances by compliance code"""
compliance_codes = [RandomComplianceArticleId(),RandomComplianceArticleId()]
batch_size = 3
VarianceFactory.create_batch(size=batch_size)
VarianceFactory(compliance_article_id=compliance_codes[0])
VarianceFactory(compliance_article_id=compliance_codes[1])
get_resp = test_client.get(
f'/variances?compliance_code={compliance_codes[0]}&compliance_code={compliance_codes[1]}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert all(map(
lambda v: v['compliance_article_id'] in compliance_codes,
get_data['records']))
def test_get_variances_application_filter_by_mine_region(self, test_client, db_session, auth_headers):
"""Should filter variances by mine region"""
region_code = "NW"
mine_with_region_nw = MineFactory(mine_region='NW')
mine_with_region_sw = MineFactory(mine_region="SW")
batch_size = 3
VarianceFactory.create_batch(size=batch_size)
VarianceFactory(mine=mine_with_region_nw)
VarianceFactory(mine=mine_with_region_sw)
get_resp = test_client.get(f'/variances?region={region_code}',headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert all(map(
lambda v: v['mine_name'] == mine_with_region_nw.mine_name,
get_data['records']))
def test_put_variance_application_with_expiry_date(self, test_client, db_session, auth_headers):
"""Should return a 400 and a relevant error message if the variance is in-review with an expiry date"""
variance = VarianceFactory()
approved_variance = VarianceFactory(approved=True)
data = {
'expiry_date': approved_variance.expiry_date
}
put_resp = test_client.put(
f'/mines/{variance.mine_guid}/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'],
data=data)
put_data = json.loads(put_resp.data.decode())
assert put_resp.status_code == 400, put_resp.response
assert 'expiry' in put_data['message'].lower()
def test_validate_applicant_guid_invalid(db_session):
variance = VarianceFactory()
with pytest.raises(AssertionError) as e:
Variance(compliance_article_id=variance.compliance_article_id,
mine_guid=variance.mine_guid,
applicant_guid='abc123')
assert 'Invalid applicant_guid' in str(e.value)
def test_delete_variance(test_client, db_session, auth_headers):
variance = VarianceFactory()
variance_guid = variance.variance_guid
delete_resp = test_client.delete(
f'/mines/{variance.mine_guid}/variances/{variance_guid}',
headers=auth_headers['full_auth_header'])
assert delete_resp.status_code == 204
def test_file_removal_not_on_variance(test_client, db_session, auth_headers):
variance = VarianceFactory()
mine_document_guid = MineDocumentFactory().mine_document_guid
delete_resp = test_client.delete(
f'/mines/{variance.mine_guid}/variances/{variance.variance_guid}/documents/{mine_document_guid}',
headers=auth_headers['full_auth_header'])
assert delete_resp.status_code == 404
def test_get_variances_wrong_mine_guid(test_client, db_session, auth_headers):
variance = VarianceFactory()
mine = MineFactory()
get_resp = test_client.get(
f'/mines/{mine.mine_guid}/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'])
assert get_resp.status_code == 404
def test_get_variances_application_filter_by_issue_date(self, test_client, db_session, auth_headers):
"""Should filter variances by issue date"""
date_minus_7_days = datetime.now() - timedelta(days=7)
date_minus_1_day = datetime.now() - timedelta(days=1)
date_today = datetime.now()
date_plus_1_day = datetime.now() + timedelta(days=1)
date_plus_7_days = datetime.now() + timedelta(days=7)
VarianceFactory(approved=True,issue_date=date_minus_7_days)
VarianceFactory(approved=True,issue_date=date_today)
VarianceFactory(approved=True,issue_date=date_plus_7_days)
date_format = "%Y-%m-%d"
get_resp = test_client.get(
f'/variances?issue_date_before={date_plus_1_day.strftime(date_format)}&issue_date_after={date_minus_1_day.strftime(date_format)}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert get_data['records'][0]['issue_date'] == date_today.strftime(date_format)
def test_put_denied_variance_missing_inspector_party_guid(test_client, db_session, auth_headers):
variance = VarianceFactory()
denied_variance = VarianceFactory(denied=True)
data = {
'compliance_article_id': denied_variance.compliance_article_id,
'received_date': denied_variance.received_date,
'variance_application_status_code': denied_variance.variance_application_status_code,
'note': denied_variance.note
}
put_resp = test_client.put(
f'/mines/{variance.mine_guid}/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'],
data=data)
put_data = json.loads(put_resp.data.decode())
assert put_resp.status_code == 400, put_resp.response
assert 'inspector' in put_data['message'].lower()
def test_get_variances_invalid_mine_guid(test_client, db_session, auth_headers):
variance = VarianceFactory()
get_resp = test_client.get(
f'/mines/abc123/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 400
assert get_data['message'] == INVALID_MINE_GUID
def test_get_variance(test_client, db_session, auth_headers):
variance = VarianceFactory()
get_resp = test_client.get(
f'/mines/{variance.mine_guid}/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert get_data['variance_guid'] == str(variance.variance_guid)
def test_get_variances_wrong_mine_guid(self, test_client, db_session, auth_headers):
"""Should return a 404 when the variance does not exist on the provided mine"""
variance = VarianceFactory()
mine = MineFactory()
get_resp = test_client.get(
f'/mines/{mine.mine_guid}/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'])
assert get_resp.status_code == 404
def test_post_not_applicable_variance_with_issue_date(test_client, db_session,
auth_headers):
approved_variance = VarianceFactory(approved=True)
nap_variance = VarianceFactory(not_applicable=True)
data = {
'compliance_article_id': nap_variance.compliance_article_id,
'received_date': nap_variance.received_date,
'variance_application_status_code':
nap_variance.variance_application_status_code,
'note': nap_variance.note,
'issue_date': approved_variance.issue_date
}
post_resp = test_client.post(f'/mines/{nap_variance.mine_guid}/variances',
headers=auth_headers['full_auth_header'],
data=data)
post_data = json.loads(post_resp.data.decode())
assert post_resp.status_code == 400, post_resp.response
assert 'issue' in post_data['message'].lower()
def test_post_variance_application_with_expiry_date(test_client, db_session,
auth_headers):
variance = VarianceFactory()
party = PartyFactory(person=True)
approved_variance = VarianceFactory(approved=True)
data = {
'compliance_article_id': variance.compliance_article_id,
'note': variance.note,
'received_date': variance.received_date,
'applicant_guid': party.party_guid,
'expiry_date': approved_variance.expiry_date
}
post_resp = test_client.post(f'/mines/{variance.mine_guid}/variances',
headers=auth_headers['full_auth_header'],
data=data)
post_data = json.loads(post_resp.data.decode())
assert post_resp.status_code == 400, post_resp.response
assert 'expiry' in post_data['message'].lower()
def test_get_variances_invalid_mine_guid(self, test_client, db_session, auth_headers):
"""Should return a 400 with relevant error message when an invalid mine guid is provided"""
variance = VarianceFactory()
get_resp = test_client.get(
f'/mines/abc123/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 400
assert get_data['message'] == INVALID_MINE_GUID
def test_file_removal(test_client, db_session, auth_headers):
variance = VarianceFactory()
variance_document = variance.documents[0]
document_count = len(variance.documents)
assert variance_document is not None
delete_resp = test_client.delete(
f'/mines/{variance.mine_guid}/variances/{variance.variance_guid}/documents/{variance_document.mine_document_guid}',
headers=auth_headers['full_auth_header'])
assert delete_resp.status_code == 204
assert len(variance.documents) == document_count - 1
def test_get_variance(self, test_client, db_session, auth_headers):
"""Should return the correct variance and a 200 response code"""
variance = VarianceFactory()
get_resp = test_client.get(
f'/mines/{variance.mine_guid}/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert get_data['variance_guid'] == str(variance.variance_guid)
def test_post_not_applicable_variance_with_expiry_date(self, test_client, db_session, auth_headers):
"""Should return a 400 and a relevant error message if the variance is not-applicable with an expiry date"""
approved_variance = VarianceFactory(approved=True)
nap_variance = VarianceFactory(not_applicable=True)
data = {
'compliance_article_id': nap_variance.compliance_article_id,
'received_date': nap_variance.received_date,
'variance_application_status_code': nap_variance.variance_application_status_code,
'note': nap_variance.note,
'expiry_date': approved_variance.expiry_date
}
post_resp = test_client.post(
f'/mines/{nap_variance.mine_guid}/variances',
headers=auth_headers['full_auth_header'],
data=data)
post_data = json.loads(post_resp.data.decode())
assert post_resp.status_code == 400, post_resp.response
assert 'expiry' in post_data['message'].lower()
def test_put_approved_variance_missing_inspector_party_guid(self, test_client, db_session, auth_headers):
"""Should return a 400 and a relevant error message if the variance is approved without an inspector"""
variance = VarianceFactory()
approved_variance = VarianceFactory(approved=True)
data = {
'compliance_article_id': approved_variance.compliance_article_id,
'received_date': approved_variance.received_date,
'variance_application_status_code': approved_variance.variance_application_status_code,
'note': approved_variance.note,
'issue_date': approved_variance.issue_date,
'expiry_date': approved_variance.expiry_date
}
put_resp = test_client.put(
f'/mines/{variance.mine_guid}/variances/{variance.variance_guid}',
headers=auth_headers['full_auth_header'],
data=data)
put_data = json.loads(put_resp.data.decode())
assert put_resp.status_code == 400, put_resp.response
assert 'inspector' in put_data['message'].lower()
def test_get_variances_pagination(self, test_client, db_session, auth_headers):
"""Should return paginated records"""
batch_size = PER_PAGE_DEFAULT + 1
variances = VarianceFactory.create_batch(size=batch_size)
get_resp = test_client.get('/variances', headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert len(get_data['records']) == PER_PAGE_DEFAULT
assert get_data['current_page'] == PAGE_DEFAULT
assert get_data['total'] == batch_size
