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); } }