<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.*" />
    <PackageReference Include="xunit" Version="2.*" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.*" />
    <PackageReference Include="coverlet.collector" Version="6.*" />
    <PackageReference Include="FluentAssertions" Version="6.*" />
    <PackageReference Include="Moq" Version="4.*" />
    <PackageReference Include="AutoFixture" Version="4.*" />
    <PackageReference Include="AutoFixture.Xunit2" Version="4.*" />
    <PackageReference Include="Bogus" Version="34.*" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\MyApp.Core\MyApp.Core.csproj" />
  </ItemGroup>

</Project>

// MyApp.Tests/GlobalUsings.cs
global using Xunit;
global using FluentAssertions;
global using Moq;
global using AutoFixture;
global using AutoFixture.Xunit2;
global using MyApp.Core; // простір імен основного проєкту

// MyApp.Tests/CalculatorTests.cs
public class CalculatorTests
{
    [Fact]
    public void Add_TwoPlusThree_ReturnsFive()
    {
        var calculator = new Calculator();
        var result = calculator.Add(2, 3);
        result.Should().Be(5);
    }
}

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.*" />
    <PackageReference Include="xunit" Version="2.*" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.*" />
    <PackageReference Include="coverlet.collector" Version="6.*" />

    <!-- Assertions та мокування -->
    <PackageReference Include="FluentAssertions" Version="6.*" />
    <PackageReference Include="Moq" Version="4.*" />

    <!-- Тестові дані -->
    <PackageReference Include="AutoFixture" Version="4.*" />
    <PackageReference Include="AutoFixture.Xunit2" Version="4.*" />
    <PackageReference Include="Bogus" Version="34.*" />

    <!-- ASP.NET інтеграційне тестування -->
    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="9.*" />

    <!-- HTTP mocking для зовнішніх сервісів -->
    <PackageReference Include="WireMock.Net" Version="1.*" />

    <!-- Testcontainers для Docker БД -->
    <PackageReference Include="Testcontainers.PostgreSql" Version="3.*" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\MyApi\MyApi.csproj" />
  </ItemGroup>

</Project>

// Спосіб 1: Додати у кінець Program.cs один рядок
// (після всіх реєстрацій і налаштувань)
app.Run();

// Для тестів — цей рядок робить Program доступним для теста:
public partial class Program { } // ← додати в кінці Program.cs

<!-- MyApi/MyApi.csproj -->
<ItemGroup>
  <InternalsVisibleTo Include="MyApi.Tests" />
</ItemGroup>

// MyApi.Tests/GlobalUsings.cs
global using Xunit;
global using FluentAssertions;
global using Moq;
global using AutoFixture;
global using AutoFixture.Xunit2;
global using System.Net;
global using System.Net.Http.Json;
global using Microsoft.AspNetCore.Mvc.Testing;
global using Microsoft.Extensions.DependencyInjection;
global using MyApi; // простір імен основного проєкту

// MyApi.Tests/Unit/Services/OrderServiceTests.cs
public class OrderServiceTests
{
    private readonly Mock<IOrderRepository> _mockRepo = new();
    private readonly OrderService _sut;

    public OrderServiceTests()
    {
        _sut = new OrderService(_mockRepo.Object);
    }

    [Fact]
    public async Task CreateOrder_WithValidData_ReturnsSuccess()
    {
        _mockRepo
            .Setup(x => x.SaveAsync(It.IsAny<Order>()))
            .ReturnsAsync(true);

        var result = await _sut.CreateAsync(new CreateOrderDto { Amount = 100m });

        result.IsSuccess.Should().BeTrue();
    }
}

