public static async Task RunInContextAsync(
TestCacheProvider cacheProvider,
LogLevel logLevel,
bool cacheAllQueries,
params Func <ApplicationDbContext, DebugLoggerProvider, Task>[] actions)
{
await _semaphoreSlim.WaitAsync();
try
{
var serviceProvider = GetConfiguredContextServiceProvider(cacheProvider, logLevel, cacheAllQueries);
var cacheServiceProvider = serviceProvider.GetRequiredService <IEFCacheServiceProvider>();
cacheServiceProvider.ClearAllCachedEntries();
using (var serviceScope = serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
foreach (var action in actions)
{
using (var context = serviceScope.ServiceProvider.GetRequiredService <ApplicationDbContext>())
{
await action(context, (DebugLoggerProvider)serviceProvider.GetRequiredService <ILoggerProvider>());
}
}
}
}
finally
{
_semaphoreSlim.Release();
}
}
public void TestSecondLevelCacheUsingProjections(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false, (context, loggerProvider) =>
{
var isActive = true;
var name = "Product1";
var list2 = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Select(x => x.ProductId)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(list2.Any());
list2 = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Select(x => x.ProductId)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
Assert.IsTrue(list2.Any());
});
}
public void TestQueriesUsingDifferentParameterValuesWillNotUseTheCache(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false, (context, loggerProvider) =>
{
var list1 = context.Products.Include(x => x.TagProducts).ThenInclude(x => x.Tag)
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive && product.ProductName == "Product1")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
var list2 = context.Products.Include(x => x.TagProducts).ThenInclude(x => x.Tag)
.OrderBy(product => product.ProductNumber)
.Where(product => !product.IsActive && product.ProductName == "Product1")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
var list3 = context.Products.Include(x => x.TagProducts).ThenInclude(x => x.Tag)
.OrderBy(product => product.ProductNumber)
.Where(product => !product.IsActive && product.ProductName == "Product2")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
var list4 = context.Products.Include(x => x.TagProducts).ThenInclude(x => x.Tag)
.OrderBy(product => product.ProductNumber)
.Where(product => !product.IsActive && product.ProductName == "Product2")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
});
}
public void TestEqualsMethodWillUseTheCache(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false, (context, loggerProvider) =>
{
var item1 = context.Products
.Where(product => product.ProductId == 2 && product.ProductName.Equals("Product1"))
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsNotNull(item1);
var item2 = context.Products
.Where(product => product.ProductId == 2 && product.ProductName.Equals("Product1"))
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
Assert.IsNotNull(item2);
var item3 = context.Products
.Where(product => product.ProductId == 1 && product.ProductName.Equals("Product1"))
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsNull(item3);
});
}
public void TestQueriesUsingExplicitTransactionsWillNotUseTheCache(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false, (context, loggerProvider) =>
{
using (var txn = context.Database.BeginTransaction())
{
// Read and modify an entity
var entity1 = context.Tags.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45)).First();
entity1.Name = "FOO";
// Save the change, cache will be invalidated
context.SaveChanges();
// Read the same entity again
entity1 = context.Tags.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45)).First();
// It will not get cached
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
// Call some method
// THIS METHOD THROWS AN EXCEPTION SO THE TRANSACTION IS NEVER COMMITTED
throw new TimeoutException();
// (we never hit these lines, so the cache is not invalidated and the transaction is not committed)
context.SaveChanges();
txn.Commit();
}
});
}
public void TestSecondLevelCacheInTwoDifferentContextsDoesNotHitTheDatabase(TestCacheProvider cacheProvider)
{
var isActive = true;
var name = "Product2";
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false,
(context, loggerProvider) =>
{
var list2 = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.IsTrue(list2.Any());
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
},
(context, loggerProvider) =>
{
var list3 = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.IsTrue(list3.Any());
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
});
}
public async Task TestSecondLevelCacheUsingTwoCountAsyncMethods(TestCacheProvider cacheProvider)
{
await EFServiceProvider.RunInContextAsync(cacheProvider, LogLevel.Debug, false,
async (context, loggerProvider) =>
{
var isActive = true;
var name = "Product2";
var count = await context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.CountAsync();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(count > 0);
count = await context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.CountAsync();
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
Assert.IsTrue(count > 0);
});
}
public async Task TestCacheAllQueriesWithNotCacheableWorks(TestCacheProvider cacheProvider)
{
await EFServiceProvider.RunInContextAsync(cacheProvider, LogLevel.Debug, true,
async (context, loggerProvider) =>
{
var isActive = true;
var name = "Product1";
var list1 = await context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.NotCacheable()
.ToListAsync();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(list1.Any());
var list2 = await context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.NotCacheable()
.ToListAsync();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(list2.Any());
});
}
public virtual void TestObjectCacheInvalidationWithOneRoot(TestCacheProvider cacheProvider)
{
var cacheService = EFServiceProvider.GetCacheServiceProvider(cacheProvider);
var efCachePolicy = new EFCachePolicy().Timeout(TimeSpan.FromMinutes(10)).ExpirationMode(CacheExpirationMode.Absolute);
const string rootCacheKey = "EFSecondLevelCache.Core.AspNetCoreSample.DataLayer.Entities.Product";
cacheService.InvalidateCacheDependencies(new EFCacheKey {
CacheDependencies = new HashSet <string> {
rootCacheKey
}
});
var key11888622 = new EFCacheKey
{
KeyHash = "11888622",
CacheDependencies = new HashSet <string> {
rootCacheKey
}
};
var val11888622 = cacheService.GetValue(key11888622, efCachePolicy);
Assert.IsNull(val11888622);
cacheService.InsertValue(
key11888622,
new EFCachedData {
Scalar = "Test1"
}, efCachePolicy);
var key44513A63 = new EFCacheKey
{
KeyHash = "44513A63",
CacheDependencies = new HashSet <string> {
rootCacheKey
}
};
var val44513A63 = cacheService.GetValue(key44513A63, efCachePolicy);
Assert.IsNull(val44513A63);
cacheService.InsertValue(
key44513A63,
new EFCachedData {
Scalar = "Test1"
}, efCachePolicy);
cacheService.InvalidateCacheDependencies(new EFCacheKey {
CacheDependencies = new HashSet <string> {
rootCacheKey
}
});
val11888622 = cacheService.GetValue(key11888622, efCachePolicy);
Assert.IsNull(val11888622);
val44513A63 = cacheService.GetValue(key44513A63, efCachePolicy);
Assert.IsNull(val44513A63);
}
protected virtual IEFCacheServiceProvider GetCacheServiceProvider(TestCacheProvider cacheProvider)
{
return(cacheProvider switch
{
TestCacheProvider.BuiltInInMemory => EFServiceProvider.GetInMemoryCacheServiceProvider(),
TestCacheProvider.CacheManagerCoreInMemory => EFServiceProvider.GetCacheManagerCoreInMemory(),
TestCacheProvider.CacheManagerCoreRedis => EFServiceProvider.GetCacheManagerCoreRedis(),
_ => throw new NotSupportedException($"{cacheProvider} is not supported."),
});
public virtual void TestParallelInsertsAndRemoves(TestCacheProvider cacheProvider)
{
var cacheService = EFServiceProvider.GetCacheServiceProvider(cacheProvider);
var efCachePolicy = new EFCachePolicy().Timeout(TimeSpan.FromMinutes(10)).ExpirationMode(CacheExpirationMode.Absolute);
var tests = new List <Action>();
for (var i = 0; i < 4000; i++)
{
var i1 = i;
tests.Add(() =>
cacheService.InsertValue(
new EFCacheKey(new HashSet <string> {
"entity1", "entity2"
})
{
KeyHash = $"EF_key{i1}"
}, new EFCachedData {
NonQuery = i1
}, efCachePolicy));
}
for (var i = 0; i < 400; i++)
{
if (i % 2 == 0)
{
tests.Add(() => cacheService.InvalidateCacheDependencies(new EFCacheKey(new HashSet <string> {
"entity1"
})
{
KeyHash = $"EF_key{i}"
}));
}
else
{
tests.Add(() => cacheService.InvalidateCacheDependencies(new EFCacheKey(new HashSet <string> {
"entity2"
})
{
KeyHash = $"EF_key{i}"
}));
}
}
Parallel.Invoke(tests.OrderBy(a => RandomNumberProvider.Next()).ToArray());
var value1 = cacheService.GetValue(new EFCacheKey(new HashSet <string> {
"entity1", "entity2"
})
{
KeyHash = "EF_key1"
}, efCachePolicy);
Assert.IsNull(value1);
}
public virtual void TestCacheInvalidationWithSimilarRoots(TestCacheProvider cacheProvider)
{
var cacheService = EFServiceProvider.GetCacheServiceProvider(cacheProvider);
var efCachePolicy = new EFCachePolicy().Timeout(TimeSpan.FromMinutes(10)).ExpirationMode(CacheExpirationMode.Absolute);
var key1 = new EFCacheKey
{
KeyHash = "EF_key1",
CacheDependencies = new HashSet <string> {
"entity1", "entity2"
}
};
cacheService.InsertValue(
key1,
new EFCachedData {
Scalar = "value1"
}, efCachePolicy);
var key2 = new EFCacheKey
{
KeyHash = "EF_key2",
CacheDependencies = new HashSet <string> {
"entity2"
}
};
cacheService.InsertValue(
key2,
new EFCachedData {
Scalar = "value2"
},
efCachePolicy);
var value1 = cacheService.GetValue(key1, efCachePolicy);
Assert.IsNotNull(value1);
var value2 = cacheService.GetValue(key2, efCachePolicy);
Assert.IsNotNull(value2);
cacheService.InvalidateCacheDependencies(new EFCacheKey {
CacheDependencies = new HashSet <string> {
"entity2"
}
});
value1 = cacheService.GetValue(key1, efCachePolicy);
Assert.IsNull(value1);
value2 = cacheService.GetValue(key2, efCachePolicy);
Assert.IsNull(value2);
}
public void TestIncludeMethodAndProjectionAffectsKeyCache(TestCacheProvider cacheProvider)
{
var isActive = true;
var name = "Product1";
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false,
(context, loggerProvider) =>
{
var product1IncludeTags = context.Products
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Include(x => x.TagProducts).ThenInclude(x => x.Tag)
.Select(x => new { Name = x.ProductName, Tag = x.TagProducts.Select(y => y.Tag) })
.OrderBy(x => x.Name)
.FirstOrDefault();
Assert.IsNotNull(product1IncludeTags);
},
(context, loggerProvider) =>
{
var firstProductIncludeTags = context.Products
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Include(x => x.TagProducts).ThenInclude(x => x.Tag)
.Select(x => new { Name = x.ProductName, Tag = x.TagProducts.Select(y => y.Tag) })
.OrderBy(x => x.Name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.IsNotNull(firstProductIncludeTags);
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
},
(context, loggerProvider) =>
{
var firstProductIncludeTags2 = context.Products
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Include(x => x.TagProducts).ThenInclude(x => x.Tag)
.Select(x => new { Name = x.ProductName, Tag = x.TagProducts.Select(y => y.Tag) })
.OrderBy(x => x.Name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.IsNotNull(firstProductIncludeTags2);
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
},
(context, loggerProvider) =>
{
var firstProduct = context.Products
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Select(x => new { Name = x.ProductName, Tag = x.TagProducts.Select(y => y.Tag) })
.OrderBy(x => x.Name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.IsNotNull(firstProduct);
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
});
}
public static IServiceProvider GetConfiguredContextServiceProvider(
TestCacheProvider cacheProvider,
LogLevel logLevel,
bool cacheAllQueries)
{
var services = new ServiceCollection();
services.AddOptions();
var basePath = Directory.GetCurrentDirectory();
Console.WriteLine($"Using `{basePath}` as the ContentRootPath");
var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(basePath)
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.Build();
services.AddSingleton(_ => configuration);
var loggerProvider = new DebugLoggerProvider();
services.AddLogging(cfg => cfg.AddConsole().AddDebug().AddProvider(loggerProvider).SetMinimumLevel(logLevel));
services.AddEFSecondLevelCache(options =>
{
switch (cacheProvider)
{
case TestCacheProvider.BuiltInInMemory:
options.UseMemoryCacheProvider();
break;
case TestCacheProvider.CacheManagerCoreInMemory:
options.UseCacheManagerCoreProvider();
addCacheManagerCoreInMemory(services);
break;
case TestCacheProvider.CacheManagerCoreRedis:
options.UseCacheManagerCoreProvider();
addCacheManagerCoreRedis(services);
break;
}
if (cacheAllQueries)
{
options.CacheAllQueries(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(30));
}
});
services.AddConfiguredMsSqlDbContext(GetConnectionString(basePath, configuration));
return(services.BuildServiceProvider());
}
public static void InitializePdaProducingPdvmSimulation <TPDVM>(
out TestGraph graph,
out Func <int, int, IEnumerable <string> > simulate)
where TPDVM : TestPDVM, new()
{
graph = new TestGraph();
var transitionProvider = new TestTransitionProvider(graph);
var cacheProvider =
new TestCacheProvider <int, int, int, TestPdaConstructingContext, TestPdaConstructingGssNode>();
var contextProcessor = new PdaExtractingContextProcessor <int, int, int, TestEdge>();
var pdvm = new TPDVM();
var simulation = new PdaConstructingPdvmSimulation(
contextProcessor, cacheProvider, transitionProvider,
() => pdvm);
simulate = (startVertex, maxCyclesExpansion) =>
{
var start = simulation.Load(startVertex, 1, -1);
simulation.Run();
var finals = pdvm.Finals;
var paths = new List <string>();
PdaContextDecoder.ExtractWords(
start,
context => finals.Contains(context),
maxCyclesExpansion,
rawPath =>
{
var path = string.Join(" ", rawPath.Select(edge => edge.Tag));
paths.Add(path);
return(true);
},
_ => { });
foreach (var path in paths)
{
Console.WriteLine(path);
}
using (var writer = new StreamWriter(Path.GetTempPath() + "contexts.dot"))
{
DumpPda(start, writer);
}
return(paths);
};
}
public static void InitializePdaProducingSimulation(
Func <int, int> startStatesProvider,
Func <int> startStackSymbolsProvider,
out TestDPDA dpda,
out TestGraph graph,
out Func <int, int, IEnumerable <string> > simulate)
{
dpda = new TestDPDA(startStatesProvider, startStackSymbolsProvider);
graph = new TestGraph();
var transitionProvider = new TestTransitionProvider(graph);
var cacheProvider =
new TestCacheProvider <int, int, int, TestPdaConstructingContext, TestPdaConstructingGssNode>();
var contextProcessor = new PdaExtractingContextProcessor <int, int, int, TestEdge>();
var simulation = new PdaConstructingSimulation(
dpda, contextProcessor, cacheProvider, transitionProvider);
var finalsInternal = new HashSet <TestPdaConstructingContext>();
simulation.OnFinalState += head => finalsInternal.Add(head.CurrentContext);
simulate = (startVertex, maxCyclesExpansion) =>
{
var start = simulation.Load(startVertex);
simulation.Run();
var paths = new List <string>();
PdaContextDecoder.ExtractWords(
start,
context => finalsInternal.Contains(context),
maxCyclesExpansion,
rawPath =>
{
var path = string.Join(" ", rawPath.Select(edge => edge.Tag));
paths.Add(path);
return(true);
},
_ => { });
using (var writer = new StreamWriter(Path.GetTempPath() + "contexts.dot"))
{
DumpPda(start, writer);
}
return(paths);
};
}
public void TestSecondLevelCacheUsingDifferentSyncMethods(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false,
(context, loggerProvider) =>
{
var isActive = true;
var name = "Product1";
var count = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.Count();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(count > 0);
var list1 = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(list1.Any());
var product1 = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(product1 != null);
var any = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == "Product2")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.Any();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(any);
var sum = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == "Product2")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.Sum(x => x.ProductId);
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(sum > 0);
});
}
public async Task TestSecondLevelCacheUsingAsyncMethodsDoesNotHitTheDatabase(TestCacheProvider cacheProvider)
{
await EFServiceProvider.RunInContextAsync(cacheProvider, LogLevel.Debug, false,
async (context, loggerProvider) =>
{
var isActive = true;
var name = "Product1";
var list1 = await context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToListAsync();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(list1.Any());
var list2 = await context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToListAsync();
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
Assert.IsTrue(list2.Any());
var list3 = await context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToListAsync();
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
Assert.IsTrue(list3.Any());
var list4 = await context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == "Product2")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToListAsync();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsTrue(list4.Any());
var product1 = await context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive == isActive && product.ProductName == "Product2")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefaultAsync();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsNotNull(product1);
});
}
public void TestIncludeMethodAffectsKeyCache(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false, (context, loggerProvider) =>
{
var firstProductIncludeTags = context.Products.Include(x => x.TagProducts).ThenInclude(x => x.Tag)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.IsNotNull(firstProductIncludeTags);
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
var firstProduct = context.Products.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45)).FirstOrDefault();
Assert.IsNotNull(firstProduct);
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
});
}
public static IEFCacheServiceProvider GetCacheServiceProvider(TestCacheProvider provider)
{
var services = new ServiceCollection();
services.AddOptions();
services.AddLogging(cfg => cfg.AddConsole().AddDebug());
switch (provider)
{
case TestCacheProvider.BuiltInInMemory:
services.AddEFSecondLevelCache(options => options.UseMemoryCacheProvider());
break;
case TestCacheProvider.CacheManagerCoreInMemory:
services.AddEFSecondLevelCache(options => options.UseCacheManagerCoreProvider());
addCacheManagerCoreInMemory(services);
break;
case TestCacheProvider.CacheManagerCoreRedis:
services.AddEFSecondLevelCache(options => options.UseCacheManagerCoreProvider());
addCacheManagerCoreRedis(services);
break;
case TestCacheProvider.EasyCachingCoreInMemory:
const string providerName1 = "InMemory1";
services.AddEFSecondLevelCache(options => options.UseEasyCachingCoreProvider(providerName1));
addEasyCachingCoreInMemory(services, providerName1);
break;
case TestCacheProvider.EasyCachingCoreRedis:
const string providerName2 = "Redis1";
services.AddEFSecondLevelCache(options => options.UseEasyCachingCoreProvider(providerName2));
addEasyCachingCoreRedis(services, providerName2);
break;
case TestCacheProvider.EasyCachingCoreHybrid:
const string providerName3 = "Hybrid1";
services.AddEFSecondLevelCache(options => options.UseEasyCachingCoreProvider(providerName3, isHybridCache: true));
addEasyCachingCoreHybrid(services, providerName3);
break;
}
var serviceProvider = services.BuildServiceProvider();
var cacheProvider = serviceProvider.GetRequiredService <IEFCacheServiceProvider>();
cacheProvider.ClearAllCachedEntries();
return(cacheProvider);
}
public void TestUsersWithAllDataTypes(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false,
(context, loggerProvider) =>
{
var items1 = context.Users
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsNotNull(items1);
var items2 = context.Users
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.ToList();
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
Assert.IsNotNull(items2);
});
}
public void TestRemoveTptDataShouldInvalidateTheCacheAutomatically(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false,
(context, loggerProvider) =>
{
var list1 = context.Posts.OfType <Page>().Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45)).ToList();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
var list2 = context.Posts.OfType <Page>().Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45)).ToList();
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
var post1 = context.Posts.First(post => post.Id == 1);
post1.Title = $"Post{RandomNumberProvider.Next()}";
context.SaveChanges();
var list3 = context.Posts.OfType <Page>().Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45)).ToList();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
});
}
public virtual void TestInsertingNullValues(TestCacheProvider cacheProvider)
{
var cacheService = EFServiceProvider.GetCacheServiceProvider(cacheProvider);
var efCachePolicy = new EFCachePolicy().Timeout(TimeSpan.FromMinutes(10)).ExpirationMode(CacheExpirationMode.Absolute);
var key1 = new EFCacheKey(new HashSet <string> {
"entity1", "entity2"
})
{
KeyHash = "EF_key1"
};
cacheService.InsertValue(
key1,
null, efCachePolicy);
var value1 = cacheService.GetValue(key1, efCachePolicy);
Assert.IsTrue(value1.IsNull, $"value1 is `{value1}`");
}
public async Task TestCacheableWorksWithSPs(TestCacheProvider cacheProvider)
{
await EFServiceProvider.RunInContextAsync(cacheProvider, LogLevel.Debug, false, async (context, loggerProvider) =>
{
var blogId = 1;
var blogs = await context.Set <BlogData>()
.FromSqlRaw("usp_GetBlogData {0}", blogId)
.Cacheable()
.ToListAsync();
Assert.IsTrue(blogs.Any());
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
blogs = await context.Set <BlogData>()
.FromSqlRaw("usp_GetBlogData {0}", blogId)
.Cacheable()
.ToListAsync();
Assert.IsTrue(blogs.Any());
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
});
}
public void TestNullValuesWillUseTheCache(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false, (context, loggerProvider) =>
{
var item1 = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive && product.ProductName == "Product1xx")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsNull(item1);
var item2 = context.Products
.OrderBy(product => product.ProductNumber)
.Where(product => product.IsActive && product.ProductName == "Product1xx")
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
Assert.IsNull(item2);
});
}
public void Setup()
{
((Hierarchy)LogManager.GetRepository()).Root.AddAppender(this);
_logs = new List <LoggingEvent>();
_cacheProvider = new TestCacheProvider(new XmlReferenceCache(CreateEmptyMetadata()));
_metadata = new XmlModelMetadata
{
Model = "A", Property = "B", Type = "string"
};
var element = XElement.Parse("<A><ResourceReference ref='1'/></A>");
_step = new ResolveReferenceStep(
_cacheProvider, new[]
{
_metadata
});
_resourceWorkItem = new ApiLoaderWorkItem("filename", 1, element, 1);
}
public void TestCachingByteArrays(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false,
(context, loggerProvider) =>
{
User user1;
const string user1Name = "User1";
var binaryData = new byte[] { 1, 2, 3 };
if (!context.Users.Any(user => user.Name == user1Name))
{
user1 = new User {
Name = user1Name, ImageData = binaryData
};
user1 = context.Users.Add(user1).Entity;
}
else
{
user1 = context.Users.First(user => user.Name == user1Name);
user1.ImageData = binaryData;
}
context.SaveChanges();
var userData = context.Users
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault(p => p.Id == user1.Id);
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsNotNull(userData);
CollectionAssert.AreEqual(binaryData, userData.ImageData);
userData = context.Users
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault(p => p.Id == user1.Id);
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
Assert.IsNotNull(userData);
CollectionAssert.AreEqual(binaryData, userData.ImageData);
});
}
public async Task TestCacheInvalidationWorksWithSPs(TestCacheProvider cacheProvider)
{
await EFServiceProvider.RunInContextAsync(cacheProvider, LogLevel.Debug, false, async (context, loggerProvider) =>
{
var blogId = 1;
var blogs = await context.Set <BlogData>()
.FromSqlRaw("usp_GetBlogData {0}", blogId)
.Cacheable()
.ToListAsync();
Assert.IsTrue(blogs.Any());
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
blogs = await context.Set <BlogData>()
.FromSqlRaw("usp_GetBlogData {0}", blogId)
.Cacheable()
.ToListAsync();
Assert.IsTrue(blogs.Any());
Assert.AreEqual(1, loggerProvider.GetCacheHitCount());
var product = new Product
{
IsActive = false,
ProductName = $"Product{RandomNumberProvider.Next()}",
ProductNumber = RandomNumberProvider.Next().ToString(),
Notes = "Notes ...",
UserId = 1
};
context.Products.Add(product);
await context.SaveChangesAsync();
blogs = await context.Set <BlogData>()
.FromSqlRaw("usp_GetBlogData {0}", blogId)
.Cacheable()
.ToListAsync();
Assert.IsTrue(blogs.Any());
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
});
}
public void PerformanceTest(TestCacheProvider cacheProvider)
{
const decimal loopCount = 1000;
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Warning, false, (context, debugLoggerProvider) =>
{
Stopwatch watch = new Stopwatch();
watch.Start();
// run normal queries
for (int i = 0; i < loopCount; i++)
{
var result = context.Posts.Where(post => post.Id >= 0).Take(100).ToList();
}
var uncachedTimeSpan = watch.Elapsed;
// cache the query result
var posts = context.Posts.Where(post => post.Id >= 0).Take(100).Cacheable().ToList();
watch.Restart();
// run cached queries
for (int i = 0; i < loopCount; i++)
{
var result = context.Posts.Where(post => post.Id >= 0).Take(100).Cacheable().ToList();
}
var cachedTimeSpan = watch.Elapsed;
var message = $"Average database query duration [+{TimeSpan.FromTicks((long)(uncachedTimeSpan.Ticks / loopCount))}].\n" +
$"Average cache query duration [+{TimeSpan.FromTicks((long)(cachedTimeSpan.Ticks / loopCount))}].\n" +
$"Cached queries are x{(uncachedTimeSpan.Ticks / (decimal)cachedTimeSpan.Ticks) - 1:N2} times faster.";
Assert.IsTrue(uncachedTimeSpan > cachedTimeSpan, message);
});
}
public void Test2DifferentCollectionsWillNotUseTheCache(TestCacheProvider cacheProvider)
{
EFServiceProvider.RunInContext(cacheProvider, LogLevel.Debug, false,
(context, loggerProvider) =>
{
var collection1 = new[] { 1, 2, 3 };
var item1 = context.Products
.Where(product => collection1.Contains(product.ProductId))
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsNotNull(item1);
var collection2 = new[] { 1, 2, 3, 4 };
var item2 = context.Products
.Where(product => collection2.Contains(product.ProductId))
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(45))
.FirstOrDefault();
Assert.AreEqual(0, loggerProvider.GetCacheHitCount());
Assert.IsNotNull(item2);
});
}
