public void CanPatch_should_throw_exception_if_data_is_null()
{
var command = new PatchContent();
ValidationAssert.Throws(() => GuardContent.CanPatch(command),
new ValidationError("Data is required.", "Data"));
}
public async Task CanCreate_should_throw_exception_if_data_is_null()
{
var command = new CreateContent();
await ValidationAssert.ThrowsAsync(() => GuardContent.CanCreate(schema, contentWorkflow, command),
new ValidationError("Data is required.", "Data"));
}
public void CreateDraft_should_not_throw_exception()
{
var content = CreateContent(Status.Published);
var command = new CreateContentDraft();
GuardContent.CanCreateDraft(command, content);
}
public void CanDeleteDraft_should_not_throw_exception()
{
var content = CreateDraftContent(Status.Draft);
var command = new DeleteContentDraft();
GuardContent.CanDeleteDraft(command, content);
}
public void CanCreate_should_throw_exception_if_data_is_null()
{
var command = new CreateContent();
ValidationAssert.Throws(() => GuardContent.CanCreate(schema, command),
new ValidationError("Data is required.", "Data"));
}
public void CanDelete_should_throw_exception_if_singleton()
{
A.CallTo(() => schema.IsSingleton).Returns(true);
var command = new DeleteContent();
Assert.Throws <DomainException>(() => GuardContent.CanDelete(schema, command));
}
public void CanChangeContentStatus_should_not_throw_exception_if_publishing_with_pending_changes()
{
var command = new ChangeContentStatus {
Status = Status.Published
};
GuardContent.CanChangeContentStatus(true, Status.Published, command);
}
public void CanDelete_should_throw_exception_if_singleton()
{
var schema = CreateSchema(true);
var command = new DeleteContent();
Assert.Throws <DomainException>(() => GuardContent.CanDelete(schema, command));
}
public void CanDelete_should_not_throw_exception()
{
SetupSingleton(false);
var command = new DeleteContent();
GuardContent.CanDelete(schema, command);
}
public void CanChangeContentStatus_should_throw_exception_if_status_flow_not_valid()
{
var command = new ChangeContentStatus {
Status = Status.Published
};
Assert.Throws <ValidationException>(() => GuardContent.CanChangeContentStatus(false, Status.Archived, command));
}
public void CanCreate_should_not_throw_exception_if_data_is_not_null()
{
var command = new CreateContent {
Data = new NamedContentData()
};
GuardContent.CanCreate(command);
}
public async Task CanCreate_should_not_throw_exception_if_data_is_not_null()
{
var command = new CreateContent {
Data = new NamedContentData()
};
await GuardContent.CanCreate(schema, contentWorkflow, command);
}
public void CanChangeContentStatus_should_throw_exception_if_due_date_in_past()
{
var command = new ChangeContentStatus {
Status = Status.Published, DueTime = dueTimeInPast
};
Assert.Throws <ValidationException>(() => GuardContent.CanChangeContentStatus(false, Status.Draft, command));
}
public void CanPatch_should_not_throw_exception_if_data_is_not_null()
{
var command = new PatchContent {
Data = new NamedContentData()
};
GuardContent.CanPatch(command);
}
public void CanDiscardChanges_should_not_throw_exception_if_pending()
{
SetupSingleton(false);
var command = new DiscardChanges();
GuardContent.CanDiscardChanges(true, command);
}
public void CanChangeContentStatus_should_not_throw_exception_if_status_flow_valid()
{
var command = new ChangeContentStatus {
Status = Status.Published
};
GuardContent.CanChangeContentStatus(false, Status.Draft, command);
}
public void CanDelete_should_not_throw_exception()
{
var schema = CreateSchema(false);
var command = new DeleteContent();
GuardContent.CanDelete(schema, command);
}
public void CanChangeContentStatus_should_throw_exception_if_publishing_without_pending_changes()
{
var command = new ChangeContentStatus {
Status = Status.Published
};
Assert.Throws <ValidationException>(() => GuardContent.CanChangeContentStatus(false, Status.Published, command));
}
public void CanChangeContentStatus_should_throw_exception_if_publishing_without_pending_changes()
{
var command = new ChangeContentStatus {
Status = Status.Published
};
ValidationAssert.Throws(() => GuardContent.CanChangeContentStatus(schema, false, Status.Published, command),
new ValidationError("Content has no changes to publish.", "Status"));
}
public void CanChangeContentStatus_should_throw_exception_if_status_not_valid()
{
var command = new ChangeContentStatus {
Status = (Status)10
};
ValidationAssert.Throws(() => GuardContent.CanChangeContentStatus(schema, false, Status.Archived, command),
new ValidationError("Status is not valid.", "Status"));
}
public void CanDeleteDraft_should_throw_exception_if_no_draft_found()
{
CreateSchema(false);
var content = new ContentState();
var command = new DeleteContentDraft();
Assert.Throws <DomainException>(() => GuardContent.CanDeleteDraft(command, content));
}
public void CanChangeContentStatus_should_throw_exception_if_status_flow_not_valid()
{
var command = new ChangeContentStatus {
Status = Status.Published
};
ValidationAssert.Throws(() => GuardContent.CanChangeContentStatus(schema, false, Status.Archived, command),
new ValidationError("Cannot change status from Archived to Published.", "Status"));
}
public void CreateDraft_should_throw_exception_if_not_published()
{
CreateSchema(false);
var content = CreateContent(Status.Draft);
var command = new CreateContentDraft();
Assert.Throws <DomainException>(() => GuardContent.CanCreateDraft(command, content));
}
public void CanDeleteDraft_should_throw_exception_if_singleton()
{
var schema = CreateSchema(true);
var content = CreateDraftContent(Status.Draft);
var command = new DeleteContentDraft();
Assert.Throws <DomainException>(() => GuardContent.CanDeleteDraft(command, schema, content));
}
public void CanChangeContentStatus_should_throw_exception_if_due_date_in_past()
{
var command = new ChangeContentStatus {
Status = Status.Published, DueTime = dueTimeInPast
};
ValidationAssert.Throws(() => GuardContent.CanChangeContentStatus(schema, false, Status.Draft, command),
new ValidationError("Due time must be in the future.", "DueTime"));
}
public async Task CanDelete_should_not_throw_exception()
{
var schema = CreateSchema(false);
var content = CreateContent(Status.Published);
var command = new DeleteContent();
await GuardContent.CanDelete(command, content, contentRepository, schema);
}
public void CanUpdate_should_throw_exception_if_data_is_null()
{
SetupSingleton(false);
var command = new UpdateContent();
ValidationAssert.Throws(() => GuardContent.CanUpdate(command),
new ValidationError("Data is required.", "Data"));
}
public async Task CanDelete_should_throw_exception_if_singleton()
{
var schema = CreateSchema(true);
var content = CreateContent(Status.Published);
var command = new DeleteContent();
await Assert.ThrowsAsync <DomainException>(() => GuardContent.CanDelete(command, content, contentRepository, schema));
}
public async Task CanCreate_should_not_throw_exception_if_singleton_and_id_is_schema_id()
{
var schema = CreateSchema(true);
var command = new CreateContent {
Data = new NamedContentData(), ContentId = schema.Id
};
await GuardContent.CanCreate(schema, contentWorkflow, command);
}
public async Task CanCreate_should_throw_exception_if_singleton()
{
var schema = CreateSchema(true);
var command = new CreateContent {
Data = new NamedContentData()
};
await Assert.ThrowsAsync <DomainException>(() => GuardContent.CanCreate(schema, contentWorkflow, command));
}
