public async Task Delete_ReturnsBadRequest_WhenUserDoesNotOwnIt()
{
//Arrange
await AuthenticateAsync();
await LoginAsync();
await TestClient.PostAsJsonAsync(
ApiRoutes.Announcements.Create, new CreateAnnouncementDto
{
Name = "Test",
Description = "Test",
Type = "Club",
Image = null
});
//Act
var response = await TestClient.DeleteAsync(
ApiRoutes.Announcements.Delete.Replace(
"{announcementId}", "99999"));
string content = await response.Content.ReadAsStringAsync();
dynamic errorResponse = JsonConvert.DeserializeObject <dynamic>(content);
string error = errorResponse.error;
//Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
error.Should().NotBeNullOrEmpty();
error.Should().BeEquivalentTo("You do not own this announcement");
}
public async Task Delete_ReturnsNoContent_WhenDeleted()
{
//Arrange
await AuthenticateAsync();
await LoginAsync();
var postResponse = await TestClient.PostAsJsonAsync(
ApiRoutes.Announcements.Create, new CreateAnnouncementDto
{
Name = "Test",
Description = "Test",
Type = "Club",
Image = null
});
var announcementResponse = await postResponse.Content.ReadAsAsync <AnnouncementResponse>();
//Act
var response = await TestClient.DeleteAsync(
ApiRoutes.Announcements.Delete.Replace(
"{announcementId}", announcementResponse.Id.ToString()));
var content = await response.Content.ReadAsStringAsync();
//Assert
response.StatusCode.Should().Be(HttpStatusCode.NoContent);
content.Should().BeNullOrEmpty();
}
public async Task TestDeletePredicateEndpoint_ShouldReturnNoContent(string endpoint, string graph,
string resourceCurie, string predicateCurie)
{
//Predicate exists
var responseOnGetNotYesDeletedPredicate = await TestClient.GetAsync(ApiRoutes
.NamedGraphResourceStartConcreteResourcePredicate
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie)
.Replace("{predicate:regex(.+:.+)}", predicateCurie));
Assert.Equal(HttpStatusCode.OK, responseOnGetNotYesDeletedPredicate.StatusCode);
//Delete predicate
var response =
await TestClient.DeleteAsync(ApiRoutes.NamedGraphResourceStartConcreteResourcePredicate
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie)
.Replace("{predicate:regex(.+:.+)}", predicateCurie));
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
//Get resource which used to have the predicate => check if it does not anymore
var resourceVm = await TestClient.GetAsync(ApiRoutes.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie)).Result.Content
.ReadAsAsync <ResourceVm>();
Assert.True(!resourceVm.Predicates.ContainsKey(predicateCurie));
}
public async Task LeaveEvent_WhenUserIsRegisteredAndItIsNotOrganizer_ShouldMarkActivityAsLeft()
{
// Arrange
string eventId = await CreateRandomNewEvent();
await AuthenticateAsync();
var userId = await GetUserId();
await TestClient.PostAsync($"UserActivity/{eventId}", null);
// Act
await TestClient.DeleteAsync($"UserActivity/{eventId}");
// Assert
var response = await TestClient.GetAsync($"UserActivity/{userId}");
var responseString = await response.Content.ReadAsStringAsync();
var activities = JsonConvert.DeserializeObject <IEnumerable <UserEventActivityDto> >(responseString);
var activity = activities.SingleOrDefault(x => x.EventId == Guid.Parse(eventId));
activity.Status
.Should()
.NotBeEmpty()
.And
.BeEquivalentTo("Left");
}
public async Task Delete_OneNote_ReturnDeletedNote()
{
// Arrange
await AuthenticateAsync();
var createdNote = await CreateNoteAsync(
new CreateNoteCommand
{
Date = _dateTimeRequestFake,
Content = _contentFake,
ProjectId = _fakeFirstProjectId.ToString()
});
//Act
var response = await TestClient.DeleteAsync(ApiRoutes.Notes.Delete.Replace("{noteId}", createdNote.Id.ToString()));
//Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("application/json; charset=utf-8", response.Content.Headers.ContentType.ToString());
var responseNote = await response.Content.ReadAsAsync <NoteResource>();
Assert.Equal(createdNote.Id, responseNote.Id);
Assert.Equal(_dateTimeRequestFake, responseNote.Date);
Assert.Equal(_contentFake, responseNote.Content);
Assert.Equal(_fakeFirstProjectId, responseNote.ProjectId);
}
public async Task GetAll_WithOnePosts_ReturnOkWithResponse()
{
//Arrange
var newClient = await CreateClientAsync(CreateTestClientEntityModel());
var request = CreateOrderForTests(newClient.Id);
var newOrder = await CreateOrderAsync(request);
//Act
var response = await TestClient.GetAsync(ApiRoutes.Orders.GetAll);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
List <Order> orders;
using (var sr = new StringReader(await response.Content.ReadAsStringAsync()))
{
var ordersOnServer = JsonConvert.DeserializeObject <List <Order> >(sr.ReadToEnd());
orders = ordersOnServer;
}
Assert.True(orders.Any(), $"{orders.Count}");
var catOrder = await TestClient.DeleteAsync(ApiRoutes.Orders.Delete + newOrder.OrderId);
var catClient = await TestClient.DeleteAsync(ApiRoutes.Clients.Delete + newClient.Id);
catClient.StatusCode.Should().Be(HttpStatusCode.Accepted, "CLEAN CLIENT AFTER TEST");
catOrder.StatusCode.Should().Be(HttpStatusCode.Accepted, "CLEAN ORDER AFTER TEST");
}
public async Task TestDelete()
{
Utilisateur utilisateur = new Utilisateur {
Nom = "Luzolo",
Postnom = "Nsambu",
Prenom = "Nadine",
Sexe = Sexe.Feminin,
Photosrc = "",
Email = "*****@*****.**",
Username = "******",
Password = "******",
NiveauAcces = NiveauAcces.Utilisateur
};
HttpResponseMessage response = await TestClient.PostAsJsonAsync(route + "create", utilisateur);
response.StatusCode.Should().Be(HttpStatusCode.OK);
Utilisateur utilisateur1 = await response.Content.ReadAsAsync <Utilisateur>();
HttpResponseMessage response1 = await TestClient.DeleteAsync(route + "delete?id=" + utilisateur1.Id);
response1.StatusCode.Should().Be(HttpStatusCode.OK);
HttpResponseMessage response2 = await TestClient.GetAsync(route + "getbyid?id=" + utilisateur1.Id);
response2.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public async Task TestConfigurationInfoEndpoint_ShouldReturnOk(string endpoint)
{
var response =
await TestClient.DeleteAsync(ApiRoutes.EndpointConfiguration.Replace("{endpoint}", endpoint));
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
public async Task Delete_ReturnsForbidden_WhenUserLoggedIn()
{
//Arrange
await AuthenticateAsync();
await LoginAsync();
var announcementResponse = await TestClient.PostAsJsonAsync(
ApiRoutes.Announcements.Create, new CreateAnnouncementDto
{
Name = "Announcement To Report",
Type = "Other",
Description = "Report",
Image = null
});
var announcementContent = await announcementResponse.Content.ReadAsAsync <AnnouncementResponse>();
var createResponse = await TestClient.PostAsJsonAsync(
ApiRoutes.Reports.Create.Replace("{announcementId}",
announcementContent.Id.ToString()), new CreateReportDto
{
ReportCause = "Test",
ReportDescription = "Test",
});
var createReportContent = createResponse.Content.ReadAsAsync <ReportResponse>();
//Act
var response = await TestClient.DeleteAsync(
ApiRoutes.Reports.Delete.Replace(
"{reportId}", createReportContent.Id.ToString()));
//Assert
response.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public async Task Put_WithGoodRequest_ReturnOK()
{
var changedData = "Changed Last Name";
//Arrange
var request = CreateTestClientEntityModel();
var newClient = await CreateClientAsync(request);
//Act
var newRequest = request;
newRequest.Id = newClient.Id;
newRequest.LastName = changedData;
var serializerSettings = new JsonSerializerSettings();
serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var myContent = JsonConvert.SerializeObject(newRequest, serializerSettings);
var stringContent = new StringContent(myContent, Encoding.UTF8, "application/json");
var response = await TestClient.PutAsync(ApiRoutes.Clients.Put + newClient.Id, stringContent);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.Accepted, "post was successful");
Client clientOnServer;
using (var sr = new StringReader(await response.Content.ReadAsStringAsync()))
{
clientOnServer = JsonConvert.DeserializeObject <Client>(sr.ReadToEnd());
}
clientOnServer.LastName.Should().Be(changedData, "post should changed data");
//After
var cat = await TestClient.DeleteAsync(ApiRoutes.Clients.Delete + newClient.Id);
cat.StatusCode.Should().Be(HttpStatusCode.Accepted);
}
public async Task GetAll_WithOnePosts_ReturnNonEmptyResponse()
{
//Arrange
var request = new ClientEntityModel()
{
Address = "Street",
City = "City",
FirstName = "Test",
Id = 0,
LastName = "Test",
ZipCode = "53-300"
};
var addedClient = await CreateClientAsync(request);
//Act
var response = await TestClient.GetAsync(ApiRoutes.Clients.GetAll);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
List <Client> clients;
//List<Client> clientsOnServer = Serializer.Deserialize<Client>(await response.Content.ReadAsStreamAsync())
using (var sr = new StringReader(await response.Content.ReadAsStringAsync()))
{
var clientsOnServer = JsonConvert.DeserializeObject <List <Client> >(sr.ReadToEnd());
clients = clientsOnServer;
}
Assert.True(clients.Exists(c => c.LastName == "Test"));
var deleteAfterTest = await TestClient.DeleteAsync(ApiRoutes.Clients.Delete + addedClient.Id);
deleteAfterTest.StatusCode.Should().Be(HttpStatusCode.Accepted, "There is Client on DB");
}
public async Task RemoveCoOrganizer_WhenUserIsCoOrganizer_ShouldChangeEventRole()
{
// Arrange
await AuthenticateAsync();
var userId = await GetUserId();
await AuthenticateAsync();
var eventId = await CreateEvent();
var payload = new AddCoOrganizerDto
{
UserId = userId
};
var payloadString = JsonConvert.SerializeObject(payload);
var content = new StringContent(payloadString, Encoding.UTF8, "application/json");
await TestClient.PostAsync($"EventParticipantsOrganizer/{eventId}/coorganizers", content);
// Act
await TestClient.DeleteAsync($"EventParticipantsOrganizer/{eventId}/coorganizers/{userId}");
// Assert
var response = await TestClient.GetAsync($"UserActivity/{userId}");
var responseBody = await response.Content.ReadAsStringAsync();
var userActivities = JsonConvert.DeserializeObject <IEnumerable <UserEventActivityDto> >(responseBody);
var activity = userActivities.SingleOrDefault(x => x.EventId.ToString() == eventId);
activity.Should().NotBeNull();
activity?.Role
.Should()
.BeEquivalentTo("StandardParticipant");
}
public async Task RemoveCoOrganizer_WhenUserIsCoOrganizer_ShouldAddUserToStandardParticipants()
{
// Arrange
await AuthenticateAsync();
var userId = await GetUserId();
await AuthenticateAsync();
var eventId = await CreateEvent();
var payload = new AddCoOrganizerDto
{
UserId = userId
};
var payloadString = JsonConvert.SerializeObject(payload);
var content = new StringContent(payloadString, Encoding.UTF8, "application/json");
await TestClient.PostAsync($"EventParticipantsOrganizer/{eventId}/coorganizers", content);
// Act
await TestClient.DeleteAsync($"EventParticipantsOrganizer/{eventId}/coorganizers/{userId}");
// Assert
var response = await TestClient.GetAsync($"Event/{eventId}");
var responseBody = await response.Content.ReadAsStringAsync();
var @event = JsonConvert.DeserializeObject <EventDto>(responseBody);
@event.Participants
.StandardParticipants
.SingleOrDefault(x => x.ToString() == eventId)
.Should()
.NotBe(userId);
}
public async Task RemoveCoOrganizer_WhenUserIsNotCoOrganizer_ShouldReturnBadRequest()
{
// Arrange
var registerDto = new RegisterUserDto
{
Email = "*****@*****.**",
Password = "******"
};
var loginDto = new LoginUserDto
{
Email = registerDto.Email,
Password = registerDto.Password
};
await AuthenticateAsync(registerDto);
var eventId = await CreateEvent();
await AuthenticateAsync();
var userId = await GetUserId();
await TestClient.PostAsync($"UserActivity/{eventId}", null);
await AuthenticateAsync(loginDto);
// Act
var response = await TestClient
.DeleteAsync($"EventParticipantsOrganizer/{eventId}/coorganizers/{userId}");
// Assert
response.StatusCode
.Should()
.BeEquivalentTo(HttpStatusCode.BadRequest);
}
public async Task RemoveCoOrganizer_WhenEventIdIsNotOrganizer_ShouldReturnBadRequest()
{
// Arrange
await AuthenticateAsync();
var coOrganizerId = await GetUserId();
await AuthenticateAsync();
var eventId = await CreateEvent();
var addCoOrganizerDto = new AddCoOrganizerDto
{
UserId = coOrganizerId
};
var payload = JsonConvert.SerializeObject(addCoOrganizerDto);
var content = new StringContent(payload, Encoding.UTF8, "application/json");
await TestClient.PostAsync($"EventParticipantsOrganizer/{eventId}/coorganizers", content);
await AuthenticateAsync();
// Act
var response = await TestClient
.DeleteAsync($"EventParticipantsOrganizer/{eventId}/coorganizers/{coOrganizerId}");
// Assert
response.StatusCode
.Should()
.BeEquivalentTo(HttpStatusCode.BadRequest);
}
public async Task TestGetById()
{
Utilisateur utilisateur = new Utilisateur {
Nom = "Luzolo",
Postnom = "Matanu",
Prenom = "Hervé",
Sexe = Sexe.Masculin,
Photosrc = "",
Email = "*****@*****.**",
Username = "******",
Password = "******",
NiveauAcces = NiveauAcces.Utilisateur
};
HttpResponseMessage response = await TestClient.PostAsJsonAsync(route + "create", utilisateur);
response.StatusCode.Should().Be(HttpStatusCode.OK);
Utilisateur utilisateur1 = await response.Content.ReadAsAsync <Utilisateur>();
HttpResponseMessage response1 = await TestClient.GetAsync(route + "getbyid?id=" + utilisateur1.Id);
response1.StatusCode.Should().Be(HttpStatusCode.OK);
Utilisateur u = await response1.Content.ReadAsAsync <Utilisateur>();
u.Equals(utilisateur1).Should().BeTrue();
HttpResponseMessage response2 = await TestClient.DeleteAsync(route + "delete?id=" + utilisateur1.Id);
response2.StatusCode.Should().Be(HttpStatusCode.OK);
HttpResponseMessage response3 = await TestClient.GetAsync(route + "getbyid?id=" + utilisateur1.Id);
response3.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public async Task Put_WithBadRequest_ReturnCreated()
{
//Arrange
var newClient = await CreateClientAsync(CreateTestClientEntityModel());
var newOrder = await CreateOrderAsync(CreateOrderForTests(newClient.Id));
//Act
newOrder.IsPayed = true;
newOrder.IsDone = true;
var stringContent = new StringContent("{\"isDone\" : true}", Encoding.UTF8, "application/json");
var response = await TestClient.PutAsync(ApiRoutes.Orders.Put + newOrder.OrderId, stringContent);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var editedOrder = JsonConvert.DeserializeObject <OrderEntityModel>(await response.Content.ReadAsStringAsync());
editedOrder.IsDone.Should().Be(false);
//After
var cat = await TestClient.DeleteAsync(ApiRoutes.Orders.Delete + newOrder.OrderId);
var catClient = await TestClient.DeleteAsync(ApiRoutes.Clients.Delete + newOrder.ClientId);
cat.StatusCode.Should().Be(HttpStatusCode.Accepted);
catClient.StatusCode.Should().Be(HttpStatusCode.Accepted);
}
public async Task TestDeleteResourceEndpoint_ShouldReturnNoContent(string endpoint, string graph,
string resourceCurie)
{
//Resource exists
var responseOnGetNotYesDeletedResource = await TestClient.GetAsync(ApiRoutes
.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie));
Assert.Equal(HttpStatusCode.OK, responseOnGetNotYesDeletedResource.StatusCode);
//Resource deleted
var response =
await TestClient.DeleteAsync(ApiRoutes.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie));
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
//Resource not found
var responseOnGetDeletedResource = await TestClient.GetAsync(ApiRoutes.NamedGraphResourcesConcreteResource
.Replace("{endpoint}", endpoint)
.Replace("{graph}", graph).Replace("{resource:regex(.+:.+)}", resourceCurie));
Assert.Equal(HttpStatusCode.NotFound, responseOnGetDeletedResource.StatusCode);
}
public async Task Delete_Tag()
{
await TestClient.PostAsJsonAsync(ApiRoutes.Tags.Create, new { tagName = "string1" });
var response = await TestClient.DeleteAsync(ApiRoutes.Tags.Delete.Replace("{tagName}", "string1"));
response.StatusCode.Should().Be(HttpStatusCode.NoContent);
}
public async Task DeleteItem_NotFound()
{
// Arrange
// Act
var response = await TestClient.DeleteAsync(Url + 1001);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public async Task ReturnNotFoundError()
{
// Act
var response = await TestClient.DeleteAsync(
new UrlFactory(ApiRoutes.Products.Delete).Create(Guid.NewGuid()));
// Assert
response.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public async void Game_on_Delete_not_found()
{
string id = "041538d2-0f6b-4d42-9902-02b179899539";
await AuthenticateAsync();
var response = await TestClient.DeleteAsync("Api/game/id?id=" + id);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task DeleteItem()
{
// Arrange
await TestClient.PostAsync(Url, Content);
// Act
var response = await TestClient.DeleteAsync(Url + 6);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.NoContent);
}
public async void Game_on_Delete_success()
{
string id = "5d224ebf-ed51-41df-90b7-ec8c3c0bb6cd";
await AuthenticateAsync();
var response = await TestClient.DeleteAsync("Api/game/id?id=" + id);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public async Task Delete_WithoutToken_Returns401()
{
//Arrange
//Act
var response = await TestClient.DeleteAsync("/api/player/1");
//Assert
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}
public async Task RemoveParticipant_WhenUserWasRegistered_ShouldRemoveActivity()
{
// Arrange
var registerOrganizerDto = new RegisterUserDto
{
Email = "*****@*****.**",
Password = "******"
};
await AuthenticateAsync(registerOrganizerDto);
string eventId = await CreateEvent();
var registerParticipantDto = new RegisterUserDto
{
Email = "*****@*****.**",
Password = "******"
};
await AuthenticateAsync(registerParticipantDto);
await TestClient.PostAsync($"UserActivity/{eventId}", null);
Guid userId = await GetUserId();
var loginOrganizerDto = new LoginUserDto
{
Email = registerOrganizerDto.Email,
Password = registerOrganizerDto.Password
};
await AuthenticateAsync(loginOrganizerDto);
// Act
var response = await TestClient.DeleteAsync($"EventParticipantsOrganizer/{eventId}/participants/{userId}");
// Assert
var loginParticipantDto = new LoginUserDto
{
Email = registerParticipantDto.Email,
Password = registerParticipantDto.Password
};
await AuthenticateAsync(loginParticipantDto);
response = await TestClient.GetAsync($"UserActivity/{userId}");
var responseBody = await response.Content.ReadAsStringAsync();
var activities = JsonConvert.DeserializeObject <IEnumerable <UserEventActivityDto> >(responseBody);
var activity = activities.SingleOrDefault(x => x.EventId.ToString() == eventId);
activity.Should()
.BeNull();
}
public async Task Delete_ReturnsNoContent_WhenDealerIsDeletedFromDatabase()
{
// Arrange
var createdDealer = await CreateDealerAsync(Instantiate_NewDealerDto_Object());
// Act
var response = await TestClient.DeleteAsync(ApiRoutes.Dealers.Delete.Replace("{dealerId}", createdDealer.Id.ToString()));
// Assert
response.StatusCode.Should().Be(HttpStatusCode.NoContent);
}
public async Task DeletePoints_NoToken_Returns401()
{
//Arrange
await InsertDummyData();
//Act
var response = await TestClient.DeleteAsync("api/points/1");
//Assert
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}
public async Task Delete_WithEmptyRequest_ReturnNotFound()
{
//Arrange
var id = 1;
//Act
var response = await TestClient.DeleteAsync($"{ApiRoutes.Orders.Delete}{id}");
//Assert
response.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public void Delete_DeletesRecord_Returns200()
{
// Arrange
string _requestUri = "http://localhost/api/boards/1001";
// Act
HttpResponseMessage response = TestClient.DeleteAsync(_requestUri).Result;
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
