NUnit и C#

// Пример теста в MSTest
[TestClass]
public class CalculatorTests
{
    [TestMethod]
    public void AddTest()
    {
        Assert.AreEqual(4, 2 + 2);
    }
}
 
// Тот же тест в NUnit
[TestFixture]
public class CalculatorTests
{
    [Test]
    public void AddTest()
    {
        Assert.AreEqual(4, 2 + 2);
    }
}
 
// И в xUnit
public class CalculatorTests
{
    [Fact]
    public void AddTest()
    {
        Assert.Equal(4, 2 + 2);
    }
}

Install-Package NUnit
Install-Package NUnit3TestAdapter

[Test]
public void DepositShouldIncreaseBalance()
{
    // Arrange - подготовка
    var account = new BankAccount(100);
    
    // Act - действие
    account.Deposit(50);
    
    // Assert - проверка
    Assert.AreEqual(150, account.Balance);
}

public class TestDiscoverer
{
    public IEnumerable<TestCase> DiscoverTests(Assembly assembly)
    {
        var testFixtures = assembly.GetTypes()
            .Where(t => t.GetCustomAttributes(typeof(TestFixtureAttribute), true).Any());
            
        foreach (var fixture in testFixtures)
        {
            var testMethods = fixture.GetMethods()
                .Where(m => m.GetCustomAttributes(typeof(TestAttribute), true).Any());
                
            foreach (var method in testMethods)
            {
                yield return new TestCase(fixture, method);
            }
        }
    }
}

[Test]
[Platform("Win")]
public void TestWindowsOnly()
{
    // Этот тест будет запущен только на Windows
}
 
[Test]
[Platform("Linux")]
public void TestLinuxOnly()
{
    // Этот тест будет запущен только на Linux
}

[Test]
[Culture("en-US")]
public void TestUSFormat()
{
    // Проверка форматирования для американской культуры
    Assert.AreEqual("1,234.56", 1234.56.ToString("N2"));
}
 
[Test]
[Culture("ru-RU")]
public void TestRussianFormat()
{
    // Проверка форматирования для русской культуры
    Assert.AreEqual("1 234,56", 1234.56.ToString("N2"));
}

[Test]
public void StringReverse_ShouldBeSymmetric()
{
    // Создаем генератор случайных строк
    var random = TestContext.CurrentContext.Random;
    
    // Генерируем случайную строку длиной до 100 символов
    string original = random.GetString(100);
    
    // Переворачиваем дважды - должны получить исходную строку
    string reversed = new string(original.Reverse().ToArray());
    string doubleReversed = new string(reversed.Reverse().ToArray());
    
    Assert.AreEqual(original, doubleReversed);
}

[Test]
[Order(1)]
public void FirstTest()
{
    // Этот тест будет выполнен первым
}
 
[Test]
[Order(2)]
public void SecondTest()
{
    // Этот тест будет выполнен вторым
}

[TestFixture]
public class CalculatorTests
{
    private Calculator _calculator;
    
    [SetUp]
    public void Initialize()
    {
        _calculator = new Calculator();
    }
    
    [Test]
    public void Add_ShouldReturnCorrectSum()
    {
        var result = _calculator.Add(5, 3);
        Assert.AreEqual(8, result);
    }
    
    [TearDown]
    public void Cleanup()
    {
        _calculator.Dispose();
    }
}

[TestFixture]
public class DatabaseTests
{
    private static DbConnection _connection;
    
    [OneTimeSetUp]
    public static void InitializeDatabase()
    {
        // Создаем подключение к БД один раз для всех тестов
        _connection = new DbConnection("connection_string");
        _connection.Open();
    }
    
    [Test]
    public void GetUser_ShouldReturnCorrectUser()
    {
        var repo = new UserRepository(_connection);
        var user = repo.GetById(1);
        Assert.IsNotNull(user);
        Assert.AreEqual("admin", user.Username);
    }
    
    [OneTimeTearDown]
    public static void CloseDatabase()
    {
        // Закрываем подключение после всех тестов
        _connection.Close();
        _connection.Dispose();
    }
}

[Test]
[Ignore("API для этой функции изменится в следуюшем спринте")]
public void SomeFeatureTest()
{
    // Этот тест не будет выполнен
}

