def test_get_exporter_compliance_case_list_2(self):
user_org_relationship = UserOrganisationRelationship.objects.get(user=self.exporter_user)
comp_case_1 = ComplianceSiteCaseFactory(
organisation=self.organisation,
site=self.organisation.primary_site,
status=get_case_status_by_status(CaseStatusEnum.OPEN),
)
self.organisation.primary_site.users.add(user_org_relationship)
site_2 = SiteFactory(organisation=self.organisation)
site_2.users.add(user_org_relationship)
comp_case_2 = ComplianceSiteCaseFactory(
organisation=self.organisation, site=site_2, status=get_case_status_by_status(CaseStatusEnum.OPEN),
)
site_3 = SiteFactory(organisation=self.organisation)
comp_case_3 = ComplianceSiteCaseFactory(
organisation=self.organisation, site=site_3, status=get_case_status_by_status(CaseStatusEnum.OPEN),
)
url = reverse("compliance:exporter_site_list")
response = self.client.get(url, **self.exporter_headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()["results"]
self.assertEqual(len(response_data), 2)
self.compare_compliance_case_in_list(response_data[0], comp_case_1, self.organisation.primary_site)
self.compare_compliance_case_in_list(response_data[1], comp_case_2, site_2)
def test_exporter_set_application_status_surrendered_success(self, mock_notify_client):
self.standard_application.status = get_case_status_by_status(CaseStatusEnum.FINALISED)
self.standard_application.save()
self.create_licence(self.standard_application, status=LicenceStatus.ISSUED)
surrendered_status = get_case_status_by_status("surrendered")
data = {"status": CaseStatusEnum.SURRENDERED}
response = self.client.put(self.url, data=data, **self.exporter_headers)
response_data = response.json()["data"]
self.standard_application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response_data["status"],
{"key": surrendered_status.status, "value": CaseStatusEnum.get_text(surrendered_status.status)},
)
self.assertEqual(self.standard_application.status, get_case_status_by_status(CaseStatusEnum.SURRENDERED))
mock_notify_client.send_email.assert_called_with(
email_address=self.standard_application.submitted_by.email,
template_id=TemplateType.APPLICATION_STATUS.template_id,
data={
"case_reference": self.standard_application.reference_code,
"application_reference": self.standard_application.name,
"link": f"{settings.EXPORTER_BASE_URL}/applications/{self.standard_application.pk}",
},
)
def test_exporter_get_compliance_visits(self):
self.exporter_user.set_role(self.organisation, self.exporter_super_user_role)
comp_visit_1 = ComplianceVisitCaseFactory(
organisation=self.organisation, status=get_case_status_by_status(CaseStatusEnum.OPEN)
)
comp_site_case = comp_visit_1.site_case
comp_visit_2 = ComplianceVisitCaseFactory(
organisation=self.organisation,
status=get_case_status_by_status(CaseStatusEnum.OPEN),
site_case=comp_site_case,
)
comp_visit_2.case_officer = self.gov_user
comp_visit_2.save()
url = reverse("compliance:exporter_visit_case_list", kwargs={"pk": comp_site_case.id})
response = self.client.get(url, **self.exporter_headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()["results"]
self.assertEqual(len(response_data), 2)
self.compare_compliance_visit_list_details(response_data[0], comp_visit_1)
self.compare_compliance_visit_list_details(response_data[1], comp_visit_2)
def test_gov_set_status_when_they_have_do_not_permission_to_reopen_closed_cases_failure(self, reopened_status):
self.standard_application.status = get_case_status_by_status(CaseStatusEnum.WITHDRAWN)
self.standard_application.save()
data = {"status": reopened_status}
response = self.client.put(self.url, data=data, **self.gov_headers)
self.standard_application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(self.standard_application.status, get_case_status_by_status(CaseStatusEnum.WITHDRAWN))
def test_exporter_set_application_status_applicant_editing_when_in_read_only_status_failure(self):
self.standard_application.status = get_case_status_by_status(CaseStatusEnum.UNDER_FINAL_REVIEW)
self.standard_application.save()
data = {"status": CaseStatusEnum.APPLICANT_EDITING}
response = self.client.put(self.url, data=data, **self.exporter_headers)
self.standard_application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(self.standard_application.status, get_case_status_by_status(CaseStatusEnum.UNDER_FINAL_REVIEW))
def test_exporter_set_application_status_withdrawn_when_application_terminal_failure(self):
self.standard_application.status = get_case_status_by_status(CaseStatusEnum.FINALISED)
self.standard_application.save()
data = {"status": CaseStatusEnum.WITHDRAWN}
response = self.client.put(self.url, data=data, **self.exporter_headers)
self.standard_application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(self.standard_application.status, get_case_status_by_status(CaseStatusEnum.FINALISED))
def test_exp_set_application_status_to_submitted_when_previously_not_applicant_editing_failure(self):
standard_application = self.create_draft_standard_application(self.organisation)
standard_application.status = get_case_status_by_status(CaseStatusEnum.INITIAL_CHECKS)
standard_application.save()
previous_submitted_at = standard_application.submitted_at
url = reverse("applications:application_submit", kwargs={"pk": standard_application.id})
response = self.client.put(url, **self.exporter_headers)
standard_application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
standard_application.status, get_case_status_by_status(CaseStatusEnum.INITIAL_CHECKS),
)
self.assertEqual(standard_application.submitted_at, previous_submitted_at)
def test_exporter_set_application_status_surrendered_not_finalised_failure(self):
""" Test failure in exporter user setting a case status to surrendered when the case was not
previously finalised.
"""
self.standard_application.status = get_case_status_by_status(CaseStatusEnum.SUBMITTED)
self.standard_application.save()
data = {"status": CaseStatusEnum.SURRENDERED}
response = self.client.put(self.url, data=data, **self.exporter_headers)
self.standard_application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.json(), {"errors": [strings.Applications.Generic.Finalise.Error.EXPORTER_SET_STATUS]})
self.assertEqual(self.standard_application.status, get_case_status_by_status(CaseStatusEnum.SUBMITTED))
def register_open_general_licence(self, open_general_licence, user):
from api.open_general_licences.models import OpenGeneralLicenceCase
from api.compliance.helpers import generate_compliance_site_case
if open_general_licence.status == OpenGeneralLicenceStatus.DEACTIVATED:
raise ValidationError({
"open_general_licence": [
"This open general licence is deactivated and cannot be registered"
]
})
if not open_general_licence.registration_required:
raise ValidationError({
"open_general_licence":
["This open general licence does not require registration"]
})
# Only register open general licences for sites in the UK which don't already have that licence registered
registrations = []
with transaction.atomic():
for site in (Site.objects.get_by_user_and_organisation(
user, self).filter(address__country_id="GB").exclude(
open_general_licence_cases__open_general_licence=
open_general_licence)):
case = OpenGeneralLicenceCase.objects.create(
open_general_licence=open_general_licence,
site=site,
case_type=open_general_licence.case_type,
organisation=self,
status=get_case_status_by_status(CaseStatusEnum.FINALISED),
submitted_at=timezone.now(),
submitted_by=user,
)
generate_compliance_site_case(case)
registrations.append(case.id)
def test_edit_open_application_end_use_details_intended_end_use_is_empty(
self):
application = self.create_draft_open_application(self.organisation)
self.submit_application(application)
application.status = get_case_status_by_status(
CaseStatusEnum.APPLICANT_EDITING)
application.save()
url = reverse("applications:end_use_details",
kwargs={"pk": application.id})
data = {
"intended_end_use": "",
}
response = self.client.put(url, data, **self.exporter_headers)
application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(len(response.json()["errors"]), 1)
self.assertEqual(
response.json()["errors"]["intended_end_use"],
[
strings.Applications.Generic.EndUseDetails.Error.
INTENDED_END_USE
],
)
def test_edit_submitted_open_application_end_use_details_major_editable(
self, attributes):
application = self.create_draft_open_application(self.organisation)
self.submit_application(application)
application.status = get_case_status_by_status(
CaseStatusEnum.APPLICANT_EDITING)
application.save()
url = reverse("applications:end_use_details",
kwargs={"pk": application.id})
key = "is_" + attributes["key"]
value = attributes["value"]
reference_key = attributes["key"] + "_ref"
reference_value = attributes["reference_number"]
data = {key: value, reference_key: reference_value}
response = self.client.put(url, data, **self.exporter_headers)
application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_200_OK)
attribute = getattr(application, key)
self.assertEqual(attribute, value)
self.assertEqual(Audit.objects.count(), 3)
def test_edit_standard_application_end_use_details_is_compliant_limitations_eu_is_empty(
self):
application = self.create_draft_standard_application(self.organisation)
application.is_eu_military = True
application.status = get_case_status_by_status(
CaseStatusEnum.APPLICANT_EDITING)
application.save()
url = reverse("applications:end_use_details",
kwargs={"pk": application.id})
data = {
"is_compliant_limitations_eu": "",
"compliant_limitations_eu_ref": "",
}
response = self.client.put(url, data, **self.exporter_headers)
application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(len(response.json()["errors"]), 1)
self.assertEqual(
response.json()["errors"]["is_compliant_limitations_eu"],
[
strings.Applications.Generic.EndUseDetails.Error.
COMPLIANT_LIMITATIONS_EU
],
)
def test_gov_set_status_for_all_except_applicant_editing_and_finalised_success(self, case_status):
if case_status == CaseStatusEnum.REVOKED:
self.standard_application.licences.add(
self.create_licence(self.standard_application, status=LicenceStatus.ISSUED)
)
data = {"status": case_status}
with mock.patch("gov_notify.service.client") as mock_notify_client:
response = self.client.put(self.url, data=data, **self.gov_headers)
self.standard_application.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.standard_application.status, get_case_status_by_status(case_status))
if CaseStatusEnum.is_terminal(case_status):
mock_notify_client.send_email.assert_called_with(
email_address=self.standard_application.submitted_by.email,
template_id=TemplateType.APPLICATION_STATUS.template_id,
data={
"case_reference": self.standard_application.reference_code,
"application_reference": self.standard_application.name,
"link": f"{settings.EXPORTER_BASE_URL}/applications/{self.standard_application.pk}",
},
)
def test_exporter_site_details(self):
self.exporter_user.set_role(self.organisation, self.exporter_super_user_role)
comp_case_1 = ComplianceSiteCaseFactory(
organisation=self.organisation,
site=self.organisation.primary_site,
status=get_case_status_by_status(CaseStatusEnum.OPEN),
)
url = reverse("compliance:exporter_site_detail", kwargs={"pk": comp_case_1.id})
response = self.client.get(url, **self.exporter_headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["id"], str(comp_case_1.id))
self.assertEqual(response_data["reference_code"], comp_case_1.reference_code)
self.assertEqual(response_data["site_name"], comp_case_1.site.name)
self.assertEqual(response_data["address"]["address_line_1"], comp_case_1.site.address.address_line_1)
self.assertEqual(response_data["address"]["address_line_2"], comp_case_1.site.address.address_line_2)
self.assertEqual(response_data["address"]["city"], comp_case_1.site.address.city)
self.assertEqual(response_data["address"]["region"], comp_case_1.site.address.region)
self.assertEqual(response_data["address"]["postcode"], comp_case_1.site.address.postcode)
self.assertEqual(response_data["address"]["country"]["id"], comp_case_1.site.address.country.id)
self.assertEqual(response_data["is_primary_site"], True)
def test_remove_external_locations_from_application_in_editable_status_success(
self, editable_status):
""" Test success in removing an external location from an application in an editable status that has
more than one external location added.
"""
application = self.create_draft_standard_application(self.organisation)
application.status = get_case_status_by_status(editable_status)
application.save()
ExternalLocationOnApplication(
application=application,
external_location=self.external_location).save()
second_external_location = self.create_external_location(
"storage facility", self.organisation)
ExternalLocationOnApplication(
application=application,
external_location=second_external_location).save()
url = reverse(
"applications:application_remove_external_location",
kwargs={
"pk": application.id,
"ext_loc_pk": self.external_location.id
},
)
response = self.client.delete(url, **self.exporter_headers)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(application.external_application_sites.count(), 1)
class OpenGeneralLicenceReissue(APIView):
authentication_classes = (GovAuthentication, )
def post(self, request, pk):
"""
Reissue an open general licence
"""
open_general_licence_case = get_object_or_404(OpenGeneralLicenceCase,
id=pk)
if Licence.objects.filter(
case=open_general_licence_case,
status__in=[LicenceStatus.ISSUED,
LicenceStatus.REINSTATED]).exists():
raise PermissionDenied({"confirm": [Cases.ReissueOGEL.ERROR]})
licence = issue_open_general_licence(open_general_licence_case)
open_general_licence_case.status = get_case_status_by_status(
CaseStatusEnum.FINALISED)
open_general_licence_case.save()
audit_trail_service.create(
actor=request.user,
verb=AuditType.OGEL_REISSUED,
target=open_general_licence_case.get_case(),
payload={"additional_text": request.data.get("note")},
)
return JsonResponse(data={"licence": str(licence.pk)})
def test_query_sends_email_to_each_application_submitter_site(
self, mock_client):
"""
When a GOV user submits a valid query to a compliance visit case
Then the request is successful and the query is saved
And an email is sent to each user that submitted a valid application
on that site which has a licence
"""
compliance_site_case = ComplianceVisitCaseFactory(
site_case=self.compliance_case,
organisation=self.organisation,
status=get_case_status_by_status(CaseStatusEnum.OPEN),
)
url = reverse("cases:case_ecju_queries",
kwargs={"pk": compliance_site_case.id})
response = self.client.post(url, self.data, **self.gov_headers)
response_data = response.json()
ecju_query = EcjuQuery.objects.get()
self.assertEqual(status.HTTP_201_CREATED, response.status_code)
self.assertEqual(response_data["ecju_query_id"], str(ecju_query.id))
self.assertEqual(ecju_query.question, self.data["question"])
self.assertEqual(mock_client.send_email.call_count, 2)
def test_audit_entries_are_created(self):
"""
Given a Good with Countries already assigned
When a user assigns a new country to the good and removes the existing one
Then two audit entries should be made showing the addition and removal
"""
case = self.submit_application(self.open_draft)
case.status = get_case_status_by_status(
CaseStatusEnum.APPLICANT_EDITING)
case.save()
self.goods_type_1.countries.set([self.country_1])
data = {str(self.goods_type_1.id): [self.country_2.id]}
self.client.put(self.good_country_url, data, **self.exporter_headers)
response_data = self.client.get(
reverse("cases:activity", kwargs={"pk": case.id}),
**self.gov_headers).json()
self.assertEqual(len(response_data["activity"]), 3)
self.assertIn(
f"added the destinations United States to '{self.goods_type_1.description}'",
str(response_data))
self.assertIn(
f"removed the destinations Spain from '{self.goods_type_1.description}'",
str(response_data))
def submit_application(application):
application.status = get_case_status_by_status(CaseStatusEnum.SUBMITTED)
application.submitted_at = timezone.now()
application.sla_remaining_days = get_application_target_sla(
application.case_type.sub_type)
application.sla_days = 0
application.save()
def test_revoke_licence_success(self, request):
request.return_value = MockResponse("", 201)
standard_application, standard_licence = self._create_licence_for_submission(
self.create_standard_application_case)
# Set Case to Finalised so it can be revoked
standard_application.status = get_case_status_by_status(
CaseStatusEnum.FINALISED)
standard_application.save()
# Give Gov User permission to change status of a Finalised Case
self.gov_user.role.permissions.add(
GovPermissions.REOPEN_CLOSED_CASES.name)
standard_licence.status = LicenceStatus.ISSUED
standard_licence.save()
expected_insert_json = HMRCIntegrationLicenceSerializer(
standard_licence).data
expected_insert_json["action"] = HMRCIntegrationActionEnum.CANCEL
url = reverse("applications:manage_status",
kwargs={"pk": standard_application.id})
response = self.client.put(url,
data={"status": CaseStatusEnum.REVOKED},
**self.gov_headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
request.assert_called_once_with(
"POST",
f"{LITE_HMRC_INTEGRATION_URL}{SEND_LICENCE_ENDPOINT}",
json={"licence": expected_insert_json},
headers=ANY,
timeout=LITE_HMRC_REQUEST_TIMEOUT,
)
def test_create_compliance_visit_case(self):
compliance_case = ComplianceSiteCaseFactory(
organisation=self.organisation,
site=self.organisation.primary_site,
case_officer_id=self.gov_user.pk,
status=get_case_status_by_status(CaseStatusEnum.OPEN),
)
data = {}
url = reverse("compliance:compliance_visit",
kwargs={"pk": compliance_case.id})
response = self.client.post(url, data, **self.gov_headers)
data = response.json()["data"]
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(data["site_case_id"], str(compliance_case.id))
self.assertEqual(data["site_case_reference_code"],
compliance_case.reference_code)
visit_case = ComplianceVisitCase.objects.get(id=data["id"])
self.assertEqual(compliance_case.case_officer_id,
visit_case.case_officer_id)
self.assertEqual(visit_case.case_type.id,
CaseTypeEnum.COMPLIANCE_VISIT.id)
def submit_application(application: BaseApplication,
user: ExporterUser = None):
if not user:
user = UserOrganisationRelationship.objects.filter(
organisation_id=application.organisation_id).first().user
application.submitted_at = timezone.localtime()
application.sla_remaining_days = get_application_target_sla(
application.case_type.sub_type)
application.status = get_case_status_by_status(
CaseStatusEnum.SUBMITTED)
application.save()
if application.case_type.sub_type in [
CaseTypeSubTypeEnum.STANDARD, CaseTypeSubTypeEnum.OPEN
]:
set_case_flags_on_submitted_standard_or_open_application(
application)
add_goods_flags_to_submitted_application(application)
apply_flagging_rules_to_case(application)
audit_trail_service.create(
actor=user.baseuser_ptr,
verb=AuditType.UPDATED_STATUS,
target=application.get_case(),
payload={
"status": {
"new": CaseStatusEnum.get_text(CaseStatusEnum.SUBMITTED),
"old": CaseStatusEnum.get_text(CaseStatusEnum.DRAFT),
}
},
)
return application
def test_remove_countries_to_application_in_editable_status_success(
self, editable_status):
add_second_country_data = {
"countries":
Country.objects.filter(id__in=("GA", "FR")).values_list("id",
flat=True)
}
delete_country_data = {
"countries":
Country.objects.filter(id="GA").values_list("id", flat=True)
}
application = self.create_draft_open_application(self.organisation)
# Add second country, as cannot delete last remaining country
url = reverse("applications:countries", kwargs={"pk": application.id})
self.client.post(url, add_second_country_data, **self.exporter_headers)
application.status = get_case_status_by_status(editable_status)
application.save()
response = self.client.post(url, delete_country_data,
**self.exporter_headers)
# Assert 'FR' country removed and 'GA' country remains
self.assertEqual(application.application_countries.count(), 1)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(application.application_countries.first().country.id,
"GA")
def test_get_case_activity_deletes_audit_notification_success(self):
self.case = self.create_standard_application_case(
self.organisation).get_case()
old_status = self.case.status.status
self.case.status = get_case_status_by_status(
CaseStatusEnum.APPLICANT_EDITING)
self.case.save()
audit = Audit.objects.create(
actor=self.exporter_user,
verb=AuditType.UPDATED_STATUS,
target=self.case,
payload={
"status": {
"new": CaseStatusEnum.APPLICANT_EDITING,
"old": old_status
}
},
)
self.gov_user.send_notification(content_object=audit, case=self.case)
url = reverse("cases:activity", kwargs={"pk": self.case.id})
response = self.client.get(url, **self.gov_headers)
case_audit_notification_count = GovNotification.objects.filter(
user=self.gov_user.baseuser_ptr,
content_type=self.audit_content_type,
case=self.case).count()
self.assertEqual(response.status_code, status.HTTP_200_OK)
case_activity = response.json()["activity"]
self.assertEqual(len(case_activity), 2)
self.assertEqual(case_audit_notification_count, 1)
def test_edit_submitted_open_application_temporary_export_details_major_editable(
self, attributes):
self.draft.status = get_case_status_by_status(
CaseStatusEnum.APPLICANT_EDITING)
self.draft.save()
date = timezone.now().date() + timezone.timedelta(days=2)
key = attributes["key"]
value = attributes["value"]
data = {
key:
value,
"proposed_return_date":
f"{date.year}-{str(date.month).zfill(2)}-{date.day}",
}
if "is_temp_direct_control" in data:
data[
"temp_direct_control_details"] = "Ukraine govt will be in control whilst product is overseas"
response = self.client.put(self.url, data, **self.exporter_headers)
self.draft.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_200_OK)
attribute = getattr(self.draft, key)
self.assertEqual(attribute, value)
if self.draft.is_temp_direct_control is not None:
self.assertEqual(
getattr(self.draft, "temp_direct_control_details"),
"Ukraine govt will be in control whilst product is overseas",
)
self.assertEqual(Audit.objects.count(), 3)
else:
self.assertEqual(Audit.objects.count(), 2)
def setUp(self):
super().setUp()
self.query = self.create_end_user_advisory("A note", "Unsure about something", self.organisation)
self.query.status = get_case_status_by_status(CaseStatusEnum.CLOSED)
self.query.save()
self.url = reverse("cases:case", kwargs={"pk": self.query.id})
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_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_filter_by_finalised_date_range(self):
day_1 = timezone.datetime(day=10, month=10, year=2020)
day_2 = timezone.datetime(day=11, month=10, year=2020)
day_3 = timezone.datetime(day=12, month=10, year=2020)
day_4 = timezone.datetime(day=13, month=10, year=2020)
day_5 = timezone.datetime(day=14, month=10, year=2020)
application_1 = StandardApplicationFactory()
application_1.status = get_case_status_by_status(
CaseStatusEnum.FINALISED)
application_1.save()
good = GoodFactory(organisation=application_1.organisation)
FinalAdviceFactory(user=self.gov_user,
team=self.team,
case=application_1,
good=good,
type=AdviceType.APPROVE,
created_at=day_2)
application_2 = StandardApplicationFactory()
application_2.status = get_case_status_by_status(
CaseStatusEnum.FINALISED)
application_2.save()
good = GoodFactory(organisation=application_2.organisation)
FinalAdviceFactory(user=self.gov_user,
team=self.team,
case=application_2,
good=good,
type=AdviceType.APPROVE,
created_at=day_4)
qs_1 = Case.objects.search(finalised_from=day_1, finalised_to=day_3)
qs_2 = Case.objects.search(finalised_from=day_3, finalised_to=day_5)
qs_3 = Case.objects.search(finalised_from=day_1)
qs_4 = Case.objects.search(finalised_to=day_5)
qs_5 = Case.objects.search(finalised_to=day_1)
qs_6 = Case.objects.search(finalised_from=day_5)
self.assertEqual(qs_1.count(), 1)
self.assertEqual(qs_2.count(), 1)
self.assertEqual(qs_3.count(), 2)
self.assertEqual(qs_4.count(), 2)
self.assertEqual(qs_5.count(), 0)
self.assertEqual(qs_6.count(), 0)
self.assertEqual(qs_1.first().pk, application_1.pk)
self.assertEqual(qs_2.first().pk, application_2.pk)
def test_exporter_view_active_licences_success(self):
self.open_general_licence_case_2.status = get_case_status_by_status(CaseStatusEnum.DRAFT)
self.open_general_licence_case_2.save()
response = self.client.get(self.url + "?active_only=True", **self.exporter_headers)
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(len(response.json()["results"]), 1)
self.assertEquals(len(response.json()["results"][0]["registrations"]), 1)
