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 _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, num_contacts, num_orders):
"""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)
return company
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)
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_orders_to_es_documents():
"""Test converting 2 orders to Elasticsearch documents."""
orders = OrderFactory.create_batch(2)
result = ESOrder.db_objects_to_es_documents(orders)
assert {item['_id'] for item in result} == {item.pk for item in orders}
def _company_factory(num_interactions, num_contacts, num_investment_projects, num_orders):
"""
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)
OrderFactory.create_batch(num_orders, 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 test_no_change(s3_stubber, caplog):
"""Test that the command ignores records that haven't changed
or records with incorrect current values.
"""
caplog.set_level('WARNING')
old_sectors = SectorFactory.create_batch(
3,
segment=factory.Iterator(['sector_1_old', 'sector_2_old', 'sector_3_old']),
)
orders = OrderFactory.create_batch(
3,
reference=factory.Iterator(['order_1', 'order_2', 'order_3']),
sector_id=factory.Iterator([sector.pk for sector in old_sectors]),
)
new_sectors = SectorFactory.create_batch(
3,
segment=factory.Iterator(['sector_1_new', 'sector_2_new', 'sector_3_new']),
)
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,old_sector_id,new_sector_id
{orders[0].pk},{old_sectors[0].pk},{new_sectors[0].pk}
{orders[1].pk},{old_sectors[1].pk},{old_sectors[1].pk}
{orders[2].pk},00000000-0000-0000-0000-000000000000,{new_sectors[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_order_sector', bucket, object_key)
for order in orders:
order.refresh_from_db()
assert f'Not updating order {orders[1]} as its sector has not changed' in caplog.text
assert f'Not updating order {orders[2]} as its sector has not changed' in caplog.text
assert len(caplog.records) == 2
assert [order.sector for order in orders] == [
new_sectors[0], old_sectors[1], old_sectors[2],
]
def test_non_existent_order(s3_stubber, caplog):
"""Test that the command logs an error when the order PK does not exist."""
caplog.set_level('ERROR')
old_sectors = SectorFactory.create_batch(
3,
segment=factory.Iterator(['sector_1_old', 'sector_2_old', 'sector_3_old']),
)
orders = OrderFactory.create_batch(
3,
reference=factory.Iterator(['order_1', 'order_2', 'order_3']),
sector_id=factory.Iterator([sector.pk for sector in old_sectors]),
)
new_sectors = SectorFactory.create_batch(
3,
segment=factory.Iterator(['sector_1_new', 'sector_2_new', 'sector_3_new']),
)
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,old_sector_id,new_sector_id
{orders[0].pk},{old_sectors[0].pk},{new_sectors[0].pk}
{orders[1].pk},{old_sectors[1].pk},{new_sectors[1].pk}
00000000-0000-0000-0000-000000000000,{old_sectors[2].pk},{new_sectors[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_order_sector', bucket, object_key)
for order in orders:
order.refresh_from_db()
assert 'Order matching query does not exist' in caplog.text
assert len(caplog.records) == 1
assert [order.sector for order in orders] == [
new_sectors[0], new_sectors[1], old_sectors[2],
]
def test_simulate(s3_stubber):
"""Test that the command simulates updates if --simulate is passed in."""
old_sectors = SectorFactory.create_batch(
3,
segment=factory.Iterator(['sector_1_old', 'sector_2_old', 'sector_3_old']),
)
orders = OrderFactory.create_batch(
3,
reference=factory.Iterator(['order_1', 'order_2', 'order_3']),
sector_id=factory.Iterator([sector.pk for sector in old_sectors]),
)
new_sectors = SectorFactory.create_batch(
3,
segment=factory.Iterator(['sector_1_new', 'sector_2_new', 'sector_3_new']),
)
bucket = 'test_bucket'
object_key = 'test_key'
csv_content = f"""id,old_sector_id,new_sector_id
{orders[0].pk},{old_sectors[0].pk},{new_sectors[0].pk}
{orders[1].pk},{old_sectors[1].pk},{new_sectors[1].pk}
{orders[2].pk},{old_sectors[2].pk},{new_sectors[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_order_sector', bucket, object_key, simulate=True)
for order in orders:
order.refresh_from_db()
assert [order.sector for order in orders] == old_sectors
def company_with_orders_factory():
"""Factory for a company with orders."""
company = CompanyFactory()
OrderFactory.create_batch(3, company=company)
return company