[Test]
public void Collection_ShouldContainExpectedElements()
{
    var numbers = new List<int> { 1, 2, 3, 4, 5 };
    
    // Проверка коллекции на несколько условий
    CollectionAssert.AllItemsAreNotNull(numbers);
    CollectionAssert.AllItemsAreUnique(numbers);
    CollectionAssert.Contains(numbers, 3);
    
    // Или с помощью ограничений (constraints)
    Assert.That(numbers, Has.Count.EqualTo(5));
    Assert.That(numbers, Has.Member(3));
    Assert.That(numbers, Is.Ordered);
}

[Test]
public void String_ShouldMatchExpectedPattern()
{
    string email = "user@example.com";
    
    // Проверка с использованием ограничений
    Assert.That(email, Is.Not.Null);
    Assert.That(email, Does.Contain("@"));
    Assert.That(email, Does.Match(@".+@.+\..+"));
}

[Test]
public void DivideByZero_ShouldThrowException()
{
    var calculator = new Calculator();
    
    // Проверка на выброс исключения
    Assert.Throws<DivideByZeroException>(() => calculator.Divide(10, 0));
    
    // Более сложная проверка с доступом к объекту исключения
    var ex = Assert.Throws<ArgumentException>(() => calculator.SquareRoot(-1));
    StringAssert.Contains("Отрицательное число", ex.Message);
}

[Test]
[TestCase(5, 3, 8)]
[TestCase(0, 0, 0)]
[TestCase(-5, 5, 0)]
[TestCase(int.MaxValue, 1, int.MinValue)] // Переполнение
public void Add_ShouldReturnCorrectSum(int a, int b, int expectedSum)
{
    var calculator = new Calculator();
    var result = calculator.Add(a, b);
    Assert.AreEqual(expectedSum, result);
}

public static IEnumerable<TestCaseData> AddTestCases
{
    get
    {
        yield return new TestCaseData(5, 3).Returns(8).SetName("Positive numbers");
        yield return new TestCaseData(0, 0).Returns(0).SetName("Zeros");
        yield return new TestCaseData(-5, 5).Returns(0).SetName("Mixed signs");
    }
}
 
[Test]
[TestCaseSource(nameof(AddTestCases))]
public int Add_ShouldReturnCorrectSum(int a, int b)
{
    var calculator = new Calculator();
    return calculator.Add(a, b);
}

[Test]
[Category("Integration")]
public void DatabaseTest()
{
    // Тест, требующий доступа к базе данных
}
 
[Test]
[Category("Unit")]
public void CalculationTest()
{
    // Изолированный модульный тест
}

[TestFixture]
public abstract class StorageTests
{
    protected IStorage Storage;
    
    [SetUp]
    public virtual void Initialize()
    {
        // Общая инициализация
    }
    
    [Test]
    public void Get_ShouldReturnStoredValue()
    {
        Storage.Set("key", "value");
        Assert.AreEqual("value", Storage.Get("key"));
    }
}
 
[TestFixture]
public class FileStorageTests : StorageTests
{
    [SetUp]
    public override void Initialize()
    {
        base.Initialize();
        Storage = new FileStorage("test.dat");
    }
}
 
[TestFixture]
public class MemoryStorageTests : StorageTests
{
    [SetUp]
    public override void Initialize()
    {
        base.Initialize();
        Storage = new MemoryStorage();
    }
}

[TestFixture]
public abstract class SortingAlgorithmTests
{
    protected abstract IList<int> Sort(IList<int> input);
    protected abstract string AlgorithmName { get; }
    
    [Test]
    public void Sort_EmptyArray_ReturnsEmptyArray()
    {
        var result = Sort(new List<int>());
        Assert.That(result, Is.Empty);
    }
    
    [Test]
    public void Sort_SingleElement_ReturnsSameElement()
    {
        var result = Sort(new List<int> { 42 });
        Assert.That(result, Has.Count.EqualTo(1));
        Assert.That(result[0], Is.EqualTo(42));
    }
    
    [Test]
    [TestCase(new[] { 3, 1, 4, 1, 5 }, new[] { 1, 1, 3, 4, 5 })]
    [TestCase(new[] { -5, 0, 5 }, new[] { -5, 0, 5 })]
    [TestCase(new[] { 9, 8, 7, 6 }, new[] { 6, 7, 8, 9 })]
    public void Sort_MultipleElements_ReturnsOrderedArray(int[] input, int[] expected)
    {
        var result = Sort(input.ToList());
        Assert.That(result, Is.EqualTo(expected));
    }
}
 
