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