small fix and change prefixes for tests

Author: burak-upstash

.github/workflows/tests.yml

@@ -0,0 +1,31 @@
+name: Test
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+
+      - name: Install Poetry
+        run: curl -sSL https://install.python-poetry.org | python3 -
+
+      - name: Set up Poetry environment
+        run: poetry install --no-root
+
+      - name: Run tests
+        run: |
+          export UPSTASH_REDIST_REST_URL="${{secrets.UPSTASH_REDIS_REST_URL}}"
+          export UPSTASH_REDIST_REST_TOKEN="${{secrets.UPSTASH_REDIS_REST_TOKEN}}"
+          poetry run pytest

tests/algorithm/limiting/test_fixed_window_limiting.py

@@ -2,7 +2,7 @@
 from tests.client import rate_limit
 from pytest import mark
 
-fixed_window = rate_limit.fixed_window(max_number_of_requests=1, window=5000, unit="ms")
+fixed_window = rate_limit.fixed_window(max_number_of_requests=1, window=10000, unit="ms")
 
 def test_below_max() -> None:
     assert (fixed_window.limit("fixed_window_1"))["is_allowed"] is True
@@ -12,7 +12,7 @@ def test_below_max() -> None:
 def test_above_max() -> None:
     fixed_window.limit("fixed_window_2")
 
-    sleep(0.5)
+    sleep(1)
 
     assert (fixed_window.limit("fixed_window_2"))["is_allowed"] is False
     assert (fixed_window.limit("fixed_window_2"))["is_allowed"] is False
@@ -24,27 +24,28 @@ def test_after_window() -> None:
     fixed_window.limit("fixed_window_3")
 
     # Wait for the reset.
-    sleep(5)
+    sleep(10)
 
     assert (fixed_window.limit("fixed_window_3"))["is_allowed"] is True
 
 
-
 def test_with_non_ms_unit() -> None:
     fixed_window_with_seconds = rate_limit.fixed_window(
-        max_number_of_requests=1, window=5, unit="s"
+        max_number_of_requests=1, window=10, unit="s"
     )
 
     assert (fixed_window_with_seconds.limit("fixed_window_4"))[
         "is_allowed"
     ] is True
 
+    sleep(1)
+
     # Exhaust the request limit.
     assert (fixed_window_with_seconds.limit("fixed_window_4"))[
         "is_allowed"
     ] is False
 
