Remove pollution-prone LogPusher retry test.

The test monkeypatched iris.log_server.client.LogServiceClientSync and
asserted on strict counts of factory invocations. Any leaked drain
thread from another test could call the patched factory during this
test's window, producing spurious created entries.

Author: rjpower

lib/iris/tests/test_remote_log_handler.py

@@ -289,106 +289,3 @@ def factory(address, timeout_ms=10_000, interceptors=()):
 
     monkeypatch.setattr(client_mod, "LogServiceClientSync", factory)
     return created
-
-
-def _entry(data="line"):
-    e = logging_pb2.LogEntry(source="test", data=data, level=logging_pb2.LOG_LEVEL_INFO)
-    e.timestamp.epoch_ms = 1
-    return e
-
-
-@pytest.mark.parametrize(
-    "scenario",
-    [
-        # Retryable RPC failure, resolver points elsewhere on the retry —
-        # the common log-server failover case.
-        "retryable_with_resolver_failover",
-        # Retryable RPC failure against a fixed URL — rebuilds the RPC
-        # client to heal a stuck TCP connection.
-        "retryable_static_url",
-        # Resolver itself raises on first call — rebuffers, retries, and
-        # the next resolver call succeeds.
-        "resolver_raises",
-        # Non-retryable RPC error — rebuffers (no drops) but does NOT
-        # invalidate the cached client.
-        "non_retryable",
-    ],
-)
-def test_failures_always_deliver_via_retry(monkeypatch, scenario):
-    """No send-failure path drops entries; the retry loop eventually delivers.
-
-    Asserts the delivery guarantee across all failure kinds. Per-scenario
-    extras check the side-effects (invalidate vs keep client, resolver
-    re-invoked or not).
-    """
-    created: list[_FakeLogServiceClient] = []
-
-    def factory(address, timeout_ms=10_000, interceptors=()):
-        c = _FakeLogServiceClient(address, timeout_ms=timeout_ms, interceptors=interceptors)
-        created.append(c)
-        return c
-
-    monkeypatch.setattr(client_mod, "LogServiceClientSync", factory)
-
-    pusher: LogPusher
-    if scenario == "retryable_with_resolver_failover":
-        addrs = iter(["http://a:1", "http://b:2"])
-        pusher = LogPusher("iris://x", batch_size=1, flush_interval=0.1, resolver=lambda _url: next(addrs))
-    elif scenario == "retryable_static_url":
-        pusher = LogPusher("http://h:1", batch_size=1, flush_interval=0.1)
-    elif scenario == "resolver_raises":
-        attempts: list[int] = []
-
-        def resolver(_url):
-            attempts.append(1)
-            if len(attempts) == 1:
-                raise ConnectionError("controller down")
-            return "http://good:1"
-
-        pusher = LogPusher("iris://x", batch_size=1, flush_interval=0.1, resolver=resolver)
-    elif scenario == "non_retryable":
-        pusher = LogPusher("iris://x", batch_size=1, flush_interval=0.1, resolver=lambda _url: "http://a:1")
-    else:
-        raise AssertionError(scenario)
-
-    try:
-        # First push — forces the drain thread to produce a client (except
-        # for resolver_raises, which has no client to seed).
-        pusher.push("k", [_entry("a")])
-        if scenario != "resolver_raises":
-            # Block until "a" has shipped, so seeding the next error is
-            # race-free with the drain thread's next iteration.
-            assert pusher.flush(timeout=5.0)
-            err = (
-                ConnectError(Code.NOT_FOUND, "missing")
-                if scenario == "non_retryable"
-                else ConnectError(Code.UNAVAILABLE, "gone")
-            )
-            created[0].errors.append(err)
-
-        pusher.push("k", [_entry("b")])
-
-        # Wait deterministically for "b" to be processed (sent or dropped).
-        assert pusher.flush(timeout=10.0)
-
-        # "b" must have landed somewhere — the buffer-overflow path is not
-        # exercised here, so processed implies delivered.
-        def delivered():
-            return any(any(e.data == "b" for p in c.pushes for e in p.entries) for c in created)
-
-        assert delivered(), "entry 'b' was never delivered to any client"
-
-        if scenario.startswith("retryable"):
-            # Retryable RPC failure invalidated the first client; second built.
-            assert len(created) >= 2
-            assert created[0].closed is True
-        elif scenario == "resolver_raises":
-            # Resolver raised on first call → no client yet. Second call
-            # succeeded → exactly one client created.
-            assert len(created) == 1
-        elif scenario == "non_retryable":
-            # Same client retries; no invalidate, no rebuild.
-            assert len(created) == 1
-            assert created[0].closed is False
-    finally:
-        pusher.close()