def test_get_most_recent_filing_by_legal_type_db_field(session):
"""Assert that the most recent legal filing can be retrieved.
Create 3 filings, find the 2 one by the type only.
"""
business = factory_business('CP1234567')
uow = versioning_manager.unit_of_work(session)
transaction = uow.create_transaction(session)
# filing 1
effective_date = '2001-07-01T00:00:00+00:00'
completion_date = datetime.datetime.fromisoformat(effective_date)
base_filing = copy.deepcopy(ANNUAL_REPORT)
base_filing['filing']['header']['effectiveDate'] = effective_date
filing1 = Filing()
filing1._filing_date = completion_date
filing1.business_id = business.id
filing1.filing_json = base_filing
filing1.effective_date = datetime.datetime.fromisoformat(effective_date)
filing1.payment_token = 'token'
filing1.transaction_id = transaction.id
filing1.payment_completion_date = completion_date
filing1.save()
# filing 2 <- target
effective_date = '2002-07-01T00:00:00+00:00'
completion_date = datetime.datetime.fromisoformat(effective_date)
base_filing = copy.deepcopy(FILING_HEADER)
base_filing['filing']['header']['effectiveDate'] = effective_date
base_filing['filing']['header']['name'] = 'changeOfDirectors'
base_filing['filing']['header']['availableOnPaperOnly'] = True
filing2 = Filing()
filing2._filing_date = completion_date
filing2.business_id = business.id
filing2.filing_json = base_filing
filing2.effective_date = datetime.datetime.fromisoformat(effective_date)
filing2.payment_token = 'token'
filing2.transaction_id = transaction.id
filing2.payment_completion_date = completion_date
filing2.save()
# filing 3
effective_date = '2003-07-01T00:00:00+00:00'
completion_date = datetime.datetime.fromisoformat(effective_date)
base_filing = copy.deepcopy(ANNUAL_REPORT)
base_filing['filing']['header']['effectiveDate'] = effective_date
filing3 = Filing()
filing3._filing_date = completion_date
filing3.business_id = business.id
filing3.filing_json = base_filing
filing3.effective_date = datetime.datetime.fromisoformat(effective_date)
filing3.payment_token = 'token'
filing3.transaction_id = transaction.id
filing3.payment_completion_date = completion_date
filing3.save()
f = Filing.get_most_recent_legal_filing(business.id, 'changeOfDirectors')
assert f.filing_type == 'changeOfDirectors'
assert f.id == filing2.id
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 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_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 test_is_pending_correction_filing(session):
"""Assert that a filing has the isPendingCorrection flag set if the correction is pending approval.
Assert linkage is set from parent to child and otherway.
"""
from legal_api.models import Filing
# setup
filing1 = Filing()
filing1.filing_json = ANNUAL_REPORT
filing1.save()
b = factory_business('CP1234567')
filing2 = factory_completed_filing(b, CORRECTION_AR)
filing2._status = 'PENDING_CORRECTION'
setattr(filing2, 'skip_status_listener', True)
filing2.save()
filing1.parent_filing = filing2
filing1.save()
# test
assert filing1.json['filing']['header']['isCorrected'] is False
assert filing1.json['filing']['header']['isCorrectionPending'] is True
assert filing2.json['filing']['header']['affectedFilings'] is not None
assert filing2.json['filing']['header']['affectedFilings'][0] == filing1.id
def test_get_most_recent_filing_by_legal_type_in_json(session):
"""Assert that the most recent legal filing can be retrieved."""
business = factory_business('CP1234567')
uow = versioning_manager.unit_of_work(session)
transaction = uow.create_transaction(session)
for i in range(1, 5):
effective_date = f'200{i}-07-01T00:00:00+00:00'
completion_date = datetime.datetime.fromisoformat(effective_date)
base_filing = copy.deepcopy(ANNUAL_REPORT)
cod = copy.deepcopy(CHANGE_OF_DIRECTORS)
base_filing['filing']['changeOfDirectors'] = cod
base_filing['filing']['header']['effectiveDate'] = effective_date
filing = Filing()
filing._filing_date = completion_date
filing.business_id = business.id
filing.filing_json = base_filing
filing.effective_date = datetime.datetime.fromisoformat(effective_date)
filing.payment_token = 'token'
filing.transaction_id = transaction.id
filing.payment_completion_date = completion_date
filing.save()
f = Filing.get_most_recent_legal_filing(business.id, 'changeOfDirectors')
assert f.effective_date == datetime.datetime.fromisoformat(effective_date)
assert f.filing_type == 'annualReport'
assert f.id == filing.id
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 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 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 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_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 test_uncorrected_filing(session):
"""Assert that a uncorrected filing is unaffected."""
from legal_api.models import Filing
# setup
filing = Filing()
filing.filing_json = ANNUAL_REPORT
filing.save()
# test
assert filing.json['filing']['header']['isCorrected'] is False
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 test_linked_not_correction(session):
"""Assert that if a filing has a parent that is not a correction, the isCorrected flag is not set."""
from legal_api.models import Filing
# setup
filing1 = Filing()
filing1.filing_json = ANNUAL_REPORT
filing1.save()
f = copy.deepcopy(FILING_HEADER)
f['filing']['changeOfDirectors'] = CHANGE_OF_DIRECTORS
filing2 = Filing()
filing2.filing_json = f
filing2.save()
filing1.parent_filing = filing2
filing1.save()
# test
assert filing1.json['filing']['header']['isCorrected'] is False
assert filing2.json['filing']['header']['affectedFilings'] is not None
def test_get_legal_filings():
"""Assert that the legal_filings member returns valid JSON Legal Filing segments."""
filing = Filing()
assert not filing.legal_filings()
filing.filing_json = ANNUAL_REPORT
legal_filings = filing.legal_filings()
assert legal_filings
assert 'annualReport' in legal_filings[0].keys()
def test_save_filing_colin_only(session):
"""Assert that the in colin only flag is retrieved and saved."""
from legal_api.models import Filing
# setup
filing = Filing()
filing.filing_json = FILING_HEADER
filing.save()
# test
assert filing.json['filing']['header']['inColinOnly'] is False
assert filing.colin_only == False
async def test_publish_event(app, session, stan_server, event_loop, client_id,
entity_stan, future):
"""Assert that filing event is placed on the queue."""
# Call back for the subscription
from entity_queue_common.service import ServiceWorker
from entity_filer.worker import APP_CONFIG, publish_event, qsm
from legal_api.models import Business, 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)
event_handler_subject = APP_CONFIG.ENTITY_EVENT_PUBLISH_OPTIONS['subject']
await entity_stan.subscribe(
subject=event_handler_subject,
queue=f'entity_queue.{event_handler_subject}',
durable_name=f'entity_durable_name.{event_handler_subject}',
cb=cb_file_handler)
s = ServiceWorker()
s.sc = entity_stan
qsm.service = s
# Setup
filing = Filing()
filing.id = 101
filing.effective_date = datetime.utcnow().replace(tzinfo=timezone.utc)
filing.filing_json = ANNUAL_REPORT
business = Business()
business.identifier = 'CP1234567'
business.legal_name = 'CP1234567 - Legal Name'
# Test
await publish_event(business, filing)
try:
await asyncio.wait_for(future, 2, loop=event_loop)
except Exception as err:
print(err)
# check it out
assert len(msgs) == 1
event_msg = json.loads(msgs[0].data.decode('utf-8'))
assert event_msg['filing']['filingId'] == 101
assert event_msg['filing']['identifier'] == 'CP1234567'
assert event_msg['filing']['legalFilings'] == ['annualReport']
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 _save_incorporation_filing(incorporation_body,
client_request,
business_id=None):
"""Create or update an incorporation filing."""
# Check that there is a JSON filing
if not incorporation_body:
return None, {'message': f'No filing json data in body of post for incorporation'}, \
HTTPStatus.BAD_REQUEST
temp_corp_num = incorporation_body['filing'][
'incorporationApplication']['nameRequest']['nrNumber']
# temp_corp_num = business_id
# If this is an update to an incorporation filing, a temporary business identifier is passed in
if business_id:
business = Business.find_by_identifier(business_id)
if not business:
return None, {'message': f'No incorporation filing exists for id {business_id}'}, \
HTTPStatus.BAD_REQUEST
else:
# Ensure there are no current businesses with the NR/random identifier
business = Business.find_by_identifier(temp_corp_num)
if business:
return None, {'message': f'Incorporation filing for {temp_corp_num} already exists'}, \
HTTPStatus.BAD_REQUEST
# Create an empty business record, to be updated by the filer
business = Business()
business.identifier = temp_corp_num
business.save()
# Ensure the business identifier matches the NR in the filing
err = validate(business, incorporation_body)
if err:
return None, err.msg, err.code
filing = Filing.get_filings_by_type(business.id,
'incorporationApplication')
# There can only be zero or one incorporation filings, if there are none, this is an
# initial request for incorporation. Create and insert a filing.
if not filing:
filing = Filing()
filing.business_id = business.id
elif len(filing) > 1:
return None, {
'message': 'more than one incorporation filing found for corp'
}, HTTPStatus.BAD_REQUEST
else:
filing = filing[0]
filing.filing_json = incorporation_body
filing.save()
return filing, None, (HTTPStatus.CREATED if
(client_request.method
== 'POST') else HTTPStatus.ACCEPTED)
def test_save_filing_with_colin_id(session):
"""Assert that saving a filing with a colin event id is set to pending."""
from legal_api.models import Filing
# setup
filing = Filing()
filing.filing_json = ANNUAL_REPORT
filing.save()
assert filing.status == Filing.Status.DRAFT.value
filing.colin_event_id = 1234
filing.save()
assert filing.status == Filing.Status.PENDING.value
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_save_filing_with_colin_id(session):
"""Assert that saving a filing from the coops-updater-job user is set to paid and source is colin."""
from legal_api.models import Filing
# setup
filing = Filing()
filing.filing_json = ANNUAL_REPORT
filing.source = Filing.Source.COLIN.value
filing.save()
# test
assert filing.source == Filing.Source.COLIN.value
assert filing.status == Filing.Status.PAID.value
def test_get_filing_by_payment_token(session):
"""Assert that a filing can be retrieved by a unique payment token."""
payment_token = '1000'
filing = Filing()
filing.filing_json = ANNUAL_REPORT
filing.payment_token = payment_token
filing.save()
rv = Filing.get_filing_by_payment_token(payment_token)
assert rv
assert rv.payment_token == payment_token
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_save_filing_with_colin_id(session):
"""Assert that saving a filing from the coops-updater-job user is set to paid and source is colin."""
from legal_api.models import Filing
# setup
filing = Filing()
filing.filing_json = ANNUAL_REPORT
user = User.create_from_jwt_token({'username': '******', 'iss': 'test', 'sub': 'test'})
filing.submitter_id = user.id
filing.save()
# test
assert filing.source == Filing.Source.COLIN.value
assert filing.status == Filing.Status.PAID.value
def test_add_invalid_json_after_payment(session):
"""Assert that a filing_json has to be valid if a payment token has been set."""
import copy
filing = Filing()
filing.payment_token = 'payment token'
ar = copy.deepcopy(ANNUAL_REPORT)
ar['filing']['header'].pop('date', None)
with pytest.raises(BusinessException) as excinfo:
filing.filing_json = ar
assert excinfo.value.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
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 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
