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