public async Task UseTheCreateEntityAsyncToCreateNewEntity()
{
await _controller.Create(inputData);
_service.Verify(s => s.CreateEntityAsync(inputData), Times.Once);
_service.VerifyNoOtherCalls();
}
public async Task Create_WhenAuthenticatedRequestReceivedWithInvalidModelState_ThenRedirectToCreateViewActionReturned()
{
var employee = EmployeeProvider.GetOnePreCreationTestEmployee();
_mockAuthService
.Setup(a => a.IsAuthenticated(_user))
.Returns(true);
_mockRepository
.Setup(r => r.AddAsync(employee))
.ReturnsAsync(EmployeeProvider.GetOnePostCreationTestEmployee());
var controller = new EmployeeController(_mockAuthService.Object, _mockRepository.Object, _mockService.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = _user
}
};
controller.ModelState.AddModelError("Forename", "Forename maximum length reached");
var actual = await controller.Create(employee) as ViewResult;
Assert.IsNotNull(actual);
Assert.IsInstanceOf <ViewResult>(actual);
Assert.That("Create", Is.EqualTo(actual.ViewName));
}
public async Task Create_WhenAuthenticatedRequestReceived_ThenRedirectToReadViewActionReturned()
{
var employee = EmployeeProvider.GetOnePreCreationTestEmployee();
_mockAuthService
.Setup(a => a.IsAuthenticated(_user))
.Returns(true);
_mockRepository
.Setup(r => r.AddAsync(employee))
.ReturnsAsync(EmployeeProvider.GetOnePostCreationTestEmployee());
var controller = new EmployeeController(_mockAuthService.Object, _mockRepository.Object, _mockService.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = _user
}
};
var actual = await controller.Create(employee) as RedirectToActionResult;
Assert.IsNotNull(actual);
Assert.IsTrue(actual.ActionName == "Read");
Assert.IsTrue(actual.ControllerName == "Employee");
}
public async Task Create_Post_ModelIsInvalid_SetViewBagPosts()
{
Mock <EmployeeService> mock = new Mock <EmployeeService>();
mock.Setup(m => m.CreateAsync(It.IsAny <EmployeeDTO>())).Throws(new ValidationException("", ""));
Mock <DepartmentService> dmock = new Mock <DepartmentService>();
Mock <PostService> pmock = new Mock <PostService>();
pmock.Setup(m => m.GetAllAsync()).ReturnsAsync(new PostDTO[] {
new PostDTO()
{
Id = 2, Title = "Programmer", Department = new DepartmentDTO {
DepartmentName = "IT"
}
}
});
EmployeeController controller = GetNewEmployeeController(mock.Object, dmock.Object, pmock.Object);
ViewResult result = (await controller.Create(null)) as ViewResult;
SelectListItem item = (result.ViewBag.Posts as SelectList).FirstOrDefault();
Assert.AreEqual("Programmer [IT]", item.Text);
Assert.AreEqual("2", item.Value);
}
public void Checking_Insert_Integration()
{
emp.Name = "sravani";
emp.Address = "Eluru";
emp.Description = "sravani";
bool expected = true;
var actionresult = employeeController.Create(emp);
JsonResult json = (JsonResult)actionresult;
var orginal = json.Data;
Assert.AreEqual(expected, orginal);
//
// TODO: Add test logic here
//
}
public void VerifyCreateEmployeeRedirectsToError()
{
_employeeRepository.Setup(x => x.Save(It.IsAny <Employee>()));
var employee = new Employee()
{
Id = 1
};
//Mocking the _employeeController.ModelState.IsValid = false
_employeeController.ModelState.AddModelError("Error", "Name is Required");
var createResult = _employeeController.Create(employee) as ViewResult;
Assert.NotNull(createResult);
Assert.Equal("Create", createResult.ViewName);
}
public async Task Create_Get_SetViewBagPosts()
{
Mock <EmployeeService> emock = new Mock <EmployeeService>();
emock.Setup(m => m.CountAsync()).ReturnsAsync(2);
Mock <DepartmentService> dmock = new Mock <DepartmentService>();
Mock <PostService> pmock = new Mock <PostService>();
pmock.Setup(m => m.GetAllAsync()).ReturnsAsync(new PostDTO[] {
new PostDTO()
{
Id = 2, Title = "Programmer", NumberOfUnits = 3, Department = new DepartmentDTO {
DepartmentName = "IT"
}
}
});
EmployeeController controller = GetNewEmployeeController(emock.Object, dmock.Object, pmock.Object);
ViewResult result = (await controller.Create()) as ViewResult;
SelectListItem item = (result.ViewBag.Posts as SelectList).FirstOrDefault();
Assert.AreEqual("Programmer [IT]", item.Text);
Assert.AreEqual("2", item.Value);
}
public async Task CreatePost_SavesData_AndReturnsRedirectToAction_WhenModelIsValid()
{
//Arrange
var options = TestFactory.CreateDbContextOptions("EmpControllerCreateDb");
using var context = new AppDbContext(options);
//add department
var department = new Department {
DepartmentName = "Emp"
};
await context.AddAsync(department);
await context.SaveChangesAsync();
var newEmployee = new Employee
{
FirstName = "First",
LastName = "Last",
ContactNumber = "2222333",
DepartmentId = department.DepartmentId
};
var controller = new EmployeeController(context);
//Act
var result = await controller.Create(newEmployee);
//Assert
Assert.IsType <RedirectToActionResult>(result);
Assert.NotEmpty(await context.Employees.ToListAsync());
}
public void Create_PostRedirectOnSuccess()
{
EmployeeController controller = GetEmployeeController(new InMemoryEmployeeRepository());
Employee model = GetEmployeeID();
var result = (RedirectToRouteResult)controller.Create(model);
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public void tests()
{
var data = new List <Employee>
{
new Employee {
ID = 1, FirstName = "Hunt1", LastName = "Huang1", HiredDate = DateTime.Parse("2020-12-01")
},
new Employee {
ID = 2, FirstName = "Hunt2", LastName = "Huang2", HiredDate = DateTime.Parse("2020-12-01")
}
}.AsQueryable();
var mockSet = new Mock <DbSet <Employee> >();
mockSet.As <IQueryable <Employee> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <Employee> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <Employee> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <Employee> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <EmployeeContext>();
mockContext.Setup(c => c.Employees).Returns(mockSet.Object);
// Arrange
var controller = new EmployeeController(mockContext.Object);
// Act
ViewResult result = controller.Index() as ViewResult;
// Assert
Assert.IsNotNull(result);
// Act
var details = controller.Details(null);
// Assert
Assert.AreEqual(details.GetType(), typeof(HttpStatusCodeResult));
// Act
var detailsWithResult = controller.Details(1);
// Assert
Assert.IsNotNull(detailsWithResult);
// Act
var createResult = controller.Create(
new Employee {
ID = 3, FirstName = "Hunt1", LastName = "Huang1", HiredDate = DateTime.Parse("2020-12-01")
});
// Assert
Assert.IsNotNull(createResult);
mockSet.Verify(m => m.Add(It.IsAny <Employee>()), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
public async Task Create_Post_ModelIsValid_RedirectToIndex()
{
Mock <EmployeeService> mock = new Mock <EmployeeService>();
EmployeeController controller = GetNewEmployeeController(mock.Object, null, null);
RedirectToRouteResult result = (await controller.Create(null)) as RedirectToRouteResult;
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public async Task Create_When_There_Are_Notifications_Should_Return_BadRequest(
EmployeeCreateModel employeeCreateModel,
EmployeeController sut)
{
sut.NotificationStore.HasNotifications().Returns(true);
var actual = await sut.Create(employeeCreateModel);
actual.Should().BeOfType <BadRequestObjectResult>();
}
public void ViewIsNotValid()
{
EmployeeController empcontroller = GetEmployeeController(new InMemoryEmployeeRepository());
empcontroller.ModelState.AddModelError("", "mock error message");
Employee model = GetEmployeeName(1, "", "", "", "", "", "");
var result = (ViewResult)empcontroller.Create(model);
Assert.AreEqual("Create", result.ViewName);
}
public void Create_PostEmployeeInRepository()
{
InMemoryEmployeeRepository emprepository = new InMemoryEmployeeRepository();
EmployeeController empcontroller = GetEmployeeController(emprepository);
Employee employee = GetEmployeeID();
empcontroller.Create(employee);
IEnumerable <Employee> employees = emprepository.GetAllEmployee();
Assert.IsTrue(employees.Contains(employee));
}
public void Create()
{
// Arrange
EmployeeController controller = new EmployeeController();
// Act
ViewResult result = controller.Create() as ViewResult;
// Assert
Assert.IsNotNull(result);
}
private void CreateSampleData()
{
var employees = new List <Employee>
{
new Employee {
EmployeeId = 1, FirstName = "John", LastName = "Smith", Address = "1900 E 400 S, Salt Lake City, Utah", Age = 35, Interests = "Reading"
},
new Employee {
EmployeeId = 2, FirstName = "Taylor", LastName = "Swift", Address = "1906 E 900 S, Salt Lake City, Utah", Age = 30, Interests = "Learning new technologies"
},
new Employee {
EmployeeId = 3, FirstName = "Shawn", LastName = "Michael", Address = "1910 E 400 S, Salt Lake City, Utah", Age = 25, Interests = "Surfing"
},
new Employee {
EmployeeId = 4, FirstName = "Adam", LastName = "Frisbee", Address = "1900 E 400 S, Salt Lake City, Utah", Age = 27, Interests = "Listening music"
},
new Employee {
EmployeeId = 5, FirstName = "Chris", LastName = "Densie", Address = "1900 E 400 S, Salt Lake City, Utah", Age = 29, Interests = "Reading"
},
new Employee {
EmployeeId = 6, FirstName = "Jennifer", LastName = "Hanson", Address = "1900 E 400 S, Salt Lake City, Utah", Age = 40, Interests = "Dancing"
},
new Employee {
EmployeeId = 7, FirstName = "Lucy", LastName = "Laputka", Address = "1900 E 400 S, Salt Lake City, Utah", Age = 25, Interests = "Singing"
},
new Employee {
EmployeeId = 8, FirstName = "Mike", LastName = "Boyle", Address = "1900 E 400 S, Salt Lake City, Utah", Age = 35, Interests = "Reading"
},
new Employee {
EmployeeId = 9, FirstName = "Boniface", LastName = "Nautwarama", Address = "1900 E 400 S, Salt Lake City, Utah", Age = 45, Interests = "Acting"
},
new Employee {
EmployeeId = 10, FirstName = "Ryan", LastName = "Kenneth", Address = "1900 E 400 S, Salt Lake City, Utah", Age = 25, Interests = "Reading"
},
new Employee {
EmployeeId = 11, FirstName = "Jeff", LastName = "Philips", Address = "1900 E 400 S, Salt Lake City, Utah", Age = 28, Interests = "Learning"
}
};
employees.ForEach(e => employeeController.Create(e, null));
}
public void Create_Get_ReturnsView()
{
// Arrange
var mockrepo = new Mock <IEmployeeService>();
var controller = new EmployeeController(mockrepo.Object);
// Act
var result = controller.Create();
// Assert
Assert.NotNull(result as ViewResult);
}
public async Task Create_Post_ModelIsInvalid_AsksForCreateView()
{
Mock <EmployeeService> mock = new Mock <EmployeeService>();
mock.Setup(m => m.CreateAsync(It.IsAny <EmployeeDTO>())).Throws(new ValidationException("", ""));
Mock <DepartmentService> dmock = new Mock <DepartmentService>();
Mock <PostService> pmock = new Mock <PostService>();
EmployeeController controller = GetNewEmployeeController(mock.Object, dmock.Object, pmock.Object);
ViewResult result = (await controller.Create(null)) as ViewResult;
Assert.AreEqual("Create", result.ViewName);
}
public void ReturnEmployeeCreateView()
{
// Arrange
var mockRepo = new Mock <IEmployeeRepository>();
var nullLogger = new NullLogger <EmployeeController>();
var controller = new EmployeeController(mockRepo.Object, map.Mapper, nullLogger);
// Act
var result = controller.Create();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
}
private void buttonAddEmp_Click(object sender, EventArgs e)
{
Data.employee = null;
Data.departmentsList = departmentController.GetDepartments();
EmployeeForm empForm = new EmployeeForm();
if (empForm.ShowDialog() == DialogResult.OK)
{
employeeController.Create(Data.employee);
UpdateDataGrid(Data.employee.DepartmentID);
}
Data.employee = null;
}
public void Create_CreatesAnEmployeeAndReturnOkResult()
{
// Arrange
var repo = new EmployeeRepository(Context);
var service = new EmployeeService(repo);
var controller = new EmployeeController(service);
// Act
var result = controller.Create(GetTestEmployee(0));
// Assert
Assert.IsType <OkResult>(result);
}
public void TestEmployeeCreateErrorView()
{
var obj = new EmployeeController();
ViewResult result = obj.Create(new Employee()
{
PRI = 21354,
FirstName = "Hasan",
LastName = "Skaiky"
}) as ViewResult;
Assert.That(result.ViewName, Is.EqualTo("Error"));
}
public void Should_Return_View()
{
// Arrange
var mockRepoEmployeeService = new Mock <IEmployeeService>();
var mockRepoLogger = new Mock <ILogger <EmployeeController> >();
var controller = new EmployeeController(mockRepoEmployeeService.Object, mockRepoLogger.Object);
// Act
var result = controller.Create();
// Assert
Assert.NotNull(result);
}
private void createEmpButton_Click(object sender, EventArgs e)
{
try
{
String tempId = empIdTextBox.Text;
tempId = tempId.Trim();
if (String.IsNullOrEmpty(tempId))
{
lblresponse.Text = "Id box is empty";
return;
}
Employee emp = new Employee();
emp.EmployeeId = Int32.Parse(tempId);
emp.Name = empNameTextBox.Text;
emp.Name = emp.Name.Trim();
if (emp.EmployeeId < 0)
{
lblresponse.Text = "Id is less than 0";
return;
}
if (String.IsNullOrEmpty(emp.Name))
{
lblresponse.Text = "You need to write a name";
return;
}
if (cmbCompanyEmployee.SelectedItem == null)
{
emp.CompanyId = 0;
}
else
{
emp.CompanyId = Int32.Parse(cmbCompanyEmployee.Text);
}
bool success = EmployeeController.Create(emp);
if (success)
{
lblresponse.Text = "Employee Created";
}
else
{
lblresponse.Text = "Failed to create Employee";
}
}
catch (Exception ex)
{
lblresponse.Text = ErrorHandlern.HandleExceptions(ex);
}
FillListWithAllEmployees();
}
public void Create_WhenNonAuthenticatedRequestForViewReceived_ThenRedirectToSignInViewActionReturned()
{
_mockAuthService
.Setup(a => a.IsAuthenticated(_user))
.Returns(false);
var controller = new EmployeeController(_mockAuthService.Object, _mockRepository.Object, _mockService.Object);
var actual = controller.Create() as RedirectToActionResult;
Assert.IsNotNull(actual);
Assert.IsTrue(actual.ActionName == "SignIn");
Assert.IsTrue(actual.ControllerName == "Authentication");
}
public void Create_ReturnBadRequestWhenModelStateIsInvalid()
{
// Arrange
var repo = new EmployeeRepository(Context);
var service = new EmployeeService(repo);
var controller = new EmployeeController(service);
var employee = GetTestEmployee(0);
controller.ModelState.AddModelError("Surname", "The field is required");
// Act
var result = controller.Create(employee);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public async Task WhenCreateShouldReturnBadResult()
{
//Arrange
var mockEmployeeService = new Mock <IEmployeeServices>();
mockEmployeeService.Setup(repo => repo.AddEmployee(null)).ReturnsAsync((Employee) new Employee {
Id = 2, FirstName = "test"
});
var controller = new EmployeeController(mockEmployeeService.Object);
//Act
//await is required as action method is a asynchrouns.
var result = await controller.Create(new EmployeeViewModel { });
//Assert
Assert.IsType <BadRequestResult>(result);
}
public async Task Create_Get_NoVacancy_AsksForErrorView()
{
Mock <EmployeeService> emock = new Mock <EmployeeService>();
emock.Setup(m => m.CountAsync()).ReturnsAsync(2);
Mock <DepartmentService> dmock = new Mock <DepartmentService>();
Mock <PostService> pmock = new Mock <PostService>();
pmock.Setup(m => m.GetAllAsync()).ReturnsAsync(new PostDTO[] { new PostDTO {
NumberOfUnits = 2
} });
EmployeeController controller = GetNewEmployeeController(emock.Object, dmock.Object, pmock.Object);
ViewResult result = (await controller.Create()) as ViewResult;
Assert.AreEqual("Error", result.ViewName);
}
public void GetCreate_SelectedDepartmentNull_ViewCreateSelectedDepartmentNull()
{
// Arrange
EmployeeController controller = new EmployeeController(mock.Object);
string selectedDepartment = null;
SelectList departmentDropDownList = controller.DepartmentsDropDownList();
// Act
var view = controller.Create(selectedDepartment);
SelectList select = ((ViewResult)view).ViewBag.DepartmentsList as SelectList;
// Assert
Assert.IsTrue(((ViewResult)view).ViewName == "");
Assert.AreEqual(selectedDepartment, ((ViewResult)view).ViewBag.SelectedDepartment);
Assert.AreEqual(departmentDropDownList.ToArray().Length, select.ToArray().Length);
Assert.AreEqual(departmentDropDownList.ToArray()[0].Value, select.ToArray()[0].Value);
Assert.AreEqual(departmentDropDownList.ToArray()[6].Value, select.ToArray()[6].Value);
}
public async Task Create_When_There_Are_No_Notifications_Should_Create_Employee(
EmployeeCreateModel employeeCreateModel,
EmployeeController sut)
{
sut.NotificationStore.HasNotifications().Returns(false);
var actual = await sut.Create(employeeCreateModel);
actual.Should().BeOfType <CreatedResult>();
actual.As <CreatedResult>()
.Value
.Should()
.BeOfType <EmployeeModel>()
.Subject
.Should()
.BeEquivalentTo(employeeCreateModel);
}
