public async Task UpdateAsync_RoleTheSame_RoleDidntChanged_OkAsync() { using (var context = InMemoryDatabaseHelper.GetDbContext()) { var userRepo = new UserRepository(context, AutomapperSingleton.Mapper); var userInDb = await new ApplicationUserFactory( role: Role.Employee, firstName: "Neo", lastName: "Tom", email: "*****@*****.**") .BuildAsync(userRepo); var newUserData = new ApplicationUser { Id = userInDb.Id, FirstName = userInDb.FirstName + "1", LastName = userInDb.LastName + "1", UserName = userInDb.UserName + "1", Email = userInDb.Email + "1", Role = Role.Employee }; var target = new UserService( userRepository: userRepo, authorizationManager: new AuthManagerMockHelper(Role.SystemAdministrator).GetManager(), emailDomainValidatorService: new EmailDomainValidatorService("gmail.com|hipo.kz"), emailSender: new EmailSender(new SendGridClientFake()), viewRenderer: new ViewRendererFake(), baseUrls: new BaseUrls(_config)); await target.UpdateAsync(newUserData); userInDb = await target.GetByIdAsync(userInDb.Id); // was changed Assert.Equal("Neo1", userInDb.FirstName); Assert.Equal("Tom1", userInDb.LastName); // Was not changed Assert.Equal("*****@*****.**", userInDb.Email); Assert.Equal("*****@*****.**", userInDb.UserName); Assert.Equal(Role.Employee, userInDb.Role); } }
public void GetAll_Is_Correct_Count(int userCount) { var dbName = $"{nameof(GetAll_Is_Correct_Count)}_{userCount}"; using (var context = InMemoryDatabaseHelper.CreateContext(CreateDatabaseName(dbName))) { InMemoryDatabaseHelper.Save(UserSeed.CreateUsers(userCount), context); } using (var context = InMemoryDatabaseHelper.CreateContext(CreateDatabaseName(dbName))) { var repository = new UserRepository(context); var userList = repository.GetAll(); Assert.NotNull(userList); Assert.Equal(userCount, userList.Count()); } }
public async Task SendCustomEmail_NotAllowedRoles_ExceptionAsync(Role role) { using (var dbContext = InMemoryDatabaseHelper.GetDbContext()) { var user = await new ApplicationUserFactory(role).BuildAsync(dbContext); var emailContent = new EmailContent( @from: "*****@*****.**", subject: "test", body: "<p> Hello world </P>", recipients: new List <string>() { "*****@*****.**" }); var service = Target(user); await Assert.ThrowsAsync <NoPermissionsException>(() => service.SendCustomEmailAsync(emailContent)); } }
private async Task Execute_Does_Not_Exist() { var userCount = 10; // Arrange using (var context = InMemoryDatabaseHelper.CreateContext(nameof(Execute_Does_Not_Exist))) { InMemoryDatabaseHelper.Save(UserSeed.CreateUsers(userCount), context); } using (var context = InMemoryDatabaseHelper.CreateContext(nameof(Execute_Does_Not_Exist))) { var userDelete = CreateUserDeleteObject(context); var userDto = new UserDto(); // Act && Assert await Assert.ThrowsAsync <Exception>(async() => await userDelete.Execute(userDto)); } }
public async Task Post_Create_User_Invalid_Model(string username, string password) { var dbName = $"{nameof(Post_Create_User_Invalid_Model)}_{username}"; using (var context = InMemoryDatabaseHelper.CreateContext(dbName)) { var controller = CreateUserControllerObject(context); var dto = new UserDto { Username = username, Password = password }; var result = await controller.Post(dto); Assert.IsType <BadRequestObjectResult>(result.Result); } }
public void GetAll_Return_Value() { // Arrange using (var context = InMemoryDatabaseHelper.CreateContext(nameof(GetAll_Return_Value))) { InMemoryDatabaseHelper.Save(UserSeed.CreateUsers(), context); } using (var context = InMemoryDatabaseHelper.CreateContext(nameof(GetAll_Return_Value))) { // Act var userFinder = CreateUserFindObject(context); var users = userFinder.GetAll(); // Assert Assert.NotNull(users); Assert.True(users.Any()); } }
public async Task ImportAsync_WrongDomain_ExceptionAsync() { var listOfUsers = new List <UserDto> { new UserDto("John", "Smith", "*****@*****.**") }; await using var context = InMemoryDatabaseHelper.GetDbContext(); var listOfUsersToImport = listOfUsers.ToArray(); var service = new UserService( userRepository: new UserRepository(context), authorizationManager: new Mock <IAuthorizationManager>().Object, emailDomainValidatorService: new EmailDomainValidatorService("example.com|hipo.kz"), emailSender: new UserEmailStub(), userEvent: new UserEventStub()); await Assert.ThrowsAsync <BadAssException>(() => service.ImportAsync(listOfUsersToImport)); }
public async Task InsertAsync_NoFunctionalManager_OkAsync(Role currentUserRole) { using (var context = InMemoryDatabaseHelper.GetDbContext()) { IAuthorizationManager authMock = new AuthManagerMockHelper(currentUserRole).GetManager(); var service = Target(context, authMock); ApplicationUser user = await service.GetByIdAsync( await service.InsertAsync( CreateAppUserForImport("John", "Test", "*****@*****.**"))); Assert.Equal(Role.Employee, user.Role); Assert.Equal("John", user.FirstName); Assert.Equal("Test", user.LastName); Assert.Equal("*****@*****.**", user.UserName); Assert.Equal("*****@*****.**", user.Email); } }
public async Task Get_Id_404_Code() { var id = Guid.NewGuid().ToString(); using (var context = InMemoryDatabaseHelper.CreateContext(nameof(Get_Id_404_Code))) { InMemoryDatabaseHelper.Save(UserSeed.CreateUsers(), context); var controller = CreateUserControllerObject(context); var actionResult = await controller.Get(id); Assert.IsType <NotFoundObjectResult>(actionResult.Result); } using (var context = InMemoryDatabaseHelper.CreateContext(nameof(Get_Id_404_Code))) { Assert.False(context.User.Any(u => u.Id == id)); } }
private static Record TestAssessment(Record record) { var store = new InMemoryDatabaseHelper().Create(); using (var db = store.OpenSession()) { db.Store(record); db.SaveChanges(); var publishingController = GetTestOpenDataPublishingController(db); var request = new AssessmentRequest { Id = record.Id }; return(((RecordServiceResult)publishingController.Assess(request)).Record); } }
public async Task GetAllAsync_WithRoles_OkAsync() { await using var context = InMemoryDatabaseHelper.GetDbContext(); var userRepo = new UserRepository(context); var user1 = await new ApplicationUserFactory(Role.Employee).BuildAsync(userRepo); var user2 = await new ApplicationUserFactory(Role.HRManager).BuildAsync(userRepo); var user3 = await new ApplicationUserFactory(Role.TopManager).BuildAsync(userRepo); var target = Target(context, new FakeAuth(Role.SystemAdministrator)); var users = await target.GetAllAsync(); Assert.NotEmpty(users); Assert.Equal(3, users.Count); Assert.Equal(Role.Employee, users.ElementAt(0).Role); Assert.Equal(Role.HRManager, users.ElementAt(1).Role); Assert.Equal(Role.TopManager, users.ElementAt(2).Role); }
public async Task UpdateAsync_NotAdminSetHigherRole_ExceptionAsync(Role currentUserRole) { await using var context = InMemoryDatabaseHelper.GetDbContext(); var userRepo = new UserRepository(context); var user1 = await new ApplicationUserFactory(Role.Employee).BuildAsync(userRepo); var user2 = await new ApplicationUserFactory(Role.Employee).BuildAsync(userRepo); IAuthorizationManager authMock = new FakeAuth(currentUserRole); var service = Target(context, authMock); var data = new UserDto("John", "Test", "*****@*****.**"); long userId = await service.InsertAsync(data); data = AutomapperSingleton.Map <UserDto>(await service.GetByIdAsync(userId)); data.Role = Role.SystemAdministrator; await Assert.ThrowsAsync <BadAssException>(() => service.UpdateAsync(data)); }
public async Task GetByUsername_No_Return_Value() { // Arrange var userGenerated = UserSeed.CreateUserTest(); using (var context = InMemoryDatabaseHelper.CreateContext(nameof(GetByUsername_No_Return_Value))) { InMemoryDatabaseHelper.Save(UserSeed.CreateUsers(), context); } using (var context = InMemoryDatabaseHelper.CreateContext(nameof(GetByUsername_No_Return_Value))) { // Act var userFinder = CreateUserFindObject(context); var user = await userFinder.GetByUsername(userGenerated.Username); // Assert Assert.Null(user); Assert.DoesNotContain(userGenerated.Username, context.User.Select(u => u.Username)); } }
public async Task SearchAsync_NoConfirmedUsers_WithRoles_OkAsync() { await using var context = InMemoryDatabaseHelper.GetDbContext(); var userRepo = new UserRepository(context); var target = Target(context, new FakeAuth(Role.SystemAdministrator)); PageModel pageModel = new PageModel(); var user = await new ApplicationUserFactory( new FakeUser( Role.Employee, firstName: "user1_name", lastName: "user1_surname", userName: "******")) .BuildAsync(context); var users = await target.SearchAsync("u", pageModel); Assert.Empty(users.Results); }
public async Task UpdateAsync_SysAdminChangesRoleForOtherUser_OkAsync() { await using var context = InMemoryDatabaseHelper.GetDbContext(); var userRepo = new UserRepository(context); var userInDb = await new ApplicationUserFactory( new FakeUser( role: Role.Employee, firstName: "Neo", lastName: "Tom", userName: "******")) .BuildAsync(userRepo); var newUserData = new UserDto( id: userInDb.Id, firstName: userInDb.FirstName + "1", lastName: userInDb.LastName + "1", userName: userInDb.Email + "1", role: Role.HRManager); var target = new UserService( userRepository: userRepo, authorizationManager: new FakeAuth(Role.SystemAdministrator), emailDomainValidatorService: new EmailDomainValidatorService("example.com|hipo.kz"), emailSender: new UserEmailStub(), userEvent: new UserEventStub()); await target.UpdateAsync(newUserData); userInDb = await target.GetByIdAsync(userInDb.Id); // was changed Assert.Equal("Neo1", userInDb.FirstName); Assert.Equal("Tom1", userInDb.LastName); // Was not changed Assert.Equal("*****@*****.**", userInDb.Email); Assert.Equal("*****@*****.**", userInDb.UserName); Assert.Equal(Role.HRManager, userInDb.Role); }
public async Task ImportAsync_DatabaseContainsNotUniqueUsers_OkAsync() { var listOfUsers = new List <UserDto> { new UserDto("John", "Smith", "*****@*****.**"), }; var listOfUsersToImport = listOfUsers.ToArray(); await using var context = InMemoryDatabaseHelper.GetDbContext(); await new ApplicationUserFactory( new FakeUser(Role.Employee, "*****@*****.**", "John", "Smith")) .CreateConfirmedAsync(context); Assert.Equal(1, await context.Users.CountAsync()); var service = Target(context, new Mock <IAuthorizationManager>().Object); Assert.Equal(0, await service.ImportAsync(listOfUsersToImport)); Assert.Equal(1, await context.Users.CountAsync()); }
public void SetUp() { var store = new InMemoryDatabaseHelper().Create(); using (var db = store.OpenSession()) { var importer = Importer.CreateImporter(db, new DaveChambersMapping()); importer.SkipBadRecords = true; importer.Import(@"C:\Work\data\Data Services metadata for top cat entry.csv"); var errors = importer.Results .Where(r => !r.Success) .Select(r => r.Record.Gemini.Title + Environment.NewLine + JsonConvert.SerializeObject(r.Validation) + Environment.NewLine); File.WriteAllLines(@"C:\work\data\dave-chambers-import-errors.txt", errors); db.SaveChanges(); imported = db.Query <Record>() .Customize(x => x.WaitForNonStaleResults()) .Take(1000).ToList(); } }
public async Task ImportAsync_WrongDomain_ExceptionAsync() { var listOfUsers = new List <ApplicationUser> { CreateAppUserForImport("John", "Smith", "*****@*****.**") }; using (var context = InMemoryDatabaseHelper.GetDbContext()) { var listOfUsersToImport = listOfUsers.ToArray(); var service = new UserService( userRepository: new UserRepository(context, AutomapperSingleton.Mapper), authorizationManager: new Mock <IAuthorizationManager>().Object, emailDomainValidatorService: new EmailDomainValidatorService("gmail.com|hipo.kz"), emailSender: new EmailSender(new SendGridClientFake()), viewRenderer: new ViewRendererFake(), baseUrls: new BaseUrls(_config)); await Assert.ThrowsAsync <BadRequestException>(() => service.ImportAsync(listOfUsersToImport)); } }
public void SetUp() { var store = new InMemoryDatabaseHelper().Create(); using (var db = store.OpenSession()) { var importer = Importer.CreateImporter(db, new EuropeanReportingMapping()); importer.SkipBadRecords = true; importer.Import(@"C:\Work\data\europeanreporting\Article 17 JNCC publishable metadata_riskassessment.csv"); var errors = importer.Results .Where(r => !r.Success) .Select(r => r.Record.Gemini.Title + Environment.NewLine + JsonConvert.SerializeObject(r.Validation) + Environment.NewLine); File.WriteAllLines(@"C:\work\data\europeanreporting\errors.txt", errors); db.SaveChanges(); imported = db.Query <Record>() .Customize(x => x.WaitForNonStaleResults()) .Take(1000).ToList(); } }
public void SetUp() { var store = new InMemoryDatabaseHelper().Create(); using (var db = store.OpenSession()) { var importer = Importer.CreateImporter(db, new ActivitiesMapping()); importer.SkipBadRecords = true; // see log for skipped bad records importer.Import(@"C:\work\activities\Catalogue2.txt"); var errors = importer.Results .Where(r => !r.Success) .Select(r => r.Record.Gemini.Title + Environment.NewLine + JsonConvert.SerializeObject(r.Validation) + Environment.NewLine); File.WriteAllLines(@"C:\work\activities\activities-errors.txt", errors); db.SaveChanges(); imported = db.Query <Record>() .Customize(x => x.WaitForNonStaleResults()) .Take(1000).ToList(); } }
public async Task Put_Create_Not_Existing_User() { using (var context = InMemoryDatabaseHelper.CreateContext(nameof(Put_Create_Not_Existing_User))) { InMemoryDatabaseHelper.Save(UserSeed.CreateUsers(), context); } using (var context = InMemoryDatabaseHelper.CreateContext(nameof(Put_Create_Not_Existing_User))) { var controller = CreateUserControllerObject(context); var dto = new UserDto { Id = UserSeed.Id, Username = UserSeed.Username, Password = UserSeed.Password }; var response = await controller.Put(dto); Assert.IsType <BadRequestObjectResult>(response.Result); Assert.Null(context.User.FirstOrDefault(u => u.Id == UserSeed.Id)); } }
public async Task GetById_Is_Exist_Value(int userCount) { var dbName = $"{nameof(GetById_Is_Exist_Value)}_{userCount}"; var userGenerated = UserSeed.CreateUserTest(); var users = UserSeed.CreateUsers(userCount); users.Add(userGenerated); using (var context = InMemoryDatabaseHelper.CreateContext(CreateDatabaseName(dbName))) { InMemoryDatabaseHelper.Save(users, context); } using (var context = InMemoryDatabaseHelper.CreateContext(CreateDatabaseName(dbName))) { var repository = new UserRepository(context); var user = await repository.GetById(userGenerated.Id); Assert.NotNull(user); Assert.True(user.Id == userGenerated.Id); Assert.Equal(user.Password, userGenerated.Password); } }
public async Task UpdateAsync_NotAdminSetHigherRole_ExceptionAsync(Role currentUserRole) { using (var context = InMemoryDatabaseHelper.GetDbContext()) { var userRepo = new UserRepository(context, AutomapperSingleton.Mapper); var user1 = await new ApplicationUserFactory(Role.Employee).BuildAsync(userRepo); var user2 = await new ApplicationUserFactory(Role.Employee).BuildAsync(userRepo); IAuthorizationManager authMock = new AuthManagerMockHelper(currentUserRole).GetManager(); var service = Target(context, authMock); var user = CreateAppUserForImport("John", "Test", "*****@*****.**"); long userId = await service.InsertAsync(user); var newUser = await service.GetByIdAsync(userId); newUser.Role = Role.SystemAdministrator; await Assert.ThrowsAsync <BadRequestException>(() => service.UpdateAsync(newUser)); } }
public async Task Add_New_Value() { var userCount = 10; var userGenerated = UserSeed.CreateUserTest(); using (var context = InMemoryDatabaseHelper.CreateContext(CreateDatabaseName(nameof(Add_New_Value)))) { InMemoryDatabaseHelper.Save(UserSeed.CreateUsers(userCount), context); var repository = new UserRepository(context); await repository.Add(userGenerated); } using (var context = InMemoryDatabaseHelper.CreateContext(CreateDatabaseName(nameof(Add_New_Value)))) { var repository = new UserRepository(context); var userList = repository.GetAll().ToList(); Assert.NotNull(userList); Assert.True(userList.Count() == userCount + 1); Assert.Contains(userGenerated.Id, userList.Select(u => u.Id)); Assert.Contains(userGenerated.Username, userList.Select(u => u.Username)); } }
public void not_eligible_for_assessment_when_path_is_not_file_path(Record record) { var store = new InMemoryDatabaseHelper().Create(); using (var db = store.OpenSession()) { db.Store(record); db.SaveChanges(); var publishingController = GetTestOpenDataPublishingController(db); var request = new AssessmentRequest { Id = record.Id }; Action a = () => publishingController.Assess(request); a.ShouldThrow <InvalidOperationException>().And.Message.Should().Be("Must have a file path for publishing"); var resultRecord = db.Load <Record>(record.Id); resultRecord.Publication.OpenData.Assessment.Should().BeNull(); } }
public void RunPubcatImport() { var store = new InMemoryDatabaseHelper().Create(); using (IDocumentSession db = store.OpenSession()) { var importer = Importer.CreateImporter(db, new PubCatMapping()); importer.SkipBadRecords = true; importer.Import(@"C:\Working\pubcat.csv"); var errors = importer.Results .Where(r => !r.Success) .Select(r => r.Record.Gemini.Title + Environment.NewLine + JsonConvert.SerializeObject(r.Validation) + Environment.NewLine); File.WriteAllLines(@"C:\working\pubcat-errors.txt", errors); db.SaveChanges(); imported = db.Query <Record>() .Customize(x => x.WaitForNonStaleResults()) .Take(1050).ToList(); } }
public async Task Put_Create_User_Success() { var userGenerated = UserSeed.CreateUserTest(); using (var context = InMemoryDatabaseHelper.CreateContext(nameof(Put_Create_Not_Existing_User))) { InMemoryDatabaseHelper.Save(new List <User> { userGenerated }, context); } using (var context = InMemoryDatabaseHelper.CreateContext(nameof(Post_Create_User_Success))) { var controller = CreateUserControllerObject(context); var dto = new UserDto { Id = userGenerated.Id, Username = UserSeed.Username, Password = UserSeed.Password }; var result = await controller.Post(dto); var dtoSuccess = result.Value; Assert.IsType <ActionResult <UserDto> >(result); Assert.IsType <UserDto>(dtoSuccess); } using (var context = InMemoryDatabaseHelper.CreateContext(nameof(Post_Create_User_Success))) { var user = context.User.FirstOrDefault(u => u.Id == userGenerated.Id); Assert.NotNull(user); Assert.True(user.Username == UserSeed.Username); Assert.True(user.Password == UserSeed.Password); } }
public void versioning_should_work() { // guid keys are problematic for raven versioning // so here's a test that show that it now works // this test mutates data so we don't use the ResusableDocumentStore... IDocumentStore store = new InMemoryDatabaseHelper().Create(); Guid id = Guid.Parse("f7b444f7-76f3-47a4-b8d8-cc204d400728"); using (IDocumentSession db = store.OpenSession()) { var record = new Record { Id = id, Gemini = Library.Example() }; db.Store(record); db.SaveChanges(); } using (IDocumentSession db = store.OpenSession()) { var record = db.Load <Record>(id); record.Notes = "i'm updating this record!"; db.SaveChanges(); } using (IDocumentSession db = store.OpenSession()) { var record = db.Load <Record>(id); Record[] revisions = db.Advanced.GetRevisionsFor <Record>(db.Advanced.GetDocumentId(record), 0, 10); revisions.Count().Should().Be(2); revisions.Select(r => r.Revision).Should().ContainInOrder(new[] { 1, 2 }); } }
private IDocumentSession GetDbForSortTests() { var store = new InMemoryDatabaseHelper().Create(); using (var db = store.OpenSession()) { var record1 = SimpleRecord().With(m => { m.Gemini.Title = "sea"; m.Gemini.DatasetReferenceDate = "2017-10-10"; }); var record2 = SimpleRecord().With(m => { m.Gemini.Title = "seabirds"; m.Gemini.DatasetReferenceDate = "2017-10-19"; }); var record3 = SimpleRecord().With(m => { m.Gemini.Title = "birds"; m.Gemini.DatasetReferenceDate = "2017-10-15"; }); var record4 = SimpleRecord().With(m => { m.Gemini.Title = "coastal birds"; m.Gemini.DatasetReferenceDate = "2017-10-17"; }); db.Store(record1); db.Store(record2); db.Store(record3); db.Store(record4); db.SaveChanges(); return(db); } }
public async Task GetByUsername_Return_Value() { // Arrange var userGenerated = UserSeed.CreateUserTest(); using (var context = InMemoryDatabaseHelper.CreateContext(nameof(GetByUsername_Return_Value))) { InMemoryDatabaseHelper.Save(new List <User> { userGenerated }, context); } using (var context = InMemoryDatabaseHelper.CreateContext(nameof(GetByUsername_Return_Value))) { // Act var userFinder = CreateUserFindObject(context); var user = await userFinder.GetByUsername(userGenerated.Username); // Assert Assert.NotNull(user); Assert.Equal(user.Username, userGenerated.Username); Assert.Equal(user.Id, userGenerated.Id); } }