public void GetLongestServingEmployees() { Employee e1 = new Employee { HireDate = new DateTime(2003, 1, 1) }; Employee e2 = new Employee { HireDate = new DateTime(2001, 1, 1) }; Employee e3 = new Employee { HireDate = new DateTime(2000, 1, 1) }; Employee e4 = new Employee { HireDate = new DateTime(2002, 1, 1) }; // The following employee verifies GetLongestServingEmployees does not return terminated employees Employee e5 = new Employee { HireDate = new DateTime(1999, 1, 1), TerminationDate = DateTime.Today }; using (FakeEmployeeContext ctx = new FakeEmployeeContext(new Employee[] { e1, e2, e3, e4, e5 }, new Department[] { })) { EmployeeRepository rep = new EmployeeRepository(ctx); // Select a subset List<Employee> result = rep.GetLongestServingEmployees(2).ToList(); Assert.AreEqual(2, result.Count, "Expected two items in result."); Assert.AreSame(e3, result[0], "Incorrect item at position 0."); Assert.AreSame(e2, result[1], "Incorrect item at position 1."); // Select more than are present result = rep.GetLongestServingEmployees(50).ToList(); Assert.AreEqual(4, result.Count, "Expected four items in result."); } }
public void InitializeWithData() { Employee e1 = new Employee(); Employee e2 = new Employee(); Department d1 = new Department(); Department d2 = new Department(); using (FakeEmployeeContext ctx = new FakeEmployeeContext(new Employee[] { e1, e2 }, new Department[] { d1, d2 })) { UnitOfWork unit = new UnitOfWork(ctx); ObservableCollection <DepartmentViewModel> departments = new ObservableCollection <DepartmentViewModel>(ctx.Departments.Select(d => new DepartmentViewModel(d))); ObservableCollection <EmployeeViewModel> employees = new ObservableCollection <EmployeeViewModel>(); foreach (var e in ctx.Employees) { employees.Add(new EmployeeViewModel(e, employees, departments, unit)); } EmployeeWorkspaceViewModel vm = new EmployeeWorkspaceViewModel(employees, departments, unit); Assert.IsNotNull(vm.CurrentEmployee, "Current employee should be set if there are departments."); Assert.AreSame(employees, vm.AllEmployees, "ViewModel should expose the same instance of the Employee collection so that changes outside the ViewModel are reflected."); Assert.AreSame(employees, vm.AllEmployees[0].ManagerLookup, "ViewModel should expose the same instance of the Employee collection to children so that changes outside the ViewModel are reflected."); Assert.AreSame(departments, vm.AllEmployees[0].DepartmentLookup, "ViewModel should expose the same instance of the Department collection to children so that changes outside the ViewModel are reflected."); } }
public void IndexOrdersByName() { var context = new FakeEmployeeContext { Departments = { new Department { Name = "BBB" }, new Department { Name = "AAA" }, new Department { Name = "ZZZ" }, } }; var target = new DepartmentController(context); var result = target.Index(); Assert.IsInstanceOfType(result.ViewData.Model, typeof(IEnumerable <Department>)); var departments = (IEnumerable <Department>)result.ViewData.Model; Assert.AreEqual("AAA", departments.ElementAt(0).Name); Assert.AreEqual("BBB", departments.ElementAt(1).Name); Assert.AreEqual("ZZZ", departments.ElementAt(2).Name); }
public void GetLongestServingEmployees() { Employee e1 = new Employee { HireDate = new DateTime(2003, 1, 1) }; Employee e2 = new Employee { HireDate = new DateTime(2001, 1, 1) }; Employee e3 = new Employee { HireDate = new DateTime(2000, 1, 1) }; Employee e4 = new Employee { HireDate = new DateTime(2002, 1, 1) }; // 以下雇员验证 GetLongestServingEmployees 不返回已离职的雇员。 Employee e5 = new Employee { HireDate = new DateTime(1999, 1, 1), TerminationDate = DateTime.Today }; using (FakeEmployeeContext ctx = new FakeEmployeeContext(new Employee[] { e1, e2, e3, e4, e5 }, new Department[] { })) { EmployeeRepository rep = new EmployeeRepository(ctx); // 选择子集 List <Employee> result = rep.GetLongestServingEmployees(2).ToList(); Assert.AreEqual(2, result.Count, "Expected two items in result."); Assert.AreSame(e3, result[0], "Incorrect item at position 0."); Assert.AreSame(e2, result[1], "Incorrect item at position 1."); // 所选项多于现有项 result = rep.GetLongestServingEmployees(50).ToList(); Assert.AreEqual(4, result.Count, "Expected four items in result."); } }
public void GetLongestServingEmployees() { Employee e1 = new Employee { HireDate = new DateTime(2003, 1, 1) }; Employee e2 = new Employee { HireDate = new DateTime(2001, 1, 1) }; Employee e3 = new Employee { HireDate = new DateTime(2000, 1, 1) }; Employee e4 = new Employee { HireDate = new DateTime(2002, 1, 1) }; // The following employee verifies GetLongestServingEmployees does not return terminated employees Employee e5 = new Employee { HireDate = new DateTime(1999, 1, 1), TerminationDate = DateTime.Today }; using (FakeEmployeeContext ctx = new FakeEmployeeContext(new Employee[] { e1, e2, e3, e4, e5 }, new Department[] { })) { EmployeeRepository rep = new EmployeeRepository(ctx); // Select a subset List <Employee> result = rep.GetLongestServingEmployees(2).ToList(); Assert.AreEqual(2, result.Count, "Expected two items in result."); Assert.AreSame(e3, result[0], "Incorrect item at position 0."); Assert.AreSame(e2, result[1], "Incorrect item at position 1."); // Select more than are present result = rep.GetLongestServingEmployees(50).ToList(); Assert.AreEqual(4, result.Count, "Expected four items in result."); } }
public void GetLongestServingEmployees() { Employee e1 = new Employee { HireDate = new DateTime(2003, 1, 1) }; Employee e2 = new Employee { HireDate = new DateTime(2001, 1, 1) }; Employee e3 = new Employee { HireDate = new DateTime(2000, 1, 1) }; Employee e4 = new Employee { HireDate = new DateTime(2002, 1, 1) }; // 以下雇员验证 GetLongestServingEmployees 不返回已离职的雇员。 Employee e5 = new Employee { HireDate = new DateTime(1999, 1, 1), TerminationDate = DateTime.Today }; using (FakeEmployeeContext ctx = new FakeEmployeeContext(new Employee[] { e1, e2, e3, e4, e5 }, new Department[] { })) { EmployeeRepository rep = new EmployeeRepository(ctx); // 选择子集 List<Employee> result = rep.GetLongestServingEmployees(2).ToList(); Assert.AreEqual(2, result.Count, "Expected two items in result."); Assert.AreSame(e3, result[0], "Incorrect item at position 0."); Assert.AreSame(e2, result[1], "Incorrect item at position 1."); // 所选项多于现有项 result = rep.GetLongestServingEmployees(50).ToList(); Assert.AreEqual(4, result.Count, "Expected four items in result."); } }
/// <summary> /// 创建基于虚设上下文的 ViewModel /// </summary> /// <param name="ctx">视图模型基于的上下文</param> /// <returns>新的 ViewModel</returns> private static DepartmentWorkspaceViewModel BuildViewModel(FakeEmployeeContext ctx) { UnitOfWork unit = new UnitOfWork(ctx); ObservableCollection <DepartmentViewModel> departments = new ObservableCollection <DepartmentViewModel>(ctx.Departments.Select(d => new DepartmentViewModel(d))); DepartmentWorkspaceViewModel vm = new DepartmentWorkspaceViewModel(departments, unit); return(vm); }
public void Initialization() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { Assert.IsNotNull(ctx.Employees, "Constructor did not not initialize Employees ObjectSet."); Assert.IsNotNull(ctx.Departments, "Constructor did not initialize Departments ObjectSet."); Assert.IsNotNull(ctx.ContactDetails, "Constructor did not initialize ContactDetails ObjectSet."); } }
public void NullArgumentChecks() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { Utilities.CheckNullArgumentException(() => { var c = new FakeEmployeeContext(null, new Department[0]); c.Dispose(); }, "employees", "ctor"); Utilities.CheckNullArgumentException(() => { var c = new FakeEmployeeContext(new Employee[0], null); c.Dispose(); }, "departments", "ctor"); Utilities.CheckNullArgumentException(() => { ctx.IsObjectTracked(null); }, "entity", "IsObjectTracked"); } }
public void CheckNullArgumentExceptions() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Utilities.CheckNullArgumentException(() => { new DepartmentWorkspaceViewModel(null, unit); }, "departments", "ctor"); Utilities.CheckNullArgumentException(() => { new DepartmentWorkspaceViewModel(new ObservableCollection<DepartmentViewModel>(), null); }, "unitOfWork", "ctor"); } }
public void CheckNullArgumentExceptions() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Utilities.CheckNullArgumentException(() => { new DepartmentWorkspaceViewModel(null, unit); }, "departments", "ctor"); Utilities.CheckNullArgumentException(() => { new DepartmentWorkspaceViewModel(new ObservableCollection <DepartmentViewModel>(), null); }, "unitOfWork", "ctor"); } }
public void AddWhenEmployeeNotSelected() { using (FakeEmployeeContext ctx = BuildContextWithData()) { EmployeeWorkspaceViewModel vm = BuildViewModel(ctx); vm.CurrentEmployee = null; TestAddEmployee(ctx, vm); } }
public void GetAllDepartmentsEmpty() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { DepartmentRepository rep = new DepartmentRepository(ctx); IEnumerable <Department> result = rep.GetAllDepartments(); Assert.AreEqual(0, result.Count()); } }
public void AddWhenDepartmentNotSelected() { using (FakeEmployeeContext ctx = BuildContextWithData()) { DepartmentWorkspaceViewModel vm = BuildViewModel(ctx); vm.CurrentDepartment = null; TestAddDepartment(ctx, vm); } }
public void GetAllEmployeesEmpty() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { EmployeeRepository rep = new EmployeeRepository(ctx); IEnumerable <Employee> result = rep.GetAllEmployees(); Assert.AreEqual(0, result.Count()); } }
public void GetAllDepartmentsEmpty() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { DepartmentRepository rep = new DepartmentRepository(ctx); IEnumerable<Department> result = rep.GetAllDepartments(); Assert.AreEqual(0, result.Count()); } }
public void GetAllEmployeesEmpty() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { EmployeeRepository rep = new EmployeeRepository(ctx); IEnumerable<Employee> result = rep.GetAllEmployees(); Assert.AreEqual(0, result.Count()); } }
public void DisposeCalled() { bool called = false; using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { ctx.DisposeCalled += (sender, e) => { called = true; }; } Assert.IsTrue(called, "Dispose did not raise DisposeCalled event."); }
public void SaveCalled() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { bool called = false; ctx.SaveCalled += (sender, e) => { called = true; }; ctx.Save(); Assert.IsTrue(called, "Save did not raise SaveCalled event."); } }
public void AddEmployee() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Employee emp = new Employee(); unit.AddEmployee(emp); Assert.IsTrue(ctx.Employees.Contains(emp), "Employee was not added to underlying context."); } }
/// <summary> /// 使用现有工作单元创建基于虚设上下文的 ViewModel /// </summary> /// <param name="ctx">视图模型基于的上下文</param> /// <param name="unit">当前工作单元</param> /// <returns>新的 ViewModel</returns> private static EmployeeWorkspaceViewModel BuildViewModel(FakeEmployeeContext ctx, UnitOfWork unit) { ObservableCollection<DepartmentViewModel> departments = new ObservableCollection<DepartmentViewModel>(ctx.Departments.Select(d => new DepartmentViewModel(d))); ObservableCollection<EmployeeViewModel> employees = new ObservableCollection<EmployeeViewModel>(); foreach (var e in ctx.Employees) { employees.Add(new EmployeeViewModel(e, employees, departments, unit)); } return new EmployeeWorkspaceViewModel(employees, departments, unit); }
public void AddDepartment() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Department dep = new Department(); unit.AddDepartment(dep); Assert.IsTrue(ctx.Departments.Contains(dep), "Department was not added to underlying context."); } }
public void RemoveEmployee() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Employee emp = new Employee(); unit.AddEmployee(emp); unit.RemoveEmployee(emp); Assert.IsFalse(ctx.Employees.Contains(emp), "Employee was not removed from underlying context."); } }
public void RemoveDepartment() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Department dep = new Department(); unit.AddDepartment(dep); unit.RemoveDepartment(dep); Assert.IsFalse(ctx.Departments.Contains(dep), "Department was not removed from underlying context."); } }
public void InitializationWithSuppliedCollections() { Department dep = new Department(); ContactDetail det = new Phone(); Employee emp = new Employee { ContactDetails = new List<ContactDetail> { det } }; using (FakeEmployeeContext ctx = new FakeEmployeeContext(new Employee[] { emp }, new Department[] { dep })) { Assert.IsTrue(ctx.Employees.Contains(emp), "Constructor did not add supplied Employees to public ObjectSet."); Assert.IsTrue(ctx.Departments.Contains(dep), "Constructor did not add supplied Departments to public ObjectSet."); Assert.IsTrue(ctx.ContactDetails.Contains(det), "Constructor did not add supplied ContactDetails to public ObjectSet."); } }
public void AddContactDetailFromDefaultConstructor() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Employee emp = new Employee(); unit.AddEmployee(emp); ContactDetail cd = new Address(); unit.AddContactDetail(emp, cd); Assert.IsTrue(ctx.ContactDetails.Contains(cd), "ContactDetail was not added to underlying context."); } }
public void DeleteCommandOnlyAvailableWhenEmployeeSelected() { using (FakeEmployeeContext ctx = BuildContextWithData()) { EmployeeWorkspaceViewModel vm = BuildViewModel(ctx); vm.CurrentEmployee = null; Assert.IsFalse(vm.DeleteEmployeeCommand.CanExecute(null), "Delete command should be disabled when no employee is selected."); vm.CurrentEmployee = vm.AllEmployees.First(); Assert.IsTrue(vm.DeleteEmployeeCommand.CanExecute(null), "Delete command should be enabled when employee is selected."); } }
public void DeleteCommandOnlyAvailableWhenDepartmentSelected() { using (FakeEmployeeContext ctx = BuildContextWithData()) { DepartmentWorkspaceViewModel vm = BuildViewModel(ctx); vm.CurrentDepartment = null; Assert.IsFalse(vm.DeleteDepartmentCommand.CanExecute(null), "Delete command should be disabled when no department is selected."); vm.CurrentDepartment = vm.AllDepartments.First(); Assert.IsTrue(vm.DeleteDepartmentCommand.CanExecute(null), "Delete command should be enabled when department is selected."); } }
public void InitializeWithData() { using (FakeEmployeeContext ctx = BuildContextWithData()) { UnitOfWork unit = new UnitOfWork(ctx); ObservableCollection <DepartmentViewModel> departments = new ObservableCollection <DepartmentViewModel>(ctx.Departments.Select(d => new DepartmentViewModel(d))); DepartmentWorkspaceViewModel vm = new DepartmentWorkspaceViewModel(departments, unit); Assert.IsNotNull(vm.CurrentDepartment, "Current department should be set if there are departments."); Assert.AreSame(departments, vm.AllDepartments, "ViewModel should expose the same instance of the collection so that changes outside the ViewModel are reflected."); Assert.IsNotNull(vm.AddDepartmentCommand, "AddDepartmentCommand should be initialized"); Assert.IsNotNull(vm.DeleteDepartmentCommand, "DeleteDepartmentCommand should be initialized"); } }
public void SaveCommand() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); IDepartmentRepository departmentRepository = new DepartmentRepository(ctx); IEmployeeRepository employeeRepository = new EmployeeRepository(ctx); MainViewModel main = new MainViewModel(unit, departmentRepository, employeeRepository); bool called = false; ctx.SaveCalled += (sender, e) => { called = true; }; main.SaveCommand.Execute(null); Assert.IsTrue(called, "SaveCommand should result in save on underlying UnitOfWork."); } }
public void ExternalAddToDepartmentLookup() { using (FakeEmployeeContext ctx = BuildContextWithData()) { EmployeeViewModel vm = BuildViewModel(ctx); DepartmentViewModel currentDepartment = vm.Department; DepartmentViewModel newDepartment = new DepartmentViewModel(new Department()); vm.DepartmentLookup.Add(newDepartment); Assert.IsTrue(vm.DepartmentLookup.Contains(newDepartment), "New department should have been added to DepartmentLookup."); Assert.AreSame(currentDepartment, vm.Department, "Assigned Department should not have changed."); Assert.IsFalse(ctx.IsObjectTracked(newDepartment.Model), "ViewModel is not responsible for adding departments created externally."); } }
public void InitializeWithEmptyData() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); ObservableCollection <DepartmentViewModel> departments = new ObservableCollection <DepartmentViewModel>(); ObservableCollection <EmployeeViewModel> employees = new ObservableCollection <EmployeeViewModel>(); EmployeeWorkspaceViewModel vm = new EmployeeWorkspaceViewModel(employees, departments, unit); Assert.AreSame(employees, vm.AllEmployees, "ViewModel should expose the same instance of the collection so that changes outside the ViewModel are reflected."); Assert.IsNull(vm.CurrentEmployee, "Current employee should not be set if there are no department."); Assert.IsNotNull(vm.AddEmployeeCommand, "AddEmployeeCommand should be initialized"); Assert.IsNotNull(vm.DeleteEmployeeCommand, "DeleteEmployeeCommand should be initialized"); } }
public void DeleteContactDetailOnlyAvailableWhenDetailIsSelected() { using (FakeEmployeeContext ctx = BuildContextWithData()) { EmployeeViewModel vm = BuildViewModel(ctx); List <ContactDetailViewModel> originalDetails = vm.ContactDetails.ToList(); vm.CurrentContactDetail = null; Assert.IsFalse(vm.DeleteContactDetailCommand.CanExecute(null), "DeleteContactDetailCommand should be disabled when no detail is selected."); vm.CurrentContactDetail = vm.ContactDetails.First(); Assert.IsTrue(vm.DeleteContactDetailCommand.CanExecute(null), "DeleteContactDetailCommand should be enabled when a detail is selected."); } }
public void ExternalRemoveManagerLookup() { using (FakeEmployeeContext ctx = BuildContextWithData()) { EmployeeViewModel vm = BuildViewModel(ctx); EmployeeViewModel currentManager = vm.ManagerLookup.First(); EmployeeViewModel toDelete = vm.ManagerLookup.Skip(1).First(); vm.Manager = currentManager; vm.ManagerLookup.Remove(toDelete); Assert.IsFalse(vm.ManagerLookup.Contains(toDelete), "Employee should have been removed from ManagerLookup."); Assert.AreSame(currentManager, vm.Manager, "Assigned Manager should not have changed."); Assert.IsTrue(ctx.IsObjectTracked(toDelete.Model), "ViewModel is not responsible for deleting Employees removed externally."); } }
public void ExternalRemoveDepartmentLookup() { using (FakeEmployeeContext ctx = BuildContextWithData()) { EmployeeViewModel vm = BuildViewModel(ctx); DepartmentViewModel currentDepartment = vm.DepartmentLookup.First(); DepartmentViewModel toDelete = vm.DepartmentLookup.Skip(1).First(); vm.Department = currentDepartment; vm.DepartmentLookup.Remove(toDelete); Assert.IsFalse(vm.DepartmentLookup.Contains(toDelete), "Department should have been removed from DepartmentLookup."); Assert.AreSame(currentDepartment, vm.Department, "Assigned Department should not have changed."); Assert.IsTrue(ctx.IsObjectTracked(toDelete.Model), "ViewModel is not responsible for deleting departments removed externally."); } }
public void ExternalAddToManagerLookup() { using (FakeEmployeeContext ctx = BuildContextWithData()) { UnitOfWork unit = new UnitOfWork(ctx); EmployeeViewModel vm = BuildViewModel(ctx, unit); EmployeeViewModel currentManager = vm.Manager; EmployeeViewModel newManager = new EmployeeViewModel(new Employee(), vm.ManagerLookup, vm.DepartmentLookup, unit); vm.ManagerLookup.Add(newManager); Assert.IsTrue(vm.ManagerLookup.Contains(newManager), "New department should have been added to ManagerLookup."); Assert.AreSame(currentManager, vm.Manager, "Assigned Manager should not have changed."); Assert.IsFalse(ctx.IsObjectTracked(newManager.Model), "ViewModel is not responsible for adding Employees created externally."); } }
public void AddContactDetailToEmployeeOutsideUnitOfWork() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Employee emp = new Employee(); ContactDetail detail = new Email(); try { unit.AddContactDetail(emp, detail); Assert.Fail("Adding a contact detail to an employee outside the Unit of Work did not throw."); } catch (InvalidOperationException ex) { Assert.AreEqual("The supplied Employee is not part of this Unit of Work.", ex.Message); } } }
public void CreateObject() { // Fake context should create the actual base type and not a type derived from it using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { object entity = ctx.CreateObject<Department>(); Assert.AreEqual(typeof(Department), entity.GetType(), "Department did not get created."); entity = ctx.CreateObject<Employee>(); Assert.AreEqual(typeof(Employee), entity.GetType(), "Employee did not get created."); entity = ctx.CreateObject<Email>(); Assert.AreEqual(typeof(Email), entity.GetType(), "Email did not get created."); entity = ctx.CreateObject<Phone>(); Assert.AreEqual(typeof(Phone), entity.GetType(), "Phone did not get created."); entity = ctx.CreateObject<Address>(); Assert.AreEqual(typeof(Address), entity.GetType(), "Address did not get created."); } }
public void CreateObject() { // 虚设上下文应该创建实际基类型,而不是从其派生的类型 using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { object entity = ctx.CreateObject<Department>(); Assert.AreEqual(typeof(Department), entity.GetType(), "Department did not get created."); entity = ctx.CreateObject<Employee>(); Assert.AreEqual(typeof(Employee), entity.GetType(), "Employee did not get created."); entity = ctx.CreateObject<Email>(); Assert.AreEqual(typeof(Email), entity.GetType(), "Email did not get created."); entity = ctx.CreateObject<Phone>(); Assert.AreEqual(typeof(Phone), entity.GetType(), "Phone did not get created."); entity = ctx.CreateObject<Address>(); Assert.AreEqual(typeof(Address), entity.GetType(), "Address did not get created."); } }
public void AddContactDetailAlreadyInUnitOfWork() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Employee emp = new Employee(); ContactDetail detail = new Phone(); unit.AddEmployee(emp); unit.AddContactDetail(emp, detail); try { unit.AddContactDetail(emp, detail); Assert.Fail("Adding an ContactDetail that was already added did not throw."); } catch (InvalidOperationException ex) { Assert.AreEqual("The supplied Phone is already part of this Unit of Work.", ex.Message); } } }
public void GetAllEmployees() { Employee e1 = new Employee(); Employee e2 = new Employee(); Employee e3 = new Employee(); using (FakeEmployeeContext ctx = new FakeEmployeeContext(new Employee[] { e1, e2, e3 }, new Department[] { })) { EmployeeRepository rep = new EmployeeRepository(ctx); IEnumerable<Employee> result = rep.GetAllEmployees(); Assert.IsNotInstanceOfType( result, typeof(IQueryable), "Repositories should not return IQueryable as this allows modification of the query that gets sent to the store. "); Assert.AreEqual(3, result.Count()); Assert.IsTrue(result.Contains(e1)); Assert.IsTrue(result.Contains(e2)); Assert.IsTrue(result.Contains(e3)); } }
public void GetAllDepartments() { Department d1 = new Department(); Department d2 = new Department(); Department d3 = new Department(); using (FakeEmployeeContext ctx = new FakeEmployeeContext(new Employee[] { }, new Department[] { d1, d2, d3 })) { DepartmentRepository rep = new DepartmentRepository(ctx); IEnumerable<Department> result = rep.GetAllDepartments(); Assert.IsNotInstanceOfType( result, typeof(IQueryable), "Repositories should not return IQueryable as this allows modification of the query that gets sent to the store. "); Assert.AreEqual(3, result.Count()); Assert.IsTrue(result.Contains(d1)); Assert.IsTrue(result.Contains(d2)); Assert.IsTrue(result.Contains(d3)); } }
public void NullArgumentChecks() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Utilities.CheckNullArgumentException(() => { new UnitOfWork(null); }, "context", "ctor"); Utilities.CheckNullArgumentException(() => { unit.AddEmployee(null); }, "employee", "AddEmployee"); Utilities.CheckNullArgumentException(() => { unit.AddDepartment(null); }, "department", "AddDepartment"); Utilities.CheckNullArgumentException(() => { unit.AddContactDetail(new Employee(), null); }, "detail", "AddContactDetail"); Utilities.CheckNullArgumentException(() => { unit.AddContactDetail(null, new Phone()); }, "employee", "AddContactDetail"); Utilities.CheckNullArgumentException(() => { unit.RemoveEmployee(null); }, "employee", "RemoveEmployee"); Utilities.CheckNullArgumentException(() => { unit.RemoveDepartment(null); }, "department", "RemoveDepartment"); Utilities.CheckNullArgumentException(() => { unit.RemoveContactDetail(null, new Phone()); }, "employee", "RemoveContactDetail"); Utilities.CheckNullArgumentException(() => { unit.RemoveContactDetail(new Employee(), null); }, "detail", "RemoveContactDetail"); } }
public void RemoveContactDetail() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Employee emp = new Employee(); ContactDetail detail = new Phone(); unit.AddEmployee(emp); unit.AddContactDetail(emp, detail); unit.RemoveContactDetail(emp, detail); Assert.IsFalse(ctx.ContactDetails.Contains(detail), "ContactDetail was not removed from underlying context."); Assert.IsFalse( emp.ContactDetails.Contains(detail), "ContactDetail is still in collection on Employee after being removed via Unit of Work."); } }
public void RemoveEmployeeOutsideUnitOfWork() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); try { unit.RemoveEmployee(new Employee()); Assert.Fail("Removing an Employee that was not added to Unit of Work did not throw."); } catch (InvalidOperationException ex) { Assert.AreEqual("The supplied Employee is not part of this Unit of Work.", ex.Message); } } }
public void RemoveEmployeeWithReports() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Employee emp = new Employee(); Employee man = new Employee(); unit.AddEmployee(emp); unit.AddEmployee(man); emp.Manager = man; unit.RemoveEmployee(man); Assert.IsFalse(ctx.Employees.Contains(man), "Employee was not removed from underlying context."); Assert.AreEqual(0, man.Reports.Count, "Employee was not removed from managers reports."); Assert.IsNull(emp.Manager, "Manager property on Employee was not cleared."); } }
public void IsObjectTracked() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { Employee e = new Employee(); Assert.IsFalse(ctx.IsObjectTracked(e), "IsObjectTracked should be false when entity is not in added."); ctx.Employees.AddObject(e); Assert.IsTrue(ctx.IsObjectTracked(e), "IsObjectTracked should be true when entity is added."); Department d = new Department(); Assert.IsFalse(ctx.IsObjectTracked(d), "IsObjectTracked should be false when entity is not in added."); ctx.Departments.AddObject(d); Assert.IsTrue(ctx.IsObjectTracked(d), "IsObjectTracked should be true when entity is added."); ContactDetail c = new Phone(); Assert.IsFalse(ctx.IsObjectTracked(c), "IsObjectTracked should be false when entity is not in added."); ctx.ContactDetails.AddObject(c); Assert.IsTrue(ctx.IsObjectTracked(c), "IsObjectTracked should be true when entity is added."); } }
/// <summary> /// Creates a ViewModel based on a fake context /// </summary> /// <param name="ctx">Context to base view model on</param> /// <returns>The new ViewModel</returns> private static EmployeeViewModel BuildViewModel(FakeEmployeeContext ctx) { return BuildViewModel(ctx, new UnitOfWork(ctx)); }
public void ReferencesGetAndSet() { // Scalar properties are inherited from BasicEmployeeViewModel and are already tested Department d1 = new Department(); Department d2 = new Department(); Employee e1 = new Employee(); Employee e2 = new Employee(); Employee employee = new Employee { Department = d1, Manager = e1 }; employee.ContactDetails.Add(new Phone()); employee.ContactDetails.Add(new Email()); using (FakeEmployeeContext ctx = new FakeEmployeeContext(new Employee[] { e1, e2, employee }, new Department[] { d1, d2 })) { UnitOfWork unit = new UnitOfWork(ctx); DepartmentViewModel dvm1 = new DepartmentViewModel(d1); DepartmentViewModel dvm2 = new DepartmentViewModel(d2); ObservableCollection<DepartmentViewModel> departments = new ObservableCollection<DepartmentViewModel> { dvm1, dvm2 }; ObservableCollection<EmployeeViewModel> employees = new ObservableCollection<EmployeeViewModel>(); EmployeeViewModel evm1 = new EmployeeViewModel(e1, employees, departments, unit); EmployeeViewModel evm2 = new EmployeeViewModel(e2, employees, departments, unit); EmployeeViewModel employeeViewModel = new EmployeeViewModel(employee, employees, departments, unit); employees.Add(evm1); employees.Add(evm2); employees.Add(employeeViewModel); // Test initial references are surfaced in ViewModel Assert.AreEqual(evm1, employeeViewModel.Manager, "ViewModel did not return ViewModel representing current manager."); Assert.AreEqual(e1, employeeViewModel.Manager.Model, "ViewModel did not return ViewModel representing current manager."); Assert.AreEqual(dvm1, employeeViewModel.Department, "ViewModel did not return ViewModel representing current department."); Assert.AreEqual(d1, employeeViewModel.Department.Model, "ViewModel did not return ViewModel representing current department."); Assert.AreEqual(2, employeeViewModel.ContactDetails.Count, "Contact details have not been populated on ViewModel."); // Test changing properties updates Model and raises PropertyChanged string lastProperty; employeeViewModel.PropertyChanged += (sender, e) => { lastProperty = e.PropertyName; }; lastProperty = null; employeeViewModel.Department = dvm2; Assert.AreEqual("Department", lastProperty, "Setting Department property did not raise correct PropertyChanged event."); Assert.AreEqual(d2, employee.Department, "Setting Department property in ViewModel is not reflected in Model."); lastProperty = null; employeeViewModel.Manager = evm2; Assert.AreEqual("Manager", lastProperty, "Setting Manager property did not raise correct PropertyChanged event."); Assert.AreEqual(e2, employee.Manager, "Setting Manager property in ViewModel is not reflected in Model."); // Test ViewModel returns current value from model employee.Manager = e1; Assert.AreEqual(evm1, employeeViewModel.Manager, "ViewModel did not return correct manager when model was updated outside of ViewModel."); employee.Department = d1; Assert.AreEqual(dvm1, employeeViewModel.Department, "ViewModel did not return correct department when model was updated outside of ViewModel."); // Test ViewModel returns current value from model when set to null employee.Manager = null; Assert.AreEqual(null, employeeViewModel.Manager, "ViewModel did not return correct manager when model was updated outside of ViewModel."); employee.Department = null; Assert.AreEqual(null, employeeViewModel.Department, "ViewModel did not return correct department when model was updated outside of ViewModel."); } }
/// <summary> /// Creates a ViewModel based on a fake context using an existing unit of work /// </summary> /// <param name="ctx">Context to base view model on</param> /// <param name="unit">Current unit of work</param> /// <returns>The new ViewModel</returns> private static EmployeeViewModel BuildViewModel(FakeEmployeeContext ctx, UnitOfWork unit) { ObservableCollection<DepartmentViewModel> departments = new ObservableCollection<DepartmentViewModel>(ctx.Departments.Select(d => new DepartmentViewModel(d))); ObservableCollection<EmployeeViewModel> employees = new ObservableCollection<EmployeeViewModel>(); foreach (var e in ctx.Employees) { employees.Add(new EmployeeViewModel(e, employees, departments, unit)); } return employees[0]; }
public void RemoveDepartmentWithEmployees() { using (FakeEmployeeContext ctx = new FakeEmployeeContext()) { UnitOfWork unit = new UnitOfWork(ctx); Department dep = new Department(); Employee emp = new Employee(); unit.AddDepartment(dep); unit.AddEmployee(emp); emp.Department = dep; unit.RemoveDepartment(dep); Assert.IsFalse(ctx.Departments.Contains(dep), "Department was not removed from underlying context."); Assert.IsNull(emp.Department, "Employee.Department property has not been nulled when deleting department."); Assert.IsNull(emp.DepartmentId, "Employee.DepartmentId property has not been nulled when deleting department."); Assert.AreEqual(0, dep.Employees.Count, "Department.Employees collection was not cleared when deleting department."); } }