// MyApi.Tests/Integration/Endpoints/OrderEndpointsTests.cs
public class OrderEndpointsTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public OrderEndpointsTests(WebApplicationFactory<Program> factory)
    {
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task GetOrders_ReturnsOk()
    {
        var response = await _client.GetAsync("/api/orders");

        response.StatusCode.Should().Be(HttpStatusCode.OK);
    }

    [Fact]
    public async Task CreateOrder_WithValidData_Returns201()
    {
        var dto = new CreateOrderDto { Amount = 150m, ProductId = Guid.NewGuid() };

        var response = await _client.PostAsJsonAsync("/api/orders", dto);

        response.StatusCode.Should().Be(HttpStatusCode.Created);
        var order = await response.Content.ReadFromJsonAsync<OrderDto>();
        order.Should().NotBeNull();
        order!.Amount.Should().Be(150m);
    }
}

public class CalculatorTests
{
    [Fact]
    public void Add_TwoPlusThree_ReturnsFive()
    {
        // Arrange
        var calculator = new Calculator();

        // Act
        var result = calculator.Add(2, 3);

        // Assert
        Assert.Equal(5, result);
    }
}

// ✅ Синхронний Fact
[Fact]
public void Synchronous_Test() { }

// ✅ Асинхронний Fact — повністю підтримується
[Fact]
public async Task Asynchronous_Test()
{
    var result = await _service.GetDataAsync();
    result.Should().NotBeNull();
}

// ✅ Async з ValueTask (більш ефективний у деяких сценаріях)
[Fact]
public async ValueTask ValueTask_Test()
{
    var result = await _service.FastOperationAsync();
    result.Should().BeTrue();
}

// Пропустити тест з поясненням
[Fact(Skip = "Відкладено: баг #1234 у зовнішньому API, виправляється у v2.1")]
public void Test_WithKnownBug() { }

// Умовний пропуск через власний атрибут
[SkipUnlessEnvironment("Integration")]
public void Test_OnlyInIntegrationEnvironment() { }

// За замовчуванням показується ім'я методу
[Fact]
public void CreateOrder_WithValidData_ReturnsSuccess() { }

// З DisplayName: показується у Test Explorer та звітах
[Fact(DisplayName = "Створення замовлення з валідними даними повертає успіх")]
public void CreateOrder_WithValidData_ReturnsSuccess_WithName() { }

// Корисно для тестів з нетехнічними читачами (BDD стиль)
[Fact(DisplayName = "Клієнт може скасувати замовлення до відправки")]
public void Customer_CanCancelOrder_BeforeShipping() { }

[Theory]
[InlineData(2, 3, 5)]
[InlineData(-1, 1, 0)]
[InlineData(0, 0, 0)]
[InlineData(int.MaxValue, 0, int.MaxValue)]
[InlineData(int.MinValue, 0, int.MinValue)]
public void Add_ReturnsCorrectSum(int a, int b, int expected)
{
    var result = new Calculator().Add(a, b);
    Assert.Equal(expected, result);
}

Add_ReturnsCorrectSum(a: 2, b: 3, expected: 5) ✅
Add_ReturnsCorrectSum(a: -1, b: 1, expected: 0) ✅
Add_ReturnsCorrectSum(a: 0, b: 0, expected: 0) ✅
...

[Theory]
[InlineData("hello", true)]
[InlineData("", false)]
[InlineData(null, false)]
[InlineData("   ", false)]
public void IsValidName_ReturnsCorrectResult(string? name, bool expected)
{
    Assert.Equal(expected, NameValidator.IsValid(name));
}

public class DiscountCalculatorTests
{
    // Статична властивість — джерело даних
    public static IEnumerable<object[]> DiscountTestCases =>
        new List<object[]>
        {
            new object[] { CustomerType.Standard, 1000m, 0m },
            new object[] { CustomerType.Premium, 1000m, 100m },   // 10%
            new object[] { CustomerType.VIP,     1000m, 200m },   // 20%
            new object[] { CustomerType.Premium, 0m,    0m },     // 0 замовлення
            new object[] { CustomerType.VIP,     500m,  100m },   // 20% від 500
        };

    [Theory]
    [MemberData(nameof(DiscountTestCases))]
    public void CalculateDiscount_ReturnsCorrectAmount(
        CustomerType type, decimal orderTotal, decimal expectedDiscount)
    {
        var result = _calculator.CalculateDiscount(type, orderTotal);
        Assert.Equal(expectedDiscount, result);
    }
}

