AndDietCoke/AndDietCokeProject/AndDietCokeTests/WebApiControllersTests/WorkerControllerTests.cs

using AndDietCokeContracts.BindingModels;
using AndDietCokeContracts.ViewModels;
using AndDietCokeDatabase.Models;
using AndDietCokeTests.Infrastructure;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;

namespace AndDietCokeTests.WebApiControllersTests;

[TestFixture]
internal class WorkerControllerTests : BaseWebApiControllerTest
{
    private Post _post;

    [SetUp]
    public void SetUp()
    {
        _post = AndDietCokeDbContext.InsertPostToDatabaseAndReturn();
    }

    [TearDown]
    public void TearDown()
    {
        AndDietCokeDbContext.RemovePostsFromDatabase();
        AndDietCokeDbContext.RemoveWorkersFromDatabase();
    }

    [Test]
    public async Task GetList_WhenHaveRecords_ShouldSuccess_Test()
    {
        //Arrange
        var worker = AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 1", postId: _post.PostId)
            .AddPost(_post);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 2", postId: _post.PostId);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 3", postId: _post.PostId);
        //Act
        var response = await HttpClient.GetAsync("/api/workers/getrecords");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<WorkerViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(3));
        });
        AssertElement(data.First(x => x.Id == worker.Id), worker);
    }

    [Test]
    public async Task GetList_WhenNoRecords_ShouldSuccess_Test()
    {
        //Act
        var response = await HttpClient.GetAsync("/api/workers/getrecords");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<WorkerViewModel>>(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
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 1", postId: _post.PostId, isDeleted: true);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 2", postId: _post.PostId, isDeleted: false);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 3", postId: _post.PostId, isDeleted: false);
        //Act
        var response = await HttpClient.GetAsync("/api/workers/getrecords?includeDeleted=false");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<WorkerViewModel>>(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
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 1", postId: _post.PostId, isDeleted: true);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 2", postId: _post.PostId, isDeleted: true);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 3", postId: _post.PostId, isDeleted: false);
        //Act
        var response = await HttpClient.GetAsync("/api/workers/getrecords?includeDeleted=true");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<WorkerViewModel>>(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_ByPostId_ShouldSuccess_Test()
    {
        //Arrange
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 1", postId: _post.PostId);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 2", postId: _post.PostId);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 3", postId: _post.PostId, isDeleted: true);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 4");
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getpostrecords?id={_post.PostId}&includeDeleted=true");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<WorkerViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(data, Has.Count.EqualTo(3));
            Assert.That(data.All(x => x.PostId == _post.PostId));
        });
    }

    [Test]
    public async Task GetList_ByPostId_WhenNoRecords_ShouldSuccess_Test()
    {
        //Arrange
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 1", postId: _post.PostId);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 4");
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getpostrecords?id={Guid.NewGuid()}&includeDeleted=true");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<WorkerViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(0));
    }

    [Test]
    public async Task GetList_ByPostId_WhenIdIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getpostrecords?id=id&includeDeleted=true");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetList_ByBirthDate_ShouldSuccess_Test()
    {
        //Arrange
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 1", birthDate: DateTime.UtcNow.AddYears(-25));
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 2", birthDate: DateTime.UtcNow.AddYears(-21));
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 3", birthDate: DateTime.UtcNow.AddYears(-20), isDeleted: true);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 4", birthDate: DateTime.UtcNow.AddYears(-19));
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getbirthdaterecords?fromDate={DateTime.Now.AddYears(-21).AddMinutes(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.Now.AddYears(-20).AddMinutes(1):MM/dd/yyyy HH:mm:ss}&includeDeleted=true");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<WorkerViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(data, Has.Count.EqualTo(2));
        });
    }

    [Test]
    public async Task GetList_ByBirthDate_WhenDateIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getbirthdaterecords?fromDate={DateTime.Now.AddMinutes(1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.Now.AddMinutes(-1):MM/dd/yyyy HH:mm:ss}&includeDeleted=true");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetList_ByEmploymentDate_ShouldSuccess_Test()
    {
        //Arrange
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 1", employmentDate: DateTime.UtcNow.AddDays(-2));
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 2", employmentDate: DateTime.UtcNow.AddDays(-1));
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 3", employmentDate: DateTime.UtcNow.AddDays(1), isDeleted: true);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(fio: "fio 4", employmentDate: DateTime.UtcNow.AddDays(2));
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getemploymentrecords?fromDate={DateTime.Now.AddDays(-1).AddMinutes(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.Now.AddDays(1).AddMinutes(1):MM/dd/yyyy HH:mm:ss}&includeDeleted=true");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<WorkerViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(data, Has.Count.EqualTo(2));
        });
    }

    [Test]
    public async Task GetList_ByEmploymentDate_WhenDateIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getemploymentrecords?fromDate={DateTime.Now.AddMinutes(1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.Now.AddMinutes(-1):MM/dd/yyyy HH:mm:ss}&includeDeleted=true");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetElement_ById_WhenHaveRecord_ShouldSuccess_Test()
    {
        //Arrange
        var worker = AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(postId: _post.PostId).AddPost(_post);
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getrecord/{worker.Id}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        AssertElement(await GetModelFromResponseAsync<WorkerViewModel>(response), worker);
    }

    [Test]
    public async Task GetElement_ById_WhenNoRecord_ShouldNotFound_Test()
    {
        //Arrange
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn();
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getrecord/{Guid.NewGuid()}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task GetElement_ById_WhenRecordWasDeleted_ShouldNotFound_Test()
    {
        //Arrange
        var worker = AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(postId: _post.PostId, isDeleted: true);
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getrecord/{worker.Id}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task GetElement_ByFIO_WhenHaveRecord_ShouldSuccess_Test()
    {
        //Arrange
        var worker = AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(postId: _post.PostId).AddPost(_post);
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getrecord/{worker.FIO}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        AssertElement(await GetModelFromResponseAsync<WorkerViewModel>(response), worker);
    }

    [Test]
    public async Task GetElement_ByFIO_WhenNoRecord_ShouldNotFound_Test()
    {
        //Arrange
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn();
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getrecord/New%20Fio");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task GetElement_ByFIO_WhenRecordWasDeleted_ShouldNotFound_Test()
    {
        //Arrange
        var worker = AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(postId: _post.PostId, isDeleted: true);
        //Act
        var response = await HttpClient.GetAsync($"/api/workers/getrecord/{worker.FIO}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task Post_ShouldSuccess_Test()
    {
        //Arrange
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn();
        var workerModel = CreateModel(_post.Id);
        //Act
        var response = await HttpClient.PostAsync($"/api/workers/register", MakeContent(workerModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        AssertElement(AndDietCokeDbContext.GetWorkerFromDatabaseById(workerModel.Id!), workerModel);
    }

    [Test]
    public async Task Post_WhenHaveRecordWithSameId_ShouldBadRequest_Test()
    {
        //Arrange
        var workerModel = CreateModel(_post.Id);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(workerModel.Id);
        //Act
        var response = await HttpClient.PostAsync($"/api/workers/register", MakeContent(workerModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Post_WhenDataIsIncorrect_ShouldBadRequest_Test()
    {
        //Arrange
        var workerModelWithIdIncorrect = new WorkerBindingModel { Id = "Id", FIO = "fio", BirthDate = DateTime.UtcNow.AddYears(-22), EmploymentDate = DateTime.UtcNow.AddDays(-5), PostId = _post.Id };
        var workerModelWithFioIncorrect = new WorkerBindingModel { Id = Guid.NewGuid().ToString(), FIO = string.Empty, BirthDate = DateTime.UtcNow.AddYears(-22), EmploymentDate = DateTime.UtcNow.AddDays(-5), PostId = _post.Id };
        var workerModelWithPostIdIncorrect = new WorkerBindingModel { Id = Guid.NewGuid().ToString(), FIO = "fio", BirthDate = DateTime.UtcNow.AddYears(-22), EmploymentDate = DateTime.UtcNow.AddDays(-5), PostId = "Id" };
        var workerModelWithBirthDateIncorrect = new WorkerBindingModel { Id = Guid.NewGuid().ToString(), FIO = "fio", BirthDate = DateTime.UtcNow.AddYears(-15), EmploymentDate = DateTime.UtcNow.AddDays(-5), PostId = _post.Id };
        //Act
        var responseWithIdIncorrect = await HttpClient.PostAsync($"/api/workers/register", MakeContent(workerModelWithIdIncorrect));
        var responseWithFioIncorrect = await HttpClient.PostAsync($"/api/workers/register", MakeContent(workerModelWithFioIncorrect));
        var responseWithPostIdIncorrect = await HttpClient.PostAsync($"/api/workers/register", MakeContent(workerModelWithPostIdIncorrect));
        var responseWithBirthDateIncorrect = await HttpClient.PostAsync($"/api/workers/register", MakeContent(workerModelWithBirthDateIncorrect));
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(responseWithIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Id is incorrect");
            Assert.That(responseWithFioIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Fio is incorrect");
            Assert.That(responseWithPostIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "PostId is incorrect");
            Assert.That(responseWithBirthDateIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "BirthDate is incorrect");
        });
    }

    [Test]
    public async Task Post_WhenSendEmptyData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PostAsync($"/api/workers/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/workers/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 workerModel = CreateModel(_post.Id);
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(workerModel.Id);
        //Act
        var response = await HttpClient.PutAsync($"/api/workers/changeinfo", MakeContent(workerModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        AndDietCokeDbContext.ChangeTracker.Clear();
        AssertElement(AndDietCokeDbContext.GetWorkerFromDatabaseById(workerModel.Id!), workerModel);
    }

    [Test]
    public async Task Put_WhenNoFoundRecord_ShouldBadRequest_Test()
    {
        //Arrange
        var workerModel = CreateModel(_post.Id, fio: "new fio");
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn();
        //Act
        var response = await HttpClient.PutAsync($"/api/workers/changeinfo", MakeContent(workerModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Put_WhenRecordWasDeleted_ShouldBadRequest_Test()
    {
        //Arrange
        var workerModel = CreateModel(_post.Id, fio: "new fio");
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(workerModel.Id, isDeleted: true);
        //Act
        var response = await HttpClient.PutAsync($"/api/workers/changeinfo", MakeContent(workerModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Put_WhenDataIsIncorrect_ShouldBadRequest_Test()
    {
        //Arrange
        var workerModelWithIdIncorrect = new WorkerBindingModel { Id = "Id", FIO = "fio", BirthDate = DateTime.UtcNow.AddYears(-22), EmploymentDate = DateTime.UtcNow.AddDays(-5), PostId = _post.Id };
        var workerModelWithFioIncorrect = new WorkerBindingModel { Id = Guid.NewGuid().ToString(), FIO = string.Empty, BirthDate = DateTime.UtcNow.AddYears(-22), EmploymentDate = DateTime.UtcNow.AddDays(-5), PostId = _post.Id };
        var workerModelWithPostIdIncorrect = new WorkerBindingModel { Id = Guid.NewGuid().ToString(), FIO = "fio", BirthDate = DateTime.UtcNow.AddYears(-22), EmploymentDate = DateTime.UtcNow.AddDays(-5), PostId = "Id" };
        var workerModelWithBirthDateIncorrect = new WorkerBindingModel { Id = Guid.NewGuid().ToString(), FIO = "fio", BirthDate = DateTime.UtcNow.AddYears(-15), EmploymentDate = DateTime.UtcNow.AddDays(-5), PostId = _post.Id };
        //Act
        var responseWithIdIncorrect = await HttpClient.PutAsync($"/api/workers/changeinfo", MakeContent(workerModelWithIdIncorrect));
        var responseWithFioIncorrect = await HttpClient.PutAsync($"/api/workers/changeinfo", MakeContent(workerModelWithFioIncorrect));
        var responseWithPostIdIncorrect = await HttpClient.PutAsync($"/api/workers/changeinfo", MakeContent(workerModelWithPostIdIncorrect));
        var responseWithBirthDateIncorrect = await HttpClient.PutAsync($"/api/workers/changeinfo", MakeContent(workerModelWithBirthDateIncorrect));
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(responseWithIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Id is incorrect");
            Assert.That(responseWithFioIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Fio is incorrect");
            Assert.That(responseWithPostIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "PostId is incorrect");
            Assert.That(responseWithBirthDateIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "BirthDate is incorrect");
        });
    }

    [Test]
    public async Task Put_WhenSendEmptyData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PutAsync($"/api/workers/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/workers/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 workerId = Guid.NewGuid().ToString();
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(workerId);
        //Act
        var response = await HttpClient.DeleteAsync($"/api/workers/delete/{workerId}");
        AndDietCokeDbContext.ChangeTracker.Clear();
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
            Assert.That(AndDietCokeDbContext.GetWorkerFromDatabaseById(workerId)!.IsDeleted);
        });
    }

    [Test]
    public async Task Delete_WhenNoFoundRecord_ShouldBadRequest_Test()
    {
        //Arrange
        AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn();
        //Act
        var response = await HttpClient.DeleteAsync($"/api/workers/delete/{Guid.NewGuid()}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Delete_WhenSendWrongFormatData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.DeleteAsync($"/api/workers/delete/id");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Delete_WhenRecordWasDeleted_ShouldBadRequest_Test()
    {
        //Arrange
        var workerId = AndDietCokeDbContext.InsertWorkerToDatabaseAndReturn(isDeleted: true).Id;
        //Act
        var response = await HttpClient.DeleteAsync($"/api/workers/delete/{workerId}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    private static void AssertElement(WorkerViewModel? actual, Worker expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.PostId, Is.EqualTo(expected.PostId));
            Assert.That(actual.PostName, Is.EqualTo(expected.Post!.PostName));
            Assert.That(actual.FIO, Is.EqualTo(expected.FIO));
            Assert.That(actual.BirthDate.ToUniversalTime().ToString(), Is.EqualTo(expected.BirthDate.ToUniversalTime().ToString()));
            Assert.That(actual.EmploymentDate.ToUniversalTime().ToString(), Is.EqualTo(expected.EmploymentDate.ToUniversalTime().ToString()));
            Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
        });
    }

    private static WorkerBindingModel CreateModel(string postId, string? id = null, string fio = "fio", DateTime? birthDate = null, DateTime? employmentDate = null)
    {
        return new()
        {
            Id = id ?? Guid.NewGuid().ToString(),
            FIO = fio,
            BirthDate = birthDate ?? DateTime.UtcNow.AddYears(-22),
            EmploymentDate = employmentDate ?? DateTime.UtcNow.AddDays(-5),
            PostId = postId
        };
    }

    private static void AssertElement(Worker? actual, WorkerBindingModel expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.PostId, Is.EqualTo(expected.PostId));
            Assert.That(actual.FIO, Is.EqualTo(expected.FIO));
            Assert.That(actual.BirthDate.ToString(), Is.EqualTo(expected.BirthDate.ToString()));
            Assert.That(actual.EmploymentDate.ToString(), Is.EqualTo(expected.EmploymentDate.ToString()));
            Assert.That(!actual.IsDeleted);
        });
    }
}