def handle(self, *args, **options):
for i in range(30):
factories.CompanyFactory(
name='Aardvark limited {}'.format(i),
description='Providing the power and beauty of Aardvarks.',
summary='Like an Aardvark',
is_published_investment_support_directory=True,
is_published_find_a_supplier=True,
keywords='Ants, Tongue, Anteater',
)
factories.CompanyFactory(
name='Wolf limited {}'.format(i),
description='Providing the stealth and prowess of wolves.',
summary='Hunts in packs',
is_published_investment_support_directory=True,
is_published_find_a_supplier=True,
keywords='Packs, Hunting, Stark, Teeth',
)
factories.CompanyFactory(
name='Grapeshot limited {}'.format(i),
description='Providing the destructiveness of grapeshot.',
summary='Like naval warfare',
is_published_investment_support_directory=True,
keywords='Pirates, Ocean, Ship',
)
for i in range(10):
gold_company = factories.CompanyFactory(
name='Gold limited {}'.format(i),
description='Providing the richness of gold.',
summary='Golden',
is_published_investment_support_directory=True,
is_published_find_a_supplier=True,
keywords='Rich, Gold, Bank, Shiny',
)
for j in range(5):
factories.CompanyCaseStudyFactory(
company=gold_company,
title='Thick case study {}'.format(j),
description='Gold is delicious.'
)
lead_company = factories.CompanyFactory(
name='Lead group {}'.format(i),
description='Providing the density of lead.',
summary='Radiation protection',
is_published_investment_support_directory=True,
is_published_find_a_supplier=True,
keywords='Packs, Thick, Heavy, Metal',
)
for j in range(5):
factories.CompanyCaseStudyFactory(
company=lead_company,
title='Thick case study {}'.format(j),
description='We determined lead sinks in water.'
)
def test_store_date_published_published_fab_company_with_date():
expected_date = timezone.now()
company = factories.CompanyFactory(is_published_find_a_supplier=True,
date_published=expected_date)
assert company.date_published == expected_date
def test_letter_sent(mock_send_letter, settings):
settings.FEATURE_VERIFICATION_LETTERS_ENABLED = True
company = factories.CompanyFactory(verification_code='test')
assert mock_send_letter.call_count == 1
assert mock_send_letter.call_args == mock.call(
company=company, form_url='send_first_verification_letter')
def test_send_letter_stannp(mock_stannp_client, settings):
settings.FEATURE_VERIFICATION_LETTERS_VIA_GOVNOTIFY_ENABLED = False
company = factories.CompanyFactory(verification_code='test')
utils.send_verification_letter(company)
mock_stannp_client.send_letter.assert_called_with(recipient={
'postal_full_name':
company.postal_full_name,
'address_line_1':
company.address_line_1,
'address_line_2':
company.address_line_2,
'locality':
company.locality,
'country':
company.country,
'postal_code':
company.postal_code,
'po_box':
company.po_box,
'custom_fields': [('full_name', company.postal_full_name),
('company_name', company.name),
('verification_code', company.verification_code),
('date', datetime.date.today().strftime('%d/%m/%Y')),
('company', company.name)]
},
template='debug')
company.refresh_from_db()
assert company.is_verification_letter_sent
assert company.date_verification_letter_sent == timezone.now()
def test_elasticsearch_migrate_turned_off(settings):
settings.FEATURE_FLAG_ELASTICSEARCH_REBUILD_INDEX = False
published_company = factories.CompanyFactory(
is_published_find_a_supplier=True)
published_investment_support_directory = factories.CompanyFactory(
is_published_investment_support_directory=True, )
CompanyDocument.get(id=published_company.pk, ignore=404).delete()
CompanyDocument.get(id=published_investment_support_directory.pk,
ignore=404).delete()
management.call_command('elasticsearch_migrate')
assert CompanyDocument.get(id=published_investment_support_directory.pk,
ignore=404) is None
assert CompanyDocument.get(id=published_company.pk, ignore=404) is None
def test_get_published_companies_check_response_contents(
authed_client, authed_supplier):
name = 'Test Company'
number = '12345678'
email = '*****@*****.**'
sectors = ['AEROSPACE', 'AUTOMOTIVE', 'BIOTECHNOLOGY_AND_PHARMACEUTICALS']
employees = '1-10'
website = 'http://test.com'
keywords = 'keyword1,keyword2,keyword3'
facebook_url = 'http://www.facebook.com/testcompany'
linkedin_url = 'http://www.linkedin.com/testcompany'
twitter_url = 'http://www.twitter.com/testcompany'
summary = 'few words about our company'
description = 'we sell cars'
is_uk_isd_company = True
is_published_investment_support_directory = True
is_published_find_a_supplier = True
expected_number_of_results = 1
expected_number_of_keys = 15
company = factories.CompanyFactory(
name=name,
number=number,
email_address=email,
sectors=sectors,
employees=employees,
website=website,
keywords=keywords,
facebook_url=facebook_url,
linkedin_url=linkedin_url,
twitter_url=twitter_url,
summary=summary,
description=description,
is_uk_isd_company=is_uk_isd_company,
is_published_find_a_supplier=is_published_find_a_supplier,
is_published_investment_support_directory=(
is_published_investment_support_directory),
)
authed_supplier.company = company
authed_supplier.save()
company.refresh_from_db()
url = reverse('published_companies')
response = authed_client.get(url)
assert len(response.json()) == expected_number_of_results
found_company = response.json()[0]
assert len(found_company.keys()) == expected_number_of_keys
assert found_company['name'] == name
assert found_company['number'] == number
assert found_company['company_email'] == email
assert found_company['sectors'] == sectors
assert found_company['employees'] == employees
assert found_company['keywords'] == keywords
assert found_company['website'] == website
assert found_company['facebook_url'] == facebook_url
assert found_company['twitter_url'] == twitter_url
assert found_company['linkedin_url'] == linkedin_url
assert found_company['summary'] == summary
assert found_company['description'] == description
assert found_company['is_uk_isd_company']
assert found_company['is_published_find_a_supplier']
assert found_company['is_published_investment_support_directory']
def test_check_contents_of_get_existing_company_by_ch_id(
authed_client, authed_supplier):
email_address = '*****@*****.**'
verification_code = '1234567890'
company = factories.CompanyFactory(
name='Test Company',
date_of_creation=datetime.date(2000, 10, 10),
email_address='*****@*****.**',
verification_code=verification_code,
is_verification_letter_sent=False,
is_uk_isd_company=True,
is_published_find_a_supplier=False,
is_published_investment_support_directory=False,
)
authed_supplier.company = company
authed_supplier.save()
company.refresh_from_db()
assert company.verification_code
url = reverse('company_by_ch_id',
kwargs={'ch_id': authed_supplier.company.number})
response = authed_client.get(url)
assert 'letter_verification_code' in response.json()
assert response.json()['company_email'] == email_address
assert response.json()['letter_verification_code'] == verification_code
assert not response.json()['is_verification_letter_sent']
assert response.json()['is_uk_isd_company']
assert not response.json()['is_published_find_a_supplier']
assert not response.json()['is_published_investment_support_directory']
def test_sends_verification_letter_stannp_post_save(settings):
settings.FEATURE_VERIFICATION_LETTERS_ENABLED = True
with mock.patch('requests.post') as requests_mock:
company = factories.CompanyFactory()
company.refresh_from_db()
assert company.verification_code
requests_mock.assert_called_once_with(
'https://dash.stannp.com/api/v1/letters/create',
auth=('debug', ''),
data={
'test': True,
'recipient[company_name]': company.name,
'recipient[country]': company.country,
'recipient[date]': datetime.date.today().strftime('%d/%m/%Y'),
'recipient[address1]': company.address_line_1,
'recipient[full_name]': company.postal_full_name,
'recipient[city]': company.locality,
'recipient[company]': company.name,
'recipient[postcode]': company.postal_code,
'recipient[title]': company.postal_full_name,
'recipient[address2]': company.address_line_2,
'recipient[verification_code]': company.verification_code,
'template': 'debug'
},
)
def test_send_registration_letter_govnotify(mock_govnotify_letter_action,
settings):
settings.FEATURE_REGISTRATION_LETTERS_ENABLED = True
company = factories.CompanyFactory()
assert mock_govnotify_letter_action.call_count == 1
expected = {
'data': {
'address_line_1': company.name,
'address_line_2': company.address_line_1,
'address_line_3': company.address_line_2,
'address_line_4': company.locality,
'address_line_5': company.country,
'address_line_6': company.po_box,
'postcode': company.postal_code,
'full_name': company.postal_full_name,
'company_name': company.name,
},
'meta': {
'action_name': 'gov-notify-letter',
'form_url': 'send_company_claimed_letter_automatically_sent',
'sender': {},
'spam_control': {},
'template_id': settings.GOVNOTIFY_REGISTRATION_LETTER_TEMPLATE_ID,
}
}
assert mock_govnotify_letter_action.call_args == mock.call(expected)
company.refresh_from_db()
assert company.is_registration_letter_sent
assert company.date_registration_letter_sent == timezone.now()
def test_does_not_overwrite_verification_code_if_already_set(settings):
settings.FEATURE_VERIFICATION_LETTERS_ENABLED = True
with mock.patch('requests.post'):
company = factories.CompanyFactory(verification_code='test')
company.refresh_from_db()
assert company.verification_code == 'test'
def test_company_doc_type_single_sector():
company = factories.CompanyFactory(date_of_creation=datetime.date(
2000, 10, 10),
sectors=['AEROSPACE'])
doc = search.company_model_to_doc_type(company)
assert doc.to_dict()['has_single_sector'] is True
def test_delete_unpublished_fab_company_from_elasticsearch():
company = factories.CompanyFactory(is_published_find_a_supplier=False)
company_pk = company.pk
company.delete()
with pytest.raises(elasticsearch.exceptions.NotFoundError):
CompanyDocument.get(id=company_pk)
def test_save_company_changes_to_elasticsearch(
is_published_find_a_supplier,
call_count,
mock_elasticsearch_company_save,
):
factories.CompanyFactory(
is_published_find_a_supplier=(is_published_find_a_supplier))
assert mock_elasticsearch_company_save.call_count == call_count
def test_does_not_send_verification_if_letter_already_sent(
mock_send_letter, settings):
settings.FEATURE_VERIFICATION_LETTERS_ENABLED = True
factories.CompanyFactory(
is_verification_letter_sent=True,
verification_code='test',
)
mock_send_letter.assert_not_called()
def test_company_doc_type_single_sector_non_local_storage(settings):
settings.STORAGE_CLASS_NAME = 'default'
company = factories.CompanyFactory()
logo_mock = PropertyMock(return_value=Mock(url='http://media.com/a.jpg'))
with patch.object(company, 'logo', new_callable=logo_mock):
doc = documents.company_model_to_document(company)
assert doc.to_dict()['logo'] == 'http://media.com/a.jpg'
def test_sends_registration_letter_post_save(
mock_utils_send_registration_letter, settings):
settings.FEATURE_REGISTRATION_LETTERS_ENABLED = True
company = factories.CompanyFactory()
assert mock_utils_send_registration_letter.call_count == 1
assert mock_utils_send_registration_letter.call_args == mock.call(
company=company,
form_url='send_company_claimed_letter_automatically_sent',
)
def test_delete_unpublish_isd_company_from_elasticsearch():
company = factories.CompanyFactory(is_published_find_a_supplier=True)
company_pk = company.pk
CompanyDocument.get(id=company_pk) # not raises if exists
company.is_published_find_a_supplier = False
company.save()
with pytest.raises(elasticsearch.exceptions.NotFoundError):
CompanyDocument.get(id=company_pk)
def test_get_published_companies_use_optional_filters(
authed_client, limit, minimal_number_of_sectors,
expected_number_of_results):
sectors_1 = ['AEROSPACE', 'AUTOMOTIVE', 'DEFENCE']
sectors_2 = ['AEROSPACE', 'AUTOMOTIVE']
company_1 = factories.CompanyFactory(
is_published_investment_support_directory=True, sectors=sectors_1)
company_2 = factories.CompanyFactory(
is_published_investment_support_directory=True, sectors=sectors_2)
supplier_1 = SupplierFactory.create(sso_id=777)
supplier_2 = SupplierFactory.create(sso_id=888)
supplier_1.company = company_1
supplier_1.save()
supplier_2.company = company_2
supplier_2.save()
url = reverse('published_companies')
params = {}
if limit is not None:
params.update({'limit': limit})
if minimal_number_of_sectors is not None:
params.update({'minimal_number_of_sectors': minimal_number_of_sectors})
response = authed_client.get(url, data=params)
assert len(response.json()) == expected_number_of_results
def create(self, validated_data):
number = f'AT{random.randint(0, 999999):06}'
countries = self.slice_choices(choices.COUNTRY_CHOICES, max_items=15)
languages = self.slice_choices(choices.EXPERTISE_LANGUAGES,
max_items=15)
regions = self.slice_choices(choices.EXPERTISE_REGION_CHOICES,
max_items=5)
industries = random.sample([
item for item in dir(sectors)
if not item.startswith('__') and item != sectors.CONFLATED
], random.randint(0, 10))
wolf_company = factories.CompanyFactory(
number=number,
name=f'Automated tests {number}',
description='Delete at will',
summary='Hunts in packs common',
is_uk_isd_company=validated_data.get('is_uk_isd_company', True),
is_published_investment_support_directory=False,
is_published_find_a_supplier=False,
keywords='Automated tests, Packs, Hunting, Stark, Teeth',
expertise_industries=industries,
expertise_regions=regions,
expertise_languages=languages,
expertise_countries=countries,
expertise_products_services={
'other': ['Regulatory', 'Finance', 'IT'],
'Finance':
self.slice_list(expertise.FINANCIAL),
'Management Consulting':
self.slice_list(expertise.MANAGEMENT_CONSULTING),
'Human Resources':
self.slice_list(expertise.HUMAN_RESOURCES),
'Legal':
self.slice_list(expertise.LEGAL),
'Publicity':
self.slice_list(expertise.PUBLICITY),
'Business Support':
self.slice_list(expertise.BUSINESS_SUPPORT),
},
website=f'https://automated.tests.{number}.com',
email_address='',
email_full_name='',
slug=f'auto-tests-isd-company-{number}',
twitter_url=f'http://twitter.com/automated-tests-{number}',
facebook_url=f'http://facebook.com/automated-tests-{number}',
linkedin_url=f'http://linkedin.com/automated-tests-{number}',
)
return wolf_company
def test_extract_recipient_address_gov_notify():
company = factories.CompanyFactory()
recipient = utils.extract_recipient_address_gov_notify(company=company)
assert recipient == {
'address_line_1': company.postal_full_name,
'address_line_2': company.address_line_1,
'address_line_3': company.address_line_2,
'address_line_4': company.locality,
'address_line_5': company.country,
'address_line_6': company.po_box,
'postcode': company.postal_code,
'full_name': company.postal_full_name,
'company_name': company.name,
}
def test_extract_expertise_parser():
company = factories.CompanyFactory(
expertise_languages=['ab', 'aa', 'it', 'made-up'],
expertise_industries=['ADVANCED_MANUFACTURING', 'AIRPORTS'],
expertise_regions=['NORTH_EAST', 'SOUTH_EAST'],
expertise_countries=['PT', 'RU'],
pk=1,
)
company_data_dict = serializers.CompanySerializer(company).data
expected_values = [
'Advanced manufacturing', 'Airports', 'North East', 'South East',
'Portugal', 'Russia', 'Abkhazian', 'Afar', 'Italian'
]
company_parser = CompanyParser(company_data_dict)
expertise_search_labels = company_parser.expertise_labels_for_search
assert expertise_search_labels == expected_values
def test_does_not_send_registration_letter_conditions(
mock_utils_send_registration_letter,
letter_registration_enabled,
is_registration_letter_sent,
company_type,
address_line_1,
postal_code,
settings,
):
settings.FEATURE_REGISTRATION_LETTERS_ENABLED = letter_registration_enabled
company = factories.CompanyFactory(
is_registration_letter_sent=is_registration_letter_sent,
company_type=company_type,
address_line_1=address_line_1,
postal_code=postal_code,
)
assert mock_utils_send_registration_letter.call_count == 0
company.refresh_from_db()
assert company.is_verification_letter_sent is False
assert company.date_verification_letter_sent is None
def test_send_verification_letter_govnotify(mock_govnotify_letter_action,
settings):
settings.FEATURE_VERIFICATION_LETTERS_VIA_GOVNOTIFY_ENABLED = True
company = factories.CompanyFactory(verification_code='999999999999')
utils.send_verification_letter(company=company, form_url='test_letter')
assert mock_govnotify_letter_action.call_count == 1
expected = {
'data': {
'address_line_1': company.postal_full_name,
'address_line_2': company.address_line_1,
'address_line_3': company.address_line_2,
'address_line_4': company.locality,
'address_line_5': company.country,
'address_line_6': company.po_box,
'postcode': company.postal_code,
'full_name': company.postal_full_name,
'company_name': company.name,
'verification_code': company.verification_code,
},
'meta': {
'action_name': 'gov-notify-letter',
'form_url': 'test_letter',
'sender': {},
'spam_control': {},
'template_id': settings.GOVNOTIFY_VERIFICATION_LETTER_TEMPLATE_ID,
}
}
assert mock_govnotify_letter_action.call_args == mock.call(expected)
company.refresh_from_db()
assert company.is_verification_letter_sent
assert company.date_verification_letter_sent == timezone.now()
def test_unknown_address_not_send_letters(mock_send_letter, settings):
settings.FEATURE_VERIFICATION_LETTERS_ENABLED = True
factories.CompanyFactory()
mock_send_letter.send_letter.assert_not_called()
def test_company_doc_type():
company = factories.CompanyFactory(date_of_creation=datetime.date(
2000, 10, 10),
sectors=['AEROSPACE', 'AIRPORTS'])
case_study = factories.CompanyCaseStudyFactory(company=company)
doc = search.company_model_to_doc_type(company)
expected = {
'date_of_creation':
'2000-10-10',
'description':
company.description,
'employees':
company.employees,
'facebook_url':
company.facebook_url,
'pk':
str(company.pk),
'keywords':
company.keywords,
'linkedin_url':
company.linkedin_url,
'logo':
'',
'modified':
'2016-11-23T11:21:10.977518Z',
'name':
company.name,
'number':
company.number,
'sectors':
company.sectors,
'sectors_label': ['Aerospace', 'Airports'],
'slug':
company.slug,
'summary':
company.summary,
'has_single_sector':
False,
'supplier_case_studies': [{
'description': case_study.description,
'image_one_caption': case_study.image_one_caption,
'image_three_caption': case_study.image_three_caption,
'image_two_caption': case_study.image_two_caption,
'keywords': case_study.keywords,
'pk': case_study.pk,
'sector': case_study.sector,
'short_summary': case_study.short_summary,
'slug': case_study.slug,
'testimonial': case_study.testimonial,
'testimonial_company': case_study.testimonial_company,
'testimonial_job_title': case_study.testimonial_job_title,
'testimonial_name': case_study.testimonial_name,
'title': case_study.title,
'website': case_study.website,
}],
'twitter_url':
company.twitter_url,
'website':
company.website,
}
assert doc.to_dict() == expected
assert doc.meta.id == company.pk
def test_company_doc_type():
company = factories.CompanyFactory(date_of_creation=datetime.date(
2000, 10, 10),
sectors=['AEROSPACE', 'AIRPORTS'])
case_study = factories.CompanyCaseStudyFactory(company=company)
logo_mock = PropertyMock(return_value=Mock(url='/media/thing.jpg'))
with patch.object(company, 'logo', new_callable=logo_mock):
doc = documents.company_model_to_document(company)
company_data_dict = serializers.CompanySerializer(company).data
company_parser = helpers.CompanyParser(company_data_dict)
expected_expertise_products_services = []
for key, values in company.expertise_products_services.items():
expected_expertise_products_services += values
expected = {
'date_of_creation':
date_to_fakedate(company.date_of_creation),
'description':
company.description,
'employees':
company.employees,
'facebook_url':
company.facebook_url,
'pk':
str(company.pk),
'keywords':
company.keywords,
'linkedin_url':
company.linkedin_url,
'logo':
'http://0.0.0.0:8000/media/thing.jpg',
'modified':
datetime_to_fakedatetime(company.modified),
'name':
company.name,
'number':
company.number,
'has_description':
True,
'sectors':
company.sectors,
'expertise_industries':
company.expertise_industries,
'expertise_regions':
company.expertise_regions,
'expertise_languages':
company.expertise_languages,
'expertise_countries':
company.expertise_countries,
'expertise_products_services':
company.expertise_products_services,
'expertise_products_services_labels':
(expected_expertise_products_services),
'sectors_label': ['Aerospace', 'Airports'],
'expertise_labels':
company_parser.expertise_labels_for_search,
'slug':
company.slug,
'summary':
company.summary,
'case_study_count':
1,
'has_single_sector':
False,
'is_showcase_company':
False,
'is_published_find_a_supplier':
False,
'is_published_investment_support_directory':
False,
'company_type':
'COMPANIES_HOUSE',
'supplier_case_studies': [{
'description': case_study.description,
'image_one_caption': case_study.image_one_caption,
'image_three_caption': case_study.image_three_caption,
'image_two_caption': case_study.image_two_caption,
'keywords': case_study.keywords,
'pk': case_study.pk,
'sector': case_study.sector,
'short_summary': case_study.short_summary,
'slug': case_study.slug,
'testimonial': case_study.testimonial,
'testimonial_company': case_study.testimonial_company,
'testimonial_job_title': case_study.testimonial_job_title,
'testimonial_name': case_study.testimonial_name,
'title': case_study.title,
'website': case_study.website,
}],
'twitter_url':
company.twitter_url,
'website':
company.website,
}
assert doc.to_dict() == expected
assert doc.meta.id == company.pk
def non_registration_sent_company():
return factories.CompanyFactory(id=100000000,
company_type=company_types.COMPANIES_HOUSE)
def test_store_date_published_unpublished_company():
company = factories.CompanyFactory(is_published_find_a_supplier=False, )
assert company.date_published is None
def test_store_date_published_published_company_fab_without_date():
company = factories.CompanyFactory(is_published_find_a_supplier=True,
date_published=None)
assert company.date_published == timezone.now()
