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_return_single_content_if_changing_status_with_null_due_time()
{
var query = CreateQuery(@"
mutation {
changeMySchemaContent(id: '<ID>', status: 'Published', dueTime: null, expectedVersion: 10) {
<FIELDS>
}
}");
commandContext.Complete(content);
var result = await ExecuteAsync(new ExecutionOptions { Query = query }, Permissions.AppContentsChangeStatusOwn);
var expected = new
{
data = new
{
changeMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <ChangeContentStatus> .That.Matches(x =>
x.ContentId == contentId &&
x.DueTime == null &&
x.ExpectedVersion == 10 &&
x.SchemaId.Equals(TestSchemas.DefaultId) &&
x.Status == Status.Published)))
.MustHaveHappened();
}
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_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_publish_command_for_status_change_without_due_time()
{
var query = @"
mutation {
changeMySchemaContent(id: ""<ID>"", status: ""Published"", expectedVersion: 10) {
<FIELDS>
}
}".Replace("<ID>", contentId.ToString()).Replace("<FIELDS>", TestContent.AllFields);
commandContext.Complete(content);
var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query });
var expected = new
{
data = new
{
changeMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <ChangeContentStatus> .That.Matches(x =>
x.ContentId == contentId &&
x.DueTime == null &&
x.ExpectedVersion == 10 &&
x.Status == Status.Published)))
.MustHaveHappened();
}
public async Task Should_return_single_content_when_creating_content()
{
var query = @"
mutation {
createMySchemaContent(data: <DATA>, publish: true) {
<FIELDS>
}
}".Replace("<DATA>", GetDataString()).Replace("<FIELDS>", TestContent.AllFields);
commandContext.Complete(content);
var result = await ExecuteAsync(new GraphQLQuery { Query = query }, Permissions.AppContentsCreate);
var expected = new
{
data = new
{
createMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <CreateContent> .That.Matches(x =>
x.SchemaId.Equals(schemaId) &&
x.ExpectedVersion == EtagVersion.Any &&
x.Publish &&
x.Data.Equals(content.Data))))
.MustHaveHappened();
}
public async Task Should_return_single_content_when_upserting_content()
{
var query = @"
mutation {
upsertMySchemaContent(id: ""<ID>"", data: <DATA>, publish: true, expectedVersion: 10) {
<FIELDS>
}
}".Replace("<ID>", contentId.ToString()).Replace("<DATA>", GetDataString()).Replace("<FIELDS>", TestContent.AllFields);
commandContext.Complete(content);
var result = await ExecuteAsync(new GraphQLQuery { Query = query }, Permissions.AppContentsUpsert);
var expected = new
{
data = new
{
upsertMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <UpsertContent> .That.Matches(x =>
x.ContentId == content.Id &&
x.ExpectedVersion == 10 &&
x.Publish &&
x.Data.Equals(content.Data))))
.MustHaveHappened();
}
public async Task Should_return_single_content_if_upserting_content()
{
var query = CreateQuery(@"
mutation {
upsertMySchemaContent(id: '<ID>', data: <DATA>, publish: true, expectedVersion: 10) {
<FIELDS>
}
}");
commandContext.Complete(content);
var result = await ExecuteAsync(new ExecutionOptions { Query = query }, Permissions.AppContentsUpsert);
var expected = new
{
data = new
{
upsertMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <UpsertContent> .That.Matches(x =>
x.ContentId == content.Id &&
x.ExpectedVersion == 10 &&
x.SchemaId.Equals(TestSchemas.DefaultId) &&
x.Status == Status.Published &&
x.Data.Equals(content.Data))))
.MustHaveHappened();
}
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.HasIds(contentId)))
.Returns(ResultList.CreateFrom(1, 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_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_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_changing_status()
{
var dueTime = InstantPattern.General.Parse("2021-12-12T11:10:09Z").Value;
var query = CreateQuery(@"
mutation {
changeMySchemaContent(id: '<ID>', status: 'Published', dueTime: '2021-12-12T11:10:09Z', expectedVersion: 10) {
<FIELDS>
}
}");
commandContext.Complete(content);
var result = await ExecuteAsync(new ExecutionOptions { Query = query }, Permissions.AppContentsChangeStatusOwn);
var expected = new
{
data = new
{
changeMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <ChangeContentStatus> .That.Matches(x =>
x.ContentId == contentId &&
x.DueTime == dueTime &&
x.ExpectedVersion == 10 &&
x.SchemaId.Equals(schemaId) &&
x.Status == Status.Published)))
.MustHaveHappened();
}
public async Task Should_return_single_content_when_creating_content_with_variable()
{
var query = CreateQuery(@"
mutation OP($data: MySchemaDataInputDto!) {
createMySchemaContent(data: $data, publish: true) {
<FIELDS>
}
}");
commandContext.Complete(content);
var result = await ExecuteAsync(new ExecutionOptions { Query = query, Inputs = GetInput() }, Permissions.AppContentsCreate);
var expected = new
{
data = new
{
createMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <CreateContent> .That.Matches(x =>
x.ExpectedVersion == EtagVersion.Any &&
x.SchemaId.Equals(schemaId) &&
x.Status == Status.Published &&
x.Data.Equals(content.Data))))
.MustHaveHappened();
}
public async Task Should_return_single_content_if_creating_content_with_custom_id()
{
var query = CreateQuery(@"
mutation {
createMySchemaContent(data: <DATA>, id: '123', publish: true) {
<FIELDS>
}
}");
commandContext.Complete(content);
var result = await ExecuteAsync(new ExecutionOptions { Query = query }, Permissions.AppContentsCreate);
var expected = new
{
data = new
{
createMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <CreateContent> .That.Matches(x =>
x.ExpectedVersion == EtagVersion.Any &&
x.ContentId == DomainId.Create("123") &&
x.SchemaId.Equals(TestSchemas.DefaultId) &&
x.Status == Status.Published &&
x.Data.Equals(content.Data))))
.MustHaveHappened();
}
public async Task Should_return_single_content_when_patching_content_with_variable()
{
var query = @"
mutation OP($data: MySchemaDataInputDto!) {
patchMySchemaContent(id: ""<ID>"", data: $data, expectedVersion: 10) {
<FIELDS>
}
}".Replace("<ID>", contentId.ToString()).Replace("<FIELDS>", TestContent.AllFields);
commandContext.Complete(content);
var result = await ExecuteAsync(new GraphQLQuery { Query = query, Inputs = GetInput() }, Permissions.AppContentsUpdateOwn);
var expected = new
{
data = new
{
patchMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <PatchContent> .That.Matches(x =>
x.ContentId == content.Id &&
x.ExpectedVersion == 10 &&
x.Data.Equals(content.Data))))
.MustHaveHappened();
}
public async Task Should_return_single_content_if_updating_content_with_variable()
{
var query = CreateQuery(@"
mutation OP($data: MySchemaDataInputDto!) {
updateMySchemaContent(id: '<ID>', data: $data, expectedVersion: 10) {
<FIELDS>
}
}");
commandContext.Complete(content);
var result = await ExecuteAsync(new ExecutionOptions { Query = query, Inputs = GetInput() }, Permissions.AppContentsUpdateOwn);
var expected = new
{
data = new
{
updateMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <UpdateContent> .That.Matches(x =>
x.ContentId == content.Id &&
x.ExpectedVersion == 10 &&
x.SchemaId.Equals(TestSchemas.DefaultId) &&
x.Data.Equals(content.Data))))
.MustHaveHappened();
}
public async Task Should_return_single_content_when_changing_status_with_null_due_time()
{
var query = @"
mutation {
changeMySchemaContent(id: ""<ID>"", status: ""Published"", dueTime: null, expectedVersion: 10) {
<FIELDS>
}
}".Replace("<ID>", contentId.ToString()).Replace("<FIELDS>", TestContent.AllFields);
commandContext.Complete(content);
var result = await ExecuteAsync(new GraphQLQuery { Query = query }, Permissions.AppContentsChangeStatusOwn);
var expected = new
{
data = new
{
changeMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <ChangeContentStatus> .That.Matches(x =>
x.ContentId == contentId &&
x.DueTime == null &&
x.ExpectedVersion == 10 &&
x.Status == Status.Published)))
.MustHaveHappened();
}
public async Task Should_return_single_content_when_creating_content_with_variable()
{
var query = @"
mutation OP($data: MySchemaDataInputDto!) {
createMySchemaContent(data: $data, publish: true) {
<FIELDS>
}
}".Replace("<FIELDS>", TestContent.AllFields);
commandContext.Complete(content);
var result = await sut.QueryAsync(requestContext, new GraphQLQuery { Query = query, Inputs = GetInput() });
var expected = new
{
data = new
{
createMySchemaContent = TestContent.Response(content)
}
};
AssertResult(expected, result);
A.CallTo(() => commandBus.PublishAsync(
A <CreateContent> .That.Matches(x =>
x.SchemaId.Equals(schemaId) &&
x.ExpectedVersion == EtagVersion.Any &&
x.Publish &&
x.Data.Equals(content.Data))))
.MustHaveHappened();
}
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);
}
