diff --git a/tests/helper/random_data.py b/tests/helper/random_data.py
index b28614a..55fa483 100644
--- a/tests/helper/random_data.py
+++ b/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()
diff --git a/tests/test_command_bounds.py b/tests/test_command_bounds.py
index fe5612e..6da8bc8 100644
--- a/tests/test_command_bounds.py
+++ b/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": [
diff --git a/tests/test_command_config.py b/tests/test_command_config.py
index b50852f..61d173f 100644
--- a/tests/test_command_config.py
+++ b/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
 
diff --git a/tests/test_command_del.py b/tests/test_command_del.py
index 975575b..2a70bee 100644
--- a/tests/test_command_del.py
+++ b/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
 
diff --git a/tests/test_command_drop.py b/tests/test_command_drop.py
index 7b75f27..63fb24e 100644
--- a/tests/test_command_drop.py
+++ b/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
 
diff --git a/tests/test_command_expire_persist.py b/tests/test_command_expire_persist.py
index 88365e4..0a89d53 100644
--- a/tests/test_command_expire_persist.py
+++ b/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)
diff --git a/tests/test_command_fset.py b/tests/test_command_fset.py
index 384b9be..b7da786 100644
--- a/tests/test_command_fset.py
+++ b/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()
diff --git a/tests/test_command_get.py b/tests/test_command_get.py
index b632c71..af43d71 100644
--- a/tests/test_command_get.py
+++ b/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
diff --git a/tests/test_command_hooks.py b/tests/test_command_hooks.py
index 3b52eef..9a4b390 100644
--- a/tests/test_command_hooks.py
+++ b/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
diff --git a/tests/test_command_intersects.py b/tests/test_command_intersects.py
index 806ef3a..6895733 100644
--- a/tests/test_command_intersects.py
+++ b/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
diff --git a/tests/test_command_keys.py b/tests/test_command_keys.py
index f84a477..abe8646 100644
--- a/tests/test_command_keys.py
+++ b/tests/test_command_keys.py
@@ -1,14 +1,18 @@
 import pytest
 
+from .helper.random_data import random_latitude, random_longitude, random_string
+
 
 @pytest.mark.asyncio
 async def test_command_keys(tile38_with_follower):
     tile38 = tile38_with_follower
 
-    key = "fleet"
-    id = "truck"
+    key = random_string()
+    id = random_string()
 
-    response = await tile38.set(key, id).point(1, 1).exec()
+    response = (
+        await tile38.set(key, id).point(random_latitude(), random_longitude()).exec()
+    )
     assert response.ok
 
     response = await tile38.keys()
diff --git a/tests/test_command_nearby.py b/tests/test_command_nearby.py
index bf129e7..8860229 100644
--- a/tests/test_command_nearby.py
+++ b/tests/test_command_nearby.py
@@ -2,8 +2,10 @@
 
 from pyle38.commands.nearby import Nearby
 
