public async Task AddSchema_DuplicateName()
{
// arrange
IMongoCollection <Schema> schemas =
_mongoResource.CreateCollection <Schema>();
IMongoCollection <SchemaVersion> versions =
_mongoResource.CreateCollection <SchemaVersion>();
IMongoCollection <SchemaPublishReport> publishReports =
_mongoResource.CreateCollection <SchemaPublishReport>();
IMongoCollection <PublishedSchema> publishedSchemas =
_mongoResource.CreateCollection <PublishedSchema>();
var repository = new SchemaRepository(
schemas, versions, publishReports, publishedSchemas);
var schema = new Schema("foo", "bar");
await repository.AddSchemaAsync(schema);
// act
Func <Task> action = () => repository.AddSchemaAsync(schema);
// assert
DuplicateKeyException ex = await Assert.ThrowsAsync <DuplicateKeyException>(action);
ex.Message.MatchSnapshot();
}
public void Controllers_WhenDuplicateKeyExceptionOccurs_ReturnsConflictError()
{
// Arrange
var domain = "http://www.domain.com";
var path = "/testController/testAction";
var exceptionMessage = "exception message";
var exception = new DuplicateKeyException(exceptionMessage);
var httpRequestMessage = new HttpRequestMessage()
{
RequestUri = new Uri(domain + path)
};
var httpControllerContext = new HttpControllerContext(_httpConfiguration, _httpRouteData, httpRequestMessage)
{
Controller = _controller
};
var httpActionContext = new HttpActionContext(httpControllerContext, _httpActionDescriptor);
var httpActionExecutedContext = new HttpActionExecutedContext(httpActionContext, exception);
// Act
var attribute = new GlobalExceptionHandlerAttribute();
attribute.OnException(httpActionExecutedContext);
// Assert
var expectedError = string.Format("Exception occurred in: {0}; Exception: {1}", path, exceptionMessage);
Assert.AreEqual(expectedError, httpActionExecutedContext.Response.Content.ReadAsStringAsync().Result);
Assert.AreEqual(HttpStatusCode.Conflict, httpActionExecutedContext.Response.StatusCode);
}
public async Task ShouldThrowValidationExceptionOnRegisterIfStudentAlreadyExistsAndLogItAsync()
{
// given
Student randomStudent = CreateRandomStudent();
Student inputStudent = randomStudent;
Student storageStudent = inputStudent;
string someMessage = new MnemonicString().GetValue();
var duplicateKeyException = new DuplicateKeyException(someMessage);
var alreadyExistsStudentException = new AlreadyExistsStudentException(duplicateKeyException);
var expectedStudentValidationException = new StudentValidationException(alreadyExistsStudentException);
this.storageBrokerMock.Setup(broker =>
broker.InsertStudentAsync(inputStudent))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Student> submitStudentTask =
this.studentService.RegisterStudentAsync(inputStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() => submitStudentTask.AsTask());
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentAsync(inputStudent),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async Task UpdateSchema_DuplicateName()
{
// arrange
IMongoCollection <Schema> schemas =
_mongoResource.CreateCollection <Schema>();
IMongoCollection <SchemaVersion> versions =
_mongoResource.CreateCollection <SchemaVersion>();
IMongoCollection <SchemaPublishReport> publishReports =
_mongoResource.CreateCollection <SchemaPublishReport>();
IMongoCollection <PublishedSchema> publishedSchemas =
_mongoResource.CreateCollection <PublishedSchema>();
var initial = new Schema("foo", "bar");
await schemas.InsertOneAsync(initial, options : null, default);
await schemas.InsertOneAsync(new Schema("bar", "bar"), options : null, default);
var repository = new SchemaRepository(
schemas, versions, publishReports, publishedSchemas);
// act
var updated = new Schema(initial.Id, "bar", "baz");
Func <Task> action = () => repository.UpdateSchemaAsync(updated);
// assert
DuplicateKeyException ex = await Assert.ThrowsAsync <DuplicateKeyException>(action);
ex.Message.MatchSnapshot();
}
public void OnException(ExceptionContext context)
{
context.Result = context.Exception switch
{
EntityNotFoundException e => new NotFoundObjectResult(e.Message),
DuplicateKeyException e => new ConflictObjectResult(e.Message),
DuplicateRequestException e => new ConflictObjectResult(e.Message),
DomainException e => new ConflictObjectResult(e.Message),
_ => new InternalServerErrorResult()
};
}
}
public async void ShouldThrowValidationExceptionOnCreateWhenStudentExamFeeAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
StudentExamFee randomStudentExamFee = CreateRandomStudentExamFee(dateTime);
StudentExamFee alreadyExistsStudentExamFee = randomStudentExamFee;
alreadyExistsStudentExamFee.UpdatedBy = alreadyExistsStudentExamFee.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsStudentExamFeeException =
new AlreadyExistsStudentExamFeeException(duplicateKeyException);
var expectedExamFeeValidationException =
new StudentExamFeeValidationException(alreadyExistsStudentExamFeeException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertStudentExamFeeAsync(alreadyExistsStudentExamFee))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <StudentExamFee> createStudentExamFeeTask =
this.studentExamFeeService.AddStudentExamFeeAsync(alreadyExistsStudentExamFee);
// then
await Assert.ThrowsAsync <StudentExamFeeValidationException>(() =>
createStudentExamFeeTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentExamFeeAsync(alreadyExistsStudentExamFee),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedExamFeeValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenUserAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset randomDateTime = GetRandomDateTime();
DateTimeOffset dateTime = randomDateTime;
User randomUser = CreateRandomUser(dateTime);
User alreadyExistsUser = randomUser;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
string password = GetRandomPassword();
var alreadyExistsUserException =
new AlreadyExistsUserException(duplicateKeyException);
var expectedUserValidationException =
new UserValidationException(alreadyExistsUserException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.userManagementBrokerMock.Setup(broker =>
broker.InsertUserAsync(alreadyExistsUser, password))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <User> registerUserTask =
this.userService.RegisterUserAsync(alreadyExistsUser, password);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
registerUserTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.InsertUserAsync(alreadyExistsUser, password),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenContactAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Contact randomContact = CreateRandomContact(dateTime);
Contact alreadyExistsContact = randomContact;
alreadyExistsContact.UpdatedBy = alreadyExistsContact.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsContactException =
new AlreadyExistsContactException(duplicateKeyException);
var expectedContactValidationException =
new ContactValidationException(alreadyExistsContactException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertContactAsync(alreadyExistsContact))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Contact> addContactTask =
this.contactService.AddContactAsync(alreadyExistsContact);
// then
await Assert.ThrowsAsync <ContactValidationException>(() =>
addContactTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertContactAsync(alreadyExistsContact),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedContactValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenCalendarEntryAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
CalendarEntry randomCalendarEntry = CreateRandomCalendarEntry(dateTime);
CalendarEntry alreadyExistsCalendarEntry = randomCalendarEntry;
alreadyExistsCalendarEntry.UpdatedBy = alreadyExistsCalendarEntry.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsCalendarEntryException =
new AlreadyExistsCalendarEntryException(duplicateKeyException);
var expectedCalendarEntryValidationException =
new CalendarEntryValidationException(alreadyExistsCalendarEntryException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertCalendarEntryAsync(alreadyExistsCalendarEntry))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <CalendarEntry> createCalendarEntryTask =
this.calendarEntryService.AddCalendarEntryAsync(alreadyExistsCalendarEntry);
// then
await Assert.ThrowsAsync <CalendarEntryValidationException>(() =>
createCalendarEntryTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedCalendarEntryValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertCalendarEntryAsync(alreadyExistsCalendarEntry),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenGuardianAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Guardian randomGuardian = CreateRandomGuardian(dateTime);
Guardian alreadyExistsGuardian = randomGuardian;
alreadyExistsGuardian.UpdatedBy = alreadyExistsGuardian.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsGuardianException =
new AlreadyExistsGuardianException(duplicateKeyException);
var expectedGuardianValidationException =
new GuardianValidationException(alreadyExistsGuardianException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertGuardianAsync(alreadyExistsGuardian))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Guardian> createGuardianTask =
this.guardianService.CreateGuardianAsync(alreadyExistsGuardian);
// then
await Assert.ThrowsAsync <GuardianValidationException>(() =>
createGuardianTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedGuardianValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertGuardianAsync(alreadyExistsGuardian),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenClassroomAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Classroom randomClassroom = CreateRandomClassroom(dateTime);
Classroom alreadyExistsClassroom = randomClassroom;
alreadyExistsClassroom.UpdatedBy = alreadyExistsClassroom.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsClassroomException =
new AlreadyExistsClassroomException(duplicateKeyException);
var expectedClassroomValidationException =
new ClassroomValidationException(alreadyExistsClassroomException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertClassroomAsync(alreadyExistsClassroom))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Classroom> createClassroomTask =
this.classroomService.CreateClassroomAsync(alreadyExistsClassroom);
// then
await Assert.ThrowsAsync <ClassroomValidationException>(() =>
createClassroomTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertClassroomAsync(alreadyExistsClassroom),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedClassroomValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenTagAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Tag randomTag = CreateRandomTag(dateTime);
Tag alreadyExistsTag = randomTag;
alreadyExistsTag.UpdatedBy = alreadyExistsTag.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsTagException =
new AlreadyExistsTagException(duplicateKeyException);
var expectedTagValidationException =
new TagValidationException(alreadyExistsTagException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertTagAsync(alreadyExistsTag))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Tag> createTagTask =
this.tagService.AddTagAsync(alreadyExistsTag);
// then
await Assert.ThrowsAsync <TagValidationException>(() =>
createTagTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedTagValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertTagAsync(alreadyExistsTag),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenTeacherAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Teacher randomTeacher = CreateRandomTeacher(dateTime);
Teacher alreadyExistsTeacher = randomTeacher;
alreadyExistsTeacher.UpdatedBy = alreadyExistsTeacher.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsTeacherException =
new AlreadyExistsTeacherException(duplicateKeyException);
var expectedTeacherValidationException =
new TeacherValidationException(alreadyExistsTeacherException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertTeacherAsync(alreadyExistsTeacher))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Teacher> registerTeacherTask =
this.teacherService.CreateTeacherAsync(alreadyExistsTeacher);
// then
await Assert.ThrowsAsync <TeacherValidationException>(() =>
registerTeacherTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertTeacherAsync(alreadyExistsTeacher),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedTeacherValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenCourseAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Course randomCourse = CreateRandomCourse(dateTime);
Course alreadyExistsCourse = randomCourse;
alreadyExistsCourse.UpdatedBy = alreadyExistsCourse.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsCourseException =
new AlreadyExistsCourseException(duplicateKeyException);
var expectedCourseValidationException =
new CourseValidationException(alreadyExistsCourseException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Throws(duplicateKeyException);
// when
ValueTask <Course> createCourseTask =
this.courseService.CreateCourseAsync(alreadyExistsCourse);
// then
await Assert.ThrowsAsync <CourseValidationException>(() =>
createCourseTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedCourseValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertCourseAsync(alreadyExistsCourse),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowDependencyValidationExceptionOnAddIfExamAlreadyExistsAndLogItAsync()
{
// given
Exam someExam = CreateRandomExam();
string exceptionMessage = GetRandomMessage();
var duplicateKeyException =
new DuplicateKeyException(exceptionMessage);
var alreadyExistsExamException =
new AlreadyExistsExamException(duplicateKeyException);
var expectedExamDependencyValidationException =
new ExamDependencyValidationException(alreadyExistsExamException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Throws(duplicateKeyException);
// when
ValueTask <Exam> addExamTask =
this.examService.AddExamAsync(someExam);
// then
await Assert.ThrowsAsync <ExamDependencyValidationException>(() =>
addExamTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedExamDependencyValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertExamAsync(It.IsAny <Exam>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowDependencyValidationExceptionOnRegisterWhenStudentAlreadyExistsAndLogItAsync()
{
// given
Student someStudent = CreateRandomStudent();
string someMessage = GetRandomMessage();
var duplicateKeyException =
new DuplicateKeyException(someMessage);
var alreadyExistsStudentException =
new AlreadyExistsStudentException(duplicateKeyException);
var expectedStudentDependencyValidationException =
new StudentDependencyValidationException(alreadyExistsStudentException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Throws(duplicateKeyException);
// when
ValueTask <Student> registerStudentTask =
this.studentService.RegisterStudentAsync(someStudent);
// then
await Assert.ThrowsAsync <StudentDependencyValidationException>(() =>
registerStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameValidationExceptionAs(
expectedStudentDependencyValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentAsync(someStudent),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowDependencyValidationExceptionOnAddIfTeacherAlreadyExsitsAndLogItAsync()
{
// given
var someTeacher = CreateRandomTeacher();
var alreadyExistsTeacher = someTeacher;
string randomMessage = GetRandomMessage();
var duplicateKeyException =
new DuplicateKeyException(randomMessage);
var alreadyExistsTeacherException =
new AlreadyExistsTeacherException(duplicateKeyException);
var expectedTeacherDependencyValidationException =
new TeacherDependencyValidationException(alreadyExistsTeacherException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Throws(duplicateKeyException);
// when
ValueTask <Teacher> addTeacherTask =
this.teacherService.CreateTeacherAsync(alreadyExistsTeacher);
// then
await Assert.ThrowsAsync <TeacherDependencyValidationException>(() =>
addTeacherTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once());
this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(
expectedTeacherDependencyValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertTeacherAsync(It.IsAny <Teacher>()),
Times.Never());
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenCourseAttachmentAlreadyExistsAndLogItAsync()
{
// given
CourseAttachment randomCourseAttachment = CreateRandomCourseAttachment();
CourseAttachment alreadyExistsCourseAttachment = randomCourseAttachment;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsCourseAttachmentException =
new AlreadyExistsCourseAttachmentException(duplicateKeyException);
var expectedCourseAttachmentValidationException =
new CourseAttachmentValidationException(alreadyExistsCourseAttachmentException);
this.storageBrokerMock.Setup(broker =>
broker.InsertCourseAttachmentAsync(alreadyExistsCourseAttachment))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <CourseAttachment> addCourseAttachmentTask =
this.courseAttachmentService.AddCourseAttachmentAsync(alreadyExistsCourseAttachment);
// then
await Assert.ThrowsAsync <CourseAttachmentValidationException>(() =>
addCourseAttachmentTask.AsTask());
this.storageBrokerMock.Verify(broker =>
broker.InsertCourseAttachmentAsync(It.IsAny <CourseAttachment>()),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedCourseAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenGuardianContactAlreadyExistsAndLogItAsync()
{
// given
GuardianContact randomGuardianContact = CreateRandomGuardianContact();
GuardianContact alreadyExistsGuardianContact = randomGuardianContact;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsGuardianContactException =
new AlreadyExistsGuardianContactException(duplicateKeyException);
var expectedGuardianContactValidationException =
new GuardianContactValidationException(alreadyExistsGuardianContactException);
this.storageBrokerMock.Setup(broker =>
broker.InsertGuardianContactAsync(alreadyExistsGuardianContact))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <GuardianContact> addGuardianContactTask =
this.guardianContactService.AddGuardianContactAsync(alreadyExistsGuardianContact);
// then
await Assert.ThrowsAsync <GuardianContactValidationException>(() =>
addGuardianContactTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedGuardianContactValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertGuardianContactAsync(alreadyExistsGuardianContact),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenStudentRegistrationAlreadyExistsAndLogItAsync()
{
// given
StudentRegistration randomStudentRegistration = CreateRandomStudentRegistration();
StudentRegistration alreadyExistsStudentRegistration = randomStudentRegistration;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsStudentRegistrationException =
new AlreadyExistsStudentRegistrationException(duplicateKeyException);
var expectedStudentRegistrationValidationException =
new StudentRegistrationValidationException(alreadyExistsStudentRegistrationException);
this.storageBrokerMock.Setup(broker =>
broker.InsertStudentRegistrationAsync(alreadyExistsStudentRegistration))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <StudentRegistration> addStudentRegistrationTask =
this.studentRegistrationService.AddStudentRegistrationAsync(alreadyExistsStudentRegistration);
// then
await Assert.ThrowsAsync <StudentRegistrationValidationException>(() =>
addStudentRegistrationTask.AsTask());
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentRegistrationAsync(It.IsAny <StudentRegistration>()),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
private OutputMember[] BuildOutputFromException(Exception ex)
{
if (ex is TargetInvocationException)
{
return(BuildOutputFromException(ex.InnerException));
}
ex = Mason.IssueTracker.Server.Domain.NHibernate.ExceptionConverter.ConvertException(ex);
string id = Guid.NewGuid().ToString();
SubResource error = new SubResource();
error[MasonProperties.ErrorProperties.Id] = id;
error[MasonProperties.ErrorProperties.Message] = ex.Message;
Resource result = new Resource();
result[MasonProperties.Error] = error;
result.Meta.Title = "Application error";
result.Meta.Description = "Something went wrong while processing the request. The data contained in this response should explain the problem.";
if (ex is DomainException)
{
Logger.Info(string.Format("{0} [{1}]", ex.Message, id), ex);
DomainException dex = (DomainException)ex;
error[MasonProperties.ErrorProperties.Code] = dex.Code;
if (dex.Messages != null && dex.Messages.Count > 0)
{
error[MasonProperties.ErrorProperties.Messages] = new List <string>(dex.Messages);
}
return(new[]
{
new OutputMember {
Value = new OperationResult.BadRequest {
ResponseResource = result
}
}
});
}
else if (ex is MissingResourceException)
{
Logger.Info(string.Format("{0} [{1}]", ex.Message, id), ex);
error[MasonProperties.ErrorProperties.Code] = ErrorHandling.Codes.MissingResource;;
return(new[]
{
new OutputMember {
Value = new OperationResult.NotFound {
ResponseResource = result
}
}
});
}
else if (ex is DuplicateKeyException)
{
Logger.Info(string.Format("{0} [{1}]", ex.Message, id), ex);
DuplicateKeyException dkex = (DuplicateKeyException)ex;
error[MasonProperties.ErrorProperties.Code] = ErrorHandling.Codes.DuplicateKey;
return(new[]
{
new OutputMember {
Value = new OperationResult.BadRequest {
ResponseResource = result
}
}
});
}
else
{
Logger.Error(string.Format("{0} [{1}]", ex.Message, id), ex);
error[MasonProperties.ErrorProperties.Code] = ErrorHandling.Codes.InternalError;;
return(new[]
{
new OutputMember {
Value = new OperationResult.InternalServerError {
ResponseResource = result
}
}
});
}
}
private int AddRange(NodePin thisLock, ref KeyRange range, AddRangeInfo value, NodePin parent, int parentIx)
{
int counter = 0;
Node me = thisLock.Ptr;
if (me.Count == me.Size && parent != null)
{
using (NodeTransaction trans = _storage.BeginTransaction())
{
TKey splitAt;
if (parent.Ptr.IsRoot) //Is root node
{
Node rootNode = trans.BeginUpdate(parent);
using (NodePin newRoot = trans.Create(parent, false))
{
rootNode.ReplaceChild(0, thisLock.Handle, newRoot.Handle);
newRoot.Ptr.Insert(0, new Element(default(TKey), thisLock.Handle));
using (NodePin next = Split(trans, ref thisLock, newRoot, 0, out splitAt, true))
using (thisLock)
{
trans.Commit();
GC.KeepAlive(thisLock);
GC.KeepAlive(next);
}
return(AddRange(newRoot, ref range, value, parent, parentIx));
}
}
trans.BeginUpdate(parent);
using (NodePin next = Split(trans, ref thisLock, parent, parentIx, out splitAt, true))
using (thisLock)
{
trans.Commit();
if (_keyComparer.Compare(value.Current.Key, splitAt) >= 0)
{
thisLock.Dispose();
range.SetMinKey(splitAt);
return(AddRange(next, ref range, value, parent, parentIx + 1));
}
next.Dispose();
range.SetMaxKey(splitAt);
return(AddRange(thisLock, ref range, value, parent, parentIx));
}
}
}
if (parent != null)
{
parent.Dispose();
}
if (me.IsLeaf)
{
using (NodeTransaction trans = _storage.BeginTransaction())
{
me = trans.BeginUpdate(thisLock);
int inserted = 0;
while (me.Count < me.Size && !value.IsComplete && range.IsKeyInRange(value.Current.Key))
{
int ordinal;
bool exists = me.BinarySearch(_itemComparer, new Element(value.Current.Key), out ordinal);
DuplicateKeyException.Assert(!exists || value.AllowUpdate);
if (exists)
{
me.SetValue(ordinal, value.Current.Key, value.Current.Value, _keyComparer);
trans.UpdateValue(value.Current.Key, value.Current.Value);
}
else
{
me.Insert(ordinal, new Element(value.Current.Key, value.Current.Value));
trans.AddValue(value.Current.Key, value.Current.Value);
inserted++;
}
counter++;
value.MoveNext();
}
trans.Commit();
if (_hasCount && inserted > 0)
{
int count = _count, test;
while (count != (test = Interlocked.CompareExchange(ref _count, count + inserted, count)))
{
count = test;
}
}
}
}
else
{
int ordinal;
me.BinarySearch(_itemComparer, new Element(value.Current.Key), out ordinal);
if (ordinal >= me.Count)
{
ordinal = me.Count - 1;
}
if (ordinal > 0)
{
range.SetMinKey(me[ordinal - 1].Key);
}
if (ordinal < (me.Count - 1))
{
range.SetMaxKey(me[ordinal + 1].Key);
}
using (NodePin child = _storage.Lock(thisLock, me[ordinal].ChildNode))
counter += AddRange(child, ref range, value, thisLock, ordinal);
}
return(counter);
}
