def test_investment_project_syncs_when_team_member_adviser_changes(
setup_es, team_member):
"""
Tests that when an adviser that is a team member of an investment project is updated,
the related investment project is resynced.
"""
adviser = team_member.adviser
adviser.dit_team = TeamFactory()
adviser.save()
setup_es.indices.refresh()
result = get_search_by_entity_query(
term='',
filter_data={
'id': team_member.investment_project.pk
},
entity=InvestmentProject,
).execute()
assert result.hits.total == 1
assert result.hits[0]['team_members'][0]['dit_team']['id'] == str(
adviser.dit_team.id)
assert result.hits[0]['team_members'][0]['dit_team'][
'name'] == adviser.dit_team.name
def test_investment_project_team_member_deleted_sync_to_es(es_with_signals, team_member):
"""Tests if investment project gets synced to Elasticsearch when a team member is deleted."""
team_member.delete()
es_with_signals.indices.refresh()
results = get_search_by_entity_query(
InvestmentProject,
term='',
filter_data={},
).execute()
assert len(results) == 1
result = results[0]
assert len(result['team_members']) == 0
def test_investment_project_auto_updates_to_es(es_with_signals):
"""Tests if investment project gets synced to Elasticsearch."""
project = InvestmentProjectFactory()
new_test_name = 'even_harder_to_find_investment_project'
project.name = new_test_name
project.save()
es_with_signals.indices.refresh()
result = get_search_by_entity_query(
InvestmentProject,
term='',
filter_data={'name': new_test_name},
).execute()
assert result.hits.total == 1
def test_investment_project_auto_sync_to_es(es_with_signals):
"""Tests if investment project gets synced to Elasticsearch."""
test_name = 'very_hard_to_find_project'
InvestmentProjectFactory(
name=test_name,
)
es_with_signals.indices.refresh()
result = get_search_by_entity_query(
InvestmentProject,
term='',
filter_data={'name': test_name},
).execute()
assert result.hits.total == 1
def test_investment_project_team_member_added_sync_to_es(
setup_es, team_member):
"""Tests if investment project gets synced to Elasticsearch when a team member is added."""
setup_es.indices.refresh()
results = get_search_by_entity_query(
term='',
filter_data={},
entity=InvestmentProject,
).execute()
assert len(results) == 1
result = results[0]
assert len(result['team_members']) == 1
assert result['team_members'][0]['id'] == str(team_member.adviser.id)
def get_base_query(self, request, validated_data):
"""Gets a filtered Elasticsearch query for the provided search parameters."""
filter_data = self._get_filter_data(validated_data)
permission_filters = self.search_app.get_permission_filters(request)
ordering = _map_es_ordering(validated_data['sortby'], self.es_sort_by_remappings)
return get_search_by_entity_query(
self.search_app.es_model,
term=validated_data['original_query'],
filter_data=filter_data,
composite_field_mapping=self.COMPOSITE_FILTERS,
permission_filters=permission_filters,
ordering=ordering,
fields_to_include=self.fields_to_include,
fields_to_exclude=self.fields_to_exclude,
)
def test_investment_project_team_member_updated_sync_to_es(es_with_signals, team_member):
"""Tests if investment project gets synced to Elasticsearch when a team member is updated."""
new_adviser = AdviserFactory()
team_member.adviser = new_adviser
team_member.save()
es_with_signals.indices.refresh()
results = get_search_by_entity_query(
InvestmentProject,
term='',
filter_data={},
).execute()
assert len(results) == 1
result = results[0]
assert len(result['team_members']) == 1
assert result['team_members'][0]['id'] == str(new_adviser.id)
def get_base_query(self, request, validated_data):
"""Gets a filtered Elasticsearch query for the provided search parameters."""
filter_data = self._get_filter_data(validated_data)
permission_filters = self.search_app.get_permission_filters(request)
aggregation_fields = (self.REMAP_FIELDS.get(field, field)
for field in self.FILTER_FIELDS
) if self.include_aggregations else None
return get_search_by_entity_query(
entity=self.entity,
term=validated_data['original_query'],
filter_data=filter_data,
composite_field_mapping=self.COMPOSITE_FILTERS,
permission_filters=permission_filters,
ordering=validated_data['sortby'],
aggregation_fields=aggregation_fields,
)
def _get_objects(request, limit, search_app, adviser_field):
if not has_permissions_for_app(request, search_app):
return []
query = get_search_by_entity_query(
term='',
entity=search_app.es_model,
filter_data={
adviser_field: request.user.id,
'created_on_exists': True,
},
ordering='created_on:desc',
)
results = limit_search_query(
query,
offset=0,
limit=limit,
).execute()
return [result.to_dict() for result in results.hits]
def test_investment_project_syncs_when_adviser_changes(es_with_signals, field):
"""
Tests that when an adviser is updated, investment projects related to that adviser are
resynced.
"""
adviser = AdviserFactory()
project = InvestmentProjectFactory(**{field: adviser})
adviser.dit_team = TeamFactory()
adviser.save()
es_with_signals.indices.refresh()
result = get_search_by_entity_query(
InvestmentProject,
term='',
filter_data={'id': project.pk},
).execute()
assert result.hits.total == 1
assert result.hits[0][field]['dit_team']['id'] == str(adviser.dit_team.id)
assert result.hits[0][field]['dit_team']['name'] == adviser.dit_team.name
def test_get_search_by_entity_query(
term,
filter_data,
composite_field_mapping,
permission_filters,
ordering,
fields_to_include,
fields_to_exclude,
expected_query,
):
"""Tests for the get_search_by_entity_query function."""
query = get_search_by_entity_query(
SimpleModelSearchApp.es_model,
term=term,
filter_data=filter_data,
composite_field_mapping=composite_field_mapping,
permission_filters=permission_filters,
ordering=ordering,
fields_to_include=fields_to_include,
fields_to_exclude=fields_to_exclude,
)
assert query.to_dict() == expected_query
assert query._index == [SimpleModelSearchApp.es_model.get_read_alias()]
def test_get_limited_search_by_entity_query():
"""Tests search by entity."""
date = '2017-06-13T09:44:31.062870'
filter_data = {
'name': 'Woodside',
'address_country.id': ['80756b9a-5d95-e211-a939-e4115bead28a'],
'archived_before': date,
'archived_after': date,
}
query = get_search_by_entity_query(
ESContact,
term='test',
filter_data=filter_data,
)
query = limit_search_query(
query,
offset=5,
limit=5,
)
assert query.to_dict() == {
'query': {
'bool': {
'must': [
{
'term': {
'_type': 'contact',
},
},
{
'bool': {
'should': [
{
'match': {
'name.keyword': {
'query': 'test',
'boost': 2,
},
},
},
{
'multi_match': {
'query':
'test',
'fields': (
'id',
'name',
'name.trigram',
'email',
'email_alternative',
'company.name',
'company.name.trigram',
),
'type':
'cross_fields',
'operator':
'and',
},
},
],
},
},
],
'filter': [
{
'bool': {
'must': [
{
'match': {
'name': {
'query': 'Woodside',
'operator': 'and',
},
},
},
{
'bool': {
'should': [
{
'match': {
'address_country.id': {
'query':
'80756b9a-5d95-e211-a939-e4115bead28a',
'operator': 'and',
},
},
},
],
'minimum_should_match':
1,
},
},
{
'range': {
'archived': {
'gte':
'2017-06-13T09:44:31.062870',
'lte':
'2017-06-13T09:44:31.062870',
},
},
},
],
},
},
],
},
},
'sort': [
'_score',
'id',
],
'from': 5,
'size': 5,
}
def test_limited_get_search_by_entity_query():
"""Tests search by entity."""
date = '2017-06-13T09:44:31.062870'
filter_data = {
'address_town': ['Woodside'],
'trading_address_country.id': ['80756b9a-5d95-e211-a939-e4115bead28a'],
'estimated_land_date_before': date,
'estimated_land_date_after': date,
}
query = get_search_by_entity_query(
term='test',
filter_data=filter_data,
entity=ESCompany,
)
query = limit_search_query(
query,
offset=5,
limit=5,
)
assert query.to_dict() == {
'query': {
'bool': {
'must': [
{
'term': {
'_type': 'company',
},
},
{
'bool': {
'should': [
{
'match_phrase': {
'name_keyword': {
'query': 'test',
'boost': 2,
},
},
},
{
'match_phrase': {
'id': 'test',
},
},
{
'multi_match': {
'query': 'test',
'fields': (
'name',
'name_trigram',
'company_number',
'trading_name',
'trading_name_trigram',
'reference_code',
'registered_address_country.name_trigram',
'registered_address_postcode_trigram',
'trading_address_country.name_trigram',
'trading_address_postcode_trigram',
'uk_region.name_trigram',
),
'type': 'cross_fields',
'operator': 'and',
},
},
],
},
},
],
},
},
'post_filter': {
'bool': {
'must': [
{
'bool': {
'should': [
{
'match': {
'address_town': {
'query': 'Woodside',
'operator': 'and',
},
},
},
],
'minimum_should_match': 1,
},
},
{
'bool': {
'should': [
{
'match_phrase': {
'trading_address_country.id':
'80756b9a-5d95-e211-a939-e4115bead28a',
},
},
],
'minimum_should_match': 1,
},
},
{
'range': {
'estimated_land_date': {
'gte': '2017-06-13T09:44:31.062870',
'lte': '2017-06-13T09:44:31.062870',
},
},
},
],
},
},
'from': 5,
'size': 5,
'sort': [
'_score',
'id',
],
}
