def test_set_team_country_on_create(self): """ Tests that when creating a new OrderAssignee, the `team` and `country` properties get populated automatically. """ # adviser belonging to a team with a country team = TeamFactory(country_id=constants.Country.france.value.id) adviser = AdviserFactory(dit_team=team) assignee = OrderAssigneeFactory(adviser=adviser) assert assignee.team == team assert str(assignee.country_id) == constants.Country.france.value.id # adviser belonging to a team without country team = TeamFactory(country=None) adviser = AdviserFactory(dit_team=team) assignee = OrderAssigneeFactory(adviser=adviser) assert assignee.team == team assert not assignee.country # adviser not belonging to any team adviser = AdviserFactory(dit_team=None) assignee = OrderAssigneeFactory(adviser=adviser) assert not assignee.team assert not assignee.country
def test_if_assigning_project_manager_second_time_doesnt_update_related_columns(self): """ Test that the assignment of project manager for the second time, doesn't update who and when made an assignment. """ investment_project = InvestmentProjectFactory( project_manager=AdviserFactory(), project_manager_first_assigned_on=datetime(2010, 1, 2, 0, 0, tzinfo=utc), project_manager_first_assigned_by=AdviserFactory(), ) url = reverse('admin:investment_investmentproject_change', args=(investment_project.pk,)) data = {} # populate data with required field values admin_form = InvestmentProjectAdmin(InvestmentProject, site).get_form(mock.Mock()) for field_name, field in admin_form.base_fields.items(): if field.required: field_value = getattr(investment_project, field_name) data[field_name] = field.prepare_value(field_value) project_manager = AdviserFactory() data['project_manager'] = project_manager.pk response = self.client.post(url, data, follow=True) assert response.status_code == status.HTTP_200_OK investment_project.refresh_from_db() assert investment_project.project_manager == project_manager assert investment_project.project_manager_first_assigned_on != now() assert investment_project.project_manager_first_assigned_by != self.user
def test_team_member_list_update_add_only(self): """Tests updating adding team members when none previously existed.""" project = InvestmentProjectFactory() new_team_member_data = [ { 'investment_project': project, 'adviser': AdviserFactory(), 'role': 'new role', }, { 'investment_project': project, 'adviser': AdviserFactory(), 'role': 'new team member', }, ] child_serializer = IProjectTeamMemberSerializer() serializer = IProjectTeamMemberListSerializer(child=child_serializer) updated_team_members = serializer.update([], new_team_member_data) assert updated_team_members[0].adviser == new_team_member_data[0][ 'adviser'] assert updated_team_members[0].role == new_team_member_data[0]['role'] assert updated_team_members[1].adviser == new_team_member_data[1][ 'adviser'] assert updated_team_members[1].role == new_team_member_data[1]['role'] assert project.team_members.count() == 2
def test_adviser_notified(self): """ Test that calling `adviser_added` sends an email notifying the adviser that they have been added to the order. """ order = OrderFactory() adviser = AdviserFactory() creator = AdviserFactory() notify.client.reset_mock() notify.adviser_added( order=order, adviser=adviser, by=creator, creation_date=dateutil_parse('2017-05-18'), ) assert notify.client.send_email_notification.called call_args = notify.client.send_email_notification.call_args_list[0][1] assert call_args['email_address'] == adviser.contact_email assert call_args[ 'template_id'] == Template.you_have_been_added_for_adviser.value assert call_args['personalisation']['recipient name'] == adviser.name assert call_args['personalisation']['creator'] == creator.name assert call_args['personalisation']['creation date'] == '18/05/2017'
def test_adviser_report_generation(): """Test the generation of the report.""" disabled_team = TeamFactory( disabled_on=datetime(1980, 1, 1, tzinfo=timezone.utc), ) advisers = [ AdviserFactory(date_joined=datetime(1980, 1, 1, tzinfo=timezone.utc)), AdviserFactory(date_joined=datetime(1990, 1, 1, tzinfo=timezone.utc), dit_team=None), AdviserFactory( date_joined=datetime(2000, 1, 1, tzinfo=timezone.utc), dit_team=disabled_team, ), ] report = AllAdvisersReport() assert list(report.rows()) == [{ 'id': adviser.pk, 'email': adviser.email, 'name': adviser.name, 'contact_email': adviser.contact_email, 'is_active': adviser.is_active, 'dit_team__name': adviser.dit_team.name if adviser.dit_team else None, 'is_team_active': adviser.dit_team.disabled_on is None if adviser.dit_team else None, 'dit_team__role__name': adviser.dit_team.role.name if adviser.dit_team else None, } for adviser in advisers]
def test_falls_back_to_email_field(self, api_request_factory, requests_mock): """ Test that advisers are looked up using the email field when a match using sso_email_user_id is not found, and the adviser's sso_email_user_id is updated. """ adviser = AdviserFactory(email='*****@*****.**', sso_email_user_id=None) requests_mock.post( STAFF_SSO_INTROSPECT_URL, json=_make_introspection_data(username='******'), ) request = api_request_factory.get('/test-path', HTTP_AUTHORIZATION='Bearer token') response = view(request) assert request.user == adviser assert response.status_code == status.HTTP_200_OK assert response.data == {'content': 'introspection-test-view'} # Check that the sso_email_user_id was set on the user adviser.refresh_from_db() assert adviser.sso_email_user_id == '*****@*****.**'
def test_simulate(s3_stubber): """Test that the command only simulates the actions if --simulate is passed in.""" advisers = [ AdviserFactory(telephone_number='000000000'), AdviserFactory(telephone_number='111111111'), ] bucket = 'test_bucket' object_key = 'test_key' csv_content = f"""id,telephone_number {advisers[0].id},+441234567890 {advisers[1].id},+440987654321 """ s3_stubber.add_response( 'get_object', { 'Body': BytesIO(bytes(csv_content, encoding='utf-8')), }, expected_params={ 'Bucket': bucket, 'Key': object_key, }, ) call_command('update_adviser_telephone_number', bucket, object_key, simulate=True) for adviser in advisers: adviser.refresh_from_db() assert advisers[0].telephone_number == '000000000' assert advisers[1].telephone_number == '111111111'
def test_audit_log(s3_stubber): """Test that the audit log is being created.""" adviser = AdviserFactory() bucket = 'test_bucket' object_key = 'test_key' csv_content = f"""id,telephone_number {adviser.id},111222333 """ s3_stubber.add_response( 'get_object', { 'Body': BytesIO(bytes(csv_content, encoding='utf-8')), }, expected_params={ 'Bucket': bucket, 'Key': object_key, }, ) call_command('update_adviser_telephone_number', bucket, object_key) adviser.refresh_from_db() assert adviser.telephone_number == '111222333' versions = Version.objects.get_for_object(adviser) assert len(versions) == 1 assert versions[0].revision.get_comment() == 'Telephone number migration.'
def project_with_max_gross_value_added(): """Test fixture returns an investment project with the max gross value.""" gva_multiplier = GVAMultiplierFactory( multiplier=Decimal('9.999999'), financial_year=1980, ) with mock.patch( 'datahub.investment.project.gva_utils.GrossValueAddedCalculator._get_gva_multiplier', ) as mock_get_multiplier: mock_get_multiplier.return_value = gva_multiplier project = InvestmentProjectFactory( investment_type_id=constants.InvestmentType.fdi.value.id, name='won project', description='investmentproject3', estimated_land_date=datetime.date(2027, 9, 13), actual_land_date=datetime.date(2022, 11, 13), investor_company=CompanyFactory( address_country_id=constants.Country.united_kingdom.value.id, ), project_manager=AdviserFactory(), project_assurance_adviser=AdviserFactory(), fdi_value_id=constants.FDIValue.higher.value.id, status=InvestmentProject.STATUSES.won, uk_region_locations=[ constants.UKRegion.north_west.value.id, ], level_of_involvement_id=Involvement.hq_only.value.id, likelihood_to_land_id=None, foreign_equity_investment=9999999999999999999, ) return project
def test_merge_when_both_companies_are_on_pipeline_for_same_adviser( self, source_status, target_status, ): """ Test that both source and target company are on pipeline for the same adviser and same status. And the merge is successful. """ adviser = AdviserFactory() source_company = CompanyFactory() target_company = CompanyFactory() PipelineItemFactory( adviser=adviser, company=source_company, status=source_status, ) PipelineItemFactory( adviser=adviser, company=target_company, status=target_status, ) user = AdviserFactory() merge_companies(source_company, target_company, user) assert not PipelineItem.objects.filter( adviser=adviser, company=source_company, ).exists() assert PipelineItem.objects.filter( adviser=adviser, company=target_company, ).exists()
def test_get_email_domain(email, domain, db): """ Test that the `Adviser.get_email_domain` method returns the domain for the given adviser's email. """ adviser = AdviserFactory(email=email, contact_email=email) assert adviser.get_email_domain() == domain
def test_non_restricted_user_can_see_all_projects(self, setup_es, permissions): """Test that normal users can see all projects.""" team = TeamFactory() team_others = TeamFactory() adviser_1 = AdviserFactory(dit_team_id=team.id) adviser_2 = AdviserFactory(dit_team_id=team_others.id) request_user = create_test_user( permission_codenames=permissions, dit_team=team, ) api_client = self.create_api_client(user=request_user) iproject_1 = InvestmentProjectFactory() iproject_2 = InvestmentProjectFactory() InvestmentProjectTeamMemberFactory(adviser=adviser_1, investment_project=iproject_1) InvestmentProjectTeamMemberFactory(adviser=adviser_2, investment_project=iproject_2) setup_es.indices.refresh() url = reverse('api-v3:search:investment_project') response = api_client.post(url, {}) assert response.status_code == status.HTTP_200_OK response_data = response.json() assert response_data['count'] == 2 assert {str(iproject_1.pk), str(iproject_2.pk)} == { result['id'] for result in response_data['results'] }
def test_change(self, refund_factory): """Test changing a refund record, its status cannot change at this point.""" refund = refund_factory() order = OrderPaidFactory() now_datetime = now() now_date_str = now_datetime.date().isoformat() now_time_str = now_datetime.time().isoformat() url = reverse('admin:omis_payment_refund_change', args=(refund.id, )) data = { 'order': order.pk, 'status': refund.status, 'requested_on_0': now_date_str, 'requested_on_1': now_time_str, 'requested_by': AdviserFactory().pk, 'requested_amount': order.total_cost, 'refund_reason': 'lorem ipsum refund reason', 'level1_approved_on_0': now_date_str, 'level1_approved_on_1': now_time_str, 'level1_approved_by': AdviserFactory().pk, 'level1_approval_notes': 'lorem ipsum level 1', 'level2_approved_on_0': now_date_str, 'level2_approved_on_1': now_time_str, 'level2_approved_by': AdviserFactory().pk, 'level2_approval_notes': 'lorem ipsum level 2', 'method': PaymentMethod.BACS, 'net_amount': order.total_cost - 1, 'vat_amount': 1, 'additional_reference': 'additional reference', 'rejection_reason': 'lorem ipsum rejection reason', } response = self.client.post(url, data, follow=True) assert response.status_code == status.HTTP_200_OK refund.refresh_from_db() assert refund.order.pk == data['order'] assert refund.status == data['status'] assert refund.requested_on == now_datetime assert refund.requested_by.pk == data['requested_by'] assert refund.requested_amount == data['requested_amount'] assert refund.refund_reason == data['refund_reason'] assert refund.level1_approved_on == now_datetime assert refund.level1_approved_by.pk == data['level1_approved_by'] assert refund.level1_approval_notes == data['level1_approval_notes'] assert refund.level2_approved_on == now_datetime assert refund.level2_approved_by.pk == data['level2_approved_by'] assert refund.level2_approval_notes == data['level2_approval_notes'] assert refund.method == data['method'] assert refund.net_amount == data['net_amount'] assert refund.vat_amount == data['vat_amount'] assert refund.additional_reference == data['additional_reference'] assert refund.rejection_reason == data['rejection_reason'] assert refund.total_amount == order.total_cost assert refund.created_by != self.user assert refund.modified_by == self.user assert not refund.payment
def test_cannot_change_adviser_after_creation(self): """After creating an OrderAssignee, the related adviser cannot be changed.""" adviser = AdviserFactory() assignee = OrderAssigneeFactory(adviser=adviser) with pytest.raises(ValueError): assignee.adviser = AdviserFactory() assignee.save()
def test_error_returned_if_duplicate_participating_advisers_specified(self): """ Test that an error is returned if an adviser is specified as a DIT participant multiple times. """ contact = ContactFactory() communication_channel = random_obj_for_model(CommunicationChannel) dit_adviser = AdviserFactory() url = reverse('api-v3:interaction:collection') request_data = { 'kind': Interaction.Kind.INTERACTION, 'communication_channel': communication_channel.pk, 'subject': 'whatever', 'date': date.today().isoformat(), 'dit_participants': [ { 'adviser': { 'id': dit_adviser.pk, }, }, { 'adviser': { 'id': AdviserFactory().pk, }, }, { 'adviser': { 'id': dit_adviser.pk, }, }, ], 'company': { 'id': contact.company.pk, }, 'contacts': [{ 'id': contact.pk, }], 'service': { 'id': random_service().pk, }, 'was_policy_feedback_provided': False, } api_client = self.create_api_client() response = api_client.post(url, request_data) assert response.status_code == status.HTTP_400_BAD_REQUEST # An error should be returned for each duplicated item in the dit_participants list in # the request assert response.json() == { 'dit_participants': [ {'adviser': ['You cannot add the same adviser more than once.']}, {}, {'adviser': ['You cannot add the same adviser more than once.']}, ], }
def setup_data(setup_es, project_with_max_gross_value_added): """Sets up data for the tests.""" investment_projects = [ InvestmentProjectFactory( investment_type_id=constants.InvestmentType.fdi.value.id, name='abc defg', description='investmentproject1', estimated_land_date=datetime.date(2011, 6, 13), actual_land_date=datetime.date(2010, 8, 13), investor_company=CompanyFactory( address_country_id=constants.Country.united_states.value.id, ), status=InvestmentProject.STATUSES.ongoing, uk_region_locations=[ constants.UKRegion.east_midlands.value.id, constants.UKRegion.isle_of_man.value.id, ], level_of_involvement_id=Involvement.hq_and_post_only.value.id, likelihood_to_land_id=LikelihoodToLand.high.value.id, foreign_equity_investment=100000, ), InvestmentProjectFactory( investment_type_id=constants.InvestmentType.fdi.value.id, name='delayed project', description='investmentproject2', estimated_land_date=datetime.date(2057, 6, 13), actual_land_date=datetime.date(2047, 8, 13), country_investment_originates_from_id=constants.Country.ireland.value.id, investor_company=CompanyFactory( address_country_id=constants.Country.japan.value.id, ), project_manager=AdviserFactory(), project_assurance_adviser=AdviserFactory(), fdi_value_id=constants.FDIValue.higher.value.id, status=InvestmentProject.STATUSES.delayed, uk_region_locations=[ constants.UKRegion.north_west.value.id, ], level_of_involvement_id=Involvement.no_involvement.value.id, likelihood_to_land_id=LikelihoodToLand.medium.value.id, ), project_with_max_gross_value_added, InvestmentProjectFactory( name='new project', description='investmentproject4', country_investment_originates_from_id=constants.Country.canada.value.id, estimated_land_date=None, level_of_involvement_id=None, likelihood_to_land_id=LikelihoodToLand.low.value.id, ), ] setup_es.indices.refresh() yield investment_projects
def setup_data(setup_es): """Sets up data for the tests.""" with freeze_time('2017-01-01 13:00:00'): company = CompanyFactory(name='Mercury trading', alias='Uranus supplies') contact = ContactFactory(company=company, first_name='John', last_name='Doe') order = OrderFactory( reference='abcd', primary_market_id=constants.Country.japan.value.id, uk_region_id=constants.UKRegion.channel_islands.value.id, assignees=[], status=OrderStatus.draft, company=company, contact=contact, discount_value=0, delivery_date=dateutil_parse('2018-01-01').date(), vat_verified=False, ) OrderSubscriberFactory( order=order, adviser=AdviserFactory(dit_team_id=constants.Team.healthcare_uk.value.id), ) OrderAssigneeFactory( order=order, adviser=AdviserFactory(dit_team_id=constants.Team.tees_valley_lep.value.id), estimated_time=60, ) with freeze_time('2017-02-01 13:00:00'): company = CompanyFactory(name='Venus Ltd', alias='Earth outsourcing') contact = ContactFactory(company=company, first_name='Jenny', last_name='Cakeman') order = OrderWithAcceptedQuoteFactory( reference='efgh', primary_market_id=constants.Country.france.value.id, uk_region_id=constants.UKRegion.east_midlands.value.id, assignees=[], status=OrderStatus.quote_awaiting_acceptance, company=company, contact=contact, discount_value=0, delivery_date=dateutil_parse('2018-02-01').date(), vat_verified=False, ) OrderSubscriberFactory( order=order, adviser=AdviserFactory(dit_team_id=constants.Team.td_events_healthcare.value.id), ) OrderAssigneeFactory( order=order, adviser=AdviserFactory(dit_team_id=constants.Team.food_from_britain.value.id), estimated_time=120, ) setup_es.indices.refresh()
def setup_data(setup_es): """Sets up data for the tests.""" investment_projects = [ InvestmentProjectFactory( name='abc defg', description='investmentproject1', estimated_land_date=datetime.date(2011, 6, 13), actual_land_date=datetime.date(2010, 8, 13), investor_company=CompanyFactory( registered_address_country_id=constants.Country.united_states.value.id, ), status=InvestmentProject.STATUSES.ongoing, uk_region_locations=[ constants.UKRegion.east_midlands.value.id, constants.UKRegion.isle_of_man.value.id, ], ), InvestmentProjectFactory( name='delayed project', description='investmentproject2', estimated_land_date=datetime.date(2057, 6, 13), actual_land_date=datetime.date(2047, 8, 13), investor_company=CompanyFactory( registered_address_country_id=constants.Country.japan.value.id, ), project_manager=AdviserFactory(), project_assurance_adviser=AdviserFactory(), fdi_value_id=constants.FDIValue.higher.value.id, status=InvestmentProject.STATUSES.delayed, uk_region_locations=[ constants.UKRegion.north_west.value.id, ], ), InvestmentProjectFactory( name='won project', description='investmentproject3', estimated_land_date=datetime.date(2027, 9, 13), actual_land_date=datetime.date(2022, 11, 13), investor_company=CompanyFactory( registered_address_country_id=constants.Country.united_kingdom.value.id, ), project_manager=AdviserFactory(), project_assurance_adviser=AdviserFactory(), fdi_value_id=constants.FDIValue.higher.value.id, status=InvestmentProject.STATUSES.won, uk_region_locations=[ constants.UKRegion.north_west.value.id, ], ), ] setup_es.indices.refresh() yield investment_projects
def test_assigning_non_ist_project_manager_doesnt_end_spi2(spi_report): """Test that non IST project manager wont end SPI 2.""" investment_project = InvestmentProjectFactory() investment_project.project_manager = AdviserFactory() investment_project.project_manager_first_assigned_on = now() investment_project.project_manager_first_assigned_by = AdviserFactory() investment_project.save() rows = list(spi_report.rows()) assert len(rows) == 1 assert 'Project manager assigned' not in rows[0] assert 'Project manager assigned by' not in rows[0]
def calendar_data_fixture(): """ Create advisers, contacts and companies so that our email samples can be attributed to some DB entities. """ advisers = [ ('*****@*****.**', 'Adviser', '1'), ('*****@*****.**', 'Adviser', '2'), ] AdviserFactory.create_batch( len(advisers), email=factory.Iterator(advisers, getter=lambda a: a[0]), first_name=factory.Iterator(advisers, getter=lambda a: a[1]), last_name=factory.Iterator(advisers, getter=lambda a: a[2]), contact_email=factory.SelfAttribute('email'), ) AdviserFactory( email='*****@*****.**', first_name='Adviser', last_name='3', contact_email='*****@*****.**', ) company_1 = CompanyFactory(name='Company 1') company_2 = CompanyFactory(name='Company 2') contacts = [ ('Bill Adama', company_1), ('Saul Tigh', company_1), ('Laura Roslin', company_2), ('Sharon Valerii', company_1), ('Sharon Valerii', company_2), ] for name, company in contacts: first_name, last_name = name.split(' ') email_prefix = name.lower().replace(' ', '.') email = f'{email_prefix}@example.net' ContactFactory( first_name=first_name, last_name=last_name, email=email, company=company, ) # Ensure that our contact who appears on multiple companies # with a single email address has more interactions for the # contact attributed to 'Company 1' contact_with_interactions = Contact.objects.get( email='*****@*****.**', company=company_1, ) CompanyInteractionFactory(contacts=[contact_with_interactions], company=company_1) yield
def test_is_user_feature_flag(code, user, is_active, lookup, expected): """Tests if is_user_feature_flag returns correct state of feature flag.""" if code != '': flag = UserFeatureFlagFactory(code=code, is_active=is_active) if user == 'flagged_user': advisor = AdviserFactory() advisor.features.set([flag]) if user == 'unflagged_user': advisor = AdviserFactory() result = is_user_feature_flag_active(lookup, advisor) assert result is expected
def test_company_subsidiaries_auto_update_to_opensearch( opensearch_with_signals): """Tests if company subsidiaries get updated in OpenSearch.""" account_owner = AdviserFactory() global_headquarters = CompanyFactory(one_list_account_owner=account_owner) subsidiaries = CompanyFactory.create_batch( 2, global_headquarters=global_headquarters) opensearch_with_signals.indices.refresh() subsidiary_ids = [subsidiary.id for subsidiary in subsidiaries] result = get_documents_by_ids( opensearch_with_signals, CompanySearchApp, subsidiary_ids, ) expected_results = {(str(subsidiary_id), str(account_owner.id)) for subsidiary_id in subsidiary_ids} search_results = { (doc['_id'], doc['_source']['one_list_group_global_account_manager']['id']) for doc in result['docs'] } assert len(result['docs']) == 2 assert search_results == expected_results new_account_owner = AdviserFactory() global_headquarters.one_list_account_owner = new_account_owner global_headquarters.save() opensearch_with_signals.indices.refresh() new_result = get_documents_by_ids( opensearch_with_signals, CompanySearchApp, subsidiary_ids, ) new_expected_results = {(str(subsidiary_id), str(new_account_owner.id)) for subsidiary_id in subsidiary_ids} new_search_results = { (doc['_id'], doc['_source']['one_list_group_global_account_manager']['id']) for doc in new_result['docs'] } assert len(new_result['docs']) == 2 assert new_search_results == new_expected_results
def test_one_list_report_generation(): """Test the generation of the One List.""" companies = CompanyFactory.create_batch( 2, headquarter_type_id=constants.HeadquarterType.ghq.value.id, classification=factory.Iterator( CompanyClassification.objects.all(), # keeps the ordering ), one_list_account_owner=AdviserFactory(), ) # ignored because headquarter_type is None CompanyFactory( headquarter_type=None, classification=random_obj_for_model(CompanyClassification), one_list_account_owner=AdviserFactory(), ) # ignored because classification is None CompanyFactory( headquarter_type_id=constants.HeadquarterType.ghq.value.id, classification=None, one_list_account_owner=AdviserFactory(), ) # ignored because one_list_account_owner is None CompanyFactory( headquarter_type_id=constants.HeadquarterType.ghq.value.id, classification=random_obj_for_model(CompanyClassification), one_list_account_owner=None, ) report = OneListReport() assert list(report.rows()) == [{ 'name': company.name, 'classification__name': company.classification.name, 'sector__segment': company.sector.segment, 'primary_contact_name': company.one_list_account_owner.name, 'one_list_account_owner__telephone_number': company.one_list_account_owner.telephone_number, 'one_list_account_owner__contact_email': company.one_list_account_owner.contact_email, 'registered_address_country__name': company.registered_address_country.name, 'registered_address_town': company.registered_address_town, 'url': f'{settings.DATAHUB_FRONTEND_URL_PREFIXES["company"]}/{company.id}', } for company in companies]
def test_with_multiple_advisers(self, data_flow_api_client): """Test that endpoint returns correct order of records""" adviser_1 = AdviserFactory(date_joined=datetime(2019, 1, 2, tzinfo=utc)) adviser_2 = AdviserFactory(date_joined=datetime(2019, 1, 3, tzinfo=utc)) adviser_3 = AdviserFactory(date_joined=datetime(2019, 1, 1, tzinfo=utc)) adviser_4 = AdviserFactory(date_joined=datetime(2019, 1, 1, tzinfo=utc)) response = data_flow_api_client.get(self.view_url) assert response.status_code == status.HTTP_200_OK assert [a['id'] for a in response.json()['results']] == [ str(a.id) for a in sorted([adviser_3, adviser_4], key=lambda x: x.id) + [adviser_1, adviser_2] ]
def test_validation_error(self, data_delta, errors): """Test validation errors.""" def resolve(value, order, data): if callable(value): return value(order, data) return value order = data_delta.pop('order', None) or OrderPaidFactory() order = resolve(order, None, None) now_datetime = now() now_date_str = now_datetime.date().isoformat() now_time_str = now_datetime.time().isoformat() url = reverse('admin:omis_payment_refund_add') data = { 'order': order.pk, 'status': RefundStatus.APPROVED, 'requested_on_0': now_date_str, 'requested_on_1': now_time_str, 'requested_by': AdviserFactory().pk, 'requested_amount': order.total_cost, 'refund_reason': 'lorem ipsum refund reason', 'level1_approved_on_0': now_date_str, 'level1_approved_on_1': now_time_str, 'level1_approved_by': AdviserFactory().pk, 'level1_approval_notes': 'lorem ipsum level 1', 'level2_approved_on_0': now_date_str, 'level2_approved_on_1': now_time_str, 'level2_approved_by': AdviserFactory().pk, 'level2_approval_notes': 'lorem ipsum level 2', 'method': PaymentMethod.BACS, 'net_amount': order.total_cost - 1, 'vat_amount': 1, 'additional_reference': 'additional reference', } for data_key, data_value in data_delta.items(): data[data_key] = resolve(data_value, order, data) response = self.client.post(url, data, follow=True) assert response.status_code == status.HTTP_200_OK form = response.context['adminform'].form assert not form.is_valid() for error_key, error_value in errors.items(): errors[error_key] = resolve(error_value, order, errors) assert form.errors == errors
def test_simulate(s3_stubber, caplog): """Test that the command simulates updates if --simulate is passed in.""" caplog.set_level('ERROR') advisers = [ AdviserFactory(contact_email='*****@*****.**'), AdviserFactory(contact_email='*****@*****.**'), AdviserFactory(contact_email='*****@*****.**'), AdviserFactory(contact_email=''), AdviserFactory(contact_email='*****@*****.**'), ] bucket = 'test_bucket' object_key = 'test_key' csv_content = f"""id,contact_email 00000000-0000-0000-0000-000000000000,[email protected] {advisers[0].id},invalid_email {advisers[1].id},[email protected] {advisers[2].id},[email protected] {advisers[3].id},[email protected] {advisers[4].id}, """ s3_stubber.add_response( 'get_object', { 'Body': BytesIO(bytes(csv_content, encoding='utf-8')), }, expected_params={ 'Bucket': bucket, 'Key': object_key, }, ) call_command('update_adviser_contact_email', bucket, object_key, simulate=True) assert len(caplog.records) == 2 assert 'Advisor matching query does not exist' in caplog.text assert 'Enter a valid email address' in caplog.text for adviser in advisers: adviser.refresh_from_db() expected_emails = [ '*****@*****.**', '*****@*****.**', '*****@*****.**', '', '*****@*****.**', ] assert [adviser.contact_email for adviser in advisers] == expected_emails
def test_ok_if_order_in_allowed_status(self, allowed_status): """ Test that the order can be marked as paid if the order is in one of the allowed statuses. """ order = OrderWithAcceptedQuoteFactory(status=allowed_status) adviser = AdviserFactory() order.mark_as_paid( by=adviser, payments_data=[ { 'amount': 1, 'received_on': dateutil_parse('2017-01-01').date(), }, { 'amount': order.total_cost - 1, 'received_on': dateutil_parse('2017-01-02').date(), }, ], ) order.refresh_from_db() assert order.status == OrderStatus.paid assert order.paid_on == dateutil_parse('2017-01-02T00:00:00Z') assert list( order.payments.order_by('received_on').values_list( 'amount', 'received_on'), ) == [ (1, dateutil_parse('2017-01-01').date()), (order.total_cost - 1, dateutil_parse('2017-01-02').date()), ]
def test_get_one_list_group_core_team( self, build_company, with_global_account_manager, ): """ Test that `get_one_list_group_core_team` returns the Core Team of `self` if the company has no `global_headquarters` or the one of its `global_headquarters` otherwise. """ team_member_advisers = AdviserFactory.create_batch( 3, first_name=factory.Iterator( ('Adam', 'Barbara', 'Chris'), ), ) global_account_manager = team_member_advisers[0] if with_global_account_manager else None company = build_company(global_account_manager) group_global_headquarters = company.global_headquarters or company OneListCoreTeamMemberFactory.create_batch( len(team_member_advisers), company=group_global_headquarters, adviser=factory.Iterator(team_member_advisers), ) core_team = company.get_one_list_group_core_team() assert core_team == [ { 'adviser': adviser, 'is_global_account_manager': adviser is global_account_manager, } for adviser in team_member_advisers ]
def test_400_if_assignee_added_with_extra_field(self, data): """ Test that estimated_time and is_lead cannot be set at this stage even when adding a new assignee. """ order = OrderPaidFactory() new_adviser = AdviserFactory() url = reverse( 'api-v3:omis:order:assignee', kwargs={'order_pk': order.id}, ) response = self.api_client.patch( url, [ { 'adviser': { 'id': new_adviser.id, }, **data, }, ], ) assert response.status_code == status.HTTP_400_BAD_REQUEST assert response.json() == [ { list(data)[0]: [ 'This field cannot be changed at this stage.', ], }, ]
def test_409_if_order_not_in_allowed_status(self, disallowed_status): """ Test that if the order is not in one of the allowed statuses, the endpoint returns 409. """ order = OrderFactory(status=disallowed_status) url = reverse( 'api-v3:omis:order:assignee', kwargs={'order_pk': order.id}, ) response = self.api_client.patch( url, [{ 'adviser': { 'id': AdviserFactory().id }, }], ) assert response.status_code == status.HTTP_409_CONFLICT assert response.json() == { 'detail': ('The action cannot be performed ' f'in the current status {disallowed_status.label}.'), }