DD.WellWorkover.Cloud/AsbCloudWebApi.Tests/Services/WellCompositeOperation/WellCompositeOperationServiceTest.cs

using AsbCloudApp.Data;
using AsbCloudApp.Data.WellOperation;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services;
using NSubstitute;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Xunit;

namespace AsbCloudWebApi.Tests.Services.WellCompositeOperation
{
    public class WellCompositeOperationServiceTest
    {
        private WellCompositeOperationService service;

        private ICrudRepository<WellSectionTypeDto> wellSectionTypeRepository
            = Substitute.For<ICrudRepository<WellSectionTypeDto>>();
        private IWellOperationCategoryRepository wellOperationCategoryRepository
            = Substitute.For<IWellOperationCategoryRepository>();
        private IWellOperationRepository wellOperationRepository
           = Substitute.For<IWellOperationRepository>();
        private IWellService wellService
           = Substitute.For<IWellService>();



        private readonly static IEnumerable<WellOperationCategoryDto> operationCategories = new List<WellOperationCategoryDto>()
        {
            new(){Id = 5096, Name = "Шаблонирование перед спуском"},
            new(){Id = 5008, Name = "Шаблонировка во время бурения"},
            new(){Id = 5013, Name = "Подъем КНБК"},
            new(){Id = 5003, Name = "Бурение ротором"},
            new(){Id = 5036, Name = "Промывка"},
            new(){Id = 5012, Name = "Подъем инструмента"},
            new(){Id = 5083, Name = "Проработка принудительная"},
        };

        private readonly static IEnumerable<WellSectionTypeDto> sectionTypes = new List<WellSectionTypeDto>()
        {
            new() {Id = 2, Caption = "Направление", Order = 0},
            new() {Id = 3, Caption = "Кондуктор", Order = 1},
            new() {Id = 31, Caption = "Техническая колонна", Order = 2}
        };

        private readonly static IEnumerable<WellOperationDto> wellOperations1 = new List<WellOperationDto>()
        {
            new()
            {
                DepthStart = 50,
                DurationHours = 1,
                IdCategory = 5096,
                IdWell = 55,
                IdWellSectionType = 2,
                OperationCategoryName = "Шаблонирование перед спуском",
                WellSectionTypeCaption = "Направление"
            },
            new()
            {
                DepthStart = 84,
                DurationHours = 1,
                IdCategory = 5008,
                IdWell = 64,
                IdWellSectionType = 2,
                OperationCategoryName = "Шаблонировка во время бурения",
                WellSectionTypeCaption = "Направление"
            }
        };

        private readonly static IEnumerable<WellOperationDto> wellOperations2 = new List<WellOperationDto>()
        {
            new()
            {
                DepthStart = 10,
                DurationHours = 1.5,
                IdCategory = 5003,
                IdWell = 55,
                IdWellSectionType = 2,
                OperationCategoryName = "Бурение ротором",
                WellSectionTypeCaption = "Направление"
            },
            new()
            {
                DepthStart = 20,
                DurationHours = 3.5,
                IdCategory = 5003,
                IdWell = 64,
                IdWellSectionType = 2,
                OperationCategoryName = "Бурение ротором",
                WellSectionTypeCaption = "Направление"
            }
        };

        private readonly static IEnumerable<WellOperationDto> wellOperations3 = new List<WellOperationDto>()
        {
            new()
            {
                DepthStart = 1372,
                DurationHours = 3,
                IdCategory = 5036,
                IdWell = 55,
                IdWellSectionType = 3,
                OperationCategoryName = "Промывка",
                WellSectionTypeCaption = "Кондуктор"
            },
            new()
            {
                DepthStart = 1435,
                DurationHours = 4,
                IdCategory = 5036,
                IdWell = 64,
                IdWellSectionType = 3,
                OperationCategoryName = "Промывка",
                WellSectionTypeCaption = "Кондуктор"
            }
        };

