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)