public async Task Should_return_multiple_assets_when_querying_assets()
{
var query = @"
query {
queryAssets(filter: ""my-query"", top: 30, skip: 5) {
<FIELDS>
}
}".Replace("<FIELDS>", TestAsset.AllFields);
var asset = TestAsset.Create(appId, DomainId.NewGuid());
A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), null, A <Q> .That.HasOData("?$top=30&$skip=5&$filter=my-query")))
.Returns(ResultList.CreateFrom(0, asset));
var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query });
var expected = new
{
data = new
{
queryAssets = new dynamic[]
{
TestAsset.Response(asset)
}
}
};
AssertResult(expected, result);
}
public async Task Should_return_single_asset_when_finding_asset()
{
var assetId = DomainId.NewGuid();
var asset = TestAsset.Create(appId, assetId);
var query = @"
query {
findAsset(id: ""<ID>"") {
<FIELDS>
}
}".Replace("<ID>", assetId.ToString()).Replace("<FIELDS>", TestAsset.AllFields);
A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), null, A <Q> .That.HasIds(assetId)))
.Returns(ResultList.CreateFrom(1, asset));
var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query });
var expected = new
{
data = new
{
findAsset = TestAsset.Response(asset)
}
};
AssertResult(expected, result);
}
public async Task Should_return_multiple_assets_if_querying_assets()
{
var query = CreateQuery(@"
query {
queryAssets(filter: 'my-query', top: 30, skip: 5) {
<FIELDS_ASSET>
}
}");
var asset = TestAsset.Create(DomainId.NewGuid());
A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), null,
A <Q> .That.Matches(x => x.QueryAsOdata == "?$top=30&$skip=5&$filter=my-query" && x.NoTotal), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(0, asset));
var result = await ExecuteAsync(new ExecutionOptions { Query = query });
var expected = new
{
data = new
{
queryAssets = new[]
{
TestAsset.Response(asset)
}
}
};
AssertResult(expected, result);
}
public async Task Should_return_single_asset_if_finding_asset()
{
var assetId = DomainId.NewGuid();
var asset = TestAsset.Create(assetId);
var query = CreateQuery(@"
query {
findAsset(id: '<ID>') {
<FIELDS_ASSET>
}
}", assetId);
A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), null,
A <Q> .That.HasIdsWithoutTotal(assetId), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom(1, asset));
var result = await ExecuteAsync(new ExecutionOptions { Query = query });
var expected = new
{
data = new
{
findAsset = TestAsset.Response(asset)
}
};
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_make_multiple_queries()
{
var assetId1 = DomainId.NewGuid();
var assetId2 = DomainId.NewGuid();
var asset1 = TestAsset.Create(appId, assetId1);
var asset2 = TestAsset.Create(appId, 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(), null, A <Q> .That.HasIds(assetId1)))
.Returns(ResultList.CreateFrom(0, asset1));
A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), null, A <Q> .That.HasIds(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_return_multiple_assets_with_total_when_querying_assets_with_total()
{
var query = @"
query {
queryAssetsWithTotal(filter: ""my-query"", top: 30, skip: 5) {
total
items {
<FIELDS>
}
}
}".Replace("<FIELDS>", TestAsset.AllFields);
var asset = TestAsset.Create(appId, DomainId.NewGuid());
A.CallTo(() => assetQuery.QueryAsync(MatchsAssetContext(), null,
A <Q> .That.Matches(x => x.ODataQuery == "?$top=30&$skip=5&$filter=my-query" && x.NoTotal == false)))
.Returns(ResultList.CreateFrom(10, asset));
var result = await ExecuteAsync(new ExecutionOptions { Query = query });
var expected = new
{
data = new
{
queryAssetsWithTotal = new
{
total = 10,
items = new dynamic[]
{
TestAsset.Response(asset)
}
}
}
};
AssertResult(expected, result);
}
