public void CreateCompensation_Returns_Created()
{
var employeeId = "16a596ae-edd3-4847-99fe-c4518e82c86f";
var compensation = new Compensation()
{
salary = 10000,
effectiveDate = "01-01-2000"
};
var requestContent = new JsonSerialization().ToJson(compensation);
var postRequestTask = _httpClient.PostAsync($"api/compensation/{employeeId}",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var newCompensation = response.DeserializeContent <Compensation>();
Assert.IsNotNull(newCompensation.compensationId);
Assert.IsNotNull(newCompensation.employee);
Assert.AreEqual(newCompensation.employee.EmployeeId, employeeId);
Assert.AreEqual(newCompensation.salary, compensation.salary);
Assert.AreEqual(newCompensation.effectiveDate, compensation.effectiveDate);
}
public void CreateCompensation_Returns_CreatedAsync()
{
var employee = new Employee()
{
EmployeeId = "16a596ae-edd3-4847-99fe-c4518e82c86f",
DirectReports = new List <Employee>()
};
// Arrange
var compensation = new Compensation()
{
CompensationId = 400,
employee = employee,
salary = 75000,
effectiveDate = DateTime.Parse("11/01/2020"),
};
// Execute
var requestContent = new JsonSerialization().ToJson(compensation);
var postRequestTask = _httpClient.PostAsync("api/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var newCompesnation = response.DeserializeContent <Compensation>();
Assert.IsNotNull(newCompesnation.CompensationId);
Assert.IsNotNull(compensation.employee);
Assert.IsNotNull(compensation.employee.EmployeeId);
Assert.AreEqual(compensation.salary, newCompesnation.salary);
Assert.AreEqual(compensation.effectiveDate, newCompesnation.effectiveDate);
}
public IActionResult CreateCompensation(String employeeId, [FromBody] Compensation compensation)
{
//Should not be able to create a compensation for a non-existant employee
var employee = _employeeService.GetById(employeeId);
if (employee == null)
{
return(NotFound());
}
//We'd normally add some validation at a higher middleware level
//and provide a proper error structure. Let's make
//sure we at least don't charge the employee instead of paying them :D
if (compensation.Salary < 0)
{
return(BadRequest());
}
compensation.Employee = employee;
_logger.LogDebug($"Received compensation create request for employee '{compensation?.Employee?.EmployeeId ?? ""}'");
var createdComp = _employeeService.CreateCompensation(compensation);
if (createdComp == null)
{
return(BadRequest());
}
return(CreatedAtRoute("getCompensationByEmployeeId", createdComp));
}
public void CreateCompensation_Multiple_Creation()
{
string paulMcCartneyEmployeeId = "b7839309-3348-463b-a7e3-5de1c168beb3";
DateTime firstEffectiveDateTime = new DateTime(2021, 5, 17);
int firstSalary = 100;
var firstCompensation = new Compensation()
{
EffectiveDate = firstEffectiveDateTime,
Salary = firstSalary,
};
PostValidCompensation(paulMcCartneyEmployeeId, firstCompensation);
DateTime secondEffectiveDateTime = new DateTime(2021, 6, 17);
int secondSalary = 200;
var secondCompensation = new Compensation()
{
EffectiveDate = secondEffectiveDateTime,
Salary = secondSalary,
};
PostValidCompensation(paulMcCartneyEmployeeId, secondCompensation);
var getRequestTask = _httpClient.GetAsync($"api/employee/{paulMcCartneyEmployeeId}/compensation");
var response = getRequestTask.Result;
var createdCompensations = response.DeserializeContent <List <Compensation> >();
Assert.AreEqual(createdCompensations.Count, 2);
Assert.AreEqual(createdCompensations[0].EffectiveDate, firstEffectiveDateTime);
Assert.AreEqual(createdCompensations[0].Salary, firstSalary);
Assert.AreEqual(createdCompensations[1].EffectiveDate, secondEffectiveDateTime);
Assert.AreEqual(createdCompensations[1].Salary, secondSalary);
}
public void CreateCompensation_Returns_Created()
{
// Initialize dummy object
var compensation = new Compensation()
{
EmployeeId = "03aa1462-ffa9-4978-901b-7c001562cf6f",
Salary = 15000,
EffectiveDate = new DateTime(2021, 2, 18)
};
var body = new JsonSerialization().ToJson(compensation);
// Request data from api
var postRequestTask = _httpClient.PostAsync($"api/compensation",
new StringContent(body, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Did the response return a 201 created code
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var newCompensation = response.DeserializeContent <Compensation>();
Assert.IsNotNull(newCompensation);
Assert.AreEqual("03aa1462-ffa9-4978-901b-7c001562cf6f", newCompensation.EmployeeId);
Assert.AreEqual(15000, newCompensation.Salary);
Assert.AreEqual(new DateTime(2021, 2, 18), newCompensation.EffectiveDate);
}
public void CreateCompensation_Returns_Created()
{
// Arrange
var compensation = new Compensation()
{
Employee = new Employee()
{
EmployeeId = "b7839309-3348-463b-a7e3-5de1c168beb3"
},
EffectiveDate = DateTime.Now,
Salary = 125000.00
};
var requestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PostAsync("api/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var newCompensation = response.DeserializeContent <Compensation>();
Assert.IsNotNull(newCompensation.Id);
Assert.AreEqual(compensation.EffectiveDate, newCompensation.EffectiveDate);
Assert.AreEqual(compensation.Salary, newCompensation.Salary);
Assert.AreEqual(compensation.Employee.EmployeeId, newCompensation.Employee.EmployeeId);
}
public IActionResult CreateCompensation([FromBody] Compensation compensation)
{
///VSHAH - Added null check to prevent object reference error when trying to write debug log if the request body was null.
if (compensation != null)
{
if (!ValidCompensationRequest(compensation))
{
return(BadRequest(ModelState));
}
try
{
_logger.LogDebug($"Received compensation create request for '{compensation.EmployeeId}'");
var compensationResult = _compensationService.Create(compensation);
return(CreatedAtRoute("getRecentCompensationByEmployeeId", new { id = compensation.EmployeeId }, compensation));
}
catch (Exception e)
{
return(BadRequest(new { message = "Error encountered while processing compensation request.", detail = $"{e.Message}" }));
}
}
else
{
_logger.LogError($"Received compensation create request with a null body");
return(BadRequest(new { message = "Request body cannot be empty" }));
}
}
public async Task CreateCompensation_RequiresSalary()
{
// Arrange
var compensation = new Compensation()
{
Employee = Guid.NewGuid().ToString(),
EffectiveDate = new DateTimeOffset(DateTime.UtcNow.Date),
};
var jsonSerialization = new JsonSerialization();
var requestContent = jsonSerialization.ToJson(compensation);
// Execute
var postRequestTask = await _httpClient.PostAsync("api/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask;
// Assert
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
var jsonContent = response.DeserializeContent <JObject>();
var salaryErrors = jsonContent.Property(nameof(Compensation.Salary));
Assert.IsNotNull(salaryErrors);
Assert.IsTrue(salaryErrors.HasValues);
}
public void GetByEmployeeId_Returns_Ok()
{
// Arrange
var employeeId = "03aa1462-ffa9-4978-901b-7c001562cf6f";
var compensation = new Compensation() // Seed value
{
Salary = 85000,
EffectiveDate = new DateTime(2020, 8, 2)
};
var firstRequestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PostAsync($"api/employee/{employeeId}/compensation",
new StringContent(firstRequestContent, Encoding.UTF8, "application/json")); // Adds seed value
postRequestTask.Wait();
var getRequestTask = _httpClient.GetAsync($"api/employee/{employeeId}/compensation"); // actual test
var response = getRequestTask.Result;
var retComp = response.DeserializeContent <Compensation>();
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(employeeId, retComp.EmployeeId);
Assert.AreEqual(compensation.Salary, retComp.Salary);
Assert.AreEqual(compensation.EffectiveDate, retComp.EffectiveDate);
}
public async Task <IHttpActionResult> PutCompensation(int id, Compensation compensation)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != compensation.Id)
{
return(BadRequest());
}
db.Entry(compensation).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CompensationExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
// var order = getOrder(compensation.OrderID);
return(Ok(removeNavAttr(compensation)));
}
public void CreateCompensation()
{
// Arrange
var compensation = new Compensation()
{
EmployeeId = "16a596ae-edd3-484992-99fe-c4518e82c86f",
Salary = Convert.ToDecimal(1234567.89),
EffectiveDate = Convert.ToDateTime("2020,11,3"),
};
var requestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PostAsync("api/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var newCompensation = response.DeserializeContent <Compensation>();
Assert.IsNotNull(newCompensation.EmployeeId);
Assert.AreEqual(compensation.Salary, newCompensation.Salary);
Assert.AreEqual(compensation.EffectiveDate, newCompensation.EffectiveDate);
}
public void CreateCompensation_Returns_Created()
{
// Arrange
var getRequestTask = _httpClient.GetAsync($"api/employee/16a596ae-edd3-4847-99fe-c4518e82c86f");
var resp = getRequestTask.Result;
var employee = resp.DeserializeContent <Employee>();
var compensation = new Compensation()
{
Employee = employee,
Salary = 80000,
EffectiveDate = new DateTime(2017, 02, 15)
};
var requestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PostAsync("api/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var newCompensation = response.DeserializeContent <Compensation>();
Assert.IsNotNull(newCompensation.Employee.EmployeeId);
Assert.AreEqual(compensation.Employee.FirstName, newCompensation.Employee.FirstName);
Assert.AreEqual(compensation.Employee.LastName, newCompensation.Employee.LastName);
Assert.AreEqual(compensation.Employee.Department, newCompensation.Employee.Department);
Assert.AreEqual(compensation.Employee.Position, newCompensation.Employee.Position);
Assert.AreEqual(compensation.EffectiveDate, newCompensation.EffectiveDate);
Assert.AreEqual(compensation.Salary, newCompensation.Salary);
}
public void CreateCompensation_Returns_Created()
{
// Arrange
var compensation = new Compensation()
{
Employee = "10dd63a3-0627-43fd-947e-bef59b3fa6c1",
EffectiveDate = new DateTimeOffset(DateTime.UtcNow.Date),
Salary = 200000
};
var requestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PostAsync("api/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var newCompensation = response.DeserializeContent <Compensation>();
//Assert.IsNotNull(newCompensation.Employee.Employee);
Assert.IsNotNull(newCompensation.Employee);
Assert.AreEqual(compensation.EffectiveDate, newCompensation.EffectiveDate);
Assert.AreEqual(compensation.Salary, newCompensation.Salary);
}
public async Task Seed()
{
// Add employees
if (!_employeeContext.Employees.Any())
{
List <Employee> employees = LoadEmployees();
_employeeContext.Employees.AddRange(employees);
await _employeeContext.SaveChangesAsync();
}
// Add one compensation
if (!_employeeContext.Compensations.Any())
{
var comp = new Compensation()
{
Employee = new Employee()
{
EmployeeId = "16a596ae-edd3-4847-99fe-c4518e82c86f"
},
EffectiveDate = new DateTime(2020, 12, 31),
Salary = 125000.00
};
_employeeContext.Compensations.AddRange(comp);
await _employeeContext.SaveChangesAsync();
}
}
public Compensation GetCompensationById(string id)
{
Compensation compensation = _employeeContext.Compensations.SingleOrDefault(c => c.Employee.EmployeeId == id);
compensation.Employee = GetById(id);
return(compensation);
}
public void UpdateCompensation_Returns_OkWhenOverwritting()
{
string employeeId = "c0c2293d-16bd-4603-8e08-638a9d18b22c";
// Arrange
var compensation = new Compensation()
{
Salary = 100,
EffectiveDate = DateTimeOffset.Now
};
var requestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PutAsync($"api/employee/{employeeId}/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
compensation.Salary = 200;
requestContent = new JsonSerialization().ToJson(compensation);
// Execute Again
postRequestTask = _httpClient.PutAsync($"api/employee/{employeeId}/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var compensationResponse = response.DeserializeContent <CompensationResponse>();
Assert.AreEqual("George Harrison", compensationResponse.Employee);
Assert.AreEqual(compensation.EffectiveDate, compensationResponse.EffectiveDate);
Assert.AreEqual(compensation.Salary, compensationResponse.Salary);
}
public void GetByEmployeeId_ValidEmployeeId_ReturnsCompensation()
{
// Arrange
var expectedCompensation = new Compensation
{
Employee = new Employee
{
EmployeeId = "16a596ae-edd3-4847-99fe-c4518e82c86f",
FirstName = "John",
LastName = "Lennon"
},
EffectiveDate = DateTime.Now.Date,
Salary = 100000
};
var logger = new Mock <ILogger <ICompensationService> >();
var repository = new Mock <ICompensationRepository>();
repository.Setup(c => c.GetByEmployeeId(expectedCompensation.Employee.EmployeeId))
.Returns(expectedCompensation);
// Execute
var compensation = new CompensationService(logger.Object, repository.Object).GetByEmployeeId(expectedCompensation.Employee.EmployeeId);
// Assert
compensation.Should().NotBeNull();
compensation.Employee.Should().NotBeNull();
compensation.Employee.FirstName.Should().Be(expectedCompensation.Employee.FirstName);
compensation.Employee.LastName.Should().Be(expectedCompensation.Employee.LastName);
compensation.EffectiveDate.Should().Be(expectedCompensation.EffectiveDate);
compensation.Salary.Should().Be(expectedCompensation.Salary);
}
public Compensation Add(Compensation compensation)
{
compensation.CompensationId = Guid.NewGuid().ToString();
_compensationContext.Compensations.Add(compensation);
return(compensation);
}
public void UpdateCompensation_Returns_OkWhenCreating()
{
string employeeId = "16a596ae-edd3-4847-99fe-c4518e82c86f";
// Arrange
var compensation = new Compensation()
{
Salary = 100,
EffectiveDate = DateTimeOffset.Now
};
var requestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PutAsync($"api/employee/{employeeId}/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var compensationResponse = response.DeserializeContent <CompensationResponse>();
Assert.AreEqual("John Lennon", compensationResponse.Employee);
Assert.AreEqual(compensation.EffectiveDate, compensationResponse.EffectiveDate);
Assert.AreEqual(compensation.Salary, compensationResponse.Salary);
}
public void Add_ValidCompensation_ReturnsCompensation()
{
// Arrange
var expectedCompensation = new Compensation
{
EmployeeId = "16a596ae-edd3-4847-99fe-c4518e82c86f",
EffectiveDate = DateTime.Now.Date,
Salary = 100000
};
Compensation persistedCompensation = null;
var logger = new Mock <ILogger <ICompensationRepository> >();
var context = new Mock <IEmployeeContext>();
context.Setup(c => c.Add(It.IsAny <Compensation>()))
.Callback((Compensation data) => persistedCompensation = data);
context.Setup(c => c.GetByEmployeeId(expectedCompensation.EmployeeId))
.Returns(expectedCompensation);
// Execute
var compensation = new CompensationRepository(logger.Object, context.Object).Add(expectedCompensation);
// Assert
persistedCompensation.Should().NotBeNull();
persistedCompensation.EmployeeId.Should().Be(expectedCompensation.EmployeeId);
persistedCompensation.EffectiveDate.Should().Be(expectedCompensation.EffectiveDate);
persistedCompensation.Salary.Should().Be(expectedCompensation.Salary);
compensation.Should().NotBeNull();
compensation.EmployeeId.Should().Be(expectedCompensation.EmployeeId);
compensation.EffectiveDate.Should().Be(expectedCompensation.EffectiveDate);
compensation.Salary.Should().Be(expectedCompensation.Salary);
}
public void CreateCompensation_Returns_Created_and_Get_And_Test_Get_By_Employee()
{
// Arrange
var compensationOriginalNoCompensationID = new Compensation()
{
EmployeeID = "16a596ae-edd3-4847-99fe-c4518e82c86f",
EffectiveDate = new DateTime(2021, 3, 10),
Salary = 101010.1
};
var compensationResponseStructure = CreateCompensationStructure(compensationOriginalNoCompensationID);
Assert.AreNotEqual(null, compensationResponseStructure.CompensationID);
Assert.IsTrue(SameContents(compensationOriginalNoCompensationID, compensationResponseStructure, false));
// Testing the get
var getResults = GetCompensationResult(compensationResponseStructure.CompensationID);
var getCompensationResponseStructure = getResults.DeserializeContent <Compensation>();
//Assert
Assert.AreEqual(HttpStatusCode.OK, getResults.StatusCode);
Assert.IsTrue(SameContents(compensationResponseStructure, getCompensationResponseStructure));
//Test Get by Employee
var getResultsByEmployeeID = _httpClient.GetAsync($"api/compensation/employee/{compensationOriginalNoCompensationID.EmployeeID}");
var resultsOfGetByEmployeeID = getResultsByEmployeeID.Result;
List <Compensation> getCompensationResponseStructureByEmployeeID = resultsOfGetByEmployeeID.DeserializeContent <List <Compensation> >();
//Assert
Assert.AreEqual(HttpStatusCode.OK, resultsOfGetByEmployeeID.StatusCode);
Assert.IsTrue(getCompensationResponseStructureByEmployeeID.Count == 1);
Assert.IsTrue(SameContents(compensationResponseStructure, getCompensationResponseStructureByEmployeeID[0]));
}
private HttpResponseMessage CreatCompensationResult(Compensation objectToCreate)
{
var requestContent = new JsonSerialization().ToJson(objectToCreate);
var postRequestTask = _httpClient.PostAsync("api/compensation", new StringContent(requestContent, Encoding.UTF8, "application/json"));
return(postRequestTask.Result);
}
public IActionResult update([FromBody] Compensation compensation)
{
if (compensation == null)
{
return(new ObjectResult(new Message {
status = "error", message = "Dữ liệu không hợp lệ"
}));
}
var a = _context.compensations.Where(p => p.compensationId.Equals(compensation.compensationId)).FirstOrDefault();
if (a == null)
{
return(new ObjectResult(new Message {
status = "error", message = "Không tồn tại"
}));
}
else
{
a.compensationId = compensation.compensationId;
a.compensationMoney = compensation.compensationMoney;
a.customerCode = compensation.customerCode;
a.insurranceId = compensation.insurranceId;
a.reason = compensation.reason;
_context.Update(a);
_context.SaveChanges();
return(new ObjectResult(new Message {
status = StatusMessage.success.ToString(), message = "Cập nhật thành công"
}));
}
}
public void CreateCompensation_Valid_Returns_Created()
{
// Arrange
Compensation compensation = new Compensation()
{
EmployeeId = "New_Employee_Test",
EffectiveDate = Convert.ToDateTime("01/22/2021"),
Salary = 99999.99
};
var requestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PostAsync("api/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Compensation newCompensation = response.DeserializeContent <Compensation>();
Assert.IsNotNull(newCompensation.EmployeeId);
Assert.AreEqual(compensation.EffectiveDate, newCompensation.EffectiveDate);
Assert.AreEqual(compensation.Salary, newCompensation.Salary);
}
public async Task <IActionResult> CreateCompensation(String id, [FromBody] Compensation compensation, CancellationToken cancellationToken)
{
_logger.LogDebug($"Received employee create compensation request for id '{id}'");
if (compensation == null)
{
ModelState.AddModelError("", "Compensation was not specified in the request");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var employee = _employeeService.GetById(id, true);
if (employee == null)
{
return(NotFound());
}
CompensationResponse compensationResponse = await _employeeService.ReplaceCompensation(employee, compensation, cancellationToken);
return(Ok(compensationResponse));
}
public void CreateCompensation_Returns_OK()
{
// Arrange
var compensation = new Compensation()
{
EmployeeId = "16a596ae-edd3-4847-99fe-c4518e82c86f",
Salary = 50000,
EffectiveDate = DateTimeOffset.Now
};
var expectedFirstName = "John";
var requestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PostAsync("api/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var newCompensation = response.DeserializeContent <Compensation>();
Assert.IsNotNull(newCompensation.EmployeeId);
Assert.AreEqual(expectedFirstName, newCompensation.Employee.FirstName);
Assert.AreEqual(compensation.Salary, newCompensation.Salary);
Assert.AreEqual(compensation.EffectiveDate, newCompensation.EffectiveDate);
}
public void CreateCompensation_Returns_Created()
{
// Arrange
var compensation = new Compensation()
{
EmployeeId = "16a596ae-edd3-4847-99fe-c4518e82c86f",
Salary = 70000.00M,
EffectiveDate = new DateTime(2019, 1, 1)
};
var requestContent = new JsonSerialization().ToJson(compensation);
// Execute
var postRequestTask = _httpClient.PostAsync("api/employee/compensation",
new StringContent(requestContent, Encoding.UTF8, "application/json"));
var response = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var newCompensation = response.DeserializeContent <Compensation>();
Assert.IsNotNull(newCompensation.CompensationId);
Assert.AreEqual(compensation.EmployeeId, newCompensation.EmployeeId);
Assert.AreEqual(compensation.Salary, newCompensation.Salary);
Assert.AreEqual(compensation.EffectiveDate, newCompensation.EffectiveDate);
}
public void CreateCompensation_Returns_BadRequest()
{
// Arrange
var employeeId = "b7839309-3348-463b-a7e3-5de1c168beb3";
var compensation = new Compensation() // Seed value
{
Salary = 85000,
EffectiveDate = new DateTime(2020, 8, 2)
};
var newCompensation = new Compensation()
{
Salary = 76000,
EffectiveDate = new DateTime(2020, 8, 5)
};
var firstRequestContent = new JsonSerialization().ToJson(compensation);
var secondRequestContent = new JsonSerialization().ToJson(newCompensation);
// Execute
var postRequestTask = _httpClient.PostAsync($"api/employee/{employeeId}/compensation",
new StringContent(firstRequestContent, Encoding.UTF8, "application/json")); // Adds seed value
var firstResponse = postRequestTask.Result;
postRequestTask = _httpClient.PostAsync($"api/employee/{employeeId}/compensation",
new StringContent(secondRequestContent, Encoding.UTF8, "application/json")); // actual test
var secondResponse = postRequestTask.Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, firstResponse.StatusCode);
Assert.AreEqual(HttpStatusCode.BadRequest, secondResponse.StatusCode);
}
public void GetCompensationByEmployeeId_ValidEmployeeId_ReturnsOk()
{
// Arrange
var expectedCompensation = new Compensation
{
Employee = new Employee
{
EmployeeId = "16a596ae-edd3-4847-99fe-c4518e82c86f",
FirstName = "John",
LastName = "Lennon"
},
EffectiveDate = new DateTime(2020, 9, 1),
Salary = 100000
};
// Execute
var getRequestTask = _httpClient.GetAsync($"api/compensations/{expectedCompensation.Employee.EmployeeId}");
var response = getRequestTask.Result;
// Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
var compensation = response.DeserializeContent <Compensation>();
compensation.Employee.FirstName.Should().Be(expectedCompensation.Employee.FirstName);
compensation.Employee.LastName.Should().Be(expectedCompensation.Employee.LastName);
compensation.EffectiveDate.Should().Be(expectedCompensation.EffectiveDate);
compensation.Salary.Should().Be(expectedCompensation.Salary);
}
public IActionResult add([FromBody] Compensation compensation)
{
if (compensation == null)
{
return(new ObjectResult(new Message {
status = "error", message = "Dữ liệu không hợp lệ"
}));
}
var a = _context.compensations.Where(p => p.compensationId == compensation.compensationId).FirstOrDefault();
if (a == null)
{
compensation.compensationId = 0;
_context.compensations.Add(compensation);
_context.SaveChanges();
return(new ObjectResult(new Message {
status = "success", message = "Thêm thành công"
}));
}
else
{
return(new ObjectResult(new Message {
status = "error", message = "Thêm thất bại"
}));
}
}
void Given_the__is(string Rate, decimal Value)
{
var DTO = new Compensation { RateChangeType = Rate };
DTO.Set(RateFields[Rate], Value);
Original(DTO);
}
public static CompensationDto createCompensationDTO(Compensation obj)
{
CompensationDto com = new CompensationDto();
com.CompensationId = obj.CompensationId;
com.CompensationType = obj.CompensationType;
com.CompensationDescription = obj.CompensationDescription;
return com;
}
public Boolean deleteCompensation(Compensation obj)
{
try
{
ICompensationSvc svc = (ICompensationSvc)this.getService(typeof(ICompensationSvc).Name);
return svc.deleteCompensation(obj);
}
catch (ServiceLoadException ex)
{
return false;
}
}
public Compensation selectCompensationById(Compensation obj)
{
try
{
ICompensationSvc svc = (ICompensationSvc)this.getService(typeof(ICompensationSvc).Name);
return svc.selectCompensationById(obj);
}
catch (ServiceLoadException ex)
{
return null;
}
}
public Compensation selectCompensationById(Compensation obj)
{
NewJobBankContext db = new NewJobBankContext();
try
{
return db.Compensations.SqlQuery("dbo.SelectCompensationById @CompensationId='" + obj.CompensationId.ToString() + "'").Single();
}
catch (Exception ex)
{
return null;
}
}
public Boolean insertCompensation(Compensation obj)
{
using (NewJobBankContext db = new NewJobBankContext())
{
try
{
db.Compensations.Add(obj);
db.SaveChanges();
return true;
}
catch (Exception ex)
{
return false;
}
}
}
public Boolean deleteCompensation(Compensation obj)
{
using (NewJobBankContext db = new NewJobBankContext())
{
try
{
Compensation compensation = db.Compensations.SqlQuery("dbo.SelectCompensationById @CompensationId='" + obj.CompensationId.ToString() + "'").Single();
if (compensation != null)
{
db.Compensations.Remove(compensation);
#region Database Submission
try
{
db.SaveChanges();
return true;
}
catch (Exception ex)
{
return false;
}
#endregion
}
else
{
return false;
}
}
catch (Exception ex)
{
return false;
}
}
}
public CompensationDto selectCompensationById(String CompensationId)
{
CompensationManager mgr = new CompensationManager();
Compensation obj = new Compensation();
obj.CompensationId = CompensationId;
obj = mgr.selectCompensationById(obj);
if (obj != null)
{
return CompensationDto.createCompensationDTO(obj);
}
else
{
return null;
}
}
