public async Task Test_Modify_Customer()
{
// New last name to change to and test
string newLastName = "Edwards";
string oldLastName = "Echols";
using (var client = new APIClientProvider().Client)
{
/*
* PUT section
*/
Customer modifiedCustomer = new Customer
{
FirstName = "Jameka",
LastName = newLastName,
};
var modifiedCustomerAsJSON = JsonConvert.SerializeObject(modifiedCustomer);
var response = await client.PutAsync(
"/api/customer/1",
new StringContent(modifiedCustomerAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
/*
* GET section
*/
var getCustomer = await client.GetAsync("/api/customer/1");
getCustomer.EnsureSuccessStatusCode();
string getCustomerBody = await getCustomer.Content.ReadAsStringAsync();
Customer newCustomer = JsonConvert.DeserializeObject <Customer>(getCustomerBody);
Assert.Equal(HttpStatusCode.OK, getCustomer.StatusCode);
Assert.Equal(newLastName, newCustomer.LastName);
Customer originalCustomer = new Customer
{
FirstName = "Jameka",
LastName = oldLastName,
};
var originalCustomerAsJSON = JsonConvert.SerializeObject(originalCustomer);
var originalResponse = await client.PutAsync(
"/api/customer/1",
new StringContent(originalCustomerAsJSON, Encoding.UTF8, "application/json")
);
string responseBodyOriginal = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, originalResponse.StatusCode);
}
}
public async Task Test_Modify_Customer()
{
using (var client = new APIClientProvider().Client)
{
var customerGetInitialResponse = await client.GetAsync("api/customers");
string initialResponseBody = await customerGetInitialResponse.Content.ReadAsStringAsync();
var customerList = JsonConvert.DeserializeObject <List <Customer> >(initialResponseBody);
Assert.Equal(HttpStatusCode.OK, customerGetInitialResponse.StatusCode);
var customerObject = customerList[0];
var defaultCustomerLastName = customerObject.LastName;
//PUT TEST BEGINS
customerObject.LastName = "newName";
var modifiedCustomAsJson = JsonConvert.SerializeObject(customerObject);
var response = await client.PutAsync($"api/customers/{customerObject.Id}",
new StringContent(modifiedCustomAsJson, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var getCustomer = await client.GetAsync($"api/customers/{customerObject.Id}");
getCustomer.EnsureSuccessStatusCode();
string getCustomerBody = await getCustomer.Content.ReadAsStringAsync();
Customer newCustomer = JsonConvert.DeserializeObject <Customer>(getCustomerBody);
Assert.Equal("newName", newCustomer.LastName);
newCustomer.LastName = defaultCustomerLastName;
var returnCustomerToDefault = JsonConvert.SerializeObject(newCustomer);
var putCustomerToDefault = await client.PutAsync($"api/customers/{customerObject.Id}",
new StringContent(returnCustomerToDefault, Encoding.UTF8, "application/json"));
string originalCustomerObject = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task Test_Modify_PaymentType()
{
using (var client = new APIClientProvider().Client)
{
PaymentType test = new PaymentType()
{
AcctNumber = 123456,
Name = "Visa",
CustomerId = 1
};
var testAsJson = JsonConvert.SerializeObject(test);
var response = await client.PutAsync("api/paymenttype/1", new StringContent(testAsJson, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
var getTest = await client.GetAsync("api/paymenttype/1");
getTest.EnsureSuccessStatusCode();
string getTestBody = await getTest.Content.ReadAsStringAsync();
PaymentType newTest = JsonConvert.DeserializeObject <PaymentType>(getTestBody);
Assert.Equal(HttpStatusCode.OK, getTest.StatusCode);
Assert.Equal("Visa", newTest.Name);
}
}
public async Task Test_Update_One_Department()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
string newName = "Humafdsfdsan Dumbsources";
int newBudget = 69;
var newDepartment = new Department
{
Name = newName,
Budget = newBudget
};
var newDepartmentAsJSON = JsonConvert.SerializeObject(newDepartment);
/*
* ACT
*/
var response = await client.PutAsync(
"/api/departments/2",
new StringContent(newDepartmentAsJSON, Encoding.UTF8, "application/json")
);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task Test_Update_One_Employee()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
string newName = "Tobey";
var newEmployee = new Employee
{
FirstName = "Someguy",
LastName = newName,
IsSupervisor = false,
DepartmentId = 1
};
var newEmployeeAsJSON = JsonConvert.SerializeObject(newEmployee);
/*
* ACT
*/
var response = await client.PutAsync(
"/api/employees/5",
new StringContent(newEmployeeAsJSON, Encoding.UTF8, "application/json")
);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task Test_Non_Existing_Get_Update_And_Delete_Order()
{
using (var order = new APIClientProvider().Client)
{
var response = await order.GetAsync("/api/Order/99999");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
//Checking Update
Order UpdateToNewOrder = new Order
{
CustomerId = 1
};
var newOrderJSON = JsonConvert.SerializeObject(UpdateToNewOrder);
response = await order.PutAsync(
$"api/Order/99999",
new StringContent(newOrderJSON, Encoding.UTF8, "application/json")
);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
//Checking Delete Part
var deleteResponse = await order.DeleteAsync($"/api/Order/99999");
Assert.Equal(HttpStatusCode.NotFound, deleteResponse.StatusCode);
}
}
public async Task Test_Update_One_Customer()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
string newName = "DummyBoi";
var newCustomer = new Customer
{
FirstName = "Somebody",
LastName = newName
};
var newCustomerAsJSON = JsonConvert.SerializeObject(newCustomer);
/*
* ACT
*/
var response = await client.PutAsync(
"/api/customers/7",
new StringContent(newCustomerAsJSON, Encoding.UTF8, "application/json")
);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task Test_Modify_NonExistentCustomer()
{
// New last name to change to and test
string newFirstName = "Sermour";
using (var client = new APIClientProvider().Client)
{
/*
* PUT section
*/
Customer modifiedSeymour = new Customer
{
FirstName = newFirstName,
LastName = "Butts"
};
var modifiedSeymourAsJSON = JsonConvert.SerializeObject(modifiedSeymour);
var response = await client.PutAsync(
"api/Customer/999999",
new StringContent(modifiedSeymourAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
Assert.False(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
}
public async Task Test_Modify_Department()
{
using (var client = new APIClientProvider().Client)
{
string newName = "HR";
Department modifiedHR = new Department
{
Name = newName,
Budget = 25000
};
var modifiedHRAsJSON = JsonConvert.SerializeObject(modifiedHR);
var response = await client.PutAsync(
"api/Department/1",
new StringContent(modifiedHRAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
var getHR = await client.GetAsync("api/Department/1");
getHR.EnsureSuccessStatusCode();
List <Department> newHR = new List <Department>();
string getHRBody = await getHR.Content.ReadAsStringAsync();
newHR = JsonConvert.DeserializeObject <List <Department> >(getHRBody);
Assert.Equal(HttpStatusCode.OK, getHR.StatusCode);
Assert.Equal(newName, newHR[0].Name);
}
}
public async Task Test_Modify_TrainingProgram()
{
using (var client = new APIClientProvider().Client)
{
//20190618 10:34:09 AM
TrainingProgram test = new TrainingProgram()
{
Name = "Dragon Training",
StartDate = new DateTime(2019, 06, 18, 10, 34, 09),
EndDate = new DateTime(2019, 06, 18, 10, 34, 09),
MaxAttendees = 2
};
var testAsJson = JsonConvert.SerializeObject(test);
var response = await client.PutAsync("api/trainingprogram/1", new StringContent(testAsJson, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
var getTest = await client.GetAsync("api/trainingprogram/1");
getTest.EnsureSuccessStatusCode();
string getTestBody = await getTest.Content.ReadAsStringAsync();
var newTest = JsonConvert.DeserializeObject <List <TrainingProgram> >(getTestBody);
Assert.Equal(HttpStatusCode.OK, getTest.StatusCode);
Assert.Equal("Dragon Training", newTest[0].Name);
}
}
public async Task Test_Modify_ProductType()
{
string newName = "HouseCare";
using (var client = new APIClientProvider().Client)
{
ProductTypes modifiedProductType = new ProductTypes
{
Name = "HouseCare",
};
var modifiedProductTypeAsJSON = JsonConvert.SerializeObject(modifiedProductType);
var response = await client.PutAsync(
"/api/producttype/1",
new StringContent(modifiedProductTypeAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
var getProductType = await client.GetAsync("/api/producttype/1");
getProductType.EnsureSuccessStatusCode();
string getProductTypeBody = await getProductType.Content.ReadAsStringAsync();
ProductTypes newProductType = JsonConvert.DeserializeObject <ProductTypes>(getProductTypeBody);
Assert.Equal(HttpStatusCode.OK, getProductType.StatusCode);
Assert.Equal(newName, newProductType.Name);
}
}
public async Task Test_Modify_Customer()
{
string newFirstName = "Not Allison";
using (var client = new APIClientProvider().Client)
{
Customer modifiedAaron = new Customer
{
FirstName = newFirstName,
LastName = "Carter"
};
var modifiedAaronAsJSON = JsonConvert.SerializeObject(modifiedAaron);
var response = await client.PutAsync(
"/api/customer/1",
new StringContent(modifiedAaronAsJSON, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
var getAaron = await client.GetAsync("/api/customer/1");
getAaron.EnsureSuccessStatusCode();
string getAaronBody = await getAaron.Content.ReadAsStringAsync();
Customer newAaron = JsonConvert.DeserializeObject <Customer>(getAaronBody);
Assert.Equal(HttpStatusCode.OK, getAaron.StatusCode);
Assert.Equal(newFirstName, newAaron.FirstName);
}
}
public async Task Test_Update_Nonexisting_Training_Program()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
TrainingProgram testTrainingProgram = new TrainingProgram()
{
Name = "Test Training Program 2",
StartDate = new DateTime(2020, 08, 26),
EndDate = new DateTime(2020, 09, 15),
MaxAttendees = 25
};
var jsonTrainingProgram = JsonConvert.SerializeObject(testTrainingProgram);
/*
* ACT
*/
var response = await client.PutAsync(
"/api/trainingPrograms/9999999",
new StringContent(jsonTrainingProgram, Encoding.UTF8, "application/json")
);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
}
public async Task Test_Non_Existing_Get_Update_And_Delete_Department()
{
using (var department = new APIClientProvider().Client)
{
var response = await department.GetAsync("/api/Department/99999");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
//Checking Update
Department UpdateToNewDept = new Department
{
Name = "New Dept",
Budget = 500
};
var newDeptJSON = JsonConvert.SerializeObject(UpdateToNewDept);
response = await department.PutAsync(
$"api/Department/99999",
new StringContent(newDeptJSON, Encoding.UTF8, "application/json")
);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
//Checking Delete Part
var deleteResponse = await department.DeleteAsync($"/api/Department/99999");
Assert.Equal(HttpStatusCode.NotFound, deleteResponse.StatusCode);
}
}
public async Task Test_Non_Existing_Get_Update_And_Delete_TrainingProgram()
{
using (var trainingProgram = new APIClientProvider().Client)
{
var response = await trainingProgram.GetAsync("/api/TrainingProgram/99999");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
//Checking Update
TrainingProgram UpdateToNewTrainingProgram = new TrainingProgram
{
Name = "Coding with Emojies",
StartDate = DateTime.Parse("2020-01-01 13:00:00"),
EndDate = DateTime.Parse("2019-01-07 13:00:00"),
MaxAttendees = 100
};
var newTrainingProgramJSON = JsonConvert.SerializeObject(UpdateToNewTrainingProgram);
response = await trainingProgram.PutAsync(
$"api/TrainingProgram/99999",
new StringContent(newTrainingProgramJSON, Encoding.UTF8, "application/json")
);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
//Checking Delete Part
var deleteResponse = await trainingProgram.DeleteAsync($"/api/TrainingProgram/99999");
Assert.Equal(HttpStatusCode.NotFound, deleteResponse.StatusCode);
}
}
public async Task Test_Modify_TrainingProgram()
{
using (var client = new APIClientProvider().Client)
{
int newmax = 15;
TrainingProgram trainingprogram = new TrainingProgram
{
Name = "How To Sell Cars",
StartDate = new DateTime(2020, 02, 14),
EndDate = new DateTime(2019, 02, 15),
MaxAttendees = newmax
};
var modifiedDeptAsJSON = JsonConvert.SerializeObject(trainingprogram);
var response = await client.PutAsync(
"/api/TrainingProgram/1",
new StringContent(modifiedDeptAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var getmax = await client.GetAsync("/api/TrainingProgram");
getmax.EnsureSuccessStatusCode();
string getBody = await getmax.Content.ReadAsStringAsync();
var newMaxAttendees = JsonConvert.DeserializeObject <List <TrainingProgram> >(getBody);
Assert.Equal(HttpStatusCode.OK, getmax.StatusCode);
Assert.Equal(newmax, newMaxAttendees[0].MaxAttendees);
}
}
public async Task Test_updateOneFalse_ProductType()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
ProductType updateProduct = new ProductType
{
Name = "Dog Socks"
};
var falseUpdateProductAsJSON = JsonConvert.SerializeObject(updateProduct);
/*
* ACT
*/
var falseUpdateResponse = await client.PutAsync("/api/producttype/1000",
new StringContent(falseUpdateProductAsJSON, Encoding.UTF8, "application/json"));
string falseUpdateResponseBody = await falseUpdateResponse.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NotFound, falseUpdateResponse.StatusCode);
}
}
public async Task Test_Put_ProductType()
{
string Name = "Mac Book Bro";
using (var client = new APIClientProvider().Client)
{
ProductType changeProductType = new ProductType
{
Name = Name
};
var productTypeJson = JsonConvert.SerializeObject(changeProductType);
var response = await client.PutAsync(
"/api/productType/1",
new StringContent(productTypeJson, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
var getProducType = await client.GetAsync("/api/productType/1");
getProducType.EnsureSuccessStatusCode();
string getProductTypeBody = await getProducType.Content.ReadAsStringAsync();
var newProductType = JsonConvert.DeserializeObject <ProductType>(getProductTypeBody);
Assert.Equal(HttpStatusCode.OK, getProducType.StatusCode);
Assert.Equal(Name, newProductType.Name);
}
}
public async Task Test_Modify_Product()
{
using (var client = new APIClientProvider().Client)
{
/*
* PUT
*/
Product ModifiedProduct = new Product
{
ProductTypeId = 1,
CustomerId = 1,
Price = 20,
Title = "This Was Modified by a test",
Description = "Modified by test",
Quantity = 500
};
var jsonBody = JsonConvert.SerializeObject(ModifiedProduct);
var response = await client.PutAsync(
"/api/products/1",
new StringContent(jsonBody, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
}
public async Task Test_Update_One_Order()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
int newCustomerId = 3;
var newOrder = new Order
{
CustomerId = newCustomerId,
PaymentTypeId = 4
};
var newOrderAsJSON = JsonConvert.SerializeObject(newOrder);
/*
* ACT
*/
var response = await client.PutAsync(
"/api/orders/6",
new StringContent(newOrderAsJSON, Encoding.UTF8, "application/json")
);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task Test_Modify_Customer()
{
string newName = "Remo";
using (var client = new APIClientProvider().Client)
{
Customer modifiedCustomer = new Customer
{
FirstName = "Mary",
LastName = newName
};
var modifiedCustomerAsJSON = JsonConvert.SerializeObject(modifiedCustomer);
var response = await client.PutAsync(
"/api/customer/1",
new StringContent(modifiedCustomerAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var getRemo = await client.GetAsync("/api/customer/1");
getRemo.EnsureSuccessStatusCode();
string getRemoBody = await getRemo.Content.ReadAsStringAsync();
Customer newLastName = JsonConvert.DeserializeObject <Customer>(getRemoBody);
Assert.Equal(HttpStatusCode.OK, getRemo.StatusCode);
Assert.Equal(newName, newLastName.LastName);
}
}
public async Task Test_Modify_Employee()
{
string newFirstName = "Real Allison";
using (var client = new APIClientProvider().Client)
{
Employee modifiedAllison = new Employee
{
FirstName = newFirstName,
LastName = "Collins",
IsSupervisor = true,
DepartmentId = 4
};
var modifiedAllisonAsJSON = JsonConvert.SerializeObject(modifiedAllison);
var response = await client.PutAsync(
"/api/employee/1",
new StringContent(modifiedAllisonAsJSON, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
var getAllison = await client.GetAsync("/api/employee/1");
getAllison.EnsureSuccessStatusCode();
string getAllisonBody = await getAllison.Content.ReadAsStringAsync();
Employee newAllison = JsonConvert.DeserializeObject <Employee>(getAllisonBody);
Assert.Equal(HttpStatusCode.OK, getAllison.StatusCode);
Assert.Equal("Real Allison", newAllison.FirstName);
}
}
public async Task Test_Update_One_Payment_Type()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
var newName = "bank-of-america";
var newPaymentType = new PaymentType
{
AcctNumber = 224500,
Name = newName,
CustomerId = 3
};
var newPaymentTypeAsJson = JsonConvert.SerializeObject(newPaymentType);
/*
* ACT
*/
var response = await client.PutAsync(
"/api/paymenttypes/5",
new StringContent(newPaymentTypeAsJson, Encoding.UTF8, "application/json")
);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task TestUpdateDepartment()
{
using (var client = new APIClientProvider().Client) {
var departmentGetInitialResponse = await client.GetAsync("api/departments");
string initialResponseBody = await departmentGetInitialResponse.Content.ReadAsStringAsync();
var departmentList = JsonConvert.DeserializeObject <List <Department> >(initialResponseBody);
Assert.Equal(HttpStatusCode.OK, departmentGetInitialResponse.StatusCode);
var departmentObject = departmentList[0];
var defaultDepartmentName = departmentObject.Name;
//BEGIN PUT TEST
departmentObject.Name = "TestName";
var modifiedDepartmentAsJson = JsonConvert.SerializeObject(departmentObject);
var response = await client.PutAsync($"api/departments/{ departmentObject.Id}",
new StringContent(modifiedDepartmentAsJson, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
var getDepartment = await client.GetAsync($"api/departments/{ departmentObject.Id}");
getDepartment.EnsureSuccessStatusCode();
string getDepartmentBody = await getDepartment.Content.ReadAsStringAsync();
Department newDepartment = JsonConvert.DeserializeObject <Department>(getDepartmentBody);
Assert.Equal("TestName", newDepartment.Name);
newDepartment.Name = defaultDepartmentName;
var returnDepartmentToDefault = JsonConvert.SerializeObject(newDepartment);
var putDepartmentToDefault = await client.PutAsync($"api/departments/{newDepartment.Id}",
new StringContent(returnDepartmentToDefault, Encoding.UTF8, "application/json"));
string originalDepartmentObject = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);;
}
}
public async Task TestUpdateTrainingProgram()
{
using (var client = new APIClientProvider().Client) {
var trainingProgramGetInitialResponse = await client.GetAsync("api/trainingprograms");
string initialResponseBody = await trainingProgramGetInitialResponse.Content.ReadAsStringAsync();
var trainingProgramList = JsonConvert.DeserializeObject <List <TrainingProgram> >(initialResponseBody);
Assert.Equal(HttpStatusCode.OK, trainingProgramGetInitialResponse.StatusCode);
var trainingProgramObject = trainingProgramList[0];
var defaultTrainingProgramName = trainingProgramObject.Name;
//BEGIN PUT TEST
trainingProgramObject.Name = "TestName";
var modifiedTrainingProgramAsJson = JsonConvert.SerializeObject(trainingProgramObject);
var response = await client.PutAsync($"api/trainingprograms/{trainingProgramObject.Id}",
new StringContent(modifiedTrainingProgramAsJson, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
var getTrainingProgram = await client.GetAsync($"api/trainingprograms/{trainingProgramObject.Id}");
getTrainingProgram.EnsureSuccessStatusCode();
string getTrainingProgramBody = await getTrainingProgram.Content.ReadAsStringAsync();
TrainingProgram newTrainingProgram = JsonConvert.DeserializeObject <TrainingProgram>(getTrainingProgramBody);
Assert.Equal("TestName", newTrainingProgram.Name);
newTrainingProgram.Name = defaultTrainingProgramName;
var returnTrainingProgramToDefault = JsonConvert.SerializeObject(newTrainingProgram);
var putTrainingProgramToDefault = await client.PutAsync($"api/trainingprograms/{newTrainingProgram.Id}",
new StringContent(returnTrainingProgramToDefault, Encoding.UTF8, "application/json"));
string originalTrainingProgramObject = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);;
}
}
public async Task Test_Modify_Order()
{
using (var client = new APIClientProvider().Client)
{
var employeeGetInitialResponse = await client.GetAsync("api/employees");
string initialResponseBody = await employeeGetInitialResponse.Content.ReadAsStringAsync();
var employeeList = JsonConvert.DeserializeObject <List <Employee> >(initialResponseBody);
Assert.Equal(HttpStatusCode.OK, employeeGetInitialResponse.StatusCode);
var employeeObject = employeeList[0];
var defaultEmployeeFirstName = employeeObject.FirstName;
/* PUT section */
employeeObject.FirstName = "Tester";
var modifiedEmployeeAsJson = JsonConvert.SerializeObject(employeeObject);
var response = await client.PutAsync($"api/employees/{employeeObject.Id}",
new StringContent(modifiedEmployeeAsJson, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var getEmployee = await client.GetAsync($"api/employees/{employeeObject.Id}");
getEmployee.EnsureSuccessStatusCode();
string getEmployeeBody = await getEmployee.Content.ReadAsStringAsync();
Employee newEmployee = JsonConvert.DeserializeObject <Employee>(getEmployeeBody);
Assert.Equal("Tester", newEmployee.FirstName);
newEmployee.FirstName = defaultEmployeeFirstName;
var returnEmployeeToDefault = JsonConvert.SerializeObject(newEmployee);
var putEmployeeToDefault = await client.PutAsync($"api/employees/{newEmployee.Id}",
new StringContent(returnEmployeeToDefault, Encoding.UTF8, "application/json"));
string originalEmployeeObject = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task Test_Modify_Product_Type()
{
using (var client = new APIClientProvider().Client)
{
var productTypeGetInitialResponse = await client.GetAsync("api/producttype");
string initialResponseBody = await productTypeGetInitialResponse.Content.ReadAsStringAsync();
var productTypeList = JsonConvert.DeserializeObject <List <ProductType> >(initialResponseBody);
Assert.Equal(HttpStatusCode.OK, productTypeGetInitialResponse.StatusCode);
var productTypeObject = productTypeList[0];
var defaultProductTypeName = productTypeObject.Name;
/* PUT section */
productTypeObject.Name = "ThisIsATest";
var modifiedProductTypeAsJson = JsonConvert.SerializeObject(productTypeObject);
var response = await client.PutAsync($"api/producttype/{productTypeObject.Id}",
new StringContent(modifiedProductTypeAsJson, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var getProductType = await client.GetAsync($"api/producttype/{productTypeObject.Id}");
getProductType.EnsureSuccessStatusCode();
string getProductTypeBody = await getProductType.Content.ReadAsStringAsync();
ProductType newProductType = JsonConvert.DeserializeObject <ProductType>(getProductTypeBody);
Assert.Equal("ThisIsATest", newProductType.Name);
newProductType.Name = defaultProductTypeName;
var returnProductTypeToDefault = JsonConvert.SerializeObject(newProductType);
var putProductTypeToDefault = await client.PutAsync($"api/producttype/{newProductType.Id}",
new StringContent(returnProductTypeToDefault, Encoding.UTF8, "application/json"));
string originalProductTypeObject = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task Test_Modify_Order()
{
using (var client = new APIClientProvider().Client)
{
var orderGetInitialResponse = await client.GetAsync("api/orders");
string initialResponseBody = await orderGetInitialResponse.Content.ReadAsStringAsync();
var orderList = JsonConvert.DeserializeObject <List <Order> >(initialResponseBody);
Assert.Equal(HttpStatusCode.OK, orderGetInitialResponse.StatusCode);
var orderObject = orderList[0];
var defaultCustomerId = orderObject.CustomerId;
/* PUT section */
orderObject.CustomerId = 1;
var modifiedOrderAsJson = JsonConvert.SerializeObject(orderObject);
var response = await client.PutAsync($"api/orders/{orderObject.Id}",
new StringContent(modifiedOrderAsJson, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var getOrder = await client.GetAsync($"api/orders/{orderObject.Id}");
getOrder.EnsureSuccessStatusCode();
string getOrderBody = await getOrder.Content.ReadAsStringAsync();
Order newOrder = JsonConvert.DeserializeObject <Order>(getOrderBody);
Assert.Equal(1, newOrder.CustomerId);
newOrder.CustomerId = defaultCustomerId;
var returnOrderToDefault = JsonConvert.SerializeObject(newOrder);
var putOrderToDefault = await client.PutAsync($"api/orders/{newOrder.Id}",
new StringContent(returnOrderToDefault, Encoding.UTF8, "application/json"));
string originalOrderObject = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task Test_Update_Existing_Product()
{
int testId = 1;
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
Product testProduct = new Product()
{
Title = "Test Product",
ProductTypeId = 1,
CustomerId = 1,
Price = (decimal)21.25,
Description = "Test Description",
Quantity = 1
};
var jsonProduct = JsonConvert.SerializeObject(testProduct);
/*
* ACT
*/
var response = await client.PutAsync(
$"/api/products/{testId}",
new StringContent(jsonProduct, Encoding.UTF8, "application/json")
);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
/*
* GET
*/
var getProduct = await client.GetAsync($"/api/products/{testId}");
getProduct.EnsureSuccessStatusCode();
string getResponse = await getProduct.Content.ReadAsStringAsync();
Product updatedProduct = JsonConvert.DeserializeObject <Product>(getResponse);
Assert.Equal(HttpStatusCode.OK, getProduct.StatusCode);
Assert.Equal(testId, updatedProduct.Id);
Assert.Equal(testProduct.Title, updatedProduct.Title);
Assert.Equal(testProduct.Description, updatedProduct.Description);
}
}
public async Task PutCustomer_Success()
{
using (HttpClient client = new APIClientProvider().Client)
{
string customer = GenerateCustomerPut();
HttpResponseMessage response = await client.PutAsync("api/Customer/4", new StringContent(customer, Encoding.UTF8, "application/json"));
response.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
}