PIbd-22_Buslaev.R.V_TwoFromTheCasketProject/TwoFromTheCasketContracts/TwoFromTheCasketTests/WebApiControllersTests/ComplitedWorkControllerTests.cs

using System.Net;
using TwoFromTheCasketContracts.ViewModels;
using TwoFromTheCasketTests.Infrastructure;
using TwoFromTheCasketDatabase.Models;
using TwoFromTheCasketTests.WebApiControllersTests;
using TwoFromTheCasketContracts.BindingModels;

namespace TwoFromTheCasketTests.ControllerTests;

[TestFixture]
public class ComplitedWorkControllerTests : BaseWebApiControllerTest
{

    [TearDown]
    public void TearDown()
    {
        TwoFromTheCasketDb.ClearTables();
    }

    [Test]
    public async Task Try_GetListByPeriod_Test()
    {
        var date = new DateTime(2024, 1, 15, 0, 0, 0, DateTimeKind.Utc);
        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: date);
        var room = TwoFromTheCasketDb.InsertRoomToDatabaseAndReturn();
        var complited = TwoFromTheCasketDb.InsertComplitedWorkToDatabaseAndReturn(date: date, roomId: room.Id, workId: work.Id);

        var from = date.AddDays(-1).ToString("o");
        var to = date.AddDays(1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByPeriod/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));

        var list = await GetModelFromResponseAsync<List<ComplitedWorkViewModel>>(response);
        Assert.That(list, Is.Not.Null);
        Assert.That(list.Count, Is.EqualTo(1));
        Assert.That(list.First().Id, Is.EqualTo(complited.Id));
    }

    [Test]
    public async Task Try_GetListByPeriod_WhenInvalidDates_Test()
    {
        var response = await HttpClient.GetAsync("api/ComplitedWork/GetListByPeriod/invalid/also-invalid");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByPeriod_WhenIncorrectDateRange_Test()
    {
        var from = new DateTime(2025, 1, 2, 0, 0, 0, DateTimeKind.Utc).ToString("o");
        var to = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByPeriod/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByRoom_Test()
    {
        var date = new DateTime(2024, 3, 15, 0, 0, 0, DateTimeKind.Utc);
        var room = TwoFromTheCasketDb.InsertRoomToDatabaseAndReturn();
        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: date);
        var complited = TwoFromTheCasketDb.InsertComplitedWorkToDatabaseAndReturn(roomId: room.Id, workId: work.Id, date: date);

        var from = date.AddDays(-1).ToString("o");
        var to = date.AddDays(1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByRoom/{room.Id}/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));

        var list = await GetModelFromResponseAsync<List<ComplitedWorkViewModel>>(response);
        Assert.That(list, Is.Not.Null);
        Assert.That(list.Count, Is.EqualTo(1));
        Assert.That(list.First().Id, Is.EqualTo(complited.Id));
    }

    [Test]
    public async Task Try_GetListByRoom_WhenEmptyRoomId_Test()
    {
        var from = DateTime.UtcNow.AddDays(-1).ToString("o");
        var to = DateTime.UtcNow.AddDays(1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByRoom/lol/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByRoom_WhenInvalidDates_Test()
    {
        var response = await HttpClient.GetAsync("api/ComplitedWork/GetListByRoom/room1/invalid/invalid");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByRoom_WhenIncorrectDateRange_Test()
    {
        var from = new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("o");
        var to = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByRoom/room1/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByWork_Test()
    {
        var date = new DateTime(2024, 2, 15, 0, 0, 0, DateTimeKind.Utc);
        var room = TwoFromTheCasketDb.InsertRoomToDatabaseAndReturn();
        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: date);
        var complited = TwoFromTheCasketDb.InsertComplitedWorkToDatabaseAndReturn(roomId: room.Id, workId: work.Id, date: date);

        var from = date.AddDays(-1).ToString("o");
        var to = date.AddDays(1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByWork/{work.Id}/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));

        var list = await GetModelFromResponseAsync<List<ComplitedWorkViewModel>>(response);
        Assert.That(list, Is.Not.Null);
        Assert.That(list.Count, Is.EqualTo(1));
        Assert.That(list.First().Id, Is.EqualTo(complited.Id));
    }

    [Test]
    public async Task Try_GetListByWork_WhenEmptyWorkId_Test()
    {
        var from = DateTime.UtcNow.AddDays(-1).ToString("o");
        var to = DateTime.UtcNow.AddDays(1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByWork/ /{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByWork_WhenInvalidDateRange_Test()
    {
        var workId = Guid.NewGuid().ToString();
        var from = new DateTime(2025, 1, 1).ToString("o");
        var to = new DateTime(2020, 1, 1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByWork/{workId}/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByWork_WhenInvalidDateFormat_Test()
    {
        var workId = Guid.NewGuid().ToString();
        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByWork/{workId}/invalid-date/another-invalid");

        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByWorker_Test()
    {
        var date = new DateTime(2024, 2, 15, 0, 0, 0, DateTimeKind.Utc);
        var room = TwoFromTheCasketDb.InsertRoomToDatabaseAndReturn();
        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: date);
        var spec = TwoFromTheCasketDb.InsertSpecializationToDatabaseAndReturn();
        var complited = TwoFromTheCasketDb.InsertComplitedWorkToDatabaseAndReturn(roomId: room.Id, workId: work.Id, date: date);
        var worker = TwoFromTheCasketDb.InsertWorkerToDatabaseAndReturn(specializationId: spec.Id);
        TwoFromTheCasketDb.InsertWorkerComplitedWorkToDatabaseAndReturn(workerId: worker.Id, complitedWorkId: complited.Id, numberOfWorkingHour: 5);

        var from = date.AddDays(-1).ToString("o");
        var to = date.AddDays(1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByWorker/{worker.Id}/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));

        var list = await GetModelFromResponseAsync<List<ComplitedWorkViewModel>>(response);
        Assert.That(list, Is.Not.Null);
        Assert.That(list.Count, Is.EqualTo(1));
        Assert.That(list.First().Id, Is.EqualTo(complited.Id));
    }

    [Test]
    public async Task Try_GetListByWorker_WhenEmptyWorkerId_Test()
    {
        var from = DateTime.UtcNow.AddDays(-1).ToString("o");
        var to = DateTime.UtcNow.AddDays(1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByWorker/ /{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByWorker_WhenInvalidGuid_Test()
    {
        var from = DateTime.UtcNow.AddDays(-1).ToString("o");
        var to = DateTime.UtcNow.AddDays(1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByWorker/invalid-guid/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetListByWorker_WhenInvalidDateRange_Test()
    {
        var workerId = Guid.NewGuid().ToString();
        var from = new DateTime(2025, 1, 1).ToString("o");
        var to = new DateTime(2020, 1, 1).ToString("o");

        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetListByWorker/{workerId}/{from}/{to}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_GetRecord_WhenInvalidGuid_Test()
    {
        var response = await HttpClient.GetAsync("api/ComplitedWork/GetRecord/not-a-guid");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.InternalServerError));
    }

    [Test]
    public async Task Try_GetRecord_WhenEmpty_Test()
    {
        var response = await HttpClient.GetAsync("api/ComplitedWork/GetRecord/");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task Try_GetRecord_WhenNotFound_Test()
    {
        var id = Guid.NewGuid().ToString();
        var response = await HttpClient.GetAsync($"api/ComplitedWork/GetRecord/{id}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task Try_Register_Test()
    {
        var room = TwoFromTheCasketDb.InsertRoomToDatabaseAndReturn();
        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: DateTime.UtcNow);
        var specialization = TwoFromTheCasketDb.InsertSpecializationToDatabaseAndReturn();
        var worker = TwoFromTheCasketDb.InsertWorkerToDatabaseAndReturn(specializationId: specialization.Id);
        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
        TwoFromTheCasketDb.WorkWarehouses.Add(new Work_Warehouse
        {
            WorkId = work.Id,
            WarehouseId = warehouse.Id,
            Quantity = 10  
        });
        TwoFromTheCasketDb.SaveChanges();

        var model = new ComplitedWorkBindingModel
        {
            Id = Guid.NewGuid().ToString(),
            RoomId = room.Id,
            WorkId = work.Id,
            Date = DateTime.UtcNow,
            Workers = new List<WorkerComplitedWorkBindingModel>
        {
            new()
            {
                WorkerId = worker.Id,
                NumberOfWorkingHours = 15
            }
        }
        };

        var response = await HttpClient.PostAsync("api/ComplitedWork/Register", MakeContent(model));

        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));

        var entity = TwoFromTheCasketDb.ComplitedWorks.FirstOrDefault(x => x.Id == model.Id);
        Assert.That(entity, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(entity!.RoomId, Is.EqualTo(model.RoomId));
            Assert.That(entity.WorkId, Is.EqualTo(model.WorkId));
            Assert.That(entity.Date.Date, Is.EqualTo(model.Date.Date));
        });

        var stock = TwoFromTheCasketDb.WorkWarehouses
                     .First(x => x.WorkId == work.Id && x.WarehouseId == warehouse.Id);
        Assert.That(stock.Quantity, Is.EqualTo(10));
    }

    [Test]
    public async Task Try_Register_WhenNoWorkers_Test()
    {
        var room = TwoFromTheCasketDb.InsertRoomToDatabaseAndReturn();
        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: DateTime.UtcNow);

        var model = new ComplitedWorkBindingModel
        {
            Id = Guid.NewGuid().ToString(),
            RoomId = room.Id,
            WorkId = work.Id,
            Date = DateTime.UtcNow,
            Workers = new List<WorkerComplitedWorkBindingModel>()
        };

        var response = await HttpClient.PostAsync("api/ComplitedWork/Register", MakeContent(model));
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }


    [Test]
    public async Task Try_Register_WhenAlreadyExists_Test()
    {
        var date = DateTime.UtcNow.Date;
        var room = TwoFromTheCasketDb.InsertRoomToDatabaseAndReturn();
        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: date);
        var complited = TwoFromTheCasketDb.InsertComplitedWorkToDatabaseAndReturn(roomId: room.Id, workId: work.Id, date: date);

        var model = new ComplitedWorkBindingModel
        {
            Id = complited.Id,
            RoomId = room.Id,
            WorkId = work.Id,
            Date = date,
            Workers = new List<WorkerComplitedWorkBindingModel>()
        };

        var response = await HttpClient.PostAsync("api/ComplitedWork/Register", MakeContent(model));
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_Register_WhenInvalidData_Test()
    {
        var model = new ComplitedWorkBindingModel
        {
            Id = "",
            RoomId = "",
            WorkId = "",
            Date = DateTime.MinValue,
            Workers = new List<WorkerComplitedWorkBindingModel>()
        };

        var response = await HttpClient.PostAsync("api/ComplitedWork/Register", MakeContent(model));
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_Delete_Test()
    {
        var date = DateTime.UtcNow.Date;
        var room = TwoFromTheCasketDb.InsertRoomToDatabaseAndReturn();
        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: date);
        var complited = TwoFromTheCasketDb.InsertComplitedWorkToDatabaseAndReturn(roomId: room.Id, workId: work.Id, date: date);

        var response = await HttpClient.DeleteAsync($"api/ComplitedWork/Delete/{complited.Id}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));

        var fromDb = TwoFromTheCasketDb.ComplitedWorks.FirstOrDefault(x => x.Id == complited.Id);
        Assert.That(fromDb, Is.Null);
    }

    [Test]
    public async Task Try_Delete_WhenInvalidGuid_Test()
    {
        var response = await HttpClient.DeleteAsync("api/ComplitedWork/Delete/invalid-guid");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Try_Delete_WhenNotFound_Test()
    {
        var response = await HttpClient.DeleteAsync($"api/ComplitedWork/Delete/{Guid.NewGuid()}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

}