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