public void CacheKeyTest8With15Parameters()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance =
                TestHelpers.CreateInstance <MemoryCacheKeyTestClass>(MemoryCacheKeyTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.With15Parameters(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);

            Assert.Equal(120, result);

            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);

            ITuple key = (ITuple)mockMemoryCache.LastCreatedEntryKey;

            Assert.Equal(16, key.Length);
            Assert.Equal("SpatialFocus.MethodCache.TestAssembly.MemoryCacheKeyTestClass.With15Parameters", key[0]);
            Assert.Equal(1, key[1]);
            Assert.Equal(2, key[2]);
            Assert.Equal(3, key[3]);
            Assert.Equal(4, key[4]);
            Assert.Equal(5, key[5]);
            Assert.Equal(6, key[6]);
            Assert.Equal(7, key[7]);
            Assert.Equal(8, key[8]);
            Assert.Equal(9, key[9]);
            Assert.Equal(10, key[10]);
            Assert.Equal(11, key[11]);
            Assert.Equal(12, key[12]);
            Assert.Equal(13, key[13]);
            Assert.Equal(14, key[14]);
            Assert.Equal(15, key[15]);
        }
Example #2
0
        public void CacheKeyTest4With7Parameters()
        {
            using MockMemoryCache mockMemoryCache = new MockMemoryCache();

            dynamic instance =
                TestHelpers.CreateInstance <MemoryCacheKeyTestClass>(MemoryCacheKeyTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.With7Parameters(1, 2, 3, 4, 5, 6, 7);

            Assert.Equal(28, result);

            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);

            ITuple key = (ITuple)mockMemoryCache.LastCreatedEntryKey;

            Assert.Equal(8, key.Length);
            Assert.Equal("SpatialFocus.MethodCache.TestAssembly.MemoryCacheKeyTestClass.With7Parameters", key[0]);
            Assert.Equal(1, key[1]);
            Assert.Equal(2, key[2]);
            Assert.Equal(3, key[3]);
            Assert.Equal(4, key[4]);
            Assert.Equal(5, key[5]);
            Assert.Equal(6, key[6]);
            Assert.Equal(7, key[7]);
        }
Example #3
0
        public void WithSlidingExpirationOption()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance =
                TestHelpers.CreateInstance <MemoryCacheEntryOptionsTestClass>(MemoryCacheEntryOptionsTests.TestResult.Assembly,
                                                                              mockMemoryCache);

            dynamic     result = instance.WithSlidingExpirationOption(1);
            ICacheEntry lastCreatedCacheEntry = mockMemoryCache.LastCreatedCacheEntry;

            Assert.Null(lastCreatedCacheEntry.AbsoluteExpirationRelativeToNow);
            Assert.Equal(TimeSpan.FromSeconds(1), lastCreatedCacheEntry.SlidingExpiration);
            Assert.Equal(CacheItemPriority.Normal, lastCreatedCacheEntry.Priority);

            Thread.Sleep(500);
            result = instance.WithSlidingExpirationOption(1);
            Thread.Sleep(500);
            result = instance.WithSlidingExpirationOption(1);
            Thread.Sleep(1000);
            result = instance.WithSlidingExpirationOption(1);

            Assert.Equal(2, mockMemoryCache.CountSets);
            Assert.Equal(4, mockMemoryCache.CountGets);
        }
            public TestContext()
            {
                MockMemoryCache
                .Setup(x => x.CreateEntry(It.IsAny <object>()))
                .Returns(() => MockCacheEntry.Object);

                MockFactory
                .Setup(x => x.Invoke(It.IsAny <ICacheEntry>()))
                .ReturnsAsync(() => Item);
            }
Example #5
0
        public void BasicTest1CreateAndGet()
        {
            using MockMemoryCache mockMemoryCache = new MockMemoryCache();

            dynamic instance = TestHelpers.CreateInstance <BasicTestClass>(MemoryCacheBasicTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.Add(1, 2);

            Assert.Equal(3, result);
            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);
        }
        public void BasicTest5DerivedClass()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance = TestHelpers.CreateInstance <DerivedTestClass>(MemoryCacheBasicTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.Add(1, 2);

            Assert.Equal(3, result);
            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);
        }
Example #7
0
        public void GenericMethodTest3GenericMethodString()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance =
                TestHelpers.CreateInstance <GenericMethodTestClass>(MemoryCacheGenericTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.GenericReturn <string>("Test");

            Assert.Equal("Test", result);
            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);
        }
Example #8
0
        public void GenericClassTest2GenericTClassMethod()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance =
                TestHelpers.CreateInstance <GenericTestClass <int> >(MemoryCacheGenericTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.GenericTClassReturn(1);

            Assert.Equal(1, result);
            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);
        }
