def test_set_org_details_to_none_foreign_address_success(self): """ Organisations based in foreign countries don't need to provide all details about themselves """ organisation = OrganisationFactory( type=OrganisationType.COMMERCIAL, primary_site__address=ForeignAddressFactory(), ) self.gov_user.role.permissions.set([GovPermissions.MANAGE_ORGANISATIONS.name]) data = { "eori_number": None, "sic_number": None, "vat_number": None, "registration_number": None, } response = self.client.put(self._get_url(organisation.id), data, **self.gov_headers) organisation.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertIsNone(organisation.eori_number) self.assertIsNone(organisation.sic_number) self.assertIsNone(organisation.vat_number) self.assertIsNone(organisation.registration_number) self.assertEqual(Audit.objects.count(), 4)
def test_list_filter_organisations_by_status(self): self.organisation_1 = OrganisationFactory(status=OrganisationStatus.IN_REVIEW) self.organisation_2 = OrganisationFactory(status=OrganisationStatus.REJECTED) self.organisation_3 = OrganisationFactory(status=OrganisationStatus.ACTIVE) response = self.client.get(self.url + "?status=" + OrganisationStatus.ACTIVE, **self.gov_headers) response_data = response.json()["results"] self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertTrue(all([item["status"]["key"] == OrganisationStatus.ACTIVE for item in response_data]))
def test_set_org_details_success(self): """ Internal users can change an organisation's information """ organisation = OrganisationFactory(type=OrganisationType.COMMERCIAL) previous_eori_number = organisation.eori_number previous_sic_number = organisation.sic_number previous_vat_number = organisation.vat_number previous_registration_number = organisation.registration_number self.gov_user.role.permissions.set([GovPermissions.MANAGE_ORGANISATIONS.name]) data = { "eori_number": self.faker.eori_number(), "sic_number": self.faker.sic_number(), "vat_number": self.faker.vat_number(), "registration_number": self.faker.registration_number(), } response = self.client.put(self._get_url(organisation.id), data, **self.gov_headers) organisation.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(organisation.eori_number, data["eori_number"]) self.assertEqual(organisation.sic_number, data["sic_number"]) self.assertEqual(organisation.vat_number, data["vat_number"]) self.assertEqual(organisation.registration_number, data["registration_number"]) audit_qs = Audit.objects.all() self.assertEqual(audit_qs.count(), 4) for audit in audit_qs: verb = AuditType.UPDATED_ORGANISATION self.assertEqual(AuditType(audit.verb), verb) if audit.payload["key"] == "registration number": org_field = "registration number" previous_value = previous_registration_number new_value = organisation.registration_number elif audit.payload["key"] == "VAT number": org_field = "VAT number" previous_value = previous_vat_number new_value = organisation.vat_number elif audit.payload["key"] == "SIC number": org_field = "SIC number" previous_value = previous_sic_number new_value = organisation.sic_number elif audit.payload["key"] == "EORI number": org_field = "EORI number" previous_value = previous_eori_number new_value = organisation.eori_number payload = { "key": org_field, "old": previous_value, "new": new_value, } self.assertEqual(audit.payload, payload)
def test_cannot_edit_organisation_without_permission(self): organisation = OrganisationFactory(type=OrganisationType.COMMERCIAL) self.gov_user.role.permissions.clear() data = {"name": self.faker.company()} response = self.client.put(self._get_url(organisation.id), data, **self.gov_headers) organisation.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertEqual(response.json()["errors"], Organisations.NO_PERM_TO_EDIT) self.assertNotEqual(organisation.name, data["name"]) self.assertEqual(Audit.objects.count(), 0)
def test_list_filter_organisations_by_name_and_type(self, name, org_types, expected_result): # Add organisations to filter OrganisationFactory(name="Individual", type=OrganisationType.INDIVIDUAL) OrganisationFactory(name="Commercial", type=OrganisationType.COMMERCIAL) OrganisationFactory(name="HMRC", type=OrganisationType.HMRC) org_types_param = "" for org_type in org_types: org_types_param += "&org_type=" + org_type response = self.client.get(self.url + "?search_term=" + name + org_types_param, **self.gov_headers) self.assertEqual(len(response.json()["results"]), expected_result)
def test_can_edit_name_with_manage_and_reopen_permissions(self): organisation = OrganisationFactory(type=OrganisationType.COMMERCIAL) self.gov_user.role.permissions.set( [GovPermissions.MANAGE_ORGANISATIONS.name, GovPermissions.REOPEN_CLOSED_CASES.name] ) data = {"name": self.faker.company()} response = self.client.put(self._get_url(organisation.id), data, **self.gov_headers) organisation.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.json()["organisation"]["name"], data["name"]) self.assertEqual(organisation.name, data["name"]) self.assertEqual(Audit.objects.count(), 1)
def test_no_name_change_to_org_does_not_reopen_finalised_cases(self): organisation = OrganisationFactory(type=OrganisationType.COMMERCIAL) self.gov_user.role.permissions.set( [GovPermissions.MANAGE_ORGANISATIONS.name, GovPermissions.REOPEN_CLOSED_CASES.name] ) case_one = self.create_standard_application_case( organisation, reference_name="Case one", user=self.exporter_user ) case_two = self.create_standard_application_case( organisation, reference_name="Case two", user=self.exporter_user ) # Set case to finalised and provide licence duration case_one.status = get_case_status_by_status("finalised") case_one.licence_duration = 12 case_one.save() self.data = {"name": organisation.name} response = self.client.put(self._get_url(organisation.id), self.data, **self.gov_headers) case_one.refresh_from_db() case_two.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(Audit.objects.count(), 2) # Check no case status were updated as the org's name was not changed self.assertEqual(case_one.status.status, CaseStatusEnum.FINALISED) self.assertEqual(case_two.status.status, CaseStatusEnum.SUBMITTED)
def test_name_change_to_org_reopens_finalised_cases(self): organisation = OrganisationFactory(type=OrganisationType.COMMERCIAL) self.gov_user.role.permissions.set( [GovPermissions.MANAGE_ORGANISATIONS.name, GovPermissions.REOPEN_CLOSED_CASES.name] ) data = {"name": self.faker.company()} case_one = self.create_standard_application_case( organisation, reference_name="Case one", user=self.exporter_user ) case_two = self.create_standard_application_case( organisation, reference_name="Case two", user=self.exporter_user ) # Set case to finalised and provide licence duration case_one.status = get_case_status_by_status("finalised") case_one.licence_duration = 12 case_one.save() response = self.client.put(self._get_url(organisation.id), data, **self.gov_headers) case_one.refresh_from_db() case_two.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(Audit.objects.count(), 3) # Check only the finalised case's status was changed self.assertEqual(case_one.status.status, CaseStatusEnum.REOPENED_DUE_TO_ORG_CHANGES) self.assertEqual(case_two.status.status, CaseStatusEnum.SUBMITTED)
def test_get_notifications_without_organisation_permission(self): OrganisationFactory(status=OrganisationStatus.IN_REVIEW) response = self.client.get(self.url, **self.gov_headers) response_data = response.json() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_data["notifications"], {"organisations": 0}) self.assertEqual(response_data["has_notifications"], False)
def test_user_cannot_be_assigned_to_site_in_another_organisation(self): organisation_2 = OrganisationFactory() data = {"sites": [organisation_2.primary_site.id]} response = self.client.put(self.url, data, **self.exporter_headers) user_organisation_relationship = get_user_organisation_relationship(self.exporter_user_2, self.organisation) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) self.assertEqual(user_organisation_relationship.sites.count(), 0)
def test_get_notifications_with_in_review_organisations(self): self.gov_user.role.permissions.set( [GovPermissions.MANAGE_ORGANISATIONS.name]) OrganisationFactory(status=OrganisationStatus.IN_REVIEW) response = self.client.get(self.url, **self.gov_headers) response_data = response.json() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_data["notifications"], {"organisations": 1}) self.assertEqual(response_data["has_notifications"], True)
def create_organisation_with_exporter_user( self, name="Organisation", org_type=OrganisationType.COMMERCIAL, exporter_user=None) -> Tuple[Organisation, ExporterUser]: organisation = OrganisationFactory(name=name, type=org_type) if not exporter_user: exporter_user = self.create_exporter_user(organisation) else: self.add_exporter_user_to_org(organisation, exporter_user) return organisation, exporter_user
def test_set_org_details_to_none_uk_address_failure(self): """ Organisations based in the UK need to provide all details about themselves """ organisation = OrganisationFactory(type=OrganisationType.COMMERCIAL) self.gov_user.role.permissions.set([GovPermissions.MANAGE_ORGANISATIONS.name]) data = { "eori_number": None, "sic_number": None, "vat_number": None, "registration_number": None, } response = self.client.put(self._get_url(organisation.id), data, **self.gov_headers) organisation.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertIsNotNone(organisation.eori_number) self.assertIsNotNone(organisation.sic_number) self.assertIsNotNone(organisation.vat_number) self.assertIsNotNone(organisation.registration_number) self.assertEqual(Audit.objects.count(), 0)
def test_authorised_to_view_application_wrong_organisation_failure(self): application = self.create_standard_application_case(self.organisation) organisation = OrganisationFactory() request = _FakeRequest(self.exporter_user, organisation) @authorised_to_view_application(ExporterUser) def a_view(request, *args, **kwargs): return HttpResponse() resp = a_view(request=request, pk=application.pk) self.assertEqual(resp.status_code, status.HTTP_403_FORBIDDEN) self.assertTrue( "You can only perform this operation on an application that has been opened within your organisation" in resp.content.decode("utf-8"))
def test_list_organisations(self): organisation = OrganisationFactory() response = self.client.get(self.url, **self.gov_headers) response_data = next(data for data in response.json()["results"] if data["id"] == str(organisation.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual( response_data, { "id": str(organisation.id), "name": organisation.name, "sic_number": organisation.sic_number, "eori_number": organisation.eori_number, "type": generate_key_value_pair(organisation.type, OrganisationType.choices), "registration_number": organisation.registration_number, "vat_number": organisation.vat_number, "status": generate_key_value_pair(organisation.status, OrganisationStatus.choices), "created_at": date_to_drf_date(organisation.created_at), }, )
def test_site_list(self): self.exporter_user.set_role(self.organisation, self.exporter_super_user_role) url = reverse("organisations:sites", kwargs={"org_pk": self.organisation.id}) # Create an additional organisation and site to ensure that only sites from the first organisation are shown OrganisationFactory() response = self.client.get(url, **self.exporter_headers) response_data = response.json() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response_data["sites"]), 1) response_site = response_data["sites"][0] primary_site = self.organisation.primary_site self.assertEqual(response_site["id"], str(primary_site.id)) self.assertEqual(response_site["name"], str(primary_site.name)) self.assertEqual(response_site["address"]["id"], str(primary_site.address.id))
def seed_organisation(cls, org_name: str, org_type: str, no_of_sites: int, no_of_users: int, primary_user: str): if Organisation.objects.filter(name__iexact=org_name).exists(): raise ValueError(f"An Organisation with name: '{org_name}' already exists") organisation = OrganisationFactory(name=org_name, type=org_type) # Sets a the Organisation's Primary Exporter User primary_user = cls._set_organisation_primary_user(organisation, primary_user) exporter_users = [primary_user] # Since a Primary User has already been created and/or set, subtract 1 from total number of users to seed exporter_users += create_exporter_users(organisation, no_of_users - 1) sites = [organisation.primary_site] # Since OrganisationFactory has already created a Site, subtract 1 from total number of sites to seed sites += [SiteFactory(organisation=organisation) for _ in range(no_of_sites - 1)] for site in sites: site.site_records_located_at = site site.save() cls._print_organisation_to_console(organisation, primary_user) return organisation, sites, exporter_users, primary_user
def setUp(self): super().setUp() self.organisation = OrganisationFactory(status=OrganisationStatus.IN_REVIEW) UserOrganisationRelationshipFactory(organisation=self.organisation, user=self.exporter_user) self.url = reverse("organisations:organisation_status", kwargs={"pk": self.organisation.pk})