test: fix race condition in delayed failure event test (#47)

**Requirements**

- [x] I have added test coverage for new or changed functionality
- [x] I have followed the repository's [pull request submission
guidelines](../blob/main/CONTRIBUTING.md#submitting-pull-requests)
- [x] I have validated my changes against all supported platform
versions

**Related issues**

None.

**Describe the solution you've provided**

Three event emission tests
(`test_provider_emits_ready_event_when_immediately_ready`,
`test_provider_emits_error_event_immediately_failed`,
`test_provider_emits_error_event_delayed_failure`) check a counter
immediately after `set_provider` without waiting for the event to be
dispatched. The OpenFeature SDK now dispatches provider events
asynchronously, so these assertions fail.

The fix uses `threading.Event` with `wait(timeout=5)`, matching the
pattern already used by `test_provider_emits_stale_event` and
`test_provider_emits_configuration_event`.

**Describe alternatives you've considered**

Could add `time.sleep()` calls, but event-based waiting is more robust
and consistent with existing tests.

**Additional context**

All 66 tests pass consistently. Lint (mypy) also passes.

Link to Devin session:
https://app.devin.ai/sessions/385a2c260fe8433ea7e6af74fcde903c
Requested by: @kinyoklion

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Test-only changes with no runtime or library behavior modified.
> 
> **Overview**
> Fixes flaky provider lifecycle tests that assumed **OpenFeature**
dispatches `PROVIDER_READY` / `PROVIDER_ERROR` synchronously on
`set_provider`.
> 
> **`test_provider_emits_ready_event_when_immediately_ready`**,
**`test_provider_emits_error_event_immediately_failed`**, and
**`test_provider_emits_error_event_delayed_failure`** now wait on a
**`threading.Event`** (with **`wait(timeout=5)`**) set from the handler
before asserting the emission count, plus a short **`time.sleep(0.1)`**
so the counter update is visible. Handlers were simplified (shared
**`emission_count`**, **`thread_event.set()`**). This matches
**`test_provider_emits_stale_event`** and
**`test_provider_emits_configuration_event`**.
> 
> No production/provider code changes—tests only.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
0340a25. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: kinyoklion

tests/test_provider.py

@@ -1,4 +1,5 @@
 import threading
+import time
 from typing import List, Union
 from unittest.mock import patch
 
@@ -150,39 +151,42 @@ def test_logger_changes_should_cascade_to_evaluation_converter(provider: LaunchD
 
 
 def test_provider_emits_ready_event_when_immediately_ready():
-    ld_provider_ready_count = 0
+    emission_count = 0
     lock = threading.Lock()
+    thread_event = threading.Event()
 
     def handle_status(details: EventDetails):
         if details.provider_name == 'launchdarkly-openfeature-server':
-            nonlocal lock
-            nonlocal ld_provider_ready_count
+            nonlocal emission_count
             with lock:
-                ld_provider_ready_count = ld_provider_ready_count + 1
+                emission_count += 1
+            thread_event.set()
 
-    # At the time of implementation this handler runs synchronously on the same
-    # thread as initialization. The lock is in case this behavior changes.
     api.add_handler(ProviderEvent.PROVIDER_READY, handle_status)
 
     openfeature_provider = LaunchDarklyProvider(Config("", offline=True))
     api.set_provider(openfeature_provider)
 
+    assert thread_event.wait(timeout=5)
+    time.sleep(0.1)
+
     with lock:
-        assert ld_provider_ready_count == 1
+        assert emission_count == 1
 
     api.shutdown()
 
 
 def test_provider_emits_error_event_immediately_failed():
-    ld_provider_error_count = 0
+    emission_count = 0
     lock = threading.Lock()
+    thread_event = threading.Event()
 
     def handle_status(details: EventDetails):
         if details.provider_name == 'launchdarkly-openfeature-server':
-            nonlocal lock
-            nonlocal ld_provider_error_count
+            nonlocal emission_count
             with lock:
-                ld_provider_error_count = ld_provider_error_count + 1
+                emission_count += 1
+            thread_event.set()
 
     api.add_handler(ProviderEvent.PROVIDER_ERROR, handle_status)
 
@@ -191,22 +195,26 @@ def handle_status(details: EventDetails):
 
     api.set_provider(openfeature_provider)
 
+    assert thread_event.wait(timeout=5)
+    time.sleep(0.1)
+
     with lock:
-        assert ld_provider_error_count == 1
+        assert emission_count == 1
 
     api.shutdown()
 
 
 def test_provider_emits_error_event_delayed_failure():
-    ld_provider_error_count = 0
+    emission_count = 0
     lock = threading.Lock()
+    thread_event = threading.Event()
 
     def handle_status(details: EventDetails):
         if details.provider_name == 'launchdarkly-openfeature-server':
-            nonlocal lock
-            nonlocal ld_provider_error_count
+            nonlocal emission_count
             with lock:
-                ld_provider_error_count = ld_provider_error_count + 1
+                emission_count += 1
+            thread_event.set()
 
     api.add_handler(ProviderEvent.PROVIDER_ERROR, handle_status)
 
@@ -215,8 +223,11 @@ def handle_status(details: EventDetails):
 
     api.set_provider(openfeature_provider)
 
+    assert thread_event.wait(timeout=5)
+    time.sleep(0.1)
+
     with lock:
-        assert ld_provider_error_count == 1
+        assert emission_count == 1
 
     api.shutdown()