test: update stream tests

Author: CahidArda

tests/commands/asyncio/stream/test_xadd.py

@@ -47,11 +47,10 @@ async def test_xadd_with_maxlen_exact(async_redis: Redis):
 
 
 @pytest.mark.asyncio
-@pytest.mark.skip(reason="Approximate trimming behavior differs in Upstash Redis")
 async def test_xadd_with_maxlen_approximate(async_redis: Redis):
     """Test XADD with approximate maxlen trimming"""
     # Add multiple entries
-    for i in range(50):
+    for i in range(120):
         await async_redis.xadd("mystream", "*", {"field": f"value{i}"})
 
     # Add with approximate maxlen
@@ -61,8 +60,8 @@ async def test_xadd_with_maxlen_approximate(async_redis: Redis):
 
     # Check stream length (should be around 30, but may be slightly more due to approximation)
     length = await async_redis.xlen("mystream")
-    assert length >= 29
-    assert length <= 35  # Allow some variance for approximation
+    assert length >= 110
+    assert length <= 130  # Allow some variance for approximation
 
 
 @pytest.mark.asyncio

tests/commands/asyncio/stream/test_xlen.py

@@ -50,16 +50,15 @@ async def test_xlen_after_deletion(async_redis: Redis):
 
 
 @pytest.mark.asyncio
-@pytest.mark.skip(reason="Trimming behavior differs in Upstash Redis")
 async def test_xlen_after_trimming(async_redis: Redis):
     """Test XLEN after trimming stream"""
     # Add multiple entries
-    for i in range(10):
+    for i in range(130):
         await async_redis.xadd("mystream", "*", {"field": f"value{i}"})
 
     # Initial length
     length = await async_redis.xlen("mystream")
-    assert length == 10
+    assert length == 130
 
     # Trim to 5 entries
     trimmed = await async_redis.xtrim("mystream", maxlen=5)

tests/commands/stream/test_xack.py

@@ -137,7 +137,6 @@ def test_xack_partial_acknowledge(redis: Redis):
     assert pending_info[0] == 2  # 2 messages still pending
 
 
-@pytest.mark.skip(reason="Error handling differs in Upstash Redis")
 def test_xack_wrong_group_name(redis: Redis):
     """Test acknowledging with wrong group name"""
     stream_key = "test_stream"
@@ -154,6 +153,5 @@ def test_xack_wrong_group_name(redis: Redis):
     # Read the message
     redis.xreadgroup(group, consumer, {stream_key: ">"}, count=1)
 
-    # Try to acknowledge with wrong group name - should fail or return 0
-    with pytest.raises(Exception):
-        redis.xack(stream_key, wrong_group, message_id)
+    response = redis.xack(stream_key, wrong_group, message_id)
+    assert response == 0

tests/commands/stream/test_xadd.py

@@ -40,11 +40,10 @@ def test_xadd_with_maxlen_exact(redis: Redis):
     assert length <= 5
 
 
-@pytest.mark.skip(reason="Approximate trimming behavior differs in Upstash Redis")
 def test_xadd_with_maxlen_approximate(redis: Redis):
     """Test XADD with approximate maxlen trimming"""
     # Add multiple entries
-    for i in range(50):
+    for i in range(110):
         redis.xadd("mystream", "*", {"field": f"value{i}"})
 
     # Add with approximate maxlen
@@ -54,8 +53,8 @@ def test_xadd_with_maxlen_approximate(redis: Redis):
 
     # Check stream length (should be around 30, but may be slightly more due to approximation)
     length = redis.xlen("mystream")
-    assert length >= 29
-    assert length <= 35  # Allow some variance for approximation
+    assert length >= 100
+    assert length <= 120  # Allow some variance for approximation
 
 
 def test_xadd_with_nomkstream(redis: Redis):

tests/commands/stream/test_xgroup.py

@@ -60,26 +60,6 @@ def test_xgroup_createconsumer(redis: Redis):
     assert result == 1  # Consumer was created
 
 
-@pytest.mark.skip(reason="Consumer creation behavior differs in Upstash Redis")
-def test_xgroup_createconsumer_already_exists(redis: Redis):
-    """Test creating a consumer that already exists"""
-    key = "test_stream"
-    group = "test_group"
-    consumer = "test_consumer"
-
-    # Create stream and group
-    redis.xadd(key, "*", {"field": "value"})
-    redis.xgroup_create(key, group, "0")
-
-    # Create consumer first time
-    result1 = redis.xgroup_createconsumer(key, group, consumer)
-    assert result1 == 1
-
-    # Try to create same consumer again
-    result2 = redis.xgroup_createconsumer(key, group, consumer)
-    assert result2 == 0  # Consumer already existed
-
-
 def test_xgroup_delconsumer(redis: Redis):
     """Test deleting a consumer from a group"""
     key = "test_stream"

tests/commands/stream/test_xinfo.py

@@ -97,7 +97,6 @@ def test_xinfo_consumers_with_consumers(redis: Redis):
     assert found_consumer
 
 
-@pytest.mark.skip(reason="Error handling differs in Upstash Redis")
 def test_xinfo_nonexistent_group(redis: Redis):
     """Test XINFO CONSUMERS on non-existent group"""
     stream_key = "test_stream"
@@ -106,9 +105,8 @@ def test_xinfo_nonexistent_group(redis: Redis):
     # Create stream but no group
     redis.xadd(stream_key, "*", {"field": "value"})
 
-    # Should raise exception for non-existent group
-    with pytest.raises(Exception):
-        redis.xinfo_consumers(stream_key, nonexistent_group)
+    response = redis.xinfo_consumers(stream_key, nonexistent_group)
+    assert response == []
 
 
 def test_xinfo_multiple_groups(redis: Redis):

tests/commands/stream/test_xtrim.py

@@ -26,13 +26,12 @@ def test_xtrim_maxlen_exact(redis: Redis):
     assert length <= 30
 
 
-@pytest.mark.skip(reason="Approximate trimming behavior differs in Upstash Redis")
 def test_xtrim_maxlen_approximate(redis: Redis):
     """Test XTRIM with approximate MAXLEN"""
     key = "test_stream"
 
     # Add many entries
-    for i in range(100):
+    for i in range(120):
         redis.xadd(key, "*", {"field": f"value{i}"})
 
     # Trim approximately
@@ -41,8 +40,8 @@ def test_xtrim_maxlen_approximate(redis: Redis):
 
     # Length should be around 30 but may vary due to approximation
     length = redis.xlen(key)
-    assert length >= 25  # Should be reasonably close
-    assert length <= 40  # But allow some variance
+    assert length >= 110  # Should be reasonably close
+    assert length <= 130  # But allow some variance
 
 
 def test_xtrim_with_limit(redis: Redis):