DD.WellWorkover.Cloud/AsbCloudInfrastructure.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 AsbCloudInfrastructure.Tests.Services.WellCompositeOperation;

public class WellCompositeOperationServiceTest
{
    private WellCompositeOperationService service;

    private ICrudRepository<WellSectionTypeDto> wellSectionTypeRepository
        = Substitute.For<ICrudRepository<WellSectionTypeDto>>();
    private IWellOperationCategoryRepository wellOperationCategoryRepository
        = Substitute.For<IWellOperationCategoryRepository>();
    private IWellOperationService wellOperationService
       = Substitute.For<IWellOperationService>();
    private IWellService wellService
       = Substitute.For<IWellService>();
    private List<int> idsWells;
    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 = "Проработка принудительная"},
        new(){Id = 5113, 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<WellDto> wells = new List<WellDto>()
    {
        new() {Id = 55, Caption = "Скважина с ключом 55"},
        new() {Id = 64, Caption = "Скважина с ключом 64"},
    };

    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);

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

        wellService.GetAsync(Arg.Any<WellRequest>(), Arg.Any<CancellationToken>())
            .Returns(wells);

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

    /// <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
        wellOperationService.GetAsync(Arg.Any<WellOperationRequest>(), Arg.Any<CancellationToken>())
            .Returns(wellOperations1);

        // act
        var result = await service.GetAsync(idsWells, 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
        wellOperationService.GetAsync(Arg.Any<WellOperationRequest>(), Arg.Any<CancellationToken>())
            .Returns(wellOperations2);

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

        // assert
        var compositeWellOperations = result.WellOperationsComposite;
        Assert.Single(compositeWellOperations);
        Assert.Equal(5113, 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
        wellOperationService.GetAsync(Arg.Any<WellOperationRequest>(), Arg.Any<CancellationToken>())
            .Returns(wellOperations3);

        // act
        var result = await service.GetAsync(idsWells, 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
        wellOperationService.GetAsync(Arg.Any<WellOperationRequest>(), Arg.Any<CancellationToken>())
            .Returns(wellOperations4);

        // act
        var result = await service.GetAsync(idsWells, 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);

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

        // act
        var result = await service.GetAsync(idsWells, 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);
    }
}