test: 🚨 use test helper where possible

tests/helper/random_data.py

@@ -31,13 +31,13 @@ def random_position() -> Position:
     return [random_longitude(), random_latitude()]
 
 
-def random_point(
+def random_point_geometry(
     position: Optional[Position] = None,
 ) -> Dict[str, Union[str, List[float]]]:
     return {"type": "Point", "coordinates": position if position else random_position()}
 
 
-def random_polygon(
+def random_polygon_geometry(
     bbox: BoundingBox = [13.1632, 52.4099, 13.6402, 52.6353],
 ) -> Dict[str, Union[str, Polygon]]:
     [min_lng, min_lat, max_lng, max_lat] = bbox
@@ -77,7 +77,7 @@ def random_polygon(
 
 def random_feature(feature_type: Literal["Point", "Polygon"]) -> dict:
     if feature_type == "Point":
-        return {"type": "Feature", "geometry": random_point()}
+        return {"type": "Feature", "geometry": random_point_geometry()}
 
     if feature_type == "Polygon":
-        return random_polygon()
+        return random_polygon_geometry()

tests/test_command_bounds.py

@@ -1,16 +1,17 @@
 import pytest
 
+from .helper.random_data import random_string
+
 
 @pytest.mark.asyncio
 async def test_command_bounds(tile38):
-    key = "fleet"
-    id = "truck"
+    key = random_string()
+    id = random_string()
 
-    await tile38.set(key, id).point(1, 1).exec()
+    response = await tile38.set(key, id).point(1, 1).exec()
+    assert response.ok
 
     expected = {
-        "ok": True,
-        "elapsed": "1 ms",
         "bounds": {
             "type": "Polygon",
             "coordinates": [

tests/test_command_config.py

@@ -8,6 +8,7 @@ async def test_command_config(tile38_with_follower):
 
     response = await tile38.config_set("keepalive", 500)
     assert response.ok
+
     response = await tile38.follower().config_set("keepalive", 500)
     assert response.ok
 

tests/test_command_del.py

@@ -2,12 +2,14 @@
 
 from pyle38.errors import Tile38KeyNotFoundError
 
-key = "fleet"
-id = "truck"
+from .helper.random_data import random_string
 
 
 @pytest.mark.asyncio
 async def test_command_del(tile38):
+    key = random_string()
+    id = random_string()
+
     response = await tile38.set(key, id).point(1, 1).exec()
     assert response.ok
 

tests/test_command_drop.py

@@ -2,12 +2,14 @@
 
 from pyle38.errors import Tile38KeyNotFoundError
 
-key = "fleet"
-id = "truck"
+from .helper.random_data import random_string
 
 
 @pytest.mark.asyncio
 async def test_command_drop(tile38):
+    key = random_string()
+    id = random_string()
+
     response = await tile38.set(key, id).point(1, 1).exec()
     assert response.ok
 

tests/test_command_expire_persist.py

@@ -1,13 +1,16 @@
 import pytest
 
-key = "fleet"
-id = "truck"
-expire = 10
+from .helper.random_data import random_integer, random_polygon_geometry, random_string
 
 
 @pytest.mark.asyncio
 async def test_command_expire_persist(tile38):
-    response = await tile38.set(key, id).point(1, 1).exec()
+    key = random_string()
+    id = random_string()
+    object = random_polygon_geometry()
+    expire = random_integer(10, 100)
+
+    response = await tile38.set(key, id).object(object).exec()
     assert response.ok
 
     response = await tile38.ttl(key, id)

tests/test_command_fset.py

@@ -2,28 +2,33 @@
 
 from pyle38.commands.fset import Fset
 
-key = "fleet"
-id = "truck1"
-obj = {
-    "type": "Feature",
-    "geometry": {"type": "Point", "coordinates": [1, 1]},
-    "properties": {},
-}
-
-fields = {"speed": 100, "state": 1}
+from .helper.random_data import random_feature, random_integer, random_string
 
 
 @pytest.mark.asyncio
 async def test_command_fset_compile(tile38):
+    key = random_string()
+    id = random_string()
+    fkey = random_string()
+    fvalue = random_integer(1, 10)
+    fields = {fkey: fvalue}
+
     received = Fset(tile38.client, key, id, fields).compile()
-    expected = ["FSET", [key, id, "speed", 100, "state", 1]]
+    expected = ["FSET", [key, id, fkey, fvalue]]
 
     assert received == expected
 
 
 @pytest.mark.asyncio
 async def test_command_fset(tile38):
-    response = await tile38.set(key, id).object(obj).exec()
+    key = random_string()
+    id = random_string()
+    fkey = random_string()
+    fvalue = random_integer(1, 10)
+    fields = {fkey: fvalue}
+    object = random_feature("Point")
+
+    response = await tile38.set(key, id).object(object).exec()
     assert response.ok
 
     response = await tile38.fset(key, id, fields).xx().exec()

tests/test_command_get.py

@@ -2,13 +2,11 @@
 
 from pyle38.commands.get import Get
 
-key = "fleet"
-id = "truck1"
-obj = {
-    "type": "Feature",
-    "geometry": {"type": "Point", "coordinates": [1, 1]},
-    "properties": {},
-}
+from .helper.random_data import random_feature, random_string
+
+key = random_string()
+id = random_string()
+object = random_feature("Point")
 
 
 @pytest.mark.parametrize(
@@ -23,42 +21,39 @@
 )
 @pytest.mark.asyncio
 async def test_command_get_compile(format, precision, expected, tile38):
-
     query = Get(tile38.client, key, id).withfields()
-
     received = query.output(format, precision).compile()
-
     assert expected == received
 
 
 @pytest.mark.asyncio
 async def test_command_get_query(tile38):
-    await tile38.set(key, id).object(obj).exec()
+    key = random_string()
+    id = random_string()
+    object = {
+        "type": "Feature",
+        "geometry": {"type": "Point", "coordinates": [1, 1]},
+        "properties": {},
+    }
+
+    await tile38.set(key, id).object(object).exec()
     await tile38.set(key, f"{id}:driver").string("John").exec()
 
-    expected_object = {"ok": True, "object": obj, "elapsed": "1 ms"}
     received = await tile38.get(key, id).asObject()
-    assert expected_object["object"] == received.object
+    assert object == received.object
 
-    expected_point = {"ok": True, "point": {"lat": 1, "lon": 1}, "elapsed": "1 ms"}
+    expected_point = {"lat": 1, "lon": 1}
     received = await tile38.get(key, id).asPoint()
-    assert expected_point["point"] == received.point
-
-    expected_bounds = {
-        "ok": True,
-        "bounds": {"ne": {"lat": 1, "lon": 1}, "sw": {"lat": 1, "lon": 1}},
-        "elapsed": "1 ms",
-    }
-    received = await tile38.get(key, id).asBounds()
-    assert expected_bounds["bounds"] == received.bounds
+    assert expected_point == received.point
 
+    expected_bounds = {"ne": {"lat": 1, "lon": 1}, "sw": {"lat": 1, "lon": 1}}
     received = await tile38.get(key, id).asBounds()
-    assert expected_bounds["bounds"] == received.bounds
+    assert expected_bounds == received.bounds
 
-    expected_hash = {"ok": True, "hash": "s00twy0", "elapsed": "1 ms"}
+    expected_hash = "s00twy0"
     received = await tile38.get(key, id).asHash(7)
-    assert expected_hash["hash"] == received.hash
+    assert expected_hash == received.hash
 
-    expected_string = {"ok": True, "object": "John", "elapsed": "1 ms"}
+    expected_string = "John"
     received = await tile38.get(key, f"{id}:driver").asStringObject()
-    assert expected_string["object"] == received.object
+    assert expected_string == received.object

tests/test_command_hooks.py

@@ -1,16 +1,21 @@
 import pytest
 
+from .helper.random_data import random_feature, random_string
+
 
 @pytest.mark.asyncio
 async def test_command_hooks(tile38_with_follower):
-
     tile38 = tile38_with_follower
 
-    # TODO: test after tile38.set_hook
-    response = await tile38.hooks()
+    key = random_string()
+    id = random_string()
+    object = random_feature("Polygon")
+    endpoint = "kafka://10.0.20.78:9092/warehouse"
 
-    assert response.ok
+    response = await tile38.sethook(id, endpoint).within(key).object(object).activate()
 
-    response = await tile38.follower().hooks()
+    assert response.ok
 
+    response = await tile38.hooks()
     assert response.ok
+    assert len(response.hooks) == 1

tests/test_command_intersects.py

@@ -2,31 +2,13 @@
 
 from pyle38.commands.intersects import Intersects
 
-key = "fleet"
-id = "truck"
-feature = {
-    "type": "Feature",
-    "geometry": {"type": "Point", "coordinates": [13.37, 52.25]},
-    "properties": {"id": id},
-}
-polygon = {
-    "type": "Polygon",
-    "coordinates": [
-        [
-            [13.361263275146484, 52.24630137198303],
-            [13.379974365234373, 52.24630137198303],
-            [13.379974365234373, 52.256705331409506],
-            [13.361263275146484, 52.256705331409506],
-            [13.361263275146484, 52.24630137198303],
-        ]
-    ],
-}
-
-expected = {"id": id, "object": feature}
+from .helper.random_data import random_string
 
 
 @pytest.mark.asyncio
 async def test_command_intersects_compile(tile38):
+    key = random_string()
+
     expected = [
         "INTERSECTS",
         [
@@ -83,6 +65,29 @@ async def test_command_intersects_compile(tile38):
     assert expected == received
 
 
+key = random_string()
+id = random_string()
+feature = {
+    "type": "Feature",
+    "geometry": {"type": "Point", "coordinates": [13.37, 52.25]},
+    "properties": {"id": id},
+}
+polygon = {
+    "type": "Polygon",
+    "coordinates": [
+        [
+            [13.361263275146484, 52.24630137198303],
+            [13.379974365234373, 52.24630137198303],
+            [13.379974365234373, 52.256705331409506],
+            [13.361263275146484, 52.256705331409506],
+            [13.361263275146484, 52.24630137198303],
+        ]
+    ],
+}
+
+expected = {"id": id, "object": feature}
+
+
 @pytest.mark.asyncio
 async def test_command_intersects_circle(tile38):
     response = await tile38.set(key, id).object(feature).exec()
@@ -228,7 +233,10 @@ async def test_command_intersects_bounds(tile38):
 
 @pytest.mark.asyncio
 async def test_command_intersects_object_with_intersection(tile38):
-    response = await tile38.set("zones", "zone").object(polygon).exec()
+    key = random_string()
+    id = random_string()
+
+    response = await tile38.set(key, id).object(polygon).exec()
     assert response.ok
 
     intersecting_feature = {
@@ -244,15 +252,19 @@ async def test_command_intersects_object_with_intersection(tile38):
         ],
     }
 
-    response = await tile38.intersects("zones").object(intersecting_feature).asObjects()
+    response = await tile38.intersects(key).object(intersecting_feature).asObjects()
 
     assert response.ok
-    assert response.objects[0].dict() == {"id": "zone", "object": polygon}
+    assert response.objects[0].dict() == {"id": id, "object": polygon}
 
 
 @pytest.mark.asyncio
 async def test_command_intersects_get(tile38):
-    response = await tile38.set("zones", "zone").object(polygon).exec()
+    key = random_string()
+    id = random_string()
+    id2 = random_string()
+
+    response = await tile38.set(key, id).object(polygon).exec()
     assert response.ok
 
     intersecting_feature = {
@@ -268,17 +280,13 @@ async def test_command_intersects_get(tile38):
         ],
     }
 
-    response = (
-        await tile38.set("zones", "zone_intersect").object(intersecting_feature).exec()
-    )
+    response = await tile38.set(key, id2).object(intersecting_feature).exec()
     assert response.ok
 
-    response = (
-        await tile38.intersects("zones").get("zones", "zone_intersect").asObjects()
-    )
+    response = await tile38.intersects(key).get(key, id2).asObjects()
 
     assert response.ok
-    assert response.objects[0].dict() == {"id": "zone", "object": polygon}
+    assert response.objects[0].dict() == {"id": id, "object": polygon}
 
 
 @pytest.mark.asyncio