-key = "fleet"
-id = "truck"
+from .helper.random_data import random_string
+
+key = random_string()
+id = random_string()
 feature = {
     "type": "Feature",
     "geometry": {"type": "Point", "coordinates": [13.37, 52.25]},
diff --git a/tests/test_command_pdel.py b/tests/test_command_pdel.py
index 46b4b37..8b21f5c 100644
--- a/tests/test_command_pdel.py
+++ b/tests/test_command_pdel.py
@@ -2,29 +2,37 @@
 
 from pyle38.errors import Tile38IdNotFoundError, Tile38KeyNotFoundError
 
-key = "fleet"
-id = "truck1"
+from .helper.random_data import random_latitude, random_longitude, random_string
 
 
 @pytest.mark.asyncio
 async def test_command_pdel(tile38):
-    response = await tile38.set(key, id).point(1, 1).exec()
+    key = random_string()
+    id = random_string()
+    lat = random_latitude()
+    lon = random_longitude()
+
+    pdel_pattern = f"{id[0:3]}*"
+
+    response = await tile38.set(key, id).point(lat, lon).exec()
     assert response.ok
 
     response = await tile38.get(key, id).asObject()
     assert response.ok
     assert response.object["type"] == "Point"
 
-    response = await tile38.pdel(key, "tr*")
+    response = await tile38.pdel(key, pdel_pattern)
     assert response.ok
 
+    # key drops because only id deleted
     with pytest.raises(Tile38KeyNotFoundError):
         await tile38.get(key, id).asObject()
 
-    await tile38.set(key, "truck1").point(1, 1).exec()
-    await tile38.set(key, "bus1").point(1, 2).exec()
+    # key stays because only one id is deleted
+    await tile38.set(key, id).point(lat, lon).exec()
+    await tile38.set(key, random_string()).point(lat, lon).exec()
 
-    await tile38.pdel(key, "t*")
+    await tile38.pdel(key, pdel_pattern)
 
     with pytest.raises(Tile38IdNotFoundError):
-        await tile38.get(key, "truck1").asObject()
+        await tile38.get(key, id).asObject()
diff --git a/tests/test_command_readonly.py b/tests/test_command_readonly.py
index 805645f..08df2b6 100644
--- a/tests/test_command_readonly.py
+++ b/tests/test_command_readonly.py
@@ -2,23 +2,27 @@
 
 from pyle38.errors import Tile38Error
 
-key = "fleet"
-id = "truck"
+from .helper.random_data import random_latitude, random_longitude, random_string
 
 
 @pytest.mark.asyncio
 async def test_command_readonly(tile38):
-    response = await tile38.set(key, id).point(1, 1).exec()
+    key = random_string()
+    id = random_string()
+    lat = random_latitude()
+    lon = random_longitude()
+
+    response = await tile38.set(key, id).point(lat, lon).exec()
     assert response.ok
 
     response = await tile38.readonly()
     assert response.ok
 
     with pytest.raises(Tile38Error):
-        await tile38.set(key, id).point(1, 1).exec()
+        await tile38.set(key, id).point(lat, lon).exec()
 
     response = await tile38.readonly(value=False)
     assert response.ok
 
-    response.ok = await tile38.set(key, id).point(1, 1).exec()
+    response.ok = await tile38.set(key, id).point(lat, lon).exec()
     assert response.ok
diff --git a/tests/test_command_rename.py b/tests/test_command_rename.py
index 1fbce34..d9be8e7 100644
--- a/tests/test_command_rename.py
+++ b/tests/test_command_rename.py
@@ -2,14 +2,18 @@
 
 from pyle38.errors import Tile38KeyNotFoundError
 
-key = "fleet"
-newkey = "fl33t"
-id = "truck"
+from .helper.random_data import random_latitude, random_longitude, random_string
 
 
 @pytest.mark.asyncio
 async def test_command_rename(tile38):
-    response = await tile38.set(key, id).point(1, 1).exec()
+    key = random_string()
+    id = random_string()
+    newkey = random_string()
+    lat = random_latitude()
+    lon = random_longitude()
+
+    response = await tile38.set(key, id).point(lat, lon).exec()
     assert response.ok
 
     response = await tile38.rename(key, newkey)
@@ -21,10 +25,16 @@ async def test_command_rename(tile38):
 
 @pytest.mark.asyncio
 async def test_command_renamex(tile38):
-    response = await tile38.set(key, id).point(1, 1).exec()
+    key = random_string()
+    id = random_string()
+    newkey = random_string()
+    lat = random_latitude()
+    lon = random_longitude()
+
+    response = await tile38.set(key, id).point(lat, lon).exec()
     assert response.ok
 
-    response = await tile38.set(newkey, id).point(1, 1).exec()
+    response = await tile38.set(newkey, id).point(lat, lon).exec()
     assert response.ok
 
     response = await tile38.rename(key, newkey, nx=True)
diff --git a/tests/test_command_scan.py b/tests/test_command_scan.py
index 1d3a835..94f0b00 100644
--- a/tests/test_command_scan.py
+++ b/tests/test_command_scan.py
@@ -2,8 +2,10 @@
 
 from pyle38.commands.scan import Scan
 
-key = "fleet"
-id = "truck"
+from .helper.random_data import random_string
+
+key = random_string()
+id = random_string()
 feature = {
     "type": "Feature",
     "geometry": {"type": "Point", "coordinates": [13.37, 52.25]},