Unverified Commit 94c66368 authored by Robert Schütz's avatar Robert Schütz Committed by GitHub
Browse files

Merge pull request #335747 from dotlambda/python3Packages.flask-limiter

python312Packages.flask-limiter: 3.7.0 -> 3.8.0
parents 612bdba2 a9d8bdc3
Loading
Loading
Loading
Loading
+9 −8
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@
  ordered-set,
  pymemcache,
  pymongo,
  pytest-cov-stub,
  pytest-mock,
  pytestCheckHook,
  pythonOlder,
@@ -20,28 +21,27 @@

buildPythonPackage rec {
  pname = "flask-limiter";
  version = "3.7.0";
  version = "3.8.0";
  pyproject = true;

  disabled = pythonOlder "3.7";
  disabled = pythonOlder "3.8";

  src = fetchFromGitHub {
    owner = "alisaifee";
    repo = "flask-limiter";
    rev = "refs/tags/${version}";
    hash = "sha256-W40zuQ/xkoV35DXehwMUJwbX0grJMfRXawiPfpRKL/g=";
    hash = "sha256-RkeG5XdanSp2syKrQgYUZ4r8D28Zt33/MsW0UxWxaU0=";
  };

  postPatch = ''
    sed -i "/--cov/d" pytest.ini

    # flask-restful is unmaintained and breaks regularly, don't depend on it
    sed -i "/import flask_restful/d" tests/test_views.py
    substituteInPlace tests/test_views.py \
      --replace-fail "import flask_restful" ""
  '';

  nativeBuildInputs = [ setuptools ];
  build-system = [ setuptools ];

  propagatedBuildInputs = [
  dependencies = [
    flask
    limits
    ordered-set
@@ -57,6 +57,7 @@ buildPythonPackage rec {

  nativeCheckInputs = [
    asgiref
    pytest-cov-stub
    pytest-mock
    pytestCheckHook
    hiro
+25 −14
Original line number Diff line number Diff line
@@ -6,6 +6,8 @@
  deprecated,
  etcd3,
  fetchFromGitHub,
  fetchpatch2,
  flaky,
  hiro,
  importlib-resources,
  motor,
@@ -13,6 +15,7 @@
  pymemcache,
  pymongo,
  pytest-asyncio,
  pytest-benchmark,
  pytest-lazy-fixture,
  pytestCheckHook,
  pythonOlder,
@@ -23,10 +26,10 @@

buildPythonPackage rec {
  pname = "limits";
  version = "3.12.0";
  version = "3.13.0";
  pyproject = true;

  disabled = pythonOlder "3.7";
  disabled = pythonOlder "3.8";

  src = fetchFromGitHub {
    owner = "alisaifee";
@@ -38,9 +41,20 @@ buildPythonPackage rec {
    postFetch = ''
      rm "$out/limits/_version.py"
    '';
    hash = "sha256-EH2/75tcKuS11XKuo4lCQrFe4/XJZpcWhuGlSuhIk18=";
    hash = "sha256-y5iMx+AC52ZgGvAvThRaeKFqCGkwmukyZsJ+nzR2AFM=";
  };

  patches = [
    (fetchpatch2 {
      name = "fix-incompatibility-with-latest-pytest-asyncio.patch";
      url = "https://github.com/alisaifee/limits/commit/f6dcdb253cd44ca8dc7380c481da1afd8b57af6b.patch";
      excludes = [ "requirements/test.txt" ];
      hash = "sha256-NwtN8WHNrwsRcIq18pRjzzGmm7XCzn6O5y+jo9Qr6iQ=";
    })
    ./remove-fixed-start-from-async-tests.patch
    ./only-test-in-memory.patch
  ];

  postPatch = ''
    substituteInPlace pytest.ini \
      --replace-fail "--cov=limits" "" \
@@ -53,16 +67,16 @@ buildPythonPackage rec {
    echo 'def get_versions(): return {"version": "${version}"}' > limits/_version.py
  '';

  nativeBuildInputs = [ setuptools ];
  build-system = [ setuptools ];

  propagatedBuildInputs = [
  dependencies = [
    deprecated
    importlib-resources
    packaging
    typing-extensions
  ];

  passthru.optional-dependencies = {
  optional-dependencies = {
    redis = [ redis ];
    rediscluster = [ redis ];
    memcached = [ pymemcache ];
@@ -79,20 +93,17 @@ buildPythonPackage rec {
  doCheck = pythonOlder "3.12"; # SystemError in protobuf

  nativeCheckInputs = [
    flaky
    hiro
    pytest-asyncio
    pytest-benchmark
    pytest-lazy-fixture
    pytestCheckHook
  ] ++ lib.flatten (lib.attrValues passthru.optional-dependencies);
  ] ++ lib.flatten (lib.attrValues optional-dependencies);

  pythonImportsCheck = [ "limits" ];
  disabledTests = [ "test_moving_window_memcached" ];

  pytestFlagsArray = [
    # All other tests require a running Docker instance
    "tests/test_limits.py"
    "tests/test_ratelimit_parser.py"
    "tests/test_limit_granularities.py"
  ];
  pythonImportsCheck = [ "limits" ];

  meta = with lib; {
    description = "Rate limiting using various strategies and storage backends such as redis & memcached";
+487 −0
Original line number Diff line number Diff line
diff --git a/tests/aio/test_storage.py b/tests/aio/test_storage.py
index 1040d18..deecd9b 100644
--- a/tests/aio/test_storage.py
+++ b/tests/aio/test_storage.py
@@ -95,102 +95,6 @@ class TestBaseStorage:
     "uri, args, expected_instance, fixture",
     [
         pytest.param("async+memory://", {}, MemoryStorage, None, id="in-memory"),
-        pytest.param(
-            "async+redis://localhost:7379",
-            {},
-            RedisStorage,
-            pytest.lazy_fixture("redis_basic"),
-            marks=pytest.mark.redis,
-            id="redis",
-        ),
-        pytest.param(
-            "async+redis+unix:///tmp/limits.redis.sock",
-            {},
-            RedisStorage,
-            pytest.lazy_fixture("redis_uds"),
-            marks=pytest.mark.redis,
-            id="redis-uds",
-        ),
-        pytest.param(
-            "async+redis+unix://:password/tmp/limits.redis.sock",
-            {},
-            RedisStorage,
-            pytest.lazy_fixture("redis_uds"),
-            marks=pytest.mark.redis,
-            id="redis-uds-auth",
-        ),
-        pytest.param(
-            "async+memcached://localhost:22122",
-            {},
-            MemcachedStorage,
-            pytest.lazy_fixture("memcached"),
-            marks=pytest.mark.memcached,
-            id="memcached",
-        ),
-        pytest.param(
-            "async+memcached://localhost:22122,localhost:22123",
-            {},
-            MemcachedStorage,
-            pytest.lazy_fixture("memcached_cluster"),
-            marks=pytest.mark.memcached,
-            id="memcached-cluster",
-        ),
-        pytest.param(
-            "async+redis+sentinel://localhost:26379",
-            {"service_name": "mymaster"},
-            RedisSentinelStorage,
-            pytest.lazy_fixture("redis_sentinel"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel",
-        ),
-        pytest.param(
-            "async+redis+sentinel://localhost:26379/mymaster",
-            {},
-            RedisSentinelStorage,
-            pytest.lazy_fixture("redis_sentinel"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel-service-name-url",
-        ),
-        pytest.param(
-            "async+redis+sentinel://:sekret@localhost:36379/mymaster",
-            {"password": "sekret"},
-            RedisSentinelStorage,
-            pytest.lazy_fixture("redis_sentinel_auth"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel-auth",
-        ),
-        pytest.param(
-            "async+redis+cluster://localhost:7001/",
-            {},
-            RedisClusterStorage,
-            pytest.lazy_fixture("redis_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster",
-        ),
-        pytest.param(
-            "async+redis+cluster://:sekret@localhost:8400/",
-            {},
-            RedisClusterStorage,
-            pytest.lazy_fixture("redis_auth_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster-auth",
-        ),
-        pytest.param(
-            "async+mongodb://localhost:37017/",
-            {},
-            MongoDBStorage,
-            pytest.lazy_fixture("mongodb"),
-            marks=pytest.mark.mongodb,
-            id="mongodb",
-        ),
-        pytest.param(
-            "async+etcd://localhost:2379",
-            {},
-            EtcdStorage,
-            pytest.lazy_fixture("etcd"),
-            marks=pytest.mark.etcd,
-            id="etcd",
-        ),
     ],
 )
 class TestConcreteStorages:
diff --git a/tests/test_storage.py b/tests/test_storage.py
index 1b8c7b0..97dcee5 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -100,110 +100,6 @@ class TestBaseStorage:
     "uri, args, expected_instance, fixture",
     [
         pytest.param("memory://", {}, MemoryStorage, None, id="in-memory"),
-        pytest.param(
-            "redis://localhost:7379",
-            {},
-            RedisStorage,
-            pytest.lazy_fixture("redis_basic"),
-            marks=pytest.mark.redis,
-            id="redis",
-        ),
-        pytest.param(
-            "redis+unix:///tmp/limits.redis.sock",
-            {},
-            RedisStorage,
-            pytest.lazy_fixture("redis_uds"),
-            marks=pytest.mark.redis,
-            id="redis-uds",
-        ),
-        pytest.param(
-            "redis+unix://:password/tmp/limits.redis.sock",
-            {},
-            RedisStorage,
-            pytest.lazy_fixture("redis_uds"),
-            marks=pytest.mark.redis,
-            id="redis-uds-auth",
-        ),
-        pytest.param(
-            "memcached://localhost:22122",
-            {},
-            MemcachedStorage,
-            pytest.lazy_fixture("memcached"),
-            marks=pytest.mark.memcached,
-            id="memcached",
-        ),
-        pytest.param(
-            "memcached://localhost:22122,localhost:22123",
-            {},
-            MemcachedStorage,
-            pytest.lazy_fixture("memcached_cluster"),
-            marks=pytest.mark.memcached,
-            id="memcached-cluster",
-        ),
-        pytest.param(
-            "memcached:///tmp/limits.memcached.sock",
-            {},
-            MemcachedStorage,
-            pytest.lazy_fixture("memcached_uds"),
-            marks=pytest.mark.memcached,
-            id="memcached-uds",
-        ),
-        pytest.param(
-            "redis+sentinel://localhost:26379",
-            {"service_name": "mymaster"},
-            RedisSentinelStorage,
-            pytest.lazy_fixture("redis_sentinel"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel",
-        ),
-        pytest.param(
-            "redis+sentinel://localhost:26379/mymaster",
-            {},
-            RedisSentinelStorage,
-            pytest.lazy_fixture("redis_sentinel"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel-service-name-url",
-        ),
-        pytest.param(
-            "redis+sentinel://:sekret@localhost:36379/mymaster",
-            {"password": "sekret"},
-            RedisSentinelStorage,
-            pytest.lazy_fixture("redis_sentinel_auth"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel-auth",
-        ),
-        pytest.param(
-            "redis+cluster://localhost:7001/",
-            {},
-            RedisClusterStorage,
-            pytest.lazy_fixture("redis_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster",
-        ),
-        pytest.param(
-            "redis+cluster://:sekret@localhost:8400/",
-            {},
-            RedisClusterStorage,
-            pytest.lazy_fixture("redis_auth_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster-auth",
-        ),
-        pytest.param(
-            "mongodb://localhost:37017/",
-            {},
-            MongoDBStorage,
-            pytest.lazy_fixture("mongodb"),
-            marks=pytest.mark.mongodb,
-            id="mongodb",
-        ),
-        pytest.param(
-            "etcd://localhost:2379",
-            {},
-            EtcdStorage,
-            pytest.lazy_fixture("etcd"),
-            marks=pytest.mark.etcd,
-            id="etcd",
-        ),
     ],
 )
 class TestConcreteStorages:
diff --git a/tests/utils.py b/tests/utils.py
index 558d766..9dcb911 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -52,75 +52,6 @@ all_storage = pytest.mark.parametrize(
     "uri, args, fixture",
     [
         pytest.param("memory://", {}, None, id="in-memory"),
-        pytest.param(
-            "redis://localhost:7379",
-            {},
-            pytest.lazy_fixture("redis_basic"),
-            marks=pytest.mark.redis,
-            id="redis_basic",
-        ),
-        pytest.param(
-            "memcached://localhost:22122",
-            {},
-            pytest.lazy_fixture("memcached"),
-            marks=[pytest.mark.memcached, pytest.mark.flaky],
-            id="memcached",
-        ),
-        pytest.param(
-            "memcached://localhost:22122,localhost:22123",
-            {},
-            pytest.lazy_fixture("memcached_cluster"),
-            marks=[pytest.mark.memcached, pytest.mark.flaky],
-            id="memcached-cluster",
-        ),
-        pytest.param(
-            "redis+cluster://localhost:7001/",
-            {},
-            pytest.lazy_fixture("redis_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster",
-        ),
-        pytest.param(
-            "redis+cluster://:sekret@localhost:8400/",
-            {},
-            pytest.lazy_fixture("redis_auth_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster-auth",
-        ),
-        pytest.param(
-            "redis+cluster://localhost:8301",
-            {
-                "ssl": True,
-                "ssl_cert_reqs": "required",
-                "ssl_keyfile": "./tests/tls/client.key",
-                "ssl_certfile": "./tests/tls/client.crt",
-                "ssl_ca_certs": "./tests/tls/ca.crt",
-            },
-            pytest.lazy_fixture("redis_ssl_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-ssl-cluster",
-        ),
-        pytest.param(
-            "redis+sentinel://localhost:26379/mymaster",
-            {"use_replicas": False},
-            pytest.lazy_fixture("redis_sentinel"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel",
-        ),
-        pytest.param(
-            "mongodb://localhost:37017/",
-            {},
-            pytest.lazy_fixture("mongodb"),
-            marks=pytest.mark.mongodb,
-            id="mongodb",
-        ),
-        pytest.param(
-            "etcd://localhost:2379",
-            {},
-            pytest.lazy_fixture("etcd"),
-            marks=[pytest.mark.etcd, pytest.mark.flaky],
-            id="etcd",
-        ),
     ],
 )
 
@@ -128,54 +59,6 @@ moving_window_storage = pytest.mark.parametrize(
     "uri, args, fixture",
     [
         pytest.param("memory://", {}, None, id="in-memory"),
-        pytest.param(
-            "redis://localhost:7379",
-            {},
-            pytest.lazy_fixture("redis_basic"),
-            marks=pytest.mark.redis,
-            id="redis",
-        ),
-        pytest.param(
-            "redis+cluster://localhost:7001/",
-            {},
-            pytest.lazy_fixture("redis_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster",
-        ),
-        pytest.param(
-            "redis+cluster://:sekret@localhost:8400/",
-            {},
-            pytest.lazy_fixture("redis_auth_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster-auth",
-        ),
-        pytest.param(
-            "redis+cluster://localhost:8301",
-            {
-                "ssl": True,
-                "ssl_cert_reqs": "required",
-                "ssl_keyfile": "./tests/tls/client.key",
-                "ssl_certfile": "./tests/tls/client.crt",
-                "ssl_ca_certs": "./tests/tls/ca.crt",
-            },
-            pytest.lazy_fixture("redis_ssl_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-ssl-cluster",
-        ),
-        pytest.param(
-            "redis+sentinel://localhost:26379/mymaster",
-            {"use_replicas": False},
-            pytest.lazy_fixture("redis_sentinel"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel",
-        ),
-        pytest.param(
-            "mongodb://localhost:37017/",
-            {},
-            pytest.lazy_fixture("mongodb"),
-            marks=pytest.mark.mongodb,
-            id="mongodb",
-        ),
     ],
 )
 
@@ -183,75 +66,6 @@ async_all_storage = pytest.mark.parametrize(
     "uri, args, fixture",
     [
         pytest.param("async+memory://", {}, None, id="in-memory"),
-        pytest.param(
-            "async+redis://localhost:7379",
-            {},
-            pytest.lazy_fixture("redis_basic"),
-            marks=pytest.mark.redis,
-            id="redis",
-        ),
-        pytest.param(
-            "async+memcached://localhost:22122",
-            {},
-            pytest.lazy_fixture("memcached"),
-            marks=[pytest.mark.memcached, pytest.mark.flaky],
-            id="memcached",
-        ),
-        pytest.param(
-            "async+memcached://localhost:22122,localhost:22123",
-            {},
-            pytest.lazy_fixture("memcached_cluster"),
-            marks=[pytest.mark.memcached, pytest.mark.flaky],
-            id="memcached-cluster",
-        ),
-        pytest.param(
-            "async+redis+cluster://localhost:7001/",
-            {},
-            pytest.lazy_fixture("redis_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster",
-        ),
-        pytest.param(
-            "async+redis+cluster://:sekret@localhost:8400/",
-            {},
-            pytest.lazy_fixture("redis_auth_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster-auth",
-        ),
-        pytest.param(
-            "async+redis+cluster://localhost:8301",
-            {
-                "ssl": True,
-                "ssl_cert_reqs": "required",
-                "ssl_keyfile": "./tests/tls/client.key",
-                "ssl_certfile": "./tests/tls/client.crt",
-                "ssl_ca_certs": "./tests/tls/ca.crt",
-            },
-            pytest.lazy_fixture("redis_ssl_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-ssl-cluster",
-        ),
-        pytest.param(
-            "async+redis+sentinel://localhost:26379/mymaster",
-            {"use_replicas": False},
-            pytest.lazy_fixture("redis_sentinel"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel",
-        ),
-        pytest.param(
-            "async+mongodb://localhost:37017/",
-            {},
-            pytest.lazy_fixture("mongodb"),
-            marks=pytest.mark.mongodb,
-            id="mongodb",
-        ),
-        pytest.param(
-            "async+etcd://localhost:2379",
-            {},
-            pytest.lazy_fixture("etcd"),
-            marks=[pytest.mark.etcd, pytest.mark.flaky],
-            id="etcd",
-        ),
     ],
 )
 
@@ -259,53 +73,5 @@ async_moving_window_storage = pytest.mark.parametrize(
     "uri, args, fixture",
     [
         pytest.param("async+memory://", {}, None, id="in-memory"),
-        pytest.param(
-            "async+redis://localhost:7379",
-            {},
-            pytest.lazy_fixture("redis_basic"),
-            marks=pytest.mark.redis,
-            id="redis",
-        ),
-        pytest.param(
-            "async+redis+cluster://localhost:7001/",
-            {},
-            pytest.lazy_fixture("redis_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster",
-        ),
-        pytest.param(
-            "async+redis+cluster://:sekret@localhost:8400/",
-            {},
-            pytest.lazy_fixture("redis_auth_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-cluster-auth",
-        ),
-        pytest.param(
-            "async+redis+cluster://localhost:8301",
-            {
-                "ssl": True,
-                "ssl_cert_reqs": "required",
-                "ssl_keyfile": "./tests/tls/client.key",
-                "ssl_certfile": "./tests/tls/client.crt",
-                "ssl_ca_certs": "./tests/tls/ca.crt",
-            },
-            pytest.lazy_fixture("redis_ssl_cluster"),
-            marks=pytest.mark.redis_cluster,
-            id="redis-ssl-cluster",
-        ),
-        pytest.param(
-            "async+redis+sentinel://localhost:26379/mymaster",
-            {"use_replicas": False},
-            pytest.lazy_fixture("redis_sentinel"),
-            marks=pytest.mark.redis_sentinel,
-            id="redis-sentinel",
-        ),
-        pytest.param(
-            "async+mongodb://localhost:37017/",
-            {},
-            pytest.lazy_fixture("mongodb"),
-            marks=pytest.mark.mongodb,
-            id="mongodb",
-        ),
     ],
 )
+87 −0
Original line number Diff line number Diff line
diff --git a/tests/aio/test_storage.py b/tests/aio/test_storage.py
index 1040d18..7015278 100644
--- a/tests/aio/test_storage.py
+++ b/tests/aio/test_storage.py
@@ -17,7 +17,6 @@ from limits.aio.storage import (
 from limits.aio.strategies import MovingWindowRateLimiter
 from limits.errors import StorageError
 from limits.storage import storage_from_string
-from tests.utils import fixed_start
 
 
 @pytest.mark.asyncio
@@ -197,7 +196,6 @@ class TestConcreteStorages:
     async def test_storage_string(self, uri, args, expected_instance, fixture):
         assert isinstance(storage_from_string(uri, **args), expected_instance)
 
-    @fixed_start
     async def test_expiry_incr(self, uri, args, expected_instance, fixture):
         storage = storage_from_string(uri, **args)
         limit = RateLimitItemPerSecond(1)
@@ -205,7 +203,6 @@ class TestConcreteStorages:
         time.sleep(1.1)
         assert await storage.get(limit.key_for()) == 0
 
-    @fixed_start
     async def test_expiry_acquire_entry(self, uri, args, expected_instance, fixture):
         if not issubclass(expected_instance, MovingWindowSupport):
             pytest.skip("%s does not support acquire entry" % expected_instance)
diff --git a/tests/aio/test_strategy.py b/tests/aio/test_strategy.py
index b21f808..efa3b95 100644
--- a/tests/aio/test_strategy.py
+++ b/tests/aio/test_strategy.py
@@ -18,14 +18,12 @@ from tests.utils import (
     async_all_storage,
     async_moving_window_storage,
     async_window,
-    fixed_start,
 )
 
 
 @pytest.mark.asyncio
 class TestAsyncWindow:
     @async_all_storage
-    @fixed_start
     async def test_fixed_window(self, uri, args, fixture):
         storage = storage_from_string(uri, **args)
         limiter = FixedWindowRateLimiter(storage)
@@ -37,7 +35,6 @@ class TestAsyncWindow:
         assert (await limiter.get_window_stats(limit)).reset_time == start + 2
 
     @async_all_storage
-    @fixed_start
     async def test_fixed_window_empty_stats(self, uri, args, fixture):
         storage = storage_from_string(uri, **args)
         limiter = FixedWindowRateLimiter(storage)
@@ -61,7 +58,6 @@ class TestAsyncWindow:
         ) == 58
 
     @async_all_storage
-    @fixed_start
     async def test_fixed_window_multiple_cost(self, uri, args, fixture):
         storage = storage_from_string(uri, **args)
         limiter = FixedWindowRateLimiter(storage)
@@ -73,7 +69,6 @@ class TestAsyncWindow:
         assert not await limiter.hit(limit, "k2", cost=6)
 
     @async_all_storage
-    @fixed_start
     async def test_fixed_window_with_elastic_expiry(self, uri, args, fixture):
         storage = storage_from_string(uri, **args)
         limiter = FixedWindowElasticExpiryRateLimiter(storage)
@@ -90,7 +85,6 @@ class TestAsyncWindow:
         assert (await limiter.get_window_stats(limit)).reset_time == end + 2
 
     @async_all_storage
-    @fixed_start
     async def test_fixed_window_with_elastic_expiry_multiple_cost(
         self, uri, args, fixture
     ):
@@ -179,7 +173,6 @@ class TestAsyncWindow:
             MovingWindowRateLimiter(storage)
 
     @async_all_storage
-    @fixed_start
     @pytest.mark.flaky
     async def test_test_fixed_window(self, uri, args, fixture):
         storage = storage_from_string(uri, **args)