public void ShouldReturnModelToDetailsView()
{
var controller = new EmployeeController(new FakeEmployeeService());
EmployeeListViewModel model = controller.Details(2).Model as EmployeeListViewModel;
Assert.IsNotNull(model);
Assert.AreEqual(20, model.Employees.Count());
Assert.AreEqual(2, model.PageInfo.CurrentPage);
Assert.AreEqual(20, model.PageInfo.TotalItems);
}
static void Main(string[] args)
{
var controller = new EmployeeController(
new EmployeeService(),
emp => new EmployeeViewModel {FullName = $"{emp.FirstName} {emp.LastName}"});
System.Console.WriteLine("Hello " + controller.GetEmployee(2).FullName);
System.Console.WriteLine("Press any key to continue.");
System.Console.ReadKey();
}
public async Task WhenGetEmployeeShouldReturnValidData()
{
//Arrange
var mockEmployeeService = new Mock <IEmployeeServices>();
mockEmployeeService.Setup(c => c.GetEmployeeById(1)).ReturnsAsync((EmployeeViewModel) new EmployeeViewModel {
Id = 1, FirstName = "sanjay", LastName = "Pakale"
});
var controller = new EmployeeController(mockEmployeeService.Object);
//Act
//await is required as action method is a asynchrouns.
var result = await controller.GetEmployee(1);
//Assert
Assert.IsType <OkObjectResult>(result);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <EmployeeViewModel>(okResult.Value);
Assert.Equal("sanjay", returnValue.FirstName);
}
/// <summary>
/// Provides a list of Contract Distributor as a result of filtering the DB on specific filters
/// </summary>
/// <returns></returns>
public List <ContractDistributor> FilteredItems()
{
ResultManager.IsCorrect = false;
List <ContractDistributor> items = new List <ContractDistributor>();
try
{
// implementing filtering pipeline
var contractDistributorList = RetrieveAllToFilter();
ContractDistributorFilteringPipeline pipeline = new ContractDistributorFilteringPipeline();
EmployeeController employee = new EmployeeController(Configurations);
int distributorId = employee.GetDistributorId(CurrentUser.Id);
pipeline.Register(new DistributorIdFilter(distributorId));
items = pipeline.Process(contractDistributorList).ToList();
ResultManager.IsCorrect = true;
}
catch (Exception ex)
{
ResultManager.Add(ErrorDefault, Trace + "Index.311: Error while retrieving ContractDistributor list from DB: " + ex.Message);
}
return(items);
}
protected void Page_Load(object sender, EventArgs e)
{
//EmployeeName = null;
if (Request.IsAuthenticated)
{
UserNameLabel2.Text = User.Identity.Name;
if (User.IsInRole("Race Coordinator"))
{
var username = User.Identity.Name;
SecurityController securitymgr = new SecurityController();
int?employeeid = securitymgr.GetCurrentUserEmployeeId(username);
if (employeeid.HasValue)
{
MessageUserControl.TryRun(() =>
{
EmployeeController sysmgr = new EmployeeController();
Employee info = sysmgr.Employee_Get(employeeid.Value);
//EmployeeName.Text = info.FullName;
UserNameLabel2.Text = info.FullName;
});
}
else
{
MessageUserControl.ShowInfo("Unregistered User", "This user is not a registered customer");
//EmployeeName.Text = "Unregistered User";
}
}
else
{
//redirect to a page that states no authorization fot the request action
Response.Redirect("~/Security/AccessDenied.aspx");
}
}
else
{
//redirect to login page
Response.Redirect("~/Account/Login.aspx");
}
}
public void TestDeleteEmployee()
{
// seeding DB
using (var context = new ProTickDatabaseContext(dbOptions))
{
DbContextSeeder.SeedFull(context);
}
// db is Test-Ready
using (var context = new ProTickDatabaseContext(dbOptions))
{
var dbm = new DatabaseQueryManager(context);
var converter = new ResourceDTOConverter(dbm);
var hasher = new Hasher();
var controller = new EmployeeController(context, converter, dbm, hasher);
var dtos = DbContextSeeder.GetSeededEmployeeDTOs(
3,
DbContextSeeder.GetSeededAddressDTOs(3),
DbContextSeeder.GetSeededRoleDTOs(3)
)
.ToList();
controller.DeleteEmployee(dtos[2].EmployeeID);
var actualCount = context.Employee.ToList().Count;
Assert.Equal(2, actualCount);
Assert.True(context.Employee.FirstOrDefault(x => x.EmployeeID == 3) == null);
Assert.True(context.Employee.FirstOrDefault(x => x.EmployeeID != 3) != null);
controller.DeleteEmployee(dtos[1].EmployeeID);
actualCount = context.Employee.ToList().Count;
Assert.Equal(1, actualCount);
Assert.True(context.Employee.FirstOrDefault(x => x.EmployeeID == 2) == null);
}
}
public void TestPostAddProfession()
{
var newProfessions = new List <string> {
"testProfOne", "testProfTwo"
};
var expected = new EmployeeModel()
{
Age = _testEmployeeModel.Age,
FirstName = _testEmployeeModel.FirstName,
LastName = _testEmployeeModel.LastName,
Professions = new List <ProfessionModel>(_testEmployeeModel.Professions)
};
newProfessions.ForEach(n => expected.Professions.Add(new ProfessionModel {
ProfessionName = n
}));
var mock = new Mock <IEmployeeDbContext>();
mock.Setup(x => x.FindModelById(It.Is <int>(id => id == 1)))
.Returns(_testEmployeeModel);
mock.Setup(x => x.SaveChanges());
var controller = new EmployeeController(mock.Object);
var actionResult = controller.AddProfession(new NewProfessionsDto {
Id = 1, ProfessionNames = newProfessions
});
var actual = actionResult as OkNegotiatedContentResult <EmployeeModel>;
mock.Verify(x => x.FindModelById(It.IsAny <int>()));
mock.Verify(x => x.SaveChanges());
Assert.IsNotNull(actual);
var compareLogic = new CompareLogic(_config);
var comparationResult = compareLogic.Compare(expected, actual.Content);
Assert.IsTrue(comparationResult.AreEqual, comparationResult.DifferencesString);
}
private void buttonSrcE_Click(object sender, EventArgs e)
{
string errMsg = "";
bool hasErr = false;
string srcE = "";
if (textBoxSrcE.Text.Equals(""))
{
errMsg += "Employee Username required.\n";
hasErr = true;
}
else
{
srcE = textBoxSrcE.Text;
}
if (!hasErr)
{
string username = srcE;
dynamic employee = EmployeeController.GetEmployee(username);
if (employee != null)
{
textBoxEName.Text = employee.Name;
textBoxEUName.Text = employee.Username;
}
else
{
textBoxEName.Text = "";
textBoxEUName.Text = "";
MessageBox.Show("No employee Found");
}
}
else
{
MessageBox.Show(errMsg);
}
}
private void loginButton_Click(object sender, EventArgs e)
{
var theController = new EmployeeController();
var id = 0;
int.TryParse(this.usernameTextBox.Text, out id);
DialogResult = DialogResult.None;
if (id != 0)
{
var theUser = new LoginSession();
try
{
theUser = theController.ValidateUserOnNetwork(id, this.passwordTextBox.Text);
}
catch (Exception exception)
{
ErrorHandler.DisplayErrorMessageToUserAndLog("Network Error",
"Unable to connect to SQL Database. Please try again.", exception);
}
if (theUser.IsAuthenticated)
{
Tag = theUser;
DialogResult = DialogResult.OK;
Close();
}
else
{
ErrorHandler.DisplayErrorBox("Login Error", "Invalid login information. Please try again.");
}
}
else
{
ErrorHandler.DisplayErrorBox("Login Error", "Invalid login information. Please try again.");
}
}
public void GetAllEmployee()
{
try
{
//Arrange
var empName = "senthil";
var controller = new EmployeeController(employeeBuiness);
// Act
var actionResult = controller.Get();
var json = JsonConvert.SerializeObject(actionResult);
var jobject = JObject.Parse(json);
var data = JsonConvert.SerializeObject(jobject["Value"]["Value"]["Data"]);
var empList = JsonConvert.DeserializeObject <List <Employee> >(data);
// Assert
Assert.IsNotNull(empList);
Assert.AreEqual(empName, empList[0].FirstName);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task When_GetEmployeeById_ShouldReturn_SuccessResult()
{
var service = new Mock <IEmployeeService>();
service.Setup(x => x.GetEmployeeById(It.IsAny <int>())).Returns(new Employee
{
ID = 10,
FirstName = "Harry",
LastName = "Potter",
Email = "*****@*****.**",
Password = "******",
PhoneNumber = "9876543215"
});
EmployeeController = new EmployeeController(service.Object);
OkObjectResult actionResult = (OkObjectResult)await EmployeeController.GetEmployeeById(10);
ResponseEntity responseEntity = (ResponseEntity)actionResult.Value;
Assert.IsNotNull(actionResult);
Assert.AreEqual(200, actionResult.StatusCode);
Assert.AreEqual(HttpStatusCode.Found, responseEntity.httpStatusCode);
Assert.AreEqual("Employee Data Found", responseEntity.message);
}
/// <summary>
/// Constructor For Setting Required References.
/// </summary>
public Tests()
{
var myConfiguration = new Dictionary <string, string>
{
{ "Jwt:Key", "ThisismySecretKey" },
{ "Jwt:Issuer", "https://localhost:44315/" },
{ "Jwt:Audiance", "https://localhost:44315/" },
{ "Logging:LogLevel:Default", "Warning" },
{ "AllowedHosts", "*" },
{ "ConnectionStrings:ConnectionString", "Server=localhost\\SQLEXPRESS;Database=EmployeeManagement;Trusted_Connection=True;" }
};
this.configuration = new ConfigurationBuilder()
.AddInMemoryCollection(myConfiguration)
.Build();
employeeManagementRL = new EmployeeManagementRL(configuration);
employeeManagementBL = new EmployeeManagementBL(employeeManagementRL);
distributedCache = new RedisCache(new RedisCacheOptions
{
Configuration = "localhost:6379"
});
controller = new EmployeeController(employeeManagementBL, distributedCache, configuration);
}
public void PositiveTest_GetEmployee_FromPassedRepo_EmployeesAreCreated()
{
var employeeMock1 = new Mock <Employee>().As <ITaxableEmployee>();
var employeeMock2 = new Mock <Employee>().As <ITaxableEmployee>();
employeeMock1.Setup(emp => emp.FirstName).Returns("TestName1");
employeeMock2.Setup(emp => emp.FirstName).Returns("TestName2");
List <ITaxableEmployee> taxableEmployees = new List <ITaxableEmployee>();
taxableEmployees.Add(employeeMock1.Object);
taxableEmployees.Add(employeeMock2.Object);
var mockRepo = new Mock <IProxyRepo <ITaxableEmployee> >();
mockRepo.Setup(x => x.Entities).Returns(taxableEmployees);
var employeeControllerSUT = new EmployeeController(mockRepo.Object);
var fromGet = employeeControllerSUT.Get().Content;
Assert.AreEqual(2, fromGet.Count);
Assert.IsTrue(fromGet[0].FirstName.Equals(employeeMock1.Object.FirstName));
Assert.IsTrue(fromGet[1].FirstName.Equals(employeeMock2.Object.FirstName));
}
public async Task Edit_Get_SetViewBagPosts()
{
Mock <EmployeeService> mock = new Mock <EmployeeService>();
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.Edit(1)) as ViewResult;
SelectListItem item = (result.ViewBag.Posts as SelectList).FirstOrDefault();
Assert.AreEqual("Programmer [IT]", item.Text);
Assert.AreEqual("2", item.Value);
}
public async Task Edit_Post_ModelIsInvalid_RetrievesEmployeeFromModel()
{
Mock <EmployeeService> mock = new Mock <EmployeeService>();
mock.Setup(m => m.EditAsync(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.Edit(new EmployeeViewModel {
Id = 2,
LastName = "Brown",
Contacts = new Models.Contacts {
Email = "*****@*****.**"
}
})) as ViewResult;
EmployeeViewModel model = result.ViewData.Model as EmployeeViewModel;
Assert.AreEqual(2, model.Id);
Assert.AreEqual("Brown", model.LastName);
Assert.AreEqual("*****@*****.**", model.Contacts.Email);
}
public async Task PutEmployee_Returns_NotFound()
{
Employee employee = null;
_mockEmployeeManager.Setup(x => x.Get(1)).ReturnsAsync(employee);
EmployeeModel employeeModel = new EmployeeModel
{
Id = 1,
GivenName = "Kiran",
SurName = "Kumar",
DateOfBirth = new DateTime(1990, 3, 3)
};
var employeeController = new EmployeeController(_mockEmployeeManager.Object)
{
Request = new HttpRequestMessage(),
Configuration = new System.Web.Http.HttpConfiguration()
};
var result = await employeeController.Put(1, employeeModel);
//asert if returns ok status code
Assert.IsTrue(result.StatusCode == System.Net.HttpStatusCode.NotFound);
}
private void btnSubmit_Click(object sender, RoutedEventArgs e)
{
string email = txtEmail.Text;
string password = txtPassword.Password;
var employee = EmployeeController.getInstance().getEmployee(email, password);
int departmentID = (int)employee.DepartmentID;
if (employee != null)
{
MessageBox.Show("Login Success!");
IView view = ViewFactory.getInstance(employee);
view.show();
Close();
}
else
{
MessageBox.Show("Login Failed!");
}
}
public void EmployeeGetById()
{
try
{
var empId = 1;
//Arrange
var controller = new EmployeeController(employeeBuiness);
// Act
var actionResult = controller.Get(empId);
var json = JsonConvert.SerializeObject(actionResult);
var jobject = JObject.Parse(json);
var employee = jobject["Value"]["Value"].ToObject <Employee>();
// Assert
Assert.IsNotNull(employee);
Assert.AreEqual(empId, employee.Id);
}
catch (Exception ex)
{
throw ex;
}
}
public void EmployeeGetByEmail()
{
try
{
var empEmail = "*****@*****.**";
//Arrange
var controller = new EmployeeController(employeeBuiness);
// Act
var actionResult = controller.SelectbyEmail(empEmail);
var json = JsonConvert.SerializeObject(actionResult);
var jobject = JObject.Parse(json);
var employee = jobject["Value"]["Value"].ToObject <Employee>();
// Assert
Assert.IsNotNull(employee);
Assert.AreEqual(empEmail, employee.Email);
}
catch (Exception ex)
{
throw ex;
}
}
public void Test1()
{
var MockEmployeeServiceProxy = new Mock <IEmployeeServiceProxy>();
MockEmployeeServiceProxy.Setup(w => w.GetAll()).Returns(Task.FromResult(new List <Models.Employee> {
new Models.Employee {
EmployeeId = 1,
FirstName = "aa",
LastName = "bb",
HireDate = new DateTime(2020, 2, 5)
}
}));
var emp = new EmployeeController(MockEmployeeServiceProxy.Object);
var result = emp.Index();
var viewresult = Assert.IsType <ViewResult>(result.Result);
var model = Assert.IsAssignableFrom <List <Models.Employee> >(viewresult.ViewData.Model);
Assert.Contains("aa", model[0].FirstName);
Assert.Contains("bb", model[0].LastName);
Assert.Contains("02/05/2020", model[0].HireDate.ToString("MM/dd/yyyy"));
}
public void PostCreate_NotValidModelSelectedDepartmentNull_ViewCreate()
{
// Arrange
EmployeeController controller = new EmployeeController(mock.Object);
controller.ModelState.AddModelError("DepartmentID", "Field DepartmentID must be not null");
Employee emp = (from e in mock.Object.Employees where e.EmployeeID == 1 select e).FirstOrDefault();
EmployeeViewModel employee = new EmployeeViewModel(emp);
SelectList departmentDropDownList = controller.DepartmentsDropDownList();
// Act
var view = controller.Create(emp);
SelectList select = ((ViewResult)view).ViewBag.DepartmentsList as SelectList;
// Assert
mock.Verify(m => m.SaveEmployee(It.IsAny <Employee>()), Times.Never());
Assert.IsTrue(view != null);
Assert.IsTrue(((ViewResult)view).ViewName == "");
Assert.IsInstanceOf(typeof(EmployeeViewModel), ((ViewResult)view).Model);
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 TestCheckSameWhiteListGroup()
{
var groupAppService = Substitute.For <IGroupAppService>();
groupAppService.CheckSameWhiteListGroupAsync(User_EmployeeMdmId, Arg.Any <Guid>())
.Returns(Task.FromResult(true));
var target = new EmployeeController(
CreateMemoryCache(),
CreateMapper(),
Substitute.For <IDepartmentAppService>(),
Substitute.For <IPositionAppService>(),
Substitute.For <IEmployeeAppService>(),
groupAppService,
_ => Substitute.For <IUserFavoriteAppService>(),
_ => Substitute.For <IUserSettingAppService>());
target.ControllerContext = CreateMockContext();
var result = await target.CheckSameWhiteListGroup(Guid.NewGuid());
result.Value.Should().BeTrue();
}
public async Task TestRemoveFavorite()
{
var userFavoriteAppService = Substitute.For <IUserFavoriteAppService>();
userFavoriteAppService.RemoveEmployeeAsync(User_Id, Arg.Any <Guid>())
.Returns(Task.FromResult(true));
var target = new EmployeeController(
CreateMemoryCache(),
CreateMapper(),
Substitute.For <IDepartmentAppService>(),
Substitute.For <IPositionAppService>(),
Substitute.For <IEmployeeAppService>(),
Substitute.For <IGroupAppService>(),
_ => userFavoriteAppService,
_ => Substitute.For <IUserSettingAppService>());
target.ControllerContext = CreateMockContext();
var result = await target.RemoveFavorite(Guid.NewGuid());
result.Value.Status.Should().Be(0);
}
private void load()
{
txtName.Text = "Good to see you back, " + employee.Name + "!";
List <PersonalRequest> pers_reqs = PersonalRequestController.getInstance().getAll();
var pers_status = pers_reqs.Where(p => p.Type == "Leaving permit" && p.Status == "Pending");
var pers_filtered = pers_status.Select(p => new
{
p.Id,
EmployeeName = p.Employee.Name,
p.Title,
p.Description,
p.Date
});
viewEmployee.ItemsSource = EmployeeController.getInstance().getAll();
viewLeaving.ItemsSource = pers_filtered;
viewPers.ItemsSource = getPersList();
viewFund.ItemsSource = getFundList();
viewWork.ItemsSource = getWorkList();
}
public void Setup()
{
var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.test.json", false, true).Build();
var databaseConfiguration = new DatabaseConfiguration();
configuration.GetSection("Database").Bind(databaseConfiguration);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(databaseConfiguration);
serviceCollection.AddSingleton <IEmployeeLogic, EmployeeLogic>();
serviceCollection.AddSingleton <IEmployeeRepository, EmployeeRepository>();
_serviceProvider = serviceCollection.BuildServiceProvider();
var employeeLogic = _serviceProvider.GetService <IEmployeeLogic>();
_employeeController = new EmployeeController(employeeLogic)
{
ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
}
};
}
public async Task Edit_Get_ModelIsValid_RetrievesEmployeeFromModel()
{
Mock <EmployeeService> emock = new Mock <EmployeeService>();
emock.Setup(m => m.FindByIdAsync(It.IsAny <int?>())).ReturnsAsync((int?_id) => new EmployeeDTO {
Id = _id.Value,
LastName = "Brown",
Contacts = new BLL.DTO.Contacts {
Email = "*****@*****.**"
}
});
Mock <DepartmentService> dmock = new Mock <DepartmentService>();
Mock <PostService> pmock = new Mock <PostService>();
EmployeeController controller = GetNewEmployeeController(emock.Object, dmock.Object, pmock.Object);
ViewResult result = (await controller.Edit(1)) as ViewResult;
EmployeeViewModel model = result.ViewData.Model as EmployeeViewModel;
Assert.AreEqual(1, model.Id);
Assert.AreEqual("Brown", model.LastName);
Assert.AreEqual("*****@*****.**", model.Contacts.Email);
}
public async void BulkInsert_Errors()
{
EmployeeControllerMockFacade mock = new EmployeeControllerMockFacade();
var mockResponse = new Mock <CreateResponse <ApiEmployeeServerResponseModel> >(null as ApiEmployeeServerResponseModel);
mockResponse.SetupGet(x => x.Success).Returns(false);
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiEmployeeServerRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiEmployeeServerResponseModel> >(mockResponse.Object));
EmployeeController controller = new EmployeeController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var records = new List <ApiEmployeeServerRequestModel>();
records.Add(new ApiEmployeeServerRequestModel());
IActionResult response = await controller.BulkInsert(records);
response.Should().BeOfType <ObjectResult>();
(response as ObjectResult).StatusCode.Should().Be((int)HttpStatusCode.UnprocessableEntity);
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiEmployeeServerRequestModel>()));
}
protected void SearchEmployeesPartial_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(PartialEmployeeNameV2.Text))
{
errormsgs.Add("Please enter a partial employee name for the search");
LoadMessageDisplay(errormsgs, "alert alert-info");
EmployeeGridViewV2.DataSource = null;
EmployeeGridViewV2.DataBind();
}
else
{
try
{
EmployeeController sysmgr = new EmployeeController();
List <EmployeeEntity> info = sysmgr.FindByPartialName(PartialEmployeeNameV2.Text);
if (info.Count == 0)
{
errormsgs.Add("No data found for the partial employee name search");
LoadMessageDisplay(errormsgs, "alert alert-info");
}
else
{
info.Sort((x, y) => x.FullName.CompareTo(y.FullName));
//load the multiple record control
//GridView
EmployeeGridViewV2.DataSource = info;
EmployeeGridViewV2.DataBind();
}
}
catch (Exception ex)
{
errormsgs.Add(GetInnerException(ex).ToString());
LoadMessageDisplay(errormsgs, "alert alert-danger");
}
}
}
public void AddEmployee()
{
var existing_mgr = new Manager
{
first_name = "John",
last_name = "Baker",
mgr_id = Guid.NewGuid()
};
var emp_id = Guid.NewGuid();
var emp = new Employee
{
emp_id = emp_id,
first_name = "Sam",
last_name = "Frank",
mgr_id = existing_mgr.mgr_id,
mgr = existing_mgr,
dept = "IT",
start_date = DateTime.Now,
title = "Network Engineer"
};
var vm = new EmployeeViewModel(emp);
var mockEmp = new Mock <DbSet <Employee> >();
mockEmp.Setup(m => m.Find(emp_id)).Returns(emp);
var mockEmpContext = new Mock <ManagerEmpContext>();
mockEmpContext.Setup(m => m.Employee).Returns(mockEmp.Object);
var controller1 = new EmployeeController(mockEmpContext.Object);
controller1.AddEmployee(vm);
mockEmp.Verify(m => m.Add(It.IsAny <Employee>()), Times.Once());
}
private void btnIniciarsesion_Click(object sender, EventArgs e)
{
if (textBox1.Text.Equals(""))
{
MessageBox.Show("El Campo no puede quedar vacio");
}
else
{
try
{
User u = new User();
u = EmployeeController.Exist(list[comboBox2.SelectedIndex].name, textBox1.Text);
Form temp = this.FindForm();
temp.Hide();
//temp.Dispose();
if (u.idDepartament == 1)
{
frmAdmi admin = new frmAdmi();
admin.ShowDialog();
}
if (u.idDepartament == 3)
{
FrmEmployee employee = new FrmEmployee(u);
employee.ShowDialog();
}
if (u.idDepartament == 2)
{
frmVigilant employeee = new frmVigilant(u);
employeee.ShowDialog();
}
}
catch (UserException)
{
MessageBox.Show("Error");
}
}
}
public async Task GetEmployee_ReturnsBadRequestResult_WhenEmployeeIdNull()
{
// Arrange
var options = new DbContextOptionsBuilder <EmployeeContext>()
.UseInMemoryDatabase(databaseName: "EmployeeDataBase")
.Options;
//// Create mocked Context by seeding Data as per Schema///
using (var context = new EmployeeContext(options))
{
context.Employee.Add(new Employee
{
Name = "Alice",
ID = "40100002",
Address = "san francisco",
Role = "Technical Manager",
Department = "IoT",
SkillSet = "Angular",
DateOfBirth = "09-MAY-1984",
DateOfJoining = "09-MAY-2006",
IsActive = true
});
context.SaveChanges();
}
using (var context = new EmployeeContext(options))
{
// Act
EmployeeController controller = new EmployeeController(context);
var result = await controller.GetEmployee(null);
// Assert
var badRequestResult = Assert.IsType <NotFoundResult>(result.Result);
}
}
public void Filter_Employee()
{
Mock <IEmployeeRepository> mockData = new Mock <IEmployeeRepository>();
mockData.Setup(m => m.Employees).Returns(new List <Employee> {
new Employee {
EmployeeID = 1, Name = "Name1", Status = true
},
new Employee {
EmployeeID = 2, Name = "Name2", Status = true
},
new Employee {
EmployeeID = 3, Name = "Name3", Status = false
},
new Employee {
EmployeeID = 4, Name = "Name4", Status = true
},
new Employee {
EmployeeID = 5, Name = "Name5", Status = false
}
});
EmployeeController controller = new EmployeeController(mockData.Object, new Mock <ITax>().Object);
List <Employee> employeesActiv = ((IEnumerable <Employee>)controller.ListActiv().Model).ToList();
List <Employee> employeesNoActiv = ((IEnumerable <Employee>)controller.ListNoActiv().Model).ToList();
Assert.IsTrue(employeesActiv.Count == 3);
Assert.AreEqual(employeesActiv[0].Name, "Name1");
Assert.AreEqual(employeesActiv[1].Name, "Name2");
Assert.AreEqual(employeesActiv[2].Name, "Name4");
Assert.IsTrue(employeesNoActiv.Count == 2);
Assert.AreEqual(employeesNoActiv[0].Name, "Name3");
Assert.AreEqual(employeesNoActiv[1].Name, "Name5");
}
public static EmployeeController Fixture()
{
EmployeeController controller = new EmployeeController(new EmployeeRepository(), "", new LoginView());
return controller;
}
