public void GetEmployee_ParametersMatchExpectedValues()
{
//Arrange
var dbOptions = new DbContextOptionsBuilder <VisitPopDbContext>()
.UseInMemoryDatabase(databaseName: $"EmployeeDb{Guid.NewGuid()}")
.Options;
var sieveOptions = Options.Create(new SieveOptions());
var fakeEmployee = new FakeEmployee {
}.Generate();
//Act
using (var context = new VisitPopDbContext(dbOptions))
{
context.Employees.AddRange(fakeEmployee);
context.SaveChanges();
var service = new EmployeeRepository(context, new SieveProcessor(sieveOptions));
//Assert
var empleadoById = service.GetEmployee(fakeEmployee.Id);
empleadoById.Id.Should().Be(fakeEmployee.Id);
empleadoById.FirstName.Should().Be(fakeEmployee.FirstName);
empleadoById.LastName.Should().Be(fakeEmployee.LastName);
empleadoById.DocId.Should().Be(fakeEmployee.DocId);
empleadoById.PhoneNumber.Should().Be(fakeEmployee.PhoneNumber);
empleadoById.EmployeeDepartmentId.Should().Be(fakeEmployee.EmployeeDepartmentId);
empleadoById.EmailAddress.Should().Be(fakeEmployee.EmailAddress);
empleadoById.EmployeeDepartments.Should().Be(fakeEmployee.EmployeeDepartments);
}
}
public void HttpPost_ReturnRedirectToRouteResult_WhenModelStateIsValid()
{
// Arrange
var mapService = new Mock <IMapService>();
var employeeService = new Mock <IEmployeeService>();
var pagerFactory = new Mock <IPagerFactory>();
var id = 20;
var employeeModel = new Mock <EmployeesViewModel>();
employeeModel.SetupProperty(x => x.Id, id);
Employee mockedEmployee = new FakeEmployee()
{
Id = id,
FirstName = "Georgi",
MiddleName = "Petrov",
LastName = "Nikolov",
};
employeeService.Setup(x => x.GetById(id)).Returns(mockedEmployee).Verifiable();
mapService.Setup(x => x.Map <Employee>(employeeModel.Object)).Returns(mockedEmployee).Verifiable();
// Act
EmployeeAdminController EmployeeController = new EmployeeAdminController(mapService.Object, pagerFactory.Object, employeeService.Object);
// Assert
Assert.IsInstanceOf <RedirectToRouteResult>(EmployeeController.Edit(employeeModel.Object));
}
public void GetTop_ShouldInvokeOnlyOnce()
{
// Arrange
var mockedRepository = new Mock <IRepository <Employee> >();
var emplService = new EmployeeService(mockedRepository.Object);
Employee employee = new FakeEmployee();
Employee employee2 = new FakeEmployee();
Employee employee3 = new FakeEmployee();
employee.Id = 2;
employee2.Id = 3;
employee3.Id = 4;
// Act
emplService.Create(employee);
emplService.Create(employee2);
emplService.Create(employee3);
emplService.GetTop(3);
// Assert
mockedRepository.Verify(r => r.All, Times.Once);
}
public void ReturnCreateLaborContractViewModel_WhenModelStateIsNotValid()
{
// Arrange
var mapService = new Mock <IMapService>();
var employeeService = new Mock <IEmployeeService>();
var selfEmploymentService = new Mock <ISelfEmploymentService>();
var payrollCalculations = new Mock <Payroll>();
var id = 5;
var freelanceContractModel = new Mock <PreviewSelfEmploymentViewModel>();
freelanceContractModel.SetupProperty(x => x.GrossSalary, 1000);
Employee mockedEmployee = new FakeEmployee()
{
Id = id,
FirstName = "Alexander",
MiddleName = "Petrov",
LastName = "Vasilev",
PersonalId = "8010107070"
};
employeeService.Setup(x => x.GetById(id)).Returns(mockedEmployee).Verifiable();
// Act
FreelanceContractController laborController = new FreelanceContractController(mapService.Object, employeeService.Object, selfEmploymentService.Object, payrollCalculations.Object);
laborController.ModelState.AddModelError("invalid", "Invalid");
var result = laborController.CreateFreelanceContract(id, freelanceContractModel.Object) as ViewResult;
// Assert
Assert.IsInstanceOf <ViewResult>(result);
Assert.AreEqual(freelanceContractModel.Object, result.Model);
}
public void GetTop_ShouldReturnInstanceOfIQueryable()
{
// Arrange
var mockedRepository = new Mock <IRepository <Employee> >();
var emplService = new EmployeeService(mockedRepository.Object);
Employee employee = new FakeEmployee();
Employee employee2 = new FakeEmployee();
Employee employee3 = new FakeEmployee();
employee.Id = 2;
employee2.Id = 3;
employee3.Id = 4;
// Act
emplService.Create(employee);
emplService.Create(employee2);
emplService.Create(employee3);
var query = emplService.GetTop(3);
// Assert
Assert.IsInstanceOf <IQueryable <Employee> >(query);
}
public void HttpGet_ReturnEmployeesViewModel_WhenActionIsCalled()
{
// Arrange
var mapService = new Mock <IMapService>();
var employeeService = new Mock <IEmployeeService>();
var pagerFactory = new Mock <IPagerFactory>();
var id = 10;
var employeeModel = new Mock <EmployeesViewModel>();
employeeModel.Setup(x => x.Id).Returns(id).Verifiable();
Employee mockedEmployee = new FakeEmployee()
{
Id = id,
FirstName = "Georgi",
MiddleName = "Petrov",
LastName = "Nikolov",
};
employeeService.Setup(x => x.GetById(id)).Returns(mockedEmployee).Verifiable();
mapService.Setup(x => x.Map <EmployeesViewModel>(mockedEmployee)).Returns(employeeModel.Object).Verifiable();
// Act
EmployeeAdminController employeeController = new EmployeeAdminController(mapService.Object, pagerFactory.Object, employeeService.Object);
var result = employeeController.Edit(id, employeeModel.Object) as ViewResult;
// Assert
Assert.IsInstanceOf <EmployeesViewModel>(result.Model);
}
public void ReturnPreviewRemunerationBillViewModel_WhenModelStateIsValid()
{
// Arrange
var mapService = new Mock <IMapService>();
var employeeService = new Mock <IEmployeeService>();
var billService = new Mock <IRemunerationBillService>();
var payrollCalculations = new Mock <Payroll>();
var id = 5;
var nonLaborContractModel = new Mock <PreviewRemunerationBillViewModel>();
nonLaborContractModel.SetupProperty(x => x.GrossSalary, 1000);
Employee mockedEmployee = new FakeEmployee()
{
Id = id,
FirstName = "Alexander",
MiddleName = "Petrov",
LastName = "Vasilev",
PersonalId = "8010107070"
};
employeeService.Setup(x => x.GetById(id)).Returns(mockedEmployee).Verifiable();
// Act
NonLaborContractController laborController = new NonLaborContractController(mapService.Object, employeeService.Object, billService.Object, payrollCalculations.Object);
var result = laborController.CreateNonLaborContract(id, nonLaborContractModel.Object) as ViewResult;
// Assert
Assert.IsInstanceOf <ViewResult>(result);
Assert.AreEqual("Details", result.ViewName);
Assert.AreEqual(nonLaborContractModel.Object, result.Model);
}
public StaffController()
{
_Context = new SREDContext();
_EmployeeRepository = new EmployeeRepository(_Context);
_EmployeeHandler = new EmployeeHandler(_Context, _EmployeeRepository);
_projectEntryHandler = new ProjectEntryHandler(_Context, _projectEntryRepository);
_staffView = new StaffView();
_fakeEmployee = new FakeEmployee();
}
public async Task GetEmployee_ReturnsSuccessCodeAndResourceWithAccurateFields()
{
var fakeEmployee = new FakeEmployeeDepartment().Ignore(d => d.Id).Generate();
var fakeEmployeeOne = new FakeEmployee {
}.Ignore(t => t.Id)
.Ignore(d => d.EmployeeDepartmentId).Generate();
//fakeEmpleadoOne.DepartamentoEmpleadoId = fakeDepartamento.Id;
var fakeEmployeeTwo = new FakeEmployee {
}.Ignore(t => t.Id)
.Ignore(d => d.EmployeeDepartmentId).Generate();
//fakeEmpleadoTwo.DepartamentoEmpleadoId = fakeDepartamento.Id;
var appFactory = _factory;
using (var scope = appFactory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <VisitPopDbContext>();
context.Database.EnsureCreated();
context.EmployeeDepartments.AddRange(fakeEmployee);
context.SaveChanges();
fakeEmployee = context.EmployeeDepartments.FirstOrDefault();
fakeEmployeeOne.EmployeeDepartmentId = fakeEmployee.Id;
fakeEmployeeOne.EmployeeDepartments = fakeEmployee;
fakeEmployeeTwo.EmployeeDepartmentId = fakeEmployee.Id;
fakeEmployeeTwo.EmployeeDepartments = fakeEmployee;
//context.TipoPersonas.RemoveRange(context.TipoPersonas);
context.Employees.AddRange(fakeEmployeeOne, fakeEmployeeTwo);
context.SaveChanges();
}
var client = appFactory.CreateClient(new WebApplicationFactoryClientOptions
{
AllowAutoRedirect = false
});
var result = await client.GetAsync("api/Employees")
.ConfigureAwait(false);
var responseContent = await result.Content.ReadAsStringAsync()
.ConfigureAwait(false);
var response = JsonConvert.DeserializeObject <PageListEmployee>(responseContent).Employees;
// Assert
result.StatusCode.Should().Be(200);
response.Should().ContainEquivalentOf(fakeEmployeeOne, options =>
options.ExcludingMissingMembers());
response.Should().ContainEquivalentOf(fakeEmployeeTwo, options =>
options.ExcludingMissingMembers());
}
public void Create_ShouldInvokeOnce_WhenParameterIsCorrect()
{
var mockedRepository = new Mock <IRepository <Employee> >();
var emplService = new EmployeeService(mockedRepository.Object);
var employee = new FakeEmployee();
emplService.Create(employee);
mockedRepository.Verify(r => r.Add(employee), Times.Once);
}
public void GetAll_ShouldInvokeOnlyOnce()
{
var mockedRepository = new Mock <IRepository <Employee> >();
var emplService = new EmployeeService(mockedRepository.Object);
var employee = new FakeEmployee();
employee.Id = 2;
emplService.Create(employee);
mockedRepository.Verify(r => r.GetAll(), Times.Once);
}
public void Delete_ShouldInvokeOnce_WhenValidId_IsPassedCorrectly()
{
var mockedRepository = new Mock <IRepository <Employee> >();
var emplService = new EmployeeService(mockedRepository.Object);
var employee = new FakeEmployee();
employee.Id = 2;
emplService.Create(employee);
emplService.DeleteById(2);
mockedRepository.Verify(r => r.Delete(It.IsAny <Employee>()), Times.Once);
}
public void Create_ShouldInvokeOnce_WhenParameterIsPassedCorrectly()
{
// Arrange
var mockedRepository = new Mock <IRepository <Employee> >();
var emplService = new EmployeeService(mockedRepository.Object);
var employee = new FakeEmployee();
// Act
emplService.Create(employee);
// Assert
mockedRepository.Verify(r => r.Add(It.IsAny <Employee>()), Times.Once);
}
public void HttpGet_ReturnPreviewEmployeePaycheckViewModel_WhenPaycheckIsNotNull()
{
// Arrange
var mapService = new Mock <IMapService>();
var employeeService = new Mock <IEmployeeService>();
var paycheckService = new Mock <IEmployeePaycheckService>();
var payrollCalculations = new Mock <Payroll>();
var id = 5;
var laborContractModel = new Mock <PreviewEmployeePaycheckViewModel>();
var employeeId = 10;
Employee mockedEmployee = new FakeEmployee()
{
Id = employeeId,
FirstName = "Georgi",
MiddleName = "Georgiev",
LastName = "Georgiev",
PersonalId = "8010104050"
};
EmployeePaycheck mockedPaycheck = new FakeEmployeePaycheck()
{
Id = id,
GrossSalary = 1000,
GrossFixedBonus = 100,
GrossNonFixedBonus = 20,
SocialSecurityIncome = 670,
PersonalInsurance = 125,
IncomeTax = 90,
NetWage = 750,
Employee = mockedEmployee,
EmployeeId = mockedEmployee.Id
};
employeeService.Setup(x => x.GetById(10)).Returns(mockedEmployee).Verifiable();
paycheckService.Setup(x => x.GetById(id)).Returns(mockedPaycheck).Verifiable();
mapService.Setup(x => x.Map <PreviewEmployeePaycheckViewModel>(mockedPaycheck)).Returns(new PreviewEmployeePaycheckViewModel()
{
Id = id, EmployeeId = employeeId
}).Verifiable();
// Act
var laborController = new LaborContractController(mapService.Object, employeeService.Object, paycheckService.Object, payrollCalculations.Object);
var result = laborController.Edit(id, mockedPaycheck) as ViewResult;
// Assert
Assert.IsInstanceOf <PreviewEmployeePaycheckViewModel>(result.Model);
}
public void AddMethod_ShouldInvokedOnce_WhenParameterIsPassedCorrectly()
{
var fakeDbSet = new Mock <DbSet <FakeEmployee> >();
var fakeDbModel = new FakeEmployee();
var mockDbContext = new Mock <ISalaryCalculatorDbContext>();
mockDbContext.Setup(mock => mock.Set <FakeEmployee>()).Returns(fakeDbSet.Object);
var repo = new SalaryCalculatorRepository <FakeEmployee>(mockDbContext.Object);
// Act
repo.Add(fakeDbModel);
// Assert
mockDbContext.Verify(mock => mock.Entry(It.IsAny <FakeEmployee>()), Times.Once());
}
public void Update_ShouldUpdateEmployeeCorrectly()
{
// Arrange
var mockedRepository = new Mock <IRepository <Employee> >();
var emplService = new EmployeeService(mockedRepository.Object);
Employee employee = new FakeEmployee();
employee.Id = 2;
// Act
emplService.Create(employee);
emplService.UpdateById(2, employee);
// Assert
mockedRepository.Verify(x => x.Update(employee), Times.Once);
}
public void GetById_ShouldInvokeOnlyOnce()
{
// Arrange
var mockedRepository = new Mock <IRepository <Employee> >();
var emplService = new EmployeeService(mockedRepository.Object);
var employee = new FakeEmployee();
employee.Id = 2;
// Act
emplService.Create(employee);
emplService.GetById(employee.Id);
// Assert
mockedRepository.Verify(r => r.GetById(employee.Id), Times.Once);
}
public void ReturnCreateEmployeePaycheckViewModel_WhenActionIsCalled()
{
// Arrange
var mapService = new Mock <IMapService>();
var employeeService = new Mock <IEmployeeService>();
var paycheckService = new Mock <IEmployeePaycheckService>();
var payrollCalculations = new Mock <Payroll>();
var id = 5;
Employee mockedEmployee = new FakeEmployee()
{
Id = id,
FirstName = "Alexander",
MiddleName = "Petrov",
LastName = "Vasilev",
PersonalId = "8010107070"
};
EmployeePaycheck mockedPaycheck = new FakeEmployeePaycheck()
{
Id = 1,
EmployeeId = id,
Employee = mockedEmployee
};
employeeService.Setup(x => x.GetById(id)).Returns(mockedEmployee).Verifiable();
var laborContractModel = new CreateEmployeePaycheckViewModel();
mapService.Setup(x => x.Map <CreateEmployeePaycheckViewModel>(mockedPaycheck)).Returns(laborContractModel).Verifiable();
// Act
LaborContractController laborController = new LaborContractController(mapService.Object, employeeService.Object, paycheckService.Object, payrollCalculations.Object);
laborController.ModelState.AddModelError("invalid", "Invalid");
var result = laborController.CreateLaborContract(id, mockedPaycheck) as ViewResult;
// Assert
Assert.IsInstanceOf <ViewResult>(result);
Assert.AreEqual(laborContractModel, result.Model);
}
public void HttpPost_ReturnRedirectToRouteResult_WhenModelStateIsValid()
{
// Arrange
var mapService = new Mock <IMapService>();
var employeeService = new Mock <IEmployeeService>();
var selfEmploymentService = new Mock <ISelfEmploymentService>();
var payrollCalculations = new Mock <Payroll>();
var id = 5;
var freelanceContractModel = new Mock <PreviewSelfEmploymentViewModel>();
var employeeId = 10;
Employee mockedEmployee = new FakeEmployee()
{
Id = employeeId,
FirstName = "Georgi",
MiddleName = "Georgiev",
LastName = "Georgiev",
PersonalId = "8010104050"
};
var mockedBill = new FakeSelfEmployment()
{
Id = id,
GrossSalary = 1000,
SocialSecurityIncome = 670,
PersonalInsurance = 125,
IncomeTax = 90,
NetWage = 750,
Employee = mockedEmployee,
EmployeeId = mockedEmployee.Id
};
employeeService.Setup(x => x.GetById(10)).Returns(mockedEmployee).Verifiable();
selfEmploymentService.Setup(x => x.GetById(id)).Returns(mockedBill).Verifiable();
mapService.Setup(x => x.Map <SelfEmployment>(freelanceContractModel.Object)).Returns(mockedBill).Verifiable();
// Act
var nonLaborController = new FreelanceContractController(mapService.Object, employeeService.Object, selfEmploymentService.Object, payrollCalculations.Object);
// Assert
Assert.IsInstanceOf <RedirectToRouteResult>(nonLaborController.Edit(freelanceContractModel.Object));
}
public async void GetEmployeesAsync_ReturnExpectedPageSize()
{
//Arrange
var dbOptions = new DbContextOptionsBuilder <VisitPopDbContext>()
.UseInMemoryDatabase(databaseName: $"EmployeeDb{Guid.NewGuid()}")
.Options;
var sieveOptions = Options.Create(new SieveOptions());
var fakeEmployeeOne = new FakeEmployee {
}.Ignore(e => e.Id).Generate();
fakeEmployeeOne.Id = 1;
var fakeEmployeeTwo = new FakeEmployee {
}.Ignore(e => e.Id).Generate();
fakeEmployeeTwo.Id = 2;
var fakeEmployeeThree = new FakeEmployee {
}.Ignore(e => e.Id).Generate();
fakeEmployeeThree.Id = 3;
//Act
using (var context = new VisitPopDbContext(dbOptions))
{
context.Employees.AddRange(fakeEmployeeOne, fakeEmployeeTwo, fakeEmployeeThree);
context.SaveChanges();
var service = new EmployeeRepository(context, new SieveProcessor(sieveOptions));
var employeeRepo = await service.GetEmployeesAsync(new EmployeeParametersDto { PageSize = 2 });
//Assert
employeeRepo.Should()
.NotBeEmpty()
.And.HaveCount(2);
employeeRepo.Should().ContainEquivalentOf(fakeEmployeeOne);
employeeRepo.Should().ContainEquivalentOf(fakeEmployeeTwo);
context.Database.EnsureDeleted();
}
}
public async void GetEmployeesAsync_ListPhoneNumberSortedInDescOrder()
{
//Arrange
var dbOptions = new DbContextOptionsBuilder <VisitPopDbContext>()
.UseInMemoryDatabase(databaseName: $"EmployeeDb{Guid.NewGuid()}")
.Options;
var sieveOptions = Options.Create(new SieveOptions());
var fakeEmployeeOne = new FakeEmployee {
}.Generate();
fakeEmployeeOne.PhoneNumber = "bravo";
var fakeEmployeeTwo = new FakeEmployee {
}.Generate();
fakeEmployeeTwo.PhoneNumber = "alpha";
var fakeEmployeeThree = new FakeEmployee {
}.Generate();
fakeEmployeeThree.PhoneNumber = "charlie";
//Act
using (var context = new VisitPopDbContext(dbOptions))
{
context.Employees.AddRange(fakeEmployeeOne, fakeEmployeeTwo, fakeEmployeeThree);
context.SaveChanges();
var service = new EmployeeRepository(context, new SieveProcessor(sieveOptions));
var employeeRepo = await service.GetEmployeesAsync(new EmployeeParametersDto { SortOrder = "-PhoneNumber" });
//Assert
employeeRepo.Should()
.ContainInOrder(fakeEmployeeThree, fakeEmployeeOne, fakeEmployeeTwo);
context.Database.EnsureDeleted();
}
}
public async void GetEmployeesAsync_FilterEmailAddressListWithExact()
{
//Arrange
var dbOptions = new DbContextOptionsBuilder <VisitPopDbContext>()
.UseInMemoryDatabase(databaseName: $"EmployeeDb{Guid.NewGuid()}")
.Options;
var sieveOptions = Options.Create(new SieveOptions());
var fakeEmployeeOne = new FakeEmployee {
}.Generate();
fakeEmployeeOne.EmailAddress = "alpha";
var fakeEmployeeTwo = new FakeEmployee {
}.Generate();
fakeEmployeeTwo.EmailAddress = "bravo";
var fakeEmployeeThree = new FakeEmployee {
}.Generate();
fakeEmployeeThree.EmailAddress = "charlie";
//Act
using (var context = new VisitPopDbContext(dbOptions))
{
context.Employees.AddRange(fakeEmployeeOne, fakeEmployeeTwo, fakeEmployeeThree);
context.SaveChanges();
var service = new EmployeeRepository(context, new SieveProcessor(sieveOptions));
var employeeRepo = await service.GetEmployeesAsync(new EmployeeParametersDto { Filters = $"EmailAddress == {fakeEmployeeTwo.EmailAddress}" });
//Assert
employeeRepo.Should()
.HaveCount(1);
context.Database.EnsureDeleted();
}
}
public void DeleteEmployee_ReturnsProperCount()
{
//Arrange
var dbOptions = new DbContextOptionsBuilder <VisitPopDbContext>()
.UseInMemoryDatabase(databaseName: $"EmployeeDb{Guid.NewGuid()}")
.Options;
var sieveOptions = Options.Create(new SieveOptions());
var fakeEmployeeOne = new FakeEmployee {
}.Generate();
var fakeEmployeeTwo = new FakeEmployee {
}.Generate();
var fakeEmployeeThree = new FakeEmployee {
}.Generate();
//Act
using (var context = new VisitPopDbContext(dbOptions))
{
context.Employees.AddRange(fakeEmployeeOne, fakeEmployeeTwo, fakeEmployeeThree);
var service = new EmployeeRepository(context, new SieveProcessor(sieveOptions));
service.DeleteEmployee(fakeEmployeeTwo);
context.SaveChanges();
//Assert
var employeeList = context.Employees.ToList();
employeeList.Should()
.NotBeEmpty()
.And.HaveCount(2);
employeeList.Should().ContainEquivalentOf(fakeEmployeeOne);
employeeList.Should().ContainEquivalentOf(fakeEmployeeThree);
Assert.DoesNotContain(employeeList, e => e == fakeEmployeeTwo);
context.Database.EnsureDeleted();
}
}
public void ReturnIEnumerableOfEmployeesViewModel_WhenActionIsCalled()
{
// Arrange
var mockedMapService = new Mock <IMapService>();
var mockedEmployeeService = new Mock <IEmployeeService>();
var mockedPagerFactory = new Mock <IPagerFactory>();
var model = new Mock <EmployeesViewModel>();
var pageModel = new Mock <PageViewModel <EmployeesViewModel> >();
var employee = new FakeEmployee()
{
Id = 15
};
model.SetupProperty(x => x.Id, 15);
IEnumerable <Employee> collectionUsers = new List <Employee>()
{
employee
};
IEnumerable <EmployeesViewModel> collectionModelUsers = new List <EmployeesViewModel>()
{
model.Object
};
mockedEmployeeService.Setup(x => x.GetAll()).Returns(collectionUsers.AsQueryable()).Verifiable();
mockedMapService.Setup(x => x.Map <IEnumerable <EmployeesViewModel> >(collectionUsers)).Returns(collectionModelUsers).Verifiable();
mockedPagerFactory.Setup(x => x.CreatePager(1, null, 10)).Returns(new Pager(1, null, 10)).Verifiable();
pageModel.SetupProperty(x => x.Items, collectionModelUsers);
pageModel.SetupProperty(x => x.Pager, new Pager(collectionModelUsers.Count(), null));
// Act
EmployeeAdminController userController = new EmployeeAdminController(mockedMapService.Object, mockedPagerFactory.Object, mockedEmployeeService.Object);
var result = userController.Index(null, pageModel.Object) as ViewResult;
// Assert
Assert.IsInstanceOf <ViewResult>(result);
Assert.AreEqual(pageModel.Object, result.Model);
}
public static void Main()
{
// item 251
Bar db = new Bar();
// item 252
Bar.IDepartment yellow_m = db.InsertDepartment(0, "Yellow marketing");
Bar.IDepartment grey_m = db.InsertDepartment(0, "Grey marketing");
// item 253
Bar.IEmployee mark = db.InsertEmployee(10, "Mark");
Bar.IEmployee john = db.InsertEmployee(20, "John");
Bar.IEmployee scott = db.InsertEmployee(30, "Scott");
// item 188
db.AddToDepartmentEmployees(yellow_m, mark);
// item 238
db.AddToDepartmentEmployees(yellow_m, null);
// item 213
var fake = new FakeEmployee {
Id = 800, Name = "fake"
};
ExpectException(() => db.AddToDepartmentEmployees(yellow_m, fake));
// item 212
db.AddToDepartmentEmployees(grey_m, mark);
db.AddToDepartmentEmployees(grey_m, john);
db.AddToDepartmentEmployees(grey_m, scott);
// item 254
var grey_employees = (
from e in grey_m.Employees
select e.Id).ToList();
var yellow_employees = (
from e in yellow_m.Employees
select e.Id).ToList();
grey_employees.Sort();
yellow_employees.Sort();
// item 255
Equal(new int[] { 10, 20, 30 }, grey_employees);
Equal(new int[] { 10 }, yellow_employees);
// item 256
Equal(new Bar.IDepartment[] { yellow_m, grey_m }, mark.Departments);
Equal(new Bar.IDepartment[] { grey_m }, john.Departments);
Equal(new Bar.IDepartment[] { grey_m }, scott.Departments);
// item 227
Bar.ICompany company = db.InsertCompany(800);
// item 228
db.SetEmployeeCompany(mark, company);
db.SetEmployeeCompany(john, company);
db.SetEmployeeCompany(scott, company);
// item 302
db.SetDepartmentCompany(grey_m, company);
db.SetDepartmentCompany(yellow_m, company);
// item 230
db.RemoveFromDepartmentEmployees(yellow_m, mark);
// item 231
db.RemoveFromDepartmentEmployees(grey_m, mark);
db.RemoveFromDepartmentEmployees(grey_m, john);
db.RemoveFromDepartmentEmployees(grey_m, scott);
// item 232
Equal(0, grey_m.Employees.Count);
Equal(0, yellow_m.Employees.Count);
// item 233
Equal(0, mark.Departments.Count);
Equal(0, john.Departments.Count);
Equal(0, scott.Departments.Count);
// item 234
db.AddToDepartmentEmployees(yellow_m, john);
// item 303
db.AddToDepartmentEmployees(grey_m, mark);
db.AddToDepartmentEmployees(grey_m, john);
db.AddToDepartmentEmployees(grey_m, scott);
// item 236
Equal(new Bar.IEmployee[] { mark, john, scott }, grey_m.Employees);
Equal(new Bar.IEmployee[] { john }, yellow_m.Employees);
// item 237
Equal(new Bar.IDepartment[] { yellow_m, grey_m }, john.Departments);
Equal(new Bar.IDepartment[] { grey_m }, mark.Departments);
Equal(new Bar.IDepartment[] { grey_m }, scott.Departments);
// item 239
db.DeleteEmployee(scott);
// item 240
Equal(new Bar.IEmployee[] { mark, john }, grey_m.Employees);
// item 241
db.DeleteDepartment(yellow_m);
// item 242
Equal(new Bar.IDepartment[] { grey_m }, john.Departments);
// item 243
db.DeleteCompany(company);
// item 244
Equal(0, db.EmployeeCount());
Equal(0, db.DepartmentCount());
}
