def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZTC_URL,
service__api_type="ztc",
alias="ZTC",
)
cls.fetched_task = ExternalTask.objects.create(
topic_name="some-topic",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"zaakUrl": serialize_variable(ZAAK),
"statustype": serialize_variable(STATUSTYPE),
"services": serialize_variable({"ZRC": {"jwt": "Bearer 12345"}}),
"toelichting": serialize_variable("some description"),
},
)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMapping.objects.create(
topic_name="ValidSignReminder",
callback="bptl.work_units.valid_sign.tasks.CreateValidSignPackage",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=VALIDSIGN_URL,
service__api_type="orc",
service__oas=VALIDSIGN_API_DOCS,
alias="ValidSignAPI",
)
cls.fetched_task = ExternalTask.objects.create(
topic_name="ValidSignReminder",
worker_id="reminder-worker-id",
task_id="reminder-task-id",
variables={
"packageId": serialize_variable("BW5fsOKyhj48A-fRwjPyYmZ8Mno="),
"email": serialize_variable("*****@*****.**"),
},
)
def setUpClass(cls):
super().setUpClass()
cls.fetched_task = ServiceTask.objects.create(
topic_name="some-topic",
variables={
"burgerservicenummer": "999999011",
"age": 18,
"bptlAppId": "some-app-id",
},
)
brp = Service.objects.create(
api_root=BRP_API_ROOT,
api_type=APITypes.orc,
auth_type=AuthTypes.api_key,
header_value="12345",
header_key="X-Api-Key",
)
DefaultServiceFactory.create(
task_mapping__topic_name="some-topic",
service=brp,
alias="brp",
)
AppServiceCredentialsFactory.create(
app__app_id="some-app-id",
service=brp,
header_key="Other-Header",
header_value="foobarbaz",
)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=DRC_URL,
service__api_type="drc",
alias="drc",
)
cls.fetched_task = ExternalTask.objects.create(
topic_name="some-topic",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"informatieobject":
serialize_variable(DOCUMENT_URL),
"lockId":
serialize_variable("bacbaeaf-600d-4b79-9414-3e1a668addd3"),
"services":
serialize_variable({
"drc": {
"jwt": "Bearer 12345"
},
}),
},
)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMapping.objects.create(
topic_name="CreateValidSignPackage",
callback="bptl.work_units.valid_sign.tasks.CreateValidSignPackage",
)
drc_svc = DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=DRC_URL,
service__api_type="drc",
alias="drc",
)
cls.drc = drc_svc.service
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=VALIDSIGN_URL,
service__api_type="orc",
service__oas=VALIDSIGN_API_DOCS,
alias="ValidSignAPI",
)
cls.fetched_task = ExternalTask.objects.create(
topic_name="CreateValidSignPackage",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"documents": serialize_variable([DOCUMENT_1, DOCUMENT_2]),
"signers": serialize_variable([SIGNER_1, SIGNER_2]),
"packageName": serialize_variable("Test package name"),
"services": serialize_variable({"drc": {"jwt": "Bearer 12345"}}),
},
)
def setUpTestData(cls):
super().setUpTestData()
xential_service = ServiceFactory.create(api_root=XENTIAL_API_ROOT,
api_type=APITypes.orc)
DefaultServiceFactory.create(alias=XENTIAL_ALIAS,
service=xential_service)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMapping.objects.create(topic_name="some-topic", )
cls.service = Service.objects.create(
label="Kownsl",
api_type=APITypes.orc,
api_root=KOWNSL_API_ROOT,
auth_type=AuthTypes.api_key,
header_key="Authorization",
header_value="Token foobarbaz",
oas=f"{KOWNSL_API_ROOT}schema/openapi.yaml",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service=cls.service,
alias="kownsl",
)
cls.task_dict = {
"topic_name": "some-topic",
"worker_id": "test-worker-id",
"task_id": "test-task-id",
"variables": {
"kownslReviewRequestId": serialize_variable("1"),
},
}
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMapping.objects.create(topic_name="xential-topic", )
xential = Service.objects.create(
label="xential",
api_type=APITypes.orc,
api_root=XENTIAL_API_ROOT,
auth_type=AuthTypes.api_key,
oas="",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service=xential,
alias="xential",
)
drc = Service.objects.create(
label="Documenten API",
api_type=APITypes.drc,
api_root=DRC_ROOT,
auth_type=AuthTypes.api_key,
oas="",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service=drc,
alias="drc",
)
def setUp(self):
super().setUp()
mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=DRC_URL,
service__api_type="drc",
alias="drc",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
self.fetched_task = ExternalTask.objects.create(
topic_name="some-topic",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"zaakUrl": serialize_variable(ZAAK),
"bptlAppId": serialize_variable("some-app-id"),
},
)
def setUpTestData(cls):
super().setUpTestData()
cls.task_dict = {
"topic_name": "send-email",
"worker_id": "test-worker-id",
"task_id": "test-task-id",
"variables": {
"usernames": {
"type": "Json",
"value": '["user:thor", "user:loki"]',
"valueInfo": {},
},
},
}
cls.task_usernames = ExternalTask.objects.create(**cls.task_dict, )
cls.task_emails = ExternalTask.objects.create(
**{
**cls.task_dict,
"variables": {
"emailaddresses": {
"type": "Json",
"value": '["thor@email", "loki@email"]',
"valueInfo": {},
}
},
})
DefaultServiceFactory.create(
task_mapping__topic_name="send-email",
service__api_root=ZAC_API_ROOT,
service__api_type=APITypes.orc,
service__auth_type=AuthTypes.no_auth,
alias="zac",
)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
cls.fetched_task = ExternalTask.objects.create(
topic_name="some-topic",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"zaakUrl": {"type": "String", "value": ZAAK, "valueInfo": {}},
"objectUrl": {"type": "String", "value": OBJECT, "valueInfo": {}},
"objectType": {"type": "String", "value": "adres", "valueInfo": {}},
"services": {
"type": "json",
"value": json.dumps(
{
"ZRC": {"jwt": "Bearer 12345"},
}
),
},
},
)
def test_no_alias_in_process_vars(self):
self.task.variables = {}
self.task.save()
DefaultServiceFactory.create(
task_mapping=self.mapping, service=self.service, alias="ZRC"
)
with self.assertRaisesMessage(
NoService, "Could not determine service credentials."
):
self.work_unit.get_client(APITypes.zrc)
def test_duplicated_alias(self):
DefaultServiceFactory.create(
task_mapping=self.mapping, service=self.service, alias="ZRC"
)
other_service = Service.objects.create(
api_type=APITypes.zrc,
label="other ZRC",
api_root="https://other.zrc.nl/api/v1/",
)
with self.assertRaises(IntegrityError):
DefaultServiceFactory.create(
task_mapping=self.mapping, service=other_service, alias="ZRC"
)
def setUpTestData(cls):
super().setUpTestData()
brp = Service.objects.create(
api_root=BRP_API_ROOT,
api_type=APITypes.orc,
auth_type=AuthTypes.no_auth,
)
DefaultServiceFactory.create(
task_mapping__topic_name="some-topic",
service=brp,
alias="brp",
)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMapping.objects.create(topic_name="xential-topic", )
xential = Service.objects.create(
label="xential",
api_type=APITypes.orc,
api_root=XENTIAL_API_ROOT,
auth_type=AuthTypes.api_key,
oas="",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service=xential,
alias="xential",
)
cls.external_task = ExternalTask.objects.create(
topic_name="xential-topic",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"bptlAppId":
serialize_variable("some-app-id"),
"templateUuid":
serialize_variable("3e09b238-0617-47c1-8e6a-f6227b3d542e"),
"interactive":
serialize_variable(False),
"templateVariables":
serialize_variable({
"textq1": "Answer1",
"dateq1": "31-12-20"
}),
"documentMetadata":
serialize_variable({
"bronorganisatie":
"517439943",
"creatiedatum":
"01-01-2021",
"titel":
"Test Document",
"auteur":
"Test Author",
"taal":
"eng",
"informatieobjecttype":
"http://openzaak.nl/catalogi/api/v1/informatieobjecttypen/06d3a135-bc20-4fce-9add-f69d8e585917",
}),
},
)
def test_no_jwt_in_process_vars(self):
# Deprecated
DefaultServiceFactory.create(
task_mapping=self.mapping, service=self.service, alias="ZRC"
)
self.task.variables = {
"services": serialize_variable({"ZRC": {"some_claims": "some value"}})
}
self.task.save()
err_message = "Expected 'jwt' key for service with alias 'ZRC'"
with self.assertWarns(DeprecationWarning):
with self.assertRaisesMessage(NoAuth, err_message):
self.work_unit.get_client(APITypes.zrc)
def test_multiple_services_same_type(self):
other_service = Service.objects.create(
api_type=APITypes.zrc,
label="other ZRC",
api_root="https://other.zrc.nl/api/v1/",
)
DefaultServiceFactory.create(
task_mapping=self.mapping, service=self.service, alias="ZRC1"
)
DefaultServiceFactory.create(
task_mapping=self.mapping, service=other_service, alias="ZRC2"
)
err_message = "Multiple 'zrc' services configured for topic 'some-topic'"
with self.assertRaisesMessage(MultipleServices, err_message):
self.work_unit.get_client(APITypes.zrc)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZTC_URL,
service__api_type="ztc",
alias="ZTC",
)
def test_get_client_with_alias(self):
# The pre-1.0 behaviour. This is deprecated.
DefaultServiceFactory.create(
task_mapping=self.mapping, service=self.service, alias="ZRC"
)
self.task.variables = {
"services": {
"type": "json",
"value": json.dumps({"ZRC": {"jwt": "Bearer 12345"}}),
}
}
self.task.save()
with self.assertWarns(DeprecationWarning):
client = self.work_unit.get_client(APITypes.zrc)
self.assertEqual(client.base_url, ZRC_URL)
self.assertTrue(client.auth_value, "Bearer 12345")
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZTC_URL,
service__api_type="ztc",
alias="ZTC",
)
cls.fetched_task = ExternalTask.objects.create(
topic_name="some-topic",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"zaakUrl":
serialize_variable(ZAAK),
"omschrijving":
serialize_variable("roltype omschrijving"),
"betrokkene":
serialize_variable({
"betrokkene": "http://some.api.nl/betrokkenen/12345",
"betrokkeneType": "natuurlijk_persoon",
"roltoelichting": "A test roltoelichting",
}),
"services":
serialize_variable({
"ZRC": {
"jwt": "Bearer 12345"
},
"ZTC": {
"jwt": "Bearer 789"
}
}),
},
)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZTC_URL,
service__api_type="ztc",
alias="ZTC",
)
cls.fetched_task = ExternalTask.objects.create(
topic_name="some-topic",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"services":
serialize_variable({
"ZRC": {
"jwt": "Bearer 12345"
},
"ZTC": {
"jwt": "Bearer 12345"
},
}),
"zaakUrl":
serialize_variable(ZAAK),
"eigenschap":
serialize_variable({
"naam": "start",
"waarde": "2020-05-01",
}),
},
)
def setUpTestData(cls):
super().setUpTestData()
zac = Service.objects.create(
api_root=ZAC_API_ROOT,
api_type=APITypes.orc,
auth_type=AuthTypes.api_key,
header_key="Authorization",
header_value=
"Token ThisIsNotTheGreatestTokenInTheWorldThisIsJustATribute",
)
DefaultServiceFactory.create(
task_mapping__topic_name="some-topic",
service=zac,
alias="zac",
)
AppServiceCredentialsFactory.create(
app__app_id="some-app-id",
service=zac,
header_key="Other-Header",
header_value="foobarbaz",
)
def setUpClass(cls):
super().setUpClass()
cls.mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=cls.mapping,
service__api_type=APITypes.zrc,
service__api_root=ZRC_URL,
alias="ZRC",
)
cls.task = ExternalTaskFactory.create(
topic_name="some-topic",
variables={
"services": {
"type": "json",
"value": json.dumps({"ZRC": {
"jwt": "Bearer 12345"
}}),
}
},
)
cls.work_unit = ZGWWorkUnit(cls.task)
def setUpTestData(cls):
super().setUpTestData()
config = CamundaConfig.get_solo()
config.root_url = "https://some.camunda.com"
config.rest_api_path = "engine-rest/"
config.save()
mapping = TaskMapping.objects.create(
topic_name="zaak-initialize",
callback="bptl.work_units.zgw.tasks.zaak.CreateZaakTask",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZTC_URL,
service__api_type="ztc",
alias="ZTC",
)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
cls.fetched_task = ExternalTask.objects.create(
topic_name="some-topic",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"identificatie": serialize_variable("ZAAK-001122"),
"bronorganisatie": serialize_variable("123456782"),
"services":
serialize_variable({"ZRC": {
"jwt": "Bearer 12345"
}}),
},
)
def setUpTestData(cls):
super().setUpTestData()
mapping = TaskMappingFactory.create(topic_name="some-topic")
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
cls.fetched_task = ExternalTask.objects.create(
topic_name="some-topic",
worker_id="test-worker-id",
task_id="test-task-id",
variables={
"zaakUrl": serialize_variable(BIJDRAGE_ZAAK),
"hoofdZaakUrl": serialize_variable(ZAAK),
"bijdrageAard": serialize_variable("bijdrage"),
"services":
serialize_variable({"ZRC": {
"jwt": "Bearer 12345"
}}),
},
)
def setUpTestData(cls):
super().setUpTestData()
default_service = DefaultServiceFactory.create(
task_mapping__topic_name="some-topic",
service__api_root=VALIDSIGN_URL,
service__api_type=APITypes.orc,
service__auth_type=AuthTypes.api_key,
service__oas=VALIDSIGN_API_DOCS,
service__header_key="default-header",
service__header_value="bar",
alias="ValidSignAPI",
)
AppServiceCredentialsFactory.create(
app__app_id="some-app",
service=default_service.service,
header_key="custom-header",
header_value="baz",
)
def test_callback_with_message_id_with_instance_id(self, m):
xential_response = self._get_sample_response("xential-response.xml")
bptl_ticket_uuid = "9c132492-6c7c-4c34-af9d-16322dff89cc"
ticket_uuid = "2d30f19b-8666-4f45-a8da-78ad7ed0ef4d"
# Setting up DRC service
mapping = TaskMapping.objects.create(topic_name="xential-topic", )
drc = Service.objects.create(
label="Documenten API",
api_type=APITypes.drc,
api_root=DRC_ROOT,
auth_type=AuthTypes.api_key,
oas="",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service=drc,
alias="DRC",
)
external_task = ExternalTask.objects.create(
topic_name="xential-topic",
worker_id="test-worker-id",
task_id="test-task-id",
instance_id="test-instance-id",
variables={
"bptlAppId":
serialize_variable("some-app-id"),
"templateUuid":
serialize_variable("3e09b238-0617-47c1-8e6a-f6227b3d542e"),
"interactive":
serialize_variable(False),
"templateVariables":
serialize_variable({
"textq1": "Answer1",
"dateq1": "31-12-20"
}),
"documentMetadata":
serialize_variable({
"bronorganisatie":
"517439943",
"creatiedatum":
"01-01-2021",
"titel":
"Test Document",
"auteur":
"Test Author",
"taal":
"eng",
"informatieobjecttype":
"http://openzaak.nl/catalogi/api/v1/informatieobjecttypen/06d3a135-bc20-4fce-9add-f69d8e585917",
}),
"messageId":
serialize_variable("document-created"),
},
)
# Mock calls
m.post(
"https://openzaak.nl/documenten/api/v1/enkelvoudiginformatieobjecten",
json={
"identificatie":
"DOCUMENT-0001",
"url":
"https://openzaak.nl/documenten/api/v1/enkelvoudiginformatieobjecten/15f4c2e8-f900-4fd1-8f31-44163d369c93",
"bronorganisatie":
"517439943",
"creatiedatum":
"01-01-2021",
"titel":
"Test Document",
"auteur":
"Test Author",
"taal":
"eng",
"informatieobjecttype":
"http://openzaak.nl/catalogi/api/v1/informatieobjecttypen/06d3a135-bc20-4fce-9add-f69d8e585917",
},
)
m.post("https://camunda.example.com/engine-rest/message")
XentialTicket.objects.create(
task=external_task,
bptl_ticket_uuid=bptl_ticket_uuid,
ticket_uuid=ticket_uuid,
)
callback_response = self.client.post(
self.endpoint,
content_type="text/xml",
data=xential_response,
HTTP_AUTHORIZATION=f"Basic {self.auth_key}",
)
self.assertEqual(status.HTTP_204_NO_CONTENT,
callback_response.status_code)
def test_full_process(self, m):
mapping = TaskMapping.objects.create(
topic_name="zaak-initialize",
callback="bptl.work_units.zgw.tasks.zaak.CreateZaakTask",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZRC_URL,
service__api_type="zrc",
alias="ZRC",
)
DefaultServiceFactory.create(
task_mapping=mapping,
service__api_root=ZTC_URL,
service__api_type="ztc",
alias="ZTC",
)
data = {
"topic": "zaak-initialize",
"vars": {
"zaaktype": ZAAKTYPE,
"organisatieRSIN": "002220647",
"services": {
"ZRC": {
"jwt": "Bearer 12345"
},
"ZTC": {
"jwt": "Bearer 789"
},
},
},
}
url = reverse("work-unit",
args=(settings.REST_FRAMEWORK["DEFAULT_VERSION"], ))
# mock openzaak services
mock_service_oas_get(m, ZTC_URL, "ztc")
mock_service_oas_get(m, ZRC_URL, "zrc")
m.get(
f"{ZTC_URL}statustypen?zaaktype={ZAAKTYPE}",
json={
"count":
1,
"next":
None,
"previous":
None,
"results": [
{
"url": STATUSTYPE,
"omschrijving": "initial",
"zaaktype": ZAAKTYPE,
"volgnummer": 1,
"isEindstatus": False,
"informeren": False,
},
],
},
)
m.post(
f"{ZRC_URL}zaken",
status_code=201,
json=RESPONSES[ZAAK],
)
m.post(
f"{ZRC_URL}statussen",
status_code=201,
json={
"url": STATUS,
"uuid": "b7218c76-7478-41e9-a088-54d2f914a713",
"zaak": ZAAK,
"statustype": STATUSTYPE,
"datumStatusGezet": "2020-01-16T00:00:00.000000Z",
"statustoelichting": "",
},
)
response = self.client.post(url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
service_task = ServiceTask.objects.get()
self.assertEqual(service_task.topic_name, "zaak-initialize")
self.assertEqual(service_task.status, Statuses.performed)
data_response = response.json()
expected_response = data.copy()
expected_response["resultVars"] = {
"zaakUrl": ZAAK,
"zaakIdentificatie": "ZAAK-2020-0000000013",
}
self.assertEqual(data_response, expected_response)
def test_multiple_services(self, m):
task_mapping = TaskMappingFactory.create(
topic_name="some-different-topic")
another_xential_api_root = "http://another.xential.nl/api/"
xential_service = ServiceFactory.create(
api_root=another_xential_api_root, api_type=APITypes.orc)
DefaultServiceFactory.create(alias=XENTIAL_ALIAS,
service=xential_service,
task_mapping=task_mapping)
user = SuperUserFactory.create()
# First Xential API
m.post(
f"{XENTIAL_API_ROOT}auth/whoami",
json={
"user": {
"uuid": "a4664ccb-259e-4107-b800-d8e5a764b9dd",
"userName": "******",
},
"XSessionId": "f7f588eb-b7c9-4d23-babd-4a98a9326367",
},
)
m.post(
f"{XENTIAL_API_ROOT}template_utils/getUsableTemplates",
json={
"objects": [{
"uuid": "uuid-1",
"objectTypeId": "templategroup",
"fields": [{
"name": "name",
"value": "Sjablonen"
}],
}]
},
)
m.post(
f"{XENTIAL_API_ROOT}template_utils/getUsableTemplates?parentGroupUuid=uuid-1",
json={
"objects": [{
"uuid":
"uuid-2",
"objectTypeId":
"ooxmltexttemplate",
"fields": [{
"name": "name",
"value": "TestSjabloon"
}],
}]
},
)
# Second Xential api
m.post(
f"{another_xential_api_root}auth/whoami",
json={
"user": {
"uuid": "a4664ccb-259e-4107-b800-d8e5a764b9dd",
"userName": "******",
},
"XSessionId": "f7f588eb-b7c9-4d23-babd-4a98a9326367",
},
)
m.post(
f"{another_xential_api_root}template_utils/getUsableTemplates",
json={
"objects": [{
"uuid": "uuid-1",
"objectTypeId": "templategroup",
"fields": [{
"name": "name",
"value": "Sjablonen"
}],
}]
},
)
m.post(
f"{another_xential_api_root}template_utils/getUsableTemplates?parentGroupUuid=uuid-1",
json={
"objects": [{
"uuid":
"uuid-2",
"objectTypeId":
"ooxmltexttemplate",
"fields": [{
"name": "name",
"value": "TestSjabloon"
}],
}]
},
)
page = self.app.get(self.url, user=user)
self.assertEqual(page.status_code, 200)
self.assertIn("template_groups", page.context)
template_group_context = page.context["template_groups"]
self.assertEqual(2, len(template_group_context))
