def test_get_by_message_id(self, stub_broker, state_middleware,
api_client):
message_id = "2718281"
state = State(message_id, StateNamesEnum.Pending, [], {})
state_middleware.backend.set_state(state, ttl=1000)
res = api_client.get("/messages/state/{}".format(message_id))
assert res.json == state.asdict()
def test_get_state_by_name(self, name_state, stub_broker, state_middleware,
api_client):
state = State("3141516", name_state, [], {})
state_middleware.backend.set_state(state, ttl=1000)
res = api_client.get("/messages/states?name={}".format(
name_state.value))
assert res.json["result"] == [state.asdict()]
def test_filter_messages(self, stub_broker, api_client):
state = State("some_message_id")
state_backend = stub_broker.get_state_backend()
state_backend.set_state(state, ttl=1000)
data = {"sort_column": "message_id", "selected_message_ids": ["some_message_id"]}
res = api_client.post("/messages/states", data=json.dumps(data), content_type="application/json")
assert res.json == {"count": 1, "data": [state.as_dict()]}
def test_get_state_by_name(self, name_state, stub_broker, state_middleware,
api_client):
state = State("1", name_state)
state_middleware.backend.set_state(state, ttl=1000)
args = {"search_value": name_state.value}
res = api_client.get("/messages/states", data=args)
assert res.json == {"count": 1, "data": [state.as_dict()]}
def test_get_group_id(self, stub_broker, api_client, state_middleware):
for i in range(2):
state_middleware.backend.set_state(State("id{}".format(i),
group_id=1),
ttl=1000)
state_middleware.backend.set_state(State("id2", group_id=2), ttl=1000)
res = api_client.get("/groups").json["data"]
res.sort(key=lambda i: i["group_id"])
for item in res:
item["messages"].sort(key=lambda i: i["message_id"])
assert res == [
{
"group_id":
1,
"messages": [{
"group_id": 1,
"message_id": "id0"
}, {
"group_id": 1,
"message_id": "id1"
}]
},
{
"group_id": 2,
"messages": [{
"group_id": 2,
"message_id": "id2"
}]
},
]
def test_filter_messages(self, stub_broker, api_client, state_middleware):
state = State("some_message_id", )
state_middleware.backend.set_state(state, ttl=1000)
data = {
"sort_column": "message_id",
"search_value": "some_mes",
}
res = api_client.get("/messages/states", query_string=data)
assert res.json == {"count": 1, "data": [state.as_dict()]}
def test_get_state_by_name(self, status, stub_broker, state_middleware,
api_client):
state = State("1", status)
state_middleware.backend.set_state(state, ttl=1000)
args = {"selected_statuses": [status.value]}
res = api_client.post("/messages/states",
data=json.dumps(args),
content_type="application/json")
assert res.json == {"count": 1, "data": [state.as_dict()]}
def test_clean_max_age(self, stub_broker, postgres_state_middleware):
backend = postgres_state_middleware.backend
backend.set_state(State("id0", end_datetime=datetime.datetime.now(pytz.utc)))
backend.set_state(State("id1", end_datetime=datetime.datetime.now(pytz.utc) - datetime.timedelta(minutes=50)))
assert len(backend.get_states()) == 2
backend.clean(max_age=25)
res = backend.get_states()
assert len(res) == 1
assert res[0].message_id == "id0"
def test_clean_not_started(self, stub_broker, postgres_state_middleware):
backend = postgres_state_middleware.backend
backend.set_state(State("id0", started_datetime=datetime.datetime.now(pytz.utc)))
backend.set_state(State("id1"))
assert len(backend.get_states()) == 2
backend.clean(not_started=True)
res = backend.get_states()
assert len(res) == 1
assert res[0].message_id == "id0"
def test_get_states_by_name(self, n, stub_broker, state_middleware, api_client):
# generate random test
random_states = []
for i in range(n):
random_state = State(f"id{i}", choice(list(StateStatusesEnum))) # random state
random_states.append(random_state.as_dict())
state_middleware.backend.set_state(random_state, ttl=1000)
# check storage
res = api_client.post("/messages/states", data=json.dumps({"size": 100}), content_type="application/json")
states = res.json["data"]
assert len(states) == n
# check integrity
for state in states:
assert state in random_states
def from_state(cls: Type[T], state: State, max_size: int, encoder: Encoder) -> T:
state_dict = state.as_dict()
for key in ["args", "kwargs", "options"]:
if key in state_dict:
encoded_value = encoder.encode(state_dict[key])
state_dict[key] = encoded_value if sys.getsizeof(encoded_value) <= max_size else None
return cls(**state_dict)
def test_change_existence_state(self, state_backend):
message_id = "14271"
state = State(
message_id, StateStatusesEnum.Pending, actor_name="do_work", args=[1, 2], kwargs={"status": "work"}
)
state_backend.set_state(state, ttl=100)
# the state status changes
state = State(message_id, StateStatusesEnum.Success)
state_backend.set_state(state, ttl=100)
# if the states exist, then it update the new fields
# then args and kwargs should hold
# and the state status should change
state = state_backend.get_state(message_id)
assert state.status == StateStatusesEnum.Success
assert state.args == [1, 2]
assert state.kwargs == {"status": "work"}
def test_select_actors(self, stub_broker, postgres_state_middleware):
backend = postgres_state_middleware.backend
for i in range(2):
backend.set_state(State(f"id{i}", actor_name=f"actor{i}"))
res = backend.get_states(selected_actors=["actor1"])
assert len(res) == 1
assert res[0].actor_name == "actor1"
def test_clean(self, stub_broker, postgres_state_middleware):
backend = postgres_state_middleware.backend
backend.set_state(State("id0"))
assert len(backend.get_states()) == 1
backend.clean()
assert len(backend.get_states()) == 0
def test_select_statuses(self, stub_broker, postgres_state_middleware):
backend = postgres_state_middleware.backend
for i in range(2):
backend.set_state(State(f"id{i}", StateStatusesEnum.Success if i else StateStatusesEnum.Skipped))
res = backend.get_states(selected_statuses=["Success"])
assert len(res) == 1
assert res[0].status == StateStatusesEnum.Success
def test_select_ids(self, stub_broker, postgres_state_middleware):
backend = postgres_state_middleware.backend
for i in range(2):
backend.set_state(State(f"id{i}"))
res = backend.get_states(selected_message_ids=["id1"])
assert len(res) == 1
assert res[0].message_id == "id1"
def test_requeue_message_with_pipeline(self, stub_broker, do_work, api_client, state_middleware):
stub_broker.enqueue = MagicMock()
state = State("id1", StateStatusesEnum.Success, actor_name="do_work", options={"pipe_target": "some_pipe"})
state_middleware.backend.set_state(state, ttl=1000)
res = api_client.post("messages/requeue/id1")
assert res.json == {"error": "requeue message in a pipeline not supported"}
assert res.status_code == 400
def test_get_states_page_size(self, size, stub_broker, api_client, state_middleware):
for i in range(0, 10):
state_middleware.backend.set_state(State("id{}".format(i)), ttl=1000)
res = api_client.post("/messages/states", data=json.dumps({"size": size}), content_type="application/json")
if size >= 10:
assert res.json["count"] == 10
else:
assert len(res.json["data"]) == size
def test_offset_in_group(self, offset, expected_len, stub_broker,
api_client, state_middleware):
for i in range(2):
state_middleware.backend.set_state(State("id{}".format(i),
group_id=1),
ttl=1000)
res = api_client.get("/groups", query_string={"offset": offset})
assert len(res.json["data"]) == expected_len
def test_count_compositions(self, stub_broker, state_middleware):
backend = state_middleware.backend
for i in range(3):
for j in range(2):
backend.set_state(State(f"id{i*j}", composition_id=f"id{j}"))
assert backend.get_states_count() == 2
def test_clean_route(self, stub_broker, postgres_state_middleware):
client = app.test_client()
backend = postgres_state_middleware.backend
backend.set_state(State("id0"))
assert len(backend.get_states()) == 1
client.delete("/messages/states")
assert len(backend.get_states()) == 0
def test_get_states_page_size(self, size, stub_broker, api_client,
state_middleware):
for i in range(0, 10):
state_middleware.backend.set_state(State("id{}".format(i)),
ttl=1000)
res = api_client.get("/messages/states", query_string={"size": size})
if size >= 10:
assert res.json["count"] == 10
else:
assert len(res.json["data"]) == size
def test_not_raise_error_with_pickle_and_non_serializable(
self, pickle_encoder, stub_broker, api_client, state_middleware):
state = State("id1",
args={
"name": "some_name",
"date": date(2020, 12, 12)
})
state_middleware.backend.set_state(state, ttl=1000)
res = api_client.get("messages/states")
assert res.json == {"count": 1, "data": [{"message_id": "id1"}]}
def test_get_states_by_name(self, n, stub_broker, state_middleware,
api_client):
# generate random test
random_states = []
for i in range(n):
random_state = State(
"id{}".format(i),
choice(list(StateNamesEnum)),
) # random state
random_states.append(random_state.as_dict())
state_middleware.backend.set_state(random_state, ttl=1000)
# check storage
res = api_client.get("/messages/states?size=100")
states = res.json["data"]
assert len(states) == n
# check integrity
for state in states:
assert state in random_states
def test_not_raise_error_with_pickle_and_non_serializable(
self, pickle_encoder, stub_broker, api_client, state_middleware
):
state = State("id1", args=["some_status", date(2020, 12, 12)])
state_middleware.backend.set_state(state, ttl=1000)
res = api_client.post("messages/states")
assert res.json == {
"count": 1,
"data": [{"args": ["some_status", "Sat, 12 Dec 2020 00:00:00 GMT"], "message_id": "id1"}],
}
def test_get_states_offset(self, offset, stub_broker, api_client, state_middleware):
for i in range(0, 10):
state_middleware.backend.set_state(State(f"id{i}"), ttl=1000)
res = api_client.post(
"/messages/states", data=json.dumps({"offset": offset, "size": 50}), content_type="application/json"
)
if offset >= 10:
assert res.json["data"] == []
else:
assert len(res.json["data"]) + offset == 10
def as_state(self, encoder: Encoder) -> State:
state_dict = {}
mapper = inspect(StoredState)
for column in mapper.attrs:
column_value = getattr(self, column.key)
if column_value is None:
continue
if column.key in ["args", "kwargs", "options"]:
column_value = encoder.decode(column_value)
state_dict[column.key] = column_value
return State.from_dict(state_dict)
def test_get_states_by_name(self, n, stub_broker, state_middleware, api_client):
# generate random test
random_states = []
for i in range(n):
random_state = State(
"id{}".format(i),
choice(list(StateNamesEnum)), # random state
sample(range(1, 10), randint(0, 5)), # random args
{str(i): str(i) for i in range(randint(0, 5))}, # random kwargs
)
random_states.append(random_state.asdict())
state_middleware.backend.set_state(random_state, ttl=1000)
# check storage
res = api_client.get("/messages/states")
states = res.json["result"]
assert len(states) == n
# check integrity
for state in states:
assert state in random_states
def test_filter_groups(self, search_value, stub_broker, api_client,
state_middleware):
for i in range(2):
state_middleware.backend.set_state(State("id{}".format(i),
group_id=1),
ttl=1000)
res = api_client.get("/groups",
query_string={"search_value": search_value})
for group in res.json["data"]:
for message in group["messages"]:
assert dict_has(message, message.keys(), search_value)
def test_get_states_offset(self, offset, stub_broker, api_client,
state_middleware):
for i in range(0, 10):
state_middleware.backend.set_state(State("id{}".format(i)),
ttl=1000)
res = api_client.get("/messages/states",
query_string={"offset": offset})
if offset >= 10:
assert res.json["data"] == []
else:
assert len(res.json["data"]) + offset == 10
