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), )