def test_process_filing_completed(app, session):
"""Assert that an AR filling status is set to completed once processed."""
from entity_filer.worker import process_filing
from legal_api.models import Business, Filing
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
# setup
business = create_business(identifier)
business_id = business.id
filing_id = (create_filing(payment_id, AR_FILING, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# TEST
process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
assert filing.transaction_id
assert business.last_agm_date
assert business.last_ar_date
def test_process_coa_filing(app, session):
"""Assert that an AR filling can be applied to the model correctly."""
from entity_filer.worker import process_filing
from entity_filer.worker import get_filing_by_payment_id
from legal_api.models import Business, Filing
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
new_delivery_address = COA_FILING['filing']['changeOfAddress']['deliveryAddress']
new_mailing_address = COA_FILING['filing']['changeOfAddress']['mailingAddress']
# setup
business = create_business(identifier)
business_id = business.id
create_filing(payment_id, COA_FILING, business.id)
payment_token = {'paymentToken': {'id': payment_id, 'statusCode': Filing.Status.COMPLETED.value}}
# TEST
process_filing(payment_token, app)
# Get modified data
filing = get_filing_by_payment_id(payment_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
delivery_address = business.delivery_address.one_or_none().json
compare_addresses(delivery_address, new_delivery_address)
mailing_address = business.mailing_address.one_or_none().json
compare_addresses(mailing_address, new_mailing_address)
def _get_report(self):
if self._report_key == 'correction':
self._report_key = self._filing.filing_json['filing'][
'correction']['correctedFilingType']
elif self._report_key == 'alteration':
self._report_key = 'alterationNotice'
if self._filing.business_id:
self._business = Business.find_by_internal_id(
self._filing.business_id)
Report._populate_business_info_to_filing(self._filing,
self._business)
headers = {
'Authorization': 'Bearer {}'.format(jwt.get_token_auth_header()),
'Content-Type': 'application/json'
}
data = {
'reportName':
self._get_report_filename(),
'template':
"'" +
base64.b64encode(bytes(self._get_template(), 'utf-8')).decode() +
"'",
'templateVars':
self._get_template_data()
}
response = requests.post(url=current_app.config.get('REPORT_SVC_URL'),
headers=headers,
data=json.dumps(data))
if response.status_code != HTTPStatus.OK:
return jsonify(message=str(response.content)), response.status_code
return response.content, response.status_code
async def test_process_ar_filing_no_agm(app, session):
"""Assert that a no agm AR filling can be applied to the model correctly."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
# setup
business = create_business(identifier)
business_id = business.id
now = datetime.date(2020, 9, 17)
ar_date = datetime.date(2020, 8, 5)
agm_date = None
ar = copy.deepcopy(ANNUAL_REPORT)
ar['filing']['business']['identifier'] = identifier
ar['filing']['annualReport']['annualReportDate'] = ar_date.isoformat()
ar['filing']['annualReport']['annualGeneralMeetingDate'] = None
# TEST
with freeze_time(now):
filing = create_filing(payment_id, ar, business.id)
filing_id = filing.id
filing_msg = {'filing': {'id': filing_id}}
await process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
assert business.last_agm_date == agm_date
assert datetime.datetime.date(business.last_ar_date) == ar_date
async def test_process_coa_filing(app, session):
"""Assert that a COD filling can be applied to the model correctly."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
new_delivery_address = COA_FILING['filing']['changeOfAddress']['offices']['registeredOffice']['deliveryAddress']
new_mailing_address = COA_FILING['filing']['changeOfAddress']['offices']['registeredOffice']['mailingAddress']
# setup
business = create_business(identifier)
business_id = business.id
filing_id = (create_filing(payment_id, COA_FILING, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# TEST
await process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
register_office = business.offices.filter_by(office_type='registeredOffice').one_or_none()
delivery_address = register_office.addresses.filter_by(address_type='delivery').one_or_none().json
compare_addresses(delivery_address, new_delivery_address)
mailing_address = register_office.addresses.filter_by(address_type='mailing').one_or_none().json
compare_addresses(mailing_address, new_mailing_address)
def get_comments(identifier, comment_id=None):
"""Return a JSON object with meta information about the Service."""
# basic checks
if identifier.startswith('T'):
filing_model = FilingModel.get_temp_reg_filing(identifier)
business = Business.find_by_internal_id(filing_model.business_id)
else:
business = Business.find_by_identifier(identifier)
err_msg, err_code = _basic_checks(identifier, business, request)
if err_msg:
return jsonify(err_msg), err_code
comments = db.session.query(Comment).filter(
Comment.business_id == business.id, Comment.filing_id.is_(None))
if comment_id:
comment = comments.filter(Comment.id == comment_id).one_or_none()
if not comment:
return jsonify({'message': f'Comment {comment_id} not found'
}), HTTPStatus.NOT_FOUND
return jsonify(comment.json)
rv = []
for comment in comments:
rv.append(comment.json)
return jsonify(comments=rv)
def test_process_ar_filing(app, session):
"""Assert that an AR filling can be applied to the model correctly."""
from entity_filer.worker import process_filing
from entity_filer.worker import get_filing_by_payment_id
from legal_api.models import Business, Filing
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
agm_date = datetime.date.fromisoformat(AR_FILING['filing']['annualReport'].get('annualGeneralMeetingDate'))
ar_date = datetime.date.fromisoformat(COMBINED_FILING['filing']['annualReport'].get('annualReportDate'))
# setup
business = create_business(identifier)
business_id = business.id
create_filing(payment_id, AR_FILING, business.id)
payment_token = {'paymentToken': {'id': payment_id, 'statusCode': Filing.Status.COMPLETED.value}}
# TEST
process_filing(payment_token, app)
# Get modified data
filing = get_filing_by_payment_id(payment_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
assert datetime.datetime.date(business.last_agm_date) == agm_date
assert datetime.datetime.date(business.last_ar_date) == ar_date
def _basic_checks(identifier, filing_id, client_request) -> Tuple[dict, int]:
"""Perform basic checks to ensure put can do something."""
json_input = client_request.get_json()
if client_request.method == 'POST' and not json_input:
return ({
'message':
f'No filing json data in body of post for {identifier}.'
}, HTTPStatus.BAD_REQUEST)
if client_request.method == 'GET' and identifier.startswith('T'):
filing_model = Filing.get_temp_reg_filing(identifier)
business = Business.find_by_internal_id(filing_model.business_id)
else:
business = Business.find_by_identifier(identifier)
filing = Filing.find_by_id(filing_id)
if not business:
return ({'message': f'{identifier} not found'}, HTTPStatus.NOT_FOUND)
# check that filing belongs to this business
if not filing or filing.business_id != business.id:
return ({
'message': f'Filing {filing_id} not found'
}, HTTPStatus.NOT_FOUND)
return (None, None)
def test_process_ar_reminder_email(app, session):
"""Assert that the ar reminder notification can be processed."""
# setup filing + business for email
filing = prep_incorp_filing(session, 'BC1234567', '1', 'COMPLETED')
business = Business.find_by_internal_id(filing.business_id)
business.legal_type = 'BC'
business.legal_name = 'test business'
token = 'token'
# test processor
with patch.object(AccountService, 'get_bearer_token', return_value=token):
with patch.object(ar_reminder_notification,
'get_recipient_from_auth',
return_value='*****@*****.**'):
with patch.object(worker, 'send_email',
return_value='success') as mock_send_email:
worker.process_email(
{
'email': {
'businessId': filing.business_id,
'type': 'annualReport',
'option': 'reminder',
'arFee': '100',
'arYear': '2021'
}
}, app)
call_args = mock_send_email.call_args
assert call_args[0][0]['content'][
'subject'] == 'test business 2021 Annual Report Reminder'
assert call_args[0][0]['recipients'] == '*****@*****.**'
assert call_args[0][0]['content']['body']
assert call_args[0][0]['content']['attachments'] == []
assert call_args[0][1] == token
async def test_worker_alteration(app, session, mocker, orig_legal_type,
new_legal_type):
"""Assert the worker process calls the alteration correctly."""
identifier = 'BC1234567'
business = create_business(identifier, legal_type=orig_legal_type)
filing = copy.deepcopy(ALTERATION_FILING_TEMPLATE)
filing['filing']['business']['legalType'] = orig_legal_type
filing['filing']['alteration']['business']['legalType'] = new_legal_type
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing_id = (create_filing(payment_id, filing, business_id=business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# mock out the email sender and event publishing
mocker.patch('entity_filer.worker.publish_email_message',
return_value=None)
mocker.patch('entity_filer.worker.publish_event', return_value=None)
mocker.patch(
'entity_filer.filing_processors.filing_components.name_request.consume_nr',
return_value=None)
mocker.patch(
'entity_filer.filing_processors.filing_components.business_profile.update_business_profile',
return_value=None)
mocker.patch('legal_api.services.bootstrap.AccountService.update_entity',
return_value=None)
# Test
await process_filing(filing_msg, app)
# Check outcome
business = Business.find_by_internal_id(business.id)
assert business.legal_type == new_legal_type
def get_documents(identifier: str,
filing_id: int,
legal_filing_name: str = None):
"""Return a JSON object with meta information about the Service."""
# basic checks
if not authorized(identifier, jwt, [
'view',
]):
return jsonify(message=get_error_message(ErrorCode.NOT_AUTHORIZED, **{
'identifier': identifier
})), HTTPStatus.UNAUTHORIZED
if identifier.startswith('T'):
filing_model = FilingModel.get_temp_reg_filing(identifier)
business = Business.find_by_internal_id(filing_model.business_id)
else:
business = Business.find_by_identifier(identifier)
if not business and not identifier.startswith('T'):
return jsonify(message=get_error_message(ErrorCode.MISSING_BUSINESS, **
{'identifier': identifier
})), HTTPStatus.NOT_FOUND
if not (filing := Filing.get(identifier, filing_id)):
return jsonify(message=get_error_message(
ErrorCode.FILING_NOT_FOUND, **{
'filing_id': filing_id,
'identifier': identifier
})), HTTPStatus.NOT_FOUND
async def test_transition_filing(app, session):
"""Assert we can create a business based on transition filing."""
filing_data = copy.deepcopy(TRANSITION_FILING_TEMPLATE)
business = create_business(filing_data['filing']['business']['identifier'])
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing = (create_filing(payment_id, filing_data, business.id))
filing_msg = {'filing': {'id': filing.id}}
# Test
await process_filing(filing_msg, app)
# Check outcome
filing = Filing.find_by_id(filing.id)
business = Business.find_by_internal_id(filing.business_id)
filing_json = filing.filing_json
assert business
assert filing
assert filing.status == Filing.Status.COMPLETED.value
assert business.restriction_ind is False
assert len(business.share_classes.all()) == len(
filing_json['filing']['transition']['shareStructure']['shareClasses'])
assert len(business.offices.all()) == len(
filing_json['filing']['transition']['offices'])
assert len(business.aliases.all()) == len(
filing_json['filing']['transition']['nameTranslations'])
assert len(business.resolutions.all()) == len(
filing_json['filing']['transition']['shareStructure']
['resolutionDates'])
assert len(PartyRole.get_parties_by_role(business.id, 'director')) == 2
def test_process_incorporation_parties(app, session):
"""Assert we successfully add parties in incorporation filing."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing = copy.deepcopy(INCORP_FILING)
schema_incorp = copy.deepcopy(INCORPORATION)
filing['filing']['incorporationApplication']['parties'] = schema_incorp['parties']
identifier = filing['filing']['incorporationApplication']['nameRequest']['nrNumber']
business = create_business(identifier)
filing_id = (create_filing(payment_id, filing, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
process_filing(filing_msg, app)
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(filing.business_id)
assert len(PartyRole.get_parties_by_role(business.id, 'director')) == 1
assert len(PartyRole.get_parties_by_role(business.id, 'incorporator')) == 1
assert len(PartyRole.get_parties_by_role(business.id, 'completing_party')) == 1
director = (PartyRole.get_parties_by_role(business.id, 'director'))[0]
incorporator = (PartyRole.get_parties_by_role(business.id, 'incorporator'))[0]
completing_party = (PartyRole.get_parties_by_role(business.id, 'completing_party'))[0]
assert director.appointment_date
assert incorporator.appointment_date
assert completing_party.appointment_date
def test_process_filing_failed(app, session):
"""Assert that an AR filling status is set to error if payment transaction failed."""
from entity_filer.worker import process_filing
from entity_filer.worker import get_filing_by_payment_id
from legal_api.models import Business, Filing
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
# setup
business = create_business(identifier)
business_id = business.id
create_filing(payment_id, AR_FILING, business.id)
payment_token = {'paymentToken': {'id': payment_id, 'statusCode': 'TRANSACTION_FAILED'}}
# TEST
process_filing(payment_token, app)
# Get modified data
filing = get_filing_by_payment_id(payment_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.business_id == business_id
assert filing.status == Filing.Status.ERROR.value
assert not business.last_agm_date
assert not business.last_ar_date
async def test_process_filing_completed(app, session, mocker):
"""Assert that an AR filling status is set to completed once processed."""
from entity_filer.worker import publish_email_message
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
# mock out the email sender and event publishing
mocker.patch('entity_filer.worker.publish_email_message',
return_value=None)
mocker.patch('entity_filer.worker.publish_event', return_value=None)
# setup
business = create_business(identifier, legal_type='CP')
business_id = business.id
filing_id = (create_filing(payment_id, AR_FILING, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# TEST
await process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
assert filing.transaction_id
assert business.last_agm_date
assert business.last_ar_date
def process_filing(payment_token, flask_app):
"""Render the filings contained in the submission."""
if not flask_app:
raise QueueException('Flask App not available.')
with flask_app.app_context():
# try to find the filing 5 times before putting back on the queue - in case payment token ends up on the queue
# before it is assigned to filing.
counter = 1
filing_submission = None
while not filing_submission and counter <= 5:
filing_submission = get_filing_by_payment_id(payment_token['paymentToken'].get('id'))
counter += 1
sleep(0.2)
if not filing_submission:
raise FilingException
if filing_submission.status == Filing.Status.COMPLETED.value:
logger.warning('Queue: Attempting to reprocess business.id=%s, filing.id=%s payment=%s',
filing_submission.business_id, filing_submission.id, payment_token)
return
if payment_token['paymentToken'].get('statusCode') == 'TRANSACTION_FAILED':
# TODO - need to surface TRANSACTION_FAILED, but Filings manages its own status
# filing_submission.status = Filing.Status.ERROR
filing_submission.payment_completion_date = datetime.datetime.utcnow()
db.session.add(filing_submission)
db.session.commit()
return
legal_filings = filing_submission.legal_filings()
# TODO: handle case where there are no legal_filings
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
if not payment_token['paymentToken'].get('statusCode') == 'TRANSACTION_FAILED':
if not payment_token['paymentToken'].get('statusCode') == Filing.Status.COMPLETED.value:
logger.error('Unknown payment status given: %s', payment_token['paymentToken'].get('statusCode'))
raise QueueException
business = Business.find_by_internal_id(filing_submission.business_id)
for filing in legal_filings:
if filing.get('annualReport'):
annual_report.process(business, filing)
if filing.get('changeOfAddress'):
change_of_address.process(business, filing)
if filing.get('changeOfDirectors'):
change_of_directors.process(business, filing)
filing_submission.transaction_id = transaction.id
db.session.add(business)
filing_submission.payment_completion_date = datetime.datetime.utcnow()
db.session.add(filing_submission)
db.session.commit()
return
def test_process_cod_filing(app, session):
"""Assert that an AR filling can be applied to the model correctly."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
end_date = datetime.datetime.utcnow().date()
# prep director for no change
filing_data = copy.deepcopy(COD_FILING)
director1 = create_director(
filing_data['filing']['changeOfDirectors']['directors'][0])
# prep director for name change
director2 = filing_data['filing']['changeOfDirectors']['directors'][1]
director2['officer']['firstName'] = director2['officer']['prevFirstName']
director2['officer']['middleInitial'] = director2['officer'][
'prevMiddleInitial']
director2['officer']['lastName'] = director2['officer']['prevLastName']
director2 = create_director(director2)
# prep director for cease
director3 = create_director(
filing_data['filing']['changeOfDirectors']['directors'][2])
director_ceased_id = director3.id
# prep director for address change
director4 = filing_data['filing']['changeOfDirectors']['directors'][3]
director4['deliveryAddress']['streetAddress'] = 'should get changed'
director4 = create_director(director4)
# list of active/ceased directors in test filing
ceased_directors, active_directors = active_ceased_lists(COD_FILING)
# setup
business = create_business(identifier)
business.directors.append(director1)
business.directors.append(director2)
business.directors.append(director3)
business.directors.append(director4)
business.save()
# check that adding the director during setup was successful
directors = Director.get_active_directors(business.id, end_date)
assert len(directors) == 4
# create filing
business_id = business.id
filing_id = (create_filing(payment_id, COD_FILING, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# TEST
process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
directors = Director.get_active_directors(business.id, end_date)
check_directors(business, directors, director_ceased_id, ceased_directors,
active_directors)
def process_filing(filing_msg: Dict, flask_app: Flask):
"""Render the filings contained in the submission."""
if not flask_app:
raise QueueException('Flask App not available.')
with flask_app.app_context():
filing_submission = Filing.find_by_id(filing_msg['filing']['id'])
if not filing_submission:
raise QueueException
if filing_submission.status == Filing.Status.COMPLETED.value:
logger.warning('QueueFiler: Attempting to reprocess business.id=%s, filing.id=%s filing=%s',
filing_submission.business_id, filing_submission.id, filing_msg)
return
legal_filings = filing_submission.legal_filings()
if legal_filings:
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
business = Business.find_by_internal_id(filing_submission.business_id)
for filing in legal_filings:
if filing.get('annualReport'):
annual_report.process(business, filing)
elif filing.get('changeOfAddress'):
change_of_address.process(business, filing)
elif filing.get('changeOfDirectors'):
filing['colinIds'] = filing_submission.colin_event_ids
change_of_directors.process(business, filing)
elif filing.get('changeOfName'):
change_of_name.process(business, filing)
elif filing.get('specialResolution'):
pass # nothing to do here
elif filing.get('voluntaryDissolution'):
voluntary_dissolution.process(business, filing)
elif filing.get('incorporationApplication'):
incorporation_filing.process(business, filing, flask_app)
filing_submission.transaction_id = transaction.id
filing_submission.set_processed()
db.session.add(business)
db.session.add(filing_submission)
db.session.commit()
publish_event(business, filing_submission)
return
def get_business_revision_after_filing(filing_id, business_id) -> dict:
"""Consolidates the business info as of a particular transaction."""
business = Business.find_by_internal_id(business_id)
filing = Filing.find_by_id(filing_id)
business_version = version_class(Business)
business_revision = db.session.query(business_version) \
.filter(business_version.transaction_id > filing.transaction_id) \
.filter(business_version.operation_type != 2) \
.filter(business_version.id == business.id) \
.order_by(business_version.transaction_id).one_or_none()
return VersionedBusinessDetailsService.business_revision_json(
business_revision, business.json())
def get_business_revision_before_filing(filing_id, business_id) -> dict:
"""Consolidates the business info of the previous filing."""
business = Business.find_by_internal_id(business_id)
filing = Filing.find_by_id(filing_id)
business_version = version_class(Business)
business_revision = db.session.query(business_version) \
.filter(business_version.transaction_id < filing.transaction_id) \
.filter(business_version.operation_type != 2) \
.filter(business_version.id == business.id) \
.order_by(business_version.transaction_id.desc()).first()
return VersionedBusinessDetailsService.business_revision_json(
business_revision, business.json())
def update_and_validate_party_and_roles(business, parties_structure, roles_count, parties_count):
"""Validate that party and party roles get created."""
party_id_list = []
err = update_parties(business, parties_structure['parties'])
business.save()
check_business = Business.find_by_internal_id(business.id)
check_party_roles = check_business.party_roles.all()
for role in check_party_roles:
if role.party_id not in party_id_list:
party_id_list.append(role.party_id)
assert len(check_party_roles) == roles_count
assert len(party_id_list) == parties_count
assert not err
def get(status=None):
"""Get filings by status formatted in json."""
pending_filings = []
filings = []
if status is None:
pending_filings = Filing.get_completed_filings_for_colin()
for filing in pending_filings:
filing_json = filing.filing_json
business = Business.find_by_internal_id(filing.business_id)
if filing_json and filing.filing_type != 'lear_epoch' and \
(filing.filing_type != 'correction' or business.legal_type != business.LegalTypes.COOP.value):
filing_json['filingId'] = filing.id
filing_json['filing']['header'][
'learEffectiveDate'] = filing.effective_date.isoformat(
)
if not filing_json['filing']['business'].get('legalName'):
business = Business.find_by_internal_id(
filing.business_id)
filing_json['filing']['business'][
'legalName'] = business.legal_name
if filing.filing_type == 'correction':
colin_ids = \
ColinEventId.get_by_filing_id(filing_json['filing']['correction']['correctedFilingId'])
if not colin_ids:
continue
filing_json['filing']['correction'][
'correctedFilingColinId'] = colin_ids[
0] # should only be 1
filings.append(filing_json)
return jsonify(filings), HTTPStatus.OK
pending_filings = Filing.get_all_filings_by_status(status)
for filing in pending_filings:
filings.append(filing.json)
return jsonify(filings), HTTPStatus.OK
async def test_cb_subscription_handler(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_filer.worker import cb_subscription_handler
from entity_filer.worker import get_filing_by_payment_id
from legal_api.models import Business
from tests.unit import create_filing, AR_FILING, create_business
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
agm_date = datetime.date.fromisoformat(
AR_FILING['filing']['annualReport'].get('annualGeneralMeetingDate'))
ar_date = datetime.date.fromisoformat(
AR_FILING['filing']['annualReport'].get('annualReportDate'))
# setup
business = create_business(identifier)
business_id = business.id
create_filing(payment_id, AR_FILING, business.id)
# register the handler to test it
entity_subject = await subscribe_to_queue(entity_stan,
cb_subscription_handler)
# add payment tokens to queue
await helper_add_payment_to_queue(entity_stan,
entity_subject,
payment_id=payment_id,
status_code='COMPLETED')
try:
await asyncio.sleep(1)
# await asyncio.wait_for(cb_future, 2, loop=event_loop)
except Exception as err:
print(err)
# Get modified data
filing = get_filing_by_payment_id(payment_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert datetime.datetime.date(business.last_agm_date) == agm_date
assert datetime.datetime.date(business.last_ar_date) == ar_date
def test_incorporation_filing(app, session):
"""Assert we can retrieve a new corp number from COLIN and incorporate a business."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing = copy.deepcopy(INCORP_FILING)
identifier = filing['filing']['incorporationApplication']['nameRequest'][
'nrNumber']
business = create_business(identifier)
filing_id = (create_filing(payment_id, filing, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
assert business.identifier == 'NR 1234567'
process_filing(filing_msg, app)
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(filing.business_id)
assert business.identifier != 'NR 1234567'
def update_and_validate_office(business, office_structure):
"""Validate that office gets created."""
err = update_offices(business, office_structure['offices'])
business.save()
check_business = Business.find_by_internal_id(business.id)
check_offices = check_business.offices.all()
assert len(check_offices) == 2
check_office_structure = {'offices': {}}
for s in check_offices:
check_office_structure['offices'][s.office_type] = {}
for address in s.addresses:
check_office_structure['offices'][
s.office_type][f'{address.address_type}Address'] = address.json
stripped_dict = strip_keys_from_dict(check_office_structure,
['id', 'addressType'])
assert stripped_dict == office_structure
assert not err
def get_company_details_revision(filing_id, business_id) -> dict:
"""Consolidates company details upto the given transaction id of a filing."""
company_profile_json = {}
business = Business.find_by_internal_id(business_id)
filing = Filing.find_by_id(filing_id)
company_profile_json['business'] = \
VersionedBusinessDetailsService.get_business_revision(filing.transaction_id, business)
company_profile_json['parties'] = \
VersionedBusinessDetailsService.get_party_role_revision(filing.transaction_id, business_id)
company_profile_json['offices'] = \
VersionedBusinessDetailsService.get_office_revision(filing.transaction_id, business_id)
company_profile_json['shareClasses'] = \
VersionedBusinessDetailsService.get_share_class_revision(filing.transaction_id, business_id)
company_profile_json['nameTranslations'] = \
VersionedBusinessDetailsService.get_name_translations_revision(filing.transaction_id, business_id)
company_profile_json['resolutions'] = \
VersionedBusinessDetailsService.get_resolution_dates_revision(filing.transaction_id, business_id)
return company_profile_json
def test_manage_share_structure__resolution_dates(app, session, test_name,
resolution_dates,
expected_error):
"""Assert that the corp share resolution date gets set."""
new_data = {'shareStructure': {'resolutionDates': resolution_dates}}
business = Business()
business.save()
err = shares.update_share_structure(business, new_data['shareStructure'])
business.save()
check_business = Business.find_by_internal_id(business.id)
check_resolution = check_business.resolutions.all()
if err:
assert err == expected_error
else:
assert len(check_resolution) == len(resolution_dates)
assert set(resolution_dates) == \
set([x.resolution_date.isoformat() for x in check_resolution])
async def test_worker_alteration(app, session, orig_legal_type, new_legal_type):
"""Assert the worker process calls the alteration correctly."""
identifier = 'BC1234567'
business = create_business(identifier, legal_type=orig_legal_type)
filing = copy.deepcopy(ALTERATION_FILING_TEMPLATE)
filing['filing']['business']['legalType'] = orig_legal_type
filing['filing']['alteration']['business']['legalType'] = new_legal_type
filing['filing']['alteration']['nameTranslations'] = [{'name': 'A5 Ltd.'}]
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing_id = (create_filing(payment_id, filing, business_id=business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# Test
await process_filing(filing_msg, app)
# Check outcome
business = Business.find_by_internal_id(business.id)
assert business.legal_type == new_legal_type
def test_manage_share_structure__share_classes(app, session, test_name,
share_structure,
expected_error):
"""Assert that the corp share classes gets set."""
business = Business()
business.save()
err = shares.update_share_structure(business,
share_structure['shareStructure'])
business.save()
check_business = Business.find_by_internal_id(business.id)
check_share_classes = check_business.share_classes.all()
check_share_structure = {'shareStructure': {'shareClasses': []}}
for s in check_share_classes:
check_share_structure['shareStructure']['shareClasses'].append(s.json)
stripped_dict = strip_keys_from_dict(check_share_structure, ['id'])
assert stripped_dict == share_structure
assert not err
async def test_incorporation_filing(app, session, bootstrap):
"""Assert we can retrieve a new corp number from COLIN and incorporate a business."""
filing = copy.deepcopy(INCORPORATION_FILING_TEMPLATE)
filing['filing']['incorporationApplication']['nameRequest'][
'nrNumber'] = 'NR 0000021'
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing_id = (create_filing(payment_id, filing, bootstrap_id=bootstrap)).id
filing_msg = {'filing': {'id': filing_id}}
# Test
await process_filing(filing_msg, app)
# Check outcome
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(filing.business_id)
filing_json = filing.filing_json
assert business
assert filing
assert filing.status == Filing.Status.COMPLETED.value
assert business.identifier == filing_json['filing']['business'][
'identifier']
assert business.founding_date.isoformat(
) == filing_json['filing']['business']['foundingDate']
assert len(business.share_classes.all()) == len(
filing_json['filing']['incorporationApplication']['shareClasses'])
assert len(business.offices.all()) == len(
filing_json['filing']['incorporationApplication']['offices'])
assert len(PartyRole.get_parties_by_role(business.id, 'director')) == 1
assert len(PartyRole.get_parties_by_role(business.id, 'incorporator')) == 1
assert len(PartyRole.get_parties_by_role(business.id,
'completing_party')) == 1
incorporator = (PartyRole.get_parties_by_role(business.id,
'incorporator'))[0]
completing_party = (PartyRole.get_parties_by_role(business.id,
'completing_party'))[0]
assert incorporator.appointment_date
assert completing_party.appointment_date
