public async Task Correct_Stats_Returned()
{
using (var contextFactory = new SqliteInMemoryDbContextFactory <ApplicationDbContext>(options => new ApplicationDbContext(options)))
{
using (var context = await contextFactory.CreateContextAsync())
{
SeedTestData.Seed(context);
await context.SaveChangesAsync();
}
using (var context = await contextFactory.CreateContextAsync())
{
var repo = new StatsRepository(context);
var results = await repo.GetRoomSummaryAsync();
//Ensure the SQL returns correct stats for each room type
foreach (var roomType in context.RoomTypes)
{
Assert.Equal(await context.Jobs.CountAsync(j => j.RoomTypeId == roomType.Id && j.StatusNum == JobStatus.NotStarted), results.First(r => r.Name == roomType.Name && r.Status == JobStatus.NotStarted.Description()).Count);
Assert.Equal(await context.Jobs.CountAsync(j => j.RoomTypeId == roomType.Id && j.StatusNum == JobStatus.Delayed), results.First(r => r.Name == roomType.Name && r.Status == JobStatus.Delayed.Description()).Count);
Assert.Equal(await context.Jobs.CountAsync(j => j.RoomTypeId == roomType.Id && j.StatusNum == JobStatus.InProgress), results.First(r => r.Name == roomType.Name && r.Status == JobStatus.InProgress.Description()).Count);
Assert.Equal(await context.Jobs.CountAsync(j => j.RoomTypeId == roomType.Id && j.StatusNum == JobStatus.Complete), results.First(r => r.Name == roomType.Name && r.Status == JobStatus.Complete.Description()).Count);
Assert.Equal(await context.Jobs.CountAsync(j => j.RoomTypeId == roomType.Id), results.First(r => r.Name == roomType.Name).Total);
}
}
}
}
public void Details_ForCompanyId_ReturnsCompany()
{
//Arrange
Company testCompany = SeedTestData.GetTestCompany();
Guid testCompanyId = testCompany.Id;
mockRepo.Setup(r => r.Company.GetCompany(testCompanyId, It.IsAny <bool>())).Returns(testCompany);
CompanyManagerController controller = new CompanyManagerController(mockRepo.Object); //controller is sut(System Under Test)
//Act
var result = controller.Details(testCompanyId);
//Assert
Assert.IsInstanceOf <ViewResult>(result);
ViewResult viewResult = result as ViewResult;
Assert.That(viewResult.Model, Is.TypeOf <Company>());
Company company = viewResult.Model as Company; //of Company company = (Company)viewResult.Model;
Assert.AreEqual(testCompanyId, company.Id);
//Assert.AreEqual(testCompany.Name, company.Name);
//Assert.AreEqual(testCompany.LaunchDate, company.LaunchDate);
//Assert.AreEqual(testCompany.Size, company.Size);
//Assert.AreEqual(testCompany.Description, company.Description);
//Assert.AreEqual(testCompany.Country, company.Country);
//Assert.AreEqual(testCompany.Address, company.Address);
//Assert.AreEqual(testCompany.LaunchDate, company.LaunchDate);
}
public void Delete_SetsMessageAndReturnsRedirectToActionResult()
{
// Arrange
var httpContext = new DefaultHttpContext();
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var testDeleteCompany = SeedTestData.GetTestCompany();
mockRepo.Setup(repo => repo.Company.GetCompany(testDeleteCompany.Id, false))
.Returns(testDeleteCompany);
var controller = new CompanyManagerController(mockRepo.Object)
{
TempData = tempData
};
// Act
var result = controller.Delete(testDeleteCompany.Id);
// Assert
Assert.IsInstanceOf <RedirectToActionResult>(result);
var redirectToActionResult = result as RedirectToActionResult;
Assert.AreEqual("Index", redirectToActionResult.ActionName);
Assert.AreEqual(tempData["Message"], "Bedrijf verwijderd");
}
public void Details_ForEmployeeId_ReturnsEmployee()
{
//Arrange
Employee testEmployee = SeedTestData.GetTestEmployee();
Guid testEmployeeId = testEmployee.Id;
mockRepo.Setup(e => e.Employee.GetEmployee(testEmployeeId, It.IsAny <bool>())).Returns(testEmployee);
EmployeeManagerController controller = new EmployeeManagerController(mockRepo.Object);
//Act
var result = controller.Details(testEmployeeId);
//Assert
Assert.IsInstanceOf <ViewResult>(result); //Klassiek assertions model van Nunit: testen op type
ViewResult viewResult = result as ViewResult;
Assert.That(viewResult.Model, Is.TypeOf <Employee>()); //Constraint assertions model van Nunit: testen op type
//of: Assert.IsInstanceOf<Employee>(viewResult.Model); //Klassiek assertions model van Nunit: testen op type
Employee employee = (Employee)viewResult.Model; //of casting via 'as' operator: viewResult.Model as Employee
Assert.AreEqual(testEmployeeId, employee.Id);
//Nog wat extra testjes voor de andere Employee Properties:
Assert.AreEqual(testEmployee.Name, employee.Name);
Assert.AreEqual(testEmployee.Description, employee.Description);
Assert.AreEqual(testEmployee.Age, employee.Age);
Assert.AreEqual(testEmployee.CompanyId, employee.CompanyId);
Assert.AreEqual(testEmployee.Position, employee.Position);
}
public static void Main(string[] args)
{
Slug.Config = new SlugOptions();
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <AppDbContext>();
var roleManager = services.GetRequiredService <RoleManager <Role> >();
var userManager = services.GetRequiredService <UserManager <User> >();
context.Database.Migrate();
SeedTestData.SeedData(context, roleManager, userManager);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred during migration");
}
}
host.Run();
}
private async Task SeedDatabase(DbContextOptions <ApplicationDbContext> options)
{
using (var context = new ApplicationDbContext(options))
{
context.Database.EnsureCreated();
SeedTestData.Seed(context);
await context.SaveChangesAsync();
}
}
public DatabaseFixture()
{
var services = new ServiceCollection();
services.AddDbContext <BookContext>(options =>
options.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()),
ServiceLifetime.Scoped, ServiceLifetime.Scoped);
var serviceProvider = services.BuildServiceProvider();
context = serviceProvider.GetRequiredService <BookContext>();
// load all tables
SeedTestData.loadNames(context);
SeedTestData.loadAuthors(context);
SeedTestData.loadBooks(context);
context.SaveChanges();
}
public void Insert_InsertsEmployeeAndReturnsAViewResult_WithAnEmployee()
{
//Arrange
mockRepo.Setup(repo => repo.Employee.CreateEmployeeForCompany(It.IsAny <Guid>(), It.IsAny <Employee>()))
.Verifiable(); //om te kunnen testen of de methode CreateEmployeeForCompany wordt aangeroepen
var controller = new EmployeeManagerController(mockRepo.Object);
var newEmployee = SeedTestData.GetTestEmployee();
//Act
var result = controller.Insert(newEmployee);
//Assert
Assert.IsInstanceOf <ViewResult>(result);
var viewResult = result as ViewResult;
Assert.AreEqual(viewResult.Model, newEmployee);
mockRepo.Verify();//Hier wordt geverifieerd om de CreateEmployeeForCompany wordt aangeroepen, indien ja, is de test ok
}
public void Insert_InsertsCompanyAndReturnsAViewResult_WithAnCompany()
{
// Arrange
var newCompany = SeedTestData.GetTestCompany();
mockRepo.Setup(repo => repo.Company.CreateCompany(newCompany))
.Verifiable(); //newCompany geeft 'nauwere test' ipv It.IsAny<Company>());
var controller = new CompanyManagerController(mockRepo.Object);
// Act
var result = controller.Insert(newCompany);
// Assert
Assert.IsInstanceOf <ViewResult>(result);
var viewResult = result as ViewResult;
Assert.AreEqual(viewResult.Model, newCompany);
mockRepo.Verify();
}
public void Index_ReturnsAViewResult_WithListOfEmployees()
{
//Arrange
mockRepo.Setup(repo => repo.Employee.GetAllEmployees(false))
.Returns(SeedTestData.GetTestEmployees());
var controller = new EmployeeManagerController(mockRepo.Object);
//Act
var result = controller.Index();
//Assert
Assert.IsInstanceOf <ViewResult>(result);
ViewResult viewResult = result as ViewResult; //casting, kan ook via (ViewResult)result
Assert.IsAssignableFrom <List <Employee> >(viewResult.ViewData.Model);
List <Employee> model = viewResult.ViewData.Model as List <Employee>;
Assert.AreEqual(2, model.Count());
//bv eerste van de testEmployees testen op Id:
Assert.IsTrue(model.Where(emp => emp.Id == SeedTestData.GetTestEmployee().Id).Any());
}
public void Update_Employee_ReturnViewResult_WithEmployee()
{
//Arrange
Employee employeeToUpdate = SeedTestData.GetTestEmployee();
Guid employeeToUpdateId = employeeToUpdate.Id;
mockRepo.Setup(repo => repo.Employee.GetEmployee(employeeToUpdateId, true))
.Returns(employeeToUpdate);
mockRepo.Setup(repo => repo.Save()).Verifiable();
var controller = new EmployeeManagerController(mockRepo.Object);
employeeToUpdate.Name = "gewijzigde naam";
//Act
var result = controller.Update(employeeToUpdate);
//Assert
Assert.IsInstanceOf <ViewResult>(result);
ViewResult viewResult = result as ViewResult;
Assert.AreEqual(employeeToUpdate, viewResult.Model);
mockRepo.Verify();
}
public void Update_Company_ReturnsViewResult_WithCompany()
{
// Arrange
Company companyToUpdate = SeedTestData.GetTestCompany();
Guid testCompanyId = companyToUpdate.Id;
mockRepo.Setup(repo => repo.Company.GetCompany(testCompanyId, true))
.Returns(companyToUpdate);
mockRepo.Setup(repo => repo.Save()).Verifiable();
var controller = new CompanyManagerController(mockRepo.Object);
companyToUpdate.Name = "gewijzigde naam";
//Act
var result = controller.Update(companyToUpdate);
// Assert
Assert.IsInstanceOf <ViewResult>(result);
ViewResult viewResult = result as ViewResult;
Assert.AreEqual(companyToUpdate, viewResult.Model);
mockRepo.Verify();
}
public void Index_ReturnsAViewResult_WithListOfCompanies()
{
//Oefening: maak aan het voorbeeld van de EmployeeMangerControllerTest
//de test methode voor Index van CompanyManagerController
//oplossing:
// Arrange
var controller = new CompanyManagerController(mockRepo.Object);
// Act
var result = controller.Index();
// Assert
Assert.IsInstanceOf <ViewResult>(result);
var viewResult = result as ViewResult;
Assert.IsAssignableFrom <List <Company> >(
viewResult.ViewData.Model);
var model = viewResult.ViewData.Model as List <Company>;
Assert.AreEqual(2, model.Count());
//bv eerste van de testCompanies testen op Id:
Assert.IsTrue(model.Where(comp => comp.Id == SeedTestData.GetTestCompany().Id).Any());
}
public void Initialize()
{
mockRepo = new Mock <IRepositoryManager>();
mockRepo.Setup(repo => repo.Company.GetAllCompanies(false))
.Returns(SeedTestData.GetTestCompanies());
}
public static Employee GetTestEmployee()
{
return(SeedTestData.GetTestEmployees().FirstOrDefault());
}
