def test_permit_amendment_model_find_by_permit_amendment_id(db_session):
permit = PermitFactory(permit_amendments=1)
permit_amendment = PermitAmendment.find_by_permit_amendment_id(
permit.permit_amendments[0].permit_amendment_id)
assert permit_amendment.permit_amendment_id == permit.permit_amendments[
0].permit_amendment_id
def test_permit_amendment_model_find_by_permit_id(db_session):
batch_size = 3
permit_id = PermitFactory(permit_amendments=batch_size).permit_id
permit_amendments = PermitAmendment.find_by_permit_id(permit_id)
assert len(permit_amendments) == batch_size
assert all(pa.permit_id == permit_id for pa in permit_amendments)
def test_post_permit_amendment_with_date_params(test_client, db_session,
auth_headers):
permit_guid = PermitFactory().permit_guid
party_guid = PartyFactory(company=True).party_guid
data = {
'permittee_party_guid':
party_guid,
'received_date':
datetime.today().strftime('%Y-%m-%d'),
'issue_date':
datetime.today().strftime('%Y-%m-%d'),
'authorization_end_date':
(datetime.today() + timedelta(days=1)).strftime('%Y-%m-%d')
}
post_resp = test_client.post(f'/permits/{permit_guid}/amendments',
json=data,
headers=auth_headers['full_auth_header'])
post_data = json.loads(post_resp.data.decode())
permittees = MinePartyAppointment.find_by_permit_guid(permit_guid)
assert post_resp.status_code == 200, post_resp.response
assert post_data['permit_guid'] == str(permit_guid), str(post_data)
assert post_data['received_date'] == data['received_date']
assert post_data['issue_date'] == data['issue_date']
assert post_data['authorization_end_date'] == data[
'authorization_end_date']
assert permittees[0].party_guid == party_guid
#permit_amdendment is actually in db
assert PermitAmendment.find_by_permit_amendment_guid(
post_data['permit_amendment_guid'])
def test_update_new_item_in_list(db_session):
mine = MineFactory(mine_permit=5)
permit = PermitFactory()
partial_mine_permit_dict = marshal(
{'mine_permit': mine.mine_permit},
api.model('test_list',
{'mine_permit': fields.List(fields.Nested(PERMIT_MODEL))}))
new_permit_dict = marshal(permit, PERMIT_MODEL)
for pa in permit.permit_amendments:
db_session.delete(pa)
db_session.delete(permit)
del new_permit_dict['mine_guid']
del new_permit_dict['permit_guid']
#FOR TESTING ONLY, lets Permitid stay because it's correct and
#postgres sequence doesn't get increased by factory object creation
partial_mine_permit_dict['mine_permit'].append(new_permit_dict)
mine.deep_update_from_dict(partial_mine_permit_dict,
_edit_key=PERMIT_EDIT_GROUP)
mine = Mine.query.filter_by(mine_guid=mine.mine_guid).first()
assert len(mine.mine_permit) == 6
assert all(len(p.permit_amendments) > 0 for p in mine.mine_permit)
def test_put_permit_amendment(test_client, db_session, auth_headers):
permit = PermitFactory(permit_amendments=1)
amendment = permit.permit_amendments[0]
data = {
'permit_amendment_type_code': 'AMD',
'permit_amendment_status_code': 'RMT'
}
put_resp = test_client.put(
f'/permits/amendments/{amendment.permit_amendment_guid}',
json=data,
headers=auth_headers['full_auth_header'])
put_data = json.loads(put_resp.data.decode())
assert put_resp.status_code == 200, put_resp.response
assert put_data['permit_guid'] == str(permit.permit_guid), str(put_data)
assert put_data['permit_amendment_type_code'] == data[
'permit_amendment_type_code']
assert put_data['permit_amendment_status_code'] == data[
'permit_amendment_status_code']
assert put_data['received_date'] == amendment.received_date.strftime(
'%Y-%m-%d')
assert put_data['issue_date'] == amendment.issue_date.strftime('%Y-%m-%d')
assert put_data[
'authorization_end_date'] == amendment.authorization_end_date.strftime(
'%Y-%m-%d')
def test_post_permit_amendment_with_date_params(test_client, db_session, auth_headers):
permit = PermitFactory()
permit_guid = permit.permit_guid
#TODO Figure out how to make permit factory make it's own initial permittee
permittee = MinePartyAppointmentFactory(
permit_guid=permit_guid, mine_party_appt_type_code='PMT', mine=permit.mine)
party_guid = PartyFactory(company=True).party_guid
data = {
'permittee_party_guid': party_guid,
'received_date': datetime.today().date().isoformat(),
'issue_date': datetime.today().date().isoformat(),
'authorization_end_date': (datetime.today() + timedelta(days=1)).date().isoformat(),
}
post_resp = test_client.post(
f'/mines/{permit.mine_guid}/permits/{permit_guid}/amendments',
json=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['permit_guid'] == str(permit_guid), str(post_data)
assert parser.parse(post_data['received_date']) == parser.parse(data['received_date'])
assert parser.parse(post_data['issue_date']) == parser.parse(data['issue_date'])
assert parser.parse(post_data['authorization_end_date']) == parser.parse(
data['authorization_end_date'])
assert permit.permittee_appointments[0].party_guid == party_guid
#permit_amdendment is actually in db
assert PermitAmendment.find_by_permit_amendment_guid(post_data['permit_amendment_guid'])
def test_put_a_reclamation_invoice(self, test_client, db_session,
auth_headers):
"""Should return the edited reclamation invoice with a 200 response code"""
mine = MineFactory(minimal=True)
permit = PermitFactory(mine=mine)
reclamation_invoice = permit.reclamation_invoices[0]
old_amount = reclamation_invoice.amount
old_vendor = reclamation_invoice.vendor
data = {
"project_id": "DUCK-467985",
"amount": 999999.99,
"vendor": "Rubber Ducky Restoration Services",
"documents": []
}
post_resp = test_client.put(
f'/securities/reclamation-invoices/{reclamation_invoice.reclamation_invoice_guid}',
json=data,
headers=auth_headers['full_auth_header'])
assert post_resp.status_code == 200, post_resp.response
post_data = json.loads(post_resp.data.decode())
assert post_data['amount'] != str(old_amount)
assert post_data['vendor'] != old_vendor
def test_put_permit_bad_permit_guid(test_client, db_session, auth_headers):
PermitFactory(permit_status_code='O')
data = {'permit_status_code': 'C'}
put_resp = test_client.put(f'/permits/{uuid.uuid4()}',
headers=auth_headers['full_auth_header'],
json=data)
assert put_resp.status_code == 404
def test_get_permit_not_found(test_client, db_session, auth_headers):
permit = PermitFactory()
get_resp = test_client.get(
f'/mines/{permit.mine_guid}/permits/{uuid.uuid4()}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert 'not found' in get_data['message']
assert get_resp.status_code == 404
def test_delete_permit_fail(test_client, db_session, auth_headers):
permit = PermitFactory(bonds=1)
permit_guid = permit.permit_guid
delete_resp = test_client.delete(
f'/mines/{permit.mine_guid}/permits/{permit_guid}',
headers=auth_headers['full_auth_header'])
assert delete_resp.status_code == 400
def test_get_with_permit_no(test_client, db_session, auth_headers):
permit_no = PermitFactory().permit_no
get_resp = test_client.get(f'/permits?permit_no={permit_no}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert get_data.get('permit_no') == permit_no
def test_get_permit(test_client, db_session, auth_headers):
permit_guid = PermitFactory().permit_guid
get_resp = test_client.get(f'/permits/{permit_guid}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_data['permit_guid'] == str(permit_guid)
assert get_resp.status_code == 200
def test_get_verify_permit_mine(self, test_client, db_session, auth_headers):
mine = MineFactory(operating=True)
permit = PermitFactory(permit_no="CX-1", mine=mine)
get_resp = test_client.get(
f'/verify/permit/mine?a_PermitNumber={permit.permit_no}&a_TypeofDeemedAuth=INDUCED', headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_data['a_Result'] == "Success"
assert get_resp.status_code == 200
def test_put_permit(test_client, db_session, auth_headers):
permit_guid = PermitFactory(permit_status_code='O').permit_guid
data = {'permit_status_code': 'C'}
put_resp = test_client.put(f'/permits/{permit_guid}',
headers=auth_headers['full_auth_header'],
json=data)
put_data = json.loads(put_resp.data.decode())
assert put_resp.status_code == 200
assert put_data.get('permit_status_code') == 'C'
def test_post_permit_with_duplicate_permit_no(test_client, db_session,
auth_headers):
mine_guid = MineFactory().mine_guid
permit_no = PermitFactory().permit_no
party_guid = PartyFactory(company=True).party_guid
data = {'permittee_party_guid': str(party_guid), 'permit_no': permit_no}
post_resp = test_client.post(f'/mines/{mine_guid}/permits',
headers=auth_headers['full_auth_header'],
json=data)
assert post_resp.status_code == 400
def test_get_permit_amendment_by_permit(test_client, db_session, auth_headers):
batch_size = 3
permit_guid = PermitFactory(permit_amendments=batch_size).permit_guid
get_resp = test_client.get(f'/permits/{permit_guid}/amendments',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert len(get_data) == batch_size
assert all(pa['permit_guid'] == str(permit_guid)
for pa in get_data), str(get_data)
def test_get_bond_by_id(self, test_client, db_session, auth_headers):
"""Should return a specific bond"""
mine = MineFactory(minimal=True)
permit = PermitFactory(mine=mine)
bond = permit.bonds[0]
get_resp = test_client.get(f'/securities/bonds/{bond.bond_guid}',
headers=auth_headers['full_auth_header'])
assert get_resp.status_code == 200, get_resp.response
get_data = json.loads(get_resp.data.decode())
assert get_data['bond_guid'] == str(bond.bond_guid)
def test_post_permittee_party_guid_not_found(test_client, db_session, auth_headers):
permit_guid = PermitFactory().permit_guid
data = {
'party_guid': str(uuid.uuid4()),
'related_guid': str(permit_guid),
'effective_date': datetime.today().strftime("%Y-%m-%d")
}
post_resp = test_client.post(
'/parties/mines', data=data, headers=auth_headers['full_auth_header'])
assert post_resp.status_code == 400, str(post_resp.response)
post_data = json.loads(post_resp.data.decode())
assert post_data['message']
def test_post_a_reclamation_invoice(self, test_client, db_session,
auth_headers):
"""Should return the created reclamation invoice with a 201 response code"""
mine = MineFactory(minimal=True)
permit = PermitFactory(mine=mine)
GOOD_RECLAMATION_INVOICE_POST_DATA['permit_guid'] = permit.permit_guid
post_resp = test_client.post('/securities/reclamation-invoices',
json=GOOD_RECLAMATION_INVOICE_POST_DATA,
headers=auth_headers['full_auth_header'])
assert post_resp.status_code == 201, post_resp.response
post_data = json.loads(post_resp.data.decode())
assert post_data['permit_guid'] == str(permit.permit_guid)
def test_post_a_reclamation_invoice_bad_data(self, test_client, db_session,
auth_headers):
"""Should return an error and a 400 response code"""
mine = MineFactory(minimal=True)
permit = PermitFactory(mine=mine)
BAD_RECLAMATION_INVOICE_POST_DATA['permit_guid'] = permit.permit_guid
post_resp = test_client.post('/securities/reclamation-invoices',
json=BAD_RECLAMATION_INVOICE_POST_DATA,
headers=auth_headers['full_auth_header'])
assert post_resp.status_code == 400, post_resp.response
post_data = json.loads(post_resp.data.decode())
assert post_data['message'] is not None
def test_get_reclamation_invoice_by_id(self, test_client, db_session,
auth_headers):
"""Should return a specific reclamation invoice"""
mine = MineFactory(minimal=True)
permit = PermitFactory(mine=mine)
reclamation_invoice = permit.reclamation_invoices[0]
get_resp = test_client.get(
f'/securities/reclamation-invoices/{reclamation_invoice.reclamation_invoice_guid}',
headers=auth_headers['full_auth_header'])
assert get_resp.status_code == 200, get_resp.response
get_data = json.loads(get_resp.data.decode())
assert get_data['reclamation_invoice_guid'] == str(
reclamation_invoice.reclamation_invoice_guid)
def test_post_permit_amendment_with_type_params(test_client, db_session, auth_headers):
permit_guid = PermitFactory().permit_guid
data = {'permit_amendment_type_code': 'OGP'}
post_resp = test_client.post(
f'/permits/{permit_guid}/amendments', json=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['permit_guid'] == str(permit_guid), str(post_data)
assert post_data['permit_amendment_type_code'] == "OGP"
assert post_data['permit_amendment_status_code'] == "ACT"
#permit_amdendment is actually in db
assert PermitAmendment.find_by_permit_amendment_guid(post_data['permit_amendment_guid'])
def test_post_with_permit_guid(test_client, db_session, auth_headers):
mine_guid = MineFactory().mine_guid
permit_guid = PermitFactory().permit_guid
data = {
'permit_no': 'mx-test-999',
'permit_status_code': 'O',
'received_date': '1999-12-12',
'issue_date': '1999-12-21',
'authorization_end_date': '2012-12-02'
}
post_resp = test_client.post(f'/mines/{mine_guid}/permits/{permit_guid}',
headers=auth_headers['full_auth_header'],
data=data)
assert post_resp.status_code == 405
def test_post_a_bond_bad_data(self, test_client, db_session, auth_headers):
"""Should return an error and a 400 response code"""
mine = MineFactory(minimal=True)
party1 = PartyFactory(person=True)
permit = PermitFactory(mine=mine)
BOND_POST_BAD_DATA['bond']['payer_party_guid'] = party1.party_guid
BOND_POST_BAD_DATA['permit_guid'] = permit.permit_guid
post_resp = test_client.post('/securities/bonds',
json=BOND_POST_BAD_DATA,
headers=auth_headers['full_auth_header'])
assert post_resp.status_code == 400, post_resp.response
post_data = json.loads(post_resp.data.decode())
assert post_data['message'] is not None
def test_post_permit_amendment_no_params(test_client, db_session,
auth_headers):
permit_guid = PermitFactory().permit_guid
post_resp = test_client.post(f'/permits/{permit_guid}/amendments',
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['permit_guid'] == str(permit_guid), str(post_data)
assert post_data['received_date'] is None
assert post_data['issue_date'] is None
assert post_data['authorization_end_date'] is None
#permit_amdendment is actually in db
assert PermitAmendment.find_by_permit_amendment_guid(
post_data['permit_amendment_guid'])
def test_post_permittee(test_client, db_session, auth_headers):
permit = PermitFactory()
party_guid = PartyFactory(person=True).party_guid
data = {
'mine_guid': str(permit.mine.mine_guid),
'party_guid': str(party_guid),
'mine_party_appt_type_code': 'PMT',
'related_guid': str(permit.permit_guid),
'effective_date': datetime.today().strftime("%Y-%m-%d")
}
post_resp = test_client.post(
'/parties/mines', data=data, headers=auth_headers['full_auth_header'])
post_data = json.loads(post_resp.data.decode())
assert post_resp.status_code == 200, str(post_resp.response)
assert post_data['party_guid'] == str(party_guid)
def test_post_a_bond(self, test_client, db_session, auth_headers):
"""Should return the created bond with a 201 response code"""
mine = MineFactory(minimal=True)
party1 = PartyFactory(person=True)
permit = PermitFactory(mine=mine)
BOND_POST_DATA['bond']['payer_party_guid'] = party1.party_guid
BOND_POST_DATA['permit_guid'] = permit.permit_guid
post_resp = test_client.post('/securities/bonds',
json=BOND_POST_DATA,
headers=auth_headers['full_auth_header'])
assert post_resp.status_code == 201, post_resp.response
post_data = json.loads(post_resp.data.decode())
assert post_data['permit_guid'] == str(permit.permit_guid)
assert post_data['payer_party_guid'] == str(party1.party_guid)
def test_get_verify_permit_mine(self, test_client, db_session, auth_headers):
mine = MineFactory(operating=True)
#by default, authorization_end_date in the PermitAmendmentFactory is >30days
permit = PermitFactory(permit_no="CX-1", mine=mine, permit_amendments=1)
now_app = NOWApplicationIdentityFactory(mine=mine)
permit.permit_amendments[0].now_identity = now_app
now_sub = NOWSubmissionFactory()
get_resp = test_client.get(
f'/verify/permit/now?a_PermitNumber={permit.permit_no}',
headers=auth_headers['full_auth_header'])
get_data = json.loads(get_resp.data.decode())
assert get_resp.status_code == 200
assert get_data['a_Result'] == "Success"
assert str(now_app.now_number) in get_data['a_NoWInfo']
def test_get_all_bonds_on_mine(self, test_client, db_session,
auth_headers):
"""Should return the correct records with a 200 response code"""
batch_size = 5
mine = MineFactory(minimal=True)
permits = PermitFactory.create_batch(size=batch_size, mine=mine)
bonds = [bond for permit in permits for bond in permit.bonds]
get_resp = test_client.get(
f'/securities/bonds?mine_guid={mine.mine_guid}',
headers=auth_headers['full_auth_header'])
assert get_resp.status_code == 200, get_resp.response
get_data = json.loads(get_resp.data.decode())
assert len(get_data['records']) == len(bonds)
assert all(
str(bond.bond_guid) in map(lambda x: x['bond_guid'],
get_data['records']) for bond in bonds)
def test_put_a_bond_missing_data(self, test_client, db_session,
auth_headers):
"""Should return 400 response code with an error"""
mine = MineFactory(minimal=True)
permit = PermitFactory(mine=mine)
bond = permit.bonds[0]
data = {
"amount": 5000010.00,
"bond_type_code": "CAS",
"bond_status_code": "ACT",
"reference_number": "#test"
}
post_resp = test_client.put(f'/securities/bonds/{bond.bond_guid}',
json=data,
headers=auth_headers['full_auth_header'])
assert post_resp.status_code == 400, post_resp.response
post_data = json.loads(post_resp.data.decode())
assert post_data['message'] is not None
