def test_global_restricted_user_with_no_team_cannot_see_projects(self, setup_es):
"""
Checks that a restricted user that doesn't have a team cannot view projects associated
with other advisers that don't have teams.
"""
adviser_other = AdviserFactory(dit_team_id=None)
request_user = create_test_user(
permission_codenames=['view_associated_investmentproject'],
)
api_client = self.create_api_client(user=request_user)
InvestmentProjectFactory()
InvestmentProjectFactory(created_by=adviser_other)
setup_es.indices.refresh()
url = reverse('api-v3:search:basic')
response = api_client.get(
url,
data={
'term': '',
'entity': 'investment_project',
},
)
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
assert response_data['count'] == 0
def test_search_sort_desc_with_null_values(self, setup_es, setup_data):
"""Tests placement of null values in sorted results when order is descending."""
InvestmentProjectFactory(name='Ether 1', total_investment=1000)
InvestmentProjectFactory(name='Ether 2')
setup_es.indices.refresh()
term = 'Ether'
url = reverse('api-v3:search:investment_project')
response = self.api_client.post(
url,
data={
'original_query': term,
'sortby': 'total_investment:desc',
},
)
assert response.status_code == status.HTTP_200_OK
assert response.data['count'] == 2
assert [
('Ether 1', 1000),
('Ether 2', None),
] == [
(investment['name'], investment['total_investment'])
for investment in response.data['results']
]
def test_non_restricted_user_can_see_all_projects(self, setup_es, permissions):
"""Test that normal users can see all projects."""
team = TeamFactory()
team_others = TeamFactory()
adviser_1 = AdviserFactory(dit_team_id=team.id)
adviser_2 = AdviserFactory(dit_team_id=team_others.id)
request_user = create_test_user(
permission_codenames=permissions,
dit_team=team,
)
api_client = self.create_api_client(user=request_user)
iproject_1 = InvestmentProjectFactory()
iproject_2 = InvestmentProjectFactory()
InvestmentProjectTeamMemberFactory(adviser=adviser_1, investment_project=iproject_1)
InvestmentProjectTeamMemberFactory(adviser=adviser_2, investment_project=iproject_2)
setup_es.indices.refresh()
url = reverse('api-v3:search:investment_project')
response = api_client.post(url, {})
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
assert response_data['count'] == 2
assert {str(iproject_1.pk), str(iproject_2.pk)} == {
result['id'] for result in response_data['results']
}
def test_sector_descends_filter(self, hierarchical_sectors, setup_es, sector_level):
"""Test the sector_descends filter."""
num_sectors = len(hierarchical_sectors)
sectors_ids = [sector.pk for sector in hierarchical_sectors]
projects = InvestmentProjectFactory.create_batch(
num_sectors,
sector_id=factory.Iterator(sectors_ids),
)
InvestmentProjectFactory.create_batch(
3,
sector=factory.LazyFunction(lambda: random_obj_for_queryset(
Sector.objects.exclude(pk__in=sectors_ids),
)),
)
setup_es.indices.refresh()
url = reverse('api-v3:search:investment_project')
body = {
'sector_descends': hierarchical_sectors[sector_level].pk,
}
response = self.api_client.post(url, body)
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
assert response_data['count'] == num_sectors - sector_level
actual_ids = {UUID(project['id']) for project in response_data['results']}
expected_ids = {project.pk for project in projects[sector_level:]}
assert actual_ids == expected_ids
def test_audit_log(s3_stubber):
"""Test that the audit log is being created."""
investment_project = InvestmentProjectFactory()
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,createdon
{investment_project.id},2015-09-29 11:03:20.000
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(bytes(csv_content, encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_created_on', bucket, object_key)
investment_project.refresh_from_db()
assert investment_project.created_on == datetime(2015,
9,
29,
11,
3,
20,
tzinfo=utc)
versions = Version.objects.get_for_object(investment_project)
assert len(versions) == 1
assert versions[0].revision.get_comment() == 'Created On migration.'
def test_audit_log(s3_stubber):
"""Test that reversion revisions are created."""
regions = list(UKRegion.objects.all())
project_with_change = InvestmentProjectFactory(actual_uk_regions=[])
project_without_change = InvestmentProjectFactory(actual_uk_regions=regions[0:1])
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,actual_uk_regions
{project_with_change.pk},{regions[2].pk}
{project_without_change.pk},{regions[2].pk}
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(csv_content.encode(encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_actual_uk_regions', bucket, object_key)
versions = Version.objects.get_for_object(project_without_change)
assert versions.count() == 0
versions = Version.objects.get_for_object(project_with_change)
assert versions.count() == 1
assert versions[0].revision.get_comment() == 'Actual UK regions migration.'
def test_audit_log(s3_stubber):
"""Test that the audit log is being created."""
investment_project = InvestmentProjectFactory()
file_companies = CompanyFactory.create_batch(3)
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,investor_company_id,intermediate_company_id,uk_company_id,uk_company_decided
{investment_project.id},{file_companies[0].pk},{file_companies[1].pk},{file_companies[2].pk},1
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(bytes(csv_content, encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_company', bucket, object_key)
investment_project.refresh_from_db()
assert investment_project.investor_company == file_companies[0]
assert investment_project.intermediate_company == file_companies[1]
assert investment_project.uk_company == file_companies[2]
assert investment_project.uk_company_decided is True
versions = Version.objects.get_for_object(investment_project)
assert len(versions) == 1
assert versions[0].revision.get_comment() == 'Companies data migration.'
def test_restricted_user_can_only_list_associated_interactions(self):
"""
Test that a restricted user can only list interactions for associated investment
projects.
"""
creator = AdviserFactory()
requester = create_test_user(
permission_codenames=[InteractionPermission.view_associated_investmentproject],
dit_team=creator.dit_team,
)
api_client = self.create_api_client(user=requester)
company = CompanyFactory()
non_associated_project = InvestmentProjectFactory()
associated_project = InvestmentProjectFactory(created_by=creator)
CompanyInteractionFactory.create_batch(3, company=company)
CompanyInteractionFactory.create_batch(
3, investment_project=non_associated_project,
)
associated_project_interactions = CompanyInteractionFactory.create_batch(
2, investment_project=associated_project,
)
url = reverse('api-v3:interaction:collection')
response = api_client.get(url)
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
assert response_data['count'] == 2
actual_ids = {i['id'] for i in response_data['results']}
expected_ids = {str(i.id) for i in associated_project_interactions}
assert actual_ids == expected_ids
def test_audit_log(s3_stubber):
"""Test that audit log is being created."""
new_sector = SectorFactory()
investment_project = InvestmentProjectFactory()
old_sector = investment_project.sector
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,old_sector,new_sector
{investment_project.id},{old_sector.id},{new_sector.id}
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(bytes(csv_content, encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_sector', bucket, object_key)
investment_project.refresh_from_db()
assert investment_project.sector == new_sector
versions = Version.objects.get_for_object(investment_project)
assert len(versions) == 1
assert versions[0].revision.get_comment() == 'Sector migration.'
def test_audit_log(s3_stubber):
"""Test that reversion revisions are created."""
project_without_change = InvestmentProjectFactory(
actual_land_date=date(2017, 2, 2))
project_with_change = InvestmentProjectFactory(
actual_land_date=date(2017, 2, 2))
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,old_actual_land_date,new_actual_land_date
{project_without_change.pk},2017-02-24,
{project_with_change.pk},2017-02-02,2016-08-24
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(csv_content.encode(encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_actual_land_date', bucket,
object_key)
versions = Version.objects.get_for_object(project_without_change)
assert len(versions) == 0
versions = Version.objects.get_for_object(project_with_change)
assert len(versions) == 1
assert versions[0].revision.get_comment(
) == 'Actual land date migration correction.'
def test_no_project_code():
"""Tests that None is returned when a project code is not set."""
# cdms_project_code is set and removed to avoid a DH project code
# being generated
project = InvestmentProjectFactory(cdms_project_code='P-79661656')
project.cdms_project_code = None
assert project.project_code is None
def test_associated_advisers_specific_roles(field):
"""Tests that get_associated_advisers() includes advisers in specific roles."""
adviser = AdviserFactory()
factory_kwargs = {
field: adviser,
}
project = InvestmentProjectFactory(**factory_kwargs)
assert adviser in tuple(project.get_associated_advisers())
def test_simulate(s3_stubber, caplog):
"""Test that the command simulates updates if --simulate is passed in."""
caplog.set_level('ERROR')
delivery_partners = list(InvestmentDeliveryPartner.objects.all()[:10])
investment_projects = [
InvestmentProjectFactory(delivery_partners=[]),
InvestmentProjectFactory(delivery_partners=[]),
InvestmentProjectFactory(delivery_partners=delivery_partners[0:1]),
InvestmentProjectFactory(delivery_partners=delivery_partners[1:2]),
InvestmentProjectFactory(delivery_partners=[]),
]
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,delivery_partners
00000000-0000-0000-0000-000000000000,
{investment_projects[0].pk},invalid-uuid
{investment_projects[1].pk},{delivery_partners[2].pk}
{investment_projects[2].pk},"{delivery_partners[3].pk},{delivery_partners[4].pk}"
{investment_projects[3].pk},
{investment_projects[4].pk},"{delivery_partners[3].pk},{delivery_partners[4].pk}"
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(csv_content.encode(encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_delivery_partners',
bucket,
object_key,
simulate=True)
for project in investment_projects:
project.refresh_from_db()
assert 'InvestmentProject matching query does not exist' in caplog.text
assert '"invalid-uuid" is not a valid UUID.' in caplog.text
assert len(caplog.records) == 2
assert [
list(project.delivery_partners.all())
for project in investment_projects
] == [
[],
[],
delivery_partners[0:1],
delivery_partners[1:2],
[],
]
def test_run(s3_stubber, caplog):
"""Test that the command updates the specified records (ignoring ones with errors)."""
caplog.set_level('ERROR')
delivery_partners = list(InvestmentDeliveryPartner.objects.all()[:10])
investment_projects = [
InvestmentProjectFactory(delivery_partners=[]),
InvestmentProjectFactory(delivery_partners=[]),
InvestmentProjectFactory(delivery_partners=delivery_partners[0:1]),
InvestmentProjectFactory(delivery_partners=delivery_partners[1:2]),
InvestmentProjectFactory(delivery_partners=[]),
]
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,delivery_partners
00000000-0000-0000-0000-000000000000,
{investment_projects[0].pk},
{investment_projects[1].pk},{delivery_partners[2].pk}
{investment_projects[2].pk},"{delivery_partners[3].pk},{delivery_partners[4].pk}"
{investment_projects[3].pk},
{investment_projects[4].pk},"{delivery_partners[3].pk},{delivery_partners[4].pk}"
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(csv_content.encode(encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_delivery_partners', bucket,
object_key)
for project in investment_projects:
project.refresh_from_db()
assert 'InvestmentProject matching query does not exist' in caplog.text
assert len(caplog.records) == 1
assert [
list(project.delivery_partners.all())
for project in investment_projects
] == [
[],
delivery_partners[2:3],
delivery_partners[0:1],
delivery_partners[1:2],
delivery_partners[3:5],
]
def test_assigning_non_ist_project_manager_doesnt_end_spi2(spi_report):
"""Test that non IST project manager wont end SPI 2."""
investment_project = InvestmentProjectFactory()
# saving separately so that project_manager_first_assigned_on is updated
investment_project.project_manager = AdviserFactory()
investment_project.save()
rows = list(spi_report.rows())
assert len(rows) == 1
assert 'Project manager assigned' not in rows[0]
def test_assigning_ist_project_manager_ends_spi2(spi_report, ist_adviser):
"""Test if assigning IST project manager would end SPI 2."""
investment_project = InvestmentProjectFactory()
# saving separately so that project_manager_first_assigned_on is updated
investment_project.project_manager = ist_adviser
investment_project.save()
rows = list(spi_report.rows())
assert len(rows) == 1
assigned_on = investment_project.project_manager_first_assigned_on
assert rows[0]['Project manager assigned'] == assigned_on.isoformat()
def setup_data(setup_es):
"""Sets up data for the tests."""
investment_projects = [
InvestmentProjectFactory(
name='abc defg',
description='investmentproject1',
estimated_land_date=datetime.date(2011, 6, 13),
actual_land_date=datetime.date(2010, 8, 13),
investor_company=CompanyFactory(
registered_address_country_id=constants.Country.united_states.value.id,
),
status=InvestmentProject.STATUSES.ongoing,
uk_region_locations=[
constants.UKRegion.east_midlands.value.id,
constants.UKRegion.isle_of_man.value.id,
],
),
InvestmentProjectFactory(
name='delayed project',
description='investmentproject2',
estimated_land_date=datetime.date(2057, 6, 13),
actual_land_date=datetime.date(2047, 8, 13),
investor_company=CompanyFactory(
registered_address_country_id=constants.Country.japan.value.id,
),
project_manager=AdviserFactory(),
project_assurance_adviser=AdviserFactory(),
fdi_value_id=constants.FDIValue.higher.value.id,
status=InvestmentProject.STATUSES.delayed,
uk_region_locations=[
constants.UKRegion.north_west.value.id,
],
),
InvestmentProjectFactory(
name='won project',
description='investmentproject3',
estimated_land_date=datetime.date(2027, 9, 13),
actual_land_date=datetime.date(2022, 11, 13),
investor_company=CompanyFactory(
registered_address_country_id=constants.Country.united_kingdom.value.id,
),
project_manager=AdviserFactory(),
project_assurance_adviser=AdviserFactory(),
fdi_value_id=constants.FDIValue.higher.value.id,
status=InvestmentProject.STATUSES.won,
uk_region_locations=[
constants.UKRegion.north_west.value.id,
],
),
]
setup_es.indices.refresh()
yield investment_projects
def test_run(s3_stubber):
"""Test that the command updates the relevant records ignoring ones with errors."""
sectors = SectorFactory.create_batch(5)
investment_projects = [
# investment project in CSV doesn't exist so row should fail
# sector should get updated
InvestmentProjectFactory(sector_id=sectors[0].id),
# sector should get updated
InvestmentProjectFactory(sector_id=None),
# sector should not get updated
InvestmentProjectFactory(sector_id=None),
# should be ignored
InvestmentProjectFactory(sector_id=sectors[3].id),
# should be skipped because of an error
InvestmentProjectFactory(sector_id=sectors[4].id),
]
new_sectors = SectorFactory.create_batch(5)
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,old_sector,new_sector
00000000-0000-0000-0000-000000000000,NULL,NULL
{investment_projects[0].id},{sectors[0].id},{new_sectors[0].id}
{investment_projects[1].id},NULL,{new_sectors[1].id}
{investment_projects[2].id},{new_sectors[2].id},{new_sectors[2].id}
{investment_projects[4].id},invalid_id,another_invalid_id
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(bytes(csv_content, encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_sector', bucket, object_key)
for investment_project in investment_projects:
investment_project.refresh_from_db()
assert investment_projects[0].sector == new_sectors[0]
assert investment_projects[1].sector == new_sectors[1]
assert investment_projects[2].sector is None
assert investment_projects[3].sector == sectors[3]
assert investment_projects[4].sector == sectors[4]
def setup_data():
"""Sets up the data and makes the ES client available."""
ContactFactory(
first_name='abc',
last_name='defg',
company=CompanyFactory(name='name0'),
)
ContactFactory(
first_name='first',
last_name='last',
company=CompanyFactory(name='name1'),
)
InvestmentProjectFactory(
name='abc defg',
description='investmentproject1',
estimated_land_date=datetime.datetime(2011, 6, 13, 9, 44, 31, 62870),
project_manager=AdviserFactory(first_name='name 0', last_name='surname 0'),
project_assurance_adviser=AdviserFactory(first_name='name 1', last_name='surname 1'),
investor_company=CompanyFactory(name='name3'),
client_relationship_manager=AdviserFactory(first_name='name 2', last_name='surname 2'),
referral_source_adviser=AdviserFactory(first_name='name 3', last_name='surname 3'),
client_contacts=[],
)
InvestmentProjectFactory(
description='investmentproject2',
estimated_land_date=datetime.datetime(2057, 6, 13, 9, 44, 31, 62870),
project_manager=AdviserFactory(first_name='name 4', last_name='surname 4'),
project_assurance_adviser=AdviserFactory(first_name='name 5', last_name='surname 5'),
investor_company=CompanyFactory(name='name4'),
client_relationship_manager=AdviserFactory(first_name='name 6', last_name='surname 6'),
referral_source_adviser=AdviserFactory(first_name='name 7', last_name='surname 7'),
client_contacts=[],
)
country_uk = constants.Country.united_kingdom.value.id
country_us = constants.Country.united_states.value.id
CompanyFactory(
name='abc defg ltd',
trading_address_1='1 Fake Lane',
trading_address_town='Downtown',
trading_address_country_id=country_uk,
)
CompanyFactory(
name='abc defg us ltd',
trading_address_1='1 Fake Lane',
trading_address_town='Downtown',
trading_address_country_id=country_us,
registered_address_country_id=country_us,
)
def test_run(s3_stubber):
"""Test that the command updates the relevant records ignoring ones with errors."""
investment_projects = [
# investment project in CSV doesn't exist so row should fail
# created_on should get updated
InvestmentProjectFactory(),
# should be ignored
InvestmentProjectFactory(),
# date in the file is invalid so it should fail
InvestmentProjectFactory(),
]
created_on_dates = [ip.created_on for ip in investment_projects]
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,createdon
00000000-0000-0000-0000-000000000000,2016-09-29 14:03:20.000
{investment_projects[0].id},2015-09-29 11:03:20.000
{investment_projects[2].id},invalid_date
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(bytes(csv_content, encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_created_on', bucket, object_key)
for investment_project in investment_projects:
investment_project.refresh_from_db()
assert investment_projects[0].created_on == datetime(2015,
9,
29,
11,
3,
20,
tzinfo=utc)
assert investment_projects[1].created_on == created_on_dates[1]
assert investment_projects[2].created_on == created_on_dates[2]
def test_earliest_interactions_are_being_selected(spi_report, ist_adviser):
"""Tests that report contains earliest interaction dates."""
investment_project = InvestmentProjectFactory(
project_manager=ist_adviser, )
service_dates = (
(Service.investment_enquiry_confirmed_prospect.value.id, '2016-01-02'),
(Service.investment_enquiry_confirmed_prospect.value.id, '2016-01-03'),
(Service.investment_enquiry_confirmed_prospect.value.id, '2016-01-01'),
(Service.investment_enquiry_assigned_to_ist_sas.value.id,
'2017-01-03'),
(Service.investment_enquiry_assigned_to_ist_sas.value.id,
'2017-01-01'),
(Service.investment_enquiry_assigned_to_ist_sas.value.id,
'2017-01-02'),
(Service.investment_ist_aftercare_offered.value.id, '2017-03-04'),
(Service.investment_ist_aftercare_offered.value.id, '2017-03-05'),
(Service.investment_ist_aftercare_offered.value.id, '2017-03-06'),
)
for service_date in service_dates:
with freeze_time(service_date[1]):
InvestmentProjectInteractionFactory(
investment_project=investment_project,
service_id=service_date[0],
)
rows = list(spi_report.rows())
assert len(rows) == 1
assert rows[0]['Enquiry processed'] == '2016-01-01T00:00:00+00:00'
assert rows[0]['Assigned to IST'] == '2017-01-01T00:00:00+00:00'
assert rows[0]['Aftercare offered on'] == '2017-03-04T00:00:00+00:00'
def test_restricted_user_can_update_associated_investment_project_interaction(self):
"""
Test that a restricted user can update an interaction for an associated investment project.
"""
project_creator = AdviserFactory()
project = InvestmentProjectFactory(created_by=project_creator)
interaction = CompanyInteractionFactory(
subject='I am a subject',
investment_project=project,
)
requester = create_test_user(
permission_codenames=[
InteractionPermission.change_associated_investmentproject,
],
dit_team=project_creator.dit_team,
)
api_client = self.create_api_client(user=requester)
url = reverse('api-v3:interaction:item', kwargs={'pk': interaction.pk})
response = api_client.patch(
url,
data={
'subject': 'I am another subject',
},
)
assert response.status_code == status.HTTP_200_OK
assert response.data['subject'] == 'I am another subject'
def test_simulate(s3_stubber):
"""Test that the command only simulates the actions if --simulate is passed in."""
investment_projects = InvestmentProjectFactory.create_batch(2)
old_comments = [ip.comments for ip in investment_projects]
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""Id,comments
{investment_projects[0].id},Comment 1
{investment_projects[1].id},Comment 2
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(bytes(csv_content, encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_comments',
bucket,
object_key,
simulate=True)
for investment_project in investment_projects:
investment_project.refresh_from_db()
assert investment_projects[0].comments == old_comments[0]
assert investment_projects[1].comments == old_comments[1]
def test_audit_log(s3_stubber):
"""Test that reversion revisions are created."""
investment_projects = InvestmentProjectFactory.create_batch(2)
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""Id,comments
{investment_projects[0].id},Comment 1
"""
s3_stubber.add_response(
'get_object',
{
'Body': BytesIO(csv_content.encode(encoding='utf-8')),
},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_investment_project_comments', bucket, object_key)
versions = Version.objects.get_for_object(investment_projects[0])
assert len(versions) == 1
assert versions[0].revision.get_comment() == 'Comments migration.'
versions = Version.objects.get_for_object(investment_projects[1])
assert len(versions) == 0
def test_investor_company_country_valid():
"""
Tests client_relationship_manager_team for a project with a client relationship
manager.
"""
project = InvestmentProjectFactory()
assert project.investor_company_country
def test_investor_company_country_none():
"""
Tests client_relationship_manager_team for a project without a client relationship
manager.
"""
project = InvestmentProjectFactory(investor_company=None)
assert project.investor_company_country is None
def test_client_relationship_manager_team_valid():
"""
Tests client_relationship_manager_team for a project with a client relationship
manager.
"""
project = InvestmentProjectFactory()
assert project.client_relationship_manager_team
def test_client_relationship_manager_team_none():
"""
Tests client_relationship_manager_team for a project without a client relationship
manager.
"""
project = InvestmentProjectFactory(client_relationship_manager=None)
assert project.client_relationship_manager_team is None
def test_basic_search_aggregations(self, setup_es, setup_data):
"""Tests basic aggregate query."""
company = CompanyFactory(name='very_unique_company')
ContactFactory(company=company)
InvestmentProjectFactory(investor_company=company)
setup_es.indices.refresh()
term = 'very_unique_company'
url = reverse('api-v3:search:basic')
response = self.api_client.get(
url,
data={
'term': term,
'entity': 'company',
},
)
assert response.status_code == status.HTTP_200_OK
assert response.data['count'] == 1
assert response.data['results'][0]['name'] == 'very_unique_company'
aggregations = [
{'count': 1, 'entity': 'company'},
{'count': 1, 'entity': 'contact'},
{'count': 1, 'entity': 'investment_project'},
]
assert all(aggregation in response.data['aggregations'] for aggregation in aggregations)
def test_basic_search_no_permissions(self, setup_es):
"""Tests model permissions enforcement in basic search for a user with no permissions."""
user = create_test_user(permission_codenames=[], dit_team=TeamFactory())
api_client = self.create_api_client(user=user)
InvestmentProjectFactory(created_by=user)
CompanyFactory()
ContactFactory()
EventFactory()
CompanyInteractionFactory()
OrderFactory()
setup_es.indices.refresh()
url = reverse('api-v3:search:basic')
response = api_client.get(
url,
data={
'term': '',
'entity': 'company',
},
)
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
assert response_data['count'] == 0
assert len(response_data['aggregations']) == 0
