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);
}
}