// Дані можна генерувати динамічно
public static IEnumerable<object[]> GenerateBoundaryData()
{
    yield return new object[] { -1, false };
    yield return new object[] { 0, false };
    yield return new object[] { 1, true };

    // Динамічна генерація
    foreach (var age in new[] { 18, 21, 65, 66 })
        yield return new object[] { age, age >= 18 && age <= 65 };

    yield return new object[] { 120, false };
}

[Theory]
[MemberData(nameof(GenerateBoundaryData))]
public void IsValidAge_ReturnsCorrectResult(int age, bool expected) { }

// SharedTestData.cs — спільні дані для кількох тест-класів
public static class SharedTestData
{
    public static IEnumerable<object[]> ValidUsers =>
        new List<object[]>
        {
            new object[] { "John", "Doe", "john@test.com", 25 },
            new object[] { "Jane", "Smith", "jane@test.com", 30 },
        };
}

// В тест-класі — посилання на інший клас
[Theory]
[MemberData(nameof(SharedTestData.ValidUsers), MemberType = typeof(SharedTestData))]
public void CreateUser_WithValidData_Succeeds(
    string firstName, string lastName, string email, int age) { }

// Окремий клас для тестових даних
public class PasswordValidationTestData : IEnumerable<object[]>
{
    private readonly List<object[]> _data = new()
    {
        // password, isValid, errorMessage
        new object[] { "Short1!", false, "Too short" },
        new object[] { "nouppercase1!", false, "No uppercase" },
        new object[] { "NOLOWERCASE1!", false, "No lowercase" },
        new object[] { "NoDigitHere!", false, "No digit" },
        new object[] { "NoSpecial1", false, "No special char" },
        new object[] { "Valid1Pass!", true, null! },
        new object[] { "AnotherValid2@", true, null! },
    };

    public IEnumerator<object[]> GetEnumerator() => _data.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

// Використання
[Theory]
[ClassData(typeof(PasswordValidationTestData))]
public void ValidatePassword_ReturnsCorrectResult(
    string password, bool isValid, string? expectedError)
{
    var result = _validator.Validate(password);
    Assert.Equal(isValid, result.IsValid);
    if (expectedError != null)
        Assert.Contains(expectedError, result.Errors);
}

// TheoryData<T> — типобезпечна альтернатива IEnumerable<object[]>
public static TheoryData<int, bool> AgeData => new()
{
    { 17, false },
    { 18, true },
    { 65, true },
    { 66, false },
};

[Theory]
[MemberData(nameof(AgeData))]
public void IsEligible_ByAge_ReturnsCorrectResult(int age, bool expected)
{
    Assert.Equal(expected, _service.IsEligible(age));
}

1. Конструктор тест-класу (= Setup)
2. Тест-метод
3. Dispose() тест-класу (= Teardown, якщо клас реалізує IDisposable)

public class OrderServiceTests : IDisposable
{
    private readonly OrderService _sut;
    private readonly Mock<IOrderRepository> _mockRepo;

    // CONSTRUCTOR = SETUP — виконується перед кожним тестом
    public OrderServiceTests()
    {
        _mockRepo = new Mock<IOrderRepository>();
        _sut = new OrderService(_mockRepo.Object);

        // Налаштовуємо загальний stubs, що потрібні більшості тестів
        _mockRepo
            .Setup(x => x.ExistsAsync(It.IsAny<Guid>()))
            .ReturnsAsync(true);
    }

    [Fact]
    public async Task CreateOrder_WithValidData_ShouldSucceed()
    {
        // _sut та _mockRepo свіжі для цього тесту
        var result = await _sut.CreateAsync(new CreateOrderDto());
        result.IsSuccess.Should().BeTrue();
    }

    [Fact]
    public async Task CreateOrder_WithDuplicateId_ShouldFail()
    {
        // Повністю ізольовано від попереднього тесту
        _mockRepo
            .Setup(x => x.ExistsAsync(It.IsAny<Guid>()))
            .ReturnsAsync(false); // Перевизначаємо для цього конкретного тесту

        var result = await _sut.CreateAsync(new CreateOrderDto());
        result.IsSuccess.Should().BeFalse();
    }

