def setUp(self):
super().setUp()
self.report_summary = self.create_picklist_item(
"Report Summary", self.team, PicklistType.REPORT_SUMMARY,
PickListStatus.ACTIVE)
self.good_1 = GoodFactory(
organisation=self.organisation,
flags=[FlagFactory(level=FlagLevels.GOOD, team=self.team)])
self.good_2 = GoodFactory(organisation=self.organisation)
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_standard_application(
organisation=self.organisation)
self.good_on_application_1 = GoodOnApplication.objects.create(
good=self.good_1,
application=self.application,
quantity=10,
unit=Units.NAR,
value=500)
self.good_on_application_2 = GoodOnApplication.objects.create(
good=self.good_2,
application=self.application,
quantity=10,
unit=Units.NAR,
value=500)
self.case = self.submit_application(self.application)
self.url = reverse_lazy("goods:control_list_entries",
kwargs={"case_pk": self.case.id})
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_submit_standard_application_adds_system_case_flags_success(self, upload_bytes_file_func, html_to_pdf_func):
upload_bytes_file_func.return_value = None
html_to_pdf_func.return_value = None
firearm_details = FirearmFactory()
firearm_good = GoodFactory(
description="a good",
organisation=self.organisation,
item_category=ItemCategory.GROUP2_FIREARMS,
firearm_details=firearm_details,
)
draft = self.create_draft_standard_application(organisation=self.organisation, good=firearm_good)
draft.is_military_end_use_controls = True
draft.is_informed_wmd = True
draft.save()
data = {"submit_declaration": True, "agreed_to_declaration": True, "agreed_to_foi": True, "foi_reason": ""}
url = reverse("applications:application_submit", kwargs={"pk": draft.id})
response = self.client.put(url, data=data, **self.exporter_headers)
self.draft.refresh_from_db()
case_flags = [str(flag_id) for flag_id in draft.flags.values_list("id", flat=True)]
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn(SystemFlags.MILITARY_END_USE_ID, case_flags)
self.assertIn(SystemFlags.WMD_END_USE_ID, case_flags)
self.assertIn(SystemFlags.FIREARMS_ID, case_flags)
html_to_pdf_func.assert_called_once()
upload_bytes_file_func.assert_called_once()
def create_standard_application_with_incorporated_good(
self,
organisation: Organisation,
reference_name="Standard Draft",
safe_document=True,
):
application = self.create_draft_standard_application(
organisation, reference_name, safe_document)
GoodOnApplication(
good=GoodFactory(
is_good_controlled=True,
organisation=self.organisation,
),
application=application,
quantity=17,
value=18,
is_good_incorporated=True,
).save()
self.ultimate_end_user = self.create_party("Ultimate End User",
organisation,
PartyType.ULTIMATE_END_USER,
application)
self.create_document_for_party(
application.ultimate_end_users.first().party, safe=safe_document)
return application
def test_filter_by_flags(self):
flag_1 = FlagFactory(name="Name_1",
level="Destination",
team=self.gov_user.team,
priority=9)
flag_2 = FlagFactory(name="Name_2",
level="Destination",
team=self.gov_user.team,
priority=10)
flag_3 = FlagFactory(name="Name_3",
level="good",
team=self.gov_user.team,
priority=1)
application_1 = StandardApplicationFactory()
application_1.flags.add(flag_1)
application_2 = StandardApplicationFactory()
application_2.flags.add(flag_2)
application_3 = StandardApplicationFactory()
application_3.flags.add(flag_2)
application_4 = StandardApplicationFactory()
GoodOnApplicationFactory(
good=GoodFactory(organisation=application_4.organisation,
flags=[flag_3]),
application=application_4,
)
qs_1 = Case.objects.search(flags=[flag_1.id])
qs_2 = Case.objects.search(flags=[flag_2.id])
qs_3 = Case.objects.search(flags=[flag_3.id])
self.assertEqual(qs_1.count(), 1)
self.assertEqual(qs_2.count(), 2)
self.assertEqual(qs_3.count(), 1)
self.assertEqual(qs_3.first().pk, application_4.pk)
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_view_good__query_filter_by_control_list_entry(
self, control_list_entry, count):
org = self.organisation
GoodFactory(organisation=org,
is_good_controlled=True,
control_list_entries=["ML1a"])
GoodFactory(organisation=org,
is_good_controlled=True,
control_list_entries=["ML1a"])
url = reverse(
"goods:goods") + "?control_list_entry=" + control_list_entry
response = self.client.get(url, **self.exporter_headers)
response_data = response.json()["results"]
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response_data), count)
def test_view_good__query_filter_by_part_number_and_combinations(self):
GoodFactory(
description="car1",
part_number="cl500",
organisation=self.organisation,
)
GoodFactory(
description="Car2",
part_number="CL300",
organisation=self.organisation,
)
GoodFactory(
description="car3",
part_number="ML500",
organisation=self.organisation,
)
GoodFactory(
description="Truck",
part_number="CL1000",
organisation=self.organisation,
)
url = reverse("goods:goods") + "?part_number=cl"
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), 3)
url = reverse("goods:goods") + "?part_number=100"
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), 1)
self.assertEqual(response_data[0]["description"], "Truck")
url = reverse("goods:goods") + "?part_number=cl&description=car"
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)
def test_get_licence_gov_view(self):
application = StandardApplicationFactory()
licence = LicenceFactory(
case=application, start_date=timezone.now().date(), status=LicenceStatus.ISSUED, duration=100,
)
self.url = reverse("cases:licences", kwargs={"pk": application.id})
good = GoodFactory(organisation=application.organisation)
good_advice = FinalAdviceFactory(
user=self.gov_user, team=self.team, case=application, good=good, type=AdviceType.APPROVE
)
good_on_application = GoodOnApplicationFactory(
application=application, good=good, quantity=100.0, value=1500, unit=Units.KGM
)
good_on_licence = GoodOnLicenceFactory(
good=good_on_application,
quantity=good_on_application.quantity,
usage=20.0,
value=good_on_application.value,
licence=licence,
)
response = self.client.get(self.url, **self.gov_headers)
response_data = response.json()["licence"]
self.assertEqual(response_data["id"], str(licence.id))
self.assertEqual(response_data["start_date"], licence.start_date.strftime("%Y-%m-%d"))
self.assertEqual(response_data["duration"], licence.duration)
self.assertEqual(response_data["goods_on_licence"][0]["good_on_application_id"], str(good_on_application.id))
self.assertEqual(response_data["goods_on_licence"][0]["usage"], good_on_licence.usage)
self.assertEqual(response_data["goods_on_licence"][0]["description"], good.description)
self.assertEqual(response_data["goods_on_licence"][0]["units"]["key"], good_on_application.unit)
self.assertEqual(response_data["goods_on_licence"][0]["applied_for_quantity"], good_on_application.quantity)
self.assertEqual(response_data["goods_on_licence"][0]["applied_for_value"], good_on_application.value)
self.assertEqual(response_data["goods_on_licence"][0]["licenced_quantity"], good_on_licence.quantity)
self.assertEqual(response_data["goods_on_licence"][0]["licenced_value"], good_on_licence.value)
self.assertEqual(
response_data["goods_on_licence"][0]["applied_for_value_per_item"],
good_on_application.value / good_on_application.quantity,
)
self.assertEqual(
response_data["goods_on_licence"][0]["licenced_value_per_item"],
good_on_licence.value / good_on_licence.quantity,
)
self.assertEqual(
len(response_data["goods_on_licence"][0]["control_list_entries"]), good.control_list_entries.count()
)
self.assertEqual(response_data["goods_on_licence"][0]["advice"]["type"]["key"], good_advice.type)
self.assertEqual(response_data["goods_on_licence"][0]["advice"]["text"], good_advice.text)
self.assertEqual(response_data["goods_on_licence"][0]["advice"]["proviso"], good_advice.proviso)
def test_filter_by_final_advice(self):
application = StandardApplicationFactory()
good = GoodFactory(organisation=application.organisation)
FinalAdviceFactory(user=self.gov_user,
team=self.team,
case=application,
good=good,
type=AdviceType.APPROVE)
qs_1 = Case.objects.search(final_advice_type=AdviceType.CONFLICTING)
qs_2 = Case.objects.search(final_advice_type=AdviceType.APPROVE)
self.assertEqual(qs_1.count(), 0)
self.assertEqual(qs_2.count(), 1)
self.assertEqual(qs_2.first().pk, application.pk)
def test_when_removing_a_clc_control_list_entry_from_many_then_new_control_list_entries_is_returned(self):
good = GoodFactory(
organisation=self.organisation, is_good_controlled=True, control_list_entries=["ML1a", "ML1b"]
)
url = reverse("goods:good", kwargs={"pk": str(good.id)})
request_data = {"is_good_controlled": True, "control_list_entries": ["ML1b"]}
response = self.client.put(url, request_data, **self.exporter_headers)
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(
response.json()["good"]["control_list_entries"],
[{"rating": "ML1b", "text": get_control_list_entry("ML1b").text}],
)
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)
def setUp(self):
super().setUp()
self.application = StandardApplicationFactory()
self.licence = LicenceFactory(
case=self.application,
start_date=timezone.now().date(),
status=LicenceStatus.REVOKED,
duration=100,
reference_code="reference",
)
self.good = GoodFactory(organisation=self.application.organisation)
self.good_on_application = GoodOnApplicationFactory(
application=self.application,
good=self.good,
quantity=100.0,
value=Decimal("1000.00"))
self.good_on_licence = GoodOnLicenceFactory(
good=self.good_on_application,
quantity=self.good_on_application.quantity,
usage=20.0,
value=20,
licence=self.licence,
)
class GoodsVerifiedTestsStandardApplication(DataTestClient):
def setUp(self):
super().setUp()
self.report_summary = self.create_picklist_item(
"Report Summary", self.team, PicklistType.REPORT_SUMMARY,
PickListStatus.ACTIVE)
self.good_1 = GoodFactory(
organisation=self.organisation,
flags=[FlagFactory(level=FlagLevels.GOOD, team=self.team)])
self.good_2 = GoodFactory(organisation=self.organisation)
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_standard_application(
organisation=self.organisation)
self.good_on_application_1 = GoodOnApplication.objects.create(
good=self.good_1,
application=self.application,
quantity=10,
unit=Units.NAR,
value=500)
self.good_on_application_2 = GoodOnApplication.objects.create(
good=self.good_2,
application=self.application,
quantity=10,
unit=Units.NAR,
value=500)
self.case = self.submit_application(self.application)
self.url = reverse_lazy("goods:control_list_entries",
kwargs={"case_pk": self.case.id})
def test_verify_multiple_goods(self):
"""
Post multiple goods to the endpoint, and check that the control code is updated for both
"""
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": ["ML1a"],
"is_good_controlled": True,
}
response = self.client.post(self.url, data, **self.gov_headers)
self.assertEquals(response.status_code, status.HTTP_200_OK)
verified_good_1 = Good.objects.get(pk=self.good_1.pk)
verified_good_2 = Good.objects.get(pk=self.good_2.pk)
self.assertEqual(verified_good_1.control_list_entries.get().rating,
"ML1a")
self.assertEqual(verified_good_2.control_list_entries.get().rating,
"ML1a")
def test_verify_multiple_goods_NLR(self):
"""
Post multiple goods to the endpoint, and check that the control code is not set if good is not controlled
"""
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": ["ML1a"],
"is_good_controlled": False,
}
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.good_2.refresh_from_db()
self.assertEqual(self.good_1.control_list_entries.count(), 1)
self.assertEqual(self.good_2.control_list_entries.count(), 1)
def test_invalid_good_pk(self):
# given one of the good pk is invalid
data = {
"objects": [self.team.pk, self.good_1.pk],
"comment": "I Am Easy to Find",
"report_summary": self.report_summary.pk,
"is_good_controlled": False,
"control_list_entries": ["ML1b"],
}
# when I review the goods
response = self.client.post(self.url, data, **self.gov_headers)
self.assertEquals(response.status_code, 200)
# then the valid good is updated
verified_good = Good.objects.get(pk=self.good_1.pk)
self.assertEqual(verified_good.control_list_entries.count(), 1)
@parameterized.expand([
(
# legacy where frontend doesn't send is_precedent
{
"comment": "I Am Easy to Find",
"is_good_controlled": False,
"control_list_entries": [],
},
False,
),
(
# precedent = False
{
"comment": "I Am Easy to Find",
"is_good_controlled": False,
"control_list_entries": [],
"is_precedent": False,
},
False,
),
(
# precedent = True
{
"comment": "I Am Easy to Find",
"is_good_controlled": False,
"control_list_entries": [],
"is_precedent": True,
},
True,
),
])
def test_is_precedent_is_set(self, input, expected_is_precedent):
defaults = {
"objects": [self.good_1.pk],
"report_summary": self.report_summary.pk,
}
data = {**defaults, **input}
# when I review the goods
response = self.client.post(self.url, data, **self.gov_headers)
self.assertEquals(response.status_code, 200)
# then the good_on_application is updated
verified_good_on_application = GoodOnApplication.objects.get(
pk=self.good_on_application_1.pk)
self.assertEqual(verified_good_on_application.is_precedent,
expected_is_precedent)
def test_standard_invalid_control_list_entries(self):
"""
Post multiple goods to the endpoint, and that a bad request is returned, and that flags is not updated
"""
data = {
"objects": [self.good_1.pk, self.good_2.pk],
"comment": "I Am Easy to Find",
"report_summary": self.report_summary.pk,
"is_good_controlled": True,
"control_list_entries": ["invalid"],
}
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
verified_good = Good.objects.get(pk=self.good_1.pk)
self.assertTrue(is_not_verified_flag_set_on_good(verified_good))
def test_standard_controlled_good_empty_control_list_entries(self):
"""
Post multiple goods, with an blank control_list_entries and is controlled, for a 400 response, and no update of goods
"""
data = {
"objects": [self.good_1.pk, self.good_2.pk],
"comment": "I Am Easy to Find",
"report_summary": self.report_summary.pk,
"is_good_controlled": True,
"control_list_entries": [],
}
response = self.client.post(self.url, data, **self.gov_headers)
self.assertEquals(response.status_code, 200)
def test_user_cannot_review_good_without_permissions(self):
"""
Tests that the right level of permissions are required by a gov user to review a good.
"""
# 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)
@parameterized.expand(CaseStatusEnum.terminal_statuses())
def test_cannot_set_control_list_entries_when_application_in_terminal_state(
self, terminal_status):
self.application.status = get_case_status_by_status(terminal_status)
self.application.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": "yes",
}
response = self.client.post(self.url, data, **self.gov_headers)
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
def create_mod_clearance_application(
self,
organisation,
case_type,
reference_name="MOD Clearance Draft",
safe_document=True,
additional_information=True,
):
if case_type == CaseTypeEnum.F680:
model = F680ClearanceApplication
elif case_type == CaseTypeEnum.GIFTING:
model = GiftingClearanceApplication
elif case_type == CaseTypeEnum.EXHIBITION:
model = ExhibitionClearanceApplication
else:
raise BaseException(
"Invalid case type when creating test MOD Clearance application"
)
application = model.objects.create(
name=reference_name,
activity="Trade",
usage="Trade",
organisation=organisation,
case_type_id=case_type.id,
status=get_case_status_by_status(CaseStatusEnum.DRAFT),
clearance_level=PvGrading.UK_UNCLASSIFIED
if case_type == CaseTypeEnum.F680 else None,
submitted_by=self.exporter_user,
)
if case_type == CaseTypeEnum.EXHIBITION:
application.title = "title"
application.required_by_date = "2021-07-20"
application.first_exhibition_date = "2022-08-19"
application.save()
# must be refreshed to return data in same format as database call
application.refresh_from_db()
elif case_type == CaseTypeEnum.F680:
application.types.add(F680ClearanceType.objects.first())
self.create_party("End User", organisation, PartyType.END_USER,
application)
self.create_party("Third party", organisation,
PartyType.THIRD_PARTY, application)
self.add_party_documents(
application,
safe_document,
consignee=case_type == CaseTypeEnum.EXHIBITION)
if additional_information:
self.add_additional_information(application)
application.intended_end_use = "intended end use here"
application.save()
else:
self.create_party("End User", organisation, PartyType.END_USER,
application)
self.create_party("Third party", organisation,
PartyType.THIRD_PARTY, application)
self.add_party_documents(
application,
safe_document,
consignee=case_type == CaseTypeEnum.EXHIBITION)
if case_type not in [
CaseTypeEnum.F680, CaseTypeEnum.EXHIBITION,
CaseTypeEnum.GIFTING
]:
self.create_party("Consignee", organisation, PartyType.CONSIGNEE,
application)
# Add a good to the standard application
self.good_on_application = GoodOnApplication.objects.create(
good=GoodFactory(organisation=organisation,
is_good_controlled=True),
application=application,
quantity=10,
unit=Units.NAR,
value=500,
)
self.create_application_document(application)
if case_type == CaseTypeEnum.EXHIBITION:
# Add a site to the application
SiteOnApplication(site=organisation.primary_site,
application=application).save()
return application
def create_draft_standard_application(
self,
organisation: Organisation,
reference_name="Standard Draft",
safe_document=True,
parties=True,
site=True,
case_type_id=CaseTypeEnum.SIEL.id,
add_a_good=True,
user: ExporterUser = None,
good=None,
):
if not user:
user = UserOrganisationRelationship.objects.filter(
organisation_id=organisation.id).first().user
application = StandardApplication(
name=reference_name,
export_type=ApplicationExportType.PERMANENT,
case_type_id=case_type_id,
have_you_been_informed=ApplicationExportLicenceOfficialType.YES,
reference_number_on_information_form="",
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,
is_eu_military=False,
is_compliant_limitations_eu=None,
intended_end_use="this is our intended end use",
is_shipped_waybill_or_lading=True,
non_waybill_or_lading_route_details=None,
status_id="00000000-0000-0000-0000-000000000000",
submitted_by=user,
)
application.save()
if add_a_good:
# Add a good to the standard application
self.good_on_application = GoodOnApplication.objects.create(
good=good if good else GoodFactory(organisation=organisation,
is_good_controlled=True),
application=application,
quantity=10,
unit=Units.NAR,
value=500,
)
if parties:
self.create_party("End User", organisation, PartyType.END_USER,
application)
self.create_party("Consignee", organisation, PartyType.CONSIGNEE,
application)
self.create_party("Third party", organisation,
PartyType.THIRD_PARTY, application)
# Set the application party documents
self.add_party_documents(application, safe_document)
self.create_application_document(application)
# Add a site to the application
if site:
SiteOnApplication(site=organisation.primary_site,
application=application).save()
return application
generate_compliance_site_case(case)
self.assertFalse(ComplianceSiteCase.objects.exists())
@parameterized.expand([
("ML21", True),
("ML22", True),
("ML2", False),
("0D", True),
])
def tests_siel_good_control_code(self, control_code, exists):
case = self.create_standard_application_case(self.organisation)
good = GoodFactory(
organisation=self.organisation,
is_good_controlled=True,
control_list_entries=[control_code],
)
GoodOnLicenceFactory(
good=GoodOnApplicationFactory(application=case, good=good),
licence=LicenceFactory(case=case),
quantity=100,
value=1,
)
generate_compliance_site_case(case)
self.assertEqual(ComplianceSiteCase.objects.exists(), exists)
def test_multiple_cases_creates_one_compliance_case(self):
# Both cases uses the organisation primary site by default on creation