[TestFixture]
public class QuickSortTests : SortingAlgorithmTests
{
    protected override IList<int> Sort(IList<int> input)
    {
        return new QuickSort().Sort(input);
    }
    
    protected override string AlgorithmName => "QuickSort";
}
 
[TestFixture]
public class BubbleSortTests : SortingAlgorithmTests
{
    protected override IList<int> Sort(IList<int> input)
    {
        return new BubbleSort().Sort(input);
    }
    
    protected override string AlgorithmName => "BubbleSort";
}

[TestFixture, Apartment(ApartmentState.STA)]
public class UIThreadTests
{
    [Test]
    public void SomeUIOperation_ShouldNotCrash()
    {
        // Этот тест выполняется в отдельном STA-потоке,
        // что необходимо для работы с UI-компонентами
    }
}

[Test]
[Timeout(1000)] // Тест не должен выполняться дольше 1 секунды
public void LongOperation_ShouldCompleteQuickly()
{
    var calculator = new Calculator();
    calculator.CalculateFactorial(10);
}

public interface ITimeProvider
{
    DateTime Now { get; }
    Task Delay(TimeSpan delay, CancellationToken token = default);
}
 
public class SystemTimeProvider : ITimeProvider
{
    public DateTime Now => DateTime.Now;
    public Task Delay(TimeSpan delay, CancellationToken token = default) => Task.Delay(delay, token);
}
 
public class FakeTimeProvider : ITimeProvider
{
    private DateTime _currentTime = DateTime.Now;
    
    public DateTime Now => _currentTime;
    
    public void AdvanceTime(TimeSpan timeSpan)
    {
        _currentTime += timeSpan;
    }
    
    public Task Delay(TimeSpan delay, CancellationToken token = default)
    {
        // Возвращаем уже завершенную задачу вместо реального ожидания
        return Task.CompletedTask;
    }
}

[Test]
public async Task ExpirationChecker_ShouldIdentifyExpiredItems()
{
    // Arrange
    var fakeTime = new FakeTimeProvider();
    var checker = new ExpirationChecker(fakeTime);
    var item = new ExpiringItem { ExpiresAt = fakeTime.Now.AddHours(1) };
    
    // Act & Assert
    Assert.IsFalse(checker.IsExpired(item));
    
    // Перематываем время на 2 часа вперед
    fakeTime.AdvanceTime(TimeSpan.FromHours(2));
    
    Assert.IsTrue(checker.IsExpired(item));
}

[Test]
public void FormatTime_ShouldRespectTimeZone()
{
    // Создаем форматтер с явным указанием часового пояса
    var formatter = new TimeFormatter(TimeZoneInfo.FindSystemTimeZoneById("UTC"));
    
    // Создаем фиксированное время для теста
    var fixedTime = new DateTime(2023, 1, 1, 12, 0, 0, DateTimeKind.Utc);
    
    Assert.AreEqual("12:00 PM", formatter.Format(fixedTime));
}

[TestFixture]
public abstract class CacheTests
{
    protected abstract ICache CreateCache();
    
    [Test]
    public void Get_NonExistentKey_ReturnsNull()
    {
        var cache = CreateCache();
        Assert.IsNull(cache.Get("nonexistent"));
    }
    
    [Test]
    public void Set_NewKey_StoresValue()
    {
        var cache = CreateCache();
        cache.Set("key", "value");
        Assert.AreEqual("value", cache.Get("key"));
    }
}
 
[TestFixture]
public class MemoryCacheTests : CacheTests
{
    protected override ICache CreateCache()
    {
        return new MemoryCache();
    }
    
    // Дополнительные тесты, специфичные для MemoryCache
}
 
[TestFixture]
public class RedisCacheTests : CacheTests
{
    protected override ICache CreateCache()
    {
        return new RedisCache("localhost:6379");
    }
    
    // Дополнительные тесты, специфичные для RedisCache
}

[Test]
[Combinatorial]
public void TestOperation(
    [Values(1, 2, 3)] int x,
    [Values("a", "b")] string y,
    [Values(true, false)] bool flag)
{
    // Этот тест запустится 12 раз с разными комбинациями параметров
    // (3 значения x * 2 значения y * 2 значения flag)
}