Example #9
0
        public void GenericMethodTest4GenericMethodCustomObjectFromTestAssembly()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance =
                TestHelpers.CreateInstance <GenericMethodTestClass>(MemoryCacheGenericTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.GenericReturn <CustomObject>(new CustomObject("Tester", 42));

            Assert.Equal(new CustomObject("Tester", 42), result);
            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);
        }
Example #10
0
        public void GenericMethodTest1NonGenericMethod()
        {
            using MockMemoryCache mockMemoryCache = new MockMemoryCache();

            dynamic instance =
                TestHelpers.CreateInstance <GenericMethodTestClass>(MemoryCacheGenericTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.NonGenericReturn(1);

            Assert.Equal(1, result);
            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);
        }
        public void BasicTest7NotWeavingMethodWithOutParameter()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance = TestHelpers.CreateInstance <BasicTestClass>(MemoryCacheBasicTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.AddAndSubtract(1, 2, out int difference);

            Assert.Equal(3, result);
            Assert.Equal(-1, difference);
            Assert.Equal(0, mockMemoryCache.CountSets);
            Assert.Equal(0, mockMemoryCache.CountGets);
        }
Example #12
0
        public void GenericMethodTest2GenericMethodInt()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance =
                TestHelpers.CreateInstance <GenericMethodTestClass>(MemoryCacheGenericTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.GenericReturn <int>(1);

            // {(SpatialFocus.MethodCache.TestAssembly.GenericTestClass.GenericReturn<T>, System.Int32, 1)}
            Assert.Equal(1, result);
            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);
        }
        public void BasicTest4NoCache()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance = TestHelpers.CreateInstance <BasicTestClass>(MemoryCacheBasicTests.TestResult.Assembly, mockMemoryCache);

            dynamic result1 = instance.UncachedAdd(1, 2);
            dynamic result2 = instance.UncachedAdd(2, 2);

            Assert.Equal(3, result1);
            Assert.Equal(4, result2);
            Assert.Equal(0, mockMemoryCache.CountSets);
            Assert.Equal(0, mockMemoryCache.CountGets);
        }
Example #14
0
        public void WithMethodLevelNoOption()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance =
                TestHelpers.CreateInstance <MemoryCacheEntryOptionsClassLevelTestClass>(MemoryCacheEntryOptionsTests.TestResult.Assembly,
                                                                                        mockMemoryCache);

            dynamic     result = instance.WithMethodLevelNoOption(1);
            ICacheEntry lastCreatedCacheEntry = mockMemoryCache.LastCreatedCacheEntry;

            Assert.Null(lastCreatedCacheEntry.AbsoluteExpirationRelativeToNow);
            Assert.Null(lastCreatedCacheEntry.SlidingExpiration);
            Assert.Equal(CacheItemPriority.Normal, lastCreatedCacheEntry.Priority);
        }
Example #15
0
        public void WithAllOptions()
        {
            using MockMemoryCache mockMemoryCache = MockMemoryCache.Default;

            dynamic instance =
                TestHelpers.CreateInstance <MemoryCacheEntryOptionsTestClass>(MemoryCacheEntryOptionsTests.TestResult.Assembly,
                                                                              mockMemoryCache);

            dynamic     result = instance.WithAllOptions(1);
            ICacheEntry lastCreatedCacheEntry = mockMemoryCache.LastCreatedCacheEntry;

            Assert.Equal(TimeSpan.FromSeconds(1), lastCreatedCacheEntry.AbsoluteExpirationRelativeToNow);
            Assert.Equal(TimeSpan.FromSeconds(2), lastCreatedCacheEntry.SlidingExpiration);
            Assert.Equal(CacheItemPriority.High, lastCreatedCacheEntry.Priority);
        }
Example #16
0
        public void CacheKeyTest1Parameterless()
        {
            using MockMemoryCache mockMemoryCache = new MockMemoryCache();

            dynamic instance =
                TestHelpers.CreateInstance <MemoryCacheKeyTestClass>(MemoryCacheKeyTests.TestResult.Assembly, mockMemoryCache);

            dynamic result = instance.Parameterless();

            Assert.Equal(1, result);

            Assert.Equal(1, mockMemoryCache.CountSets);
            Assert.Equal(1, mockMemoryCache.CountGets);

            ITuple key = (ITuple)mockMemoryCache.LastCreatedEntryKey;

            Assert.Equal(1, key.Length);
            Assert.Equal("SpatialFocus.MethodCache.TestAssembly.MemoryCacheKeyTestClass.Parameterless", key[0]);
        }