def test_with_multiple_lists(self):
"""Test that deleting company from one list will not delete it from the other lists."""
company = CompanyFactory()
company_lists = CompanyListFactory.create_batch(5, adviser=self.user)
CompanyListItemFactory.create_batch(
5,
list=factory.Iterator(company_lists),
company=company,
)
# company exists on 5 user's lists
assert CompanyListItem.objects.filter(list__in=company_lists,
company=company).count() == 5
url = _get_list_item_url(company_lists[0].pk, company.pk)
response = self.api_client.delete(url)
assert response.status_code == status.HTTP_204_NO_CONTENT
assert response.content == b''
assert not CompanyListItem.objects.filter(list=company_lists[0],
company=company).exists()
# The company exists on 4 other lists
assert CompanyListItem.objects.filter(list__in=company_lists,
company=company).count() == 4
def test_with_multiple_user_lists(self):
"""Test that user who owns multiple lists can list all their contents."""
lists = CompanyListFactory.create_batch(5, adviser=self.user)
company_list_companies = {}
# add multiple companies to user's lists
for company_list in lists:
companies = CompanyFactory.create_batch(5)
company_list_companies[company_list.pk] = companies
CompanyListItemFactory.create_batch(
len(companies),
list=company_list,
company=factory.Iterator(companies),
)
# check if contents of each user's list can be listed
for company_list in lists:
url = _get_list_item_collection_url(company_list.pk)
response = self.api_client.get(url)
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
result_company_ids = {
result['company']['id']
for result in response_data['results']
}
assert result_company_ids == {
str(company.id)
for company in company_list_companies[company_list.pk]
}
def test_can_filter_by_valid_company_id(self):
"""Test that a user's lists can be filtered to those containing a particular company."""
company_to_filter_by = CompanyFactory()
# Create some lists containing `company_to_filter_by`
expected_lists = CompanyListFactory.create_batch(3, adviser=self.user)
CompanyListItemFactory.create_batch(
len(expected_lists),
list=factory.Iterator(expected_lists),
company=company_to_filter_by,
)
# Create some lists without `company_to_filter_by` that should not be returned
CompanyListFactory.create_batch(3, adviser=self.user)
response = self.api_client.get(
list_collection_url,
data={
'items__company_id': company_to_filter_by.pk,
},
)
assert response.status_code == status.HTTP_200_OK
results = response.json()['results']
assert len(results) == len(expected_lists)
expected_list_ids = {str(list_.pk) for list_ in expected_lists}
actual_list_ids = {result['id'] for result in results}
assert actual_list_ids == expected_list_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_factory(num_interactions=0,
num_contacts=0,
num_orders=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)
OrderFactory.create_batch(num_orders, company=company)
CompanyListItemFactory.create_batch(num_company_list_items,
company=company)
return company
def test_with_only_items_on_other_users_lists(self):
"""
Test that an empty list is returned if the user has no companies on their selected list,
but other users have companies on theirs.
"""
CompanyListItemFactory.create_batch(5)
company_list = CompanyListFactory(adviser=self.user)
url = _get_list_item_collection_url(company_list.pk)
response = self.api_client.get(url)
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
assert response_data['results'] == []
def test_includes_accurate_item_count(self, num_items):
"""Test that the correct item count is returned."""
company_list = CompanyListFactory(adviser=self.user)
CompanyListItemFactory.create_batch(num_items, list=company_list)
# Create some unrelated items – should not affect the count
CompanyListItemFactory.create_batch(7)
response = self.api_client.get(list_collection_url)
assert response.status_code == status.HTTP_200_OK
results = response.json()['results']
result = next(result for result in results
if result['id'] == str(company_list.pk))
assert result['item_count'] == num_items
def test_returns_no_lists_if_filtered_by_company_not_on_a_list(self):
"""
Test that no lists are returned when filtering lists by a company not on any of the
authenticated user's lists.
"""
# Create some lists and list items for the user
CompanyListItemFactory.create_batch(5, list__adviser=self.user)
# Filter by a company not on a list
response = self.api_client.get(
list_collection_url,
data={
'items__company_id': CompanyFactory().pk,
},
)
assert response.status_code == status.HTTP_200_OK
assert response.json()['results'] == []
def test_does_not_overwrite_other_items(self):
"""Test that adding an item does not overwrite other (unrelated) items."""
existing_companies = CompanyFactory.create_batch(5)
company_list = CompanyListFactory(adviser=self.user)
CompanyListItemFactory.create_batch(
5,
list=company_list,
company=factory.Iterator(existing_companies),
)
company_to_add = CompanyFactory()
url = _get_list_item_url(company_list.pk, company_to_add.pk)
response = self.api_client.put(url)
assert response.status_code == status.HTTP_204_NO_CONTENT
list_item_queryset = CompanyListItem.objects.filter(list=company_list)
companies_after = {item.company for item in list_item_queryset}
assert companies_after == {*existing_companies, company_to_add}
def _company_factory(
num_interactions=0,
num_contacts=0,
num_orders=0,
num_referrals=0,
num_company_list_items=0,
num_pipeline_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)
PipelineItemFactory.create_batch(num_pipeline_items, company=company)
return company
def test_sorting(self):
"""
Test that list items are sorted in reverse order of the date of the latest
interaction with the company.
Note that we want companies without any interactions to be sorted last.
"""
# These dates are in the order we expect them to be returned
# `None` represents a company without any interactions
interaction_dates = [
datetime(2019, 10, 8, tzinfo=utc),
datetime(2016, 9, 7, tzinfo=utc),
datetime(2009, 5, 6, tzinfo=utc),
None,
]
shuffled_dates = sample(interaction_dates, len(interaction_dates))
company_list = CompanyListFactory(adviser=self.user)
list_items = CompanyListItemFactory.create_batch(
len(interaction_dates), list=company_list)
for interaction_date, list_item in zip(shuffled_dates, list_items):
if interaction_date:
CompanyInteractionFactory(date=interaction_date,
company=list_item.company)
url = _get_list_item_collection_url(company_list.pk)
# Make sure future interactions are also sorted correctly
with freeze_time('2017-12-11 09:00:00'):
response = self.api_client.get(url)
assert response.status_code == status.HTTP_200_OK
results = response.json()['results']
assert len(results) == len(interaction_dates)
actual_interaction_dates = [
result['latest_interaction']['date']
if result['latest_interaction'] else None for result in results
]
expected_interaction_dates = [
format_date_or_datetime(date_.date()) if date_ else None
for date_ in interaction_dates
]
assert actual_interaction_dates == expected_interaction_dates
def company_with_company_list_items_factory():
"""Factory for a company that is on users' personal company lists."""
company = CompanyFactory()
CompanyListItemFactory.create_batch(3, company=company)
return company
