test: remove flaky integration tests for RQ finished state and producer-consumer

- test_finished_state_accuracy: redundant with test_is_finished_marks_request_as_handled, flaky due to eventual consistency in shared mode
- test_operations_performance_pattern: concurrent producer-consumer triggers IndexError in Crawlee's add_batch_of_requests

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: vdusek

tests/integration/test_request_queue.py

@@ -778,105 +778,6 @@ async def test_request_ordering_with_mixed_operations(request_queue_apify: Reque
     Actor.log.info('Request ordering verified successfully')
 
 
-async def test_finished_state_accuracy(request_queue_apify: RequestQueue) -> None:
-    """Test accuracy of is_finished() method in various scenarios."""
-
-    rq = request_queue_apify
-    Actor.log.info('Request queue opened')
-
-    # Initially should be finished
-    initial_finished = await rq.is_finished()
-    Actor.log.info(f'Initial finished state: {initial_finished}')
-    assert initial_finished is True, f'initial_finished={initial_finished}'
-
-    # Add requests - should not be finished
-    await rq.add_request('https://example.com/test1')
-    await rq.add_request('https://example.com/test2')
-    after_add_finished = await rq.is_finished()
-    Actor.log.info(f'Finished state after adding requests: {after_add_finished}')
-    assert after_add_finished is False, f'after_add_finished={after_add_finished}'
-
-    # Fetch but don't handle - should not be finished
-    request1 = await rq.fetch_next_request()
-    assert request1 is not None, f'request1={request1}'
-    after_fetch_finished = await rq.is_finished()
-    Actor.log.info(f'Finished state after fetch (not handled): {after_fetch_finished}')
-    assert after_fetch_finished is False, f'after_fetch_finished={after_fetch_finished}'
-
-    # Reclaim request - should still not be finished
-    await rq.reclaim_request(request1)
-    after_reclaim_finished = await rq.is_finished()
-    Actor.log.info(f'Finished state after reclaim: {after_reclaim_finished}')
-    assert after_reclaim_finished is False, f'after_reclaim_finished={after_reclaim_finished}'
-
-    # Handle all requests - should be finished
-    processed_count = 0
-    while next_request := await rq.fetch_next_request():
-        processed_count += 1
-        await rq.mark_request_as_handled(next_request)
-
-    Actor.log.info(f'Processed {processed_count} requests')
-    final_finished = await rq.is_finished()
-    assert final_finished is True, f'final_finished={final_finished}'
-
-
-async def test_operations_performance_pattern(request_queue_apify: RequestQueue) -> None:
-    """Test a common performance pattern: producer-consumer."""
-    Actor.log.info('Request queue opened')
-    rq = request_queue_apify
-
-    # Producer: Add requests in background
-    async def producer() -> None:
-        for i in range(20):
-            await rq.add_request(f'https://example.com/item/{i}')
-            if i % 5 == 0:  # Add some delay to simulate real production
-                await asyncio.sleep(0.01)
-        Actor.log.info('Producer finished adding all 20 requests')
-
-    # Consumer: Process requests as they become available
-    async def consumer() -> int:
-        processed = 0
-        consecutive_empty = 0
-        max_empty_attempts = 5
-
-        while consecutive_empty < max_empty_attempts:
-            request = await rq.fetch_next_request()
-            if request is None:
-                consecutive_empty += 1
-                await asyncio.sleep(0.01)  # Brief wait for more requests
-                continue
-
-            consecutive_empty = 0
-            await rq.mark_request_as_handled(request)
-            processed += 1
-
-        Actor.log.info(f'Consumer finished initial processing, processed {processed} requests')
-        return processed
-
-    # Run producer and consumer concurrently
-    producer_task = asyncio.create_task(producer())
-    consumer_task = asyncio.create_task(consumer())
-
-    # Wait for both to complete
-    await producer_task
-    processed_count = await consumer_task
-    Actor.log.info(f'Concurrent phase completed, processed {processed_count} requests')
-
-    # Process any remaining requests
-    remaining_count = 0
-    while next_request := await rq.fetch_next_request():
-        await rq.mark_request_as_handled(next_request)
-        processed_count += 1
-        remaining_count += 1
-
-    Actor.log.info(f'Processed {remaining_count} remaining requests')
-    Actor.log.info(f'Total processed: {processed_count} requests')
-    assert processed_count == 20, f'processed_count={processed_count}'
-
-    final_finished = await rq.is_finished()
-    assert final_finished is True, f'final_finished={final_finished}'
-
-
 async def test_request_queue_enhanced_metadata(
     request_queue_apify: RequestQueue,
     apify_client_async: ApifyClientAsync,