    // DISPOSE = TEARDOWN — виконується після кожного тесту
    public void Dispose()
    {
        // Звільняємо ресурси: закриваємо з'єднання, видаляємо файли тощо
        _sut.Dispose(); // якщо _sut є IDisposable
    }
}

// Fixture: ресурс, що дорого ініціалізувати
public class SqliteDatabaseFixture : IDisposable
{
    public IDbConnection Connection { get; private set; }
    public string DatabaseName { get; } = $"test_{Guid.NewGuid():N}";

    public SqliteDatabaseFixture()
    {
        // Це виконується ОДИН РАЗ для всіх тестів у класі
        Connection = new SqliteConnection($"Data Source={DatabaseName}.db");
        Connection.Open();

        // Створюємо схему
        Connection.Execute("""
            CREATE TABLE Users (
                Id TEXT PRIMARY KEY,
                Name TEXT NOT NULL,
                Email TEXT NOT NULL
            )
        """);
    }

    public void ResetData()
    {
        // Очищення між тестами
        Connection.Execute("DELETE FROM Users");
    }

    public void Dispose()
    {
        Connection.Dispose();
        File.Delete($"{DatabaseName}.db");
    }
}

// Тест-клас з fixture
public class UserRepositoryTests : IClassFixture<SqliteDatabaseFixture>
{
    private readonly SqliteDatabaseFixture _db;

    // xUnit інжектує fixture через конструктор
    public UserRepositoryTests(SqliteDatabaseFixture db)
    {
        _db = db;
        _db.ResetData(); // Очищаємо дані перед кожним тестом
        // Але САМО ПІДКЛЮЧЕННЯ not recreated — тільки дані
    }

    [Fact]
    public async Task GetById_WhenUserExists_ReturnsUser()
    {
        // Arrange: вставляємо дані
        await _db.Connection.ExecuteAsync(
            "INSERT INTO Users VALUES (@Id, @Name, @Email)",
            new { Id = "1", Name = "John", Email = "john@test.com" });

        var repo = new UserRepository(_db.Connection);

        // Act
        var user = await repo.GetByIdAsync("1");

        // Assert
        user.Should().NotBeNull();
        user!.Name.Should().Be("John");
    }

    [Fact]
    public async Task GetById_WhenUserNotExists_ReturnsNull()
    {
        var repo = new UserRepository(_db.Connection);

        // База порожня (ResetData в конструкторі)
        var user = await repo.GetByIdAsync("nonexistent");

        user.Should().BeNull();
    }
}

SqliteDatabaseFixture() — 1 раз для всього класу

  Для кожного тесту:
    UserRepositoryTests() (конструктор)
      db.ResetData() — очищення між тестами
    UserRepositoryTests.TestMethod()
    UserRepositoryTests.Dispose() якщо є

SqliteDatabaseFixture.Dispose() — 1 раз після всіх тестів

// 1. Визначаємо колекцію
[CollectionDefinition("Database Collection")]
public class DatabaseCollection : ICollectionFixture<SqliteDatabaseFixture>
{
    // Порожній клас — тільки маркер
}

// 2. Позначаємо тест-класи як частину колекції
[Collection("Database Collection")]
public class UserRepositoryTests
{
    private readonly SqliteDatabaseFixture _db;
    public UserRepositoryTests(SqliteDatabaseFixture db) => _db = db;
    // ...
}

[Collection("Database Collection")]
public class OrderRepositoryTests
{
    private readonly SqliteDatabaseFixture _db;
    public OrderRepositoryTests(SqliteDatabaseFixture db) => _db = db;
    // ...
}

// AssemblyInfo.cs або атрибут на рівні namespace

// Вимкнути паралелізм для всієї сборки
[assembly: CollectionBehavior(DisableTestParallelization = true)]

// Встановити максимальну кількість паралельних потоків
[assembly: CollectionBehavior(MaxParallelThreads = 4)]

// Дозволити паралелізм всередині класу (небезпечно — тільки якщо клас thread-safe)
[assembly: CollectionBehavior(CollectionBehavior.CollectionPerAssembly)]

{
  "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
  "parallelizeAssembly": false,
  "parallelizeTestCollections": true,
  "maxParallelThreads": 8,
  "methodDisplay": "method",
  "diagnosticMessages": false,
  "longRunningTestSeconds": 10
}

// Два класи в одній колекції — виконуються послідовно між собою
// (але паралельно з класами без колекції або з іншими колекціями)
[Collection("Sequential Integration")]
public class DatabaseIntegrationTests { }

[Collection("Sequential Integration")]
public class ApiIntegrationTests { }

public class OrderServiceTests
{
    private readonly ITestOutputHelper _output;
    private readonly OrderService _sut;

