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

Tests fixed.

pull/285/head
Sebastian 9 years ago
parent
cf76e8cc41
commit
1013ce9378
6 changed files with 150 additions and 133 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 11
      src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentCollection.cs
  2. 12
      src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentDraftCollection.cs
  3. 15
      src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentPublishedCollection.cs
  4. 61
      src/Squidex.Domain.Apps.Entities/Contents/ContentQueryService.cs
  5. 38
      tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/ContentChangedTriggerTests.cs
  6. 146
      tests/Squidex.Domain.Apps.Entities.Tests/Contents/ContentQueryServiceTests.cs

11
src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentCollection.cs
View File

@ -108,17 +108,6 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
return ResultList.Create<IContentEntity>(contentItems.Result, contentCount.Result); return ResultList.Create<IContentEntity>(contentItems.Result, contentCount.Result);
} }
public async Task<IContentEntity> FindContentAsync(IAppEntity app, ISchemaEntity schema, Guid id)
{
var contentEntity =
await Collection.Find(x => x.IndexedSchemaId == schema.Id && x.Id == id && x.IsDeleted != true).Not(x => x.DataText)
.FirstOrDefaultAsync();
contentEntity?.ParseData(schema.SchemaDef);
return contentEntity;
}
public Task CleanupAsync(Guid id) public Task CleanupAsync(Guid id)
{ {
return Collection.UpdateManyAsync( return Collection.UpdateManyAsync(

12
src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentDraftCollection.cs
View File

@ -11,6 +11,7 @@ using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using MongoDB.Driver; using MongoDB.Driver;
using NodaTime; using NodaTime;
using Squidex.Domain.Apps.Entities.Apps;
using Squidex.Domain.Apps.Entities.Contents; using Squidex.Domain.Apps.Entities.Contents;
using Squidex.Domain.Apps.Entities.Contents.State; using Squidex.Domain.Apps.Entities.Contents.State;
using Squidex.Domain.Apps.Entities.Schemas; using Squidex.Domain.Apps.Entities.Schemas;
@ -67,6 +68,17 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
}); });
} }
public async Task<IContentEntity> FindContentAsync(IAppEntity app, ISchemaEntity schema, Guid id)
{
var contentEntity =
await Collection.Find(x => x.IndexedSchemaId == schema.Id && x.Id == id && x.IsDeleted != true).Not(x => x.DataText)
.FirstOrDefaultAsync();
contentEntity?.ParseData(schema.SchemaDef);
return contentEntity;
}
public async Task<(ContentState Value, long Version)> ReadAsync(Guid key, Func<Guid, Guid, Task<ISchemaEntity>> getSchema) public async Task<(ContentState Value, long Version)> ReadAsync(Guid key, Func<Guid, Guid, Task<ISchemaEntity>> getSchema)
{ {
var contentEntity = var contentEntity =

15
src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentPublishedCollection.cs
View File

@ -8,6 +8,10 @@
using System; using System;
using System.Threading.Tasks; using System.Threading.Tasks;
using MongoDB.Driver; using MongoDB.Driver;
using Squidex.Domain.Apps.Entities.Apps;
using Squidex.Domain.Apps.Entities.Contents;
using Squidex.Domain.Apps.Entities.Schemas;
using Squidex.Infrastructure.MongoDb;
namespace Squidex.Domain.Apps.Entities.MongoDb.Contents namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
{ {
@ -30,6 +34,17 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
await base.SetupCollectionAsync(collection); await base.SetupCollectionAsync(collection);
} }
public async Task<IContentEntity> FindContentAsync(IAppEntity app, ISchemaEntity schema, Guid id)
{
var contentEntity =
await Collection.Find(x => x.IndexedSchemaId == schema.Id && x.Id == id).Not(x => x.DataText)
.FirstOrDefaultAsync();
contentEntity?.ParseData(schema.SchemaDef);
return contentEntity;
}
public Task UpsertAsync(MongoContentEntity content) public Task UpsertAsync(MongoContentEntity content)
{ {
content.DataText = content.DataByIds.ToFullText(); content.DataText = content.DataByIds.ToFullText();

61
src/Squidex.Domain.Apps.Entities/Contents/ContentQueryService.cs
View File

@ -27,6 +27,10 @@ namespace Squidex.Domain.Apps.Entities.Contents
{ {
public sealed class ContentQueryService : IContentQueryService public sealed class ContentQueryService : IContentQueryService
{ {
private static readonly Status[] StatusAll = { Status.Archived, Status.Draft, Status.Published };
private static readonly Status[] StatusArchived = { Status.Archived };
private static readonly Status[] StatusPublished = { Status.Published };
private static readonly Status[] StatusDraftOrPublished = { Status.Draft, Status.Published };
private readonly IContentRepository contentRepository; private readonly IContentRepository contentRepository;
private readonly IContentVersionLoader contentVersionLoader; private readonly IContentVersionLoader contentVersionLoader;
private readonly IAppProvider appProvider; private readonly IAppProvider appProvider;
@ -67,24 +71,22 @@ namespace Squidex.Domain.Apps.Entities.Contents
var schema = await GetSchemaAsync(app, schemaIdOrName); var schema = await GetSchemaAsync(app, schemaIdOrName);
var isFrontendClient = IsFrontendClient(user);
var isVersioned = version > EtagVersion.Empty; var isVersioned = version > EtagVersion.Empty;
var isFrontend = IsFrontendClient(user);
var parsedStatus = isFrontendClient ? null : new[] { Status.Published }; var parsedStatus = isFrontend ? StatusAll : StatusPublished;
var content = var content =
isVersioned ? isVersioned ?
await FindContentByVersionAsync(id, version) : await FindContentByVersionAsync(id, version) :
await FindContentAsync(app, id, parsedStatus, schema); await FindContentAsync(app, id, parsedStatus, schema);
if (content == null || (content.Status != Status.Published && !isFrontendClient) || content.SchemaId.Id != schema.Id) if (content == null || (content.Status != Status.Published && !isFrontend) || content.SchemaId.Id != schema.Id)
{ {
throw new DomainObjectNotFoundException(id.ToString(), typeof(ISchemaEntity)); throw new DomainObjectNotFoundException(id.ToString(), typeof(ISchemaEntity));
} }
content = TransformContent(app, schema, user, Enumerable.Repeat(content, 1), isVersioned, isFrontendClient).FirstOrDefault(); return TransformContent(app, schema, user, content, isFrontend, isVersioned);
return content;
} }
public async Task<IResultList<IContentEntity>> QueryAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, bool archived, string query) public async Task<IResultList<IContentEntity>> QueryAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, bool archived, string query)
@ -95,14 +97,14 @@ namespace Squidex.Domain.Apps.Entities.Contents
var schema = await GetSchemaAsync(app, schemaIdOrName); var schema = await GetSchemaAsync(app, schemaIdOrName);
var isFrontendClient = IsFrontendClient(user); var isFrontend = IsFrontendClient(user);
var parsedQuery = ParseQuery(app, query, schema); var parsedQuery = ParseQuery(app, query, schema);
var parsedStatus = ParseStatus(isFrontendClient, archived); var parsedStatus = ParseStatus(isFrontend, archived);
var contents = await contentRepository.QueryAsync(app, schema, parsedStatus.ToArray(), parsedQuery); var contents = await contentRepository.QueryAsync(app, schema, parsedStatus, parsedQuery);
return TransformContents(app, schema, user, contents, false, isFrontendClient); return TransformContents(app, schema, user, contents, false, isFrontend);
} }
public async Task<IResultList<IContentEntity>> QueryAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, bool archived, HashSet<Guid> ids) public async Task<IResultList<IContentEntity>> QueryAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, bool archived, HashSet<Guid> ids)
@ -114,13 +116,21 @@ namespace Squidex.Domain.Apps.Entities.Contents
var schema = await GetSchemaAsync(app, schemaIdOrName); var schema = await GetSchemaAsync(app, schemaIdOrName);
var isFrontendClient = IsFrontendClient(user); var isFrontend = IsFrontendClient(user);
var parsedStatus = ParseStatus(isFrontendClient, archived); var parsedStatus = ParseStatus(isFrontend, archived);
var contents = await contentRepository.QueryAsync(app, schema, parsedStatus.ToArray(), ids); var contents = await contentRepository.QueryAsync(app, schema, parsedStatus, ids);
return TransformContents(app, schema, user, contents, false, isFrontendClient); return TransformContents(app, schema, user, contents, false, isFrontend);
}
private IContentEntity TransformContent(IAppEntity app, ISchemaEntity schema, ClaimsPrincipal user,
IContentEntity content,
bool isFrontend,
bool isVersioned)
{
return TransformContents(app, schema, user, Enumerable.Repeat(content, 1), isVersioned, isFrontend).FirstOrDefault();
} }
private IResultList<IContentEntity> TransformContents(IAppEntity app, ISchemaEntity schema, ClaimsPrincipal user, private IResultList<IContentEntity> TransformContents(IAppEntity app, ISchemaEntity schema, ClaimsPrincipal user,
@ -128,12 +138,12 @@ namespace Squidex.Domain.Apps.Entities.Contents
bool isTypeChecking, bool isTypeChecking,
bool isFrontendClient) bool isFrontendClient)
{ {
var transformed = TransformContent(app, schema, user, contents, isTypeChecking, isFrontendClient); var transformed = TransformContents(app, schema, user, (IEnumerable<IContentEntity>)contents, isTypeChecking, isFrontendClient);
return ResultList.Create(transformed, contents.Total); return ResultList.Create(transformed, contents.Total);
} }
private IEnumerable<IContentEntity> TransformContent(IAppEntity app, ISchemaEntity schema, ClaimsPrincipal user, private IEnumerable<IContentEntity> TransformContents(IAppEntity app, ISchemaEntity schema, ClaimsPrincipal user,
IEnumerable<IContentEntity> contents, IEnumerable<IContentEntity> contents,
bool isTypeChecking, bool isTypeChecking,
bool isFrontendClient) bool isFrontendClient)
@ -203,28 +213,19 @@ namespace Squidex.Domain.Apps.Entities.Contents
return schema; return schema;
} }
private static List<Status> ParseStatus(bool isFrontendClient, bool archived) private static Status[] ParseStatus(bool isFrontendClient, bool archived)
{ {
var status = new List<Status>();
if (isFrontendClient) if (isFrontendClient)
{ {
if (archived) if (archived)
{ {
status.Add(Status.Archived); return StatusArchived;
} }
else
{ return StatusDraftOrPublished;
status.Add(Status.Draft);
status.Add(Status.Published);
}
}
else
{
status.Add(Status.Published);
} }
return status; return StatusPublished;
} }
private Task<IContentEntity> FindContentByVersionAsync(Guid id, long version) private Task<IContentEntity> FindContentByVersionAsync(Guid id, long version)

