tsai
/
squidex
mirror of https://github.com/Squidex/squidex.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Fake it easy for read models.

pull/95/head
Sebastian Stehle 8 years ago
parent
0573ab045c
commit
01c493825b
5 changed files with 117 additions and 169 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 57
      tests/Squidex.Domain.Apps.Read.Tests/Apps/CachingAppProviderTests.cs
  2. 8
      tests/Squidex.Domain.Apps.Read.Tests/Apps/ConfigAppLimitsProviderTests.cs
  3. 97
      tests/Squidex.Domain.Apps.Read.Tests/Contents/GraphQLTests.cs
  4. 63
      tests/Squidex.Domain.Apps.Read.Tests/Contents/ODataQueryTests.cs
  5. 61
      tests/Squidex.Domain.Apps.Read.Tests/Schemas/CachingSchemaProviderTests.cs

57
tests/Squidex.Domain.Apps.Read.Tests/Apps/CachingAppProviderTests.cs
View File

@ -8,9 +8,9 @@
using System;
using System.Threading.Tasks;
using FakeItEasy;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using Moq;
using Squidex.Domain.Apps.Events.Apps;
using Squidex.Domain.Apps.Read.Apps.Repositories;
using Squidex.Domain.Apps.Read.Apps.Services.Implementations;
@ -26,27 +26,21 @@ namespace Squidex.Domain.Apps.Read.Apps
public class CachingAppProviderTests
{
private readonly IMemoryCache cache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
private readonly Mock<IAppRepository> repository = new Mock<IAppRepository>();
private readonly IAppRepository repository = A.Fake<IAppRepository>();
private readonly CachingAppProvider sut;
private readonly IAppEntity appV1;
private readonly IAppEntity appV2;
private readonly IAppEntity appV1 = A.Dummy<IAppEntity>();
private readonly IAppEntity appV2 = A.Dummy<IAppEntity>();
private readonly NamedId<Guid> appId = new NamedId<Guid>(Guid.NewGuid(), "my-app");
public CachingAppProviderTests()
{
var appV1Mock = new Mock<IAppEntity>();
var appV2Mock = new Mock<IAppEntity>();
A.CallTo(() => appV1.Id).Returns(appId.Id);
A.CallTo(() => appV1.Name).Returns(appId.Name);
appV1Mock.Setup(x => x.Id).Returns(appId.Id);
appV1Mock.Setup(x => x.Name).Returns(appId.Name);
A.CallTo(() => appV2.Id).Returns(appId.Id);
A.CallTo(() => appV2.Name).Returns(appId.Name);
appV2Mock.Setup(x => x.Id).Returns(appId.Id);
appV2Mock.Setup(x => x.Name).Returns(appId.Name);
appV1 = appV1Mock.Object;
appV2 = appV2Mock.Object;
sut = new CachingAppProvider(cache, repository.Object);
sut = new CachingAppProvider(cache, repository);
}
[Fact]
@ -70,33 +64,32 @@ namespace Squidex.Domain.Apps.Read.Apps
[Fact]
public async Task Should_also_retrieve_app_by_name_if_retrieved_by_id_before()
{
repository.Setup(x => x.FindAppAsync(appId.Id)).Returns(Task.FromResult(appV1));
A.CallTo(() => repository.FindAppAsync(appId.Id)).Returns(Task.FromResult(appV1));
await ProvideAppById(appV1);
await ProvideAppByName(appV1);
repository.Verify(x => x.FindAppAsync(appId.Id), Times.Once());
repository.Verify(x => x.FindAppAsync(appId.Name), Times.Never());
A.CallTo(() => repository.FindAppAsync(appId.Id)).MustHaveHappened();
A.CallTo(() => repository.FindAppAsync(appId.Name)).MustNotHaveHappened();
}
[Fact]
public async Task Should_also_retrieve_app_by_id_if_retrieved_by_name_before()
{
repository.Setup(x => x.FindAppAsync(appId.Name)).Returns(Task.FromResult(appV1));
A.CallTo(() => repository.FindAppAsync(appId.Name)).Returns(Task.FromResult(appV1));
await ProvideAppByName(appV1);
await ProvideAppById(appV1);
repository.Verify(x => x.FindAppAsync(appId.Name), Times.Once());
repository.Verify(x => x.FindAppAsync(appId.Id), Times.Never());
A.CallTo(() => repository.FindAppAsync(appId.Id)).MustNotHaveHappened();
A.CallTo(() => repository.FindAppAsync(appId.Name)).MustHaveHappened();
}
[Fact]
public async Task Should_clear_cache_for_id_after_update_event()
{
var apps = ProviderResults(appV1, appV2);
repository.Setup(x => x.FindAppAsync(appId.Id)).Returns(() => Task.FromResult(apps()));
A.CallTo(() => repository.FindAppAsync(appId.Id)).Returns(appV2);
A.CallTo(() => repository.FindAppAsync(appId.Id)).Returns(appV1).Once();
await ProvideAppById(appV1);
@ -104,15 +97,14 @@ namespace Squidex.Domain.Apps.Read.Apps
await ProvideAppById(appV2);
repository.Verify(x => x.FindAppAsync(appId.Id), Times.Exactly(2));
A.CallTo(() => repository.FindAppAsync(appId.Id)).MustHaveHappened(Repeated.Exactly.Times(2));
}
[Fact]
public async Task Should_clear_cache_for_name_after_update_event()
{
var apps = ProviderResults(appV1, appV2);
repository.Setup(x => x.FindAppAsync(appId.Name)).Returns(() => Task.FromResult(apps()));
A.CallTo(() => repository.FindAppAsync(appId.Name)).Returns(appV2);
A.CallTo(() => repository.FindAppAsync(appId.Name)).Returns(appV1).Once();
await ProvideAppByName(appV1);
@ -120,7 +112,7 @@ namespace Squidex.Domain.Apps.Read.Apps
await ProvideAppByName(appV2);
repository.Verify(x => x.FindAppAsync(appId.Name), Times.Exactly(2));
A.CallTo(() => repository.FindAppAsync(appId.Name)).MustHaveHappened(Repeated.Exactly.Times(2));
}
private async Task ProvideAppById(IAppEntity app)
@ -132,12 +124,5 @@ namespace Squidex.Domain.Apps.Read.Apps
{
Assert.Equal(app, await sut.FindAppByNameAsync(appId.Name));
}
private static Func<T> ProviderResults<T>(params T[] items)
{
var index = 0;
return () => items[index++];
}
}
}

