Refactor to abstract out sync specs versus common spec functionality

Author: reisenberger

src/Polly.Caching.Distributed.SharedSpecs/Integration/CacheRoundTripSpecsBase.cs

@@ -7,6 +7,50 @@ public abstract class CacheRoundTripSpecsBase
     {
         protected const string OperationKey = "SomeOperationKey";
 
+        public abstract void Should_roundtrip_this_variant_of<TResult>(TResult testValue);
+
+        [Theory]
+        [MemberData(nameof(SampleClassData))]
+        public void Should_roundtrip_all_variants_of_reference_type(SampleClass testValue)
+        {
+            Should_roundtrip_this_variant_of<SampleClass>(testValue);
+        }
+
+        [Theory]
+        [MemberData(nameof(SampleStringData))]
+        public void Should_roundtrip_all_variants_of_string(String testValue)
+        {
+            Should_roundtrip_this_variant_of<String>(testValue);
+        }
+
+        [Theory]
+        [MemberData(nameof(SampleNumericData))]
+        public void Should_roundtrip_all_variants_of_numeric(int testValue)
+        {
+            Should_roundtrip_this_variant_of<int>(testValue);
+        }
+
+        [Theory]
+        [MemberData(nameof(SampleEnumData))]
+        public void Should_roundtrip_all_variants_of_enum(SampleEnum testValue)
+        {
+            Should_roundtrip_this_variant_of<SampleEnum>(testValue);
+        }
+
+        [Theory]
+        [MemberData(nameof(SampleBoolData))]
+        public void Should_roundtrip_all_variants_of_bool(bool testValue)
+        {
+            Should_roundtrip_this_variant_of<bool>(testValue);
+        }
+
+        [Theory]
+        [MemberData(nameof(SampleNullableBoolData))]
+        public void Should_roundtrip_all_variants_of_nullable_bool(bool? testValue)
+        {
+            Should_roundtrip_this_variant_of<bool?>(testValue);
+        }
+
         public static TheoryData<SampleClass> SampleClassData =>
             new TheoryData<SampleClass>
             {

src/Polly.Caching.Distributed.SharedSpecs/Integration/CacheRoundTripSpecsSyncBase.cs

@@ -0,0 +1,49 @@
+#if !NETCOREAPP1_1
+
+using System;
+using FluentAssertions;
+
+namespace Polly.Caching.Distributed.Specs.Integration
+{
+    public abstract class CacheRoundTripSpecsSyncBase<TCache> : CacheRoundTripSpecsBase
+    {
+        public override void Should_roundtrip_this_variant_of<TResult>(TResult testValue)
+        {
+            // Arrange
+            var (cacheProvider, cache) = CachePolicyFactory.CreateCachePolicy<TCache, TResult>();
+
+            // Assert - should not be in cache
+            (bool cacheHit1, TResult fromCache1) = cacheProvider.TryGet(OperationKey);
+            cacheHit1.Should().BeFalse();
+            fromCache1.Should().Be(default(TResult));
+
+            // Act - should execute underlying delegate and place in cache
+            int underlyingDelegateExecuteCount = 0;
+            cache.Execute(ctx =>
+                {
+                    underlyingDelegateExecuteCount++;
+                    return testValue;
+                }, new Context(OperationKey))
+                .ShouldBeEquivalentTo(testValue);
+
+            // Assert - should have executed underlying delegate
+            underlyingDelegateExecuteCount.Should().Be(1);
+
+            // Assert - should be in cache
+            (bool cacheHit2, TResult fromCache2) = cacheProvider.TryGet(OperationKey);
+            cacheHit2.Should().BeTrue();
+            fromCache2.ShouldBeEquivalentTo(testValue);
+
+            // Act - should execute underlying delegate and place in cache
+            cache.Execute(ctx =>
+                {
+                    underlyingDelegateExecuteCount++;
+                    throw new Exception("Cache should be used so this should not get invoked.");
+                }, new Context(OperationKey))
+                .ShouldBeEquivalentTo(testValue);
+            underlyingDelegateExecuteCount.Should().Be(1);
+        }
+    }
+}
+
+#endif

src/Polly.Caching.Distributed.SharedSpecs/Integration/CacheRoundTripSpecs_NetStandardIDistributedCacheProvider.cs

@@ -0,0 +1,8 @@
+#if !NETCOREAPP1_1
+
+namespace Polly.Caching.Distributed.Specs.Integration
+{
+    public class CacheRoundTripSpecs_NetStandardIDistributedCacheProvider_Sync_ByteArray : CacheRoundTripSpecsSyncBase<byte[]> { }
+}
+
+#endif

src/Polly.Caching.Distributed.SharedSpecs/Integration/CacheRoundTripSpecs_NetStandardIDistributedCacheProvider_Sync_ByteArray.cs

@@ -0,0 +1,8 @@
+#if !NETCOREAPP1_1
+
+namespace Polly.Caching.Distributed.Specs.Integration
+{
+    public class CacheRoundTripSpecs_NetStandardIDistributedCacheProvider_Sync_String : CacheRoundTripSpecsSyncBase<string> { }
+}
+
+#endif

src/Polly.Caching.Distributed.SharedSpecs/Integration/CacheRoundTripSpecs_NetStandardIDistributedCacheProvider_Sync_String.cs

@@ -12,7 +12,9 @@
     <Compile Include="$(MSBuildThisFileDirectory)Integration\ByteArraySerializer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Integration\CachePolicyFactory.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Integration\CacheRoundTripSpecsBase.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Integration\CacheRoundTripSpecs_NetStandardIDistributedCacheProvider.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Integration\CacheRoundTripSpecsSyncBase.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Integration\CacheRoundTripSpecs_NetStandardIDistributedCacheProvider_Sync_ByteArray.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Integration\CacheRoundTripSpecs_NetStandardIDistributedCacheProvider_Sync_String.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Unit\CacheProviderHelperTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Unit\NetStandardIDistributedCacheByteArrayProviderSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Unit\NetStandardIDistributedCacheStringProviderSpecs.cs" />