[Test]
[Pairwise]
public void TestWithManyParameters(
    [Values(1, 2, 3, 4)] int a,
    [Values(1, 2, 3, 4)] int b,
    [Values(1, 2, 3, 4)] int c,
    [Values(1, 2, 3, 4)] int d)
{
    // Вместо 4^4 = 256 тестов, запустится значительно меньше,
    // но при этом все пары значений будут протестированы
}

[Test]
public async Task AsyncOperation_ShouldReturnCorrectResult()
{
    // Arrange
    var service = new DataService();
    
    // Act
    var result = await service.GetDataAsync();
    
    // Assert
    Assert.IsNotNull(result);
    Assert.That(result.Items, Has.Count.GreaterThan(0));
}

[Test]
public void AsyncOperation_ShouldRespectCancellation()
{
    // Arrange
    var service = new DataService();
    using var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(50));
    
    // Act & Assert
    Assert.ThrowsAsync<OperationCanceledException>(async () => 
        await service.LongRunningOperationAsync(cts.Token));
}

[Test]
public void UserService_GetUser_ShouldReturnUserFromRepository()
{
    // Arrange
    var mockRepo = new Mock<IUserRepository>();
    mockRepo.Setup(repo => repo.GetById(1))
            .Returns(new User { Id = 1, Name = "Admin" });
            
    var service = new UserService(mockRepo.Object);
    
    // Act
    var user = service.GetUser(1);
    
    // Assert
    Assert.IsNotNull(user);
    Assert.AreEqual("Admin", user.Name);
    mockRepo.Verify(repo => repo.GetById(1), Times.Once);
}

public class UserRepositoryMockBuilder
{
    private readonly Mock<IUserRepository> _mock = new Mock<IUserRepository>();
    
    public UserRepositoryMockBuilder WithUser(int id, string name)
    {
        _mock.Setup(repo => repo.GetById(id))
             .Returns(new User { Id = id, Name = name });
        return this;
    }
    
    public UserRepositoryMockBuilder WithException(int id)
    {
        _mock.Setup(repo => repo.GetById(id))
             .Throws<NotFoundException>();
        return this;
    }
    
    public IUserRepository Build()
    {
        return _mock.Object;
    }
}
 
[Test]
public void UserService_GetUser_ShouldThrowWhenUserNotFound()
{
    // Arrange
    var repository = new UserRepositoryMockBuilder()
        .WithException(1)
        .Build();
        
    var service = new UserService(repository);
    
    // Act & Assert
    Assert.Throws<UserNotFoundException>(() => service.GetUser(1));
}

[AttributeUsage(AttributeTargets.Method)]
public class DatabaseSetupAttribute : NUnit.Framework.Attributes.PropertyAttribute
{
    public string ConnectionString { get; }
    public string ScriptPath { get; }
    
    public DatabaseSetupAttribute(string connectionString, string scriptPath)
    {
        ConnectionString = connectionString;
        ScriptPath = scriptPath;
    }
}
 
public class DatabaseSetupActionAttribute : TestActionAttribute
{
    public override void BeforeTest(ITest test)
    {
        var attribute = test.Method.GetCustomAttributes<DatabaseSetupAttribute>(true).FirstOrDefault();
        if (attribute != null)
        {
            // Выполняем скрипт перед тестом
            using var connection = new SqlConnection(attribute.ConnectionString);
            connection.Open();
            var script = File.ReadAllText(attribute.ScriptPath);
            using var command = new SqlCommand(script, connection);
            command.ExecuteNonQuery();
        }
    }
    
    public override void AfterTest(ITest test)
    {
        // Очистка после теста
    }
}
 
[Test]
[DatabaseSetup("Data Source=test.db", "Scripts/SetupUser.sql")]
public void Database_ShouldContainUser()
{
    using var connection = new SqlConnection("Data Source=test.db");
    connection.Open();
    using var command = new SqlCommand("SELECT COUNT(*) FROM Users WHERE Username = 'admin'", connection);
    var count = (int)command.ExecuteScalar();
    Assert.AreEqual(1, count);
}

[TestFixture]
[Parallelizable(ParallelScope.Children)]
public class ParallelTests
{
    [Test]
    public async Task Test1()
    {
        await Task.Delay(1000);
        Assert.Pass();
    }
    
    [Test]
    public async Task Test2()
    {
        await Task.Delay(1000);
        Assert.Pass();
    }
    
    [Test]
    [Parallelizable(ParallelScope.None)] // Этот тест не будет выполняться параллельно
    public void NonParallelTest()
    {
        Thread.Sleep(1000);
        Assert.Pass();
    }
}

