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