def test_company_referrals_ordering(api_client):
"""
Test that the company referrals are ordered by ('modified_on', 'pk')
"""
company_referrals = []
with freeze_time() as frozen_datetime:
company_referrals += CompanyReferralFactory.create_batch(2)
frozen_datetime.tick(datetime.timedelta(microseconds=1))
company_referrals += CompanyReferralFactory.create_batch(8)
frozen_datetime.tick(datetime.timedelta(seconds=1, microseconds=1))
response = hawk.get(
api_client, get_url('api-v3:activity-stream:company-referrals'))
assert response.status_code == status.HTTP_200_OK
sorted_company_referral_ids = [
f'dit:DataHubCompanyReferral:{obj.pk}'
for obj in sorted(company_referrals,
key=lambda obj: (obj.modified_on, obj.pk))
]
response_company_referral_ids = [
item['object']['id'] for item in response.json()['orderedItems']
]
assert sorted_company_referral_ids == response_company_referral_ids
def _company_factory(
num_interactions=0,
num_contacts=0,
num_investment_projects=0,
num_orders=0,
num_referrals=0,
num_company_list_items=0,
num_pipeline_items=0,
):
"""
Factory for a company that has companies, interactions, investment projects and OMIS orders.
"""
company = CompanyFactory()
ContactFactory.create_batch(num_contacts, company=company)
CompanyInteractionFactory.create_batch(num_interactions, company=company)
CompanyReferralFactory.create_batch(num_referrals,
company=company,
contact=None)
OrderFactory.create_batch(num_orders, company=company)
CompanyListItemFactory.create_batch(num_company_list_items,
company=company)
PipelineItemFactory.create_batch(num_pipeline_items, company=company)
fields_iter = cycle(INVESTMENT_PROJECT_COMPANY_FIELDS)
fields = islice(fields_iter, 0, num_investment_projects)
InvestmentProjectFactory.create_batch(
num_investment_projects,
**{field: company
for field in fields},
)
return company
def company_with_referrals_factory():
"""
Factory for a company with referrals.
No company contacts are created to simplify testing.
"""
company = CompanyFactory()
CompanyReferralFactory.create_batch(3, company=company, contact=None)
return company
def test_doesnt_return_other_users_referrals(self):
"""Test that other users' referrals are not returned."""
# Create some referrals sent or received by other users
CompanyReferralFactory.create_batch(2)
response = self.api_client.get(collection_url)
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
assert response_data['results'] == []
def unrelated_objects():
"""
Create some objects not related to a known company.
This is used in tests below to make sure objects unrelated to the company being merged
do not affect the counts of objects that will be affected by the merge.
"""
ContactFactory.create_batch(2)
CompanyReferralFactory.create_batch(2)
CompanyInteractionFactory.create_batch(2)
OrderFactory.create_batch(2)
InvestmentProjectFactory.create_batch(2)
def _company_factory(
num_interactions=0,
num_contacts=0,
num_orders=0,
num_referrals=0,
num_company_list_items=0,
):
"""Factory for a company that has companies, interactions and OMIS orders."""
company = CompanyFactory()
ContactFactory.create_batch(num_contacts, company=company)
CompanyInteractionFactory.create_batch(num_interactions, company=company)
CompanyReferralFactory.create_batch(num_referrals, company=company, contact=None)
OrderFactory.create_batch(num_orders, company=company)
CompanyListItemFactory.create_batch(num_company_list_items, company=company)
return company
def test_str(self):
"""Test __str__()."""
referral = CompanyReferralFactory.build(
company__name='Mars Ltd',
subject='Wants to export to the Far East',
)
assert str(referral) == 'Mars Ltd – Wants to export to the Far East'
def test_returns_items_in_expected_format(self):
"""Test that referrals are returned in expected format."""
company_referral = CompanyReferralFactory(created_by=self.user)
response = self.api_client.get(collection_url)
assert response.status_code == status.HTTP_200_OK
results = response.json()['results']
assert len(results) == 1
assert results[0] == {
'id': str(company_referral.pk),
'company': {
'id': str(company_referral.company.pk),
'name': company_referral.company.name,
},
'completed_by': None,
'completed_on': None,
'contact': {
'id': str(company_referral.contact.pk),
'name': company_referral.contact.name,
},
'created_by': format_expected_adviser(company_referral.created_by),
'created_on': format_date_or_datetime(company_referral.created_on),
'interaction': None,
'recipient': format_expected_adviser(company_referral.recipient),
'status': company_referral.status,
'subject': company_referral.subject,
'notes': company_referral.notes,
}
def test_with_multiple_records(self, data_flow_api_client):
"""Test that endpoint returns correct number of records"""
with freeze_time('2019-01-01 12:30:00'):
referral1 = CompanyReferralFactory()
with freeze_time('2019-01-03 12:00:00'):
referral2 = CompanyReferralFactory()
with freeze_time('2019-01-01 12:00:00'):
referral3 = CompanyReferralFactory()
referral4 = CompanyReferralFactory()
response = data_flow_api_client.get(self.view_url)
assert response.status_code == status.HTTP_200_OK
response_results = response.json()['results']
assert len(response_results) == 4
expected_list = sorted([referral3, referral4],
key=lambda x: x.pk) + [referral1, referral2]
for index, referral in enumerate(expected_list):
assert str(referral.id) == response_results[index]['id']
def test_returns_items_for_sender_and_recipient(self):
"""Test that both sent and received referrals are returned."""
sender = CompanyReferralFactory(created_by=self.user)
recipient1 = CompanyReferralFactory(recipient=self.user)
recipient2 = CompanyReferralFactory(recipient=self.user)
response = self.api_client.get(collection_url)
assert response.status_code == status.HTTP_200_OK
results = response.json()['results']
assert len(results) == 3
expected_referrals = {
str(sender.pk),
str(recipient1.pk),
str(recipient2.pk)
}
assert {result['id'] for result in results} == expected_referrals
def test_body_validation(self, request_data, expected_response_data):
"""Test validation of the request body in various cases."""
referral = CompanyReferralFactory()
url = _complete_url(referral.pk)
resolved_data = resolve_objects(request_data)
response = self.api_client.post(url, data=resolved_data)
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.json() == expected_response_data
def test_permission_checking(self, permission_codenames, expected_status, api_client):
"""Test that the expected status is returned depending on the permissions the user has."""
user = create_test_user(permission_codenames=permission_codenames)
api_client = self.create_api_client(user=user)
referral = CompanyReferralFactory()
url = _complete_url(referral.pk)
request_data = _sample_valid_request_data(referral)
response = api_client.post(url, data=request_data)
assert response.status_code == expected_status
def test_permission_checking(self, permission_codenames, expected_status,
api_client):
"""
Test that the expected status is returned depending on the permissions the user has.
"""
referral = CompanyReferralFactory()
user = create_test_user(permission_codenames=permission_codenames)
url = _item_url(referral.pk)
api_client = self.create_api_client(user=user)
response = api_client.get(url)
assert response.status_code == expected_status
def test_returns_401_if_unauthenticated(self, api_client):
"""Test that a 401 is returned if the user is unauthenticated."""
referral = CompanyReferralFactory()
url = _complete_url(referral.pk)
response = api_client.post(url, data={})
assert response.status_code == status.HTTP_401_UNAUTHORIZED
def test_creates_an_interaction(self, extra_data):
"""Test that an interaction is created on success."""
referral = CompanyReferralFactory()
url = _complete_url(referral.pk)
contact = ContactFactory(company=referral.company)
service = random_service()
request_data = {
'kind': Interaction.Kind.INTERACTION,
'subject': 'test subject',
'date': '2020-02-03',
'dit_participants': [
{
'adviser': self.user
},
],
'contacts': [contact],
'service': service,
'was_policy_feedback_provided': False,
**extra_data,
}
resolved_request_data = resolve_objects(request_data)
with freeze_time(FROZEN_DATETIME):
response = self.api_client.post(url, data=resolved_request_data)
assert response.status_code == status.HTTP_201_CREATED
referral.refresh_from_db()
assert referral.interaction_id
interaction_data = Interaction.objects.values().get(
pk=referral.interaction_id)
expected_interaction_data = {
# Automatically set fields
'created_by_id':
self.user.pk,
'created_on':
FROZEN_DATETIME,
'id':
referral.interaction_id,
'modified_by_id':
self.user.pk,
'modified_on':
FROZEN_DATETIME,
# Fields specified in the request body
'communication_channel_id':
resolved_request_data.get('communication_channel'),
'date':
datetime(2020, 2, 3, tzinfo=utc),
'event_id':
resolved_request_data.get('event'),
'grant_amount_offered':
None,
'investment_project_id':
None,
'kind':
resolved_request_data['kind'],
'net_company_receipt':
None,
'notes':
'',
'policy_feedback_notes':
'',
'service_answers':
None,
'service_delivery_status_id':
None,
'service_id':
service.pk,
'source':
None,
'status':
Interaction.Status.COMPLETE,
'subject':
resolved_request_data['subject'],
'theme':
None,
'was_policy_feedback_provided':
resolved_request_data['was_policy_feedback_provided'],
'were_countries_discussed':
None,
# Other fields
'archived':
False,
'archived_by_id':
None,
'archived_documents_url_path':
'',
'archived_on':
None,
'archived_reason':
None,
'large_capital_opportunity_id':
None,
'has_related_trade_agreements':
None,
# TODO: a legacy field, remove once interaction.company field is removed
'company_id':
referral.company_id,
}
assert interaction_data == expected_interaction_data
assert list(referral.interaction.contacts.all()) == [contact]
assert list(referral.interaction.companies.all()) == [referral.company]
participant = referral.interaction.dit_participants.get()
assert participant.adviser == self.user
assert participant.team == self.user.dit_team
def test_updates_referral_status(self):
"""Test that the status of the referral is updated on success."""
referral = CompanyReferralFactory()
url = _complete_url(referral.pk)
request_data = _sample_valid_request_data(referral)
with freeze_time(FROZEN_DATETIME):
response = self.api_client.post(url, data=request_data)
assert response.status_code == status.HTTP_201_CREATED
response_data = response.json()
referral.refresh_from_db()
interaction = referral.interaction
assert response_data == {
'id':
response_data['id'],
'kind':
Interaction.Kind.INTERACTION.value,
'status':
Interaction.Status.COMPLETE.value,
'theme':
interaction.theme,
'is_event':
None,
'service_delivery_status':
None,
'grant_amount_offered':
None,
'net_company_receipt':
None,
'policy_areas': [],
'policy_feedback_notes':
'',
'policy_issue_types': [],
'was_policy_feedback_provided':
interaction.was_policy_feedback_provided,
'communication_channel': {
'id': str(interaction.communication_channel.pk),
'name': interaction.communication_channel.name,
},
'subject':
interaction.subject,
'date':
interaction.date.date().isoformat(),
'dit_participants':
[{
'adviser': {
'id': str(dit_participant.adviser.pk),
'first_name': dit_participant.adviser.first_name,
'last_name': dit_participant.adviser.last_name,
'name': dit_participant.adviser.name,
},
'team': {
'id': str(dit_participant.team.pk),
'name': dit_participant.team.name,
},
}
for dit_participant in interaction.dit_participants.order_by('pk')
],
'notes':
interaction.notes,
'company': {
'id': str(interaction.company.pk),
'name': interaction.company.name,
},
'companies': [
{
'id': str(interaction.company.pk),
'name': interaction.company.name,
},
],
'contacts': [{
'id': str(contact.pk),
'name': contact.name,
'first_name': contact.first_name,
'last_name': contact.last_name,
'job_title': contact.job_title,
} for contact in interaction.contacts.order_by('pk')],
'event':
None,
'service': {
'id': str(interaction.service.pk),
'name': interaction.service.name,
},
'service_answers':
None,
'investment_project':
None,
'archived_documents_url_path':
interaction.archived_documents_url_path,
'were_countries_discussed':
interaction.were_countries_discussed,
'export_countries': [],
'created_by': {
'id': str(interaction.created_by.pk),
'first_name': interaction.created_by.first_name,
'last_name': interaction.created_by.last_name,
'name': interaction.created_by.name,
},
'modified_by': {
'id': str(interaction.modified_by.pk),
'first_name': interaction.modified_by.first_name,
'last_name': interaction.modified_by.last_name,
'name': interaction.modified_by.name,
},
'created_on':
format_date_or_datetime(FROZEN_DATETIME),
'modified_on':
format_date_or_datetime(FROZEN_DATETIME),
'archived':
False,
'archived_by':
None,
'archived_on':
None,
'archived_reason':
None,
'company_referral': {
'id': str(referral.pk),
'subject': referral.subject,
'created_by': format_expected_adviser(referral.created_by),
'created_on': format_date_or_datetime(referral.created_on),
'recipient': format_expected_adviser(referral.recipient),
},
'large_capital_opportunity':
None,
'related_trade_agreements': [],
}
assert referral.status == CompanyReferral.Status.COMPLETE
assert referral.completed_by == self.user
assert referral.completed_on == FROZEN_DATETIME
assert referral.modified_by == self.user
assert referral.modified_on == FROZEN_DATETIME
def test_company_referral_activity_without_team_and_contact(api_client):
"""
Get a list of company referrals and test the returned JSON is valid as per:
https://www.w3.org/TR/activitystreams-core/
"""
recipient = AdviserFactory(dit_team=None)
company_referral = CompanyReferralFactory(recipient=recipient, contact=None)
response = hawk.get(api_client, get_url('api-v3:activity-stream:company-referrals'))
assert response.status_code == status.HTTP_200_OK
assert response.json() == {
'@context': 'https://www.w3.org/ns/activitystreams',
'summary': 'Company Referral Activities',
'type': 'OrderedCollectionPage',
'id': 'http://testserver/v3/activity-stream/company-referral',
'partOf': 'http://testserver/v3/activity-stream/company-referral',
'previous': None,
'next': None,
'orderedItems': [
{
'id': f'dit:DataHubCompanyReferral:{company_referral.id}:Announce',
'type': 'Announce',
'published': format_date_or_datetime(company_referral.modified_on),
'generator': {'name': 'dit:dataHub', 'type': 'Application'},
'object': {
'id': f'dit:DataHubCompanyReferral:{company_referral.id}',
'type': ['dit:CompanyReferral'],
'startTime': format_date_or_datetime(company_referral.created_on),
'dit:subject': company_referral.subject,
'dit:status': str(company_referral.status),
'attributedTo': [
{
'id': f'dit:DataHubCompany:{company_referral.company.pk}',
'dit:dunsNumber': company_referral.company.duns_number,
'dit:companiesHouseNumber': company_referral.company.company_number,
'type': ['Organization', 'dit:Company'],
'name': company_referral.company.name,
},
{
'id': f'dit:DataHubAdviser:{company_referral.created_by.pk}',
'type': ['Person', 'dit:Adviser'],
'dit:emailAddress':
company_referral.created_by.contact_email
or company_referral.created_by.email,
'name': company_referral.created_by.name,
'dit:team': {
'id': f'dit:DataHubTeam:{company_referral.created_by.dit_team.pk}',
'type': ['Group', 'dit:Team'],
'name': company_referral.created_by.dit_team.name,
},
'dit:DataHubCompanyReferral:role': 'sender',
},
{
'id': f'dit:DataHubAdviser:{company_referral.recipient.pk}',
'type': ['Person', 'dit:Adviser'],
'dit:emailAddress':
company_referral.recipient.contact_email
or company_referral.recipient.email,
'name': company_referral.recipient.name,
'dit:DataHubCompanyReferral:role': 'recipient',
},
],
'url': company_referral.get_absolute_url(),
},
},
],
}
def test_company_referral_activity(api_client):
"""
Get a list of company referrals and test the returned JSON is valid as per:
https://www.w3.org/TR/activitystreams-core/
"""
start = datetime.datetime(year=2012,
month=7,
day=12,
hour=15,
minute=6,
second=3)
with freeze_time(start) as frozen_datetime:
company_referral = CompanyReferralFactory()
frozen_datetime.tick(datetime.timedelta(seconds=1, microseconds=1))
response = hawk.get(
api_client, get_url('api-v3:activity-stream:company-referrals'))
assert response.status_code == status.HTTP_200_OK
assert response.json() == {
'@context':
'https://www.w3.org/ns/activitystreams',
'summary':
'Company Referral Activities',
'type':
'OrderedCollectionPage',
'next':
'http://testserver/v3/activity-stream/company-referral' +
'?cursor=2012-07-12T15%3A06%3A03.000000%2B00%3A00' +
f'&cursor={str(company_referral.id)}',
'orderedItems': [
{
'id':
f'dit:DataHubCompanyReferral:{company_referral.id}:Announce',
'type': 'Announce',
'published':
format_date_or_datetime(company_referral.modified_on),
'generator': {
'name': 'dit:dataHub',
'type': 'Application'
},
'object': {
'id':
f'dit:DataHubCompanyReferral:{company_referral.id}',
'type': ['dit:CompanyReferral'],
'startTime':
format_date_or_datetime(company_referral.created_on),
'dit:subject':
company_referral.subject,
'dit:status':
str(company_referral.status),
'attributedTo': [
{
'id':
f'dit:DataHubCompany:{company_referral.company.pk}',
'dit:dunsNumber':
company_referral.company.duns_number,
'dit:companiesHouseNumber':
company_referral.company.company_number,
'type': ['Organization', 'dit:Company'],
'name': company_referral.company.name,
},
{
'id':
f'dit:DataHubAdviser:{company_referral.created_by.pk}',
'type': ['Person', 'dit:Adviser'],
'dit:emailAddress':
company_referral.created_by.contact_email
or company_referral.created_by.email,
'name':
company_referral.created_by.name,
'dit:team': {
'id':
f'dit:DataHubTeam:{company_referral.created_by.dit_team.pk}',
'type': ['Group', 'dit:Team'],
'name':
company_referral.created_by.dit_team.name,
},
'dit:DataHubCompanyReferral:role':
'sender',
},
{
'id':
f'dit:DataHubAdviser:{company_referral.recipient.pk}',
'type': ['Person', 'dit:Adviser'],
'dit:emailAddress':
company_referral.recipient.contact_email
or company_referral.recipient.email,
'name':
company_referral.recipient.name,
'dit:team': {
'id':
f'dit:DataHubTeam:{company_referral.recipient.dit_team.pk}',
'type': ['Group', 'dit:Team'],
'name':
company_referral.recipient.dit_team.name,
},
'dit:DataHubCompanyReferral:role':
'recipient',
},
{
'id':
f'dit:DataHubContact:{company_referral.contact.pk}',
'type': ['Person', 'dit:Contact'],
'url': company_referral.contact.get_absolute_url(),
'dit:emailAddress': company_referral.contact.email,
'dit:jobTitle': company_referral.contact.job_title,
'name': company_referral.contact.name,
},
],
'url':
company_referral.get_absolute_url(),
},
},
],
}
