def test_sector_descends_filter(self, hierarchical_sectors,
es_with_collector, sector_level):
"""Test the sector_descends filter."""
num_sectors = len(hierarchical_sectors)
sectors_ids = [sector.pk for sector in hierarchical_sectors]
orders = OrderFactory.create_batch(
num_sectors,
sector_id=factory.Iterator(sectors_ids),
)
OrderFactory.create_batch(
3,
sector=factory.LazyFunction(lambda: random_obj_for_queryset(
Sector.objects.exclude(pk__in=sectors_ids), )),
)
es_with_collector.flush_and_refresh()
url = reverse('api-v3:search:order')
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(order['id']) for order in response_data['results']}
expected_ids = {order.pk for order in orders[sector_level:]}
assert actual_ids == expected_ids
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]
companies = CompanyFactory.create_batch(
num_sectors,
sector_id=factory.Iterator(sectors_ids),
)
CompanyFactory.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:company')
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(company['id']) for company in response_data['results']}
expected_ids = {company.pk for company in companies[sector_level:]}
assert actual_ids == expected_ids
def test_only_ist_interactions_are_being_selected(spi_report, ist_adviser):
"""Tests that report takes into account IST interactions only."""
investment_project = InvestmentProjectFactory(
project_manager=ist_adviser,
)
service_dates = (
(ServiceConstant.account_management.value.id, '2015-01-23'),
(
random_obj_for_queryset(Service.objects.exclude(pk__in=ALL_SPI_SERVICE_IDS)).id,
'2015-12-03',
),
(ServiceConstant.investment_enquiry_confirmed_prospect.value.id, '2016-01-02'),
(
random_obj_for_queryset(Service.objects.exclude(pk__in=ALL_SPI_SERVICE_IDS)).id,
'2016-01-02',
),
(
random_obj_for_queryset(Service.objects.exclude(pk__in=ALL_SPI_SERVICE_IDS)).id,
'2016-01-03',
),
(ServiceConstant.investment_enquiry_confirmed_prospect.value.id, '2016-01-01'),
(
random_obj_for_queryset(Service.objects.exclude(pk__in=ALL_SPI_SERVICE_IDS)).id,
'2017-01-01',
),
(ServiceConstant.investment_enquiry_assigned_to_ist_sas.value.id, '2017-01-03'),
(ServiceConstant.investment_ist_aftercare_offered.value.id, '2017-03-04'),
)
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-03T00:00:00+00:00'
assert rows[0]['Aftercare offered on'] == '2017-03-04T00:00:00+00:00'
def random_service(disabled=False):
"""Get a random service."""
# TODO: services that require interaction questions need to be excluded until the support
# is fully implemented otherwise some tests, which don't provide answers when required, will
# fail
return random_obj_for_queryset(
Service.objects.filter(
disabled_on__isnull=not disabled,
interaction_questions__isnull=True,
children__isnull=True,
),
)
def test_sector_descends_filter_for_investment_project_interaction(
self,
hierarchical_sectors,
setup_es,
sector_level,
):
"""Test the sector_descends filter with investment project interactions."""
num_sectors = len(hierarchical_sectors)
sectors_ids = [sector.pk for sector in hierarchical_sectors]
projects = ActiveInvestmentProjectFactory.create_batch(
num_sectors,
sector_id=factory.Iterator(sectors_ids),
)
investment_project_interactions = InvestmentProjectInteractionFactory.create_batch(
3,
investment_project=factory.Iterator(projects),
)
other_projects = ActiveInvestmentProjectFactory.create_batch(
3,
sector=factory.LazyFunction(lambda: random_obj_for_queryset(
Sector.objects.exclude(pk__in=sectors_ids), )),
)
InvestmentProjectInteractionFactory.create_batch(
3,
investment_project=factory.Iterator(other_projects),
)
setup_es.indices.refresh()
url = reverse('api-v3:search:interaction')
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(interaction['id'])
for interaction in response_data['results']
}
expected_ids = {
interaction.pk
for interaction in investment_project_interactions[sector_level:]
}
assert actual_ids == expected_ids
def test_company_sector_descends_filter(
self,
hierarchical_sectors,
opensearch_with_collector,
sector_level,
):
"""Test the company_sector_descends filter."""
num_sectors = len(hierarchical_sectors)
sectors_ids = [sector.pk for sector in hierarchical_sectors]
companies = CompanyFactory.create_batch(
num_sectors,
sector_id=factory.Iterator(sectors_ids),
)
contacts = ContactFactory.create_batch(
3,
company=factory.Iterator(companies),
)
other_companies = CompanyFactory.create_batch(
3,
sector=factory.LazyFunction(lambda: random_obj_for_queryset(
SectorModel.objects.exclude(pk__in=sectors_ids), )),
)
ContactFactory.create_batch(
3,
company=factory.Iterator(other_companies),
)
opensearch_with_collector.flush_and_refresh()
url = reverse('api-v3:search:contact')
body = {
'company_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.UUID(contact['id'])
for contact in response_data['results']
}
expected_ids = {contact.pk for contact in contacts[sector_level:]}
assert actual_ids == expected_ids
def _random_non_ita_one_list_tier():
queryset = OneListTier.objects.exclude(
pk=OneListTierID.tier_d_international_trade_advisers.value, )
return random_obj_for_queryset(queryset)
def test_run(s3_stubber, caplog, reset_unmatched):
"""
Test that the command updates the specified records (ignoring ones with errors).
If `reset_unmatched` is False, the existing records not in the CSV are kept untouched,
otherwise they are set to None.
"""
caplog.set_level('ERROR')
new_one_list_tier = random_obj_for_model(OneListTier)
one_list_companies = CompanyFactory.create_batch(
8,
one_list_tier=factory.LazyFunction(
lambda: random_obj_for_queryset(
OneListTier.objects.exclude(pk=new_one_list_tier.pk), ), ),
one_list_account_owner=factory.SubFactory(AdviserFactory),
)
non_one_list_companies = CompanyFactory.create_batch(
3,
one_list_tier=None,
one_list_account_owner=None,
)
for company in chain(one_list_companies, non_one_list_companies):
save_prev_fields(company, 'one_list_tier_id',
'one_list_account_owner_id')
advisers = AdviserFactory.create_batch(4)
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,one_list_tier_id,one_list_account_owner_id
00000000-0000-0000-0000-000000000000,test,test
{one_list_companies[0].pk},{one_list_companies[0].one_list_tier_id},{one_list_companies[0].one_list_account_owner_id}
{one_list_companies[1].pk},{one_list_companies[1].one_list_tier_id},{advisers[0].pk}
{one_list_companies[2].pk},{new_one_list_tier.pk},{one_list_companies[2].one_list_account_owner_id}
{one_list_companies[3].pk},null,null
{one_list_companies[4].pk},00000000-0000-0000-0000-000000000000,{advisers[1].pk}
{one_list_companies[5].pk},{new_one_list_tier.pk},00000000-0000-0000-0000-000000000000
{non_one_list_companies[0].pk},{new_one_list_tier.pk},{advisers[2].pk}
{non_one_list_companies[1].pk},00000000-0000-0000-0000-000000000000,{advisers[3].pk}
{non_one_list_companies[2].pk},{new_one_list_tier.pk},00000000-0000-0000-0000-000000000000
"""
s3_stubber.add_response(
'get_object',
{'Body': BytesIO(csv_content.encode(encoding='utf-8'))},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command('update_one_list_fields',
bucket,
object_key,
reset_unmatched=reset_unmatched)
for company in chain(one_list_companies, non_one_list_companies):
company.refresh_from_db()
# assert exceptions
assert len(caplog.records) == 5
assert 'Company matching query does not exist' in caplog.records[
0].exc_text
assert 'OneListTier matching query does not exist' in caplog.records[
1].exc_text
assert 'Advisor matching query does not exist' in caplog.records[
2].exc_text
assert 'OneListTier matching query does not exist' in caplog.records[
3].exc_text
assert 'Advisor matching query does not exist' in caplog.records[
4].exc_text
# one_list_companies[0]: nothing changed
assert_did_not_change(one_list_companies[0], 'one_list_tier_id',
'one_list_account_owner_id')
# one_list_companies[1]: only one_list_account_owner_id changed
assert_changed(one_list_companies[1], 'one_list_account_owner_id')
assert_did_not_change(one_list_companies[1], 'one_list_tier_id')
assert one_list_companies[1].one_list_account_owner == advisers[0]
# one_list_companies[2]: only one_list_tier_id changed
assert_did_not_change(one_list_companies[2], 'one_list_account_owner_id')
assert_changed(one_list_companies[2], 'one_list_tier_id')
assert one_list_companies[2].one_list_tier == new_one_list_tier
# one_list_companies[3]: all changed
assert_changed(one_list_companies[3], 'one_list_tier_id',
'one_list_account_owner_id')
assert one_list_companies[3].one_list_tier_id is None
assert one_list_companies[3].one_list_account_owner_id is None
# one_list_companies[4]: nothing changed
assert_did_not_change(one_list_companies[4], 'one_list_tier_id',
'one_list_account_owner_id')
# one_list_companies[5]: nothing changed
assert_did_not_change(one_list_companies[5], 'one_list_tier_id',
'one_list_account_owner_id')
# non_one_list_companies[0]: all changed
assert_changed(non_one_list_companies[0], 'one_list_tier_id',
'one_list_account_owner_id')
assert non_one_list_companies[0].one_list_account_owner == advisers[2]
assert non_one_list_companies[0].one_list_tier == new_one_list_tier
# non_one_list_companies[1]: nothing changed
assert_did_not_change(
non_one_list_companies[1],
'one_list_tier_id',
'one_list_account_owner_id',
)
# non_one_list_companies[2]: nothing changed
assert_did_not_change(
non_one_list_companies[2],
'one_list_tier_id',
'one_list_account_owner_id',
)
# one_list_companies[6] / [7]: if reset_unmatched == False => nothing changed else all changed
if reset_unmatched:
assert_changed(one_list_companies[6], 'one_list_tier_id',
'one_list_account_owner_id')
assert_changed(one_list_companies[7], 'one_list_tier_id',
'one_list_account_owner_id')
assert one_list_companies[6].one_list_tier is None
assert one_list_companies[6].one_list_account_owner is None
assert one_list_companies[7].one_list_tier is None
assert one_list_companies[7].one_list_account_owner is None
else:
assert_did_not_change(
one_list_companies[6],
'one_list_tier_id',
'one_list_account_owner_id',
)
assert_did_not_change(
one_list_companies[7],
'one_list_tier_id',
'one_list_account_owner_id',
)
def test_simulate(s3_stubber, caplog, reset_unmatched):
"""Test that the command simulates updates if --simulate is passed in."""
caplog.set_level('ERROR')
new_one_list_tier = random_obj_for_model(OneListTier)
one_list_companies = CompanyFactory.create_batch(
8,
one_list_tier=factory.LazyFunction(
lambda: random_obj_for_queryset(
OneListTier.objects.exclude(pk=new_one_list_tier.pk), ), ),
one_list_account_owner=factory.SubFactory(AdviserFactory),
)
non_one_list_companies = CompanyFactory.create_batch(
3,
one_list_tier=None,
one_list_account_owner=None,
)
for company in chain(one_list_companies, non_one_list_companies):
save_prev_fields(company, 'one_list_tier_id',
'one_list_account_owner_id')
advisers = AdviserFactory.create_batch(4)
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,one_list_tier_id,one_list_account_owner_id
00000000-0000-0000-0000-000000000000,test,test
{one_list_companies[0].pk},{one_list_companies[0].one_list_tier_id},{one_list_companies[0].one_list_account_owner_id}
{one_list_companies[1].pk},{one_list_companies[1].one_list_tier_id},{advisers[0].pk}
{one_list_companies[2].pk},{new_one_list_tier.pk},{one_list_companies[2].one_list_account_owner_id}
{one_list_companies[3].pk},null,null
{one_list_companies[4].pk},00000000-0000-0000-0000-000000000000,{advisers[1].pk}
{one_list_companies[5].pk},{new_one_list_tier.pk},00000000-0000-0000-0000-000000000000
{non_one_list_companies[0].pk},{new_one_list_tier.pk},{advisers[2].pk}
{non_one_list_companies[1].pk},00000000-0000-0000-0000-000000000000,{advisers[3].pk}
{non_one_list_companies[2].pk},{new_one_list_tier.pk},00000000-0000-0000-0000-000000000000
"""
s3_stubber.add_response(
'get_object',
{'Body': BytesIO(csv_content.encode(encoding='utf-8'))},
expected_params={
'Bucket': bucket,
'Key': object_key,
},
)
call_command(
'update_one_list_fields',
bucket,
object_key,
reset_unmatched=reset_unmatched,
simulate=True,
)
for company in chain(one_list_companies, non_one_list_companies):
company.refresh_from_db()
# assert exceptions
assert len(caplog.records) == 5
assert 'Company matching query does not exist' in caplog.records[
0].exc_text
assert 'OneListTier matching query does not exist' in caplog.records[
1].exc_text
assert 'Advisor matching query does not exist' in caplog.records[
2].exc_text
assert 'OneListTier matching query does not exist' in caplog.records[
3].exc_text
assert 'Advisor matching query does not exist' in caplog.records[
4].exc_text
# assert that nothing really changed
for company in chain(one_list_companies, non_one_list_companies):
assert_did_not_change(company, 'one_list_tier_id',
'one_list_account_owner_id')
def random_communication_channel(disabled=False):
"""Get a random communication channel."""
return random_obj_for_queryset(
CommunicationChannel.objects.filter(disabled_on__isnull=not disabled),
)
def _random_service(disabled=False):
return random_obj_for_queryset(
Service.objects.filter(disabled_on__isnull=not disabled), )
