Squashed 'dotnet-server-sdk-shared-tests/' changes from ea2fb6f..1a27958

1a27958 use SDK 6.2.0
59a3648 add standard tests for big segment stores (#3)

git-subtree-dir: dotnet-server-sdk-shared-tests
git-subtree-split: 1a27958efe673c97bb0f8ddecdbce11c7cfcb20b

Author: eli-darkly

.circleci/config.yml

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

LaunchDarkly.ServerSdk.SharedTests.Tests/BigSegmentStore/BigSegmentStoreBaseTestsTest.cs

@@ -0,0 +1,108 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using LaunchDarkly.Sdk.Server.Interfaces;
+using Xunit.Abstractions;
+
+using static LaunchDarkly.Sdk.Server.Interfaces.BigSegmentStoreTypes;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests.BigSegmentStore
+{
+    public class BigSegmentStoreBaseTestsTest : BigSegmentStoreBaseTests
+    {
+        // This runs BigSegmentStoreBaseTests against a mock store implementation that is known to
+        // behave as expected, to verify that the test suite logic has the correct expectations.
+
+        protected override BigSegmentStoreTestConfig Configuration =>
+            new BigSegmentStoreTestConfig
+            {
+                StoreFactoryFunc = CreateStoreFactory,
+                ClearDataAction = ClearData,
+                SetMetadataAction = SetMetadata,
+                SetSegmentsAction = SetSegments
+            };
+
+        private class DataSet {
+            public StoreMetadata? Metadata = null;
+            public Dictionary<string, IMembership> Memberships = new Dictionary<string, IMembership>();
+        }
+
+        private readonly Dictionary<string, DataSet> _allData = new Dictionary<string, DataSet>();
+
+        public BigSegmentStoreBaseTestsTest(ITestOutputHelper testOutput) : base(testOutput)
+        {
+        }
+
+        private IBigSegmentStoreFactory CreateStoreFactory(string prefix) =>
+            new MockStoreFactory(GetOrCreateDataSet(prefix));
+
+        private Task ClearData(string prefix)
+        {
+            var data = GetOrCreateDataSet(prefix);
+            data.Metadata = null;
+            data.Memberships.Clear();
+            return Task.CompletedTask;
+        }
+
+        private Task SetMetadata(string prefix, StoreMetadata metadata)
+        {
+            GetOrCreateDataSet(prefix).Metadata = metadata;
+            return Task.CompletedTask;
+        }
+
+        private Task SetSegments(string prefix, string userHashKey,
+            IEnumerable<string> includedSegmentRefs, IEnumerable<string> excludedSegmentRefs)
+        {
+            GetOrCreateDataSet(prefix).Memberships[userHashKey] =
+                NewMembershipFromSegmentRefs(includedSegmentRefs, excludedSegmentRefs);
+            return Task.CompletedTask;
+        }
+
+        private DataSet GetOrCreateDataSet(string prefix)
+        {
+            if (!_allData.ContainsKey(prefix))
+            {
+                _allData[prefix] = new DataSet();
+            }
+            return _allData[prefix];
+        }
+
+        private class MockStoreFactory : IBigSegmentStoreFactory
+        {
+            private readonly DataSet _data;
+
+            public MockStoreFactory(DataSet data)
+            {
+                _data = data;
+            }
+
+            public IBigSegmentStore CreateBigSegmentStore(LdClientContext context) =>
+                new MockStore(_data);
+        }
+
+        private class MockStore : IBigSegmentStore
+        {
+            private readonly DataSet _data;
+
+            public MockStore(DataSet data)
+            {
+                _data = data;
+            }
+
+            public void Dispose() { }
+
+            public Task<IMembership> GetMembershipAsync(string userHash)
+            {
+                if (_data.Memberships.TryGetValue(userHash, out var result))
+                {
+                    return Task.FromResult(result);
+                }
+                return Task.FromResult((IMembership)null);
+            }
+
+            public Task<StoreMetadata?> GetMetadataAsync()
+            {
+                return Task.FromResult(_data.Metadata);
+            }
+        }
+    }
+}

LaunchDarkly.ServerSdk.SharedTests/BigSegmentStore/BigSegmentStoreBaseTests.cs

@@ -0,0 +1,149 @@
+using System.Threading.Tasks;
+using LaunchDarkly.Logging;
+using LaunchDarkly.Sdk.Server.Interfaces;
+using Xunit;
+using Xunit.Abstractions;
+
+using static LaunchDarkly.Sdk.Server.Interfaces.BigSegmentStoreTypes;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests.BigSegmentStore
+{
+    /// <summary>
+    /// A configurable Xunit test class for all implementations of <c>IBigSegmentStore</c>.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Each implementation of those interfaces should define a test class that is a subclass of this
+    /// class for their implementation type, and run it in the unit tests for their project.
+    /// </para>
+    /// <para>
+    /// You must override the <see cref="Configuration"/> property to provide details specific to
+    /// your implementation type.
+    /// </para>
+    /// </remarks>
+    public abstract class BigSegmentStoreBaseTests
+    {
+        /// <summary>
+        /// Override this method to create the configuration for the test suite.
+        /// </summary>
+        protected abstract BigSegmentStoreTestConfig Configuration { get; }
+
+        private const string prefix = "testprefix";
+        private const string fakeUserHash = "userhash";
+        private const string segmentRef1 = "key1", segmentRef2 = "key2", segmentRef3 = "key3";
+        private static readonly string[] allSegmentRefs = new string[] { segmentRef1, segmentRef2, segmentRef3 };
+
+        private readonly ILogAdapter _testLogging;
+
+        protected BigSegmentStoreBaseTests()
+        {
+            _testLogging = Logs.None;
+        }
+
+        protected BigSegmentStoreBaseTests(ITestOutputHelper testOutput)
+        {
+            _testLogging = TestLogging.TestOutputAdapter(testOutput);
+        }
+
+        private IBigSegmentStore MakeStore()
+        {
+            var context = new LdClientContext(new BasicConfiguration("sdk-key", false, _testLogging.Logger("")),
+                LaunchDarkly.Sdk.Server.Configuration.Default("sdk-key"));
+            return Configuration.StoreFactoryFunc(prefix).CreateBigSegmentStore(context);
+        }
+
+        private async Task<IBigSegmentStore> MakeEmptyStore()
+        {
+            var store = MakeStore();
+            try
+            {
+                await Configuration.ClearDataAction(prefix);
+            }
+            catch
+            {
+                store.Dispose();
+                throw;
+            }
+            return store;
+        }
+
+        [Fact]
+        public async void MissingMetadata()
+        {
+            using (var store = await MakeEmptyStore())
+            {
+                Assert.Null(await store.GetMetadataAsync());
+            }
+        }
+
+        [Fact]
+        public async void ValidMetadata()
+        {
+            using (var store = await MakeEmptyStore())
+            {
+                var metadata = new StoreMetadata { LastUpToDate = UnixMillisecondTime.Now };
+                await Configuration.SetMetadataAction(prefix, metadata);
+
+                var result = await store.GetMetadataAsync();
+                Assert.NotNull(result);
+                Assert.Equal(metadata.LastUpToDate, result.Value.LastUpToDate);
+            }
+        }
+
+        [Fact]
+        public async void MembershipNotFound()
+        {
+            using (var store = await MakeEmptyStore())
+            {
+                var membership = await store.GetMembershipAsync(fakeUserHash);
+
+                // Either null or an empty membership is allowed in this case
+                if (membership != null)
+                {
+                    AssertEqualMembership(NewMembershipFromSegmentRefs(null, null), membership);
+                }
+            }
+        }
+
+        [Theory]
+        [InlineData(new string[] { segmentRef1 }, new string[] { })]
+        [InlineData(new string[] { segmentRef1, segmentRef2 }, new string[] { })]
+        [InlineData(new string[] { }, new string[] { segmentRef1 })]
+        [InlineData(new string[] { }, new string[] { segmentRef1, segmentRef2 })]
+        [InlineData(new string[] { segmentRef1, segmentRef2 }, new string[] { segmentRef2, segmentRef3 })]
+        public async void MembershipFound(string[] includes, string[] excludes)
+        {
+            using (var store = await MakeEmptyStore())
+            {
+                await Configuration.SetSegmentsAction(prefix, fakeUserHash, includes, excludes);
+
+                var membership = await store.GetMembershipAsync(fakeUserHash);
+
+                AssertEqualMembership(NewMembershipFromSegmentRefs(includes, excludes), membership);
+            }
+        }
+
+        private static void AssertEqualMembership(IMembership expected, IMembership actual)
+        {
+            if (actual.GetType().FullName.StartsWith("LaunchDarkly.Sdk.Server.Internal.BigSegments.MembershipBuilder"))
+            {
+                // The store implementation is using our standard membership types, so we can rely on the
+                // standard equality test for those
+                Assert.Equal(expected, actual);
+            }
+            else
+            {
+                // The store implementation has implemented IMembership in some other way, so we have to
+                // check for the inclusion or exclusion of specific keys
+                foreach (var segmentRef in allSegmentRefs)
+                {
+                    if (actual.CheckMembership(segmentRef) != expected.CheckMembership(segmentRef))
+                    {
+                        Assert.True(false, string.Format("expected membership for {0} to be {1} but was {2}",
+                            segmentRef, expected.CheckMembership(segmentRef), actual.CheckMembership(segmentRef)));
+                    }
+                }
+            }
+        }
+    }
+}

LaunchDarkly.ServerSdk.SharedTests/BigSegmentStore/BigSegmentStoreTestConfig.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using LaunchDarkly.Sdk.Server.Interfaces;
+
+using static LaunchDarkly.Sdk.Server.Interfaces.BigSegmentStoreTypes;
+
+namespace LaunchDarkly.Sdk.Server.SharedTests.BigSegmentStore
+{
+    /// <summary>
+    /// A function that takes a prefix string and returns a configured factory for
+    /// your implementation of <c>IBigSegmentStore</c>.
+    /// </summary>
+    /// <remarks>
+    /// If the prefix string is null or "", it should use the default prefix defined by the
+    /// data store implementation. The factory must include any necessary configuration that
+    /// may be appropriate for the test environment (for instance, pointing it to a database
+    /// instance that has been set up for the tests).
+    /// </remarks>
+    /// <param name="prefix">the database prefix</param>
+    /// <returns>a configured factory</returns>
+    public delegate IBigSegmentStoreFactory StoreFactoryFunc(string prefix);
+
+    /// <summary>
+    /// An asynchronous function that removes all data from the underlying
+    /// data store for the specified prefix string.
+    /// </summary>
+    /// <param name="prefix">the database prefix</param>
+    /// <returns>an asynchronous task</returns>
+    public delegate Task ClearDataAction(string prefix);
+
+    /// <summary>
+    /// An asynchronous function that updates the store metadata to the specified values.
+    /// This must be provided separately by the test code because the store interface used by
+    /// the SDK has no update methods.
+    /// </summary>
+    /// <param name="prefix">the database prefix</param>
+    /// <param name="metadata">the data to write to the store</param>
+    /// <returns>an asynchronous task</returns>
+    public delegate Task SetMetadataAction(string prefix, StoreMetadata metadata);
+
+    /// <summary>
+    /// An asynchronous function that updates the membership state for a user in the store.
+    /// This must be provided separately by the test code because the store interface used by
+    /// the SDK has no update methods.
+    /// </summary>
+    /// <param name="prefix">the database prefix</param>
+    /// <param name="userHashKey">the hashed user key</param>
+    /// <param name="includedSegmentRefs">segment references to be included</param>
+    /// <param name="excludedSegmentRefs">segment references to be excluded</param>
+    /// <returns>an asynchronous task</returns>
+    public delegate Task SetSegmentsAction(string prefix, string userHashKey,
+        IEnumerable<string> includedSegmentRefs, IEnumerable<string> excludedSegmentRefs);
+
+    /// <summary>
+    /// Configuration for <see cref="BigSegmentStoreBaseTests"/>.
+    /// </summary>
+    public sealed class BigSegmentStoreTestConfig
+    {
+        public StoreFactoryFunc StoreFactoryFunc { get; set; }
+
+        public ClearDataAction ClearDataAction { get; set; }
+
+        public SetMetadataAction SetMetadataAction { get; set; }
+
+        public SetSegmentsAction SetSegmentsAction { get; set; }
+    }
+}

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

@@ -13,7 +13,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="LaunchDarkly.ServerSdk" Version="[6.0.0,7.0.0)" />
+    <PackageReference Include="LaunchDarkly.ServerSdk" Version="[6.2.0,7.0.0)" />
     <PackageReference Include="LaunchDarkly.Logging" Version="[1.0.1,]" />
     <PackageReference Include="xunit" Version="2.4.1" />
   </ItemGroup>