8
tests/Squidex.Domain.Apps.Read.Tests/Apps/ConfigAppLimitsProviderTests.cs
View File

@ -7,8 +7,8 @@
// ==========================================================================
using System.Linq;
using FakeItEasy;
using FluentAssertions;
using Moq;
using Squidex.Domain.Apps.Read.Apps.Services.Implementations;
using Xunit;
@ -112,11 +112,11 @@ namespace Squidex.Domain.Apps.Read.Apps
private static IAppEntity CreateApp(string plan)
{
var app = new Mock<IAppEntity>();
var app = A.Dummy<IAppEntity>();
app.Setup(x => x.PlanId).Returns(plan);
A.CallTo(() => app.PlanId).Returns(plan);
return app.Object;
return app;
}
}
}

97
tests/Squidex.Domain.Apps.Read.Tests/Contents/GraphQLTests.cs
View File

@ -9,9 +9,9 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using FakeItEasy;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using Moq;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Squidex.Domain.Apps.Core;
@ -59,32 +59,29 @@ namespace Squidex.Domain.Apps.Read.Contents
.AddOrUpdateField(new GeolocationField(9, "my-geolocation", Partitioning.Invariant,
new GeolocationFieldProperties()));
private readonly Mock<ISchemaRepository> schemaRepository = new Mock<ISchemaRepository>();
private readonly Mock<IContentRepository> contentRepository = new Mock<IContentRepository>();
private readonly Mock<IAssetRepository> assetRepository = new Mock<IAssetRepository>();
private readonly IAppEntity app;
private readonly ISchemaRepository schemaRepository = A.Fake<ISchemaRepository>();
private readonly ISchemaEntity schemaEntity = A.Fake<ISchemaEntity>();
private readonly IContentRepository contentRepository = A.Fake<IContentRepository>();
private readonly IAssetRepository assetRepository = A.Fake<IAssetRepository>();
private readonly IAppEntity appEntity = A.Dummy<IAppEntity>();
private readonly IMemoryCache cache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
private readonly IGraphQLService sut;
public GraphQLTests()
{
var appEntity = new Mock<IAppEntity>();
appEntity.Setup(x => x.Id).Returns(appId);
appEntity.Setup(x => x.PartitionResolver).Returns(x => InvariantPartitioning.Instance);
A.CallTo(() => appEntity.Id).Returns(appId);
A.CallTo(() => appEntity.PartitionResolver).Returns(x => InvariantPartitioning.Instance);
app = appEntity.Object;
A.CallTo(() => schemaEntity.Id).Returns(schemaId);
A.CallTo(() => schemaEntity.Name).Returns(schema.Name);
A.CallTo(() => schemaEntity.Schema).Returns(schema);
A.CallTo(() => schemaEntity.IsPublished).Returns(true);
var schemaEntity = new Mock<ISchemaEntity>();
schemaEntity.Setup(x => x.Id).Returns(schemaId);
schemaEntity.Setup(x => x.Name).Returns(schema.Name);
schemaEntity.Setup(x => x.Schema).Returns(schema);
schemaEntity.Setup(x => x.IsPublished).Returns(true);
var schemas = new List<ISchemaEntity> { schemaEntity };
var schemas = new List<ISchemaEntity> { schemaEntity.Object };
A.CallTo(() => schemaRepository.QueryAllAsync(appId)).Returns(Task.FromResult<IReadOnlyList<ISchemaEntity>>(schemas));
schemaRepository.Setup(x => x.QueryAllAsync(appId)).Returns(Task.FromResult<IReadOnlyList<ISchemaEntity>>(schemas));
sut = new CachingGraphQLService(cache, schemaRepository.Object, assetRepository.Object, contentRepository.Object, new FakeUrlGenerator());
sut = new CachingGraphQLService(cache, schemaRepository, assetRepository, contentRepository, new FakeUrlGenerator());
}
[Fact]
@ -115,11 +112,10 @@ namespace Squidex.Domain.Apps.Read.Contents
var assets = new List<IAssetEntity> { assetEntity };
assetRepository.Setup(x => x.QueryAsync(app.Id, null, null, "my-query", 30, 5))
.Returns(Task.FromResult<IReadOnlyList<IAssetEntity>>(assets))
.Verifiable();
A.CallTo(() => assetRepository.QueryAsync(appEntity.Id, null, null, "my-query", 30, 5))
.Returns(Task.FromResult<IReadOnlyList<IAssetEntity>>(assets));
var result = await sut.QueryAsync(app, new GraphQLQuery { Query = query });
var result = await sut.QueryAsync(appEntity, new GraphQLQuery { Query = query });
var expected = new
{
@ -150,8 +146,6 @@ namespace Squidex.Domain.Apps.Read.Contents
};
AssertJson(expected, new { data = result.Data });
assetRepository.VerifyAll();
}
[Fact]
@ -181,11 +175,10 @@ namespace Squidex.Domain.Apps.Read.Contents
}}
}}";
assetRepository.Setup(x => x.FindAssetAsync(assetId))
.Returns(Task.FromResult(assetEntity))
.Verifiable();
A.CallTo(() => assetRepository.FindAssetAsync(assetId))
.Returns(Task.FromResult(assetEntity));
var result = await sut.QueryAsync(app, new GraphQLQuery { Query = query });
var result = await sut.QueryAsync(appEntity, new GraphQLQuery { Query = query });
var expected = new
{
@ -213,8 +206,6 @@ namespace Squidex.Domain.Apps.Read.Contents
};
AssertJson(expected, new { data = result.Data });
assetRepository.VerifyAll();
}
[Fact]
@ -257,11 +248,10 @@ namespace Squidex.Domain.Apps.Read.Contents
var contents = new List<IContentEntity> { contentEntity };
contentRepository.Setup(x => x.QueryAsync(app, schemaId, false, null, "?$top=30&$skip=5"))
.Returns(Task.FromResult<IReadOnlyList<IContentEntity>>(contents))
.Verifiable();
A.CallTo(() => contentRepository.QueryAsync(appEntity, schemaId, false, null, "?$top=30&$skip=5"))
.Returns(Task.FromResult<IReadOnlyList<IContentEntity>>(contents));
var result = await sut.QueryAsync(app, new GraphQLQuery { Query = query });
var result = await sut.QueryAsync(appEntity, new GraphQLQuery { Query = query });
var expected = new
{
@ -318,8 +308,6 @@ namespace Squidex.Domain.Apps.Read.Contents
};
AssertJson(expected, new { data = result.Data });
contentRepository.VerifyAll();
}
[Fact]
@ -361,11 +349,10 @@ namespace Squidex.Domain.Apps.Read.Contents
}}
}}";
contentRepository.Setup(x => x.FindContentAsync(app, schemaId, contentId))
.Returns(Task.FromResult(contentEntity))
.Verifiable();
A.CallTo(() => contentRepository.FindContentAsync(appEntity, schemaId, contentId))
.Returns(Task.FromResult(contentEntity));
var result = await sut.QueryAsync(app, new GraphQLQuery { Query = query });
var result = await sut.QueryAsync(appEntity, new GraphQLQuery { Query = query });
var expected = new
{
@ -419,8 +406,6 @@ namespace Squidex.Domain.Apps.Read.Contents
};
AssertJson(expected, new { data = result.Data });
contentRepository.VerifyAll();
}
[Fact]
@ -448,15 +433,13 @@ namespace Squidex.Domain.Apps.Read.Contents
var refContents = new List<IContentEntity> { contentRefEntity };
contentRepository.Setup(x => x.FindContentAsync(app, schemaId, contentId))
.Returns(Task.FromResult(contentEntity))
.Verifiable();
A.CallTo(() => contentRepository.FindContentAsync(appEntity, schemaId, contentId))
.Returns(Task.FromResult(contentEntity));
contentRepository.Setup(x => x.QueryAsync(app, schemaId, false, new HashSet<Guid> {contentRefId }, null))
.Returns(Task.FromResult<IReadOnlyList<IContentEntity>>(refContents))
.Verifiable();
A.CallTo(() => contentRepository.QueryAsync(appEntity, schemaId, false, A<HashSet<Guid>>.That.Matches(x => x.Contains(contentRefId)), null))
.Returns(Task.FromResult<IReadOnlyList<IContentEntity>>(refContents));
var result = await sut.QueryAsync(app, new GraphQLQuery { Query = query });
var result = await sut.QueryAsync(appEntity, new GraphQLQuery { Query = query });
var expected = new
{
@ -483,8 +466,6 @@ namespace Squidex.Domain.Apps.Read.Contents
};
AssertJson(expected, new { data = result.Data });
contentRepository.VerifyAll();
}
[Fact]
@ -512,15 +493,13 @@ namespace Squidex.Domain.Apps.Read.Contents
var refAssets = new List<IAssetEntity> { assetRefEntity };
contentRepository.Setup(x => x.FindContentAsync(app, schemaId, contentId))
.Returns(Task.FromResult(contentEntity))
.Verifiable();
A.CallTo(() => contentRepository.FindContentAsync(appEntity, schemaId, contentId))
.Returns(Task.FromResult(contentEntity));
assetRepository.Setup(x => x.QueryAsync(app.Id, null, new HashSet<Guid> { assetRefId }, null, int.MaxValue, 0))
.Returns(Task.FromResult<IReadOnlyList<IAssetEntity>>(refAssets))
.Verifiable();
A.CallTo(() => assetRepository.QueryAsync(appEntity.Id, null, A<HashSet<Guid>>.That.Matches(x => x.Contains(assetRefId)), null, int.MaxValue, 0))
.Returns(Task.FromResult<IReadOnlyList<IAssetEntity>>(refAssets));
var result = await sut.QueryAsync(app, new GraphQLQuery { Query = query });
var result = await sut.QueryAsync(appEntity, new GraphQLQuery { Query = query });
var expected = new
{
@ -547,8 +526,6 @@ namespace Squidex.Domain.Apps.Read.Contents
};
AssertJson(expected, new { data = result.Data });
contentRepository.VerifyAll();
}
private static IContentEntity CreateContent(Guid id, Guid refId, Guid assetId)

