public async Task ThrowsExeptionWhenBusinessUnitWasNotFound()
{
var options = TestUtils.GetOptions(nameof(ThrowsExeptionWhenBusinessUnitWasNotFound));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelpersLogbook.TestBusinessUnit01());
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelpersLogbook.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelpersLogbook.TestTown01());
await arrangeContext.Logbooks.AddAsync(TestHelpersLogbook.TestLogbook01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedBusinessValidator = new Mock <IBusinessValidator>();
var sut = new LogbookService(assertContext, mockedBusinessValidator.Object);
var ex = await Assert.ThrowsExceptionAsync <NotFoundException>(() => sut.AddLogbookToBusinessUnitAsync(TestHelpersLogbook.TestLogbook01().Id, 2));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.BusinessUnitNotFound));
}
}
public async Task ThrowsExceptionWhenModeratorUserDoesExists_AddModeratorToBusinessUnitsAsync()
{
var options = TestUtils.GetOptions(nameof(ThrowsExceptionWhenModeratorUserDoesExists_AddModeratorToBusinessUnitsAsync));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit01());
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelperBusinessUnit.TestTown01());
await arrangeContext.Users.AddAsync(TestHelperBusinessUnit.TestUser01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>(MockBehavior.Strict);
var sut = new BusinessUnitService(assertContext, mockBusinessValidator.Object);
var businessUnit = await sut.AddModeratorToBusinessUnitsAsync(TestHelperBusinessUnit.TestUser01().Id, TestHelperBusinessUnit.TestBusinessUnit01().Id);
var moderatorUser = await assertContext.Users.FindAsync(TestHelperBusinessUnit.TestUser01().Id);
var ex = await Assert.ThrowsExceptionAsync <NotFoundException>(() => sut.AddModeratorToBusinessUnitsAsync("11", TestHelperBusinessUnit.TestBusinessUnit01().Id));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.UserNotFound));
}
}
public async Task Succeed_ReturnUpdateReview()
{
var options = TestUtils.GetOptions(nameof(Succeed_ReturnUpdateReview));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelperReview.TestBusinessUnit01());
await arrangeContext.Reviews.AddAsync(TestHelperReview.Review01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>();
var mockReviewEditor = new Mock <IReviewEditor>();
var sut = new ReviewService(assertContext, mockBusinessValidator.Object, mockReviewEditor.Object);
var review = await sut.UpdateReviewAsync(1, "Edit Text of Review01");
mockBusinessValidator.Verify(x => x.IsDescriptionInRange("Edit Text of Review01"), Times.Exactly(1));
Assert.AreEqual(review.EditedDescription, "Edit Text of Review01");
}
}
public async Task Succeed_ReturnGetBusinessUnitById()
{
var options = TestUtils.GetOptions(nameof(Succeed_ReturnGetBusinessUnitById));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelperBusinessUnit.TestTown01());
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>();
var sut = new BusinessUnitService(assertContext, mockBusinessValidator.Object);
var getBusinessUnitById = await sut.GetBusinessUnitById(1);
Assert.AreEqual(getBusinessUnitById.Id, 1);
}
}
public async Task SuccessfullyEditNote()
{
var options = TestUtils.GetOptions(nameof(SuccessfullyEditNote));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Notes.AddAsync(TestHelpersNote.TestNote1());
await arrangeContext.NoteCategories.AddAsync(TestHelpersNote.TestNoteCategory1());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedValidator = new Mock <IBusinessValidator>();
var sut = new NoteService(assertContext, mockedValidator.Object);
var noteDTO = await sut.EditNoteAsync(TestHelpersNote.TestNote1().Id,
TestHelpersNote.TestUser1().Id,
"The room is clean", "710f8fd0-c90f-4d6a-b421-3aef173d9cf4", TestHelpersNote.TestNoteCategory1().Id);
Assert.AreEqual(noteDTO.Description, "The room is clean");
Assert.AreEqual(noteDTO.Image, "710f8fd0-c90f-4d6a-b421-3aef173d9cf4");
Assert.AreEqual(noteDTO.CategoryName, TestHelpersNote.TestNoteCategory1().Name);
}
}
public static UserManager <User> GetUserManager(ManagerLogbookContext context)
{
var store = new UserStore <User>(context);
var userManager = new UserManager <User>(store, null, null, null, null, null, null, null, null);
return(userManager);
}
public async Task Succeed_ReturnLogbookWhenManagerWasRemoved()
{
var options = TestUtils.GetOptions(nameof(Succeed_ReturnLogbookWhenManagerWasRemoved));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Users.AddAsync(TestHelpersLogbook.TestUser01());
await arrangeContext.Users.AddAsync(TestHelpersLogbook.TestUser02());
await arrangeContext.Logbooks.AddAsync(TestHelpersLogbook.TestLogbook04());
await arrangeContext.UsersLogbooks.AddAsync(TestHelpersLogbook.TestUsersLogbooks04());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedBusinessValidator = new Mock <IBusinessValidator>();
var sut = new LogbookService(assertContext, mockedBusinessValidator.Object);
await sut.RemoveManagerFromLogbookAsync(TestHelpersLogbook.TestUser01().Id, TestHelpersLogbook.TestLogbook04().Id);
Assert.AreEqual(assertContext.UsersLogbooks.Select(x => x.LogbookId).Count(), 0);
}
}
public async Task SucceedCreateWhenNoCategoryAdded()
{
var options = TestUtils.GetOptions(nameof(SucceedCreateWhenNoCategoryAdded));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.UsersLogbooks.AddAsync(TestHelpersNote.TestUsersLogbooks1());
await arrangeContext.Users.AddAsync(TestHelpersNote.TestUser1());
await arrangeContext.Logbooks.AddAsync(TestHelpersNote.TestLogbook1());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedValidator = new Mock <IBusinessValidator>();
var sut = new NoteService(assertContext, mockedValidator.Object);
var description = "Room 37 needs cleaning.";
var image = "abd22cec-9df6-43ea-b5aa-991689af55d1";
var noteDTO = await sut.CreateNoteAsync(TestHelpersNote.TestUser1().Id, TestHelpersNote.TestLogbook1().Id,
description, image, null);
mockedValidator.Verify(x => x.IsDescriptionInRange(description), Times.Exactly(1));
mockedValidator.Verify(x => x.IsDescriptionIsNullOrEmpty(description), Times.Exactly(1));
Assert.AreEqual(noteDTO.Id, 1);
Assert.AreEqual(noteDTO.Description, description);
Assert.IsNull(noteDTO.CategoryName);
Assert.IsFalse(noteDTO.IsActiveTask);
}
}
public async Task ThrowsExceptionWhenUserIsNotAuthorized()
{
var options = TestUtils.GetOptions(nameof(ThrowsExceptionWhenUserIsNotAuthorized));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Users.AddAsync(TestHelpersNote.TestUser1());
await arrangeContext.Logbooks.AddAsync(TestHelpersNote.TestLogbook1());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedValidator = new Mock <IBusinessValidator>();
var sut = new NoteService(assertContext, mockedValidator.Object);
var description = "Room 37 needs cleaning.";
var image = "abd22cec-9df6-43ea-b5aa-991689af55d1";
var ex = await Assert.ThrowsExceptionAsync <NotAuthorizedException>(() => sut.CreateNoteAsync(TestHelpersNote.TestUser1().Id, TestHelpersNote.TestLogbook1().Id,
description, image, TestHelpersNote.TestNoteCategory2().Id));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.UserNotManagerOfLogbook, TestHelpersNote.TestUser1().UserName, TestHelpersNote.TestLogbook1().Name));
}
}
public async Task ThrowsExeptionWhenManagerIsAlreadyAddedToLogbook()
{
var options = TestUtils.GetOptions(nameof(ThrowsExeptionWhenManagerIsAlreadyAddedToLogbook));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Users.AddAsync(TestHelpersLogbook.TestUser01());
await arrangeContext.Logbooks.AddAsync(TestHelpersLogbook.TestLogbook01());
await arrangeContext.UsersLogbooks.AddAsync(TestHelpersLogbook.TestUsersLogbooks01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedBusinessValidator = new Mock <IBusinessValidator>();
var sut = new LogbookService(assertContext, mockedBusinessValidator.Object);
var ex = await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.AddManagerToLogbookAsync(TestHelpersLogbook.TestUser01().Id, 1));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.ManagerIsAlreadyInLogbook, TestHelpersLogbook.TestUser01().UserName, TestHelpersLogbook.TestLogbook01().Name));
}
}
public async Task ReturnRightPagesCount()
{
var options = TestUtils.GetOptions(nameof(ReturnRightPagesCount));
using (var arrangeContext = new ManagerLogbookContext(options))
{
var notes = new List <Note>();
for (int i = 0; i < 35; i++)
{
notes.Add(new Note()
{
Description = "Very nice morning.",
LogbookId = TestHelpersNote.TestLogbook1().Id
});
}
await arrangeContext.Notes.AddRangeAsync(notes);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedValidator = new Mock <IBusinessValidator>();
var notesPerPage = 15;
var sut = new NoteService(assertContext, mockedValidator.Object);
var pages = await sut.GetPageCountForNotesAsync(notesPerPage, TestHelpersNote.TestLogbook1().Id);
Assert.AreEqual(pages, 3);
}
}
public async Task Return_RightCollectionWhenNoDatesSelected()
{
var options = TestUtils.GetOptions(nameof(Return_RightCollectionWhenNoDatesSelected));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Notes.AddAsync(TestHelpersNote.TestNote1());
await arrangeContext.Notes.AddAsync(TestHelpersNote.TestNote2());
await arrangeContext.Notes.AddAsync(TestHelpersNote.TestNote3());
await arrangeContext.NoteCategories.AddAsync(TestHelpersNote.TestNoteCategory1());
await arrangeContext.UsersLogbooks.AddAsync(TestHelpersNote.TestUsersLogbooks1());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedValidator = new Mock <IBusinessValidator>();
var sut = new NoteService(assertContext, mockedValidator.Object);
var notesDTO = await sut.SearchNotesAsync(TestHelpersNote.TestUser1().Id,
TestHelpersNote.TestLogbook1().Id, DateTime.MinValue, DateTime.MinValue, 2, "room37", null);
Assert.AreEqual(notesDTO.Count, 2);
}
}
public async Task Should_SearchBusinessUnitsWhenTownIsNullAsync()
{
var options = TestUtils.GetOptions(nameof(Should_SearchBusinessUnitsWhenTownIsNullAsync));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit01());
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit02());
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelperBusinessUnit.TestTown01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>(MockBehavior.Strict);
var mockListBusinessUnit = new List <BusinessUnit>();
var sut = new BusinessUnitService(assertContext, mockBusinessValidator.Object);
var businessUnits = await sut.SearchBusinessUnitsAsync("Kempinski", 1, null);
Assert.AreEqual(businessUnits.Count, 1);
}
}
public async Task ThrowsExeptionWhenModeratorNotExistsBy_ReturnGetAllReviewsByModeratorId()
{
var options = TestUtils.GetOptions(nameof(ThrowsExeptionWhenModeratorNotExistsBy_ReturnGetAllReviewsByModeratorId));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelperReview.TestBusinessUnit01());
await arrangeContext.Reviews.AddAsync(TestHelperReview.Review01());
await arrangeContext.Reviews.AddAsync(TestHelperReview.Review02());
await arrangeContext.Users.AddAsync(TestHelperReview.TestUser01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>();
var mockReviewEditor = new Mock <IReviewEditor>();
var sut = new ReviewService(assertContext, mockBusinessValidator.Object, mockReviewEditor.Object);
var review = await sut.GetAllReviewsByModeratorIdAsync(TestHelperReview.TestUser01().Id);
var ex = await Assert.ThrowsExceptionAsync <NotFoundException>(() => sut.GetAllReviewsByModeratorIdAsync("2"));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.UserNotFound));
}
}
public async Task ThrowsExeption_WhenUserIsNotAuthorized()
{
var options = TestUtils.GetOptions(nameof(ThrowsExeption_WhenUserIsNotAuthorized));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Notes.AddAsync(TestHelpersNote.TestNote1());
await arrangeContext.Users.AddAsync(TestHelpersNote.TestUser3());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedValidator = new Mock <IBusinessValidator>();
var sut = new NoteService(assertContext, mockedValidator.Object);
var ex = await Assert.ThrowsExceptionAsync <NotAuthorizedException>(() => sut.ShowLogbookNotesWithActiveStatusAsync(TestHelpersNote.TestUser3().Id,
TestHelpersNote.TestLogbook1().Id));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.UserIsNotAuthorizedToViewNotes, TestHelpersNote.TestUser3().UserName));
}
}
public async Task Should_GetAllBusinessUnitsByBusinessUnitCategoryAsync()
{
var options = TestUtils.GetOptions(nameof(Should_GetAllBusinessUnitsByBusinessUnitCategoryAsync));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit01());
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit02());
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelperBusinessUnit.TestTown01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>(MockBehavior.Strict);
var sut = new BusinessUnitService(assertContext, mockBusinessValidator.Object);
var businessUnits = await sut.GetAllBusinessUnitsByCategoryIdAsync(1);
Assert.AreEqual(businessUnits.Count, 2);
}
}
public async Task Return_RightCollection()
{
var options = TestUtils.GetOptions(nameof(Return_RightCollection));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Notes.AddAsync(TestHelpersNote.TestNote1());
await arrangeContext.Notes.AddAsync(TestHelpersNote.TestNote2());
await arrangeContext.Notes.AddAsync(TestHelpersNote.TestNote3());
await arrangeContext.UsersLogbooks.AddAsync(TestHelpersNote.TestUsersLogbooks1());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedValidator = new Mock <IBusinessValidator>();
var sut = new NoteService(assertContext, mockedValidator.Object);
var notesDTO = await sut.ShowLogbookNotesForDaysBeforeAsync(TestHelpersNote.TestUser1().Id, TestHelpersNote.TestLogbook1().Id, 3);
Assert.AreEqual(notesDTO.Count, 2);
}
}
public async Task GiveLikeBusinessUnitAsync()
{
var options = TestUtils.GetOptions(nameof(GiveLikeBusinessUnitAsync));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit01());
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelperBusinessUnit.TestTown01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>(MockBehavior.Strict);
var sut = new BusinessUnitService(assertContext, mockBusinessValidator.Object);
var businessUnitDTO = await sut.GiveLikeBusinessUnitAsync(TestHelperBusinessUnit.TestBusinessUnit01().Id);
Assert.AreEqual(businessUnitDTO.Likes, 1);
}
}
public async Task SuccessfullySwitch()
{
var options = TestUtils.GetOptions(nameof(SuccessfullySwitch));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Users.AddAsync(TestHelpersNote.TestUser1());
await arrangeContext.Logbooks.AddAsync(TestHelpersNote.TestLogbook1());
await arrangeContext.UsersLogbooks.AddAsync(TestHelpersNote.TestUsersLogbooks1());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedRapper = new Mock <IUserServiceWrapper>();
var sut = new UserService(assertContext, mockedRapper.Object);
var userDTO = await sut.SwitchLogbookAsync(TestHelpersNote.TestUser1().Id,
TestHelpersNote.TestLogbook1().Id);
Assert.AreEqual(userDTO.CurrentLogbookId, TestHelpersNote.TestLogbook1().Id);
}
}
public async Task Succeed_ReturnCreateBusinessUnit()
{
var options = TestUtils.GetOptions(nameof(Succeed_ReturnCreateBusinessUnit));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelperBusinessUnit.TestTown01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>();
var sut = new BusinessUnitService(assertContext, mockBusinessValidator.Object);
var businessUnitDTO = await sut.CreateBusinnesUnitAsync("Hilton", "Cerni Vryh 15", "0123456789", "*****@*****.**", "Information for BU", 1, 1, "picture");
mockBusinessValidator.Verify(x => x.IsNameInRange("Hilton"), Times.Exactly(1));
mockBusinessValidator.Verify(x => x.IsAddressInRange("Cerni Vryh 15"), Times.Exactly(1));
mockBusinessValidator.Verify(x => x.IsPhoneNumberValid("0123456789"), Times.Exactly(1));
mockBusinessValidator.Verify(x => x.IsEmailValid("*****@*****.**"), Times.Exactly(1));
Assert.AreEqual(businessUnitDTO.Name, "Hilton");
Assert.AreEqual(businessUnitDTO.Address, "Cerni Vryh 15");
Assert.AreEqual(businessUnitDTO.PhoneNumber, "0123456789");
Assert.AreEqual(businessUnitDTO.Email, "*****@*****.**");
}
}
public async Task ThrowsExeptionWhenManagerWasNotFoundByRemoveManagerFromLogbook()
{
var options = TestUtils.GetOptions(nameof(ThrowsExeptionWhenManagerWasNotFoundByRemoveManagerFromLogbook));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Users.AddAsync(TestHelpersLogbook.TestUser01());
await arrangeContext.Logbooks.AddAsync(TestHelpersLogbook.TestLogbook01());
await arrangeContext.UsersLogbooks.AddAsync(TestHelpersLogbook.TestUsersLogbooks01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedBusinessValidator = new Mock <IBusinessValidator>();
var sut = new LogbookService(assertContext, mockedBusinessValidator.Object);
var ex = await Assert.ThrowsExceptionAsync <NotFoundException>(() => sut.RemoveManagerFromLogbookAsync("2", TestHelpersLogbook.TestLogbook01().Id));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.UserNotFound));
}
}
public async Task Succeed_ReturnLogbookWhenParametersAreValid()
{
var options = TestUtils.GetOptions(nameof(Succeed_ReturnLogbookWhenParametersAreValid));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Logbooks.AddAsync(TestHelpersLogbook.TestLogbook01());
await arrangeContext.BusinessUnits.AddAsync(TestHelpersLogbook.TestBusinessUnit01());
await arrangeContext.Notes.AddAsync(TestHelpersLogbook.TestNote01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedBusinessValidator = new Mock <IBusinessValidator>();
var sut = new LogbookService(assertContext, mockedBusinessValidator.Object);
var logbookDTO = await sut.UpdateLogbookAsync(1, "Hotel", 1, "picture");
Assert.AreEqual(logbookDTO.Name, "Hotel");
Assert.AreEqual(logbookDTO.Picture, "picture");
}
}
public async Task NotChangedWhenNullValuesAdded()
{
var options = TestUtils.GetOptions(nameof(NotChangedWhenNullValuesAdded));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Notes.AddAsync(TestHelpersNote.TestNote1());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedValidator = new Mock <IBusinessValidator>();
var sut = new NoteService(assertContext, mockedValidator.Object);
var noteDTO = await sut.EditNoteAsync(TestHelpersNote.TestNote1().Id,
TestHelpersNote.TestUser1().Id,
null, null, null);
Assert.AreEqual(noteDTO.Description, TestHelpersNote.TestNote1().Description);
Assert.AreEqual(noteDTO.Image, TestHelpersNote.TestNote1().Image);
Assert.AreEqual(noteDTO.CategoryName, TestHelpersNote.TestNoteCategory2().Name);
}
}
public async Task ThrowsExeptionWhenLogbookIsNull()
{
var options = TestUtils.GetOptions(nameof(ThrowsExeptionWhenLogbookIsNull));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.Logbooks.AddAsync(TestHelpersLogbook.TestLogbook01());
await arrangeContext.BusinessUnits.AddAsync(TestHelpersLogbook.TestBusinessUnit01());
await arrangeContext.Notes.AddAsync(TestHelpersLogbook.TestNote01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedBusinessValidator = new Mock <IBusinessValidator>();
var sut = new LogbookService(assertContext, mockedBusinessValidator.Object);
var ex = await Assert.ThrowsExceptionAsync <NotFoundException>(() => sut.UpdateLogbookAsync(10, "name", 1, "picture"));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.LogbookNotFound));
}
}
public async Task Should_AddModeratorToBusinessUnitsAsync()
{
var options = TestUtils.GetOptions(nameof(Should_AddModeratorToBusinessUnitsAsync));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit01());
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelperBusinessUnit.TestTown01());
await arrangeContext.Users.AddAsync(TestHelperBusinessUnit.TestUser01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>(MockBehavior.Strict);
var sut = new BusinessUnitService(assertContext, mockBusinessValidator.Object);
var businessUnitDTO = await sut.AddModeratorToBusinessUnitsAsync(TestHelperBusinessUnit.TestUser01().Id, TestHelperBusinessUnit.TestBusinessUnit01().Id);
var moderatorUser = await assertContext.Users.FindAsync(TestHelperBusinessUnit.TestUser01().Id);
Assert.AreEqual(moderatorUser.BusinessUnitId, TestHelperBusinessUnit.TestBusinessUnit01().Id);
}
}
public async Task ThrowsException_UpdateBusinessUnitNameAlreadyExists()
{
var options = TestUtils.GetOptions(nameof(ThrowsException_UpdateBusinessUnitNameAlreadyExists));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelperBusinessUnit.TestTown01());
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit01());
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit02());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>();
var sut = new BusinessUnitService(assertContext, mockBusinessValidator.Object);
var ex = await Assert.ThrowsExceptionAsync <AlreadyExistsException>(() => sut.UpdateBusinessUnitAsync(1, TestHelperBusinessUnit.TestBusinessUnit02().Name, "Nishava 12", "1234567890", "information2", "*****@*****.**", 1, 1, "picture2"));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.BusinessUnitNameAlreadyExists));
}
}
public async Task ThrowsExceptionWhenBusinessUnitCategoryNameAlreadyExists()
{
var options = TestUtils.GetOptions(nameof(ThrowsExceptionWhenBusinessUnitCategoryNameAlreadyExists));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelperBusinessUnit.TestTown01());
await arrangeContext.BusinessUnits.AddAsync(TestHelperBusinessUnit.TestBusinessUnit02());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>();
var sut = new BusinessUnitService(assertContext, mockBusinessValidator.Object);
var ex = await Assert.ThrowsExceptionAsync <AlreadyExistsException>(() => sut.CreateBusinessUnitCategoryAsync(TestHelperBusinessUnit.TestBusinessUnitCategory01().Name));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.BusinessUnitCategoryNameAlreadyExists));
}
}
public async Task Succeed_ReturnGetAllReviewsByBusinessUnitId()
{
var options = TestUtils.GetOptions(nameof(Succeed_ReturnGetAllReviewsByBusinessUnitId));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelperReview.TestBusinessUnit01());
await arrangeContext.Reviews.AddAsync(TestHelperReview.Review01());
await arrangeContext.Reviews.AddAsync(TestHelperReview.Review02());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>();
var mockReviewEditor = new Mock <IReviewEditor>();
var sut = new ReviewService(assertContext, mockBusinessValidator.Object, mockReviewEditor.Object);
var review = await sut.GetAllReviewsByBusinessUnitIdAsync(1);
Assert.AreEqual(review.Count, 2);
}
}
public async Task ThrowsExeptionWhenReviewWasNotFound()
{
var options = TestUtils.GetOptions(nameof(ThrowsExeptionWhenReviewWasNotFound));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelperReview.TestBusinessUnit01());
await arrangeContext.Reviews.AddAsync(TestHelperReview.Review01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockBusinessValidator = new Mock <IBusinessValidator>();
var mockReviewEditor = new Mock <IReviewEditor>();
var sut = new ReviewService(assertContext, mockBusinessValidator.Object, mockReviewEditor.Object);
var ex = await Assert.ThrowsExceptionAsync <NotFoundException>(() => sut.UpdateReviewAsync(2, "Edit Text of Review01"));
Assert.AreEqual(ex.Message, string.Format(ServicesConstants.ReviewNotFound));
}
}
public async Task Succeed_ReturnLogbookWhenWasAddedToBusinessUnitAsync()
{
var options = TestUtils.GetOptions(nameof(Succeed_ReturnLogbookWhenWasAddedToBusinessUnitAsync));
using (var arrangeContext = new ManagerLogbookContext(options))
{
await arrangeContext.BusinessUnits.AddAsync(TestHelpersLogbook.TestBusinessUnit01());
await arrangeContext.BusinessUnitCategories.AddAsync(TestHelpersLogbook.TestBusinessUnitCategory01());
await arrangeContext.Towns.AddAsync(TestHelpersLogbook.TestTown01());
await arrangeContext.Logbooks.AddAsync(TestHelpersLogbook.TestLogbook01());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new ManagerLogbookContext(options))
{
var mockedBusinessValidator = new Mock <IBusinessValidator>();
var sut = new LogbookService(assertContext, mockedBusinessValidator.Object);
await sut.AddLogbookToBusinessUnitAsync(TestHelpersLogbook.TestLogbook01().Id, TestHelpersLogbook.TestBusinessUnit01().Id);
await assertContext.SaveChangesAsync();
Assert.AreEqual(TestHelpersLogbook.TestLogbook01().BusinessUnitId, TestHelpersLogbook.TestBusinessUnit01().Id);
}
}
