public void Can_DELETE_Reqstar_PrettyRestApi(IRestClient client)
{
client.Delete(new DeleteReqstar {
Id = 1
});
var reqstarsLeft = db.Select <Reqstar>();
Assert.That(reqstarsLeft.Count,
Is.EqualTo(ReqstarsService.SeedData.Length - 1));
}
public void Can_DELETE_Reqstar_PrettyRestApi(IRestClient client)
{
client.Delete(new DeleteReqstar {
Id = 1
});
var reqstarsLeft = GetAllReqstars(client);
Assert.That(reqstarsLeft.Count,
Is.EqualTo(SeedData.Reqstars.Length - 1));
}
public IActionResult DeleteGame(int gameId)
{
var request = new RestRequest($"api/ludo/{gameId}", Method.DELETE);
_client.Delete(request);
Log.Information("Game: {gameId} was deleted", gameId);
var listOfCreatedGames = GetGames();
return(View("~/Views/Ludo/JoinGame.cshtml", listOfCreatedGames));
}
public void Contextual_Request_and_Response_Filters_are_executed_using_RestClient(IRestClient client)
{
var response = client.Delete <AttributeFilteredResponse>("attributefiltered");
Assert.IsTrue(response.RequestFilterExecuted);
Assert.IsTrue(response.ResponseFilterExecuted);
Assert.IsTrue(response.ContextualRequestFilterExecuted);
Assert.IsTrue(response.ContextualResponseFilterExecuted);
Assert.IsTrue(response.RequestFilterDependenyIsResolved);
Assert.IsTrue(response.ResponseFilterDependencyIsResolved);
}
public void Delete(int categoryId)
{
var request = new RestRequest(Url + categoryId)
{
Method = Method.DELETE, RequestFormat = DataFormat.Json
};
var response = _client.Delete(request);
var responseData = JsonConvert.DeserializeObject <Category>(response.Content);
UpdateCategoryData();
ResponseDataDescription(response, responseData);
}
public void Delete(long id, long?parentId)
{
if (id <= 0)
{
throw new ArgumentException("Item must exist in Zendesk");
}
var resourceUri = parentId == null ? ResourceUri : string.Format(ResourceUri, parentId);
var requestUri = Client.BuildUri(string.Format("{0}/{1}", resourceUri, id));
Client.Delete(requestUri);
}
public async Task DeleteAsync(int id)
{
string path = $"{DEFAULT_PATH}/{id}";
client.Endpoint = Endpoint;
var district = await client.Delete(path);
if (district.IsFaulted)
{
throw new ApiException(district.DataLayerArgumentException ?? district.DataLayerException);
}
}
public static void Logout()
{
IRestRequest request = new RestRequest()
{
Resource = LogoutEndPoint
};
request.AddCookie(LoginResponse.Data.session.name, LoginResponse.Data.session.value);
var response = client.Delete(request);
Assert.AreEqual(204, (int)response.StatusCode);
}
// Deleting
public void DeleteCallFlow(string id)
{
ParameterValidator.IsNotNullOrWhiteSpace(id, "id");
var callFlows = new CallFlows(new CallFlow {
Id = id
});
restClient.Delete(callFlows);
}
public bool DeleteAuction(int auctionId)
{
// place code here
RestRequest request = new RestRequest(API_URL + $"/{auctionId}");
IRestResponse response = client.Delete(request);
if (!response.IsSuccessful)
{
throw new Exception("ExpectFailure");
}
return(true);
}
public async Task RemoveProduct(Guid cartId, Guid productId)
{
var request = new RemoveProductRequest(cartId, productId);
var response = await restClient.Delete <RemoveProductRequest, RemoveProductResponse>(routing.URL,
routing.RemoveProduct, request, HeaderAccept.Json);
if (!response.IsSuccess)
{
//do something
}
}
public void Handles_Thrown_Http_Error_With_Forbidden_status_code(IRestClient client)
{
try
{
client.Delete <UserResponse>("/users");
Assert.Fail();
}
catch (WebServiceException ex)
{
Assert.That(ex.ErrorCode, Is.EqualTo("CanNotExecute"));
Assert.That(ex.StatusCode, Is.EqualTo((int)System.Net.HttpStatusCode.Forbidden));
Assert.That(ex.Message, Is.EqualTo("CanNotExecute"));
}
}
public void Handles_Thrown_Http_Error_With_Forbidden_status_code_using_IReturnVoid(IRestClient client)
{
try
{
client.Delete(new UserReturnVoid());
Assert.Fail();
}
catch (WebServiceException ex)
{
Assert.That(ex.StatusCode, Is.EqualTo((int)System.Net.HttpStatusCode.Forbidden));
Assert.That(ex.ErrorCode, Is.EqualTo("CanNotExecute"));
Assert.That(ex.Message, Is.EqualTo("Failed to execute!"));
}
}
public void DeleteAuction(int auctionId)
{
RestRequest request = new RestRequest(AUCTIONS_URL + "/" + auctionId);
IRestResponse response = client.Delete(request);
if (response.ResponseStatus != ResponseStatus.Completed || !response.IsSuccessful)
{
Console.WriteLine(ProcessErrorResponse(response));
}
else
{
Console.WriteLine("Auction successfully deleted.");
}
}
/// <summary>
/// Remove previously uploaded payload
/// </summary>
/// <returns>True if successfully removed from server</returns>
public bool RemovePayload()
{
if (payloadID.HasValue)
{
var request = new RestRequest($"payload/{payloadID.Value}");
var response = client.Delete(request);
if (response.IsSuccessful)
{
payloadID = null;
}
return(response.IsSuccessful);
}
return(true);
}
public void Crud_NewUser_Success()
{
// Create.
User original = DataFactory.RandomUser;
Response <User> created = _client.Post <User, User>(content: original);
Assert.Equal(HttpStatusCode.Created, created.StatusCode);
Assert.NotNull(created.Data);
Assert.NotNull(created.Data.Id);
Assert.Equal(original.Email, created.Data.Email);
Assert.Equal(original.FirstName, created.Data.FirstName);
Assert.Equal(original.LastName, created.Data.LastName);
_output.WriteLine($"Created new user:\n{created.Data.ToJson()}");
// Retrieve single.
Response <User> retrieved = _client.Get <User>(created.Data.Id);
Assert.Equal(HttpStatusCode.OK, retrieved.StatusCode);
Assert.NotNull(retrieved.Data);
Assert.Equal(created.Data.Id, retrieved.Data.Id);
_output.WriteLine($"Retrieved newly created user:\n{retrieved.ToJson()}");
// Update.
const string newMiddleName = "Perry";
User retrievedUser = retrieved.Data;
retrievedUser.MiddleNames = newMiddleName;
Response updatedResponse = _client.Put(retrievedUser.Id, retrievedUser);
Assert.Equal(HttpStatusCode.OK, updatedResponse.StatusCode);
Response <User> updated = _client.Get <User>(retrievedUser.Id);
Assert.Equal(HttpStatusCode.OK, updated.StatusCode);
Assert.NotNull(updated.Data);
Assert.Equal(retrievedUser.Id, updated.Data.Id);
Assert.Equal(newMiddleName, updated.Data.MiddleNames);
_output.WriteLine($"Updated the MiddleNames property of the newly created user:\n{updated.ToJson()}");
// Delete.
Response deleteResponse = _client.Delete(created.Data.Id);
Assert.Equal(HttpStatusCode.OK, deleteResponse.StatusCode);
Response headResponse = _client.Head(created.Data.Id);
Assert.Equal(HttpStatusCode.NotFound, headResponse.StatusCode);
_output.WriteLine($"Successfully deleted user {created.Data.Id}.");
}
public bool DeleteAuction(int auctionId)
{
RestRequest request = new RestRequest(AUCTIONS_URL + "/" + auctionId);
IRestResponse response = client.Delete(request);
if (response.ResponseStatus != ResponseStatus.Completed || !response.IsSuccessful)
{
ProcessErrorResponse(response);
}
else
{
return(true);
}
return(false);
}
public void Handles_Thrown_Http_Error_With_Forbidden_status_code(IRestClient client)
{
try
{
client.Delete <UserResponse>("/users");
Assert.Fail();
}
catch (WebServiceException ex)
{
//IIS Express/WebDev server doesn't pass-thru custom HTTP StatusDescriptions
//Assert.That(ex.ErrorCode, Is.EqualTo("CanNotExecute"));
Assert.That(ex.StatusCode, Is.EqualTo((int)System.Net.HttpStatusCode.Forbidden));
//Assert.That(ex.Message, Is.EqualTo("CanNotExecute"));
}
}
public Response doDelete(String path, Hashtable parameters)
{
try {
Response resp = restClient.Delete <Response> (completePath(path, parameters));
resp.inError = false;
return(resp);
} catch (Exception e) {
Response resp = new Response();
resp.inError = true;
resp.error = e.ToString();
resp.exception = e;
log.log("doDelete: error in response: " + e.ToString());
return(resp);
}
}
public T Delete <T>(IRestRequest request) where T : class, new()
{
var result = _restClient.Delete <T>(request);
if (!string.IsNullOrEmpty(result.ErrorMessage))
{
throw new Exception(result.ErrorMessage, result.ErrorException);
}
if (result.ResponseStatus == ResponseStatus.Error)
{
throw new Exception(result.Content);
}
return(result.Data);
}
public void DeletePatientMedSupp_Test()
{
DeletePatientMedSuppDataRequest request = new DeletePatientMedSuppDataRequest
{
Context = context,
ContractNumber = contractNumber,
Id = "54ef4bac84ac0711a867ccde",
UserId = userId,
Version = version
};
//[Route("/{Context}/{Version}/{ContractNumber}/PatientMedSupp/{Id}", "DELETE")]
DeletePatientMedSuppDataResponse response = client.Delete <DeletePatientMedSuppDataResponse>(
string.Format("{0}/{1}/{2}/{3}/PatientMedSupp/{4}?UserId={5}", url, context, version, contractNumber, request.Id, request.UserId));
Assert.IsNotNull(response);
}
public void DeletePatientMedSupp_Test()
{
DeletePatientAllergyRequest request = new DeletePatientAllergyRequest
{
ContractNumber = contractNumber,
Id = "54ef51a984ac0711a867cd43",
PatientId = "5325db24d6a4850adcbba85a",
UserId = userId,
Version = version
};
//[Route("/{Version}/{ContractNumber}/Patient/{PatientId}/PatientMedSupp/{Id}", "DELETE")]
DeletePatientMedSuppResponse response = client.Delete <DeletePatientMedSuppResponse>(
string.Format("{0}/{1}/{2}/Patient/{3}/PatientMedSupp/{4}?UserId={5}", url, version, contractNumber, request.PatientId, request.Id, request.UserId));
Assert.IsNotNull(response);
}
public bool DeleteAuction(int auctionId)
{
RestRequest request = new RestRequest(API_URL + "/" + auctionId);
IRestResponse response = client.Delete(request);
if (response.ResponseStatus != ResponseStatus.Completed)
{
Console.WriteLine("Error occurred - unable to reach server.");
return(false);
}
else if (!response.IsSuccessful)
{
Console.WriteLine("Error occurred -- received non-success response: " + response.StatusCode);
return(false);
}
return(true);
}
public bool DeleteAuction(int auctionId)
{
RestRequest request = new RestRequest(API_URL + "/" + auctionId);
IRestResponse response = client.Delete(request);
if (response.ResponseStatus != ResponseStatus.Completed)
{
throw new HttpRequestException();
}
else if (!response.IsSuccessful)
{
throw new HttpRequestException();
}
else
{
return(true);
}
}
public void WhenDeleteItWithIdAndErrorMessage(string IdBoard, string ServerMessage)
{
request = new RestRequest(getBoards + IdBoard);
request.AddHeader("Accept", "application/json");
request.AddQueryParameter("key", key);
request.AddQueryParameter("token", token);
//request.AddParameter("Id", IdBoard);
response = client.Delete(request);
responseContent = response.Content;
if (responseContent.Contains(ServerMessage))
{
result = true;
}
Assert.IsTrue(result);
result = false;
}
public bool DeleteAuction(int auctionId)
{
RestRequest request = new RestRequest(API_URL + "/" + auctionId);
IRestResponse response = client.Delete(request);
if (response.ResponseStatus != ResponseStatus.Completed)
{
throw new Exception("Error occurred - unable to reach server.", response.ErrorException);
}
else if (!response.IsSuccessful)
{
throw new Exception("Error occurred - received non-success response: " + (int)response.StatusCode);
}
else
{
return(response.IsSuccessful);
}
}
private bool SendResponse(JobResponse results)
{
try
{
var request = new RestRequest($"job/{results.ID}/{workerID}");
request.AddJsonBody(results);
var response = client.Delete(request);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return(true);
}
}
catch
{
}
return(false);
}
public bool DeleteAuction(int auctionId)
{
RestRequest request = new RestRequest(API_URL + "/" + auctionId);
IRestResponse response = client.Delete(request);
if (response.ResponseStatus != ResponseStatus.Completed)
{
Console.WriteLine("Didn't connect");
}
else if (!response.IsSuccessful)
{
Console.WriteLine("The response wasn't successful." + (int)response.StatusCode);
}
else
{
return(true);
}
return(false);
}
public void VerifyDeleteProductAPI()
{
//POST Request to create a new Product
restRequest = new RestRequest(endpointUrl + "/products");
Dictionary <string, object> requestPayload = new Dictionary <string, object>();
requestPayload.Add("name", "Samsung Mobile");
requestPayload.Add("type", "Mobile");
requestPayload.Add("price", 500);
requestPayload.Add("shipping", 10);
requestPayload.Add("upc", "Samsung Mobile");
requestPayload.Add("description", "Best Samsung Mobile");
requestPayload.Add("manufacturer", "Samsung Mobile");
requestPayload.Add("model", "Samsung Mobile M21");
requestPayload.Add("url", "Samsung Mobile");
requestPayload.Add("image", "Samsung Mobile");
restRequest.AddJsonBody(requestPayload);
IRestResponse <DatumDTO> restResponse = restClient.Post <DatumDTO>(restRequest);
int productId = restResponse.Data.id;
//DELETE
IRestRequest restRequestForDelete = new RestRequest($"{endpointUrl}/products/{productId}");
IRestResponse restResponseForDelete = restClient.Delete(restRequestForDelete);
Assert.AreEqual(HttpStatusCode.OK, restResponseForDelete.StatusCode);
Assert.AreEqual(200, (int)restResponseForDelete.StatusCode);
//GET
IRestRequest restRequestForGet = new RestRequest($"{endpointUrl}/products/{productId}");
IRestResponse restResponseForGet = restClient.Get(restRequestForGet);
Assert.AreEqual(HttpStatusCode.NotFound, restResponseForGet.StatusCode);
}
public void DeletePatientSystems_Test()
{
DeletePatientSystemsRequest request = new DeletePatientSystemsRequest
{
ContractNumber = contractNumber,
UserId = userId,
Version = version,
Token = token,
PatientId = "5325da9ed6a4850adcbba6ce",
Ids = "55a038f7d43325251c8fbdb8,55a038f8d43325251c8fbdbf"
};
JsonServiceClient.HttpWebRequestFilter = x =>
x.Headers.Add(string.Format("{0}: {1}", "Token", token));
//[Route("/{Version}/{ContractNumber}/Patient/{PatientId}PatientSystems/{Ids}", "DELETE")]
DeletePatientSystemsResponse response = client.Delete <DeletePatientSystemsResponse>(string.Format("{0}/{1}/{2}/Patient/{3}/PatientSystems/{4}", url, version, contractNumber, request.PatientId, request.Ids));
Assert.IsNotNull(response);
}