38
tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/ContentChangedTriggerTests.cs
View File

@ -20,6 +20,8 @@ using Squidex.Infrastructure;
using Squidex.Infrastructure.EventSourcing; using Squidex.Infrastructure.EventSourcing;
using Xunit; using Xunit;
#pragma warning disable SA1401 // Fields must be private
namespace Squidex.Domain.Apps.Core.Operations.HandleRules.Triggers namespace Squidex.Domain.Apps.Core.Operations.HandleRules.Triggers
{ {
public class ContentChangedTriggerTests public class ContentChangedTriggerTests
@ -28,28 +30,22 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules.Triggers
private static readonly NamedId<Guid> SchemaMatch = new NamedId<Guid>(Guid.NewGuid(), "my-schema1"); private static readonly NamedId<Guid> SchemaMatch = new NamedId<Guid>(Guid.NewGuid(), "my-schema1");
private static readonly NamedId<Guid> SchemaNonMatch = new NamedId<Guid>(Guid.NewGuid(), "my-schema2"); private static readonly NamedId<Guid> SchemaNonMatch = new NamedId<Guid>(Guid.NewGuid(), "my-schema2");
public static IEnumerable<object[]> TestData public static IEnumerable<object[]> TestData = new[]
{ {
get new object[] { 0, 1, 1, 1, 1, new RuleCreated() },
{ new object[] { 0, 1, 1, 1, 1, new ContentCreated { SchemaId = SchemaNonMatch } },
return new[] new object[] { 1, 1, 0, 0, 0, new ContentCreated { SchemaId = SchemaMatch } },
{ new object[] { 0, 0, 0, 0, 0, new ContentCreated { SchemaId = SchemaMatch } },
new object[] { 0, 1, 1, 1, 1, new RuleCreated() }, new object[] { 1, 0, 1, 0, 0, new ContentUpdated { SchemaId = SchemaMatch } },
new object[] { 0, 1, 1, 1, 1, new ContentCreated { SchemaId = SchemaNonMatch } }, new object[] { 0, 0, 0, 0, 0, new ContentUpdated { SchemaId = SchemaMatch } },
new object[] { 1, 1, 0, 0, 0, new ContentCreated { SchemaId = SchemaMatch } }, new object[] { 1, 0, 0, 1, 0, new ContentDeleted { SchemaId = SchemaMatch } },
new object[] { 0, 0, 0, 0, 0, new ContentCreated { SchemaId = SchemaMatch } }, new object[] { 0, 0, 0, 0, 0, new ContentDeleted { SchemaId = SchemaMatch } },
new object[] { 1, 0, 1, 0, 0, new ContentUpdated { SchemaId = SchemaMatch } }, new object[] { 1, 0, 0, 0, 1, new ContentStatusChanged { SchemaId = SchemaMatch, Status = Status.Published } },
new object[] { 0, 0, 0, 0, 0, new ContentUpdated { SchemaId = SchemaMatch } }, new object[] { 0, 0, 0, 0, 0, new ContentStatusChanged { SchemaId = SchemaMatch, Status = Status.Published } },
new object[] { 1, 0, 0, 1, 0, new ContentDeleted { SchemaId = SchemaMatch } }, new object[] { 0, 1, 1, 1, 1, new ContentStatusChanged { SchemaId = SchemaMatch, Status = Status.Archived } },
new object[] { 0, 0, 0, 0, 0, new ContentDeleted { SchemaId = SchemaMatch } }, new object[] { 0, 1, 1, 1, 1, new ContentStatusChanged { SchemaId = SchemaMatch, Status = Status.Draft } },
new object[] { 1, 0, 0, 0, 1, new ContentStatusChanged { SchemaId = SchemaMatch, Status = Status.Published } }, new object[] { 0, 1, 1, 1, 1, new SchemaCreated { SchemaId = SchemaNonMatch } }
new object[] { 0, 0, 0, 0, 0, new ContentStatusChanged { SchemaId = SchemaMatch, Status = Status.Published } }, };
new object[] { 0, 1, 1, 1, 1, new ContentStatusChanged { SchemaId = SchemaMatch, Status = Status.Archived } },
new object[] { 0, 1, 1, 1, 1, new ContentStatusChanged { SchemaId = SchemaMatch, Status = Status.Draft } },
new object[] { 0, 1, 1, 1, 1, new SchemaCreated { SchemaId = SchemaNonMatch } }
};
}
}
[Fact] [Fact]
public void Should_return_false_when_trigger_contains_no_schemas() public void Should_return_false_when_trigger_contains_no_schemas()

146
tests/Squidex.Domain.Apps.Entities.Tests/Contents/ContentQueryServiceTests.cs
View File

@ -11,6 +11,7 @@ using System.Linq;
using System.Security.Claims; using System.Security.Claims;
using System.Threading.Tasks; using System.Threading.Tasks;
using FakeItEasy; using FakeItEasy;
using Microsoft.OData;
using Microsoft.OData.UriParser; using Microsoft.OData.UriParser;
using Squidex.Domain.Apps.Core.Apps; using Squidex.Domain.Apps.Core.Apps;
using Squidex.Domain.Apps.Core.Contents; using Squidex.Domain.Apps.Core.Contents;
@ -24,6 +25,8 @@ using Squidex.Infrastructure;
using Squidex.Infrastructure.Security; using Squidex.Infrastructure.Security;
using Xunit; using Xunit;
#pragma warning disable SA1401 // Fields must be private
namespace Squidex.Domain.Apps.Entities.Contents namespace Squidex.Domain.Apps.Entities.Contents
{ {
public class ContentQueryServiceTests public class ContentQueryServiceTests
@ -56,6 +59,7 @@ namespace Squidex.Domain.Apps.Entities.Contents
A.CallTo(() => content.Id).Returns(contentId); A.CallTo(() => content.Id).Returns(contentId);
A.CallTo(() => content.Data).Returns(contentData); A.CallTo(() => content.Data).Returns(contentData);
A.CallTo(() => content.DataDraft).Returns(contentData);
A.CallTo(() => content.Status).Returns(Status.Published); A.CallTo(() => content.Status).Returns(Status.Published);
A.CallTo(() => schema.SchemaDef).Returns(new Schema("my-schema")); A.CallTo(() => schema.SchemaDef).Returns(new Schema("my-schema"));
@ -95,11 +99,29 @@ namespace Squidex.Domain.Apps.Entities.Contents
} }
[Fact] [Fact]
public async Task Should_return_content_from_repository_and_transform() public async Task Should_throw_if_schema_not_found_in_check()
{
A.CallTo(() => appProvider.GetSchemaAsync(appId, "my-schema"))
.Returns((ISchemaEntity)null);
await Assert.ThrowsAsync<DomainObjectNotFoundException>(() => sut.ThrowIfSchemaNotExistsAsync(app, "my-schema"));
}
public static IEnumerable<object[]> SingleRequestData = new[]
{ {
new object[] { true, new[] { Status.Archived, Status.Draft, Status.Published } },
new object[] { false, new[] { Status.Published } }
};
[Theory]
[MemberData(nameof(SingleRequestData))]
public async Task Should_return_content_from_repository_and_transform(bool isFrontend, params Status[] status)
{
SetupClaims(isFrontend);
A.CallTo(() => appProvider.GetSchemaAsync(appId, schemaId, false)) A.CallTo(() => appProvider.GetSchemaAsync(appId, schemaId, false))
.Returns(schema); .Returns(schema);
A.CallTo(() => contentRepository.FindContentAsync(app, schema, A<Status[]>.Ignored, contentId)) A.CallTo(() => contentRepository.FindContentAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), contentId))
.Returns(content); .Returns(content);
A.CallTo(() => schema.ScriptQuery) A.CallTo(() => schema.ScriptQuery)
@ -146,66 +168,38 @@ namespace Squidex.Domain.Apps.Entities.Contents
await Assert.ThrowsAsync<DomainObjectNotFoundException>(async () => await sut.FindContentAsync(app, schemaId.ToString(), user, contentId)); await Assert.ThrowsAsync<DomainObjectNotFoundException>(async () => await sut.FindContentAsync(app, schemaId.ToString(), user, contentId));
} }
[Fact] public static IEnumerable<object[]> ManyRequestData = new[]
public async Task Should_return_contents_with_ids_from_repository()
{ {
await TestManyIdRequest(true, false, new HashSet<Guid> { Guid.NewGuid() }, Status.Draft, Status.Published); new object[] { 5, 200, false, true, new[] { Status.Published } },
} new object[] { 5, 200, false, false, new[] { Status.Published } },
new object[] { 5, 200, true, false, new[] { Status.Draft, Status.Published } },
[Fact] new object[] { 5, 200, true, true, new[] { Status.Archived } }
public async Task Should_return_contents_with_ids_from_repository_and_transform_as_non_frontend() };
{
await TestManyIdRequest(false, false, new HashSet<Guid> { Guid.NewGuid() }, Status.Published); [Theory]
} [MemberData(nameof(ManyRequestData))]
public async Task Should_query_contents_by_query_from_repository_and_transform(int count, int total, bool isFrontend, bool archive, params Status[] status)
[Fact]
public async Task Should_return_non_archived_contents_from_repository()
{
await TestManyRequest(true, false, Status.Draft, Status.Published);
}
[Fact]
public async Task Should_return_non_archived_contents_from_repository_and_transform_as_non_frontend()
{
await TestManyRequest(false, false, Status.Published);
}
[Fact]
public async Task Should_return_archived_contents_from_repository()
{
await TestManyRequest(true, true, Status.Archived);
}
[Fact]
public async Task Should_return_draft_contents_from_repository()
{
await TestManyRequest(false, false, Status.Published);
}
[Fact]
public async Task Should_return_draft_contents_from_repository_and_transform_when_requesting_archive_as_non_frontend()
{
await TestManyRequest(false, true, Status.Published);
}
private async Task TestManyRequest(bool isFrontend, bool archive, params Status[] status)
{ {
SetupClaims(isFrontend); SetupClaims(isFrontend);
SetupFakeWithOdataQuery(status);
SetupFakeWithScripting(); SetupFakeWithScripting();
A.CallTo(() => appProvider.GetSchemaAsync(appId, schemaId, false))
.Returns(schema);
A.CallTo(() => contentRepository.QueryAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), A<ODataUriParser>.Ignored))
.Returns(ResultList.Create(Enumerable.Repeat(content, count), total));
var result = await sut.QueryAsync(app, schemaId.ToString(), user, archive, string.Empty); var result = await sut.QueryAsync(app, schemaId.ToString(), user, archive, string.Empty);
Assert.Equal(contentData, result[0].Data); Assert.Equal(contentData, result[0].Data);
Assert.Equal(content.Id, result[0].Id); Assert.Equal(content.Id, result[0].Id);
Assert.Equal(123, result.Total); Assert.Equal(total, result.Total);
if (!isFrontend) if (!isFrontend)
{ {
A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.Ignored, A<string>.Ignored)) A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.Ignored, A<string>.Ignored))
.MustHaveHappened(Repeated.Exactly.Times(result.Count)); .MustHaveHappened(Repeated.Exactly.Times(count));
} }
else else
{ {
@ -214,24 +208,52 @@ namespace Squidex.Domain.Apps.Entities.Contents
} }
} }
private async Task TestManyIdRequest(bool isFrontend, bool archive, HashSet<Guid> ids, params Status[] status) [Fact]
public Task Should_throw_if_query_is_invalid()
{ {
SetupClaims(isFrontend); A.CallTo(() => appProvider.GetSchemaAsync(appId, schemaId, false))
.Returns(schema);
A.CallTo(() => modelBuilder.BuildEdmModel(schema, app))
.Throws(new ODataException());
SetupFakeWithIdQuery(status, ids); return Assert.ThrowsAsync<ValidationException>(() => sut.QueryAsync(app, schemaId.ToString(), user, false, "query"));
}
public static IEnumerable<object[]> ManyIdRequestData = new[]
{
new object[] { 5, 200, false, true, new[] { Status.Published } },
new object[] { 5, 200, false, false, new[] { Status.Published } },
new object[] { 5, 200, true, false, new[] { Status.Draft, Status.Published } },
new object[] { 5, 200, true, true, new[] { Status.Archived } }
};
[Theory]
[MemberData(nameof(ManyIdRequestData))]
public async Task Should_query_contents_by_id_from_repository_and_transform(int count, int total, bool isFrontend, bool archive, params Status[] status)
{
var ids = new HashSet<Guid>(Enumerable.Range(0, count).Select(x => Guid.NewGuid()));
SetupClaims(isFrontend);
SetupFakeWithScripting(); SetupFakeWithScripting();
A.CallTo(() => appProvider.GetSchemaAsync(appId, schemaId, false))
.Returns(schema);
A.CallTo(() => contentRepository.QueryAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), ids))
.Returns(ResultList.Create(Enumerable.Repeat(content, count), total));
var result = await sut.QueryAsync(app, schemaId.ToString(), user, archive, ids); var result = await sut.QueryAsync(app, schemaId.ToString(), user, archive, ids);
Assert.Equal(contentData, result[0].Data); Assert.Equal(contentData, result[0].Data);
Assert.Equal(content.Id, result[0].Id); Assert.Equal(content.Id, result[0].Id);
Assert.Equal(123, result.Total); Assert.Equal(total, result.Total);
if (!isFrontend) if (!isFrontend)
{ {
A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.Ignored, A<string>.Ignored)) A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.Ignored, A<string>.Ignored))
.MustHaveHappened(Repeated.Exactly.Times(result.Count)); .MustHaveHappened(Repeated.Exactly.Times(count));
} }
else else
{ {
@ -248,24 +270,6 @@ namespace Squidex.Domain.Apps.Entities.Contents
} }
} }
private void SetupFakeWithIdQuery(Status[] status, HashSet<Guid> ids)
{
A.CallTo(() => appProvider.GetSchemaAsync(appId, schemaId, false))
.Returns(schema);
A.CallTo(() => contentRepository.QueryAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), ids))
.Returns(ResultList.Create(Enumerable.Repeat(content, 1), 123));
}
private void SetupFakeWithOdataQuery(Status[] status)
{
A.CallTo(() => appProvider.GetSchemaAsync(appId, schemaId, false))
.Returns(schema);
A.CallTo(() => contentRepository.QueryAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), A<ODataUriParser>.Ignored))
.Returns(ResultList.Create(Enumerable.Repeat(content, 1), 123));
}
private void SetupFakeWithScripting() private void SetupFakeWithScripting()
{ {
A.CallTo(() => schema.ScriptQuery) A.CallTo(() => schema.ScriptQuery)

Write Preview
Loading…
Cancel
Save