public async Task Should_make_multiple_queries()
{
var assetId1 = Guid.NewGuid();
var assetId2 = Guid.NewGuid();
var asset1 = CreateAsset(assetId1);
var asset2 = CreateAsset(assetId2);
var query1 = @"
query {
findAsset(id: ""<ID>"") {
id
}
}".Replace("<ID>", assetId1.ToString());
var query2 = @"
query {
findAsset(id: ""<ID>"") {
id
}
}".Replace("<ID>", assetId2.ToString());
A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), MatchIdQuery(assetId1)))
.Returns(ResultList.CreateFrom(0, asset1));
A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), MatchIdQuery(assetId2)))
.Returns(ResultList.CreateFrom(0, asset2));
var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query1 }, new GraphQLQuery { Query = query2 });
var expected = new object[]
{
new
{
data = new
{
findAsset = new
{
id = asset1.Id
}
}
},
new
{
data = new
{
findAsset = new
{
id = asset2.Id
}
}
}
};
AssertResult(expected, result);
}
public async Task Should_query_all()
{
var users = ResultList.CreateFrom(0, A.Fake <IUser>());
A.CallTo(() => userService.QueryAsync(null, int.MaxValue, 0, ct))
.Returns(users);
var result = await sut.QueryAllAsync(ct);
Assert.Single(result);
}
public async Task Should_also_fetch_referenced_contents_from_flat_data_if_field_is_included_in_query()
{
var contentRefId = DomainId.NewGuid();
var contentRef = TestContent.CreateRef(TestSchemas.Ref1Id, contentRefId, "schemaRef1Field", "ref1");
var contentId = DomainId.NewGuid();
var content = TestContent.Create(contentId, contentRefId);
var query = CreateQuery(@"
query {
findMySchemaContent(id: '<ID>') {
id
flatData {
myReferences {
id
}
}
}
}", contentId);
A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(),
A <Q> .That.HasIdsWithoutTotal(contentRefId), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(0, contentRef));
A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(),
A <Q> .That.HasIdsWithoutTotal(contentId), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(1, content));
var result = await ExecuteAsync(new ExecutionOptions { Query = query });
var expected = new
{
data = new
{
findMySchemaContent = new
{
id = content.Id,
flatData = new
{
myReferences = new[]
{
new
{
id = contentRefId
}
}
}
}
}
};
AssertResult(expected, result);
}
public async Task Should_query_asset_folders_with_appId()
{
var parentId = DomainId.NewGuid();
var assetFolders = ResultList.CreateFrom <IAssetFolderEntity>(10);
A.CallTo(() => assetFolderRepository.QueryAsync(appId.Id, parentId, A <CancellationToken> ._))
.Returns(assetFolders);
var result = await sut.QueryAssetFoldersAsync(appId.Id, parentId);
Assert.Same(assetFolders, result);
}
public async Task Should_load_assets_folders_from_repository()
{
var parentId = Guid.NewGuid();
var assetFolders = ResultList.CreateFrom <IAssetFolderEntity>(10);
A.CallTo(() => assetFolderRepository.QueryAsync(appId.Id, parentId))
.Returns(assetFolders);
var result = await sut.QueryAssetFoldersAsync(requestContext, parentId);
Assert.Same(assetFolders, result);
}
public async Task Should_query_by_ids()
{
var ids = new[] { "1", "2" };
var users = ResultList.CreateFrom(0, A.Fake <IUser>());
A.CallTo(() => userService.QueryAsync(ids))
.Returns(users);
var result = await sut.QueryManyAsync(ids);
Assert.Single(result);
}
public async Task Should_query_many_by_email()
{
var email = "*****@*****.**";
var users = ResultList.CreateFrom(0, A.Fake <IUser>());
A.CallTo(() => userService.QueryAsync(email, 10, 0))
.Returns(users);
var result = await sut.QueryByEmailAsync(email);
Assert.Single(result);
}
public async Task Should_not_enrich_if_content_has_more_items()
{
var ref1_1 = CreateRefContent(DomainId.NewGuid(), 1, "ref1_1", 13, refSchemaId1);
var ref1_2 = CreateRefContent(DomainId.NewGuid(), 2, "ref1_2", 17, refSchemaId1);
var ref2_1 = CreateRefContent(DomainId.NewGuid(), 3, "ref2_1", 23, refSchemaId2);
var ref2_2 = CreateRefContent(DomainId.NewGuid(), 4, "ref2_2", 29, refSchemaId2);
var contents = new[]
{
CreateContent(new[] { ref1_1.Id }, new[] { ref2_1.Id, ref2_2.Id }),
CreateContent(new[] { ref1_2.Id }, new[] { ref2_1.Id, ref2_2.Id })
};
A.CallTo(() => contentQuery.QueryAsync(
A <Context> .That.Matches(x => x.ShouldSkipContentEnrichment() && x.ShouldSkipTotal()), A <Q> .That.HasIds(ref1_1.Id, ref1_2.Id, ref2_1.Id, ref2_2.Id), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(4, ref1_1, ref1_2, ref2_1, ref2_2));
await sut.EnrichAsync(requestContext, contents, schemaProvider, default);
Assert.Equal(
new ContentData()
.AddField("ref1",
new ContentFieldData()
.AddInvariant(
JsonValue.Object()
.Add("en", "ref1_1, 13")
.Add("de", "ref1_1, 13")))
.AddField("ref2",
new ContentFieldData()
.AddInvariant(
JsonValue.Object()
.Add("en", "2 Reference(s)")
.Add("de", "2 Reference(s)"))),
contents[0].ReferenceData);
Assert.Equal(
new ContentData()
.AddField("ref1",
new ContentFieldData()
.AddInvariant(
JsonValue.Object()
.Add("en", "ref1_2, 17")
.Add("de", "ref1_2, 17")))
.AddField("ref2",
new ContentFieldData()
.AddInvariant(
JsonValue.Object()
.Add("en", "2 Reference(s)")
.Add("de", "2 Reference(s)"))),
contents[1].ReferenceData);
}
public async Task Should_enrich_with_reference_data()
{
var ref1_1 = CreateRefContent(Guid.NewGuid(), "ref1_1", 13);
var ref1_2 = CreateRefContent(Guid.NewGuid(), "ref1_2", 17);
var ref2_1 = CreateRefContent(Guid.NewGuid(), "ref2_1", 23);
var ref2_2 = CreateRefContent(Guid.NewGuid(), "ref2_2", 29);
var source = new IContentEntity[]
{
CreateContent(new Guid[] { ref1_1.Id }, new Guid[] { ref2_1.Id }),
CreateContent(new Guid[] { ref1_2.Id }, new Guid[] { ref2_2.Id })
};
A.CallTo(() => contentQuery.QueryAsync(A <Context> .Ignored, A <IReadOnlyList <Guid> > .That.Matches(x => x.Count == 4)))
.Returns(ResultList.CreateFrom(4, ref1_1, ref1_2, ref2_1, ref2_2));
var enriched = await sut.EnrichAsync(source, requestContext);
Assert.Equal(
new NamedContentData()
.AddField("ref1",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref1_1, 13")
.Add("de", "ref1_1, 13")))
.AddField("ref2",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref2_1, 23")
.Add("de", "ref2_1, 23"))),
enriched.ElementAt(0).ReferenceData);
Assert.Equal(
new NamedContentData()
.AddField("ref1",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref1_2, 17")
.Add("de", "ref1_2, 17")))
.AddField("ref2",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref2_2, 29")
.Add("de", "ref2_2, 29"))),
enriched.ElementAt(1).ReferenceData);
}
public async Task Should_not_enrich_when_content_has_more_items()
{
var ref1_1 = CreateRefContent(Guid.NewGuid(), 1, "ref1_1", 13, refSchemaId1);
var ref1_2 = CreateRefContent(Guid.NewGuid(), 2, "ref1_2", 17, refSchemaId1);
var ref2_1 = CreateRefContent(Guid.NewGuid(), 3, "ref2_1", 23, refSchemaId2);
var ref2_2 = CreateRefContent(Guid.NewGuid(), 4, "ref2_2", 29, refSchemaId2);
var source = new IContentEntity[]
{
CreateContent(new[] { ref1_1.Id }, new[] { ref2_1.Id, ref2_2.Id }),
CreateContent(new[] { ref1_2.Id }, new[] { ref2_1.Id, ref2_2.Id })
};
A.CallTo(() => contentQuery.QueryAsync(A <Context> .That.Matches(x => x.IsNoEnrichment()), A <IReadOnlyList <Guid> > .That.Matches(x => x.Count == 4)))
.Returns(ResultList.CreateFrom(4, ref1_1, ref1_2, ref2_1, ref2_2));
var enriched = await sut.EnrichAsync(source, requestContext);
Assert.Equal(
new NamedContentData()
.AddField("ref1",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref1_1, 13")
.Add("de", "ref1_1, 13")))
.AddField("ref2",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "2 Reference(s)")
.Add("de", "2 Reference(s)"))),
enriched.ElementAt(0).ReferenceData);
Assert.Equal(
new NamedContentData()
.AddField("ref1",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref1_2, 17")
.Add("de", "ref1_2, 17")))
.AddField("ref2",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "2 Reference(s)")
.Add("de", "2 Reference(s)"))),
enriched.ElementAt(1).ReferenceData);
}
public async Task Should_enrich_with_reference_data()
{
var ref1_1 = CreateRefContent(DomainId.NewGuid(), 1, "ref1_1", 13, refSchemaId1);
var ref1_2 = CreateRefContent(DomainId.NewGuid(), 2, "ref1_2", 17, refSchemaId1);
var ref2_1 = CreateRefContent(DomainId.NewGuid(), 3, "ref2_1", 23, refSchemaId2);
var ref2_2 = CreateRefContent(DomainId.NewGuid(), 3, "ref2_2", 29, refSchemaId2);
var contents = new[]
{
CreateContent(new[] { ref1_1.Id }, new[] { ref2_1.Id }),
CreateContent(new[] { ref1_2.Id }, new[] { ref2_2.Id })
};
A.CallTo(() => contentQuery.QueryAsync(A <Context> .That.Matches(x => !x.ShouldEnrichContent()), A <Q> .That.HasIds(ref1_1.Id, ref1_2.Id, ref2_1.Id, ref2_2.Id)))
.Returns(ResultList.CreateFrom(4, ref1_1, ref1_2, ref2_1, ref2_2));
await sut.EnrichAsync(requestContext, contents, schemaProvider);
Assert.Equal(
new ContentData()
.AddField("ref1",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref1_1, 13")
.Add("de", "ref1_1, 13")))
.AddField("ref2",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref2_1, 23")
.Add("de", "ref2_1, 23"))),
contents[0].ReferenceData);
Assert.Equal(
new ContentData()
.AddField("ref1",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref1_2, 17")
.Add("de", "ref1_2, 17")))
.AddField("ref2",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref2_2, 29")
.Add("de", "ref2_2, 29"))),
contents[1].ReferenceData);
}
public async Task Should_not_enrich_when_content_has_more_items()
{
var ref1_1 = CreateRefContent(DomainId.NewGuid(), 1, "ref1_1", 13, refSchemaId1);
var ref1_2 = CreateRefContent(DomainId.NewGuid(), 2, "ref1_2", 17, refSchemaId1);
var ref2_1 = CreateRefContent(DomainId.NewGuid(), 3, "ref2_1", 23, refSchemaId2);
var ref2_2 = CreateRefContent(DomainId.NewGuid(), 4, "ref2_2", 29, refSchemaId2);
var contents = new[]
{
CreateContent(new[] { ref1_1.Id }, new[] { ref2_1.Id, ref2_2.Id }),
CreateContent(new[] { ref1_2.Id }, new[] { ref2_1.Id, ref2_2.Id })
};
A.CallTo(() => contentQuery.QueryAsync(A <Context> .That.Matches(x => !x.ShouldEnrichContent()), A <IReadOnlyList <DomainId> > .That.Matches(x => x.Count == 4)))
.Returns(ResultList.CreateFrom(4, ref1_1, ref1_2, ref2_1, ref2_2));
await sut.EnrichAsync(requestContext, contents, schemaProvider);
Assert.Equal(
new NamedContentData()
.AddField("ref1",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref1_1, 13")
.Add("de", "ref1_1, 13")))
.AddField("ref2",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "2 Reference(s)")
.Add("de", "2 Reference(s)"))),
contents[0].ReferenceData);
Assert.Equal(
new NamedContentData()
.AddField("ref1",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "ref1_2, 17")
.Add("de", "ref1_2, 17")))
.AddField("ref2",
new ContentFieldData()
.AddJsonValue("iv",
JsonValue.Object()
.Add("en", "2 Reference(s)")
.Add("de", "2 Reference(s)"))),
contents[1].ReferenceData);
}
public async Task Should_also_fetch_references_contents_if_field_is_included_in_query()
{
var contentRefId = DomainId.NewGuid();
var contentRef = TestContent.CreateRef(TestSchemas.Ref1Id, contentRefId, "ref1-field", "ref1");
var contentId = DomainId.NewGuid();
var content = TestContent.Create(contentId, contentRefId);
var query = CreateQuery(@"
query {
findMySchemaContent(id: '<ID>') {
id
referencesMyRefSchema1Contents(top: 30, skip: 5) {
id
}
}
}", contentId);
A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(),
A <Q> .That.HasIdsWithoutTotal(contentId), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(1, content));
A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), contentRef.SchemaId.Id.ToString(),
A <Q> .That.Matches(x => x.QueryAsOdata == "?$top=30&$skip=5" && x.Referencing == contentId && x.NoTotal), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(1, contentRef));
var result = await ExecuteAsync(new ExecutionOptions { Query = query });
var expected = new
{
data = new
{
findMySchemaContent = new
{
id = contentId,
referencesMyRefSchema1Contents = new[]
{
new
{
id = contentRefId
}
}
}
}
};
AssertResult(expected, result);
}
public async Task <IResultList <IContentEntity> > QueryAsync(IAppEntity app, ISchemaEntity schema, Q q, SearchScope scope)
{
Guard.NotNull(app, nameof(app));
Guard.NotNull(schema, nameof(schema));
Guard.NotNull(q, nameof(q));
try
{
var query = q.Query.AdjustToModel(schema.SchemaDef);
List <DomainId>?fullTextIds = null;
if (!string.IsNullOrWhiteSpace(query.FullText))
{
var searchFilter = SearchFilter.ShouldHaveSchemas(schema.Id);
fullTextIds = await indexer.SearchAsync(query.FullText, app, searchFilter, scope);
if (fullTextIds?.Count == 0)
{
return(ResultList.CreateFrom <IContentEntity>(0));
}
}
var filter = CreateFilter(schema.AppId.Id, Enumerable.Repeat(schema.Id, 1), fullTextIds, query, q.Reference);
var contentCount = Collection.Find(filter).CountDocumentsAsync();
var contentItems = FindContentsAsync(query, filter);
var(items, total) = await AsyncHelper.WhenAll(contentItems, contentCount);
foreach (var entity in items)
{
entity.ParseData(schema.SchemaDef, DataConverter);
}
return(ResultList.Create <IContentEntity>(total, items));
}
catch (MongoCommandException ex) when(ex.Code == 96)
{
throw new DomainException(T.Get("common.resultTooLarge"));
}
catch (MongoQueryException ex) when(ex.Message.Contains("17406"))
{
throw new DomainException(T.Get("common.resultTooLarge"));
}
}
public async Task <IResultList <IContentEntity> > DoAsync(IAppEntity app, ISchemaEntity schema, ClrQuery query, SearchScope scope)
{
Guard.NotNull(app, nameof(app));
Guard.NotNull(schema, nameof(schema));
Guard.NotNull(query, nameof(query));
try
{
query = query.AdjustToModel(schema.SchemaDef);
List <Guid>?fullTextIds = null;
if (!string.IsNullOrWhiteSpace(query.FullText))
{
var searchFilter = SearchFilter.ShouldHaveSchemas(schema.Id);
fullTextIds = await indexer.SearchAsync(query.FullText, app, searchFilter, scope);
if (fullTextIds?.Count == 0)
{
return(ResultList.CreateFrom <IContentEntity>(0));
}
}
var filter = CreateFilter(schema.Id, fullTextIds, query);
var contentCount = Collection.Find(filter).CountDocumentsAsync();
var contentItems = FindContentsAsync(query, filter);
await Task.WhenAll(contentItems, contentCount);
foreach (var entity in contentItems.Result)
{
entity.ParseData(schema.SchemaDef, converter);
}
return(ResultList.Create <IContentEntity>(contentCount.Result, contentItems.Result));
}
catch (MongoCommandException ex) when(ex.Code == 96)
{
throw new DomainException("Result set is too large to be retrieved. Use $take parameter to reduce the number of items.");
}
catch (MongoQueryException ex) when(ex.Message.Contains("17406"))
{
throw new DomainException("Result set is too large to be retrieved. Use $take parameter to reduce the number of items.");
}
}
public async Task Should_upsert_content_with_with_resolved_ids()
{
var requestContext = SetupContext(Permissions.AppContentsUpsert);
var(_, data, query) = CreateTestData(true);
var id1 = DomainId.NewGuid();
var id2 = DomainId.NewGuid();
A.CallTo(() => contentQuery.QueryAsync(requestContext, A <string> ._, A <Q> .That.Matches(x => x.JsonQuery == query)))
.Returns(ResultList.CreateFrom(2,
CreateContent(id1),
CreateContent(id2)));
var command = BulkCommand(BulkUpdateType.Upsert, query: query, data: data);
command.Jobs ![0].ExpectedCount = 2;
public async Task <IResultList <IUser> > QueryAsync(IEnumerable <string> ids)
{
Guard.NotNull(ids, nameof(ids));
ids = ids.Where(userFactory.IsId);
if (!ids.Any())
{
return(ResultList.CreateFrom <IUser>(0));
}
var users = userManager.Users.Where(x => ids.Contains(x.Id)).ToList();
var resolved = await ResolveAsync(users);
return(ResultList.Create(users.Count, resolved));
}
public async Task Should_throw_exception_when_query_resolves_multiple_contents()
{
var requestContext = SetupContext(Permissions.AppContentsUpdateOwn);
var(id, _, query) = CreateTestData(true);
A.CallTo(() => contentQuery.QueryAsync(requestContext, A <string> ._, A <Q> .That.Matches(x => x.JsonQuery == query)))
.Returns(ResultList.CreateFrom(2, CreateContent(id), CreateContent(id)));
var command = BulkCommand(BulkUpdateType.ChangeStatus, query);
var result = await PublishAsync(command);
Assert.Single(result, x => x.JobIndex == 0 && x.ContentId == null && x.Exception is DomainException);
A.CallTo(() => commandBus.PublishAsync(A <ICommand> ._))
.MustNotHaveHappened();
}
public async Task Should_resolve_recursively()
{
var folder11 = CreateFolder("level1");
var folder21 = CreateFolder("level2");
A.CallTo(() => assetQuery.QueryAssetFoldersAsync(requestContext, DomainId.Empty))
.Returns(ResultList.CreateFrom(1, folder11));
A.CallTo(() => assetQuery.QueryAssetFoldersAsync(requestContext, folder11.Id))
.Returns(ResultList.CreateFrom(1, folder21));
var folderId2 = await sut.ResolveOrCreateAsync(requestContext, commandBus, "level1/level2");
Assert.Equal(folder21.Id, folderId2);
A.CallTo(() => commandBus.PublishAsync(A <ICommand> ._))
.MustNotHaveHappened();
}
public async Task <IResultList <IContentEntity> > QueryAsync(DomainId appId, List <ISchemaEntity> schemas, Q q,
CancellationToken ct)
{
Guard.NotNull(q, nameof(q));
if (q.ScheduledFrom == null || q.ScheduledTo == null)
{
return(ResultList.CreateFrom <IContentEntity>(0));
}
var filter = CreateFilter(appId, schemas.Select(x => x.Id), q.ScheduledFrom.Value, q.ScheduledTo.Value);
var contentEntities = await Collection.Find(filter).Limit(100).ToListAsync(ct);
var contentTotal = (long)contentEntities.Count;
return(ResultList.Create(contentTotal, contentEntities));
}
public async Task <IResultList <IContentEntity> > QueryAsync(IAppEntity app, ISchemaEntity schema, Status[] status, bool inDraft, Query query, bool includeDraft = true)
{
Guard.NotNull(app, nameof(app));
Guard.NotNull(schema, nameof(schema));
Guard.NotNull(query, nameof(query));
using (Profiler.TraceMethod <MongoContentRepository>("QueryAsyncByQuery"))
{
var fullTextIds = await indexer.SearchAsync(query.FullText, app, schema.Id, inDraft?Scope.Draft : Scope.Published);
if (fullTextIds?.Count == 0)
{
return(ResultList.CreateFrom <IContentEntity>(0));
}
return(await contents.QueryAsync(schema, query, fullTextIds, status, inDraft, includeDraft));
}
}
public async Task QueryAsync_should_return_contents(int isFrontend, int unpublished, SearchScope scope)
{
var ctx =
CreateContext(isFrontend: isFrontend == 1, allowSchema: true)
.WithUnpublished(unpublished == 1);
var content = CreateContent(contentId);
A.CallTo(() => contentRepository.QueryAsync(ctx.App, schema, A <ClrQuery> ._, scope))
.Returns(ResultList.CreateFrom(5, content));
var result = await sut.QueryAsync(ctx, schemaId.Name, Q.Empty);
Assert.Equal(contentData, result[0].Data);
Assert.Equal(contentId, result[0].Id);
Assert.Equal(5, result.Total);
}
public async Task Should_enrich_with_asset_urls()
{
var img1 = CreateAsset(DomainId.NewGuid(), 1, AssetType.Image, "Image1.png");
var img2 = CreateAsset(DomainId.NewGuid(), 2, AssetType.Unknown, "Image2.png", "image/svg+xml");
var doc1 = CreateAsset(DomainId.NewGuid(), 3, AssetType.Unknown, "Document1.png");
var doc2 = CreateAsset(DomainId.NewGuid(), 4, AssetType.Unknown, "Document2.png", "image/svg+xml", 20_000);
var contents = new[]
{
CreateContent(
new[] { img1.Id },
new[] { img2.Id, img1.Id }),
CreateContent(
new[] { doc1.Id },
new[] { doc2.Id, doc1.Id })
};
A.CallTo(() => assetQuery.QueryAsync(
A <Context> .That.Matches(x => x.ShouldSkipAssetEnrichment() && x.ShouldSkipTotal()), null, A <Q> .That.HasIds(doc1.Id, doc2.Id, img1.Id, img2.Id), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(4, img1, img2, doc1, doc2));
await sut.EnrichAsync(requestContext, contents, schemaProvider, default);
Assert.Equal(
new ContentData()
.AddField("asset1",
new ContentFieldData()
.AddLocalized("iv", JsonValue.Array($"url/to/{img1.Id}", img1.FileName)))
.AddField("asset2",
new ContentFieldData()
.AddLocalized("en", JsonValue.Array($"url/to/{img2.Id}", img2.FileName))),
contents[0].ReferenceData);
Assert.Equal(
new ContentData()
.AddField("asset1",
new ContentFieldData()
.AddLocalized("iv", JsonValue.Array(doc1.FileName)))
.AddField("asset2",
new ContentFieldData()
.AddLocalized("en", JsonValue.Array(doc2.FileName))),
contents[1].ReferenceData);
}
public async Task Should_resolve_references_in_loop()
{
var referenceId1 = DomainId.NewGuid();
var reference1 = CreateReference(referenceId1, 1);
var referenceId2 = DomainId.NewGuid();
var reference2 = CreateReference(referenceId1, 2);
var @event = new EnrichedContentEvent
{
Data =
new NamedContentData()
.AddField("references",
new ContentFieldData()
.AddJsonValue(JsonValue.Array(referenceId1, referenceId2))),
AppId = appId
};
A.CallTo(() => contentQuery.QueryAsync(A <Context> ._, A <IReadOnlyList <DomainId> > .That.Contains(referenceId1)))
.Returns(ResultList.CreateFrom(1, reference1));
A.CallTo(() => contentQuery.QueryAsync(A <Context> ._, A <IReadOnlyList <DomainId> > .That.Contains(referenceId2)))
.Returns(ResultList.CreateFrom(1, reference2));
var vars = new TemplateVars
{
["event"] = @event
};
var template = @"
{% for id in event.data.references.iv %}
{% reference 'ref', id %}
Text: {{ ref.data.field1.iv }} {{ ref.data.field2.iv }}
{% endfor %}
";
var expected = @"
Text: Hello 1 World 1
Text: Hello 2 World 2
";
var result = await sut.RenderAsync(template, vars);
Assert.Equal(expected, result);
}
public async Task Should_resolve_references_in_loop_with_filter()
{
var referenceId1 = DomainId.NewGuid();
var reference1 = CreateReference(referenceId1, 1);
var referenceId2 = DomainId.NewGuid();
var reference2 = CreateReference(referenceId2, 2);
var @event = new EnrichedContentEvent
{
Data =
new ContentData()
.AddField("references",
new ContentFieldData()
.AddInvariant(JsonValue.Array(referenceId1, referenceId2))),
AppId = appId
};
A.CallTo(() => contentQuery.QueryAsync(A <Context> ._, A <Q> .That.HasIds(referenceId1), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(1, reference1));
A.CallTo(() => contentQuery.QueryAsync(A <Context> ._, A <Q> .That.HasIds(referenceId2), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(1, reference2));
var vars = new TemplateVars
{
["event"] = @event
};
var template = @"
{% for id in event.data.references.iv %}
{% assign ref = id | reference %}
Text: {{ ref.data.field1.iv }} {{ ref.data.field2.iv }} {{ ref.id }}
{% endfor %}
";
var expected = $@"
Text: Hello 1 World 1 {referenceId1}
Text: Hello 2 World 2 {referenceId2}
";
var result = await sut.RenderAsync(template, vars);
Assert.Equal(Cleanup(expected), Cleanup(result));
}
public async Task Should_resolve_references()
{
var referenceId1 = DomainId.NewGuid();
var reference1 = CreateReference(referenceId1, 1);
var referenceId2 = DomainId.NewGuid();
var reference2 = CreateReference(referenceId1, 2);
var user = new ClaimsPrincipal();
var data =
new ContentData()
.AddField("references",
new ContentFieldData()
.AddInvariant(JsonValue.Array(referenceId1, referenceId2)));
A.CallTo(() => contentQuery.QueryAsync(
A<Context>.That.Matches(x => x.App.Id == appId.Id && x.User == user), A<Q>.That.HasIds(referenceId1, referenceId2), A<CancellationToken>._))
.Returns(ResultList.CreateFrom(2, reference1, reference2));
var vars = new ScriptVars
{
["appId"] = appId.Id,
["data"] = data,
["dataOld"] = null,
["user"] = user
};
var expected = @"
Text: Hello 1 World 1
Text: Hello 2 World 2
";
var script = @"
getReferences(data.references.iv, function (references) {
var result1 = `Text: ${references[0].data.field1.iv} ${references[0].data.field2.iv}`;
var result2 = `Text: ${references[1].data.field1.iv} ${references[1].data.field2.iv}`;
complete(`${result1}\n${result2}`);
})";
var result = (await sut.ExecuteAsync(vars, script)).ToString();
Assert.Equal(Cleanup(expected), Cleanup(result));
}
public async Task <IResultList <IContentEntity> > QueryAsync(IAppEntity app, ISchemaEntity schema, Q q)
{
using (Profiler.TraceMethod <MongoContentRepository>())
{
if (q.Ids != null && q.Ids.Count > 0)
{
return(await queryByIds.QueryAsync(app.Id, new List <ISchemaEntity> {
schema
}, q));
}
if (q.Referencing == default)
{
return(await queryByQuery.QueryAsync(app, schema, q));
}
return(ResultList.CreateFrom <IContentEntity>(0));
}
}
public async Task Should_enrich_with_asset_urls()
{
var image1 = CreateAsset(DomainId.NewGuid(), 1, AssetType.Image, "Image1.png");
var image2 = CreateAsset(DomainId.NewGuid(), 2, AssetType.Image, "Image2.png");
var document1 = CreateAsset(DomainId.NewGuid(), 3, AssetType.Unknown, "Document1.png");
var document2 = CreateAsset(DomainId.NewGuid(), 4, AssetType.Unknown, "Document2.png");
var contents = new[]
{
CreateContent(
new[] { image1.Id },
new[] { image2.Id, image1.Id }),
CreateContent(
new[] { document1.Id },
new[] { document2.Id, document1.Id })
};
A.CallTo(() => assetQuery.QueryAsync(A <Context> .That.Matches(x => !x.ShouldEnrichAsset()), null, A <Q> .That.Matches(x => x.Ids.Count == 4)))
.Returns(ResultList.CreateFrom(4, image1, image2, document1, document2));
await sut.EnrichAsync(requestContext, contents, schemaProvider);
Assert.Equal(
new NamedContentData()
.AddField("asset1",
new ContentFieldData()
.AddValue("iv", JsonValue.Array($"url/to/{image1.Id}", image1.FileName)))
.AddField("asset2",
new ContentFieldData()
.AddValue("en", JsonValue.Array($"url/to/{image2.Id}", image2.FileName))),
contents[0].ReferenceData);
Assert.Equal(
new NamedContentData()
.AddField("asset1",
new ContentFieldData()
.AddValue("iv", JsonValue.Array(document1.FileName)))
.AddField("asset2",
new ContentFieldData()
.AddValue("en", JsonValue.Array(document2.FileName))),
contents[1].ReferenceData);
}
public async Task Should_query_assets_and_enrich_it()
{
var asset1 = CreateAsset(DomainId.NewGuid());
var asset2 = CreateAsset(DomainId.NewGuid());
var parentId = DomainId.NewGuid();
var q = Q.Empty.WithODataQuery("fileName eq 'Name'");
A.CallTo(() => assetRepository.QueryAsync(appId.Id, parentId, q, A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(8, asset1, asset2));
var result = await sut.QueryAsync(requestContext, parentId, q);
Assert.Equal(8, result.Total);
AssertAsset(asset1, result[0]);
AssertAsset(asset2, result[1]);
}
public async Task Should_query_contents(int isFrontend, int unpublished, SearchScope scope)
{
var requestContext = CreateContext(isFrontend, isUnpublished: unpublished);
var content1 = CreateContent(DomainId.NewGuid());
var content2 = CreateContent(DomainId.NewGuid());
var q = Q.Empty.WithReference(DomainId.NewGuid());
A.CallTo(() => contentRepository.QueryAsync(requestContext.App, schema, q, scope))
.Returns(ResultList.CreateFrom(5, content1, content2));
var result = await sut.QueryAsync(requestContext, schemaId.Name, q);
Assert.Equal(5, result.Total);
AssertContent(content1, result[0]);
AssertContent(content2, result[1]);
}