    // xUnit автоматично інжектує ITestOutputHelper
    public OrderServiceTests(ITestOutputHelper output)
    {
        _output = output;
        _sut = new OrderService();
    }

    [Fact]
    public async Task ProcessOrder_LogsProgress()
    {
        _output.WriteLine("Starting ProcessOrder test...");

        var order = new Order { Amount = 1000m };
        var result = await _sut.ProcessOrder(order);

        _output.WriteLine($"Result: {result.Status}, Duration: {result.ProcessingMs}ms");

        result.IsSuccess.Should().BeTrue();
    }
}

Starting ProcessOrder test...
Result: Success, Duration: 45ms

[Fact]
public void DebugComplexCalculation()
{
    var input = GenerateComplexInput();
    _output.WriteLine($"Input: {JsonSerializer.Serialize(input)}");

    var result = _calculator.Process(input);
    _output.WriteLine($"Result: {JsonSerializer.Serialize(result)}");
    _output.WriteLine($"Intermediate steps: {string.Join(", ", _calculator.Steps)}");

    result.Total.Should().Be(expected);
}

public class OrderEndpointTests
{
    [Fact]
    [Trait("Category", "Integration")]
    [Trait("Feature", "Orders")]
    public async Task GetOrders_ReturnsAllOrders() { }

