def test_get_filings_by_status_before_go_live_date(session, test_type, days, expected, status):
"""Assert that a filing can be retrieved by status."""
import copy
uow = versioning_manager.unit_of_work(session)
transaction = uow.create_transaction(session)
business = factory_business('CP1234567')
payment_token = '1000'
ar = copy.deepcopy(ANNUAL_REPORT)
go_live_date = datetime.date.fromisoformat(current_app.config.get('GO_LIVE_DATE'))
filing_date = go_live_date + datetime.timedelta(days=days)
filing = Filing()
filing.filing_date = filing_date
filing.business_id = business.id
filing.filing_json = ar
filing.payment_token = payment_token
filing.transaction_id = transaction.id
filing.payment_completion_date = datetime.datetime.utcnow()
filing.save()
rv = Filing.get_filings_by_status(business.id, [Filing.Status.COMPLETED.value], go_live_date)
assert eval(expected) # pylint: disable=eval-used; useful for parameterized tests
if rv:
assert rv[0].status == status
def factory_completed_filing(business, data_dict, filing_date=FROZEN_DATETIME, payment_token=None, colin_id=None):
"""Create a completed filing."""
if not payment_token:
payment_token = str(base64.urlsafe_b64encode(uuid.uuid4().bytes)).replace('=', '')
with freeze_time(filing_date):
filing = Filing()
filing.business_id = business.id
filing.filing_date = filing_date
filing.filing_json = data_dict
filing.save()
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
filing.transaction_id = transaction.id
filing.payment_token = payment_token
filing.effective_date = filing_date
filing.payment_completion_date = filing_date
if colin_id:
colin_event = ColinEventId()
colin_event.colin_event_id = colin_id
colin_event.filing_id = filing.id
colin_event.save()
filing.save()
return filing
def post(identifier, filing_id=None):
"""Create a new filing for the business."""
json_input = request.get_json()
if not json_input:
return jsonify({'message':
f'No filing json data in body of post for {identifier}.'}), \
HTTPStatus.BAD_REQUEST
business = Business.find_by_identifier(identifier)
if not business:
return jsonify({'message':
f'{identifier} not found'}), HTTPStatus.NOT_FOUND
if filing_id: # checked since we're overlaying routes
return jsonify({'message':
f'Illegal to attempt to create a new filing over an existing filing for {identifier}.'}), \
HTTPStatus.FORBIDDEN
try:
filing = Filing()
filing.business_id = business.id
filing.filing_date = datetime.datetime.utcnow()
filing.filing_json = json_input
filing.save()
except BusinessException as err:
return jsonify({'message': err.error}), err.status_code
return jsonify(filing.filing_json), HTTPStatus.CREATED
def factory_filing(business, data_dict, filing_date=FROZEN_DATETIME):
"""Create a filing."""
filing = Filing()
filing.business_id = business.id
filing.filing_date = filing_date
filing.filing_json = data_dict
filing.save()
return filing
def test_changing_uninvoiced_saved_filing_is_unlocked(session):
"""Assert that saving an un-invoiced filing is still unlocked."""
# should succeed
filing = Filing()
filing.filing_date = EPOCH_DATETIME
filing.filing_json = ANNUAL_REPORT
assert not filing.locked
filing.save()
assert not filing.locked
def factory_incorporation_filing(business, data_dict, filing_date=FROZEN_DATETIME, effective_date=FROZEN_DATETIME):
"""Create a filing."""
filing = Filing()
filing.business_id = business.id
filing.filing_date = filing_date
filing.effective_date = effective_date
filing.filing_json = data_dict
filing.save()
return filing
def factory_pending_filing(business, data_dict, filing_date=FROZEN_DATETIME):
"""Create a pending filing."""
filing = Filing()
filing.business_id = business.id
filing.filing_date = filing_date
filing.filing_json = data_dict
filing.payment_token = 2
filing.save()
return filing
def test_changing_unsaved_filing_is_unlocked(session):
"""Assert an unlocked, but saved filing, can be changed."""
# should succeed
filing = Filing()
filing.payment_token = 'payment_token'
filing.filing_date = EPOCH_DATETIME
filing.filing_json = ANNUAL_REPORT
assert not filing.locked
filing.save()
assert filing.locked
def factory_error_filing(business, data_dict, filing_date=FROZEN_DATETIME):
"""Create an error filing."""
filing = Filing()
filing.business_id = business.id
filing.filing_date = filing_date
filing.filing_json = data_dict
filing.save()
filing.payment_token = 5
filing.payment_completion_date = (datetime.now()).replace(tzinfo=timezone.utc)
return filing
def factory_error_filing(business, data_dict):
"""Create an error filing."""
filing = Filing()
filing.business_id = business.id
filing.filing_date = FROZEN_DATETIME
filing.filing_json = data_dict
filing.save()
filing.payment_token = 5
filing.payment_completion_date = datetime.now()
return filing
def factory_epoch_filing(business, filing_date=FROZEN_DATETIME):
"""Create an error filing."""
filing = Filing()
filing.business_id = business.id
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
filing.transaction_id = transaction.id
filing.filing_date = filing_date
filing.filing_json = {'filing': {'header': {'name': 'lear_epoch'}}}
filing.save()
return filing
def load_historic_filings(corp_num: str, business: Business, legal_type: str):
"""Load historic filings for a business."""
try:
# get historic filings
r = requests.get(
f'{COLIN_API}/api/v1/businesses/{legal_type}/{corp_num}/filings/historic',
timeout=TIMEOUT)
if r.status_code != HTTPStatus.OK or not r.json():
print(
f'skipping history for {corp_num} historic filings not found')
else:
for historic_filing in r.json():
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
filing = Filing()
filing_date = historic_filing['filing']['header']['date']
filing.filing_date = datetime.datetime.strptime(
filing_date, '%Y-%m-%d')
filing.business_id = business.id
filing.filing_json = historic_filing
for colin_id in filing.filing_json['filing']['header'][
'colinIds']:
colin_event_id = ColinEventId()
colin_event_id.colin_event_id = colin_id
filing.colin_event_ids.append(colin_event_id)
filing.transaction_id = transaction.id
filing._filing_type = historic_filing['filing']['header'][
'name']
filing.paper_only = True
filing.effective_date = datetime.datetime.strptime(
historic_filing['filing']['header']['effectiveDate'],
'%Y-%m-%d')
updater_user = User.find_by_username(UPDATER_USERNAME)
filing.submitter_id = updater_user.id
filing.source = Filing.Source.COLIN.value
db.session.add(filing)
# only commit after all historic filings were added successfully
db.session.commit()
LOADED_FILING_HISTORY.append(corp_num)
except requests.exceptions.Timeout:
print('rolling back partial changes...')
db.session.rollback()
FAILED_FILING_HISTORY.append(corp_num)
print('colin_api request timed out getting historic filings.')
except Exception as err:
print('rolling back partial changes...')
db.session.rollback()
FAILED_FILING_HISTORY.append(corp_num)
raise err
def test_add_json_after_payment(session):
"""Assert that the json can be added in the same session that a paymentToken was applied."""
filing = Filing()
filing.filing_date = EPOCH_DATETIME
# sanity check starting value
assert not filing.status
filing.payment_token = 'payment token'
filing.filing_json = ANNUAL_REPORT
assert filing.json
assert filing.status == Filing.Status.PENDING.value
def test_minimal_filing_json(session):
"""Assert that a minimal filing can be created."""
b = factory_business('CP1234567')
data = {'filing': 'not a real filing, fail validation'}
filing = Filing()
filing.business_id = b.id
filing.filing_date = datetime.datetime.utcnow()
filing.filing_data = json.dumps(data)
filing.save()
assert filing.id is not None
def _save_filing(client_request: LocalProxy, business_identifier: str,
user: User,
filing_id: int) -> Tuple[Business, Filing, dict, int]:
"""Save the filing to the ledger.
If not successful, a dict of errors is returned.
Returns: {
Business: business model object found for the identifier provided
Filing: filing model object for the submitted filing
dict: a dict of errors
int: the HTTPStatus error code
}
"""
json_input = client_request.get_json()
if not json_input:
return None, None, {'message':
f'No filing json data in body of post for {business_identifier}.'}, \
HTTPStatus.BAD_REQUEST
business = Business.find_by_identifier(business_identifier)
if not business:
return None, None, {
'message': f'{business_identifier} not found'
}, HTTPStatus.NOT_FOUND
if client_request.method == 'PUT':
rv = db.session.query(Business, Filing). \
filter(Business.id == Filing.business_id). \
filter(Business.identifier == business_identifier). \
filter(Filing.id == filing_id). \
one_or_none()
if not rv:
return None, None, {
'message': f'{business_identifier} no filings found'
}, HTTPStatus.NOT_FOUND
filing = rv[1]
else:
filing = Filing()
filing.business_id = business.id
try:
filing.submitter_id = user.id
filing.filing_date = datetime.datetime.utcnow()
filing.filing_json = json_input
filing.save()
except BusinessException as err:
return None, None, {'error': err.error}, err.status_code
return business, filing, None, None
def test_add_json_and_payment_after_saved_filing(session):
"""Assert that the json can be added in the same session that a paymentToken was applied."""
filing = Filing()
filing.filing_date = EPOCH_DATETIME
filing.save()
# sanity check starting value
assert filing.status == Filing.Status.DRAFT.value
filing.payment_token = 'payment token'
filing.filing_json = AR_FILING
assert filing.json
assert filing.status == Filing.Status.PENDING.value
def factory_completed_filing(business, data_dict, filing_date=FROZEN_DATETIME):
"""Create a completed filing."""
filing = Filing()
filing.business_id = business.id
filing.filing_date = filing_date
filing.filing_json = data_dict
filing.save()
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
filing.transaction_id = transaction.id
filing.payment_token = 1
filing.payment_completion_date = datetime.now()
return filing
def create_filing(token, json_filing=None, business_id=None):
"""Return a test filing."""
from legal_api.models import Filing
filing = Filing()
filing.payment_token = str(token)
filing.filing_date = EPOCH_DATETIME
if json_filing:
filing.filing_json = json_filing
if business_id:
filing.business_id = business_id
filing.save()
return filing
def test_get_current_registrar(session):
"""Assert that the current registrar is returned."""
b = factory_business('CP1234567')
filing = Filing()
filing.business_id = b.id
filing.filing_date = datetime.datetime.utcnow()
filing.filing_data = ANNUAL_REPORT
filing.save()
registrar_info = RegistrarInfo.get_registrar_info(filing.effective_date)
assert registrar_info['startDate']
assert registrar_info['endDate'] is None
assert registrar_info['signature']
assert registrar_info['name']
assert registrar_info['title']
def test_filing_orm_delete_allowed_for_in_progress_filing(session):
"""Assert that attempting to delete a filing will raise a BusinessException."""
from legal_api.exceptions import BusinessException
b = factory_business('CP1234567')
filing = Filing()
filing.business_id = b.id
filing.filing_date = datetime.datetime.utcnow()
filing.filing_json = ANNUAL_REPORT
filing.save()
with not_raises(BusinessException):
session.delete(filing)
session.commit()
async def test_publish_email_message(app, session, stan_server, event_loop,
client_id, entity_stan, future):
"""Assert that payment tokens can be retrieved and decoded from the Queue."""
# Call back for the subscription
from entity_queue_common.service import ServiceWorker
from entity_pay.worker import APP_CONFIG, publish_email_message, qsm
from legal_api.models import Filing
# file handler callback
msgs = []
async def cb_file_handler(msg):
nonlocal msgs
nonlocal future
msgs.append(msg)
if len(msgs) == 1:
future.set_result(True)
file_handler_subject = APP_CONFIG.EMAIL_PUBLISH_OPTIONS['subject']
await subscribe_to_queue(entity_stan, file_handler_subject,
f'entity_queue.{file_handler_subject}',
f'entity_durable_name.{file_handler_subject}',
cb_file_handler)
s = ServiceWorker()
s.sc = entity_stan
qsm.service = s
# Test
filing = Filing()
filing.id = 101
filing.filing_type = 'incorporationApplication'
filing_date = datetime.datetime.utcnow()
filing.filing_date = filing_date
filing.effective_date = filing_date
await publish_email_message(filing)
try:
await asyncio.wait_for(future, 2, loop=event_loop)
except Exception as err:
print(err)
# check it out
assert len(msgs) == 1
assert get_data_from_msg(msgs[0], 'id') == filing.id
assert get_data_from_msg(msgs[0], 'type') == filing.filing_type
assert get_data_from_msg(msgs[0], 'option') == 'filed'
def create_filing(token=None, filing_json=None, business_id=None, filing_date=EPOCH_DATETIME, bootstrap_id: str = None):
"""Return a test filing."""
filing = Filing()
if token:
filing.payment_token = str(token)
filing.filing_date = filing_date
if filing_json:
filing.filing_json = filing_json
if business_id:
filing.business_id = business_id
if bootstrap_id:
filing.temp_reg = bootstrap_id
filing.save()
return filing
def test_get_registrar_for_a_filing(session):
"""Assert that the registrar effective on that date is returned."""
b = factory_business('CP1234567')
filing = Filing()
filing.business_id = b.id
filing.filing_date = datetime.datetime(2012, 6, 6)
filing.effective_date = datetime.datetime(2012, 6, 6)
filing.filing_data = ANNUAL_REPORT
filing.save()
registrar_info = RegistrarInfo.get_registrar_info(filing.effective_date)
assert registrar_info['startDate']
assert registrar_info['endDate']
assert registrar_info['signature']
assert registrar_info['name'] == 'ANGELO COCCO'
assert registrar_info['title'] == 'A/Registrar of Companies'
def create_filing(filing_type, colin_filing, colin_event_id, corp_num):
"""Create legal api filing using colin filing as base"""
effective_date = colin_filing['filing']['business']['foundingDate']
colin_filing['filing']['business']['identifier'] = corp_num
filing = Filing(effective_date=effective_date, filing_json=colin_filing)
filing._filing_type = filing_type
filing.filing_date = effective_date
colin_event = ColinEventId()
colin_event.colin_event_id = colin_event_id
filing.colin_event_ids.append(colin_event)
# Override the state setting mechanism
filing.skip_status_listener = True
filing._status = 'PENDING'
filing.source = Filing.Source.COLIN.value
return filing
def factory_filing(business,
data_dict,
filing_date=FROZEN_DATETIME,
filing_type=None):
"""Create a filing."""
filing = Filing()
filing.business_id = business.id
filing.filing_date = filing_date
filing.filing_json = data_dict
if filing_type:
filing._filing_type = filing_type
try:
filing.save()
except Exception as err:
print(err)
return filing
def test_add_payment_completion_date_after_payment(session):
"""Assert that the json can be added in the same session that a paymentToken was applied."""
filing = Filing()
filing.filing_date = EPOCH_DATETIME
filing.save()
filing.payment_token = 'payment token'
filing.filing_json = ANNUAL_REPORT
# sanity check starting position
assert filing.json
assert filing.status == Filing.Status.PENDING.value
filing.payment_completion_date = EPOCH_DATETIME
print(filing.status)
assert filing.status == Filing.Status.COMPLETED.value
def create_filing(token=None, json_filing=None, business_id=None, filing_date=EPOCH_DATETIME, bootstrap_id: str = None):
"""Return a test filing."""
from legal_api.models import Filing
filing = Filing()
if token:
filing.payment_token = str(token)
filing.filing_date = filing_date
if json_filing:
filing.filing_json = json_filing
if business_id:
filing.business_id = business_id
if bootstrap_id:
filing.temp_reg = bootstrap_id
filing.save()
return filing
def test_filing_orm_delete_blocked_if_invoiced(session):
"""Assert that attempting to delete a filing will raise a BusinessException."""
from legal_api.exceptions import BusinessException
b = factory_business('CP1234567')
filing = Filing()
filing.business_id = b.id
filing.filing_date = datetime.datetime.utcnow()
filing.filing_json = ANNUAL_REPORT
filing.payment_token = 'a token'
filing.save()
with pytest.raises(BusinessException) as excinfo:
session.delete(filing)
session.commit()
assert excinfo.value.status_code == HTTPStatus.FORBIDDEN
assert excinfo.value.error == 'Deletion not allowed.'
def test_filing_block_orm_delete(session):
"""Assert that attempting to delete a filing will raise a BusinessException."""
from legal_api.exceptions import BusinessException
b = factory_business('CP1234567')
data = {'filing': 'not a real filing, fail validation'}
filing = Filing()
filing.business_id = b.id
filing.filing_date = datetime.datetime.utcnow()
filing.filing_data = json.dumps(data)
filing.save()
with pytest.raises(BusinessException) as excinfo:
session.delete(filing)
session.commit()
assert excinfo.value.status_code == HTTPStatus.FORBIDDEN
assert excinfo.value.error == 'Deletion not allowed.'
# get historic filings
r = requests.get(COLIN_API + '/api/v1/businesses/' +
row['CORP_NUM'] + '/filings/historic',
timeout=TIMEOUT)
if r.status_code != HTTPStatus.OK or not r.json():
print(
f'skipping history for {row["CORP_NUM"]} historic filings not found'
)
for historic_filing in r.json():
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
filing = Filing()
filing_date = historic_filing['filing']['header'][
'date']
filing.filing_date = datetime.datetime.strptime(
filing_date, '%Y-%m-%d')
filing.business_id = business.id
filing.filing_json = historic_filing
filing.transaction_id = transaction.id
filing_type = historic_filing['filing']['header'][
'name']
filing.colin_event_id = historic_filing['filing'][
filing_type]['eventId']
filing.paper_only = True
db.session.add(filing)
db.session.commit()
except requests.exceptions.Timeout as timeout:
print(
'colin_api request timed out getting historic filings.'
)
