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>()); }