public async Task Should_return_single_content_if_finding_content_with_version() { var contentId = DomainId.NewGuid(); var content = TestContent.Create(contentId); var query = CreateQuery(@" query { findMySchemaContent(id: '<ID>', version: 3) { <FIELDS_CONTENT> } }", contentId); A.CallTo(() => contentQuery.FindAsync(MatchsContentContext(), TestSchemas.Default.Id.ToString(), contentId, 3, A <CancellationToken> ._)) .Returns(content); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { findMySchemaContent = TestContent.Response(content) } }; AssertResult(expected, result); }
public async Task Should_cache_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 @cache(duration: 1000) { 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 result1 = await ExecuteAsync(new ExecutionOptions { Query = query }); var result2 = 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, result1); AssertResult(expected, result2); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIdsWithoutTotal(contentRefId), A <CancellationToken> ._)) .MustHaveHappenedOnceExactly(); }
public async Task Should_return_single_content_if_finding_content() { var contentId = DomainId.NewGuid(); var content = TestContent.Create(contentId); var query = CreateQuery(@" query { findMySchemaContent(id: '<ID>') { <FIELDS_CONTENT> } }", contentId); 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 = TestContent.Response(content) } }; AssertResult(expected, result); }
public async Task Should_return_multiple_contents_if_querying_contents() { var query = CreateQuery(@" query { queryMySchemaContents(top: 30, skip: 5) { <FIELDS_CONTENT> } }"); var contentId = DomainId.NewGuid(); var content = TestContent.Create(contentId); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), TestSchemas.Default.Id.ToString(), A <Q> .That.Matches(x => x.QueryAsOdata == "?$top=30&$skip=5" && x.NoTotal), A <CancellationToken> ._)) .Returns(ResultList.CreateFrom(0, content)); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { queryMySchemaContents = new[] { TestContent.Response(content) } } }; AssertResult(expected, result); }
public async Task Should_return_multiple_contents_when_querying_contents() { var query = CreateQuery(@" query { queryMySchemaContents(top: 30, skip: 5) { <FIELDS_CONTENT> } }"); var content = TestContent.Create(appId, schemaId, DomainId.NewGuid(), DomainId.Empty, DomainId.Empty); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), schemaId.Id.ToString(), A <Q> .That.Matches(x => x.ODataQuery == "?$top=30&$skip=5" && x.NoTotal == true))) .Returns(ResultList.CreateFrom(0, content)); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { queryMySchemaContents = new dynamic[] { TestContent.Response(content) } } }; AssertResult(expected, result); }
public async Task Should_also_fetch_referencing_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 { findMyRefSchema1Content(id: '<ID>') { id referencingMySchemaContents(top: 30, skip: 5) { id data { myLocalizedString { de_DE } } } } }", contentRefId); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIdsWithoutTotal(contentRefId), A <CancellationToken> ._)) .Returns(ResultList.CreateFrom(1, contentRef)); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), content.SchemaId.Id.ToString(), A <Q> .That.Matches(x => x.QueryAsOdata == "?$top=30&$skip=5" && x.Reference == contentRefId && x.NoTotal), A <CancellationToken> ._)) .Returns(ResultList.CreateFrom(1, content)); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { findMyRefSchema1Content = new { id = contentRefId, referencingMySchemaContents = new[] { new { id = contentId, data = new { myLocalizedString = new { de_DE = "de-DE" } } } } } } }; AssertResult(expected, result); }
public GraphQLMutationTests() { content = TestContent.Create(contentId, TestSchemas.Ref1.Id, TestSchemas.Ref2.Id, null); A.CallTo(() => commandBus.PublishAsync(A <ICommand> .Ignored)) .Returns(commandContext); }
public async Task Should_not_return_data_when_field_not_part_of_content() { var contentId = DomainId.NewGuid(); var content = TestContent.Create(appId, schemaId, contentId, DomainId.Empty, DomainId.Empty, new ContentData()); var query = @" query { findMySchemaContent(id: ""<ID>"") { id version created createdBy lastModified lastModifiedBy url data { myInvalid { iv } } } }".Replace("<ID>", contentId.ToString()); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIds(contentId))) .Returns(ResultList.CreateFrom(1, content)); var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query }); var json = serializer.Serialize(result); Assert.Contains("\"data\":null", json); }
public async Task Should_return_single_content_when_finding_content_with_version() { var contentId = DomainId.NewGuid(); var content = TestContent.Create(appId, schemaId, contentId, DomainId.Empty, DomainId.Empty); var query = @" query { findMySchemaContent(id: ""<ID>"", version: 3) { <FIELDS> } }".Replace("<FIELDS>", TestContent.AllFields).Replace("<ID>", contentId.ToString()); A.CallTo(() => contentQuery.FindAsync(MatchsContentContext(), schemaId.Id.ToString(), contentId, 3)) .Returns(content); var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query }); var expected = new { data = new { findMySchemaContent = TestContent.Response(content) } }; AssertResult(expected, result); }
public async Task Should_not_return_data_if_field_not_part_of_content() { var contentId = DomainId.NewGuid(); var content = TestContent.Create(contentId, data: new ContentData()); var query = CreateQuery(@" query { findMySchemaContent(id: '<ID>') { id version created createdBy lastModified lastModifiedBy url data { myInvalid { iv } } } }", contentId); 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 json = serializer.Serialize(result); Assert.Contains("\"errors\"", json, StringComparison.Ordinal); }
public async Task Should_return_multiple_contents_when_querying_contents() { var query = @" query { queryMySchemaContents(top: 30, skip: 5) { <FIELDS> } }".Replace("<FIELDS>", TestContent.AllFields); var content = TestContent.Create(appId, schemaId, DomainId.NewGuid(), DomainId.Empty, DomainId.Empty); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), schemaId.Id.ToString(), A <Q> .That.HasOData("?$top=30&$skip=5"))) .Returns(ResultList.CreateFrom(0, content)); var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query }); var expected = new { data = new { queryMySchemaContents = new dynamic[] { TestContent.Response(content) } } }; AssertResult(expected, result); }
public async Task Should_return_single_content_when_finding_content() { var contentId = DomainId.NewGuid(); var content = TestContent.Create(appId, schemaId, contentId, DomainId.Empty, DomainId.Empty); var query = @" query { findMySchemaContent(id: ""<ID>"") { <FIELDS> } }".Replace("<FIELDS>", TestContent.AllFields).Replace("<ID>", contentId.ToString()); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIdsWithoutTotal(contentId))) .Returns(ResultList.CreateFrom(1, content)); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { findMySchemaContent = TestContent.Response(content) } }; AssertResult(expected, result); }
public async Task Should_also_fetch_referencing_contents_when_field_is_included_in_query() { var contentRefId = DomainId.NewGuid(); var contentRef = TestContent.CreateRef(schemaRefId1, contentRefId, "ref1-field", "ref1"); var contentId = DomainId.NewGuid(); var content = TestContent.Create(appId, schemaId, contentId, contentRefId, DomainId.Empty); var query = @" query { findMyRefSchema1Content(id: ""<ID>"") { id referencingMySchemaContents(top: 30, skip: 5) { id data { myString { de } } } } }".Replace("<ID>", contentRefId.ToString()); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIdsWithoutTotal(contentRefId))) .Returns(ResultList.CreateFrom(1, contentRef)); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), content.SchemaId.Id.ToString(), A <Q> .That.Matches(x => x.ODataQuery == "?$top=30&$skip=5" && x.Reference == contentRefId && x.NoTotal == true))) .Returns(ResultList.CreateFrom(1, content)); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { findMyRefSchema1Content = new { id = contentRefId, referencingMySchemaContents = new[] { new { id = contentId, data = new { myString = new { de = "value" } } } } } } }; AssertResult(expected, result); }
public async Task Should_also_fetch_referencing_contents_when_field_is_included_in_query() { var contentRefId = DomainId.NewGuid(); var contentRef = TestContent.CreateRef(schemaRefId1, contentRefId, "ref1-field", "ref1"); var contentId = DomainId.NewGuid(); var content = TestContent.Create(appId, schemaId, contentId, contentRefId, DomainId.Empty); var query = @" query { findMyRefSchema1Content(id: ""<ID>"") { id referencingMySchemaContents(top: 30, skip: 5) { id data { myString { de } } } } }".Replace("<ID>", contentRefId.ToString()); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <IReadOnlyList <DomainId> > ._)) .Returns(ResultList.CreateFrom(0, contentRef)); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), schemaId.Id.ToString(), A <Q> .That.HasOData("?$top=30&$skip=5", contentRefId))) .Returns(ResultList.CreateFrom(1, content)); var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query }); var expected = new { data = new { findMyRefSchema1Content = new { id = contentRefId, referencingMySchemaContents = new[] { new { id = contentId, data = new { myString = new { de = "value" } } } } } } }; AssertResult(expected, result); }
public async Task Should_also_fetch_referenced_assets_if_field_is_included_in_query() { var assetRefId = DomainId.NewGuid(); var assetRef = TestAsset.Create(assetRefId); var contentId = DomainId.NewGuid(); var content = TestContent.Create(contentId, assetId: assetRefId); var query = CreateQuery(@" query { findMySchemaContent(id: '<ID>') { id data { myAssets { iv { id } } } } }", contentId); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIdsWithoutTotal(contentId), A <CancellationToken> ._)) .Returns(ResultList.CreateFrom(1, content)); A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), null, A <Q> .That.HasIdsWithoutTotal(assetRefId), A <CancellationToken> ._)) .Returns(ResultList.CreateFrom(0, assetRef)); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { findMySchemaContent = new { id = content.Id, data = new { myAssets = new { iv = new[] { new { id = assetRefId } } } } } } }; AssertResult(expected, result); }
public async Task Should_also_fetch_referenced_assets_when_field_is_included_in_query() { var assetRefId = DomainId.NewGuid(); var assetRef = TestAsset.Create(appId, assetRefId); var contentId = DomainId.NewGuid(); var content = TestContent.Create(appId, schemaId, contentId, DomainId.Empty, assetRefId); var query = @" query { findMySchemaContent(id: ""<ID>"") { id data { myAssets { iv { id } } } } }".Replace("<ID>", contentId.ToString()); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIds(contentId))) .Returns(ResultList.CreateFrom(1, content)); A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), null, A <Q> ._)) .Returns(ResultList.CreateFrom(0, assetRef)); var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query }); var expected = new { data = new { findMySchemaContent = new { id = content.Id, data = new { myAssets = new { iv = new[] { new { id = assetRefId } } } } } } }; AssertResult(expected, result); }
public async Task Should_return_multiple_contents_with_total_when_querying_contents_with_total() { var query = @" query { queryMySchemaContentsWithTotal(top: 30, skip: 5) { total items { <FIELDS> } } }".Replace("<FIELDS>", TestContent.AllFields); var content = TestContent.Create(appId, schemaId, DomainId.NewGuid(), DomainId.Empty, DomainId.Empty); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), schemaId.Id.ToString(), A <Q> .That.Matches(x => x.ODataQuery == "?$top=30&$skip=5" && x.NoTotal == false))) .Returns(ResultList.CreateFrom(10, content)); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { queryMySchemaContentsWithTotal = new { total = 10, items = new dynamic[] { TestContent.Response(content) } } } }; AssertResult(expected, result); }
public async Task Should_also_fetch_referenced_contents_when_field_is_included_in_query() { var contentRefId = DomainId.NewGuid(); var contentRef = TestContent.CreateRef(schemaRefId1, contentRefId, "ref1-field", "ref1"); var contentId = DomainId.NewGuid(); var content = TestContent.Create(schemaId, contentId, contentRefId, DomainId.Empty); var query = @" query { findMySchemaContent(id: ""<ID>"") { id data { myReferences { iv { id data { ref1Field { iv } } } } } } }".Replace("<ID>", contentId.ToString()); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <IReadOnlyList <DomainId> > ._)) .Returns(ResultList.CreateFrom(0, contentRef)); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), MatchId(contentId))) .Returns(ResultList.CreateFrom(1, content)); var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query }); var expected = new { data = new { findMySchemaContent = new { id = content.Id, data = new { myReferences = new { iv = new[] { new { id = contentRefId, data = new { ref1Field = new { iv = "ref1" } } } } } } } } }; AssertResult(expected, result); }
public async Task Should_also_fetch_union_contents_when_field_is_included_in_query() { var contentRefId = DomainId.NewGuid(); var contentRef = TestContent.CreateRef(schemaRefId1, contentRefId, "ref1-field", "ref1"); var contentId = DomainId.NewGuid(); var content = TestContent.Create(appId, schemaId, contentId, contentRefId, DomainId.Empty); var query = @" query { findMySchemaContent(id: ""<ID>"") { id data { myUnion { iv { ... on Content { id } ... on MyRefSchema1 { data { ref1Field { iv } } } __typename } } } } }".Replace("<ID>", contentId.ToString()); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> ._)) .Returns(ResultList.CreateFrom(0, contentRef)); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIds(contentId))) .Returns(ResultList.CreateFrom(1, content)); var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query }); var expected = new { data = new { findMySchemaContent = new { id = content.Id, data = new { myUnion = new { iv = new[] { new { id = contentRefId, data = new { ref1Field = new { iv = "ref1" } }, __typename = "MyRefSchema1" } } } } } } }; AssertResult(expected, result); }
public async Task Should_return_multiple_flat_contents_when_querying_contents() { const string query = @" query { queryMySchemaContents(top: 30, skip: 5) { id version created createdBy lastModified lastModifiedBy status statusColor url flatData { myString myNumber myBoolean myDatetime myJsonValue: myJson(path: ""value"") myJson myGeolocation myTags myLocalized myArray { nestedNumber nestedBoolean } } } }"; var content = TestContent.Create(appId, schemaId, DomainId.NewGuid(), DomainId.Empty, DomainId.Empty); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), schemaId.Id.ToString(), A <Q> .That.HasOData("?$top=30&$skip=5"))) .Returns(ResultList.CreateFrom(0, content)); var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query }); var expected = new { data = new { queryMySchemaContents = new dynamic[] { new { id = content.Id, version = 1, created = content.Created, createdBy = "subject:user1", lastModified = content.LastModified, lastModifiedBy = "subject:user2", status = "DRAFT", statusColor = "red", url = $"contents/my-schema/{content.Id}", flatData = new { myString = "value", myNumber = 1, myBoolean = true, myDatetime = content.LastModified, myJsonValue = 1, myJson = new { value = 1 }, myGeolocation = new { latitude = 10, longitude = 20 }, myTags = new[] { "tag1", "tag2" }, myLocalized = "de-DE", myArray = new[] { new { nestedNumber = 10, nestedBoolean = true }, new { nestedNumber = 20, nestedBoolean = false } } } } } } }; AssertResult(expected, result); }
public async Task Should_also_fetch_referenced_contents_when_field_is_included_in_query() { var contentRefId = DomainId.NewGuid(); var contentRef = TestContent.CreateRef(schemaRefId1, contentRefId, "ref1-field", "ref1"); var contentId = DomainId.NewGuid(); var content = TestContent.Create(appId, schemaId, contentId, contentRefId, DomainId.Empty); var query = @" query { findMySchemaContent(id: ""<ID>"") { id data { myReferences { iv { id data { ref1Field { iv } } } } } } }".Replace("<ID>", contentId.ToString()); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIdsWithoutTotal(contentRefId))) .Returns(ResultList.CreateFrom(0, contentRef)); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), A <Q> .That.HasIdsWithoutTotal(contentId))) .Returns(ResultList.CreateFrom(1, content)); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { findMySchemaContent = new { id = content.Id, data = new { myReferences = new { iv = new[] { new { id = contentRefId, data = new { ref1Field = new { iv = "ref1" } } } } } } } } }; AssertResult(expected, result); }
public async Task Should_return_multiple_flat_contents_if_querying_contents() { var query = CreateQuery(@" query { queryMySchemaContents(top: 30, skip: 5) { id version created createdBy lastModified lastModifiedBy status statusColor url flatData { myString myNumber myBoolean myDatetime myJsonValue: myJson(path: 'value') myJson myGeolocation myTags myLocalized myArray { nestedNumber nestedBoolean } } } }"); var content = TestContent.Create(appId, schemaId, DomainId.NewGuid(), DomainId.Empty, DomainId.Empty); A.CallTo(() => contentQuery.QueryAsync(MatchsContentContext(), schemaId.Id.ToString(), A <Q> .That.Matches(x => x.ODataQuery == "?$top=30&$skip=5" && x.NoTotal == true), A <CancellationToken> ._)) .Returns(ResultList.CreateFrom(0, content)); var result = await ExecuteAsync(new ExecutionOptions { Query = query }); var expected = new { data = new { queryMySchemaContents = new dynamic[] { new { id = content.Id, version = 1, created = content.Created, createdBy = "subject:user1", lastModified = content.LastModified, lastModifiedBy = "client:client1", status = "DRAFT", statusColor = "red", url = $"contents/my-schema/{content.Id}", flatData = new { myString = "value", myNumber = 1.0, myBoolean = true, myDatetime = content.LastModified.ToString(), myJsonValue = 1, myJson = new { value = 1 }, myGeolocation = new { latitude = 10, longitude = 20 }, myTags = new[] { "tag1", "tag2" }, myLocalized = "de-DE", myArray = new[] { new { nestedNumber = 10.0, nestedBoolean = true }, new { nestedNumber = 20.0, nestedBoolean = false } } } } } } }; AssertResult(expected, result); }
public async Task Should_also_fetch_union_contents_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 data { myUnion { iv { ... on Content { id } ... on MyRefSchema1 { data { schemaRef1Field { iv } } } __typename } } } } }", 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, data = new { myUnion = new { iv = new[] { new { id = contentRefId, data = new { schemaRef1Field = new { iv = "ref1" } }, __typename = "MyRefSchema1" } } } } } } }; AssertResult(expected, result); }