Squashed 'dotnet-server-sdk-shared-tests/' changes from 3eff003..ea2fb6f

ea2fb6f use 6.x GA release
23ee6a6 update dependency to match what the SDK is using
9d138db use latest prerelease SDK
7bace38 fix target framework
82197f0 update dependencies
478cad3 update to latest prerelease API
7d9d771 Merge branch 'sdk5.x'
32eb2bf update shared test code for SDK 6.0 API (#2)

git-subtree-dir: dotnet-server-sdk-shared-tests
git-subtree-split: ea2fb6f73c3e98315c6a7bbaf07ea8c2f19dbbc7

Author: eli-darkly

.circleci/config.yml

@@ -11,5 +11,5 @@ jobs:
     steps:
       - checkout
       - run: dotnet restore
-      - run: dotnet build LaunchDarkly.ServerSdk.SharedTests -f netstandard2.0
-      - run: dotnet test LaunchDarkly.ServerSdk.SharedTests.Tests/LaunchDarkly.ServerSdk.SharedTests.Tests.csproj -f netcoreapp2.1
+      - run: dotnet build LaunchDarkly.ServerSdk.SharedTests
+      - run: dotnet test LaunchDarkly.ServerSdk.SharedTests.Tests/LaunchDarkly.ServerSdk.SharedTests.Tests.csproj

LaunchDarkly.ServerSdk.SharedTests.Tests/DataStore/MockAsyncStore.cs

@@ -0,0 +1,43 @@
+using System.Threading.Tasks;
+using LaunchDarkly.Sdk.Server.Interfaces;
+
+using static LaunchDarkly.Sdk.Server.Interfaces.DataStoreTypes;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests.DataStore
+{
+    // MockAsyncStore is defined as a simple wrapper around MockSyncStore because we're not trying to
+    // test any real asynchronous functionality in the data store itself; we're just testing that the
+    // SDK makes the appropriate calls to the IPersistentDataStoreAsync API.
+
+    public class MockAsyncStore : IPersistentDataStoreAsync
+    {
+        private readonly MockSyncStore _syncStore;
+
+        public MockAsyncStore(MockDatabase db, string prefix)
+        {
+            _syncStore = new MockSyncStore(db, prefix);
+        }
+
+        public void Dispose() { }
+
+#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+
+        public async Task<SerializedItemDescriptor?> GetAsync(DataKind kind, string key) =>
+            _syncStore.Get(kind, key);
+
+        public async Task<KeyedItems<SerializedItemDescriptor>> GetAllAsync(DataKind kind) =>
+            _syncStore.GetAll(kind);
+
+        public async Task InitAsync(FullDataSet<SerializedItemDescriptor> allData) =>
+            _syncStore.Init(allData);
+
+        public async Task<bool> InitializedAsync() => _syncStore.Initialized();
+
+        public async Task<bool> IsStoreAvailableAsync() => true;
+
+        public async Task<bool> UpsertAsync(DataKind kind, string key, SerializedItemDescriptor item) =>
+            _syncStore.Upsert(kind, key, item);
+
+#pragma warning restore CS1998
+    }
+}

LaunchDarkly.ServerSdk.SharedTests.Tests/DataStore/MockDatabase.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+
+using static LaunchDarkly.Sdk.Server.Interfaces.DataStoreTypes;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests.DataStore
+{
+    public class MockDatabase
+    {
+        public static readonly MockDatabase Instance = new MockDatabase();
+
+        public readonly IDictionary<string, Dictionary<DataKind, Dictionary<string, SerializedItemDescriptor>>> _data =
+            new Dictionary<string, Dictionary<DataKind, Dictionary<string, SerializedItemDescriptor>>>();
+
+        public readonly ISet<string> _inited = new HashSet<string>();
+
+        private MockDatabase() { }
+
+        public Dictionary<DataKind, Dictionary<string, SerializedItemDescriptor>> DataForPrefix(string prefix)
+        {
+            if (_data.TryGetValue(prefix ?? "", out var ret))
+            {
+                return ret;
+            }
+            var d = new Dictionary<DataKind, Dictionary<string, SerializedItemDescriptor>>();
+            _data[prefix ?? ""] = d;
+            return d;
+        }
+
+        public Dictionary<string, SerializedItemDescriptor> DataForPrefixAndKind(string prefix, DataKind kind)
+        {
+            var dfp = DataForPrefix(prefix);
+            if (dfp.TryGetValue(kind, out var ret))
+            {
+                return ret;
+            }
+            var d = new Dictionary<string, SerializedItemDescriptor>();
+            dfp[kind] = d;
+            return d;
+        }
+
+        public void Clear(string prefix)
+        {
+            _data.Remove(prefix ?? "");
+            _inited.Remove(prefix ?? "");
+        }
+
+        public bool Inited(string prefix) => _inited.Contains(prefix ?? "");
+
+        public void SetInited(string prefix) => _inited.Add(prefix ?? "");
+    }
+}

LaunchDarkly.ServerSdk.SharedTests.Tests/DataStore/MockSyncStore.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using LaunchDarkly.Sdk.Server.Interfaces;
+
+using static LaunchDarkly.Sdk.Server.Interfaces.DataStoreTypes;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests.DataStore
+{
+    public class MockSyncStore : IPersistentDataStore
+    {
+        private readonly MockDatabase _db;
+        private readonly string _prefix;
+
+        public MockSyncStore(MockDatabase db, string prefix)
+        {
+            _db = db;
+            _prefix = prefix ?? "";
+        }
+
+        public void Dispose() { }
+
+        public SerializedItemDescriptor? Get(DataKind kind, string key) =>
+            _db.DataForPrefixAndKind(_prefix, kind).TryGetValue(key, out var ret) ?
+                ret : (SerializedItemDescriptor?)null;
+
+        public KeyedItems<SerializedItemDescriptor> GetAll(DataKind kind) =>
+            new KeyedItems<SerializedItemDescriptor>(_db.DataForPrefixAndKind(_prefix, kind));
+
+        public void Init(FullDataSet<SerializedItemDescriptor> allData)
+        {
+            _db.DataForPrefix(_prefix).Clear();
+            foreach (var coll in allData.Data)
+            {
+                _db.DataForPrefix(_prefix)[coll.Key] = new Dictionary<string, SerializedItemDescriptor>(coll.Value.Items);
+            }
+            _db.SetInited(_prefix);
+        }
+
+        public bool Initialized() => _db.Inited(_prefix);
+
+        public bool IsStoreAvailable() => true;
+
+        public bool Upsert(DataKind kind, string key, SerializedItemDescriptor item)
+        {
+            var dict = _db.DataForPrefixAndKind(_prefix, kind);
+            if (dict.TryGetValue(key, out var oldItem) && oldItem.Version >= item.Version)
+            {
+                return false;
+            }
+            dict[key] = item;
+            return true;
+        }
+    }
+}

LaunchDarkly.ServerSdk.SharedTests.Tests/DataStore/PersistentDataStoreBaseTestsAsyncTest.cs

@@ -0,0 +1,40 @@
+using System.Threading.Tasks;
+using LaunchDarkly.Sdk.Server.Interfaces;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests.DataStore
+{
+    // This runs PersistentDataStoreBaseTests against a mock store implementation that is known to
+    // behave as expected, to verify that the test suite logic has the correct expectations.
+
+    [Collection("Sequential")] // don't want this and the other test class to run simultaneously
+    public class PersistentDataStoreBaseTestsAsyncTest : PersistentDataStoreBaseTests
+    {
+        protected override PersistentDataStoreTestConfig Configuration =>
+            new PersistentDataStoreTestConfig
+            {
+                StoreAsyncFactoryFunc = CreateStoreFactory,
+                ClearDataAction = ClearAllData,
+            };
+
+        public PersistentDataStoreBaseTestsAsyncTest(ITestOutputHelper testOutput) : base(testOutput) { }
+
+        private IPersistentDataStoreAsyncFactory CreateStoreFactory(string prefix) =>
+            new MockAsyncStoreFactory { Database = MockDatabase.Instance, Prefix = prefix };
+
+#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+        private async Task ClearAllData(string prefix) =>
+            MockDatabase.Instance.Clear(prefix);
+#pragma warning restore CS1998
+
+        private class MockAsyncStoreFactory : IPersistentDataStoreAsyncFactory
+        {
+            internal MockDatabase Database { get; set; }
+            internal string Prefix { get; set; }
+
+            public IPersistentDataStoreAsync CreatePersistentDataStore(LdClientContext context) =>
+                new MockAsyncStore(Database, Prefix);
+        }
+    }
+}

LaunchDarkly.ServerSdk.SharedTests.Tests/DataStore/PersistentDataStoreBaseTestsSyncTest.cs

@@ -0,0 +1,40 @@
+using System.Threading.Tasks;
+using LaunchDarkly.Sdk.Server.Interfaces;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests.DataStore
+{
+    // This runs PersistentDataStoreBaseTests against a mock store implementation that is known to
+    // behave as expected, to verify that the test suite logic has the correct expectations.
+
+    [Collection("Sequential")] // don't want this and the other test class to run simultaneously
+    public class PersistentDataStoreBaseTestsSyncTest : PersistentDataStoreBaseTests
+    {
+        protected override PersistentDataStoreTestConfig Configuration =>
+            new PersistentDataStoreTestConfig
+            {
+                StoreFactoryFunc = CreateStoreFactory,
+                ClearDataAction = ClearAllData,
+            };
+
+        public PersistentDataStoreBaseTestsSyncTest(ITestOutputHelper testOutput) : base(testOutput) { }
+
+        private IPersistentDataStoreFactory CreateStoreFactory(string prefix) =>
+            new MockSyncStoreFactory { Database = MockDatabase.Instance, Prefix = prefix };
+
+#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+        private async Task ClearAllData(string prefix) =>
+            MockDatabase.Instance.Clear(prefix);
+#pragma warning restore CS1998
+
+        private class MockSyncStoreFactory : IPersistentDataStoreFactory
+        {
+            internal MockDatabase Database { get; set; }
+            internal string Prefix { get; set; }
+
+            public IPersistentDataStore CreatePersistentDataStore(LdClientContext context) =>
+                new MockSyncStore(Database, Prefix);
+        }
+    }
+}

LaunchDarkly.ServerSdk.SharedTests.Tests/LaunchDarkly.ServerSdk.SharedTests.Tests.csproj

@@ -2,11 +2,15 @@
   <PropertyGroup>
     <TargetFrameworks>netcoreapp2.1</TargetFrameworks>
     <IsPackable>false</IsPackable>
+    <RootNamespace>LaunchDarkly.Sdk.Server.SharedTests</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\LaunchDarkly.ServerSdk.SharedTests\LaunchDarkly.ServerSdk.SharedTests.csproj" />
+  </ItemGroup>
 </Project>

LaunchDarkly.ServerSdk.SharedTests/AsyncUtils.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests
+{
+    internal static class AsyncUtils
+    {
+        private static readonly TaskFactory _taskFactory = new TaskFactory(CancellationToken.None,
+            TaskCreationOptions.None, TaskContinuationOptions.None, TaskScheduler.Default);
+
+        // This procedure for blocking on a Task without using Task.Wait is derived from the MIT-licensed ASP.NET
+        // code here: https://github.com/aspnet/AspNetIdentity/blob/master/src/Microsoft.AspNet.Identity.Core/AsyncHelper.cs
+        // In general, mixing sync and async code is not recommended, and if done in other ways can result in
+        // deadlocks. See: https://stackoverflow.com/questions/9343594/how-to-call-asynchronous-method-from-synchronous-method-in-c
+        // Task.Wait would only be safe if we could guarantee that every intermediate Task within the async
+        // code had been modified with ConfigureAwait(false), but that is very error-prone and we can't depend
+        // on feature store implementors doing so.
+
+        internal static void WaitSafely(Func<Task> taskFn)
+        {
+            _taskFactory.StartNew(taskFn)
+                .Unwrap()
+                .GetAwaiter()
+                .GetResult();
+            // Note, GetResult does not throw AggregateException so we don't need to post-process exceptions
+        }
+
+        internal static bool WaitSafely(Func<Task> taskFn, TimeSpan timeout)
+        {
+            try
+            {
+                return _taskFactory.StartNew(taskFn)
+                    .Unwrap()
+                    .Wait(timeout);
+            }
+            catch (AggregateException e)
+            {
+                throw UnwrapAggregateException(e);
+            }
+        }
+
+        internal static T WaitSafely<T>(Func<Task<T>> taskFn)
+        {
+            return _taskFactory.StartNew(taskFn)
+                .Unwrap()
+                .GetAwaiter()
+                .GetResult();
+        }
+
+        private static Exception UnwrapAggregateException(AggregateException e)
+        {
+            if (e.InnerExceptions.Count == 1)
+            {
+                return e.InnerExceptions[0];
+            }
+            return e;
+        }
+    }
+}

LaunchDarkly.ServerSdk.SharedTests/DataStore/DataBuilder.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using static LaunchDarkly.Sdk.Server.Interfaces.DataStoreTypes;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests.DataStore
+{
+    /// <summary>
+    /// Simplifies building the input parameter for a data store's Init method.
+    /// </summary>
+    public class DataBuilder
+    {
+        private readonly IDictionary<DataKind, IDictionary<String, TestEntity>> _data =
+            new Dictionary<DataKind, IDictionary<String, TestEntity>>();
+
+        public DataBuilder Add(DataKind kind, params TestEntity[] items)
+        {
+            IDictionary<String, TestEntity> itemsDict;
+            if (!_data.TryGetValue(kind, out itemsDict))
+            {
+                itemsDict = new Dictionary<String, TestEntity>();
+                _data[kind] = itemsDict;
+            }
+            foreach (var item in items)
+            {
+                itemsDict[item.Key] = item;
+            }
+            return this;
+        }
+
+        public FullDataSet<SerializedItemDescriptor> BuildSerialized()
+        {
+            return new FullDataSet<SerializedItemDescriptor>(
+                _data.ToDictionary(kv => kv.Key,
+                    kv => new KeyedItems<SerializedItemDescriptor>(
+                        kv.Value.ToDictionary(kv1 => kv1.Key,
+                        kv1 => kv1.Value.SerializedItemDescriptor
+                        )
+                    )
+                ));
+        }
+    }
+}