[Test]
public void ValidateData_WithNestedErrors_ShouldThrowWithCorrectInnerException()
{
    var validator = new DataValidator();
    
    // Проверка вложенного исключения
    var ex = Assert.Throws<ValidationException>(() => validator.ValidateComplex(null));
    Assert.IsInstanceOf<ArgumentNullException>(ex.InnerException);
    Assert.That(ex.InnerException.Message, Does.Contain("Value cannot be null"));
}

[Theory]
public void SquareRoot_ShouldWorkForAnyPositiveNumber(
    [Range(1, 100, 5)] double input)
{
    var result = Math.Sqrt(input);
    Assert.That(result * result, Is.EqualTo(input).Within(0.00001));
}

[Test]
[Retry(3)] // Попытаться запустить до 3 раз в случае неудачи
public async Task ExternalApi_ShouldReturnValidResponse()
{
    var client = new HttpClient();
    var response = await client.GetAsync("https://api.example.com/data");
    Assert.That(response.IsSuccessStatusCode);
}

[Test]
[MaxTime(500)] // Максимальное время выполнения - 500 мс
public void Operation_ShouldBePerformedQuickly()
{
    var processor = new DataProcessor();
    processor.ProcessData(largeDataSet);
}

[Test]
[TestCaseSource(typeof(TestDataProvider), nameof(TestDataProvider.LoadFromCsv))]
public void ProcessCustomer_ShouldCalculateCorrectDiscount(
    Customer customer, decimal expectedDiscount)
{
    var service = new DiscountService();
    var discount = service.CalculateDiscount(customer);
    Assert.AreEqual(expectedDiscount, discount);
}
 
public static class TestDataProvider
{
    public static IEnumerable<TestCaseData> LoadFromCsv()
    {
        using var reader = new StreamReader("TestData/customers.csv");
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            var parts = line.Split(',');
            var customer = new Customer
            {
                Id = int.Parse(parts[0]),
                Name = parts[1],
                PurchaseAmount = decimal.Parse(parts[2])
            };
            var expectedDiscount = decimal.Parse(parts[3]);
            
            yield return new TestCaseData(customer, expectedDiscount)
                .SetName($"Customer {customer.Id}: {customer.Name}");
        }
    }
}

[Test]
public void ComplexOperation_ShouldLogProgress()
{
    var processor = new DataProcessor();
    
    TestContext.WriteLine("Starting data processing test");
    processor.OnProgress += (sender, progress) => 
        TestContext.WriteLine($"Progress: {progress}%");
    
    processor.ProcessData(largeDataSet);
    
    TestContext.WriteLine("Processing completed");
    Assert.That(processor.IsComplete);
}

[Test]
public void SearchAlgorithm_ShouldBeEfficient()
{
    var searcher = new Searcher();
    var largeArray = Enumerable.Range(1, 1000000).ToArray();
    
    // Выполняем поиск несколько раз для более точных измерений
    var stopwatch = new Stopwatch();
    stopwatch.Start();
    
    for (int i = 0; i < 100; i++)
    {
        searcher.Find(largeArray, 500000);
    }
    
    stopwatch.Stop();
    
    TestContext.WriteLine($"Search time: {stopwatch.ElapsedMilliseconds} ms");
    Assert.That(stopwatch.ElapsedMilliseconds, Is.LessThan(200));
}

public enum TestLevel
{
    Unit,
    Integration,
    System
}
 
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
public class TestLevelAttribute : PropertyAttribute
{
    public TestLevelAttribute(TestLevel level) 
        : base("Level", level) { }
}
 
[Test]
[TestLevel(TestLevel.Unit)]
public void SimpleCalculation_ShouldReturnCorrectResult()
{
    // Чистый модульный тест
}
 
[Test]
[TestLevel(TestLevel.Integration)]
public void DatabaseOperation_ShouldPersistData()
{
    // Интеграционный тест, требующий базу данных
}

[TestFixture]
public class TestSuite
{
    [TestCase("filter=cat==UnitTest")]
    public void RunSelectedTests(string filter)
    {
        var runner = new NUnitTestAssemblyRunner(new DefaultTestAssemblyBuilder());
        runner.Load(Assembly.GetExecutingAssembly(), new Dictionary<string, object>());
        
        var filterService = new TestFilterService();
        var testFilter = filterService.MakeTestFilter(filter);
        
        var result = runner.Run(null, testFilter);
        
        Console.WriteLine($"Passed: {result.PassCount}, Failed: {result.FailCount}");
    }
}

