public void GetKey_NonFunction_ShouldThrowArgumentException()
 {
     using (var fixture = new ExpressionCacheBaseFixture())
     {
         Should.Throw <ArgumentException>(() => fixture.ExpressionCacheBase.GetKey(() => 1 + 2));
     }
 }
Example #2
0
        public void GetKey_NonFunction_ShouldThrowArgumentException()
        {
            Action act = () =>
            {
                using var fixture = new ExpressionCacheBaseFixture();
                fixture.ExpressionCacheBase.GetKey(() => 1 + 2);
            };

            act.Should().Throw <ArgumentException>();
        }
Example #3
0
        public void InvokeCache_ResultInCache_ShouldReturnCachedResult()
        {
            using var fixture = new ExpressionCacheBaseFixture();
            fixture.SetCacheProviderGetSuccess();
            var key = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithoutParameters());

            var result = fixture.ExpressionCacheBase.InvokeCache(() => _testFunctions.FunctionWithoutParameters(), ExpressionCacheBaseFixture.TimeSpan, CacheAction.Invoke);

            result.Should().Be(ExpressionCacheBaseFixture.CachedResult);
            fixture.CacheProviderMock.Verify(m => m.Get <string>(key), Times.Once);
            fixture.CacheProviderMock.Verify(m => m.Set(key, result, ExpressionCacheBaseFixture.TimeSpan), Times.Never);
        }
Example #4
0
        public async Task InvokeCacheAsync_Bypass_ShouldReturnNewValueAndCache()
        {
            using var fixture = new ExpressionCacheBaseFixture();
            fixture.SetCacheProviderGetAsyncSuccess();
            var key = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithoutParametersAsync());

            var result = await fixture.ExpressionCacheBase.InvokeCacheAsync(() => _testFunctions.FunctionWithoutParametersAsync(), ExpressionCacheBaseFixture.TimeSpan, CacheAction.Bypass);

            result.Should().Be(TestFunctionsFixture.ReturnResult);
            fixture.CacheProviderMock.Verify(m => m.GetAsync <string>(key), Times.Never);
            fixture.CacheProviderMock.Verify(m => m.SetAsync(key, result, ExpressionCacheBaseFixture.TimeSpan), Times.Never);
        }
Example #5
0
        public async Task InvokeCacheAsync_NullFunction_ShouldNotCacheNull()
        {
            using var fixture = new ExpressionCacheBaseFixture();
            fixture.SetCacheProviderGetAsyncFailure();
            var key = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithoutParametersAsync());

            var result = await fixture.ExpressionCacheBase.InvokeCacheAsync(() => _testFunctions.NullFunctionWithoutParametersAsync(), ExpressionCacheBaseFixture.TimeSpan, CacheAction.Invoke);

            result.Should().BeNull();
            fixture.CacheProviderMock.Verify(m => m.GetAsync <string>(key), Times.Never);
            fixture.CacheProviderMock.Verify(m => m.SetAsync(key, result, ExpressionCacheBaseFixture.TimeSpan), Times.Never);
        }
Example #6
0
        public void GetKey_FunctionWithoutParameters_ShouldReturnCacheKeyString()
        {
            using var fixture = new ExpressionCacheBaseFixture();
            var key      = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithoutParameters());
            var asyncKey = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithoutParametersAsync());

            key.Should().Be(CacheKeyHelper.Prefix(
                                CacheKeyHelper.Format(_testFunctions.ClassName) +
                                CacheKeyHelper.Format(nameof(_testFunctions.FunctionWithoutParameters))));
            asyncKey.Should().Be(CacheKeyHelper.Prefix(
                                     CacheKeyHelper.Format(_testFunctions.ClassName) +
                                     CacheKeyHelper.Format(nameof(_testFunctions.FunctionWithoutParametersAsync))));
        }
        public async Task InvokeCacheAsync_Overwrite_ShouldReturnFunctionResult()
        {
            using (var fixture = new ExpressionCacheBaseFixture())
            {
                fixture.SetCacheProviderGetAsyncSuccess();
                var key = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithoutParametersAsync());

                var result = await fixture.ExpressionCacheBase.InvokeCacheAsync(() => _testFunctions.FunctionWithoutParametersAsync(), ExpressionCacheBaseFixture.TimeSpan, CacheAction.Overwrite);

                result.ShouldBe(_testFunctions.ReturnResult);
                fixture.CacheProviderMock.Verify(m => m.GetAsync <string>(key), Times.Never);
                fixture.CacheProviderMock.Verify(m => m.SetAsync(key, result, ExpressionCacheBaseFixture.TimeSpan), Times.Once);
            }
        }
Example #8
0
        public void GetKey_FunctionWithTwoParameters_ShouldReturnCacheKeyString()
        {
            const int    parameterOne = 1;
            const string parameterTwo = "Testing";

            using var fixture = new ExpressionCacheBaseFixture();
            var key      = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithTwoParameters(parameterOne, parameterTwo));
            var asyncKey = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithTwoParametersAsync(parameterOne, parameterTwo));

            key.Should().Be(CacheKeyHelper.Prefix(
                                CacheKeyHelper.Format(_testFunctions.ClassName) +
                                CacheKeyHelper.Format(nameof(_testFunctions.FunctionWithTwoParameters)) +
                                CacheKeyHelper.Format(parameterOne) +
                                CacheKeyHelper.Format(parameterTwo)));
            asyncKey.Should().Be(CacheKeyHelper.Prefix(
                                     CacheKeyHelper.Format(_testFunctions.ClassName) +
                                     CacheKeyHelper.Format(nameof(_testFunctions.FunctionWithTwoParametersAsync)) +
                                     CacheKeyHelper.Format(parameterOne) +
                                     CacheKeyHelper.Format(parameterTwo)));
        }
        public void GetKey_FunctionWithOneParameter_ShouldReturnCacheKeyString()
        {
            const int parameter = 1;

            using (var fixture = new ExpressionCacheBaseFixture())
            {
                var key      = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithOneParameter(parameter));
                var asyncKey = fixture.ExpressionCacheBase.GetKey(() => _testFunctions.FunctionWithOneParameterAsync(parameter));

                key.ShouldBe(
                    CacheKeyHelper.Format(_testFunctions.ClassName) +
                    CacheKeyHelper.Format(nameof(_testFunctions.FunctionWithOneParameter)) +
                    CacheKeyHelper.Format(parameter)
                    );
                asyncKey.ShouldBe(
                    CacheKeyHelper.Format(_testFunctions.ClassName) +
                    CacheKeyHelper.Format(nameof(_testFunctions.FunctionWithOneParameterAsync)) +
                    CacheKeyHelper.Format(parameter)
                    );
            }
        }