public async Task Should_throw_exception_if_workflow_permits_update()
{
var operation = Operation(CreateContent(Status.Draft), normalSchema);
A.CallTo(() => contentWorkflow.CanUpdateAsync(operation.Snapshot, operation.Snapshot.EditingStatus(), operation.User))
.Returns(false);
await Assert.ThrowsAsync <DomainException>(() => operation.CheckUpdateAsync());
}
public async Task Should_throw_exception_when_workflow_permits_update()
{
var context = CreateContext(CreateContent(Status.Draft), normalSchema);
A.CallTo(() => contentWorkflow.CanUpdateAsync(context.Content, context.Content.EditingStatus(), context.User))
.Returns(false);
await Assert.ThrowsAsync <DomainException>(() => context.CheckUpdateAsync());
}
public async Task Should_enrich_content_with_can_update()
{
var content = new ContentEntity {
SchemaId = schemaId
};
A.CallTo(() => workflow.CanUpdateAsync(content, content.Status, requestContext.User))
.Returns(true);
var ctx = requestContext.Clone(b => b.WithResolveFlow(false));
await sut.EnrichAsync(ctx, new[] { content }, null !);
Assert.True(content.CanUpdate);
}
public async Task Should_enrich_content_with_can_update()
{
requestContext.WithResolveFlow(true);
var source = new ContentEntity {
SchemaId = schemaId
};
A.CallTo(() => contentWorkflow.CanUpdateAsync(source))
.Returns(true);
var result = await sut.EnrichAsync(source, requestContext);
Assert.True(result.CanUpdate);
}
public async Task Should_enrich_content_with_can_update()
{
var content = new ContentEntity {
SchemaId = schemaId
};
A.CallTo(() => contentWorkflow.CanUpdateAsync(content, requestContext.User))
.Returns(true);
var ctx = requestContext.WithResolveFlow(true);
await sut.EnrichAsync(ctx, new[] { content }, schemaProvider);
Assert.True(content.CanUpdate);
}
private static async Task ValidateCanUpdate(ContentState content, IContentWorkflow contentWorkflow, ClaimsPrincipal user)
{
if (!await contentWorkflow.CanUpdateAsync(content, content.EditingStatus, user))
{
throw new DomainException($"The workflow does not allow updates at status {content.Status}");
}
}
private static async Task ValidateCanUpdate(ContentState content, IContentWorkflow contentWorkflow, ClaimsPrincipal user)
{
if (!await contentWorkflow.CanUpdateAsync(content, content.EditingStatus, user))
{
throw new DomainException(T.Get("contents.workflowErrorUpdate", new { status = content.EditingStatus }));
}
}
private static async Task ValidateCanUpdate(IContentEntity content, IContentWorkflow contentWorkflow)
{
if (!await contentWorkflow.CanUpdateAsync(content))
{
throw new DomainException($"The workflow does not allow updates at status {content.Status}");
}
}
private static async Task ValidateCanUpdate(IContentEntity content, IContentWorkflow contentWorkflow, ClaimsPrincipal user)
{
var status = content.NewStatus ?? content.Status;
if (!await contentWorkflow.CanUpdateAsync(content, status, user))
{
throw new DomainException(T.Get("contents.workflowErrorUpdate", new { status }));
}
}
public static async Task CanUpdate(UpdateContent command, IContentEntity content, IContentWorkflow contentWorkflow)
{
Guard.NotNull(command, nameof(command));
CheckPermission(content, command, Permissions.AppContentsUpdate, Permissions.AppContentsUpsert);
if (!command.DoNotValidateWorkflow)
{
var status = content.NewStatus ?? content.Status;
if (!await contentWorkflow.CanUpdateAsync(content, status, command.User))
{
throw new DomainException(T.Get("contents.workflowErrorUpdate", new { status }));
}
}
Validate.It(e =>
{
if (command.Data == null)
{
e(Not.Defined(nameof(command.Data)), nameof(command.Data));
}
});
}
private async Task EnrichCanUpdateAsync(ContentEntity content, Context context)
{
var editingStatus = content.NewStatus ?? content.Status;
content.CanUpdate = await contentWorkflow.CanUpdateAsync(content, editingStatus, context.User);
}
private void SetupCanUpdate(bool canUpdate)
{
A.CallTo(() => contentWorkflow.CanUpdateAsync(A <IContentEntity> ._, A <Status> ._, user))
.Returns(canUpdate);
}
private async Task EnrichCanUpdateAsync(IContentEntity content, ContentEntity result, Context context)
{
result.CanUpdate = await contentWorkflow.CanUpdateAsync(content, context.User);
}
private void SetupCanUpdate(bool canUpdate)
{
A.CallTo(() => contentWorkflow.CanUpdateAsync(A <IContentEntity> .Ignored))
.Returns(canUpdate);
}
private async Task ResolveCanUpdateAsync(IContentEntity content, ContentEntity result)
{
result.CanUpdate = await contentWorkflow.CanUpdateAsync(content);
}