spiff-arena/tests/spiffworkflow_backend/integration/test_process_api.py

1675 lines
68 KiB
Python

"""Test Process Api Blueprint."""
import io
import json
import time
from typing import Any
import pytest
from flask.app import Flask
from flask.testing import FlaskClient
from flask_bpmn.models.db import db
from tests.spiffworkflow_backend.helpers.base_test import BaseTest
from tests.spiffworkflow_backend.helpers.test_data import load_test_spec
from spiffworkflow_backend.exceptions.process_entity_not_found_error import (
ProcessEntityNotFoundError,
)
from spiffworkflow_backend.models.active_task import ActiveTaskModel
from spiffworkflow_backend.models.process_group import ProcessGroup
from spiffworkflow_backend.models.process_group import ProcessGroupSchema
from spiffworkflow_backend.models.process_instance import ProcessInstanceModel
from spiffworkflow_backend.models.process_instance import ProcessInstanceStatus
from spiffworkflow_backend.models.process_instance_report import (
ProcessInstanceReportModel,
)
from spiffworkflow_backend.models.process_model import NotificationType
from spiffworkflow_backend.models.process_model import ProcessModelInfoSchema
from spiffworkflow_backend.models.task_event import TaskEventModel
from spiffworkflow_backend.models.user import UserModel
from spiffworkflow_backend.services.file_system_service import FileSystemService
from spiffworkflow_backend.services.process_instance_processor import (
ProcessInstanceProcessor,
)
from spiffworkflow_backend.services.process_model_service import ProcessModelService
# from spiffworkflow_backend.services.git_service import GitService
class TestProcessApi(BaseTest):
"""TestProcessAPi."""
def test_process_model_add(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_add_new_process_model."""
process_model_identifier = "sample"
model_display_name = "Sample"
model_description = "The sample"
self.create_process_model_with_api(
client,
process_model_id=process_model_identifier,
process_model_display_name=model_display_name,
process_model_description=model_description,
)
process_model = ProcessModelService().get_process_model(
process_model_identifier
)
assert model_display_name == process_model.display_name
assert 0 == process_model.display_order
assert 1 == len(ProcessModelService().get_process_groups())
bpmn_file_name = "sample.bpmn"
bpmn_file_data_bytes = self.get_test_data_file_contents(
bpmn_file_name, "sample"
)
self.create_spec_file(
client,
file_name=bpmn_file_name,
file_data=bpmn_file_data_bytes,
process_model=process_model,
)
process_model = ProcessModelService().get_process_model(
process_model_identifier
)
assert process_model.primary_file_name == bpmn_file_name
assert process_model.primary_process_id == "sample"
def test_primary_process_id_updates_via_xml(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_primary_process_id_updates_via_xml."""
process_model_identifier = "sample"
initial_primary_process_id = "sample"
terminal_primary_process_id = "new_process_id"
process_model = load_test_spec(process_model_id=process_model_identifier)
assert process_model.primary_process_id == initial_primary_process_id
bpmn_file_name = "sample.bpmn"
bpmn_file_data_bytes = self.get_test_data_file_contents(
bpmn_file_name, "sample"
)
bpmn_file_data_string = bpmn_file_data_bytes.decode("utf-8")
old_string = f'bpmn:process id="{initial_primary_process_id}"'
new_string = f'bpmn:process id="{terminal_primary_process_id}"'
updated_bpmn_file_data_string = bpmn_file_data_string.replace(
old_string, new_string
)
updated_bpmn_file_data_bytes = bytearray(updated_bpmn_file_data_string, "utf-8")
data = {"file": (io.BytesIO(updated_bpmn_file_data_bytes), bpmn_file_name)}
user = self.find_or_create_user()
response = client.put(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}/files/{bpmn_file_name}",
data=data,
follow_redirects=True,
content_type="multipart/form-data",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
process_model = ProcessModelService().get_process_model(
process_model_identifier
)
assert process_model.primary_file_name == bpmn_file_name
assert process_model.primary_process_id == terminal_primary_process_id
def test_process_model_delete(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_delete."""
self.create_process_model_with_api(client)
# assert we have a model
process_model = ProcessModelService().get_process_model("make_cookies")
assert process_model is not None
assert process_model.id == "make_cookies"
# delete the model
user = self.find_or_create_user()
response = client.delete(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert response.json["ok"] is True
# assert we no longer have a model
with pytest.raises(ProcessEntityNotFoundError):
ProcessModelService().get_process_model("make_cookies")
def test_process_model_delete_with_instances(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_delete_with_instances."""
test_process_group_id = "runs_without_input"
test_process_model_id = "sample"
user = self.find_or_create_user()
headers = self.logged_in_headers(user)
# create an instance from a model
response = self.create_process_instance(
client, test_process_group_id, test_process_model_id, headers
)
data = json.loads(response.get_data(as_text=True))
# make sure the instance has the correct model
assert data["process_model_identifier"] == test_process_model_id
# try to delete the model
response = client.delete(
f"/v1.0/process-models/{test_process_group_id}/{test_process_model_id}",
headers=self.logged_in_headers(user),
)
# make sure we get an error in the response
assert response.status_code == 400
data = json.loads(response.get_data(as_text=True))
assert data["error_code"] == "existing_instances"
assert (
data["message"]
== "We cannot delete the model `sample`, there are existing instances that depend on it."
)
def test_process_model_update(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_update."""
self.create_process_model_with_api(client)
process_model = ProcessModelService().get_process_model("make_cookies")
assert process_model.id == "make_cookies"
assert process_model.display_name == "Cooooookies"
assert process_model.is_review is False
assert process_model.primary_file_name is None
assert process_model.primary_process_id is None
process_model.display_name = "Updated Display Name"
process_model.primary_file_name = "superduper.bpmn"
process_model.primary_process_id = "superduper"
process_model.is_review = True # not in the include list, so get ignored
user = self.find_or_create_user()
response = client.put(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}",
headers=self.logged_in_headers(user),
content_type="application/json",
data=json.dumps(ProcessModelInfoSchema().dump(process_model)),
)
assert response.status_code == 200
assert response.json is not None
assert response.json["display_name"] == "Updated Display Name"
assert response.json["primary_file_name"] == "superduper.bpmn"
assert response.json["primary_process_id"] == "superduper"
assert response.json["is_review"] is False
def test_process_model_list(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_list."""
# create a group
group_id = "test_group"
user = self.find_or_create_user()
self.create_process_group(client, user, group_id)
# add 5 models to the group
for i in range(5):
process_model_identifier = f"test_model_{i}"
model_display_name = f"Test Model {i}"
model_description = f"Test Model {i} Description"
self.create_process_model_with_api(
client,
group_id,
process_model_identifier,
model_display_name,
model_description,
)
# get all models
response = client.get(
f"/v1.0/process-models?process_group_identifier={group_id}",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert len(response.json["results"]) == 5
assert response.json["pagination"]["count"] == 5
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 1
# get first page, 1 per page
response = client.get(
f"/v1.0/process-models?page=1&per_page=1&process_group_identifier={group_id}",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert len(response.json["results"]) == 1
assert response.json["results"][0]["id"] == "test_model_0"
assert response.json["pagination"]["count"] == 1
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 5
# get second page, 1 per page
response = client.get(
f"/v1.0/process-models?page=2&per_page=1&process_group_identifier={group_id}",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert len(response.json["results"]) == 1
assert response.json["results"][0]["id"] == "test_model_1"
assert response.json["pagination"]["count"] == 1
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 5
# get first page, 3 per page
response = client.get(
f"/v1.0/process-models?page=1&per_page=3&process_group_identifier={group_id}",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert len(response.json["results"]) == 3
assert response.json["results"][0]["id"] == "test_model_0"
assert response.json["pagination"]["count"] == 3
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 2
# get second page, 3 per page
response = client.get(
f"/v1.0/process-models?page=2&per_page=3&process_group_identifier={group_id}",
headers=self.logged_in_headers(user),
)
# there should only be 2 left
assert response.json is not None
assert len(response.json["results"]) == 2
assert response.json["results"][0]["id"] == "test_model_3"
assert response.json["pagination"]["count"] == 2
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 2
def test_process_group_add(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_add_process_group."""
process_group = ProcessGroup(
id="test",
display_name="Another Test Category",
display_order=0,
admin=False,
)
user = self.find_or_create_user()
response = client.post(
"/v1.0/process-groups",
headers=self.logged_in_headers(user),
content_type="application/json",
data=json.dumps(ProcessGroupSchema().dump(process_group)),
)
assert response.status_code == 201
# Check what is returned
result = ProcessGroupSchema().loads(response.get_data(as_text=True))
assert result is not None
assert result.display_name == "Another Test Category"
assert result.id == "test"
# Check what is persisted
persisted = ProcessModelService().get_process_group("test")
assert persisted.display_name == "Another Test Category"
assert persisted.id == "test"
def test_process_group_delete(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_group_delete."""
process_group_id = "test"
process_group_display_name = "My Process Group"
user = self.find_or_create_user()
self.create_process_group(
client, user, process_group_id, display_name=process_group_display_name
)
persisted = ProcessModelService().get_process_group(process_group_id)
assert persisted is not None
assert persisted.id == process_group_id
client.delete(
f"/v1.0/process-groups/{process_group_id}",
headers=self.logged_in_headers(user),
)
with pytest.raises(ProcessEntityNotFoundError):
ProcessModelService().get_process_group(process_group_id)
def test_process_group_update(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test Process Group Update."""
group_id = "test_process_group"
group_display_name = "Test Group"
user = self.find_or_create_user()
self.create_process_group(
client, user, group_id, display_name=group_display_name
)
process_group = ProcessModelService().get_process_group(group_id)
assert process_group.display_name == group_display_name
process_group.display_name = "Modified Display Name"
response = client.put(
f"/v1.0/process-groups/{group_id}",
headers=self.logged_in_headers(user),
content_type="application/json",
data=json.dumps(ProcessGroupSchema().dump(process_group)),
)
assert response.status_code == 200
process_group = ProcessModelService().get_process_group(group_id)
assert process_group.display_name == "Modified Display Name"
def test_process_group_list(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_group_list."""
# add 5 groups
user = self.find_or_create_user()
for i in range(5):
group_id = f"test_process_group_{i}"
group_display_name = f"Test Group {i}"
self.create_process_group(
client, user, group_id, display_name=group_display_name
)
# get all groups
response = client.get(
"/v1.0/process-groups",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert len(response.json["results"]) == 5
assert response.json["pagination"]["count"] == 5
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 1
# get first page, one per page
response = client.get(
"/v1.0/process-groups?page=1&per_page=1",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert len(response.json["results"]) == 1
assert response.json["results"][0]["id"] == "test_process_group_0"
assert response.json["pagination"]["count"] == 1
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 5
# get second page, one per page
response = client.get(
"/v1.0/process-groups?page=2&per_page=1",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert len(response.json["results"]) == 1
assert response.json["results"][0]["id"] == "test_process_group_1"
assert response.json["pagination"]["count"] == 1
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 5
# get first page, 3 per page
response = client.get(
"/v1.0/process-groups?page=1&per_page=3",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert len(response.json["results"]) == 3
assert response.json["results"][0]["id"] == "test_process_group_0"
assert response.json["results"][1]["id"] == "test_process_group_1"
assert response.json["results"][2]["id"] == "test_process_group_2"
assert response.json["pagination"]["count"] == 3
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 2
# get second page, 3 per page
response = client.get(
"/v1.0/process-groups?page=2&per_page=3",
headers=self.logged_in_headers(user),
)
# there should only be 2 left
assert response.json is not None
assert len(response.json["results"]) == 2
assert response.json["results"][0]["id"] == "test_process_group_3"
assert response.json["results"][1]["id"] == "test_process_group_4"
assert response.json["pagination"]["count"] == 2
assert response.json["pagination"]["total"] == 5
assert response.json["pagination"]["pages"] == 2
def test_process_model_file_update_fails_if_no_file_given(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_file_update."""
self.create_spec_file(client)
process_model = load_test_spec("random_fact")
data = {"key1": "THIS DATA"}
user = self.find_or_create_user()
response = client.put(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}/files/random_fact.svg",
data=data,
follow_redirects=True,
content_type="multipart/form-data",
headers=self.logged_in_headers(user),
)
assert response.status_code == 400
assert response.json is not None
assert response.json["error_code"] == "no_file_given"
def test_process_model_file_update_fails_if_contents_is_empty(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_file_update."""
self.create_spec_file(client)
process_model = load_test_spec("random_fact")
data = {"file": (io.BytesIO(b""), "random_fact.svg")}
user = self.find_or_create_user()
response = client.put(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}/files/random_fact.svg",
data=data,
follow_redirects=True,
content_type="multipart/form-data",
headers=self.logged_in_headers(user),
)
assert response.status_code == 400
assert response.json is not None
assert response.json["error_code"] == "file_contents_empty"
def test_process_model_file_update(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_file_update."""
original_file = self.create_spec_file(client)
process_model = load_test_spec("random_fact")
new_file_contents = b"THIS_IS_NEW_DATA"
data = {"file": (io.BytesIO(new_file_contents), "random_fact.svg")}
user = self.find_or_create_user()
response = client.put(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}/files/random_fact.svg",
data=data,
follow_redirects=True,
content_type="multipart/form-data",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert response.json["ok"]
response = client.get(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}/files/random_fact.svg",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
updated_file = json.loads(response.get_data(as_text=True))
assert original_file != updated_file
assert updated_file["file_contents"] == new_file_contents.decode()
def test_process_model_file_delete_when_bad_process_model(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_file_update."""
self.create_spec_file(client)
process_model = load_test_spec("random_fact")
user = self.find_or_create_user()
response = client.delete(
f"/v1.0/process-models/INCORRECT-NON-EXISTENT-GROUP/{process_model.id}/files/random_fact.svg",
follow_redirects=True,
headers=self.logged_in_headers(user),
)
assert response.status_code == 400
assert response.json is not None
assert response.json["error_code"] == "process_model_cannot_be_found"
def test_process_model_file_delete_when_bad_file(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_file_update."""
self.create_spec_file(client)
process_model = load_test_spec("random_fact")
user = self.find_or_create_user()
response = client.delete(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}/files/random_fact_DOES_NOT_EXIST.svg",
follow_redirects=True,
headers=self.logged_in_headers(user),
)
assert response.status_code == 400
assert response.json is not None
assert response.json["error_code"] == "process_model_file_cannot_be_found"
def test_process_model_file_delete(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_file_update."""
self.create_spec_file(client)
process_model = load_test_spec("random_fact")
user = self.find_or_create_user()
response = client.delete(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}/files/random_fact.svg",
follow_redirects=True,
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert response.json["ok"]
response = client.get(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}/files/random_fact.svg",
headers=self.logged_in_headers(user),
)
assert response.status_code == 404
def test_get_file(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_get_file."""
user = self.find_or_create_user()
test_process_group_id = "group_id1"
process_model_dir_name = "hello_world"
load_test_spec(process_model_dir_name, process_group_id=test_process_group_id)
response = client.get(
f"/v1.0/process-models/{test_process_group_id}/{process_model_dir_name}/files/hello_world.bpmn",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert response.json["name"] == "hello_world.bpmn"
assert response.json["process_group_id"] == "group_id1"
assert response.json["process_model_id"] == "hello_world"
def test_get_workflow_from_workflow_spec(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_get_workflow_from_workflow_spec."""
user = self.find_or_create_user()
process_model = load_test_spec("hello_world")
response = client.post(
f"/v1.0/process-models/{process_model.process_group_id}/{process_model.id}/process-instances",
headers=self.logged_in_headers(user),
)
assert response.status_code == 201
assert response.json is not None
assert "hello_world" == response.json["process_model_identifier"]
# assert('Task_GetName' == response.json['next_task']['name'])
def test_get_process_groups_when_none(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_get_process_groups_when_none."""
user = self.find_or_create_user()
response = client.get(
"/v1.0/process-groups", headers=self.logged_in_headers(user)
)
assert response.status_code == 200
assert response.json is not None
assert response.json["results"] == []
def test_get_process_groups_when_there_are_some(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_get_process_groups_when_there_are_some."""
user = self.find_or_create_user()
load_test_spec("hello_world")
response = client.get(
"/v1.0/process-groups", headers=self.logged_in_headers(user)
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json["results"]) == 1
assert response.json["pagination"]["count"] == 1
assert response.json["pagination"]["total"] == 1
assert response.json["pagination"]["pages"] == 1
def test_get_process_group_when_found(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_get_process_group_when_found."""
user = self.find_or_create_user()
test_process_group_id = "group_id1"
process_model_dir_name = "hello_world"
load_test_spec(process_model_dir_name, process_group_id=test_process_group_id)
response = client.get(
f"/v1.0/process-groups/{test_process_group_id}",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert response.json["id"] == test_process_group_id
assert response.json["process_models"][0]["id"] == process_model_dir_name
def test_get_process_model_when_found(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_get_process_model_when_found."""
user = self.find_or_create_user()
test_process_group_id = "group_id1"
process_model_dir_name = "hello_world"
load_test_spec(process_model_dir_name, process_group_id=test_process_group_id)
response = client.get(
f"/v1.0/process-models/{test_process_group_id}/{process_model_dir_name}",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert response.json["id"] == process_model_dir_name
assert len(response.json["files"]) == 1
assert response.json["files"][0]["name"] == "hello_world.bpmn"
def test_get_process_model_when_not_found(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_get_process_model_when_not_found."""
user = self.find_or_create_user()
process_model_dir_name = "THIS_NO_EXISTS"
group_id = self.create_process_group(client, user, "my_group")
response = client.get(
f"/v1.0/process-models/{group_id}/{process_model_dir_name}",
headers=self.logged_in_headers(user),
)
assert response.status_code == 400
assert response.json is not None
assert response.json["error_code"] == "process_model_cannot_be_found"
def test_process_instance_create(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_create."""
test_process_group_id = "runs_without_input"
test_process_model_id = "sample"
user = self.find_or_create_user()
headers = self.logged_in_headers(user)
response = self.create_process_instance(
client, test_process_group_id, test_process_model_id, headers
)
assert response.json is not None
assert response.json["updated_at_in_seconds"] is not None
assert response.json["status"] == "not_started"
assert response.json["process_model_identifier"] == test_process_model_id
# TODO: mock out the responses for the git service so we can do something like this
# current_revision = GitService.get_current_revision()
# assert response.json["bpmn_version_control_identifier"] == current_revision
def test_process_instance_run(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_run."""
process_group_id = "runs_without_input"
process_model_id = "sample"
user = self.find_or_create_user()
headers = self.logged_in_headers(user)
response = self.create_process_instance(
client, process_group_id, process_model_id, headers
)
assert response.json is not None
process_instance_id = response.json["id"]
response = client.post(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert type(response.json["updated_at_in_seconds"]) is int
assert response.json["updated_at_in_seconds"] > 0
assert response.json["status"] == "complete"
assert response.json["process_model_identifier"] == process_model_id
assert response.json["data"]["current_user"]["username"] == user.username
assert response.json["data"]["Mike"] == "Awesome"
assert response.json["data"]["person"] == "Kevin"
def test_process_instance_show(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_show."""
process_group_id = "simple_script"
process_model_id = "simple_script"
user = self.find_or_create_user()
headers = self.logged_in_headers(user)
create_response = self.create_process_instance(
client, process_group_id, process_model_id, headers
)
assert create_response.json is not None
process_instance_id = create_response.json["id"]
client.post(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
show_response = client.get(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}",
headers=self.logged_in_headers(user),
)
assert show_response.json is not None
file_system_root = FileSystemService.root_path()
file_path = f"{file_system_root}/{process_group_id}/{process_model_id}/{process_model_id}.bpmn"
with open(file_path) as f_open:
xml_file_contents = f_open.read()
assert show_response.json["bpmn_xml_file_contents"] == xml_file_contents
def test_message_start_when_starting_process_instance(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_message_start_when_starting_process_instance."""
# ensure process model is loaded in db
load_test_spec(
"message_receiver",
process_model_source_directory="message_send_one_conversation",
bpmn_file_name="message_receiver",
)
user = self.find_or_create_user()
message_model_identifier = "message_send"
payload = {
"topica": "the_topica_string",
"topicb": "the_topicb_string",
"andThis": "another_item_non_key",
}
response = client.post(
f"/v1.0/messages/{message_model_identifier}",
content_type="application/json",
headers=self.logged_in_headers(user),
data=json.dumps({"payload": payload}),
)
assert response.status_code == 200
json_data = response.json
assert json_data
assert json_data["status"] == "complete"
process_instance_id = json_data["id"]
process_instance = ProcessInstanceModel.query.filter_by(
id=process_instance_id
).first()
assert process_instance
processor = ProcessInstanceProcessor(process_instance)
process_instance_data = processor.get_data()
assert process_instance_data
assert process_instance_data["the_payload"] == payload
def test_message_start_when_providing_message_to_running_process_instance(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_message_start_when_providing_message_to_running_process_instance."""
process_model = load_test_spec(
"message_sender",
process_model_source_directory="message_send_one_conversation",
bpmn_file_name="message_sender",
)
user = self.find_or_create_user()
message_model_identifier = "message_response"
payload = {
"the_payload": {
"topica": "the_payload.topica_string",
"topicb": "the_payload.topicb_string",
"andThis": "another_item_non_key",
}
}
response = self.create_process_instance(
client,
process_model.process_group_id,
process_model.id,
self.logged_in_headers(user),
)
assert response.json is not None
process_instance_id = response.json["id"]
response = client.post(
f"/v1.0/process-models/{process_model.process_group_id}/"
f"{process_model.id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
assert response.json is not None
response = client.post(
f"/v1.0/messages/{message_model_identifier}",
content_type="application/json",
headers=self.logged_in_headers(user),
data=json.dumps(
{"payload": payload, "process_instance_id": process_instance_id}
),
)
assert response.status_code == 200
json_data = response.json
assert json_data
assert json_data["status"] == "complete"
process_instance_id = json_data["id"]
process_instance = ProcessInstanceModel.query.filter_by(
id=process_instance_id
).first()
assert process_instance
processor = ProcessInstanceProcessor(process_instance)
process_instance_data = processor.get_data()
assert process_instance_data
assert process_instance_data["the_payload"] == payload
def test_process_instance_can_be_terminated(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_message_start_when_providing_message_to_running_process_instance."""
# this task will wait on a catch event
process_model = load_test_spec(
"message_sender",
process_model_source_directory="message_send_one_conversation",
bpmn_file_name="message_sender",
)
user = self.find_or_create_user()
response = self.create_process_instance(
client,
process_model.process_group_id,
process_model.id,
self.logged_in_headers(user),
)
assert response.json is not None
process_instance_id = response.json["id"]
response = client.post(
f"/v1.0/process-models/{process_model.process_group_id}/"
f"{process_model.id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
response = client.post(
f"/v1.0/process-models/{process_model.process_group_id}/"
f"{process_model.id}/process-instances/{process_instance_id}/terminate",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
process_instance = ProcessInstanceModel.query.filter_by(
id=process_instance_id
).first()
assert process_instance
assert process_instance.status == "terminated"
def test_process_instance_delete(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_delete."""
process_group_id = "my_process_group"
process_model_id = "user_task"
user = self.find_or_create_user()
headers = self.logged_in_headers(user)
response = self.create_process_instance(
client, process_group_id, process_model_id, headers
)
assert response.json is not None
process_instance_id = response.json["id"]
response = client.post(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
assert response.json is not None
task_events = (
db.session.query(TaskEventModel)
.filter(TaskEventModel.process_instance_id == process_instance_id)
.all()
)
assert len(task_events) == 1
task_event = task_events[0]
assert task_event.user_id == user.id
delete_response = client.delete(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}",
headers=self.logged_in_headers(user),
)
assert delete_response.status_code == 200
def test_process_instance_run_user_task_creates_task_event(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_run_user_task."""
process_group_id = "my_process_group"
process_model_id = "user_task"
user = self.find_or_create_user()
headers = self.logged_in_headers(user)
response = self.create_process_instance(
client, process_group_id, process_model_id, headers
)
assert response.json is not None
process_instance_id = response.json["id"]
response = client.post(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
assert response.json is not None
task_events = (
db.session.query(TaskEventModel)
.filter(TaskEventModel.process_instance_id == process_instance_id)
.all()
)
assert len(task_events) == 1
task_event = task_events[0]
assert task_event.user_id == user.id
# TODO: When user tasks work, we need to add some more assertions for action, task_state, etc.
def test_task_show(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_run_user_task."""
process_group_id = "my_process_group"
process_model_id = "dynamic_enum_select_fields"
user = self.find_or_create_user()
headers = self.logged_in_headers(user)
response = self.create_process_instance(
client, process_group_id, process_model_id, headers
)
assert response.json is not None
process_instance_id = response.json["id"]
response = client.post(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
assert response.json is not None
active_tasks = (
db.session.query(ActiveTaskModel)
.filter(ActiveTaskModel.process_instance_id == process_instance_id)
.all()
)
assert len(active_tasks) == 1
active_task = active_tasks[0]
response = client.get(
f"/v1.0/tasks/{process_instance_id}/{active_task.task_id}",
headers=self.logged_in_headers(user),
)
assert response.json is not None
assert (
response.json["form_schema"]["definitions"]["Color"]["anyOf"][1]["title"]
== "Green"
)
def test_process_instance_list_with_default_list(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_list_with_default_list."""
test_process_group_id = "runs_without_input"
process_model_dir_name = "sample"
user = self.find_or_create_user()
headers = self.logged_in_headers(user)
self.create_process_instance(
client, test_process_group_id, process_model_dir_name, headers
)
response = client.get(
"/v1.0/process-instances",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json["results"]) == 1
assert response.json["pagination"]["count"] == 1
assert response.json["pagination"]["pages"] == 1
assert response.json["pagination"]["total"] == 1
process_instance_dict = response.json["results"][0]
assert type(process_instance_dict["id"]) is int
assert (
process_instance_dict["process_model_identifier"] == process_model_dir_name
)
assert (
process_instance_dict["process_group_identifier"] == test_process_group_id
)
assert type(process_instance_dict["start_in_seconds"]) is int
assert process_instance_dict["start_in_seconds"] > 0
assert process_instance_dict["end_in_seconds"] is None
assert process_instance_dict["status"] == "not_started"
def test_process_instance_list_with_paginated_items(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_list_with_paginated_items."""
test_process_group_id = "runs_without_input"
process_model_dir_name = "sample"
user = self.find_or_create_user()
headers = self.logged_in_headers(user)
self.create_process_instance(
client, test_process_group_id, process_model_dir_name, headers
)
self.create_process_instance(
client, test_process_group_id, process_model_dir_name, headers
)
self.create_process_instance(
client, test_process_group_id, process_model_dir_name, headers
)
self.create_process_instance(
client, test_process_group_id, process_model_dir_name, headers
)
self.create_process_instance(
client, test_process_group_id, process_model_dir_name, headers
)
response = client.get(
"/v1.0/process-instances?per_page=2&page=3",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json["results"]) == 1
assert response.json["pagination"]["count"] == 1
assert response.json["pagination"]["pages"] == 3
assert response.json["pagination"]["total"] == 5
response = client.get(
"/v1.0/process-instances?per_page=2&page=1",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json["results"]) == 2
assert response.json["pagination"]["count"] == 2
assert response.json["pagination"]["pages"] == 3
assert response.json["pagination"]["total"] == 5
def test_process_instance_list_filter(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_list_filter."""
test_process_group_id = "runs_without_input"
test_process_model_id = "sample"
user = self.find_or_create_user()
load_test_spec(test_process_model_id, process_group_id=test_process_group_id)
statuses = [status.value for status in ProcessInstanceStatus]
# create 5 instances with different status, and different start_in_seconds/end_in_seconds
for i in range(5):
process_instance = ProcessInstanceModel(
status=ProcessInstanceStatus[statuses[i]].value,
process_initiator=user,
process_model_identifier=test_process_model_id,
process_group_identifier=test_process_group_id,
updated_at_in_seconds=round(time.time()),
start_in_seconds=(1000 * i) + 1000,
end_in_seconds=(1000 * i) + 2000,
bpmn_json=json.dumps({"i": i}),
)
db.session.add(process_instance)
db.session.commit()
# Without filtering we should get all 5 instances
response = client.get(
f"/v1.0/process-instances?process_group_identifier={test_process_group_id}&process_model_identifier={test_process_model_id}",
headers=self.logged_in_headers(user),
)
assert response.json is not None
results = response.json["results"]
assert len(results) == 5
# filter for each of the status
# we should get 1 instance each time
for i in range(5):
response = client.get(
f"/v1.0/process-instances?process_status={ProcessInstanceStatus[statuses[i]].value}&process_group_identifier={test_process_group_id}&process_model_identifier={test_process_model_id}",
headers=self.logged_in_headers(user),
)
assert response.json is not None
results = response.json["results"]
assert len(results) == 1
assert results[0]["status"] == ProcessInstanceStatus[statuses[i]].value
response = client.get(
f"/v1.0/process-instances?process_status=not_started,complete&process_group_identifier={test_process_group_id}&process_model_identifier={test_process_model_id}",
headers=self.logged_in_headers(user),
)
assert response.json is not None
results = response.json["results"]
assert len(results) == 2
assert results[0]["status"] in ["complete", "not_started"]
assert results[1]["status"] in ["complete", "not_started"]
# filter by start/end seconds
# start > 1000 - this should eliminate the first
response = client.get(
"/v1.0/process-instances?start_from=1001",
headers=self.logged_in_headers(user),
)
assert response.json is not None
results = response.json["results"]
assert len(results) == 4
for i in range(4):
assert json.loads(results[i]["bpmn_json"])["i"] in (1, 2, 3, 4)
# start > 2000, end < 5000 - this should eliminate the first 2 and the last
response = client.get(
"/v1.0/process-instances?start_from=2001&end_till=5999",
headers=self.logged_in_headers(user),
)
assert response.json is not None
results = response.json["results"]
assert len(results) == 2
assert json.loads(results[0]["bpmn_json"])["i"] in (2, 3)
assert json.loads(results[1]["bpmn_json"])["i"] in (2, 3)
# start > 1000, start < 4000 - this should eliminate the first and the last 2
response = client.get(
"/v1.0/process-instances?start_from=1001&start_till=3999",
headers=self.logged_in_headers(user),
)
assert response.json is not None
results = response.json["results"]
assert len(results) == 2
assert json.loads(results[0]["bpmn_json"])["i"] in (1, 2)
assert json.loads(results[1]["bpmn_json"])["i"] in (1, 2)
# end > 2000, end < 6000 - this should eliminate the first and the last
response = client.get(
"/v1.0/process-instances?end_from=2001&end_till=5999",
headers=self.logged_in_headers(user),
)
assert response.json is not None
results = response.json["results"]
assert len(results) == 3
for i in range(3):
assert json.loads(results[i]["bpmn_json"])["i"] in (1, 2, 3)
def test_process_instance_report_list(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_instance_report_list."""
process_group_identifier = "runs_without_input"
process_model_identifier = "sample"
user = self.find_or_create_user()
self.logged_in_headers(user)
load_test_spec(
process_model_identifier, process_group_id=process_group_identifier
)
report_identifier = "testreport"
report_metadata = {"order_by": ["month"]}
ProcessInstanceReportModel.create_with_attributes(
identifier=report_identifier,
process_group_identifier=process_group_identifier,
process_model_identifier=process_model_identifier,
report_metadata=report_metadata,
user=user,
)
response = client.get(
f"/v1.0/process-models/{process_group_identifier}/{process_model_identifier}/process-instances/reports",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json) == 1
assert response.json[0]["identifier"] == report_identifier
assert response.json[0]["report_metadata"]["order_by"] == ["month"]
def test_process_instance_report_show_with_default_list(
self,
app: Flask,
client: FlaskClient,
with_db_and_bpmn_file_cleanup: None,
setup_process_instances_for_reports: list[ProcessInstanceModel],
) -> None:
"""Test_process_instance_report_show_with_default_list."""
test_process_group_id = "runs_without_input"
process_model_dir_name = "sample"
user = self.find_or_create_user()
report_metadata = {
"columns": [
{"Header": "id", "accessor": "id"},
{
"Header": "process_model_identifier",
"accessor": "process_model_identifier",
},
{"Header": "process_group_id", "accessor": "process_group_identifier"},
{"Header": "start_in_seconds", "accessor": "start_in_seconds"},
{"Header": "status", "accessor": "status"},
{"Header": "Name", "accessor": "name"},
{"Header": "Status", "accessor": "status"},
],
"order_by": ["test_score"],
"filter_by": [
{"field_name": "grade_level", "operator": "equals", "field_value": 2}
],
}
ProcessInstanceReportModel.create_with_attributes(
identifier="sure",
process_group_identifier=test_process_group_id,
process_model_identifier=process_model_dir_name,
report_metadata=report_metadata,
user=self.find_or_create_user(),
)
response = client.get(
f"/v1.0/process-models/{test_process_group_id}/{process_model_dir_name}/process-instances/reports/sure",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json["results"]) == 2
assert response.json["pagination"]["count"] == 2
assert response.json["pagination"]["pages"] == 1
assert response.json["pagination"]["total"] == 2
process_instance_dict = response.json["results"][0]
assert type(process_instance_dict["id"]) is int
assert (
process_instance_dict["process_model_identifier"] == process_model_dir_name
)
assert (
process_instance_dict["process_group_identifier"] == test_process_group_id
)
assert type(process_instance_dict["start_in_seconds"]) is int
assert process_instance_dict["start_in_seconds"] > 0
assert process_instance_dict["status"] == "complete"
def test_process_instance_report_show_with_dynamic_filter_and_query_param(
self,
app: Flask,
client: FlaskClient,
with_db_and_bpmn_file_cleanup: None,
setup_process_instances_for_reports: list[ProcessInstanceModel],
) -> None:
"""Test_process_instance_report_show_with_default_list."""
test_process_group_id = "runs_without_input"
process_model_dir_name = "sample"
user = self.find_or_create_user()
report_metadata = {
"filter_by": [
{
"field_name": "grade_level",
"operator": "equals",
"field_value": "{{grade_level}}",
}
],
}
ProcessInstanceReportModel.create_with_attributes(
identifier="sure",
process_group_identifier=test_process_group_id,
process_model_identifier=process_model_dir_name,
report_metadata=report_metadata,
user=self.find_or_create_user(),
)
response = client.get(
f"/v1.0/process-models/{test_process_group_id}/{process_model_dir_name}/process-instances/reports/sure?grade_level=1",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json["results"]) == 1
def test_process_instance_report_show_with_bad_identifier(
self,
app: Flask,
client: FlaskClient,
with_db_and_bpmn_file_cleanup: None,
setup_process_instances_for_reports: list[ProcessInstanceModel],
) -> None:
"""Test_process_instance_report_show_with_default_list."""
test_process_group_id = "runs_without_input"
process_model_dir_name = "sample"
user = self.find_or_create_user()
response = client.get(
f"/v1.0/process-models/{test_process_group_id}/{process_model_dir_name}/process-instances/reports/sure?grade_level=1",
headers=self.logged_in_headers(user),
)
assert response.status_code == 404
data = json.loads(response.get_data(as_text=True))
assert data["error_code"] == "unknown_process_instance_report"
def setup_testing_instance(
self,
client: FlaskClient,
process_group_id: str,
process_model_id: str,
user: UserModel,
) -> Any:
"""Setup_testing_instance."""
headers = self.logged_in_headers(user)
response = self.create_process_instance(
client, process_group_id, process_model_id, headers
)
process_instance = response.json
assert isinstance(process_instance, dict)
process_instance_id = process_instance["id"]
return process_instance_id
def test_error_handler(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_error_handler."""
process_group_id = "data"
process_model_id = "error"
user = self.find_or_create_user()
process_instance_id = self.setup_testing_instance(
client, process_group_id, process_model_id, user
)
process = (
db.session.query(ProcessInstanceModel)
.filter(ProcessInstanceModel.id == process_instance_id)
.first()
)
assert process.status == "not_started"
response = client.post(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
assert response.status_code == 400
api_error = json.loads(response.get_data(as_text=True))
assert api_error["error_code"] == "task_error"
assert (
'TypeError:can only concatenate str (not "int") to str'
in api_error["message"]
)
process = (
db.session.query(ProcessInstanceModel)
.filter(ProcessInstanceModel.id == process_instance_id)
.first()
)
assert process.status == "faulted"
def test_error_handler_suspend(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_error_handler_suspend."""
process_group_id = "data"
process_model_id = "error"
user = self.find_or_create_user()
process_instance_id = self.setup_testing_instance(
client, process_group_id, process_model_id, user
)
process_model = ProcessModelService().get_process_model(
process_model_id, process_group_id
)
ProcessModelService().update_spec(
process_model,
{"fault_or_suspend_on_exception": NotificationType.suspend.value},
)
process = (
db.session.query(ProcessInstanceModel)
.filter(ProcessInstanceModel.id == process_instance_id)
.first()
)
assert process.status == "not_started"
response = client.post(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
assert response.status_code == 400
process = (
db.session.query(ProcessInstanceModel)
.filter(ProcessInstanceModel.id == process_instance_id)
.first()
)
assert process.status == "suspended"
def test_error_handler_with_email(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_error_handler."""
process_group_id = "data"
process_model_id = "error"
user = self.find_or_create_user()
process_instance_id = self.setup_testing_instance(
client, process_group_id, process_model_id, user
)
process_model = ProcessModelService().get_process_model(
process_model_id, process_group_id
)
ProcessModelService().update_spec(
process_model, {"exception_notification_addresses": ["user@example.com"]}
)
mail = app.config["MAIL_APP"]
with mail.record_messages() as outbox:
response = client.post(
f"/v1.0/process-models/{process_group_id}/{process_model_id}/process-instances/{process_instance_id}/run",
headers=self.logged_in_headers(user),
)
assert response.status_code == 400
assert len(outbox) == 1
message = outbox[0]
assert message.subject == "Unexpected error in app"
assert (
message.body == 'TypeError:can only concatenate str (not "int") to str'
)
assert message.recipients == process_model.exception_notification_addresses
process = (
db.session.query(ProcessInstanceModel)
.filter(ProcessInstanceModel.id == process_instance_id)
.first()
)
assert process.status == "faulted"
def test_process_model_file_create(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_process_model_file_create."""
process_group_id = "hello_world"
process_model_id = "hello_world"
file_name = "hello_world.svg"
file_data = b"abc123"
result = self.create_spec_file(
client,
process_group_id=process_group_id,
process_model_id=process_model_id,
file_name=file_name,
file_data=file_data,
)
assert result["process_group_id"] == process_group_id
assert result["process_model_id"] == process_model_id
assert result["name"] == file_name
assert bytes(str(result["file_contents"]), "utf-8") == file_data
def test_can_get_message_instances_by_process_instance_id_and_without(
self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
) -> None:
"""Test_can_get_message_instances_by_process_instance_id."""
load_test_spec(
"message_receiver",
process_model_source_directory="message_send_one_conversation",
bpmn_file_name="message_receiver",
)
user = self.find_or_create_user()
message_model_identifier = "message_send"
payload = {
"topica": "the_topica_string",
"topicb": "the_topicb_string",
"andThis": "another_item_non_key",
}
response = client.post(
f"/v1.0/messages/{message_model_identifier}",
content_type="application/json",
headers=self.logged_in_headers(user),
data=json.dumps({"payload": payload}),
)
assert response.status_code == 200
assert response.json is not None
process_instance_id_one = response.json["id"]
response = client.post(
f"/v1.0/messages/{message_model_identifier}",
content_type="application/json",
headers=self.logged_in_headers(user),
data=json.dumps({"payload": payload}),
)
assert response.status_code == 200
assert response.json is not None
process_instance_id_two = response.json["id"]
response = client.get(
f"/v1.0/messages?process_instance_id={process_instance_id_one}",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json["results"]) == 1
assert (
response.json["results"][0]["process_instance_id"]
== process_instance_id_one
)
response = client.get(
f"/v1.0/messages?process_instance_id={process_instance_id_two}",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json["results"]) == 1
assert (
response.json["results"][0]["process_instance_id"]
== process_instance_id_two
)
response = client.get(
"/v1.0/messages",
headers=self.logged_in_headers(user),
)
assert response.status_code == 200
assert response.json is not None
assert len(response.json["results"]) == 2
# TODO: test the auth callback endpoint
# def test_can_store_authentication_secret(
# self, app: Flask, client: FlaskClient, with_db_and_bpmn_file_cleanup: None
# ) -> None:
# """Test_can_store_authentication_secret."""
# response = client.get(
# "/v1.0/authentication_callback",
# headers=self.logged_in_headers(user),
# )
# def test_get_process_model(self):
#
# load_test_spec('random_fact')
# response = client.get('/v1.0/workflow-specification/random_fact', headers=self.logged_in_headers())
# assert_success(response)
# json_data = json.loads(response.get_data(as_text=True))
# api_spec = WorkflowSpecInfoSchema().load(json_data)
#
# fs_spec = process_model_service.get_spec('random_fact')
# assert(WorkflowSpecInfoSchema().dump(fs_spec) == json_data)
#
# def test_waku_debug_info(self) -> None:
# """Test_waku_debug_info."""
# debug_info_method = "get_waku_v2_debug_v1_info"
#
# headers = {"Content-Type": "application/json"}
#
# rpc_json = {
# "jsonrpc": "2.0",
# "method": debug_info_method,
# "params": [],
# "id": "id",
# }
#
# request_url = "http://localhost:8545"
# rpc_response = requests.post(request_url, headers=headers, json=rpc_json)
#
# rpc_json_text: dict = json.loads(rpc_response.text)
# assert isinstance(rpc_json_text, dict)
# # assert 'jsonrpc' in rpc_json_text
# # assert rpc_json_text['jsonrpc'] == '2.0'
# assert "result" in rpc_json_text
# result = rpc_json_text["result"]
# assert isinstance(result, dict)
# assert "listenAddresses" in result
# assert "enrUri" in result
#
# print("test_call_waku")
#
# def test_send_message(self) -> None:
# """Test_send_message."""
# relay_message_method = "post_waku_v2_relay_v1_message"
#
# headers = {"Content-Type": "application/json"}
#
# # class WakuMessage:
# # payload: str
# # contentTopic: str # Optional
# # # version: int # Optional
# # timestamp: int # Optional
# payload = "This is my message"
# contentTopic = "myTestTopic" # noqa: N806
# timestamp = time.time()
#
# waku_relay_message = {
# "payload": payload,
# "contentTopic": contentTopic,
# "timestamp": timestamp,
# }
#
# # ["", [{"contentTopic":"/waku/2/default-content/proto"}]]
# params = ["/waku/2/default-waku/proto", {"message": waku_relay_message}]
# rpc_json = {
# "jsonrpc": "2.0",
# "method": relay_message_method,
# "params": params,
# "id": 1,
# }
#
# request_url = "http://localhost:8545"
# rpc_response = requests.post(request_url, headers=headers, json=rpc_json)
# assert rpc_response.status_code == 200
#
# rpc_json_data: dict = json.loads(rpc_response.text)
# assert "error" in rpc_json_data
# assert "result" in rpc_json_data
# assert rpc_json_data["error"] is None
# assert rpc_json_data["result"] is True
#
# print("test_send_message")
#
# def test_get_waku_messages(self) -> None:
# """Test_get_waku_messages."""
# method = "get_waku_v2_store_v1_messages"
# headers = {"Content-Type": "application/json"}
# params = [{"contentTopic": "/waku/2/default-content/proto"}]
#
# rpc_json = {"jsonrpc": "2.0", "method": method, "params": params, "id": 1}
# request_url = "http://localhost:8545"
# rpc_response = requests.post(request_url, headers=headers, json=rpc_json)
# assert rpc_response.status_code == 200
#
# rpc_json_data: dict = json.loads(rpc_response.text)
# assert "error" in rpc_json_data
# assert rpc_json_data["error"] is None
# assert "result" in rpc_json_data
# assert isinstance(rpc_json_data["result"], dict)
# assert "messages" in rpc_json_data["result"]
# assert "pagingInfo" in rpc_json_data["result"]
#
# print("get_waku_messages")