test: make FileDataSource auto-update tests more robust against timing issues (#192)

**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)
- [ ] I have validated my changes against all supported platform
versions

**Related issues**

Fixes flaky test
`ModifiedFileIsReloadedEvenIfOneFileIsMissingIfSkipMissingPathsIsSet`
observed in CI: [test run
logs](https://productionresultssa1.blob.core.windows.net/actions-results/13f4e4cd-7974-47b0-b829-de269e609d1f/workflow-job-run-843a6286-f650-51c4-b0dc-5c1e9e4974ff/logs/job/job-logs.txt)

**Describe the solution you've provided**

Added a new `AssertHelpers.ExpectJsonValue<T>()` helper that loops on
`ExpectValue()` until the received value's JSON matches the expected
JSON (or times out). This preserves the original `AssertJsonEqual`
assertions while handling race conditions from file watcher events.

The helper uses `JsonTestValue` parameters to match the return type of
`DataSetAsJson()` and the expected signature of `AssertJsonEqual()`.

Tests modified in `FileDataSourceTest.cs`:
- `ModifiedFileIsReloadedEvenIfOneFileIsMissingIfSkipMissingPathsIsSet`
- `IfFlagsAreBadAtStartTimeAutoUpdateCanStillLoadGoodDataLater`

Also fixed a separate flaky test in `PollingDataSourceTest.cs`:
-
`SuccessfulRequestCausesDataToBeStoredAndDataSourceInitializedMetadata`
- added `initTask.Wait()` before checking `Initialized` flag to avoid
race condition

**Describe alternatives you've considered**

- Adding `Thread.Sleep()` delays - rejected as this would make tests
slower and still potentially flaky
- Using `ExpectPredicate()` with custom predicates - rejected per review
feedback to preserve original `AssertJsonEqual` assertions for clarity
- Modifying the application code - rejected per guidelines to focus on
fixing test code rather than application code

**Additional context**

- Link to Devin run:
https://app.devin.ai/sessions/151f389666f447c78d9990e42bc57b48
- Requested by: [email protected]

**Human review checklist**
- [ ] Verify `ExpectJsonValue` correctly handles the timeout and doesn't
silently swallow real failures (it catches `XunitException` to skip
intermediate events)
- [ ] Confirm the 30-second timeout is appropriate (matches existing
patterns in the codebase)
- [ ] Verify the original assertions are preserved and we're testing the
same behavior
- [ ] Note: The `AssertJsonEqual` call after `ExpectJsonValue` is
intentionally redundant for readability per review feedback

---------

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

Author: devin-ai-integration[bot]

pkgs/sdk/server/test/AssertHelpers.cs

@@ -78,5 +78,40 @@ public static void ExpectPredicate<T>(EventSink<T> sink, Predicate<T> predicate,
                 return;
             }
         }
+
+        /// <summary>
+        /// Expect that the given sink will receive a value that matches the expected JSON within the specified timeout.
+        /// This handles race conditions where multiple events may be received (e.g., from file watcher triggers)
+        /// by continuing to check events until one matches or the timeout expires.
+        /// </summary>
+        /// <param name="sink">the sink to check events from</param>
+        /// <param name="expectedJson">the expected JSON value</param>
+        /// <param name="actualJsonFunc">function to convert the received value to JSON for comparison</param>
+        /// <param name="timeout">the overall timeout</param>
+        /// <typeparam name="T">the type of the sink</typeparam>
+        /// <returns>the value that matched the expected JSON</returns>
+        public static T ExpectJsonValue<T>(EventSink<T> sink, JsonTestValue expectedJson, Func<T, JsonTestValue> actualJsonFunc,
+            TimeSpan timeout)
+        {
+            var deadline = DateTime.UtcNow + timeout;
+
+            while (true)
+            {
+                var remaining = deadline - DateTime.UtcNow;
+                Assert.True(remaining > TimeSpan.Zero, "Timed out waiting for expected JSON value");
+
+                var candidate = sink.ExpectValue(remaining);
+
+                try
+                {
+                    AssertJsonEqual(expectedJson, actualJsonFunc(candidate));
+                    return candidate;
+                }
+                catch (XunitException)
+                {
+                    // This was an intermediate event that doesn't match; keep waiting for the correct one
+                }
+            }
+        }
     }
 }

pkgs/sdk/server/test/Internal/DataSources/FileDataSourceTest.cs

@@ -270,7 +270,14 @@ public void ModifiedFileIsReloadedEvenIfOneFileIsMissingIfSkipMissingPathsIsSet(
 
                     file1.SetContentFromPath(TestUtils.TestFilePath("segment-only.json"));
 
-                    var newData = _updateSink.Inits.ExpectValue(TimeSpan.FromSeconds(5));
+                    // Use ExpectJsonValue to handle potential race conditions where the file watcher
+                    // may trigger multiple reload events. This keeps checking events until one matches
+                    // the expected JSON or the timeout expires.
+                    var newData = AssertHelpers.ExpectJsonValue(
+                        _updateSink.Inits,
+                        DataSetAsJson(ExpectedDataSetForSegmentOnlyFile(2)),
+                        DataSetAsJson,
+                        TimeSpan.FromSeconds(30));
 
                     AssertJsonEqual(DataSetAsJson(ExpectedDataSetForSegmentOnlyFile(2)), DataSetAsJson(newData));
                 }
@@ -291,11 +298,18 @@ public void IfFlagsAreBadAtStartTimeAutoUpdateCanStillLoadGoodDataLater()
 
                     file.SetContentFromPath(TestUtils.TestFilePath("segment-only.json"));
 
-                    var newData = _updateSink.Inits.ExpectValue(TimeSpan.FromSeconds(5));
-
-                    AssertJsonEqual(DataSetAsJson(ExpectedDataSetForSegmentOnlyFile(2)), DataSetAsJson(newData));
+                    // Use ExpectJsonValue to handle potential race conditions where the file watcher
+                    // may trigger multiple reload events. This keeps checking events until one matches
+                    // the expected JSON or the timeout expires.
                     // Note that the expected version is 2 because we increment the version on each
                     // *attempt* to load the files, not on each successful load.
+                    var newData = AssertHelpers.ExpectJsonValue(
+                        _updateSink.Inits,
+                        DataSetAsJson(ExpectedDataSetForSegmentOnlyFile(2)),
+                        DataSetAsJson,
+                        TimeSpan.FromSeconds(30));
+
+                    AssertJsonEqual(DataSetAsJson(ExpectedDataSetForSegmentOnlyFile(2)), DataSetAsJson(newData));
                 }
             }
         }

pkgs/sdk/server/test/Internal/DataSources/PollingDataSourceTest.cs

@@ -96,9 +96,12 @@ public void SuccessfulRequestCausesDataToBeStoredAndDataSourceInitializedMetadat
                     // the http server as it isn't implemented in this package.
                     Assert.NotEmpty(receivedData.Item2);
 
-                    Assert.True(dataSource.Initialized);
+                    // Wait for initialization to complete before checking Initialized flag
+                    // to avoid race condition where data is received but flag not yet set
+                    bool completed = initTask.Wait(TimeSpan.FromSeconds(1));
+                    Assert.True(completed);
 
-                    Assert.True(initTask.IsCompleted);
+                    Assert.True(dataSource.Initialized);
                     Assert.False(initTask.IsFaulted);
                 }
             }