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})