[TestFixture]
public class DiscountServiceTests
{
    private DiscountService _service;
    private Mock<IProductRepository> _repositoryMock;
 
    [SetUp]
    public void Setup()
    {
        _repositoryMock = new Mock<IProductRepository>();
        _service = new DiscountService(_repositoryMock.Object);
    }
 
    [Test]
    [TestCase(999, 0.0)]        // До 1000 - нет скидки
    [TestCase(1000, 0.05)]      // От 1000 до 1999 - 5%
    [TestCase(1999, 0.05)]
    [TestCase(2000, 0.1)]       // От 2000 до 4999 - 10%
    [TestCase(4999, 0.1)]
    [TestCase(5000, 0.5)]       // От 5000 до 19999 - 50%
    [TestCase(19999, 0.5)]
    [TestCase(20000, 0.0)]      // От 20000 - нет скидки (спец. условие)
    public void CalculateDiscount_BasedOnAmount_ReturnsCorrectPercentage(
        double salesAmount, double expectedDiscountRate)
    {
        // Act
        double actualDiscountRate = _service.CalculateDiscountRate(salesAmount);
 
        // Assert
        Assert.AreEqual(expectedDiscountRate, actualDiscountRate, 0.001);
    }
 
    [Test]
    public void CalculateDiscount_NegativeAmount_ThrowsArgumentException()
    {
        // Assert
        Assert.Throws<ArgumentException>(() => _service.CalculateDiscountRate(-100));
    }
}

[TestFixture]
public class ProductControllerTests
{
    private ProductController _controller;
    private Mock<IProductService> _serviceMock;
 
    [SetUp]
    public void Setup()
    {
        _serviceMock = new Mock<IProductService>();
        _controller = new ProductController(_serviceMock.Object);
    }
 
    [Test]
    public async Task GetProducts_ReturnsOkWithProducts()
    {
        // Arrange
        var products = new List<Product>
        {
            new Product { Id = 1, Name = "Product1", Price = 10.99m },
            new Product { Id = 2, Name = "Product2", Price = 20.99m }
        };
        _serviceMock.Setup(s => s.GetAllAsync()).ReturnsAsync(products);
 
        // Act
        var result = await _controller.GetProducts();
 
        // Assert
        var okResult = result as OkObjectResult;
        Assert.IsNotNull(okResult);
        var returnedProducts = okResult.Value as List<Product>;
        Assert.IsNotNull(returnedProducts);
        Assert.AreEqual(2, returnedProducts.Count);
    }
}

[TestFixture]
public class ConcurrentAccessTests
{
    private TestServer _server;
    private HttpClient _client;
    private DbContextOptions<AppDbContext> _dbOptions;
 
    [OneTimeSetUp]
    public void InitializeServer()
    {
        // Настройка тестового сервера и БД
        _dbOptions = new DbContextOptionsBuilder<AppDbContext>()
            .UseInMemoryDatabase("TestDb")
            .Options;
            
        // Заполняем тестовыми данными
        using (var context = new AppDbContext(_dbOptions))
        {
            context.Products.Add(new Product { Id = 1, Name = "Test", Stock = 10 });
            context.SaveChanges();
        }
            
        var webHostBuilder = new WebHostBuilder()
            .UseStartup<TestStartup>()
            .ConfigureServices(services => 
            {
                services.AddDbContext<AppDbContext>(options => 
                    options.UseInMemoryDatabase("TestDb"));
            });
            
        _server = new TestServer(webHostBuilder);
        _client = _server.CreateClient();
    }
 
    [Test]
    public async Task PurchaseProduct_ConcurrentAccess_ManagesStockCorrectly()
    {
        // Пять одновременных запросов на покупку 3 единиц товара
        // (всего в наличии 10, должно быть обработано не более 3 запросов)
        var tasks = Enumerable.Range(0, 5)
            .Select(_ => _client.PostAsync("/api/purchase", 
                new StringContent(
                    JsonConvert.SerializeObject(new { ProductId = 1, Quantity = 3 }),
                    Encoding.UTF8, 
                    "application/json")))
            .ToArray();
            
        await Task.WhenAll(tasks);
        
        // Проверяем результаты
        int successCount = tasks.Count(t => t.Result.IsSuccessStatusCode);
        
        // Проверяем остаток на складе
        using (var context = new AppDbContext(_dbOptions))
        {
            var product = await context.Products.FindAsync(1);
            Assert.IsNotNull(product);
            Assert.AreEqual(1, product.Stock); // 10 - (3*3) = 1
            Assert.AreEqual(3, successCount); // Только 3 запроса успешны
        }
    }
    