63
tests/Squidex.Domain.Apps.Read.Tests/Contents/ODataQueryTests.cs
View File

@ -8,12 +8,12 @@
using System;
using System.Collections.Immutable;
using FakeItEasy;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using Microsoft.OData.Edm;
using MongoDB.Bson.Serialization;
using MongoDB.Driver;
using Moq;
using Squidex.Domain.Apps.Core;
using Squidex.Domain.Apps.Core.Schemas;
using Squidex.Domain.Apps.Read.Apps;
@ -62,17 +62,17 @@ namespace Squidex.Domain.Apps.Read.Contents
{
var builder = new EdmModelBuilder(new MemoryCache(Options.Create(new MemoryCacheOptions())));
var schemaEntity = new Mock<ISchemaEntity>();
schemaEntity.Setup(x => x.Id).Returns(Guid.NewGuid());
schemaEntity.Setup(x => x.Version).Returns(3);
schemaEntity.Setup(x => x.Schema).Returns(schema);
var schemaEntity = A.Dummy<ISchemaEntity>();
A.CallTo(() => schemaEntity.Id).Returns(Guid.NewGuid());
A.CallTo(() => schemaEntity.Version).Returns(3);
A.CallTo(() => schemaEntity.Schema).Returns(schema);
var appEntity = new Mock<IAppEntity>();
appEntity.Setup(x => x.Id).Returns(Guid.NewGuid());
appEntity.Setup(x => x.Version).Returns(3);
appEntity.Setup(x => x.PartitionResolver).Returns(languagesConfig.ToResolver());
var appEntity = A.Dummy<IAppEntity>();
A.CallTo(() => appEntity.Id).Returns(Guid.NewGuid());
A.CallTo(() => appEntity.Version).Returns(3);
A.CallTo(() => appEntity.PartitionResolver).Returns(languagesConfig.ToResolver());
edmModel = builder.BuildEdmModel(schemaEntity.Object, appEntity.Object);
edmModel = builder.BuildEdmModel(schemaEntity, appEntity);
}
[Fact]
@ -294,55 +294,55 @@ namespace Squidex.Domain.Apps.Read.Contents
public void Should_set_top()
{
var parser = edmModel.ParseQuery("$top=3");
var cursor = new Mock<IFindFluent<MongoContentEntity, MongoContentEntity>>();
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>();
cursor.Object.Take(parser);
cursor.Take(parser);
cursor.Verify(x => x.Limit(3));
A.CallTo(() => cursor.Limit(3)).MustHaveHappened();
}
[Fact]
public void Should_set_max_top_if_larger()
{
var parser = edmModel.ParseQuery("$top=300");
var cursor = new Mock<IFindFluent<MongoContentEntity, MongoContentEntity>>();
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>();
cursor.Object.Take(parser);
cursor.Take(parser);
cursor.Verify(x => x.Limit(200));
A.CallTo(() => cursor.Limit(200)).MustHaveHappened();
}
[Fact]
public void Should_set_default_top()
{
var parser = edmModel.ParseQuery("");
var cursor = new Mock<IFindFluent<MongoContentEntity, MongoContentEntity>>();
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>();
cursor.Object.Take(parser);
cursor.Take(parser);
cursor.Verify(x => x.Limit(20));
A.CallTo(() => cursor.Limit(20)).MustHaveHappened();
}
[Fact]
public void Should_set_skip()
{
var parser = edmModel.ParseQuery("$skip=3");
var cursor = new Mock<IFindFluent<MongoContentEntity, MongoContentEntity>>();
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>();
cursor.Object.Skip(parser);
cursor.Skip(parser);
cursor.Verify(x => x.Skip(3));
A.CallTo(() => cursor.Skip(3)).MustHaveHappened();
}
[Fact]
public void Should_not_set_skip()
{
var parser = edmModel.ParseQuery("");
var cursor = new Mock<IFindFluent<MongoContentEntity, MongoContentEntity>>();
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>();
cursor.Object.Take(parser);
cursor.Take(parser);
cursor.Verify(x => x.Skip(It.IsAny<int>()), Times.Never);
A.CallTo(() => cursor.Skip(A<int>.Ignored)).MustNotHaveHappened();
}
private static string C(string value)
@ -353,16 +353,17 @@ namespace Squidex.Domain.Apps.Read.Contents
private string S(string value)
{
var parser = edmModel.ParseQuery(value);
var cursor = new Mock<IFindFluent<MongoContentEntity, MongoContentEntity>>();
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>();
var i = string.Empty;
cursor.Setup(x => x.Sort(It.IsAny<SortDefinition<MongoContentEntity>>())).Callback(new Action<SortDefinition<MongoContentEntity>>(s =>
{
i = s.Render(serializer, registry).ToString();
}));
A.CallTo(() => cursor.Sort(A<SortDefinition<MongoContentEntity>>.Ignored))
.Invokes((SortDefinition<MongoContentEntity> sortDefinition) =>
{
i = sortDefinition.Render(serializer, registry).ToString();
});
cursor.Object.Sort(parser, schema);
cursor.Sort(parser, schema);
return i;
}