        private readonly static IEnumerable<WellOperationDto> wellOperations4 = new List<WellOperationDto>()
        {
            new()
            {
                DepthStart = 1000,
                DurationHours = 10,
                IdCategory = 5012,
                IdWell = 55,
                IdWellSectionType = 31,
                OperationCategoryName = "Подъем инструмента",
                WellSectionTypeCaption = "Техническая колонна"
            },
            new()
            {
                DepthStart = 500,
                DurationHours = 5,
                IdCategory = 5083,
                IdWell = 55,
                IdWellSectionType = 31,
                OperationCategoryName = "Проработка принудительная",
                WellSectionTypeCaption = "Техническая колонна"
            },
            new()
            {
                DepthStart = 600,
                DurationHours = 5,
                IdCategory = 5083,
                IdWell = 64,
                IdWellSectionType = 31,
                OperationCategoryName = "Проработка принудительная",
                WellSectionTypeCaption = "Техническая колонна"
            }
        };

        public WellCompositeOperationServiceTest()
        {

            wellSectionTypeRepository.GetAllAsync(Arg.Any<CancellationToken>())
                .Returns(sectionTypes);

            wellOperationCategoryRepository.Get(Arg.Any<bool>())
                .Returns(operationCategories);

            service = new WellCompositeOperationService(
                wellSectionTypeRepository,
                wellOperationCategoryRepository,
                wellOperationRepository,
                wellService);
        }

        /// <summary>
        /// На вход подаются 2 операции с одинаковыми секциями (id = 2), но разными категориями (ids = 5096, 5008) и ключами скважин (ids = 55, 64)
        /// Метод возвращает объект с одной композитной операцией и списком операций в разрезе 2-х скважин
        /// Композитная операция должна иметь категорию 5013
        /// </summary>
        /// <returns></returns>
        [Fact]
        public async Task GetAsync_return_composite_and_others_with_category_5013()
        {
            // arrange
            wellOperationRepository.GetAsync(Arg.Any<WellOperationRequest>(), Arg.Any<CancellationToken>())
                .Returns(wellOperations1);

            var idsWell = new List<int>() { 55, 64 };

            // act
            var result = await service.GetAsync(idsWell, CancellationToken.None);

            // assert
            var compositeWellOperations = result.WellOperationsComposite;
            Assert.Single(compositeWellOperations);
            Assert.Equal(5013, compositeWellOperations.FirstOrDefault()?.IdCategory);
            Assert.Equal(1, compositeWellOperations.FirstOrDefault()?.DurationHours);
            Assert.Equal(84, compositeWellOperations.FirstOrDefault()?.DepthStart);

            var categoryName = compositeWellOperations.Select(o => o.OperationCategoryName).First();
            Assert.Equal("Подъем КНБК", categoryName);
        }

        /// <summary>
        /// На вход подаются 2 операции с одинаковыми секциями (id = 2) и категориями (id = 5003), но разными ключами скважин (ids = 55, 64)
        /// Метод возвращает объект с одной композитной операцией и списком операций в разрезе 2-х скважин
        /// Операция композитной скважины должна содержать данные той операции, которая содержит минимальный duration_hours 
        /// </summary>
        /// <returns></returns>
        [Fact]
        public async Task GetAsync_return_composite_with_minimum_depth_start()
        {
            // arrange
            wellOperationRepository.GetAsync(Arg.Any<WellOperationRequest>(), Arg.Any<CancellationToken>())
                .Returns(wellOperations2);

            var idsWell = new List<int>() { 55, 64 };

            // act
            var result = await service.GetAsync(idsWell, CancellationToken.None);

            // assert
            var compositeWellOperations = result.WellOperationsComposite;
            Assert.Single(compositeWellOperations);
            Assert.Equal(5003, compositeWellOperations.FirstOrDefault()!.IdCategory);
            Assert.Equal(1.5, compositeWellOperations.FirstOrDefault()!.DurationHours);
            Assert.Equal(10, compositeWellOperations.FirstOrDefault()!.DepthStart);
        }

