public void TestEmployeePayHistoryRepositoryAdd(EmployeePayHistory _EmployeePayHistory) { var _EmployeePayHistoryRepository = RepositoryHelper.GetEmployeePayHistoryRepository(); _EmployeePayHistoryRepository.Add(_EmployeePayHistory); _EmployeePayHistoryRepository.Save(); }
/// <summary> /// Deep load all EmployeePayHistory children. /// </summary> private void Step_03_DeepLoad_Generated() { using (TransactionManager tm = CreateTransaction()) { int count = -1; mock = CreateMockInstance(tm); mockCollection = DataRepository.EmployeePayHistoryProvider.GetPaged(tm, 0, 10, out count); DataRepository.EmployeePayHistoryProvider.DeepLoading += new EntityProviderBaseCore <EmployeePayHistory, EmployeePayHistoryKey> .DeepLoadingEventHandler( delegate(object sender, DeepSessionEventArgs e) { if (e.DeepSession.Count > 3) { e.Cancel = true; } } ); if (mockCollection.Count > 0) { DataRepository.EmployeePayHistoryProvider.DeepLoad(tm, mockCollection[0]); System.Console.WriteLine("EmployeePayHistory instance correctly deep loaded at 1 level."); mockCollection.Add(mock); // DataRepository.EmployeePayHistoryProvider.DeepSave(tm, mockCollection); } //normally one would commit here //tm.Commit(); //IDisposable will Rollback Transaction since it's left uncommitted } }
public async Task ShouldUpdateOneEmployeePayHistoryRecord() { ResetDatabase(); var payHistory = new EmployeePayHistory { BusinessEntityID = 17, RateChangeDate = new DateTime(2008, 1, 6), Rate = 50.00M, PayFrequency = PayFrequency.Biweekly }; string jsonPayHistory = JsonConvert.SerializeObject(payHistory); HttpContent content = new StringContent(jsonPayHistory, Encoding.UTF8, "application/json"); var response = await _client.PutAsync($"{serviceAddress}{rootAddress}/payhistory", content); Assert.True(response.IsSuccessStatusCode); Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); var test = await _client .GetAsync($"{serviceAddress}{rootAddress}/payhistory/{payHistory.BusinessEntityID}/{payHistory.RateChangeDate.ToString("yyyy-MM-dd")}"); var jsonResponse = await test.Content.ReadAsStringAsync(); var result = JsonConvert.DeserializeObject <EmployeePayHistory>(jsonResponse); Assert.Equal(payHistory.Rate, result.Rate); }
public static void Map(this EmployeePayHistory destination, EmployeePayHistory source) { destination.BusinessEntityID = source.BusinessEntityID; destination.RateChangeDate = source.RateChangeDate; destination.Rate = source.Rate; destination.PayFrequency = source.PayFrequency; }
public void TestEmployeePayHistoryRepositoryDelete(EmployeePayHistory _EmployeePayHistory) { var _EmployeePayHistoryRepository = RepositoryHelper.GetEmployeePayHistoryRepository(); _EmployeePayHistoryRepository.Repository.Delete(_EmployeePayHistory); _EmployeePayHistoryRepository.Save(); }
///<summary> /// Update the Typed EmployeePayHistory Entity with modified mock values. ///</summary> static public void UpdateMockInstance(TransactionManager tm, EmployeePayHistory mock) { EmployeePayHistoryTest.UpdateMockInstance_Generated(tm, mock); // make any alterations necessary // (i.e. for DB check constraints, special test cases, etc.) SetSpecialTestData(mock); }
public ViewEmployeePayHistory(EmployeePayHistory employee) { this.BusinessEntityID = employee.BusinessEntityID; this.RateChangeDate = employee.RateChangeDate; this.Rate = employee.Rate; this.PayFrequency = employee.PayFrequency; this.ModifiedDate = employee.ModifiedDate; }
public EmployeePayHistoryModel Create(EmployeePayHistory eph) { return(new EmployeePayHistoryModel() { Rate = eph.Rate, ModifiedDate = eph.ModifiedDate, PayFrequency = eph.PayFrequency, RateChangeDate = eph.RateChangeDate }); }
/// <summary> /// Converts the dto to entities. /// </summary> /// <param name="_EmployeePayHistoryDto">The EmployeePayHistory dto.</param> /// <returns>EmployeePayHistory</returns> public EmployeePayHistory ConvertDtoToEntities(EmployeePayHistoryDto _EmployeePayHistoryDto) { if (_EmployeePayHistoryDto == null) { throw new ArgumentNullException("model should not be null"); } var efEmployeePayHistory = new EmployeePayHistory(); ConvertObject(_EmployeePayHistoryDto, efEmployeePayHistory); return(efEmployeePayHistory); }
/// <summary> /// Test methods exposed by the EntityHelper class. /// </summary> private void Step_20_TestEntityHelper_Generated() { using (TransactionManager tm = CreateTransaction()) { mock = CreateMockInstance(tm); EmployeePayHistory entity = mock.Copy() as EmployeePayHistory; entity = (EmployeePayHistory)mock.Clone(); Assert.IsTrue(EmployeePayHistory.ValueEquals(entity, mock), "Clone is not working"); } }
// PUT api/awbuildversion/5 public void Put(EmployeePayHistory value) { var GetActionType = Request.Headers.Where(x => x.Key.Equals("ActionType")).FirstOrDefault(); if (GetActionType.Key != null) { if (GetActionType.Value.ToList()[0].Equals("DELETE")) adventureWorks_BC.EmployeePayHistoryDelete(value); if (GetActionType.Value.ToList()[0].Equals("UPDATE")) adventureWorks_BC.EmployeePayHistoryUpdate(value); } }
///<summary> /// Update the Typed EmployeePayHistory Entity with modified mock values. ///</summary> static public void UpdateMockInstance_Generated(TransactionManager tm, EmployeePayHistory mock) { mock.Rate = TestUtility.Instance.RandomShort(); mock.PayFrequency = TestUtility.Instance.RandomByte(); mock.ModifiedDate = TestUtility.Instance.RandomDateTime(); //OneToOneRelationship Employee mockEmployeeByEmployeeId = EmployeeTest.CreateMockInstance(tm); DataRepository.EmployeeProvider.Insert(tm, mockEmployeeByEmployeeId); mock.EmployeeId = mockEmployeeByEmployeeId.EmployeeId; }
public void TransformEmployeePayHistory() { var adapter = new TypeAdapter(); var eph = new EmployeePayHistory() { EmployeeID = 1, ModifiedDate = DateTime.Now }; var dto = adapter.Transform <EmployeePayHistory, EmployeePayHistoryDto>(eph); Assert.Equal(1, dto.EmployeeID); }
/// <summary> /// Converts the dto to entities. /// </summary> /// <param name="_EmployeePayHistoryDto">The EmployeePayHistory dto.</param> /// <param name="skipNullPropertyValue">if set to <c>true</c> [skip null property value].</param> /// <returns>EmployeePayHistory</returns> public EmployeePayHistory ConvertDtoToEntities(EmployeePayHistoryDto _EmployeePayHistoryDto, bool skipNullPropertyValue) { if (_EmployeePayHistoryDto == null) { throw new ArgumentNullException("model should not be null"); } var efEmployeePayHistory = new EmployeePayHistory(); ConvertObjectWithCheckNull(_EmployeePayHistoryDto, skipNullPropertyValue, efEmployeePayHistory); return(efEmployeePayHistory); }
public void TransformEmployeePayHistory() { var adapter = new TypeAdapter<EmployeePayHistory, EmployeePayHistoryDTO>(); var eph = new EmployeePayHistory() { EmployeeID = 1, ModifiedDate = DateTime.Now }; var dto = adapter.Transform<EmployeePayHistory, EmployeePayHistoryDTO>(eph); Assert.Equal(1, dto.EmployeeID); }
/// <summary> /// Check the foreign key dal methods. /// </summary> private void Step_10_FK_Generated() { using (TransactionManager tm = CreateTransaction()) { EmployeePayHistory entity = CreateMockInstance(tm); bool result = DataRepository.EmployeePayHistoryProvider.Insert(tm, entity); Assert.IsTrue(result, "Could Not Test FK, Insert Failed"); TList <EmployeePayHistory> t0 = DataRepository.EmployeePayHistoryProvider.GetByEmployeeId(tm, entity.EmployeeId, 0, 10); } }
///<summary> /// Returns a Typed EmployeePayHistory Entity with mock values. ///</summary> static public EmployeePayHistory CreateMockInstance(TransactionManager tm) { // get the default mock instance EmployeePayHistory mock = EmployeePayHistoryTest.CreateMockInstance_Generated(tm); // make any alterations necessary // (i.e. for DB check constraints, special test cases, etc.) SetSpecialTestData(mock); // return the modified object return(mock); }
/// <summary> /// Check the indexes dal methods. /// </summary> private void Step_11_IX_Generated() { using (TransactionManager tm = CreateTransaction()) { EmployeePayHistory entity = CreateMockInstance(tm); bool result = DataRepository.EmployeePayHistoryProvider.Insert(tm, entity); Assert.IsTrue(result, "Could Not Test IX, Insert Failed"); EmployeePayHistory t0 = DataRepository.EmployeePayHistoryProvider.GetByEmployeeIdRateChangeDate(tm, entity.EmployeeId, entity.RateChangeDate); } }
public virtual EmployeePayHistory MapBOToEF( BOEmployeePayHistory bo) { EmployeePayHistory efEmployeePayHistory = new EmployeePayHistory(); efEmployeePayHistory.SetProperties( bo.BusinessEntityID, bo.ModifiedDate, bo.PayFrequency, bo.Rate, bo.RateChangeDate); return(efEmployeePayHistory); }
/// <summary> /// Serialize the mock EmployeePayHistory entity into a temporary file. /// </summary> private void Step_06_SerializeEntity_Generated() { using (TransactionManager tm = CreateTransaction()) { mock = CreateMockInstance(tm); string fileName = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "temp_EmployeePayHistory.xml"); EntityHelper.SerializeXml(mock, fileName); Assert.IsTrue(System.IO.File.Exists(fileName), "Serialized mock not found"); System.Console.WriteLine("mock correctly serialized to a temporary file."); } }
public virtual BOEmployeePayHistory MapEFToBO( EmployeePayHistory ef) { var bo = new BOEmployeePayHistory(); bo.SetProperties( ef.BusinessEntityID, ef.ModifiedDate, ef.PayFrequency, ef.Rate, ef.RateChangeDate); return(bo); }
public async Task ShouldRaiseExceptionDuplicateEmployeePayHistory() { var payHistory = new EmployeePayHistory { BusinessEntityID = 1, RateChangeDate = new DateTime(2009, 1, 14), Rate = 150.00M, PayFrequency = PayFrequency.Biweekly }; var exception = await Assert.ThrowsAsync <AdventureWorksUniqueIndexException>(() => _payHistoryRepo.CreatePayHistory(payHistory)); Assert.Equal("Error: This operation would result in a duplicate employee pay history record.", exception.Message); }
public void MapEFToBOList() { var mapper = new DALEmployeePayHistoryMapper(); EmployeePayHistory entity = new EmployeePayHistory(); entity.SetProperties(1, DateTime.Parse("1/1/1987 12:00:00 AM"), 1, 1m, DateTime.Parse("1/1/1987 12:00:00 AM")); List <BOEmployeePayHistory> response = mapper.MapEFToBO(new List <EmployeePayHistory>() { entity }); response.Count.Should().Be(1); }
/// <summary> /// Make any alterations necessary (i.e. for DB check constraints, special test cases, etc.) /// </summary> /// <param name="mock">Object to be modified</param> static private void SetSpecialTestData(EmployeePayHistory mock) { //Code your changes to the data object here. if (TestUtility.Instance.RandomBoolean()) { mock.PayFrequency = 1; } else { mock.PayFrequency = 2; } mock.Rate = TestUtility.Instance.RandomNumber(7, 200); }
public bool EmployeePayHistoryDelete(EmployeePayHistory employeepayhistory) { return(Execute <bool>(dal => { EmployeePayHistory employeepayhistoryDelete = dal.EmployeePayHistory.Where(x => x.BusinessEntityID == employeepayhistory.BusinessEntityID).FirstOrDefault(); if (employeepayhistoryDelete != null) { dal.EmployeePayHistory.DeleteOnSubmit(employeepayhistoryDelete); dal.SubmitChanges(); return true; } return false; })); }
/// <summary> /// Inserts a mock EmployeePayHistory entity into the database. /// </summary> private void Step_01_Insert_Generated() { using (TransactionManager tm = CreateTransaction()) { mock = CreateMockInstance(tm); Assert.IsTrue(DataRepository.EmployeePayHistoryProvider.Insert(tm, mock), "Insert failed"); System.Console.WriteLine("DataRepository.EmployeePayHistoryProvider.Insert(mock):"); System.Console.WriteLine(mock); //normally one would commit here //tm.Commit(); //IDisposable will Rollback Transaction since it's left uncommitted } }
public void MapEFToBO() { var mapper = new DALEmployeePayHistoryMapper(); EmployeePayHistory entity = new EmployeePayHistory(); entity.SetProperties(1, DateTime.Parse("1/1/1987 12:00:00 AM"), 1, 1m, DateTime.Parse("1/1/1987 12:00:00 AM")); BOEmployeePayHistory response = mapper.MapEFToBO(entity); response.BusinessEntityID.Should().Be(1); response.ModifiedDate.Should().Be(DateTime.Parse("1/1/1987 12:00:00 AM")); response.PayFrequency.Should().Be(1); response.Rate.Should().Be(1m); response.RateChangeDate.Should().Be(DateTime.Parse("1/1/1987 12:00:00 AM")); }
public async Task ShouldCreateEmployeePayHistoryRecord() { var payHistory = new EmployeePayHistory { BusinessEntityID = 1, RateChangeDate = new DateTime(2020, 8, 18), Rate = 150.00M, PayFrequency = PayFrequency.Biweekly }; await _payHistoryRepo.CreatePayHistory(payHistory); var result = await _payHistoryRepo.GetPayHistoryByID(payHistory.BusinessEntityID, payHistory.RateChangeDate); Assert.NotNull(result); }
// PUT api/awbuildversion/5 public void Put(EmployeePayHistory value) { var GetActionType = Request.Headers.Where(x => x.Key.Equals("ActionType")).FirstOrDefault(); if (GetActionType.Key != null) { if (GetActionType.Value.ToList()[0].Equals("DELETE")) { adventureWorks_BC.EmployeePayHistoryDelete(value); } if (GetActionType.Value.ToList()[0].Equals("UPDATE")) { adventureWorks_BC.EmployeePayHistoryUpdate(value); } } }
/// <summary> /// Converts the entities to dto. /// </summary> /// <param name="_EmployeePayHistory">The EmployeePayHistory entity</param> /// <returns>EmployeePayHistoryDto</returns> public EmployeePayHistoryDto ConvertEntitiesToDto(EmployeePayHistory _EmployeePayHistory) { if (_EmployeePayHistory == null) { throw new ArgumentNullException("models should not be null"); } var _EmployeePayHistoryDto = new EmployeePayHistoryDto(); _EmployeePayHistoryDto.EmployeeID = _EmployeePayHistory.EmployeeID; _EmployeePayHistoryDto.RateChangeDate = _EmployeePayHistory.RateChangeDate; _EmployeePayHistoryDto.Rate = _EmployeePayHistory.Rate; _EmployeePayHistoryDto.PayFrequency = _EmployeePayHistory.PayFrequency; _EmployeePayHistoryDto.ModifiedDate = _EmployeePayHistory.ModifiedDate; return(_EmployeePayHistoryDto); }
/// <summary> /// Serialize a EmployeePayHistory collection into a temporary file. /// </summary> private void Step_08_SerializeCollection_Generated() { using (TransactionManager tm = CreateTransaction()) { string fileName = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "temp_EmployeePayHistoryCollection.xml"); mock = CreateMockInstance(tm); TList <EmployeePayHistory> mockCollection = new TList <EmployeePayHistory>(); mockCollection.Add(mock); EntityHelper.SerializeXml(mockCollection, fileName); Assert.IsTrue(System.IO.File.Exists(fileName), "Serialized mock collection not found"); System.Console.WriteLine("TList<EmployeePayHistory> correctly serialized to a temporary file."); } }
public async void Get() { var mock = new ServiceMockFacade <IEmployeePayHistoryRepository>(); var record = new EmployeePayHistory(); mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(record)); var service = new EmployeePayHistoryService(mock.LoggerMock.Object, mock.RepositoryMock.Object, mock.ModelValidatorMockFactory.EmployeePayHistoryModelValidatorMock.Object, mock.BOLMapperMockFactory.BOLEmployeePayHistoryMapperMock, mock.DALMapperMockFactory.DALEmployeePayHistoryMapperMock); ApiEmployeePayHistoryResponseModel response = await service.Get(default(int)); response.Should().NotBeNull(); mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>())); }
/// <summary> /// Create a new EmployeePayHistory object. /// </summary> /// <param name="employeeID">Initial value of EmployeeID.</param> /// <param name="rateChangeDate">Initial value of RateChangeDate.</param> /// <param name="rate">Initial value of Rate.</param> /// <param name="payFrequency">Initial value of PayFrequency.</param> /// <param name="modifiedDate">Initial value of ModifiedDate.</param> public static EmployeePayHistory CreateEmployeePayHistory(int employeeID, global::System.DateTime rateChangeDate, decimal rate, byte payFrequency, global::System.DateTime modifiedDate) { EmployeePayHistory employeePayHistory = new EmployeePayHistory(); employeePayHistory.EmployeeID = employeeID; employeePayHistory.RateChangeDate = rateChangeDate; employeePayHistory.Rate = rate; employeePayHistory.PayFrequency = payFrequency; employeePayHistory.ModifiedDate = modifiedDate; return employeePayHistory; }
// POST api/awbuildversion public void Post(EmployeePayHistory value) { adventureWorks_BC.EmployeePayHistoryAdd(value); }
/// <summary> /// There are no comments for EmployeePayHistory in the schema. /// </summary> public void AddToEmployeePayHistory(EmployeePayHistory employeePayHistory) { base.AddObject("EmployeePayHistory", employeePayHistory); }