    [OneTimeTearDown]
    public void CleanupServer()
    {
        _client.Dispose();
        _server.Dispose();
    }
}

[TestFixture]
public class PerformanceTests
{
    [Test]
    [Category("Performance")]
    public void SearchAlgorithm_LargeDataset_PerformsWithinThreshold()
    {
        // Arrange
        var dataSet = GenerateLargeDataSet(1000000);
        var searchEngine = new SearchEngine();
        var query = "specific rare term";
        
        // Act
        var sw = Stopwatch.StartNew();
        var results = searchEngine.Search(dataSet, query);
        sw.Stop();
        
        // Assert
        Assert.That(sw.ElapsedMilliseconds, Is.LessThan(100));
        TestContext.WriteLine($"Search completed in {sw.ElapsedMilliseconds}ms");
    }
    
    private List<Document> GenerateLargeDataSet(int count)
    {
        // Генерация тестовых данных
        return Enumerable.Range(0, count)
            .Select(i => new Document 
            { 
                Id = i, 
                Content = $"Document {i} content with some random words {(i % 1000 == 0 ? "specific rare term" : "")}" 
            })
            .ToList();
    }
}

[TestFixture]
public class OrderProcessingIntegrationTests
{
    private TestMessageBus _messageBus;
    private OrderService _orderService;
    private PaymentServiceMock _paymentService;
    private DeliveryServiceMock _deliveryService;
 
    [SetUp]
    public void Setup()
    {
        _messageBus = new TestMessageBus();
        _paymentService = new PaymentServiceMock(_messageBus);
        _deliveryService = new DeliveryServiceMock(_messageBus);
        _orderService = new OrderService(_messageBus);
        
        // Регистрируем все сервисы на шине сообщений
        _messageBus.RegisterHandler<PaymentRequestMessage>(_paymentService.HandlePayment);
        _messageBus.RegisterHandler<DeliveryRequestMessage>(_deliveryService.HandleDelivery);
        _messageBus.RegisterHandler<PaymentCompletedMessage>(_orderService.HandlePaymentCompleted);
    }
 
    [Test]
    public async Task OrderProcessing_HappyPath_CompletesSuccessfully()
    {
        // Arrange
        var order = new Order
        {
            Id = Guid.NewGuid(),
            CustomerId = "customer1",
            Items = new List<OrderItem>
            {
                new OrderItem { ProductId = "product1", Quantity = 2, Price = 10.99m }
            },
            TotalAmount = 21.98m
        };
 
        // Act
        await _orderService.ProcessOrder(order);
        
        // Даем время на обработку всех сообщений
        await Task.Delay(100);
 
        // Assert
        Assert.AreEqual(OrderStatus.Completed, order.Status);
        Assert.IsTrue(_paymentService.ProcessedOrders.Contains(order.Id));
        Assert.IsTrue(_deliveryService.ProcessedOrders.Contains(order.Id));
    }
 
    [Test]
    public async Task OrderProcessing_PaymentFails_OrderIsCancelled()
    {
        // Arrange
        var order = new Order
        {
            Id = Guid.NewGuid(),
            CustomerId = "customer2",  // Этот клиент будет иметь проблемы с оплатой
            Items = new List<OrderItem>
            {
                new OrderItem { ProductId = "product1", Quantity = 2, Price = 10.99m }
            },
            TotalAmount = 21.98m
        };
        
        _paymentService.SetFailForCustomer("customer2");
 
        // Act
        await _orderService.ProcessOrder(order);
        
        // Даем время на обработку всех сообщений
        await Task.Delay(100);
 
        // Assert
        Assert.AreEqual(OrderStatus.Cancelled, order.Status);
        Assert.IsTrue(_paymentService.ProcessedOrders.Contains(order.Id));
        Assert.IsFalse(_deliveryService.ProcessedOrders.Contains(order.Id));
    }
}

[TestFixture]
public class BigDataProcessingTests
{
    private DataProcessor _processor;
    private string _testDataPath;
 
