def test_filter_by_goods_related_description(self): application_1 = StandardApplicationFactory() good_1 = GoodFactory( organisation=application_1.organisation, description="Desc 1", comment="Comment 1", report_summary="Report Summary 1", ) GoodOnApplicationFactory(application=application_1, good=good_1) application_2 = StandardApplicationFactory() good_2 = GoodFactory(organisation=application_2.organisation, description="afdaf", comment="asdfsadf", report_summary="asdfdsf") GoodOnApplicationFactory(application=application_2, good=good_2) application_3 = StandardApplicationFactory() goods_type = GoodsTypeFactory(application=application_3) qs_1 = Case.objects.search( goods_related_description=good_1.description) qs_2 = Case.objects.search(goods_related_description=good_1.comment) qs_3 = Case.objects.search( goods_related_description=good_1.report_summary) qs_4 = Case.objects.search( goods_related_description=goods_type.description) self.assertEqual(qs_1.count(), 1) self.assertEqual(qs_2.count(), 1) self.assertEqual(qs_3.count(), 1) self.assertEqual(qs_4.count(), 1) self.assertEqual(qs_1.first().pk, application_1.pk) self.assertEqual(qs_2.first().pk, application_1.pk) self.assertEqual(qs_3.first().pk, application_1.pk) self.assertEqual(qs_4.first().pk, application_3.pk)
def test_change_approve_final_advice_deletes_good_country_decisions(self): self.gov_user.role.permissions.set([ constants.GovPermissions.MANAGE_LICENCE_FINAL_ADVICE.name, ]) case = self.create_open_application_case(self.organisation) url = reverse("cases:case_final_advice", kwargs={"pk": case.id}) goods_type = GoodsTypeFactory(application=case) FinalAdviceFactory( user=self.gov_user, team=self.team, case=case, goods_type=goods_type, type=AdviceType.APPROVE, ) GoodCountryDecisionFactory(case=case, goods_type=goods_type, country=Country.objects.first()) data = { "text": "Changed my mind. Reject this", "type": AdviceType.REFUSE, "goods_type": str(goods_type.id), } response = self.client.post(url, **self.gov_headers, data=[data]) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.json()["advice"][0]["goods_type"], str(goods_type.id)) self.assertFalse( GoodCountryDecision.objects.filter(goods_type=goods_type).exists())
def setUp(self): super().setUp() self.gov_user.role.permissions.set( [GovPermissions.MANAGE_LICENCE_FINAL_ADVICE.name]) self.case = self.create_open_application_case(self.organisation) self.url = reverse("cases:goods_countries_decisions", kwargs={"pk": self.case.id}) # Covers every combination of APPROVE/REFUSE for goods_type on country self.countries = [Country.objects.first(), Country.objects.last()] self.approved_country = self.countries[0] self.refused_country = self.countries[1] self.approved_goods_type = GoodsTypeFactory(application=self.case) self.approved_goods_type_clcs = [ControlListEntry.objects.first()] self.approved_goods_type.control_list_entries.set( self.approved_goods_type_clcs) self.approved_goods_type.countries.set(self.countries) self.refused_goods_type = GoodsTypeFactory(application=self.case) self.refused_goods_type_clcs = [ControlListEntry.objects.last()] self.refused_goods_type.control_list_entries.set( self.refused_goods_type_clcs) self.refused_goods_type.countries.set(self.countries) FinalAdviceFactory( user=self.gov_user, team=self.team, case=self.case, goods_type=self.approved_goods_type, type=AdviceType.APPROVE, ) FinalAdviceFactory( user=self.gov_user, team=self.team, case=self.case, goods_type=self.refused_goods_type, type=AdviceType.REFUSE, ) FinalAdviceFactory(user=self.gov_user, team=self.team, case=self.case, country=self.approved_country, type=AdviceType.APPROVE) FinalAdviceFactory(user=self.gov_user, team=self.team, case=self.case, country=self.refused_country, type=AdviceType.REFUSE)
def setUp(self): super().setUp() self.report_summary = self.create_picklist_item( "Report Summary", self.team, PicklistType.REPORT_SUMMARY, PickListStatus.ACTIVE) role = Role(name="review_goods") role.permissions.set([constants.GovPermissions.REVIEW_GOODS.name]) role.save() self.gov_user.role = role self.gov_user.save() self.application = self.create_draft_open_application( organisation=self.organisation) self.good_1 = GoodsTypeFactory(application=self.application) self.good_1.flags.add(self.create_flag("New Flag", "Good", self.team)) self.good_2 = GoodsTypeFactory(application=self.application) self.case = self.submit_application(self.application) self.url = reverse_lazy("goods:control_list_entries", kwargs={"case_pk": self.case.id})
def create_draft_open_application(self, organisation: Organisation, reference_name="Open Draft", case_type_id=CaseTypeEnum.OIEL.id): application = OpenApplication( name=reference_name, case_type_id=case_type_id, export_type=ApplicationExportType.PERMANENT, activity="Trade", usage="Trade", organisation=organisation, status=get_case_status_by_status(CaseStatusEnum.DRAFT), is_military_end_use_controls=False, is_informed_wmd=False, is_suspected_wmd=False, intended_end_use="intended end use is none of your business", is_shipped_waybill_or_lading=True, non_waybill_or_lading_route_details=None, status_id="00000000-0000-0000-0000-000000000000", submitted_by=self.exporter_user, ) application.save() # Add a goods description GoodsTypeFactory(application=application, is_good_controlled=True) GoodsTypeFactory(application=application, is_good_controlled=True) # Add a country to the application - GB cannot be a destination on licences! CountryOnApplication(application=application, country=get_country("FR")).save() # Add a site to the application SiteOnApplication(site=organisation.primary_site, application=application).save() return application
def create_hmrc_query( self, organisation: Organisation, reference_name="HMRC Query", safe_document=True, have_goods_departed=False, ): application = HmrcQuery( name=reference_name, case_type_id=CaseTypeEnum.HMRC.id, activity="Trade", usage="Trade", organisation=organisation, hmrc_organisation=self.hmrc_organisation, reasoning="I Am Easy to Find", status=get_case_status_by_status(CaseStatusEnum.DRAFT), have_goods_departed=have_goods_departed, submitted_by=self.hmrc_exporter_user, ) application.save() end_user = self.create_party("End User", organisation, PartyType.END_USER, application) consignee = self.create_party("Consignee", organisation, PartyType.CONSIGNEE, application) third_party = self.create_party("Third party", organisation, PartyType.THIRD_PARTY, application) self.assertEqual(end_user, application.end_user.party) self.assertEqual(consignee, application.consignee.party) self.assertEqual(third_party, application.third_parties.get().party) goods_type = GoodsTypeFactory(application=application) # Set the application party documents self.create_document_for_party(application.end_user.party, safe=safe_document) self.create_document_for_party(application.consignee.party, safe=safe_document) self.create_document_for_party(application.third_parties.first().party, safe=safe_document) self.create_document_for_goods_type(goods_type) # Add a site to the application SiteOnApplication(site=organisation.primary_site, application=application).save() return application
def test_cannot_remove_goodstype_from_open_cryptographic_application(self): self.create_draft_open_application(self.organisation) application = self.create_draft_open_application(organisation=self.organisation) application.goodstype_category = GoodsTypeCategory.CRYPTOGRAPHIC application.save() goodstype = GoodsTypeFactory(application=application) initial_goods_count = GoodsType.objects.all().count() url = reverse( "applications:application_goodstype", kwargs={"pk": application.id, "goodstype_pk": goodstype.id}, ) response = self.client.delete(url, **self.exporter_headers) self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertEquals(GoodsType.objects.all().count(), initial_goods_count)
class OpenApplicationAdviceDocumentsTests(DataTestClient): def test_get_final_advice_documents_refuse_good_on_country(self): case = self.create_open_application_case(self.organisation) url = reverse("cases:final_advice_documents", kwargs={"pk": case.id}) country = Country.objects.first() goods_type = GoodsTypeFactory(application=case) goods_type.countries.set([country]) FinalAdviceFactory( user=self.gov_user, team=self.team, case=case, goods_type=goods_type, type=AdviceType.APPROVE, ) GoodCountryDecisionFactory(case=case, country=country, approve=False) response = self.client.get(url, **self.gov_headers) response_data = response.json()["documents"] # GoodCountryDecision overrides the approve final advice with a rejection self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_data, {"refuse": {"value": "Refuse"}})
def test_filter_by_good_control_list_entry(self): application_1 = StandardApplicationFactory() good = GoodFactory( organisation=application_1.organisation, is_good_controlled=True, control_list_entries=["ML1a"], ) GoodOnApplicationFactory(application=application_1, good=good) application_2 = OpenApplicationFactory() GoodsTypeFactory(application=application_2, is_good_controlled=True, control_list_entries=["ML2a"]) qs_1 = Case.objects.search(control_list_entry="") qs_2 = Case.objects.search(control_list_entry="ML1b") qs_3 = Case.objects.search(control_list_entry="ML1a") qs_4 = Case.objects.search(control_list_entry="ML2a") self.assertEqual(qs_1.count(), 2) self.assertEqual(qs_2.count(), 0) self.assertEqual(qs_3.count(), 1) self.assertEqual(qs_4.count(), 1)
class GoodsVerifiedTestsOpenApplication(DataTestClient): def setUp(self): super().setUp() self.report_summary = self.create_picklist_item( "Report Summary", self.team, PicklistType.REPORT_SUMMARY, PickListStatus.ACTIVE) role = Role(name="review_goods") role.permissions.set([constants.GovPermissions.REVIEW_GOODS.name]) role.save() self.gov_user.role = role self.gov_user.save() self.application = self.create_draft_open_application( organisation=self.organisation) self.good_1 = GoodsTypeFactory(application=self.application) self.good_1.flags.add(self.create_flag("New Flag", "Good", self.team)) self.good_2 = GoodsTypeFactory(application=self.application) self.case = self.submit_application(self.application) self.url = reverse_lazy("goods:control_list_entries", kwargs={"case_pk": self.case.id}) def test_verify_single_good(self): """ Post a singular good to the endpoint, and check that the control code is updated, and flags are removed """ data = { "objects": self.good_1.pk, "comment": "I Am Easy to Find", "report_summary": self.report_summary.pk, "is_good_controlled": True, "control_list_entries": ["ML1a"], } response = self.client.post(self.url, data, **self.gov_headers) self.assertEquals(response.status_code, status.HTTP_200_OK) self.good_1.refresh_from_db() self.assertEqual( list( self.good_1.control_list_entries.values_list("rating", flat=True)), ["ML1a"]) # determine that flags have been removed when good verified self.assertFalse(is_not_verified_flag_set_on_good(self.good_1)) def test_verify_only_change_comment_doesnt_remove_flags(self): """ Assert that not changing the control code does not remove the flags """ self.good_1.is_good_controlled = True self.good_1.control_list_entries.set([get_control_list_entry("ML1a")]) self.good_1.save() data = { "objects": self.good_1.pk, "comment": "I Am Easy to Find", "report_summary": self.report_summary.pk, "control_list_entries": ["ML1a"], "is_good_controlled": True, } response = self.client.post(self.url, data, **self.gov_headers) self.assertEquals(response.status_code, status.HTTP_200_OK) self.good_1.refresh_from_db() self.assertEqual( list( self.good_1.control_list_entries.values_list("rating", flat=True)), ["ML1a"]) # determine that flags have not been removed when control code hasn't changed self.assertEqual(self.good_1.flags.count(), 1) def test_invalid_control_list_entries(self): """ Post multiple goods to the endpoint, and that a bad request is returned, and that flags are not updated """ data = { "objects": [self.good_1.pk, self.good_2.pk], "comment": "I Am Easy to Find", "report_summary": self.report_summary.pk, "control_list_entries": ["invalid"], "is_good_controlled": "True", } response = self.client.post(self.url, data, **self.gov_headers) self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) # since it has an invalid control code, flags should not be removed self.good_1.refresh_from_db() self.good_2.refresh_from_db() self.assertTrue(is_not_verified_flag_set_on_good(self.good_1)) self.assertTrue(is_not_verified_flag_set_on_good(self.good_2)) def test_user_cannot_review_goods_without_permissions(self): """ Tests that the right level of permissions are required """ # create a second user to adopt the super user role as it will # overwritten otherwise if we try and remove the role from the first valid_user = GovUserFactory( baseuser_ptr__email="*****@*****.**", baseuser_ptr__first_name="John", baseuser_ptr__last_name="Smith", team=self.team, role=self.super_user_role, ) valid_user.save() self.gov_user.role = self.default_role self.gov_user.save() response = self.client.post(self.url, **self.gov_headers) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)