public async Task Test_Create_And_Delete_Customer()
{
using (var client = new APIClientProvider().Client)
{
Customer customer = new Customer
{
FirstName = "Steve",
LastName = "Brownlee",
};
var customerAsJSON = JsonConvert.SerializeObject(customer);
var response = await client.PostAsync(
"/Customer",
new StringContent(customerAsJSON, Encoding.UTF8, "application/json")
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Customer newCustomer = JsonConvert.DeserializeObject <Customer>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("Steve", newCustomer.FirstName);
Assert.Equal("Brownlee", newCustomer.LastName);
var deleteResponse = await client.DeleteAsync($"/Customer/{newCustomer.Id}");
deleteResponse.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Create_Delete_PaymentType()
{
using (var client = new APIClientProvider().Client)
{
PaymentType Visa = new PaymentType
{
Name = "Visa",
AccountNumber = 555666,
CustomerId = 2
};
var VisaAsJSON = JsonConvert.SerializeObject(Visa);
var response = await client.PostAsync(
"/api/paymenttypes",
new StringContent(VisaAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
var NewVisa = JsonConvert.DeserializeObject <PaymentType>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal(Visa.Name, NewVisa.Name);
Assert.Equal(Visa.AccountNumber, NewVisa.AccountNumber);
var deleteResponse = await client.DeleteAsync($"/api/paymenttypes/{NewVisa.Id}");
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Create_And_Delete_Department()
{
using (var client = new APIClientProvider().Client)
{
Department newDepartment = new Department
{
Name = "TestDepartment",
Budget = 9000
};
var departmentAsJSON = JsonConvert.SerializeObject(newDepartment);
var response = await client.PostAsync(
"/departments",
new StringContent(departmentAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
Department newerDepartment = JsonConvert.DeserializeObject <Department>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("TestDepartment", newerDepartment.Name);
Assert.Equal(9000, newerDepartment.Budget);
var deleteResponse = await client.DeleteAsync($"/departments/{newerDepartment.Id}");
deleteResponse.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Delete_PaymentType()
{
using (var client = new APIClientProvider().Client)
{
var newPaymentType = new PaymentType()
{
Name = "UBS",
AcctNumber = 98765,
CustomerId = 1
};
var jsonNewPaymentType = JsonConvert.SerializeObject(newPaymentType);
var response = await client.PostAsync("/api/PaymentTypes",
new StringContent(jsonNewPaymentType,
Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
var paymentType = JsonConvert.DeserializeObject <PaymentType>(responseBody);
/*
* ACT
*/
var deleteResponse = await client.DeleteAsync($"/api/PaymentTypes/{paymentType.Id}");
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Create_And_Delete_Order()
{
using (var client = new APIClientProvider().Client)
{
Order orderOne = new Order
{
CustomerId = 3,
PaymentTypeId = 3
};
var orderOneAsJSON = JsonConvert.SerializeObject(orderOne);
var response = await client.PostAsync(
"api/Order",
new StringContent(orderOneAsJSON, Encoding.UTF8, "application/json")
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
var newOrder = JsonConvert.DeserializeObject <Order>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal(3, newOrder.CustomerId);
Assert.Equal(3, newOrder.PaymentTypeId);
var deleteResponse = await client.DeleteAsync($"api/Order/{newOrder.Id}");
deleteResponse.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Delete_ProductType()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
ProductType newProductType = new ProductType()
{
Name = "DELETE TEST"
};
var productAsJSON = JsonConvert.SerializeObject(newProductType);
var postResponse = await client.PostAsync(
"/api/producttypes",
new StringContent(productAsJSON, Encoding.UTF8, "application/json"));
string responseBody = await postResponse.Content.ReadAsStringAsync();
var product = JsonConvert.DeserializeObject <ProductType>(responseBody);
/*
* ACT
*/
var deleteResponse = await client.DeleteAsync($"/api/producttypes/{product.Id}");
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.OK, deleteResponse.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_Remove_Product()
{
using (var client = new APIClientProvider().Client)
{
var productGetInitialResponse = await client.GetAsync("api/products");
string initialResponseBody = await productGetInitialResponse.Content.ReadAsStringAsync();
var productList = JsonConvert.DeserializeObject <List <Product> >(initialResponseBody);
Assert.Equal(HttpStatusCode.OK, productGetInitialResponse.StatusCode);
int removeLastObject = productList.Count - 1;
var productObject = productList[removeLastObject];
var response = await client.DeleteAsync($"api/products/{productObject.Id}");
string responseBody = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var getProduct = await client.GetAsync($"api/products/{productObject.Id}");
getProduct.EnsureSuccessStatusCode();
string getProductBody = await getProduct.Content.ReadAsStringAsync();
Product newProduct = JsonConvert.DeserializeObject <Product>(getProductBody);
Assert.Equal(HttpStatusCode.NoContent, getProduct.StatusCode);
}
}
public async Task Test_Delete_TrainingProgram()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
TrainingProgram trainingProgramToDelete = new TrainingProgram
{
Name = "Test Training Program",
StartDate = DateTime.Now,
EndDate = DateTime.Today.AddDays(1),
MaxAttendees = 2
};
// Serialize the C# object into a JSON string
var trainingProgramAsJSON = JsonConvert.SerializeObject(trainingProgramToDelete);
/*
* ACT
*/
//Insert object
var response = await client.PostAsync(
"/api/trainingprogram",
new StringContent(trainingProgramAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
var newTrainingProgram = JsonConvert.DeserializeObject <TrainingProgram>(responseBody);
//Get object
var getTrainingProgramToDelete = await client.GetAsync($"/api/trainingprogram/{newTrainingProgram.Id}");
getTrainingProgramToDelete.EnsureSuccessStatusCode();
string getTrainingProgramToDeleteBody = await getTrainingProgramToDelete.Content.ReadAsStringAsync();
TrainingProgram newTrainingProgramFromResponse = JsonConvert.DeserializeObject <TrainingProgram>(getTrainingProgramToDeleteBody);
//Delete Object
var deleteTrainingProgram = await client.DeleteAsync($"/api/trainingprogram/{newTrainingProgram.Id}");
deleteTrainingProgram.EnsureSuccessStatusCode();
//Try to Get Object Again
var attemptGetTrainingProgram = await client.GetAsync($"/api/trainingprogram/{newTrainingProgram.Id}");
attemptGetTrainingProgram.EnsureSuccessStatusCode();
string attemptGetTrainingProgramBody = await getTrainingProgramToDelete.Content.ReadAsStringAsync();
TrainingProgram newAttemptToGetTrainingProgram = JsonConvert.DeserializeObject <TrainingProgram>(attemptGetTrainingProgramBody);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.NoContent, attemptGetTrainingProgram.StatusCode);
}
}
public async Task Test_Create_And_Delete_ProductType()
{
using (var client = new APIClientProvider().Client)
{
ProductType drugs = new ProductType
{
Name = "Drugs"
};
var drugsAsJSON = JsonConvert.SerializeObject(drugs);
var response = await client.PostAsync(
"/productTypes",
new StringContent(drugsAsJSON, Encoding.UTF8, "application/json")
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
var newDrugs = JsonConvert.DeserializeObject <ProductType>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("Drugs", newDrugs.Name);
// Delete the newly posted object
var deleteResponse = await client.DeleteAsync($"/productTypes/{newDrugs.Id}");
deleteResponse.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Create_And_Delete_Program()
{
using (var client = new APIClientProvider().Client)
{
TrainingProgram trainingProgram = new TrainingProgram
{
Name = "AWS",
StartDate = DateTime.Today,
EndDate = DateTime.Now,
MaxAttendees = 70
};
var programAsJSON = JsonConvert.SerializeObject(trainingProgram);
var response = await client.PostAsync(
"/TrainingPrograms",
new StringContent(programAsJSON, Encoding.UTF8, "application/json")
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
TrainingProgram newProgram = JsonConvert.DeserializeObject <TrainingProgram>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal(70, newProgram.MaxAttendees);
Assert.Equal("AWS", newProgram.Name);
var deleteResponse = await client.DeleteAsync($"/TrainingPrograms/{newProgram.Id}");
deleteResponse.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.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_Create_Delete_ProductType()
{
using (var client = new APIClientProvider().Client)
{
ProductType tablet = new ProductType
{
Name = "Televisions"
};
var tabletAsJSON = JsonConvert.SerializeObject(tablet);
var response = await client.PostAsync(
"api/producttype/",
new StringContent(tabletAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
var newTablet = JsonConvert.DeserializeObject <ProductType>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("Televisions", newTablet.Name);
var deleteResponse = await client.DeleteAsync($"api/producttype/{newTablet.Id}");
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Delete_Order()
{
using (var client = new APIClientProvider().Client)
{
var response = await client.DeleteAsync("/api/Order/1");
/*
* DELETE section
*/
var getOldList = await client.GetAsync("/api/Order");
getOldList.EnsureSuccessStatusCode();
string getOldListBody = await getOldList.Content.ReadAsStringAsync();
var oldList = JsonConvert.DeserializeObject <List <Order> >(getOldListBody);
var getOrder = await client.GetAsync("/api/Order");
getOrder.EnsureSuccessStatusCode();
string getOrderBody = await getOrder.Content.ReadAsStringAsync();
var newList = JsonConvert.DeserializeObject <List <Order> >(getOrderBody);
/*
* ASSERT
*/
Assert.False(newList.Count > oldList.Count);
}
}
public async Task Test_Create_and_Delete_PaymentType()
{
using (var client = new APIClientProvider().Client)
{
PaymentType payment = new PaymentType
{
AcctNumber = 11111,
Name = "Diner's Club",
CustomerId = 1
};
var paymentAsJSON = JsonConvert.SerializeObject(payment);
var response = await client.PostAsync(
"/api/paymentType",
new StringContent(paymentAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
var newPayment = JsonConvert.DeserializeObject <PaymentType>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal(11111, newPayment.AcctNumber);
Assert.Equal("Diner's Club", newPayment.Name);
Assert.Equal(1, newPayment.CustomerId);
var deleteResponse = await client.DeleteAsync($"/api/paymentType/{newPayment.Id}");
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Create_And_Delete_ProductTypes()
{
using (var client = new APIClientProvider().Client)
{
ProductType productName = new ProductType
{
Name = "product1"
};
var productNameAsJSON = JsonConvert.SerializeObject(productName);
var response = await client.PostAsync("/api/ProductTypes",
new StringContent(productNameAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
var newProductName = JsonConvert.DeserializeObject <ProductType>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("product1", newProductName.Name);
var deleteResponse = await client.DeleteAsync($"/api/ProductTypes/{newProductName.Id}");
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Create_and_Delete_TrainingProgram()
{
using (var client = new APIClientProvider().Client)
{
TrainingProgram test = new TrainingProgram()
{
Name = "test",
StartDate = new DateTime(2000, 7, 7),
EndDate = new DateTime(2000, 7, 7),
MaxAttendees = 5
};
var testAsJson = JsonConvert.SerializeObject(test);
var response = await client.PostAsync("api/trainingprogram", new StringContent(testAsJson, Encoding.UTF8, "application/json"));
string responseBody = await response.Content.ReadAsStringAsync();
var newTest = JsonConvert.DeserializeObject <TrainingProgram>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("test", newTest.Name);
Assert.Equal(new DateTime(2000, 7, 7), newTest.StartDate);
Assert.Equal(new DateTime(2000, 7, 7), newTest.EndDate);
Assert.Equal(5, newTest.MaxAttendees);
var deleteResponse = await client.DeleteAsync($"api/trainingprogram/{newTest.Id}");
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Create_And_Delete_Customer()
{
using (var client = new APIClientProvider().Client)
{
Customer john = new Customer
{
FirstName = "John",
LastName = "Chalmers"
};
var johnAsJSON = JsonConvert.SerializeObject(john);
var response = await client.PostAsync(
"/api/customer",
new StringContent(johnAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
var newJohn = JsonConvert.DeserializeObject <Customer>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("John", newJohn.FirstName);
Assert.Equal("Chalmers", newJohn.LastName);
var deleteResponse = await client.DeleteAsync($"/api/customer/{newJohn.Id}");
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task Test_Create_And_Delete_Product_Type()
{
using (var client = new APIClientProvider().Client)
{
ProductType raft = new ProductType
{
Name = "raft"
};
var raftAsJson = JsonConvert.SerializeObject(raft);
var response = await client.PostAsync(
"/api/producttype",
new StringContent(raftAsJson, Encoding.UTF8, "application/json")
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
var newRaft = JsonConvert.DeserializeObject <ProductType>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("raft", newRaft.Name);
var deleteResponse = await client.DeleteAsync($"/api/producttype/{newRaft.Id}");
deleteResponse.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
public async Task TestDeleteTrainingProgram()
{
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);
int removeLastObject = trainingProgramList.Count - 1;
var trainingProgramObject = trainingProgramList[removeLastObject];
var response = await client.DeleteAsync($"api/trainingprograms/{ trainingProgramObject.Id}");
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(HttpStatusCode.NoContent, getTrainingProgram.StatusCode);
}
}
public async Task Test_Create_and_Delete_Computer()
{
using (var client = new APIClientProvider().Client)
{
Computer computer = new Computer
{
Make = "MBP",
Manufacturer = "Apple",
PurchaseDate = new DateTime(2009, 2, 15),
DecomissionDate = new DateTime(2014, 6, 14)
};
var computerAsJSON = JsonConvert.SerializeObject(computer);
var response = await client.PostAsync(
"/api/computer",
new StringContent(computerAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
var newComputer = JsonConvert.DeserializeObject <Computer>(responseBody);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("MBP", newComputer.Make);
Assert.Equal("Apple", newComputer.Manufacturer);
var deleteResponse = await client.DeleteAsync($"/api/computer/{newComputer.Id}");
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
//=========================
// Test Delete Customer
//=========================
public async Task Test_Delete_Customer()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
/*
* ACT
*/
var response = await client.DeleteAsync("/api/customers/1");
string responseBody = await response.Content.ReadAsStringAsync();
var customer = JsonConvert.DeserializeObject <Customer>(responseBody);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
Assert.Equal("Jack", customer.FirstName);
}
}
public async Task Test_Remove_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);
int removeLastObject = orderList.Count - 1;
var orderObject = orderList[removeLastObject];
var response = await client.DeleteAsync($"api/orders/{orderObject.Id}");
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(HttpStatusCode.NoContent, getOrder.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_Delete_Order()
{
using (var client = new APIClientProvider().Client)
{
/*
* ARRANGE
*/
Order orderToDelete = new Order
{
CustomerId = 1,
PaymentTypeId = 1,
Status = "alive... for now"
};
// Serialize the C# object into a JSON string
var orderAsJSON = JsonConvert.SerializeObject(orderToDelete);
/*
* ACT
*/
//Insert object
var response = await client.PostAsync(
"/api/orders",
new StringContent(orderAsJSON, Encoding.UTF8, "application/json")
);
string responseBody = await response.Content.ReadAsStringAsync();
var newOrder = JsonConvert.DeserializeObject <Order>(responseBody);
//Get object
var getOrderToDelete = await client.GetAsync($"/api/orders/{newOrder.Id}");
getOrderToDelete.EnsureSuccessStatusCode();
string getOrderToDeleteBody = await getOrderToDelete.Content.ReadAsStringAsync();
Order newOrderFromResponse = JsonConvert.DeserializeObject <Order>(getOrderToDeleteBody);
//Delete Object
var deleteOrder = await client.DeleteAsync($"/api/orders/{newOrder.Id}");
deleteOrder.EnsureSuccessStatusCode();
//Try to Get Object Again
var attemptGetOrder = await client.GetAsync($"/api/orders/{newOrder.Id}");
attemptGetOrder.EnsureSuccessStatusCode();
string attemptGetOrderBody = await getOrderToDelete.Content.ReadAsStringAsync();
Order newAttemptToGetOrder = JsonConvert.DeserializeObject <Order>(attemptGetOrderBody);
/*
* ASSERT
*/
Assert.Equal(HttpStatusCode.NoContent, attemptGetOrder.StatusCode);
}
}
private async Task <HttpResponseMessage> DeleteComputer(int id)
{
using (var client = new APIClientProvider().Client)
{
return(await client.DeleteAsync(
$"/api/computers/{id}"));
}
}
public async Task Test_Delete_TrainingProgram()
{
using (var client = new APIClientProvider().Client)
{
var response = await client.DeleteAsync("/api/trainingprogram/1");
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
}
public async Task Test_Delete_Computer()
{
using (var client = new APIClientProvider().Client)
{
var response = await client.DeleteAsync("/api/computer/4");
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
}
public async Task Test_Delete_PaymentType_On_Order()
{
using (var client = new APIClientProvider().Client)
{
var response = await client.DeleteAsync("/api/paymentTypes/1");
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
}
}
public async Task Test_Delete_NonExistent_Department_Fails()
{
using (var client = new APIClientProvider().Client)
{
var deleteResponse = await client.DeleteAsync("api/Department/600000");
Assert.False(deleteResponse.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.NotFound, deleteResponse.StatusCode);
}
}