public void Get_WhenCalled_ReturnsOkResult()
{
// Act
var okResult = _controller.GetEmployees();
// Assert
Assert.IsType <OkObjectResult>(okResult.Result);
}
public void EmployeesControllerTest()
{
var moqReporsitory = new MockRepository(MockBehavior.Default);
List <Employees> mockEmployees = new List <Employees> {
new Employees {
ID = 1, FirstName = "Test 1", MiddleName = "Test 2", LastName = "Test 3", Salary = 1000
},
new Employees {
ID = 2, FirstName = "Test 2", MiddleName = "Test 2", LastName = "Test 3", Salary = 1000
},
new Employees {
ID = 3, FirstName = "Test 3", MiddleName = "Test 2", LastName = "Test 3", Salary = 1000
},
new Employees {
ID = 4, FirstName = "Test 4", MiddleName = "Test 2", LastName = "Test 3", Salary = 1000
}
};
var employeesRepository = moqReporsitory.Create <IEmployeesRepository>();
//This line means - Whenerver "GetEmployees" function get called then return "mockEmployees" list
employeesRepository.Setup(repository => repository.GetEmployees()).Returns(mockEmployees);
var employeesCOntroller = new EmployeesController(employeesRepository.Object);
var actionResult = employeesCOntroller.GetEmployees() as OkObjectResult;
Assert.AreEqual((actionResult.Value as List <Employees>).Count(), mockEmployees.Count);
// This lines verifies that "GetEmployees" function should get invoked or called atleast once.
// This is called behavioural testing
employeesRepository.Verify(repository => repository.GetEmployees(), times: Times.Exactly(1));
}
public async Task EmployeeController_GetEmployees_Test()
{
var employeeRepository = new Data.Repositories.Fakes.StubIEmployeeRepository();
var ADGraphAPI = new Web.Security.Fakes.StubIADGraphApi();
employeeRepository.GetAllAsync = () =>
{
return(Task.FromResult(new List <Employee>()
{
new Employee()
{
EmployeeId = 1
}, new Employee()
{
EmployeeId = 2
}
}.AsEnumerable()));
};
var target = new EmployeesController(employeeRepository, new SecurityHelper(), ADGraphAPI);
var result = await target.GetEmployees();
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count());
}
public void GetEmployees_ReturnsEmployeesData()
{
//Arrange
var employeesSummary = new List <EmployeeSummary>
{
new EmployeeSummary {
ID = 1, EmployeeName = "First"
},
new EmployeeSummary {
ID = 2, EmployeeName = "second"
}
};
var employeeSummaryService = new Mock <IEmployeeSummaryService>();
employeeSummaryService.Setup(p => p.GetEmployeesSummary()).Returns(employeesSummary);
var controller = new EmployeesController(employeeSummaryService.Object);
//Act
var employees = controller.GetEmployees();
//Assert
Assert.IsAssignableFrom <IEnumerable <EmployeeSummary> >(employees);
var employee = employees.First(e => e.ID == 1);
Assert.Equal("First", employee.EmployeeName);
}
public async void GetEmployees()
{
var response = await _controller.GetEmployees();
var responseValue = Assert.IsAssignableFrom <IEnumerable <EmployeeDTO> >(response.Value);
Assert.Equal(3, responseValue.Count());
}
public async Task Get_All_Employees()
{
OkObjectResult result = (await _employeesController.GetEmployees()).Result as OkObjectResult;
Assert.IsNotNull(result);
Assert.IsNotNull(result.Value);
Assert.IsInstanceOf <IEnumerable <EmployeeViewModel> >(result.Value);
}
public void GetAllEmployees()
{
EmployeesController ec = new EmployeesController();
var testEmployees = GetTestEmployees();
var result = ec.GetEmployees();
Assert.AreEqual(testEmployees.Count, result.Count);
}
private void BookingForm_Load(object sender, EventArgs e)
{
lb_Products.DisplayMember = "Title";
lb_Services.DisplayMember = "Title";
cb_employee.DataSource = employeeController.GetEmployees();
cb_employee.DisplayMember = "FirstName";
dgv_bookings.DataSource = bookingsController.GetBookingsByEmployee((Employee)cb_employee.SelectedItem, dateTime1.SelectionStart);
//dgv_bookings.DataSource = bookingsController.GetAllBookings();
}
public async Task TestGetEmployeesNotFound()
{
_repository.Setup(repo => repo.GetEmployeesAsync()).ReturnsAsync(new List <Employee>());
var employeeController = new EmployeesController(_repository.Object, _mapper);
var result = await employeeController.GetEmployees();
Assert.IsInstanceOfType(result.Result, typeof(NotFoundObjectResult));
}
public async Task TestGetEmployees()
{
_repository.Setup(repo => repo.GetEmployeesAsync()).ReturnsAsync(GetTestEmployees());
var employeeController = new EmployeesController(_repository.Object, _mapper);
var result = await employeeController.GetEmployees();
Assert.IsInstanceOfType(result.Result, typeof(OkObjectResult));
Assert.AreEqual("Rakshi N S", ((result.Result as OkObjectResult).Value as List <EmployeeToReturn>).First().EmployeeName);
}
public async Task GetEmployees_WithNoParameters_ShouldBeOk()
{
//Execute
var response = await _controller.GetEmployees(null, null, null);
//Assert
Assert.NotNull(response);
Assert.IsTrue(response is OkObjectResult);
var result = response as OkObjectResult;
Assert.AreEqual((int)HttpStatusCode.OK, result.StatusCode);
Assert.IsTrue(result.Value is List <Employee>);
var body = (List <Employee>)result.Value;
Assert.IsNotEmpty(body);
Assert.IsTrue(body.Count == body.Select(e => e.EmployeeId).Count());
}
public void BasicResultTesting()
{
EmployeesController controller = new EmployeesController();
List <Employee> result = controller.GetEmployees();
Assert.IsNotNull(result);
Assert.AreEqual("Sindhuja", result.ToArray()[0].FirstName);
Assert.AreEqual("Steve", result.ToArray()[3].FirstName);
}
public async Task DisplayAllEmployee()
{
var context = CreateContextForSQLite();
var getEmployees = await GetTestEmployees(context);
var controller = new EmployeesController(getEmployees);
var result = await controller.GetEmployees();
Assert.Equal(await getEmployees.Employees.ToListAsync(), result.Value);
}
public async void Get_All_Employees()
{
using (var context = GetContextWithData())
using (var controller = new EmployeesController(context))
{
var result = await controller.GetEmployees();
output.WriteLine(result.Count().ToString());
Assert.True(result.Count() != 0);
}
}
public void GetAllEmployeeTests()
{
// ACT
IHttpActionResult actionResult = _employeesController.GetEmployees();
var contentResult = actionResult as OkNegotiatedContentResult <IQueryable <Employee> >;
// ASSERT
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(contentResult.Content.Count(), 9);
}
public void GetAllEmployees()
{
var controller = new EmployeesController(context);
controller.Configuration = new HttpConfiguration();
WebApiConfig.Register(controller.Configuration);
var result = controller.GetEmployees();
Assert.AreEqual(context.Employees.Local.Count, result.Count());
}
public async void Task_GetEmployee_Return_OkResult()
{
//Arrange
var dbContext = DbContextMocker.GetMyDbContext(nameof(Task_GetEmployee_Return_OkResult));
var controller = new EmployeesController(dbContext);
//Act
var data = await controller.GetEmployees();
//Assert
Assert.Equal(3, data.Value.Count());
}
public async Task GetEmployees_Should_Return_Collection_With_Members_From_Company_With_ID_2()
{
var moq = new Mock <IEmployeeManager>();
moq.Setup(x => x.All(2)).ReturnsAsync(this.data.GetAllEmployees(2));
var controller = new EmployeesController(moq.Object);
var employees = await controller.GetEmployees(2);
Assert.AreEqual(2, employees.FirstOrDefault().CompanyId);
}
public void GetEmployees_DatabaseReturnEmployees_ReturnCorrectEmployees()
{
unitOfWork.Setup(uow => uow.Employees.GetAll())
.Returns(GetEmployeesList());
var response = controller.GetEmployees() as OkNegotiatedContentResult <IEnumerable <ApplicationUserDto> >;
var employees = response.Content;
Assert.IsNotNull(response);
Assert.That(employees.Count, Is.EqualTo(2));
Assert.That(employees.ElementAt(0).Name, Is.EqualTo("Test"));
Assert.That(employees.ElementAt(0).JobTitle, Is.EqualTo("Test"));
}
public void ShouldGetEmployeesWhenCalled()
{
var pageNumber = 1;
var pageSize = 10;
_employeeService.GetEmployees(pageNumber, pageSize).Returns(GetMockEmployees());
_employeesController = new EmployeesController(_employeeService, _employeeValidator, _logger);
var employees = _employeesController.GetEmployees(pageNumber, pageSize);
Assert.NotNull(employees);
Assert.Single(employees);
}
public async Task GetEmployees_ActionExecute_ReturnAllEmployees()
{
// Arrange
_mockrepo.Setup(repo => repo.Employee.GetEmployeesAsync())
.ReturnsAsync(GetTestEmployees());
// Act
var result = await _controller.GetEmployees();
// Assert
var okresult = Assert.IsType <OkObjectResult>(result);
var employees = Assert.IsAssignableFrom <IEnumerable <EmployeeViewModel> >(okresult.Value);
employees.Should().HaveCount(2);
//Assert.Equal(2, employees.Should().HaveCount(2));
}
public async void AddEmployeeStats()
{
eCtrl = new EmployeesController();
List <Employee> employees = await eCtrl.GetEmployees(EmployeeId);
int b = 0;
foreach (Employee e in employees)
{
if (employees.Count > 0)
{
b++;
}
}
lblNoOfEmployees.Text = "Number of Employees: " + b;
}
public async Task EmployeesController_GetEmployees_Test()
{
bool called = false;
var employeeRepository = new Data.Repositories.Fakes.StubIEmployeeRepository();
employeeRepository.GetEmployeesAsyncStringPictureTypeInt32Int32 = (id, picture, pageSize, pageCount) =>
{
called = true;
return(Task.FromResult((new List <Employee>()).AsEnumerable()));
};
var target = new EmployeesController(employeeRepository, new SecurityHelper());
var result = await target.GetEmployees(string.Empty, PictureType.Small, 1, 1);
Assert.IsNotNull(result);
Assert.IsTrue(called);
}
public void PostAndGetTest()
{
var options = new DbContextOptionsBuilder <PharmacyDBContext>()
.UseSqlServer("Server=localhost\\SQLEXPRESS;Database=PharmacyDB; Trusted_Connection=True;MultipleActiveResultSets=true")
.Options;
var context = new PharmacyDBContext(options);
EmployeesController controller = new EmployeesController(context);
var TestEmployees = new Employees {
FullName = "UnitTest2", Salary = System.Convert.ToDecimal(1111.22222), IdBranch = 1
};
var CallBack = (Employees)((CreatedAtActionResult)controller.PostEmployees(TestEmployees).Result.Result).Value;
var result = controller.GetEmployees(CallBack.Id).Result.Value;
Assert.Equal(CallBack, result);//Assert
}
public async void AddDataToTable()
{
EmployeesController eCtrl = new EmployeesController();
SessionsController sCtrl = SessionsController.Instance;
employeesGridView.UseWaitCursor = true;
try {
employeesGridView.DataSource = await eCtrl.GetEmployees(sCtrl.EmployeeId);
}
catch (Exception) {
MessageBox.Show("No connection to service");
}
employeesGridView.Columns["Password"].Visible = false;
employeesGridView.Columns["Salt"].Visible = false;
employeesGridView.Columns["Venues"].Visible = false;
employeesGridView.UseWaitCursor = false;
employeesGridView.ClearSelection();
employeesGridView.CurrentCell = null;
}
protected void listChiTiet_CustomCallback(object sender, DevExpress.Web.ASPxGridView.ASPxGridViewCustomCallbackEventArgs e)
{
string s = e.Parameters.ToString();
List <EmployeesInfo> lsEmp = new List <EmployeesInfo>();
foreach (string sItem in s.Split(','))
{
if (string.IsNullOrEmpty(sItem))
{
continue;
}
int id = Convert.ToInt32(sItem);
employees = objEmployees.GetEmployees(id);
lsEmp.Add(employees);
}
listChiTiet.DataSource = lsEmp;
listChiTiet.DataBind();
}
public void GetEmployees_ReturnsOkResult_WithListOfEmployees()
{
// Arrange
var controller = new EmployeesController(mockRepo.Object, _mapper);
// Act
var result = controller.GetEmployees();
// Assert
Assert.IsInstanceOf <OkObjectResult>(result.Result);
var okResult = result.Result as OkObjectResult;
Assert.IsInstanceOf <IEnumerable <EmployeeDto> >(okResult.Value);
var items = okResult.Value as IEnumerable <EmployeeDto>;
Assert.AreEqual(2, items.Count());
//bv eerste van de testEmployees testen op Id:
Assert.IsTrue(items.Where(emp => emp.Id == SeedTestData.GetTestEmployee().Id).Any());
}
private void BookingForm_Load(object sender, EventArgs e)
{
lb_employee.DataSource = employeeController.GetEmployees();
lb_employee.DisplayMember = "FirstName";
foreach (Service service in servicesController.GetAllServices())
{
ListViewItem i = new ListViewItem();
i.Tag = service;
i.Text = service.Title;
i.ToolTipText = service.Price.ToString();
lv_services.Items.Add(i);
}
foreach (Product product in productsController.GetAllProducts())
{
ListViewItem i = new ListViewItem();
i.Tag = product;
i.Text = product.Title;
i.ToolTipText = product.RetailPrice.ToString();
lv_products.Items.Add(i);
}
}
public void GetTest()
{
var options = new DbContextOptionsBuilder <PharmacyDBContext>()
.UseSqlServer("Server=localhost\\SQLEXPRESS;Database=PharmacyDB; Trusted_Connection=True;MultipleActiveResultSets=true")
.Options;
var context = new PharmacyDBContext(options);
EmployeesController controller = new EmployeesController(context);
var TestEmployees = new Employees
{
Id = 1,
FullName = "Some Name",
IdBranch = 1,
Salary = System.Convert.ToDecimal(100.0000),
IdBranchNavigation = { }
};
var result = controller.GetEmployees(TestEmployees.Id).Result.Value;
Assert.Equal(TestEmployees.FullName, result.FullName); //Assert
Assert.Equal(TestEmployees.Salary, result.Salary); //Assert
}
public async Task Get_All_Test()
{
EmployeesController target = new EmployeesController(this.employeesRepository.Object, this.mapper.Object);
target.ControllerContext = new ControllerContext();
target.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult result = await target.GetEmployees(null);
var okObjectResult = result as OkObjectResult;
Assert.IsNotNull(okObjectResult);
var employees = okObjectResult.Value as List <EmployeeForListDto>;
Assert.IsNotNull(employees);
Assert.AreEqual(2, employees.Count);
Assert.IsNotNull(employees.Find(x => x.Id == 1));
Assert.IsNotNull(employees.Find(x => x.Id == 2));
this.employeesRepository.Verify(m => m.Get(It.IsAny <FilterParams>()), Times.Once);
}