    [OneTimeSetUp]
    public void GlobalSetup()
    {
        // Подготавливаем тестовые данные (скачиваем, распаковываем)
        _testDataPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
        Directory.CreateDirectory(_testDataPath);
        
        // Копируем тестовые данные из ресурсов
        ExtractTestDataset(_testDataPath);
        
        _processor = new DataProcessor();
    }
 
    [Test]
    [Category("BigData")]
    public void ProcessLargeDataset_ProducesCorrectResults()
    {
        // Arrange
        var inputFile = Path.Combine(_testDataPath, "sales_data.csv");
        var outputFile = Path.Combine(_testDataPath, "results.json");
        
        // Act
        var result = _processor.ProcessFile(inputFile, outputFile);
        
        // Assert
        Assert.IsTrue(result.Success);
        Assert.That(result.ProcessedRecords, Is.GreaterThan(10000));
        
        // Проверяем результаты обработки
        var processedData = JsonConvert.DeserializeObject<ProcessingResult>(
            File.ReadAllText(outputFile));
            
        Assert.AreEqual(1250345.67m, processedData.TotalSales, 0.01m);
        Assert.AreEqual(432, processedData.UniqueCustomers);
    }
    
    [OneTimeTearDown]
    public void GlobalCleanup()
    {
        // Удаляем временные данные
        if (Directory.Exists(_testDataPath))
            Directory.Delete(_testDataPath, true);
    }
    
    private void ExtractTestDataset(string targetPath)
    {
        // Код извлечения тестовых данных из ресурсов сборки
    }
}

[TestFixture]
public class SchedulerTests
{
    private Scheduler _scheduler;
    private MockTimeProvider _timeProvider;
 
    [SetUp]
    public void Setup()
    {
        _timeProvider = new MockTimeProvider(new DateTime(2023, 1, 1, 12, 0, 0));
        _scheduler = new Scheduler(_timeProvider);
    }
 
    [Test]
    public void DailyTask_ShouldRunOncePerDay()
    {
        // Arrange
        int executionCount = 0;
        _scheduler.ScheduleDaily("12:30", () => executionCount++);
        
        // Act - имитируем течение времени
        // Проверяем 12:29 - задача не должна выполниться
        _timeProvider.SetCurrentTime(new DateTime(2023, 1, 1, 12, 29, 0));
        _scheduler.CheckSchedule();
        Assert.AreEqual(0, executionCount);
        
        // Проверяем 12:30 - задача должна выполниться
        _timeProvider.SetCurrentTime(new DateTime(2023, 1, 1, 12, 30, 0));
        _scheduler.CheckSchedule();
        Assert.AreEqual(1, executionCount);
        
        // Проверяем 12:31 - задача не должна выполниться повторно
        _timeProvider.SetCurrentTime(new DateTime(2023, 1, 1, 12, 31, 0));
        _scheduler.CheckSchedule();
        Assert.AreEqual(1, executionCount);
        
        // Переходим на следующий день - задача должна выполниться снова
        _timeProvider.SetCurrentTime(new DateTime(2023, 1, 2, 12, 30, 0));
        _scheduler.CheckSchedule();
        Assert.AreEqual(2, executionCount);
    }
}

[TestFixture]
public class MainWindowTests
{
    private Application _application;
    private Window _mainWindow;
 
    [SetUp]
    public void Setup()
    {
        // Запускаем тестируемое приложение
        _application = Application.Launch("MyApp.exe");
        _mainWindow = _application.GetWindow("Main Window", InitializeOption.NoCache);
    }
 
    [Test]
    public void CalculateButton_WhenClicked_DisplaysResult()
    {
        // Arrange
        var num1TextBox = _mainWindow.Get<TextBox>("Num1TextBox");
        var num2TextBox = _mainWindow.Get<TextBox>("Num2TextBox");
        var calculateButton = _mainWindow.Get<Button>("CalculateButton");
        var resultLabel = _mainWindow.Get<Label>("ResultLabel");
        
        // Act
        num1TextBox.Text = "5";
        num2TextBox.Text = "7";
        calculateButton.Click();
        
        // Assert
        Assert.AreEqual("Результат: 12", resultLabel.Text);
    }
 
    [TearDown]
    public void TearDown()
    {
        // Закрываем приложение после тестов
        if (_application != null)
            _application.Close();
    }
}