61
tests/Squidex.Domain.Apps.Read.Tests/Schemas/CachingSchemaProviderTests.cs
View File

@ -8,9 +8,9 @@
using System;
using System.Threading.Tasks;
using FakeItEasy;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using Moq;
using Squidex.Domain.Apps.Events.Schemas;
using Squidex.Domain.Apps.Read.Schemas.Repositories;
using Squidex.Domain.Apps.Read.Schemas.Services.Implementations;
@ -26,30 +26,24 @@ namespace Squidex.Domain.Apps.Read.Schemas
public class CachingSchemaProviderTests
{
private readonly IMemoryCache cache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
private readonly Mock<ISchemaRepository> repository = new Mock<ISchemaRepository>();
private readonly ISchemaRepository repository = A.Fake<ISchemaRepository>();
private readonly CachingSchemaProvider sut;
private readonly ISchemaEntity schemaV1;
private readonly ISchemaEntity schemaV2;
private readonly ISchemaEntity schemaV1 = A.Dummy<ISchemaEntity>();
private readonly ISchemaEntity schemaV2 = A.Dummy<ISchemaEntity>();
private readonly NamedId<Guid> schemaId = new NamedId<Guid>(Guid.NewGuid(), "my-schema");
private readonly NamedId<Guid> appId = new NamedId<Guid>(Guid.NewGuid(), "my-app");
public CachingSchemaProviderTests()
{
var schemaV1Mock = new Mock<ISchemaEntity>();
var schemaV2Mock = new Mock<ISchemaEntity>();
A.CallTo(() => schemaV1.Id).Returns(schemaId.Id);
A.CallTo(() => schemaV1.Name).Returns(schemaId.Name);
A.CallTo(() => schemaV1.AppId).Returns(appId.Id);
schemaV1Mock.Setup(x => x.Id).Returns(schemaId.Id);
schemaV1Mock.Setup(x => x.Name).Returns(schemaId.Name);
schemaV1Mock.Setup(x => x.AppId).Returns(appId.Id);
A.CallTo(() => schemaV2.Id).Returns(schemaId.Id);
A.CallTo(() => schemaV2.Name).Returns(schemaId.Name);
A.CallTo(() => schemaV2.AppId).Returns(appId.Id);
schemaV2Mock.Setup(x => x.Id).Returns(schemaId.Id);
schemaV2Mock.Setup(x => x.Name).Returns(schemaId.Name);
schemaV2Mock.Setup(x => x.AppId).Returns(appId.Id);
schemaV1 = schemaV1Mock.Object;
schemaV2 = schemaV2Mock.Object;
sut = new CachingSchemaProvider(cache, repository.Object);
sut = new CachingSchemaProvider(cache, repository);
}
[Fact]
@ -73,33 +67,32 @@ namespace Squidex.Domain.Apps.Read.Schemas
[Fact]
public async Task Should_also_retrieve_schema_by_name_if_retrieved_by_id_before()
{
repository.Setup(x => x.FindSchemaAsync(schemaId.Id)).Returns(Task.FromResult(schemaV1));
A.CallTo(() => repository.FindSchemaAsync(schemaId.Id)).Returns(Task.FromResult(schemaV1));
await ProvideSchemaById(schemaV1);
await ProvideSchemaByName(schemaV1);
repository.Verify(x => x.FindSchemaAsync(schemaId.Id), Times.Once());
repository.Verify(x => x.FindSchemaAsync(appId.Id, schemaId.Name), Times.Never());
A.CallTo(() => repository.FindSchemaAsync(schemaId.Id)).MustHaveHappened();
A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name)).MustNotHaveHappened();
}
[Fact]
public async Task Should_also_retrieve_schema_by_id_if_retrieved_by_name_before()
{
repository.Setup(x => x.FindSchemaAsync(appId.Id, schemaId.Name)).Returns(Task.FromResult(schemaV1));
A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name)).Returns(Task.FromResult(schemaV1));
await ProvideSchemaByName(schemaV1);
await ProvideSchemaById(schemaV1);
repository.Verify(x => x.FindSchemaAsync(appId.Id, schemaId.Name), Times.Once());
repository.Verify(x => x.FindSchemaAsync(schemaId.Id), Times.Never());
A.CallTo(() => repository.FindSchemaAsync(schemaId.Id)).MustNotHaveHappened();
A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name)).MustHaveHappened();
}
[Fact]
public async Task Should_clear_cache_for_id_after_update_event()
{
var schemas = ProviderResults(schemaV1, schemaV2);
repository.Setup(x => x.FindSchemaAsync(schemaId.Id)).Returns(() => Task.FromResult(schemas()));
A.CallTo(() => repository.FindSchemaAsync(schemaId.Id)).Returns(schemaV2);
A.CallTo(() => repository.FindSchemaAsync(schemaId.Id)).Returns(schemaV1).Once();
await ProvideSchemaById(schemaV1);
@ -107,15 +100,14 @@ namespace Squidex.Domain.Apps.Read.Schemas
await ProvideSchemaById(schemaV2);
repository.Verify(x => x.FindSchemaAsync(schemaId.Id), Times.Exactly(2));
A.CallTo(() => repository.FindSchemaAsync(schemaId.Id)).MustHaveHappened(Repeated.Exactly.Times(2));
}
[Fact]
public async Task Should_clear_cache_for_name_after_update_event()
{
var schemas = ProviderResults(schemaV1, schemaV2);
repository.Setup(x => x.FindSchemaAsync(appId.Id, schemaId.Name)).Returns(() => Task.FromResult(schemas()));
A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name)).Returns(schemaV2);
A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name)).Returns(schemaV1).Once();
await ProvideSchemaByName(schemaV1);
@ -123,7 +115,7 @@ namespace Squidex.Domain.Apps.Read.Schemas
await ProvideSchemaByName(schemaV2);
repository.Verify(x => x.FindSchemaAsync(appId.Id, schemaId.Name), Times.Exactly(2));
A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name)).MustHaveHappened(Repeated.Exactly.Times(2));
}
private async Task ProvideSchemaById(ISchemaEntity schema)
@ -135,12 +127,5 @@ namespace Squidex.Domain.Apps.Read.Schemas
{
Assert.Equal(schema, await sut.FindSchemaByNameAsync(appId.Id, schemaId.Name));
}
private static Func<T> ProviderResults<T>(params T[] items)
{
var index = 0;
return () => items[index++];
}
}
}

Write Preview
Loading…
Cancel
Save