public void Test_SqlIsUncacheable( )
{
CachingQuerySqlBuilder cachingQuerySqlBuilder;
Mock <IQuerySqlBuilder> mockQuerySqlBuilder;
IQuerySqlBuilder querySqlBuilder;
StructuredQuery structuredQuery;
QuerySqlBuilderSettings settings;
QueryBuild queryBuild;
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
structuredQuery = new StructuredQuery( );
settings = new QuerySqlBuilderSettings( );
queryBuild = new QueryBuild( );
queryBuild.SqlIsUncacheable = true;
mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict);
mockQuerySqlBuilder.Setup(x => x.BuildSql(structuredQuery, settings))
.Returns(() => queryBuild)
.Verifiable( );
querySqlBuilder = mockQuerySqlBuilder.Object;
cachingQuerySqlBuilder = new CachingQuerySqlBuilder(querySqlBuilder, userRuleSetProvider);
cachingQuerySqlBuilder.BuildSql(structuredQuery, settings);
cachingQuerySqlBuilder.BuildSql(structuredQuery, settings);
mockQuerySqlBuilder.Verify(x => x.BuildSql(structuredQuery, settings), Times.Exactly(2));
mockQuerySqlBuilder.VerifyAll( );
}
public void Test_Cached()
{
CachingQuerySqlBuilder cachingQuerySqlBuilder;
Mock <IQuerySqlBuilder> mockQuerySqlBuilder;
IQuerySqlBuilder querySqlBuilder;
StructuredQuery structuredQuery;
QuerySqlBuilderSettings settings;
QueryBuild queryBuild;
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
structuredQuery = new StructuredQuery( );
settings = new QuerySqlBuilderSettings( );
queryBuild = new QueryBuild( );
mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict);
mockQuerySqlBuilder.Setup(x => x.BuildSql(structuredQuery, settings))
.Returns(() => queryBuild)
.Verifiable();
querySqlBuilder = mockQuerySqlBuilder.Object;
cachingQuerySqlBuilder = new CachingQuerySqlBuilder(querySqlBuilder, userRuleSetProvider);
Assert.That(cachingQuerySqlBuilder.BuildSql(structuredQuery, settings),
Is.SameAs(queryBuild), "Incorrect conversion");
Assert.That(cachingQuerySqlBuilder.Cache,
Has.Count.EqualTo(1));
mockQuerySqlBuilder.Verify(x => x.BuildSql(structuredQuery, settings), Times.Exactly(1));
mockQuerySqlBuilder.VerifyAll();
}
public void Test_EnsureCached_TwoThreads( )
{
CachingQuerySqlBuilder cachingQuerySqlBuilder;
Mock <IQuerySqlBuilder> mockQuerySqlBuilder;
IQuerySqlBuilder querySqlBuilder;
StructuredQuery structuredQuery;
QuerySqlBuilderSettings settings;
QueryBuild queryBuild;
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
structuredQuery = new StructuredQuery( );
settings = new QuerySqlBuilderSettings( );
queryBuild = new QueryBuild( );
mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict);
mockQuerySqlBuilder.Setup(x => x.BuildSql(structuredQuery, settings))
.Returns(() => {
Thread.Sleep(100);
return(queryBuild);
})
.Verifiable( );
querySqlBuilder = mockQuerySqlBuilder.Object;
cachingQuerySqlBuilder = new CachingQuerySqlBuilder(querySqlBuilder, userRuleSetProvider);
Task task1 = Task.Factory.StartNew(() => cachingQuerySqlBuilder.BuildSql(structuredQuery, settings));
Thread.Sleep(1); // BlockIfPending can handle overlapping, but no coincident requests
Task task2 = Task.Factory.StartNew(() => cachingQuerySqlBuilder.BuildSql(structuredQuery, settings));
Task.WaitAll(task1, task2);
mockQuerySqlBuilder.Verify(x => x.BuildSql(structuredQuery, settings), Times.Exactly(1));
mockQuerySqlBuilder.VerifyAll( );
}
public void Test_Cached( )
{
CachingQueryRunner cachingQueryRunner;
Mock <IQueryRunner> mockQueryRunner;
IQueryRunner queryRunner;
StructuredQuery structuredQuery;
QuerySettings settings;
QueryBuild queryBuild;
QueryResult result;
IQuerySqlBuilder queryBuilder = MockQuerySqlBuilder( );
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
structuredQuery = new StructuredQuery( );
settings = new QuerySettings( );
queryBuild = new QueryBuild( );
result = new QueryResult(queryBuild);
mockQueryRunner = new Mock <IQueryRunner>(MockBehavior.Strict);
mockQueryRunner.Setup(x => x.ExecutePrebuiltQuery(structuredQuery, settings, It.IsNotNull <QueryBuild>()))
.Returns(() =>
{
return(result);
})
.Verifiable( );
queryRunner = mockQueryRunner.Object;
cachingQueryRunner = new CachingQueryRunner(queryRunner, userRuleSetProvider, queryBuilder);
Assert.That(cachingQueryRunner.ExecuteQuery(structuredQuery, settings),
Is.SameAs(result));
Assert.That(cachingQueryRunner.Cache,
Has.Count.EqualTo(1));
mockQueryRunner.Verify(x => x.ExecutePrebuiltQuery(structuredQuery, settings, It.IsNotNull <QueryBuild>( )), Times.Exactly(1));
mockQueryRunner.VerifyAll( );
}
/// <summary>
/// Create a new <see cref="CachingQueryRunner"/>.
/// </summary>
/// <param name="queryRunner">
/// The <see cref="IQueryRunner"/> that will actually generate the SQL. This cannot be null.
/// </param>
/// <param name="userRuleSetProvider"></param>
/// <param name="querySqlBuilder"></param>
/// <exception cref="ArgumentNullException">
/// <paramref name="queryRunner"/> cannot be null.
/// </exception>
public CachingQueryRunner([WithKey(Factory.NonCachedKey)] IQueryRunner queryRunner, IUserRuleSetProvider userRuleSetProvider, IQuerySqlBuilder querySqlBuilder)
{
if (queryRunner == null)
{
throw new ArgumentNullException("queryRunner");
}
if (userRuleSetProvider == null)
{
throw new ArgumentNullException("userRuleSetProvider");
}
QueryRunner = queryRunner;
QuerySqlBuilder = querySqlBuilder;
UserRuleSetProvider = userRuleSetProvider;
// Create cache
var fact = new CacheFactory
{
CacheName = "Query Result",
MaxCacheEntries = CacheFactory.DefaultMaximumCacheSize
};
Cache = fact.Create <CachingQueryRunnerKey, CachingQueryRunnerValue>( );
_cacheInvalidator = new CachingQueryRunnerInvalidator(Cache);
}
internal static void Test_Scenario(StructuredQuery structuredQuery, Action invalidationCallback, bool expectInvalidation)
{
CachingQuerySqlBuilder cachingQuerySqlBuilder;
Mock <IQuerySqlBuilder> mockQuerySqlBuilder;
IQuerySqlBuilder querySqlBuilder;
QuerySettings settings;
QueryBuild queryBuild;
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
settings = new QuerySettings( );
queryBuild = new QueryBuild( );
var cacheInvalidators = new CacheInvalidatorFactory( ).CacheInvalidatorsList_TestOnly;
mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict);
mockQuerySqlBuilder.Setup(x => x.BuildSql(It.IsAny <StructuredQuery>( ), settings))
.Returns <StructuredQuery, QuerySettings>((sq, qs) =>
{
QuerySqlBuilder.IdentifyCacheDependencies(sq, settings);
return(queryBuild);
})
.Verifiable( );
querySqlBuilder = mockQuerySqlBuilder.Object;
cachingQuerySqlBuilder = new CachingQuerySqlBuilder(querySqlBuilder, userRuleSetProvider);
try
{
// Add current cache invalidator to global factory
cacheInvalidators.Add(cachingQuerySqlBuilder.CacheInvalidator);
using (var scope = Factory.Current.BeginLifetimeScope(cb =>
{
cb.Register(c => cachingQuerySqlBuilder).As <ICacheService>( );
}))
using (Factory.SetCurrentScope(scope))
{
// Run first time
cachingQuerySqlBuilder.BuildSql(structuredQuery.DeepCopy( ), settings);
// Perform potential invalidation task
using (new SecurityBypassContext( ))
{
invalidationCallback( );
}
// Run second time
cachingQuerySqlBuilder.BuildSql(structuredQuery.DeepCopy( ), settings);
}
int times = expectInvalidation ? 2 : 1;
mockQuerySqlBuilder.Verify(x => x.BuildSql(It.IsAny <StructuredQuery>( ), settings), Times.Exactly(times));
mockQuerySqlBuilder.VerifyAll( );
}
finally
{
// Restore cache invalidators
cacheInvalidators.Remove(cachingQuerySqlBuilder.CacheInvalidator);
}
}
/// <summary>
/// Create a new <see cref="CachingPerRuleSetEntityAccessControlChecker" />.
/// </summary>
/// <param name="entityAccessControlChecker">The <see cref="IEntityAccessControlChecker" /> used to actually perform checks.
/// This cannot be null.</param>
/// <param name="userRuleSetProvider">The user rule set provider.</param>
/// <param name="cacheName">(Optional) Cache name. If supplied, this cannot be null, empty or whitespace.</param>
/// <exception cref="System.ArgumentNullException">userRuleSetProvider</exception>
/// <exception cref="ArgumentNullException"><paramref name="entityAccessControlChecker" /> cannot be null. <paramref name="cacheName" /> cannot be null, empty or whitespace.</exception>
internal CachingPerRuleSetEntityAccessControlChecker(IEntityAccessControlChecker entityAccessControlChecker, IUserRuleSetProvider userRuleSetProvider, string cacheName = "Access control")
: base(entityAccessControlChecker, cacheName)
{
if (userRuleSetProvider == null)
{
throw new ArgumentNullException("userRuleSetProvider");
}
UserRuleSetProvider = userRuleSetProvider;
}
public void Test_EnsureResultsFromDifferentInstancesReturnCorrectRequestColumnData( )
{
CachingQueryRunner cachingQueryRunner;
Mock <IQueryRunner> mockQueryRunner;
IQueryRunner queryRunner;
QuerySettings settings;
QueryBuild queryBuild;
QueryResult result;
IQuerySqlBuilder queryBuilder = MockQuerySqlBuilder( );
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
StructuredQuery sq1 = new StructuredQuery {
RootEntity = new ResourceEntity("test:person")
};
sq1.SelectColumns.Add(new SelectColumn {
Expression = new ResourceExpression(sq1.RootEntity, "core:name")
});
StructuredQuery sq2 = new StructuredQuery {
RootEntity = new ResourceEntity("test:person")
};
sq2.SelectColumns.Add(new SelectColumn {
Expression = new ResourceExpression(sq2.RootEntity, "core:name")
});
Assert.That(sq1.SelectColumns [0].ColumnId, Is.Not.EqualTo(sq2.SelectColumns [0].ColumnId));
settings = new QuerySettings( );
queryBuild = new QueryBuild( );
result = new QueryResult(queryBuild);
result.Columns.Add(new ResultColumn {
RequestColumn = sq1.SelectColumns [0]
});
mockQueryRunner = new Mock <IQueryRunner>(MockBehavior.Strict);
mockQueryRunner.Setup(x => x.ExecutePrebuiltQuery(sq1, settings, It.IsNotNull <QueryBuild>( )))
.Returns(() => result)
.Verifiable( );
queryRunner = mockQueryRunner.Object;
cachingQueryRunner = new CachingQueryRunner(queryRunner, userRuleSetProvider, queryBuilder);
QueryResult result1 = cachingQueryRunner.ExecuteQuery(sq1, settings);
Assert.That(result1.Columns [0].RequestColumn, Is.EqualTo(sq1.SelectColumns [0]));
QueryResult result2 = cachingQueryRunner.ExecuteQuery(sq2, settings);
Assert.That(result2.Columns [0].RequestColumn, Is.EqualTo(sq2.SelectColumns [0]));
mockQueryRunner.Verify(x => x.ExecutePrebuiltQuery(sq1, settings, It.IsNotNull <QueryBuild>( )), Times.Exactly(1));
mockQueryRunner.VerifyAll( );
}
/// <summary>
/// Constructor.
/// </summary>
public PerUserRuleSetCache(ICache <Tuple <int, TKey>, TValue> innerCache, IUserRuleSetProvider ruleSetProvider)
{
if (ruleSetProvider == null)
{
throw new ArgumentException("ruleSetProvider");
}
_ruleSetProvider = ruleSetProvider;
_rulesSetsHasher = new UserRuleSetsHasher(ruleSetProvider);
_cache = innerCache;
_cache.ItemsRemoved += CacheOnItemsRemoved;
}
[Ignore] // Blocking layer has been disabled for this cache.
public void Test_EnsureCached_TwoThreads(bool resultIsUserSpecific, bool runAsDifferentUser, bool expectedToCache)
{
CachingQueryRunner cachingQueryRunner;
Mock <IQuerySqlBuilder> mockQuerySqlBuilder;
Mock <IQueryRunner> mockQueryRunner;
IQueryRunner queryRunner;
StructuredQuery structuredQuery;
QuerySettings settings1;
QuerySettings settings2;
QueryBuild queryBuild;
QueryResult result;
IQuerySqlBuilder queryBuilder;
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
structuredQuery = new StructuredQuery( );
settings1 = new QuerySettings( );
settings1.RunAsUser = 1;
settings2 = new QuerySettings( );
settings2.RunAsUser = runAsDifferentUser ? 2 : 1;
queryBuild = new QueryBuild( );
result = new QueryResult(queryBuild);
queryBuild.DataReliesOnCurrentUser = resultIsUserSpecific;
mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict);
mockQuerySqlBuilder.Setup(x => x.BuildSql(It.IsAny <StructuredQuery>( ), It.IsNotNull <QuerySqlBuilderSettings>( ))).Returns(queryBuild);
queryBuilder = mockQuerySqlBuilder.Object;
mockQueryRunner = new Mock <IQueryRunner>(MockBehavior.Strict);
mockQueryRunner.Setup(x => x.ExecutePrebuiltQuery(structuredQuery, It.IsNotNull <QuerySettings>(), It.IsNotNull <QueryBuild>( )))
.Returns(() =>
{
Thread.Sleep(100);
return(result);
})
.Verifiable( );
queryRunner = mockQueryRunner.Object;
cachingQueryRunner = new CachingQueryRunner(queryRunner, userRuleSetProvider, queryBuilder);
Task task1 = Task.Factory.StartNew(() => cachingQueryRunner.ExecuteQuery(structuredQuery, settings1));
Thread.Sleep(1); // BlockIfPending can handle overlapping, but no coincident requests
Task task2 = Task.Factory.StartNew(() => cachingQueryRunner.ExecuteQuery(structuredQuery, settings2));
Task.WaitAll(task1, task2);
int calls = expectedToCache ? 1 : 2;
mockQueryRunner.Verify(x => x.ExecutePrebuiltQuery(structuredQuery, It.IsNotNull <QuerySettings>(), It.IsNotNull <QueryBuild>( )), Times.Exactly(calls));
mockQueryRunner.VerifyAll( );
}
public void TestSetup( )
{
CachingQueryRunner cachingQueryRunner;
Mock <IQueryRunner> mockQueryRunner;
IQueryRunner queryRunner;
IQuerySqlBuilder queryBuilder = MockQuerySqlBuilder( );
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
mockQueryRunner = new Mock <IQueryRunner>(MockBehavior.Strict);
queryRunner = mockQueryRunner.Object;
cachingQueryRunner = new CachingQueryRunner(queryRunner, userRuleSetProvider, queryBuilder);
cachingQueryRunner.Clear( );
}
/// <summary>
/// Create a new <see cref="CachingUserRuleSetProvider"/>.
/// </summary>
/// <param name="innerProvider">
/// The <see cref="IUserRuleSetProvider"/> that will actually calculate the result. This cannot be null.
/// </param>
public CachingUserRuleSetProvider(IUserRuleSetProvider innerProvider)
{
if (innerProvider == null)
{
throw new ArgumentNullException("innerProvider");
}
InnerProvider = innerProvider;
Cache = new CacheFactory()
{
BlockIfPending = true,
CacheName = "UserRuleSet",
MaxCacheEntries = CacheFactory.DefaultMaximumCacheSize,
Distributed = false
}.Create <CachingUserRuleSetProviderKey, UserRuleSet>();
_cacheInvalidator = new CachingUserRuleSetProviderInvalidator(Cache);
}
public void Test_EnsureCached(bool resultIsUserSpecific, bool runAsDifferentUser, bool expectedToCache)
{
CachingQueryRunner cachingQueryRunner;
Mock <IQuerySqlBuilder> mockQuerySqlBuilder;
Mock <IQueryRunner> mockQueryRunner;
IQueryRunner queryRunner;
StructuredQuery structuredQuery;
QuerySettings settings;
QueryBuild queryBuild;
QueryResult result;
IQuerySqlBuilder queryBuilder;
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
structuredQuery = new StructuredQuery( );
settings = new QuerySettings( );
settings.RunAsUser = 1;
queryBuild = new QueryBuild( );
result = new QueryResult(queryBuild);
queryBuild.DataReliesOnCurrentUser = resultIsUserSpecific;
mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict);
mockQuerySqlBuilder.Setup(x => x.BuildSql(It.IsAny <StructuredQuery>( ), It.IsNotNull <QuerySqlBuilderSettings>( ))).Returns(queryBuild);
queryBuilder = mockQuerySqlBuilder.Object;
mockQueryRunner = new Mock <IQueryRunner>(MockBehavior.Strict);
mockQueryRunner.Setup(x => x.ExecutePrebuiltQuery(structuredQuery, settings, It.IsNotNull <QueryBuild>( )))
.Returns(() => result)
.Verifiable( );
queryRunner = mockQueryRunner.Object;
cachingQueryRunner = new CachingQueryRunner(queryRunner, userRuleSetProvider, queryBuilder);
cachingQueryRunner.ExecuteQuery(structuredQuery, settings);
if (runAsDifferentUser)
{
settings.RunAsUser = 2;
}
cachingQueryRunner.ExecuteQuery(structuredQuery, settings);
int calls = expectedToCache ? 1 : 2;
mockQueryRunner.Verify(x => x.ExecutePrebuiltQuery(structuredQuery, settings, It.IsNotNull <QueryBuild>( )), Times.Exactly(calls));
mockQueryRunner.VerifyAll( );
}
public void Test_Ctor()
{
CachingQuerySqlBuilder cachingQuerySqlBuilder;
Mock <IQuerySqlBuilder> mockQuerySqlBuilder;
IQuerySqlBuilder querySqlBuilder;
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict);
querySqlBuilder = mockQuerySqlBuilder.Object;
cachingQuerySqlBuilder = new CachingQuerySqlBuilder(querySqlBuilder, userRuleSetProvider);
Assert.That(cachingQuerySqlBuilder,
Has.Property("QuerySqlBuilder").SameAs(querySqlBuilder));
Assert.That(cachingQuerySqlBuilder,
Has.Property("Cache").Not.Null
.And.Property("Cache").Count.EqualTo(0));
Assert.That(cachingQuerySqlBuilder.CacheInvalidator, Is.Not.Null);
mockQuerySqlBuilder.VerifyAll();
}
public void Test_EnsureDifferentInstancesCanCacheMatch( )
{
CachingQueryRunner cachingQueryRunner;
Mock <IQueryRunner> mockQueryRunner;
IQueryRunner queryRunner;
QuerySettings settings;
QueryBuild queryBuild;
QueryResult result;
IQuerySqlBuilder queryBuilder = MockQuerySqlBuilder( );
IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( );
StructuredQuery sq1 = ReportHelpers.BuildFilterQuery("Name='test1'", new EntityRef("test:person"), true);
sq1.SelectColumns.Add(new SelectColumn {
Expression = new ResourceExpression(sq1.RootEntity, "core:name")
});
StructuredQuery sq2 = ReportHelpers.BuildFilterQuery("Name='test1'", new EntityRef("test:person"), true);
sq2.SelectColumns.Add(new SelectColumn {
Expression = new ResourceExpression(sq2.RootEntity, "core:name")
});
settings = new QuerySettings( );
queryBuild = new QueryBuild( );
result = new QueryResult(queryBuild);
mockQueryRunner = new Mock <IQueryRunner>(MockBehavior.Strict);
mockQueryRunner.Setup(x => x.ExecutePrebuiltQuery(sq1, settings, It.IsNotNull <QueryBuild>( )))
.Returns(() => result)
.Verifiable( );
queryRunner = mockQueryRunner.Object;
cachingQueryRunner = new CachingQueryRunner(queryRunner, userRuleSetProvider, queryBuilder);
cachingQueryRunner.ExecuteQuery(sq1, settings);
cachingQueryRunner.ExecuteQuery(sq2, settings);
mockQueryRunner.Verify(x => x.ExecutePrebuiltQuery(sq1, settings, It.IsNotNull <QueryBuild>( )), Times.Exactly(1));
mockQueryRunner.VerifyAll( );
}
/// <summary>
/// Create a new <see cref="CachingQuerySqlBuilder"/>.
/// </summary>
/// <param name="querySqlBuilder">
/// The <see cref="IQuerySqlBuilder"/> that will actually generate the SQL. This cannot be null.
/// </param>
/// <param name="userRuleSetProvider"></param>
/// <exception cref="ArgumentNullException">
/// <paramref name="querySqlBuilder"/> cannot be null.
/// </exception>
public CachingQuerySqlBuilder([WithKey(Factory.NonCachedKey)] IQuerySqlBuilder querySqlBuilder, IUserRuleSetProvider userRuleSetProvider)
{
if (querySqlBuilder == null)
{
throw new ArgumentNullException("querySqlBuilder");
}
if (userRuleSetProvider == null)
{
throw new ArgumentNullException("userRuleSetProvider");
}
QuerySqlBuilder = querySqlBuilder;
UserRuleSetProvider = userRuleSetProvider;
var fact = new CacheFactory
{
CacheName = "Query SQL",
BlockIfPending = true
};
Cache = fact.Create <CachingQuerySqlBuilderKey, CachingQuerySqlBuilderValue>("Query SQL");
_cacheInvalidator = new CachingQuerySqlBuilderInvalidator(Cache);
}
public MetadataCache(ICache <Tuple <int, TKey>, TValue> innerCache, IUserRuleSetProvider ruleSetProvider, ICacheInvalidator invalidator) : base(innerCache, ruleSetProvider)
{
_invalidator = invalidator;
}
public UserRuleSetsHasher(IUserRuleSetProvider provider)
{
_ruleSetProvider = provider;
}
public void CachingUserRuleSetProvider( )
{
IUserRuleSetProvider provider = Factory.UserRuleSetProvider;
Assert.That(provider, Is.TypeOf <CachingUserRuleSetProvider>());
}