        /// <summary>
        /// На вход подаются 2 операции с одинаковыми секциями (id = 3) и категориями (id = 5036), но разными ключами скважин (ids = 55, 64)
        /// Метод возвращает объект с одной композитной операцией и списком операций в разрезе 2-х скважин
        /// Операция композитной скважины должна содержать данные той операции, которая содержит минимальный duration_hours 
        /// </summary>
        /// <returns></returns>
        [Fact]
        public async Task GetAsync_return_data3()
        {
            // arrange
            wellOperationRepository.GetAsync(Arg.Any<WellOperationRequest>(), Arg.Any<CancellationToken>())
                .Returns(wellOperations3);

            var idsWell = new List<int>() { 55, 64 };

            // act
            var result = await service.GetAsync(idsWell, CancellationToken.None);

            // assert
            var compositeWellOperations = result.WellOperationsComposite;
            Assert.Single(compositeWellOperations);
            Assert.Equal(5036, compositeWellOperations.FirstOrDefault()!.IdCategory);
            Assert.Equal(3, compositeWellOperations.FirstOrDefault()!.DurationHours);
            Assert.Equal(1372, compositeWellOperations.FirstOrDefault()!.DepthStart);
        }

        /// <summary>
        /// На вход подаются 3 операции с одинаковыми секциями (id = 31), но разными категориями (ids = 5012, 5083) и ключами скважин (ids = 55, 64)
        /// Метод возвращает объект с одной композитной операцией и списком операций в разрезе 2-х скважин
        /// Операция композитной скважины должна содержать:
        ///     данные той операции, которая содержит минимальный duration_hours
        ///     категорию с ключом 5013
        /// </summary>
        /// <returns></returns>
        [Fact]
        public async Task GetAsync_return_data4()
        {
            // arrange
            wellOperationRepository.GetAsync(Arg.Any<WellOperationRequest>(), Arg.Any<CancellationToken>())
                .Returns(wellOperations4);

            var idsWell = new List<int>() { 55, 64 };

            // act
            var result = await service.GetAsync(idsWell, CancellationToken.None);

            // assert
            var compositeWellOperations = result.WellOperationsComposite;
            Assert.Single(compositeWellOperations);
            Assert.Equal(5013, compositeWellOperations.FirstOrDefault()!.IdCategory);
            Assert.Equal(5, compositeWellOperations.FirstOrDefault()!.DurationHours);
            Assert.Equal(600, compositeWellOperations.FirstOrDefault()!.DepthStart);
        }

        /// <summary>
        /// На вход подаются список разных операций с разными ключами скважин (ids = 55, 64)
        /// Метод возвращает объект с одной композитной операцией и списком операций в разрезе 2-х скважин
        /// Операция композитной скважины должна содержать глубину забоя = 1372
        /// </summary>
        /// <returns></returns>
        [Fact]
        public async Task GetAsync_return_data5()
        {
            // arrange
            var wellOperations = new List<WellOperationDto>();
            wellOperations.AddRange(wellOperations1);
            wellOperations.AddRange(wellOperations2);
            wellOperations.AddRange(wellOperations3);
            wellOperations.AddRange(wellOperations4);

            wellOperationRepository.GetAsync(Arg.Any<WellOperationRequest>(), Arg.Any<CancellationToken>())
                .Returns(wellOperations);

            var idsWell = new List<int>() { 55, 64 };

            // act
            var result = await service.GetAsync(idsWell, CancellationToken.None);

            // assert
            var wellOperationsCount = result.WellCompositeSourceOperations
                .SelectMany(o => o.Operations).Count();
            Assert.Equal(wellOperations.Count(), wellOperationsCount);

            var lastOperationComposite = result.WellOperationsComposite.Last();
            Assert.Equal(1372, lastOperationComposite.DepthStart);
        }
    }
}