    [Fact]
    [Trait("Category", "Unit")]
    [Trait("Feature", "Orders")]
    public void CalculateOrderTotal_IsCorrect() { }
}

// Замість [Trait("Category", "Unit")] — чистіший синтаксис
public class UnitTestAttribute : TraitAttribute
{
    public UnitTestAttribute() : base("Category", "Unit") { }
}

public class IntegrationTestAttribute : TraitAttribute
{
    public IntegrationTestAttribute() : base("Category", "Integration") { }
}

// Використання
[Fact]
[UnitTest]
public void My_Unit_Test() { }

[Fact]
[IntegrationTest]
public async Task My_Integration_Test() { }

// Базова перевірка exception
[Fact]
public void Divide_ByZero_ThrowsDivideByZeroException()
{
    var calc = new Calculator();
    Assert.Throws<DivideByZeroException>(() => calc.Divide(5, 0));
}

// Отримання exception для детальної перевірки
[Fact]
public void RegisterUser_WithExistingEmail_ThrowsWithCorrectMessage()
{
    var service = new UserService();

    var exception = Assert.Throws<DuplicateEmailException>(
        () => service.Register("existing@email.com", "password"));

    Assert.Equal("User with this email already exists", exception.Message);
    Assert.Equal("existing@email.com", exception.Email);
}

// Async exceptions
[Fact]
public async Task CreateOrder_WithInvalidData_ThrowsValidationException()
{
    var service = new OrderService();

    await Assert.ThrowsAsync<ValidationException>(
        async () => await service.CreateAsync(new CreateOrderDto { Amount = -1 }));
}

// FluentAssertions — більш читабельно
[Fact]
public async Task CreateOrder_Fluent_ThrowsValidationException()
{
    var service = new OrderService();

    Func<Task> act = () => service.CreateAsync(new CreateOrderDto { Amount = -1 });

    await act.Should()
        .ThrowAsync<ValidationException>()
        .WithMessage("*amount*")
        .Where(ex => ex.Errors.Count > 0);
}

// Рівність
Assert.Equal(expected, actual);
Assert.NotEqual(notExpected, actual);

// Рівність з custom tolerance для чисел з плаваючою кропкою
Assert.Equal(3.14159, result, precision: 5); // 5 знаків після коми
Assert.Equal(3.14, result, tolerance: 0.005); // абсолютна різниця ≤ 0.005

// Null перевірки
Assert.Null(value);
Assert.NotNull(value);

// Boolean
Assert.True(condition);
Assert.False(condition);
Assert.True(condition, "Пояснення чому умова мала бути true");

// Порожня / непорожня
Assert.Empty(collection);
Assert.NotEmpty(collection);

// Наявність елементу
Assert.Contains(3, collection);
Assert.DoesNotContain(99, collection);

// Наявність за умовою
Assert.Contains(collection, item => item.IsActive);
Assert.DoesNotContain(collection, item => item.IsDeleted);

// Кількість елементів
Assert.Single(collection);     // рівно 1
Assert.Equal(5, collection.Count());

// Порядок (xUnit 2.5+)
Assert.All(collection, item => Assert.True(item.Price > 0));

// Перевірка типу
Assert.IsType<OrderDto>(result);
Assert.IsNotType<ErrorResponse>(result);

// Перевірка наслідування
Assert.IsAssignableFrom<IDisposable>(service);

// Конвертація з перевіркою
var dto = Assert.IsType<OrderDto>(result); // Повертає typed result
dto.Id.Should().NotBeEmpty(); // Далі можна використовувати typed

// Один і той самий об'єкт у пам'яті (reference equality)
Assert.Same(expectedObject, actualObject);
Assert.NotSame(object1, object2);

// Розширення для доменних об'єктів
public static class OrderAssertions
{
    public static void ShouldBeSuccessful(this Order order)
    {
        Assert.NotNull(order);
        Assert.Equal(OrderStatus.Confirmed, order.Status);
        Assert.NotEqual(Guid.Empty, order.Id);
        Assert.True(order.TotalAmount > 0, "Order total should be positive");
        Assert.NotEmpty(order.Items);
    }

    public static void ShouldBeRefunded(this Order order, decimal expectedRefund)
    {
        Assert.Equal(OrderStatus.Refunded, order.Status);
        Assert.Equal(expectedRefund, order.RefundAmount);
        Assert.NotNull(order.RefundedAt);
    }
}

// Використання у тестах
[Fact]
public async Task CreateOrder_WithValidData_ShouldSucceed()
{
    var order = await _service.CreateAsync(validDto);

    order.ShouldBeSuccessful(); // Один рядок замість 5 assertions
}

// З FluentAssertions: ще потужніший підхід
public class OrderAssertionExtensions
{
    public static AndConstraint<OrderAssertions> BeSuccessful(
        this ObjectAssertions assertions)
    {
        var order = assertions.Subject as Order;
        order.Should().NotBeNull();
        order!.Status.Should().Be(OrderStatus.Confirmed);
        order.Id.Should().NotBeEmpty();
        // ...
        return new AndConstraint<OrderAssertions>(new OrderAssertions(order));
    }
}

{
  "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",

  // Виведення назви методу або повного кваліфікованого імені
  "methodDisplay": "method",       // "method" або "classAndMethod"
  "methodDisplayOptions": "all",   // Перетворення назв методів

  // Паралелізм
  "parallelizeAssembly": true,
  "parallelizeTestCollections": true,
  "maxParallelThreads": -1,        // -1 = автоматично

  // Таймаути
  "longRunningTestSeconds": 5,     // Попередження для тестів > 5 секунд

  // Вивід
  "diagnosticMessages": false,     // true = більше деталей про runner

  // Відображення
  "preEnumerateTheories": true,    // Попередньо показати всі Theory iterations
  "stopOnFail": false              // true = зупинитись після першого провалу
}