def test_query_progress(dummy_redis):
"""
Test correct counts for dependency progress are returned.
"""
dummy = DummyQuery(dummy_param="DUMMY")
queued_qsm = QueryStateMachine(dummy_redis, dummy.query_id,
get_db().conn_id)
queued_qsm.enqueue()
stored_dummy = DummyQuery(dummy_param="STORED_DUMMY")
stored_dummy.store()
executing_dummy = DummyQuery(dummy_param="EXECUTING_DUMMY")
executing_qsm = QueryStateMachine(dummy_redis, executing_dummy.query_id,
get_db().conn_id)
executing_qsm.enqueue()
executing_qsm.execute()
nested = DummyQuery(dummy_param=[dummy, stored_dummy, executing_dummy])
assert query_progress(nested) == dict(
eligible=3,
running=1,
queued=1,
)
nested.store()
assert query_progress(nested) == dict(
eligible=0,
running=0,
queued=0,
)
def test_unstored_dependencies_graph():
"""
Test that unstored_dependencies_graph returns the correct graph in an example case.
"""
# Create dummy queries with dependency structure
#
# 5:unstored
# / \
# 3:stored 4:unstored
# / \ /
# 1:unstored 2:unstored
#
# Note: we add a string parameter to each query so that they have different query IDs
dummy1 = DummyQuery(dummy_param=["dummy1"])
dummy2 = DummyQuery(dummy_param=["dummy2"])
dummy3 = DummyQuery(dummy_param=["dummy3", dummy1, dummy2])
dummy4 = DummyQuery(dummy_param=["dummy4", dummy2])
dummy5 = DummyQuery(dummy_param=["dummy5", dummy3, dummy4])
dummy3.store()
expected_query_nodes = [dummy2, dummy4]
graph = unstored_dependencies_graph(dummy5)
assert not any(dict(graph.nodes(data="stored")).values())
assert len(graph) == len(expected_query_nodes)
for query in expected_query_nodes:
assert f"x{query.query_id}" in graph.nodes()
assert (graph.nodes[f"x{query.query_id}"]["query_object"].query_id ==
query.query_id)
def test_dependencies_eligible_for_store():
"""
Test that the set of only storeable dependencies is returned.
"""
class UnStoreableQuery(DummyQuery):
@property
def table_name(self):
raise NotImplementedError("This dummy cannot be stored.")
dummy = DummyQuery(dummy_param="DUMMY")
unstoreable_dummy = UnStoreableQuery(dummy_param="UNSTOREABLE_DUMMY")
nested = DummyQuery(dummy_param=[dummy, unstoreable_dummy])
assert dependencies_eligible_for_store(nested) == {dummy, nested}
def test_unstored_dependencies_graph_for_stored_query():
"""
Test that the unstored dependencies graph for a stored query is empty.
"""
dummy1 = DummyQuery(dummy_param=["dummy1"])
dummy2 = DummyQuery(dummy_param=["dummy2"])
dummy3 = DummyQuery(dummy_param=["dummy3", dummy1, dummy2])
dummy3.store()
graph = unstored_dependencies_graph(dummy3)
assert len(graph) == 0
def test_queued_dependencies(dummy_redis):
"""
Test that only queued dependencies are returned.
"""
dummy = DummyQuery(dummy_param="DUMMY")
queued_qsm = QueryStateMachine(dummy_redis, dummy.query_id,
get_db().conn_id)
queued_qsm.enqueue()
stored_dummy = DummyQuery(dummy_param="STORED_DUMMY")
stored_dummy.store()
executing_dummy = DummyQuery(dummy_param="EXECUTING_DUMMY")
executing_qsm = QueryStateMachine(dummy_redis, executing_dummy.query_id,
get_db().conn_id)
executing_qsm.enqueue()
executing_qsm.execute()
nested = DummyQuery(dummy_param=[dummy, stored_dummy, executing_dummy])
assert queued_dependencies(
set([nested, dummy, stored_dummy, executing_dummy])) == [dummy]
def _flowmachine_query_obj(self):
return DummyQuery(dummy_param=self.dummy_param)
def _flowmachine_query_obj(self):
sleep(self.dummy_delay)
return DummyQuery(dummy_param=self.dummy_param)
