DD.WellWorkover.Cloud/AsbCloudWebApi.IntegrationTests/Controllers/ScheduleControllerTest.cs

using AsbCloudApp.Data;
using AsbCloudDb.Model;
using AsbCloudInfrastructure;
using AsbCloudWebApi.IntegrationTests.Clients;
using Mapster;
using Microsoft.EntityFrameworkCore;
using System.Net;
using Xunit;

namespace AsbCloudWebApi.IntegrationTests.Controllers
{
    public abstract class CrudWellRelatedClient<TDto, TEntity> : BaseIntegrationTest
        where TDto : AsbCloudApp.Data.IId, AsbCloudApp.Data.IWellRelated
        where TEntity : class, AsbCloudDb.Model.IId, AsbCloudDb.Model.IWellRelated
    {
        public abstract IEnumerable<TDto> ValidDtos { get; }
        public abstract IEnumerable<TDto> InvalidDtos { get; }
        protected List<string> ExcludeProps { get; set; } = new() { "Id" };

        protected ICrudWellRelatedClient<TDto> client;

        public CrudWellRelatedClient(WebAppFactoryFixture factory, string uriSuffix) 
            : base(factory)
        {
            client = factory.GetAuthorizedHttpClient<ICrudWellRelatedClient<TDto>>(uriSuffix);
        }

        protected async Task<DbSet<TEntity>> GetCleanDbSet()
        {
            var dbset = dbContext.Set<TEntity>();
            dbset.RemoveRange(dbset);
            await dbContext.SaveChangesAsync(CancellationToken.None);
            return dbset;
        }

        [Fact]
        public async Task Insert_returns_success()
        {
            foreach (var validDto in ValidDtos)
                await _Insert_returns_success(validDto);
        }

        private async Task _Insert_returns_success(TDto validDto)
        {
            var dbset = await GetCleanDbSet();

            //act
            var response = await client.InsertAsync(validDto);

            //assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.True(response.Content > 0);

            var entity = dbset.First();
            var fromDbDto = Convert(entity);
            MatchHelper.Match(validDto, fromDbDto, ExcludeProps);
        }

        [Fact]
        public async Task Insert_fails()
        {
            foreach (var inValidDto in InvalidDtos)
                await _Insert_fails(inValidDto);
        }

        private async Task _Insert_fails(TDto invalidDto)
        {
            var dbset = await GetCleanDbSet();
            //act
            var response = await client.InsertAsync(invalidDto);

            //assert
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
        }

        protected virtual TDto Convert(TEntity entity)
        {
            var dto = entity.Adapt<TDto>();
            return dto;
        }
    }

    public class ScheduleControllerTest : CrudWellRelatedClient<ScheduleDto, Schedule>
    {
        static DrillerDto driller = new (){ 
            Id = 2 ,
            Name = "Name" ,
            Patronymic = "Patronymic",
            Surname = "Surname",
        };
        static Well well = Data.Defaults.Wells.First();

        public override IEnumerable<ScheduleDto> ValidDtos { get; } = new ScheduleDto[]
        {
            new() {
                Id = 1,
                IdWell = well.Id,
                Driller = driller,
                IdDriller = driller.Id,
                DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
                DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
                ShiftStart = new TimeDto(8, 0, 0),
                ShiftEnd = new TimeDto(20, 0, 0),
            },
            new() {
                Id = 1,
                IdWell = well.Id,
                Driller = driller,
                IdDriller = driller.Id,
                DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
                DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
                ShiftStart = new TimeDto(20, 0, 0),
                ShiftEnd = new TimeDto(8, 0, 0),
            }
        };

        public override IEnumerable<ScheduleDto> InvalidDtos { get; } = new ScheduleDto[]
        {
            new() {
                Id = 1,
                IdWell = well.Id,
                Driller = driller,
                IdDriller = driller.Id,
                DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
                DrillEnd = new DateTime(2022, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
                ShiftStart = new TimeDto(8, 0, 0),
                ShiftEnd = new TimeDto(20, 0, 0),
            },
            new() {
                Id = 1,
                IdWell = well.Id,
                Driller = driller,
                IdDriller = int.MaxValue - 1,
                DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
                DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
                ShiftStart = new TimeDto(8, 0, 0),
                ShiftEnd = new TimeDto(20, 0, 0),
            }
        };

        public ScheduleControllerTest(WebAppFactoryFixture factory) 
            : base(factory, "api/schedule")
        {
            var dbDriller = driller.Adapt<Driller>();
            dbContext.Set<Driller>().Add(dbDriller);
            dbContext.SaveChanges();

            ExcludeProps.Add(nameof(ScheduleDto.Driller));
        }

        protected override ScheduleDto Convert(Schedule entity)
        {
            var dto = base.Convert(entity);
            dto.DrillStart = entity.DrillStart.ToRemoteDateTime(well.Timezone.Hours);
            dto.DrillEnd = entity.DrillEnd.ToRemoteDateTime(well.Timezone.Hours);
            return dto;
        }
    }
}