-    sleep(5)
+    sleep(10)
 
     assert (fixed_window_with_seconds.limit("fixed_window_4"))[
         "is_allowed"

tests/algorithm/reset/test_fixed_window_reset.py

@@ -1,6 +1,7 @@
+import pytest
 from tests.client import rate_limit
 from pytest import mark
-from time import time_ns
+from time import sleep, time_ns
 from math import floor
 
 fixed_window = rate_limit.fixed_window(max_number_of_requests=1, window=3000, unit="ms")
@@ -11,7 +12,6 @@ def test_before_the_first_request() -> None:
 def test_after_the_first_request() -> None:
     fixed_window.limit("fixed_window_reset_2")
 
-    assert (
-        fixed_window.reset("fixed_window_reset_2")
-        == floor((time_ns() / 1000000) / 3000) * 3000 + 3000
-    )
+    sleep(0.3)
+
+    assert pytest.approx(floor((time_ns() / 1000000) / 3000) * 3000 + 3000, 0.1) == fixed_window.reset("fixed_window_reset_2")

tests/asyncio/algorithm/limiting/test_async_fixed_window_limiting.py

@@ -2,52 +2,54 @@
 from tests.asyncio.client import rate_limit
 from pytest import mark
 
-fixed_window = rate_limit.fixed_window(max_number_of_requests=1, window=5000, unit="ms")
+fixed_window = rate_limit.fixed_window(max_number_of_requests=1, window=10000, unit="ms")
 
 
 @mark.asyncio
 async def test_below_max() -> None:
-    assert (await fixed_window.limit("fixed_window_1"))["is_allowed"] is True
+    assert (await fixed_window.limit("async_fixed_window_1"))["is_allowed"] is True
 
 
 @mark.asyncio
 async def test_above_max() -> None:
-    await fixed_window.limit("fixed_window_2")
+    await fixed_window.limit("async_fixed_window_2")
 
-    await sleep(0.5)
+    await sleep(1)
 
-    assert (await fixed_window.limit("fixed_window_2"))["is_allowed"] is False
-    assert (await fixed_window.limit("fixed_window_2"))["is_allowed"] is False
+    assert (await fixed_window.limit("async_fixed_window_2"))["is_allowed"] is False
+    assert (await fixed_window.limit("async_fixed_window_2"))["is_allowed"] is False
 
 
 @mark.asyncio
 async def test_after_window() -> None:
     # Exhaust the request limit.
-    await fixed_window.limit("fixed_window_3")
+    await fixed_window.limit("async_fixed_window_3")
 
     # Wait for the reset.
-    await sleep(5)
+    await sleep(10)
 
-    assert (await fixed_window.limit("fixed_window_3"))["is_allowed"] is True
+    assert (await fixed_window.limit("async_fixed_window_3"))["is_allowed"] is True
 
 
 @mark.asyncio
 async def test_with_non_ms_unit() -> None:
     fixed_window_with_seconds = rate_limit.fixed_window(
-        max_number_of_requests=1, window=5, unit="s"
+        max_number_of_requests=1, window=10, unit="s"
     )
 
-    assert (await fixed_window_with_seconds.limit("fixed_window_4"))[
+    assert (await fixed_window_with_seconds.limit("async_fixed_window_4"))[
         "is_allowed"
     ] is True
 
+    await sleep(1)
+
     # Exhaust the request limit.
-    assert (await fixed_window_with_seconds.limit("fixed_window_4"))[
+    assert (await fixed_window_with_seconds.limit("async_fixed_window_4"))[
         "is_allowed"
     ] is False
 
-    await sleep(5)
+    await sleep(10)
 
-    assert (await fixed_window_with_seconds.limit("fixed_window_4"))[
+    assert (await fixed_window_with_seconds.limit("async_fixed_window_4"))[
         "is_allowed"
     ] is True

tests/asyncio/algorithm/limiting/test_async_token_bucket_limiting.py

@@ -10,26 +10,26 @@
 
 @mark.asyncio
 async def test_below_max() -> None:
-    assert (await token_bucket.limit("token_bucket_1"))["is_allowed"] is True
+    assert (await token_bucket.limit("async_token_bucket_1"))["is_allowed"] is True
 
 
 @mark.asyncio
 async def test_above_max() -> None:
-    await token_bucket.limit("token_bucket_2")
+    await token_bucket.limit("async_token_bucket_2")
 
-    assert (await token_bucket.limit("token_bucket_2"))["is_allowed"] is False
-    assert (await token_bucket.limit("token_bucket_2"))["is_allowed"] is False
+    assert (await token_bucket.limit("async_token_bucket_2"))["is_allowed"] is False
+    assert (await token_bucket.limit("async_token_bucket_2"))["is_allowed"] is False
 
 
 @mark.asyncio
 async def test_after_window() -> None:
     # Exhaust the request limit.
-    await token_bucket.limit("token_bucket_3")
+    await token_bucket.limit("async_token_bucket_3")
 
     # Wait for the refill.
     sleep(3)
 
-    assert (await token_bucket.limit("token_bucket_3"))["is_allowed"] is True
+    assert (await token_bucket.limit("async_token_bucket_3"))["is_allowed"] is True
 
 
 @mark.asyncio
@@ -39,18 +39,18 @@ async def test_with_non_ms_unit() -> None:
     )
 
     # Exhaust the request limit.
-    assert (await token_bucket_with_seconds.limit("token_bucket_4"))[
+    assert (await token_bucket_with_seconds.limit("async_token_bucket_4"))[
         "is_allowed"
     ] is True
 
-    assert (await token_bucket_with_seconds.limit("token_bucket_4"))[
+    assert (await token_bucket_with_seconds.limit("async_token_bucket_4"))[
         "is_allowed"
     ] is False
 
     # Wait for the refill.
     sleep(3)
 
-    assert (await token_bucket_with_seconds.limit("token_bucket_4"))[
+    assert (await token_bucket_with_seconds.limit("async_token_bucket_4"))[
         "is_allowed"
     ] is True
 
@@ -64,60 +64,60 @@ async def test_with_non_ms_unit() -> None:
 @mark.asyncio
 async def test_burst() -> None:
     # Exhaust the request limit.
-    await burst_token_bucket.limit("burst_token_bucket_1")
-    await burst_token_bucket.limit("burst_token_bucket_1")
+    await burst_token_bucket.limit("async_burst_token_bucket_1")
+    await burst_token_bucket.limit("async_burst_token_bucket_1")
 
     # Wait for the refill.
     sleep(2)
 
-    assert (await burst_token_bucket.limit("burst_token_bucket_1"))[
+    assert (await burst_token_bucket.limit("async_burst_token_bucket_1"))[
         "is_allowed"
     ] is True
-    assert (await burst_token_bucket.limit("burst_token_bucket_1"))[
+    assert (await burst_token_bucket.limit("async_burst_token_bucket_1"))[
         "is_allowed"
     ] is False
-    assert (await burst_token_bucket.limit("burst_token_bucket_1"))[
+    assert (await burst_token_bucket.limit("async_burst_token_bucket_1"))[
         "is_allowed"
     ] is False
 
 
 @mark.asyncio
 async def test_with_positive_number_of_tokens_before_the_refill() -> None:
-    await burst_token_bucket.limit("burst_token_bucket_2")
+    await burst_token_bucket.limit("async_burst_token_bucket_2")
 
     """
     At this point the bucket should've had 1 token. 
     Since the refill adds another one, the next two requests should pass.
     """
     sleep(2)
 
-    assert (await burst_token_bucket.limit("burst_token_bucket_2"))[
+    assert (await burst_token_bucket.limit("async_burst_token_bucket_2"))[
         "is_allowed"
     ] is True
-    assert (await burst_token_bucket.limit("burst_token_bucket_2"))[
+    assert (await burst_token_bucket.limit("async_burst_token_bucket_2"))[
         "is_allowed"
     ] is True
-    assert (await burst_token_bucket.limit("burst_token_bucket_2"))[
+    assert (await burst_token_bucket.limit("async_burst_token_bucket_2"))[
         "is_allowed"
     ] is False
 
 
 @mark.asyncio
 async def test_multiple_refills() -> None:
     # Exhaust the request limit.
-    await burst_token_bucket.limit("burst_token_bucket_3")
-    await burst_token_bucket.limit("burst_token_bucket_3")
+    await burst_token_bucket.limit("async_burst_token_bucket_3")
+    await burst_token_bucket.limit("async_burst_token_bucket_3")
 
     # Wait for 2 refills.
     sleep(4)
 
-    assert (await burst_token_bucket.limit("burst_token_bucket_3"))[
+    assert (await burst_token_bucket.limit("async_burst_token_bucket_3"))[
         "is_allowed"
     ] is True
-    assert (await burst_token_bucket.limit("burst_token_bucket_3"))[
+    assert (await burst_token_bucket.limit("async_burst_token_bucket_3"))[
         "is_allowed"
     ] is True
-    assert (await burst_token_bucket.limit("burst_token_bucket_3"))[
+    assert (await burst_token_bucket.limit("async_burst_token_bucket_3"))[
         "is_allowed"
     ] is False
 

tests/asyncio/algorithm/remaining/test_async_fixed_window_remaining.py

@@ -6,11 +6,11 @@
 
 @mark.asyncio
 async def test_before_the_first_request() -> None:
-    assert await fixed_window.remaining("fixed_window_remaining_1") == 1
+    assert await fixed_window.remaining("async_fixed_window_remaining_1") == 1
 
 
 @mark.asyncio
 async def test_after_the_first_request() -> None:
-    await fixed_window.limit("fixed_window_remaining_2")
+    await fixed_window.limit("async_fixed_window_remaining_2")
 
-    assert await fixed_window.remaining("fixed_window_remaining_2") == 0
+    assert await fixed_window.remaining("async_fixed_window_remaining_2") == 0

tests/asyncio/algorithm/remaining/test_async_token_bucket_remaining.py

@@ -9,14 +9,14 @@
 
 @mark.asyncio
 async def test_before_the_first_request() -> None:
-    assert await token_bucket.remaining("token_bucket_remaining_1") == 1
+    assert await token_bucket.remaining("async_token_bucket_remaining_1") == 1
 
 
 @mark.asyncio
 async def test_after_the_first_request() -> None:
-    await token_bucket.limit("token_bucket_remaining_2")
+    await token_bucket.limit("async_token_bucket_remaining_2")
 
-    assert await token_bucket.remaining("token_bucket_remaining_2") == 0
+    assert await token_bucket.remaining("async_token_bucket_remaining_2") == 0
 
 
 # Use a client that has different maximum number of tokens and refill rate.
@@ -28,23 +28,23 @@ async def test_after_the_first_request() -> None:
 @mark.asyncio
 async def test_after_burst() -> None:
     # Exhaust the request limit.
-    await burst_token_bucket.limit("burst_token_bucket_remaining_1")
-    await burst_token_bucket.limit("burst_token_bucket_remaining_1")
+    await burst_token_bucket.limit("async_burst_token_bucket_remaining_1")
+    await burst_token_bucket.limit("async_burst_token_bucket_remaining_1")
 
     # Wait for the refill.
     sleep(2)
 
-    assert await burst_token_bucket.remaining("burst_token_bucket_remaining_1") == 1
+    assert await burst_token_bucket.remaining("async_burst_token_bucket_remaining_1") == 1
 
 
 @mark.asyncio
 async def test_after_burst_with_positive_number_of_tokens_before_the_refill() -> None:
-    await burst_token_bucket.limit("burst_token_bucket_remaining_2")
+    await burst_token_bucket.limit("async_burst_token_bucket_remaining_2")
 
     """
     At this point the bucket should've had 1 token. 
     Since the refill adds another one, the identifier should have 2 requests left.
     """
     sleep(2)
 
-    assert await burst_token_bucket.remaining("burst_token_bucket_remaining_2") == 2
+    assert await burst_token_bucket.remaining("async_burst_token_bucket_remaining_2") == 2

tests/asyncio/algorithm/reset/test_async_fixed_window_reset.py

@@ -8,14 +8,14 @@
 
 @mark.asyncio
 async def test_before_the_first_request() -> None:
-    assert await fixed_window.reset("fixed_window_reset_1") == -1
+    assert await fixed_window.reset("async_fixed_window_reset_1") == -1
 
 
 @mark.asyncio
 async def test_after_the_first_request() -> None:
-    await fixed_window.limit("fixed_window_reset_2")
+    await fixed_window.limit("async_fixed_window_reset_2")
 
     assert (
-        await fixed_window.reset("fixed_window_reset_2")
+        await fixed_window.reset("async_fixed_window_reset_2")
         == floor((time_ns() / 1000000) / 3000) * 3000 + 3000
     )