709 lines
26 KiB
C#
709 lines
26 KiB
C#
|
|
using SmallSoftwareContracts.BindingModels;
|
|
using SmallSoftwareContracts.Enums;
|
|
using SmallSoftwareContracts.ViewModels;
|
|
using SmallSoftwareDatabase.Models;
|
|
using SmallSoftwareTests.Infrastructure;
|
|
using System.Net;
|
|
|
|
namespace SmallSoftwareTests.WebApiControllersApi;
|
|
|
|
[TestFixture]
|
|
internal class SoftwareControllerTests : BaseWebApiControllerTest
|
|
{
|
|
private string _manufacturerId;
|
|
[SetUp]
|
|
public void SetUp()
|
|
{
|
|
_manufacturerId =
|
|
SmallSoftwareDbContext.InsertManufacturerToDatabaseAndReturn().Id;
|
|
}
|
|
[TearDown]
|
|
public void TearDown()
|
|
{
|
|
SmallSoftwareDbContext.RemoveSoftwaresFromDatabase();
|
|
SmallSoftwareDbContext.RemoveManufacturersFromDatabase();
|
|
}
|
|
[Test]
|
|
public async Task GetList_WhenHaveRecords_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
var software =
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 1");
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 2");
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 3");
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync("/api/softwares/getrecords?includeDeleted=false");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
var data = await
|
|
GetModelFromResponseAsync<List<SoftwareViewModel>>(response);
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(data, Is.Not.Null);
|
|
Assert.That(data, Has.Count.EqualTo(3));
|
|
});
|
|
AssertElement(data.First(x => x.Id == software.Id), software);
|
|
}
|
|
[Test]
|
|
public async Task GetList_WhenNoRecords_ShouldSuccess_Test()
|
|
{
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync("/api/softwares/getrecords?includeDeleted=false");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
var data = await
|
|
GetModelFromResponseAsync<List<SoftwareViewModel>>(response);
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(data, Is.Not.Null);
|
|
Assert.That(data, Has.Count.EqualTo(0));
|
|
});
|
|
}
|
|
[Test]
|
|
public async Task GetList_OnlyActual_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 1", isDeleted: true);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 2", isDeleted: false);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 3", isDeleted: false);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync("/api/softwares/getrecords?includeDeleted=false");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
var data = await
|
|
GetModelFromResponseAsync<List<SoftwareViewModel>>(response);
|
|
Assert.That(data, Is.Not.Null);
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(data, Has.Count.EqualTo(2));
|
|
Assert.That(data.All(x => !x.IsDeleted));
|
|
});
|
|
}
|
|
[Test]
|
|
public async Task GetList_IncludeNoActual_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 1", isDeleted: true);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 2", isDeleted: true);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 3", isDeleted: false);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync("/api/softwares/getrecords?includeDeleted=true");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
var data = await
|
|
GetModelFromResponseAsync<List<SoftwareViewModel>>(response);
|
|
Assert.That(data, Is.Not.Null);
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(data, Has.Count.EqualTo(3));
|
|
Assert.That(data.Any(x => x.IsDeleted));
|
|
Assert.That(data.Any(x => !x.IsDeleted));
|
|
});
|
|
}
|
|
[Test]
|
|
public async Task GetList_ByManufacturer_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
var manufacruer =
|
|
SmallSoftwareDbContext.InsertManufacturerToDatabaseAndReturn(manufacturerName: "name 2");
|
|
var software =
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 1", isDeleted: true);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 2", isDeleted: false);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(manufacruer.Id,
|
|
softwareName: "name 3", isDeleted: false);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/getmanufacturerrecords?id={_manufacturerId}&includeDeleted=true");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
var data = await
|
|
GetModelFromResponseAsync<List<SoftwareViewModel>>(response);
|
|
Assert.That(data, Is.Not.Null);
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(data, Has.Count.EqualTo(2));
|
|
Assert.That(data.All(x => x.ManufacturerId ==
|
|
_manufacturerId));
|
|
});
|
|
AssertElement(data.First(x => x.Id == software.Id), software);
|
|
}
|
|
[Test]
|
|
public async Task GetList_ByManufacturerOnlyActual_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
var manufacruer =
|
|
SmallSoftwareDbContext.InsertManufacturerToDatabaseAndReturn(manufacturerName: "name 2");
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 1", isDeleted: true);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: "name 2", isDeleted: false);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(manufacruer.Id,
|
|
softwareName: "name 3", isDeleted: false);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/getmanufacturerrecords?id={_manufacturerId}&includeDeleted = false");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
var data = await
|
|
GetModelFromResponseAsync<List<SoftwareViewModel>>(response);
|
|
Assert.That(data, Is.Not.Null);
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(data, Has.Count.EqualTo(1));
|
|
Assert.That(data.All(x => x.ManufacturerId == _manufacturerId
|
|
&& !x.IsDeleted));
|
|
});
|
|
}
|
|
[Test]
|
|
public async Task GetList_ManufacturerIdIsNotGuid_ShouldBadRequest_Test()
|
|
{
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/getmanufacturerrecords?id=id&includeDeleted=false");
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task
|
|
GetHistoryBySoftwareId_WhenHaveRecords_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
var software =
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId);
|
|
SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 20,
|
|
DateTime.UtcNow.AddDays(-1));
|
|
SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 30,
|
|
DateTime.UtcNow.AddMinutes(-10));
|
|
var history =
|
|
SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 40,
|
|
DateTime.UtcNow.AddDays(1));
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/gethistory?id={software.Id}");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
var data = await
|
|
GetModelFromResponseAsync<List<SoftwareHistoryViewModel>>(response);
|
|
Assert.That(data, Is.Not.Null);
|
|
Assert.That(data, Has.Count.EqualTo(3));
|
|
AssertElement(data[0], history);
|
|
}
|
|
[Test]
|
|
public async Task GetHistoryBySoftwareId_WhenNoRecords_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
var software =
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId);
|
|
SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 20,
|
|
DateTime.UtcNow.AddDays(-1));
|
|
SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 30,
|
|
DateTime.UtcNow.AddMinutes(-10));
|
|
SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 40,
|
|
DateTime.UtcNow.AddDays(1));
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/gethistory?id={Guid.NewGuid()}");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
var data = await
|
|
GetModelFromResponseAsync<List<SoftwareViewModel>>(response);
|
|
Assert.That(data, Is.Not.Null);
|
|
Assert.That(data, Has.Count.EqualTo(0));
|
|
}
|
|
[Test]
|
|
public async Task
|
|
GetHistoryBySoftwareId_SoftwareIdIsNotGuid_ShouldBadRequest_Test()
|
|
{
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/gethistory?id=id");
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task GetElement_ById_WhenHaveRecord_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
var software =
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/getrecord/{software.Id}");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
AssertElement(await
|
|
GetModelFromResponseAsync<SoftwareViewModel>(response), software);
|
|
}
|
|
[Test]
|
|
public async Task GetElement_ById_WhenNoRecord_ShouldNotFound_Test()
|
|
{
|
|
//Arrange
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/getrecord/{Guid.NewGuid()}");
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.NotFound));
|
|
}
|
|
[Test]
|
|
public async Task
|
|
GetElement_ById_WhenRecordWasDeleted_ShouldNotFound_Test()
|
|
{
|
|
//Arrange
|
|
var software =
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId, isDeleted:
|
|
true);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/getrecord/{software.Id}");
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.NotFound));
|
|
}
|
|
[Test]
|
|
public async Task GetElement_ByName_WhenHaveRecord_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
var software =
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/getrecord/{software.SoftwareName}");
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
|
AssertElement(await
|
|
GetModelFromResponseAsync<SoftwareViewModel>(response), software);
|
|
}
|
|
[Test]
|
|
public async Task GetElement_ByName_WhenNoRecord_ShouldNotFound_Test()
|
|
{
|
|
//Arrange
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/getrecord/New%20Name");
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.NotFound));
|
|
}
|
|
[Test]
|
|
public async Task
|
|
GetElement_ByName_WhenRecordWasDeleted_ShouldNotFound_Test()
|
|
{
|
|
//Arrange
|
|
var software =
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId, isDeleted:
|
|
true);
|
|
//Act
|
|
var response = await
|
|
HttpClient.GetAsync($"/api/softwares/getrecord/{software.SoftwareName}");
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.NotFound));
|
|
}
|
|
[Test]
|
|
public async Task Post_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId);
|
|
var softwareModel = CreateModel(_manufacturerId);
|
|
//Act
|
|
var response = await HttpClient.PostAsync($"/api/softwares/register",
|
|
MakeContent(softwareModel));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.NoContent));
|
|
AssertElement(SmallSoftwareDbContext.GetSoftwareFromDatabaseById(softwareModel.Id!), softwareModel);
|
|
}
|
|
[Test]
|
|
public async Task Post_WhenHaveRecordWithSameId_ShouldBadRequest_Test()
|
|
{
|
|
//Arrange
|
|
var softwareModel = CreateModel(_manufacturerId);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareModel.Id);
|
|
//Act
|
|
var response = await HttpClient.PostAsync($"/api/softwares/register",
|
|
MakeContent(softwareModel));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Post_WhenHaveRecordWithSameName_ShouldBadRequest_Test()
|
|
{
|
|
//Arrange
|
|
var softwareModel = CreateModel(_manufacturerId, softwareName: "unique name");
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: softwareModel.SoftwareName!);
|
|
//Act
|
|
var response = await HttpClient.PostAsync($"/api/softwares/register",
|
|
MakeContent(softwareModel));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Post_WhenDataIsIncorrect_ShouldBadRequest_Test()
|
|
{
|
|
//Arrange
|
|
var softwareModelWithIdIncorrect = new SoftwareBindingModel
|
|
{
|
|
Id = "Id",
|
|
ManufacturerId = _manufacturerId,
|
|
SoftwareName = "name",
|
|
Price = 100,
|
|
SoftwareType = SoftwareType.Windows.ToString()
|
|
};
|
|
var softwareModelWithNameIncorrect = new SoftwareBindingModel
|
|
{
|
|
Id = Guid.NewGuid().ToString(),
|
|
ManufacturerId = _manufacturerId,
|
|
SoftwareName = string.Empty,
|
|
Price = 100,
|
|
SoftwareType = SoftwareType.Windows.ToString()
|
|
};
|
|
var softwareModelWithSoftwareTypeIncorrect = new SoftwareBindingModel
|
|
{
|
|
Id = Guid.NewGuid().ToString(),
|
|
ManufacturerId = _manufacturerId,
|
|
SoftwareName =
|
|
"name",
|
|
Price = 100,
|
|
SoftwareType = string.Empty
|
|
};
|
|
var softwareModelWithPriceIncorrect = new SoftwareBindingModel
|
|
{
|
|
Id =
|
|
Guid.NewGuid().ToString(),
|
|
ManufacturerId = _manufacturerId,
|
|
SoftwareName =
|
|
"name",
|
|
Price = 0,
|
|
SoftwareType = SoftwareType.Windows.ToString()
|
|
};
|
|
//Act
|
|
var responseWithIdIncorrect = await
|
|
HttpClient.PostAsync($"/api/softwares/register",
|
|
MakeContent(softwareModelWithIdIncorrect));
|
|
var responseWithNameIncorrect = await
|
|
HttpClient.PostAsync($"/api/softwares/register",
|
|
MakeContent(softwareModelWithNameIncorrect));
|
|
var responseWithSoftwareTypeIncorrect = await
|
|
HttpClient.PostAsync($"/api/softwares/register",
|
|
MakeContent(softwareModelWithSoftwareTypeIncorrect));
|
|
var responseWithPriceIncorrect = await
|
|
HttpClient.PostAsync($"/api/softwares/register",
|
|
MakeContent(softwareModelWithPriceIncorrect));
|
|
//Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(responseWithIdIncorrect.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest), "Id is incorrect");
|
|
Assert.That(responseWithNameIncorrect.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest), "Name is incorrect");
|
|
Assert.That(responseWithSoftwareTypeIncorrect.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest), "Name is incorrect");
|
|
Assert.That(responseWithPriceIncorrect.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest), "Name is incorrect");
|
|
});
|
|
}
|
|
[Test]
|
|
public async Task Post_WhenSendEmptyData_ShouldBadRequest_Test()
|
|
{
|
|
//Act
|
|
var response = await HttpClient.PostAsync($"/api/softwares/register",MakeContent(string.Empty));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Post_WhenSendWrongFormatData_ShouldBadRequest_Test()
|
|
{
|
|
//Act
|
|
var response = await HttpClient.PostAsync($"/api/softwares/register",
|
|
MakeContent(new { Data = "test", Position = 10 }));
|
|
//Assert
|
|
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Put_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
var softwareModel = CreateModel(_manufacturerId);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareModel.Id);
|
|
//Act
|
|
var response = await HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(softwareModel));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.NoContent));
|
|
SmallSoftwareDbContext.ChangeTracker.Clear();
|
|
AssertElement(SmallSoftwareDbContext.GetSoftwareFromDatabaseById(softwareModel.Id!), softwareModel);
|
|
}
|
|
[Test]
|
|
public async Task Put_WhenNoFoundRecord_ShouldBadRequest_Test()
|
|
{
|
|
//Arrange
|
|
var softwareModel = CreateModel(_manufacturerId);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId);
|
|
//Act
|
|
var response = await HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(softwareModel));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Put_WhenHaveRecordWithSameName_ShouldBadRequest_Test()
|
|
{
|
|
//Arrange
|
|
var softwareModel = CreateModel(_manufacturerId, softwareName: "unique name");
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId, softwareModel.Id);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareName: softwareModel.SoftwareName!);
|
|
//Act
|
|
var response = await HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(softwareModel));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Put_WhenRecordWasDeleted_ShouldBadRequest_Test()
|
|
{
|
|
//Arrange
|
|
var softwareModel = CreateModel(_manufacturerId);
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareModel.Id, isDeleted: true);
|
|
//Act
|
|
var response = await HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(softwareModel));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Put_WhenDataIsIncorrect_ShouldBadRequest_Test()
|
|
{
|
|
//Arrange
|
|
var softwareModelWithIdIncorrect = new SoftwareBindingModel
|
|
{
|
|
Id = "Id",
|
|
ManufacturerId = _manufacturerId,
|
|
SoftwareName = "name",
|
|
Price = 100,
|
|
SoftwareType = SoftwareType.Windows.ToString()
|
|
};
|
|
var softwareModelWithNameIncorrect = new SoftwareBindingModel
|
|
{
|
|
Id =
|
|
Guid.NewGuid().ToString(),
|
|
ManufacturerId = _manufacturerId,
|
|
SoftwareName =
|
|
string.Empty,
|
|
Price = 100,
|
|
SoftwareType = SoftwareType.Windows.ToString()
|
|
};
|
|
var softwareModelWithSoftwareTypeIncorrect = new SoftwareBindingModel
|
|
{
|
|
Id = Guid.NewGuid().ToString(),
|
|
ManufacturerId = _manufacturerId,
|
|
SoftwareName =
|
|
"name",
|
|
Price = 100,
|
|
SoftwareType = string.Empty
|
|
};
|
|
var softwareModelWithPriceIncorrect = new SoftwareBindingModel
|
|
{
|
|
Id =
|
|
Guid.NewGuid().ToString(),
|
|
ManufacturerId = _manufacturerId,
|
|
SoftwareName =
|
|
"name",
|
|
Price = 0,
|
|
SoftwareType = SoftwareType.Windows.ToString()
|
|
};
|
|
//Act
|
|
var responseWithIdIncorrect = await
|
|
HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(softwareModelWithIdIncorrect));
|
|
var responseWithNameIncorrect = await
|
|
HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(softwareModelWithNameIncorrect));
|
|
var responseWithSoftwareTypeIncorrect = await
|
|
HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(softwareModelWithSoftwareTypeIncorrect));
|
|
var responseWithPriceIncorrect = await
|
|
HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(softwareModelWithPriceIncorrect));
|
|
//Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(responseWithIdIncorrect.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest), "Id is incorrect");
|
|
Assert.That(responseWithNameIncorrect.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest), "Name is incorrect");
|
|
Assert.That(responseWithSoftwareTypeIncorrect.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest), "Name is incorrect");
|
|
Assert.That(responseWithPriceIncorrect.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest), "Name is incorrect");
|
|
});
|
|
}
|
|
[Test]
|
|
public async Task Put_WhenSendEmptyData_ShouldBadRequest_Test()
|
|
{
|
|
//Act
|
|
var response = await HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(string.Empty));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Put_WhenSendWrongFormatData_ShouldBadRequest_Test()
|
|
{
|
|
//Act
|
|
var response = await HttpClient.PutAsync($"/api/softwares/changeinfo",
|
|
MakeContent(new { Data = "test", Position = 10 }));
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Delete_ShouldSuccess_Test()
|
|
{
|
|
//Arrange
|
|
var softwareId = Guid.NewGuid().ToString();
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId,
|
|
softwareId);
|
|
//Act
|
|
var response = await
|
|
HttpClient.DeleteAsync($"/api/softwares/delete/{softwareId}");
|
|
SmallSoftwareDbContext.ChangeTracker.Clear();
|
|
//Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.NoContent));
|
|
Assert.That(SmallSoftwareDbContext.GetSoftwareFromDatabaseById(softwareId)!.IsDeleted);
|
|
});
|
|
}
|
|
[Test]
|
|
public async Task Delete_WhenNoFoundRecord_ShouldBadRequest_Test()
|
|
{
|
|
//Arrange
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId);
|
|
//Act
|
|
var response = await
|
|
HttpClient.DeleteAsync($"/api/softwares/delete/{Guid.NewGuid()}");
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Delete_WhenRecordWasDeleted_ShouldBadRequest_Test()
|
|
{
|
|
//Arrange
|
|
var softwareId =
|
|
SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturerId, isDeleted:
|
|
true).Id;
|
|
//Act
|
|
var response = await
|
|
HttpClient.DeleteAsync($"/api/softwares/delete/{softwareId}");
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
[Test]
|
|
public async Task Delete_WhenSendWrongFormatData_ShouldBadRequest_Test()
|
|
{
|
|
//Act
|
|
var response = await
|
|
HttpClient.DeleteAsync($"/api/softwares/delete/id");
|
|
//Assert
|
|
Assert.That(response.StatusCode,
|
|
Is.EqualTo(HttpStatusCode.BadRequest));
|
|
}
|
|
private static void AssertElement(SoftwareViewModel? actual, Software expected)
|
|
{
|
|
Assert.That(actual, Is.Not.Null);
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(actual.Id, Is.EqualTo(expected.Id));
|
|
Assert.That(actual.ManufacturerId,
|
|
Is.EqualTo(expected.ManufacturerId));
|
|
Assert.That(actual.SoftwareName,
|
|
Is.EqualTo(expected.SoftwareName));
|
|
Assert.That(actual.SoftwareType,
|
|
Is.EqualTo(expected.SoftwareType.ToString()));
|
|
Assert.That(actual.Price, Is.EqualTo(expected.Price));
|
|
Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
|
|
Assert.That(actual.ManufacturerName,
|
|
Is.EqualTo(expected.Manufacturer!.ManufacturerName));
|
|
});
|
|
}
|
|
private static void AssertElement(SoftwareHistoryViewModel? actual,
|
|
SoftwareHistory expected)
|
|
{
|
|
Assert.That(actual, Is.Not.Null);
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(actual.SoftwareName,
|
|
Is.EqualTo(expected.Software!.SoftwareName));
|
|
Assert.That(actual.OldPrice, Is.EqualTo(expected.OldPrice));
|
|
Assert.That(actual.ChangeDate.ToString(),
|
|
Is.EqualTo(expected.ChangeDate.ToString()));
|
|
});
|
|
}
|
|
private static SoftwareBindingModel CreateModel(string manufacturerId,
|
|
string? id = null, string softwareName = "name", SoftwareType softwareType =
|
|
SoftwareType.Windows, double price = 1)
|
|
=> new()
|
|
{
|
|
Id = id ?? Guid.NewGuid().ToString(),
|
|
ManufacturerId = manufacturerId,
|
|
SoftwareName = softwareName,
|
|
SoftwareType = softwareType.ToString(),
|
|
Price = price
|
|
};
|
|
private static void AssertElement(Software? actual, SoftwareBindingModel
|
|
expected)
|
|
{
|
|
Assert.That(actual, Is.Not.Null);
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(actual.Id, Is.EqualTo(expected.Id));
|
|
Assert.That(actual.ManufacturerId,
|
|
Is.EqualTo(expected.ManufacturerId));
|
|
Assert.That(actual.SoftwareName,
|
|
Is.EqualTo(expected.SoftwareName));
|
|
Assert.That(actual.SoftwareType.ToString(),
|
|
Is.EqualTo(expected.SoftwareType));
|
|
Assert.That(actual.Price, Is.EqualTo(expected.Price));
|
|
Assert.That(!actual.IsDeleted);
|
|
});
|
|
}
|
|
}
|
|
|