xUnit Shared Fixture Trap — Local Pass, CI Fail

// First, add Moq to the test project:
// dotnet add OrderProcessing.Tests package Moq

// ─── OrderProcessing.Core/IEmailService.cs ───
namespace OrderProcessing.Core
{
    public interface IEmailService
    {
        // Sends a confirmation to the given address and returns true on success
        bool SendOrderConfirmation(string recipientEmail, int orderId);
    }
}

// ─── OrderProcessing.Core/OrderService.cs ───
namespace OrderProcessing.Core
{
    public class OrderService
    {
        private readonly IEmailService _emailService;
        private readonly OrderCalculator _calculator;

        // Dependencies injected through constructor — this is what makes mocking possible
        public OrderService(IEmailService emailService, OrderCalculator calculator)
        {
            _emailService = emailService;
            _calculator = calculator;
        }

        // Places an order, calculates final price, and sends a confirmation email
        // Returns the final order total, or throws if email fails
        public decimal PlaceOrder(string customerEmail, decimal subtotal, decimal discountPercent)
        {
            if (string.IsNullOrWhiteSpace(customerEmail))
                throw new ArgumentException("Customer email is required.", nameof(customerEmail));

            decimal finalTotal = _calculator.CalculateTotal(subtotal, discountPercent);

            // Generate a deterministic order ID (simplified for the example)
            int orderId = Math.Abs(customerEmail.GetHashCode() % 100000);

            bool emailSent = _emailService.SendOrderConfirmation(customerEmail, orderId);

            if (!emailSent)
                throw new InvalidOperationException("Order confirmation email could not be sent.");

            return finalTotal;
        }
    }
}

// ─── OrderProcessing.Tests/OrderServiceTests.cs ───
using Xunit;
using Moq;
using OrderProcessing.Core;

namespace OrderProcessing.Tests
{
    public class OrderServiceTests
    {
        // Moq creates a fake IEmailService — no real emails, no SMTP server needed
        private readonly Mock<IEmailService> _mockEmailService;
        private readonly OrderService _orderService;

        public OrderServiceTests()
        {
            _mockEmailService = new Mock<IEmailService>();
            var calculator = new OrderCalculator(); // real calculator — no need to mock pure math

            // Inject the MOCK email service into OrderService
            _orderService = new OrderService(_mockEmailService.Object, calculator);
        }

        [Fact]
        public void PlaceOrder_WhenEmailSucceeds_ReturnsFinalTotal()
        {
            // Arrange: script the fake email service to succeed for ANY string and int
            _mockEmailService
                .Setup(emailSvc => emailSvc.SendOrderConfirmation(
                    It.IsAny<string>(),   // match any email address
                    It.IsAny<int>()))     // match any order ID
                .Returns(true);           // always say 'yes, email was sent'

            // Act: place a real order through the real OrderService
            decimal finalTotal = _orderService.PlaceOrder(
                customerEmail: "alice@example.com",
                subtotal: 150.00m,
                discountPercent: 10m
            );

            // Assert 1: the math came out right (10% off 150 = 135)
            Assert.Equal(135.00m, finalTotal);

            // Assert 2: verify the email service was called exactly once
            // This proves we didn't forget to send the confirmation
            _mockEmailService.Verify(
                emailSvc => emailSvc.SendOrderConfirmation(
                    "alice@example.com",   // must be this exact address
                    It.IsAny<int>()),      // any order ID is fine
                Times.Once()              // called exactly once — not zero, not twice
            );
        }

        [Fact]
        public void PlaceOrder_WhenEmailServiceFails_ThrowsInvalidOperationException()
        {
            // Arrange: script the fake email service to FAIL
            _mockEmailService
                .Setup(emailSvc => emailSvc.SendOrderConfirmation(
                    It.IsAny<string>(),
                    It.IsAny<int>()))
                .Returns(false); // simulate an SMTP outage

            // Act + Assert: placing the order should throw because email failed
            var exception = Assert.Throws<InvalidOperationException>(
                () => _orderService.PlaceOrder("bob@example.com", 200.00m, 0m)
            );

            Assert.Contains("confirmation email", exception.Message);
        }

        [Fact]
        public void PlaceOrder_WhenEmailIsEmpty_ThrowsArgumentException_BeforeCallingEmailService()
        {
            // Act + Assert: an empty email should fail immediately
            Assert.Throws<ArgumentException>(
                () => _orderService.PlaceOrder("", 100.00m, 0m)
            );

            // Verify the email service was NEVER called — we should have thrown before reaching it
            _mockEmailService.Verify(
                emailSvc => emailSvc.SendOrderConfirmation(
                    It.IsAny<string>(),
                    It.IsAny<int>()),
                Times.Never() // this line proves our guard clause fired correctly
            );
        }
    }
}

// dotnet add OrderProcessing.Tests package Microsoft.EntityFrameworkCore.InMemory

// ─── OrderProcessing.Core/Order.cs ───
namespace OrderProcessing.Core
{
    public class Order
    {
        public int Id { get; set; }
        public string CustomerEmail { get; set; } = string.Empty;
        public decimal Total { get; set; }
        public DateTime PlacedAt { get; set; }
    }
}

// ─── OrderProcessing.Core/AppDbContext.cs ───
using Microsoft.EntityFrameworkCore;

namespace OrderProcessing.Core
{
    public class AppDbContext : DbContext
    {
        public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
        public DbSet<Order> Orders => Set<Order>();
    }
}

// ─── OrderProcessing.Tests/DatabaseFixture.cs ───
// This class is created ONCE and shared across all tests in OrderRepositoryTests
using Microsoft.EntityFrameworkCore;
using OrderProcessing.Core;

namespace OrderProcessing.Tests
{
    public class DatabaseFixture : IDisposable
    {
        public AppDbContext Context { get; }

        public DatabaseFixture()
        {
            // Build an in-memory database — fast, isolated, no file system needed
            var options = new DbContextOptionsBuilder<AppDbContext>()
                .UseInMemoryDatabase(databaseName: "OrderTests_" + Guid.NewGuid()) // unique name prevents bleed-over
                .Options;

            Context = new AppDbContext(options);

            // Seed with known data that tests can rely on
            Context.Orders.AddRange(
                new Order { Id = 1, CustomerEmail = "alice@example.com", Total = 99.99m, PlacedAt = DateTime.UtcNow },
                new Order { Id = 2, CustomerEmail = "bob@example.com",   Total = 249.00m, PlacedAt = DateTime.UtcNow }
            );
            Context.SaveChanges();
        }

        // Called automatically by xUnit after all tests in the class have run
        public void Dispose()
        {
            Context.Database.EnsureDeleted(); // clean up the in-memory database
            Context.Dispose();
        }
    }
}

// ─── OrderProcessing.Tests/OrderRepositoryTests.cs ───
using Xunit;
using OrderProcessing.Core;

namespace OrderProcessing.Tests
{
    // IClassFixture<DatabaseFixture> tells xUnit: create DatabaseFixture once, share it with all tests here
    public class OrderRepositoryTests : IClassFixture<DatabaseFixture>
    {
        private readonly AppDbContext _context;

        // xUnit injects the shared fixture through the constructor
        public OrderRepositoryTests(DatabaseFixture fixture)
        {
            _context = fixture.Context;
        }

        [Fact]
        public void GetOrder_WhenIdExists_ReturnsCorrectOrder()
        {
            // Act: query the seeded in-memory database
            var order = _context.Orders.Find(1);

            // Assert: the seeded data is exactly what we expect
            Assert.NotNull(order);
            Assert.Equal("alice@example.com", order.CustomerEmail);
            Assert.Equal(99.99m, order.Total);
        }

        [Fact]
        public void GetOrder_WhenIdDoesNotExist_ReturnsNull()
        {
            // Act: look for an order that was never seeded
            var order = _context.Orders.Find(999);

            // Assert: EF Core returns null for a missing key — not an exception
            Assert.Null(order);
        }

        [Fact]
        public void GetAllOrders_ReturnsExactlySeedCount()
        {
            // The fixture seeded exactly 2 orders
            int orderCount = _context.Orders.Count();
            Assert.Equal(2, orderCount);
        }
    }
}

using Xunit;
using OrderProcessing.Core;
using System.Collections.Generic;

namespace OrderProcessing.Tests
{
    public class OrderCalculatorTheoryTests
    {
        private readonly OrderCalculator _calculator = new OrderCalculator();

        // MemberData: a static property returning the test cases
        public static IEnumerable<object[]> DiscountTestData =>
            new List<object[]>
            {
                new object[] { 100.00m, 10m, 90.00m },
                new object[] { 200.00m, 25m, 150.00m },
                new object[] { 50.00m,  100m, 0.00m  },
                new object[] { 99.99m,  0m,   99.99m },
                new object[] { 0.00m,   50m,  0.00m  }
            };

        [Theory]
        [MemberData(nameof(DiscountTestData))]
        public void CalculateTotal_WithMemberData_ReturnsCorrectTotal(decimal subtotal, decimal discountPercent, decimal expectedTotal)
        {
            decimal actualTotal = _calculator.CalculateTotal(subtotal, discountPercent);
            Assert.Equal(expectedTotal, actualTotal);
        }

        // MemberData can also reference a static method (useful for computed or file-backed data)
        public static IEnumerable<object[]> GetShippingTestData()
        {
            // In production, read from a CSV or database
            yield return new object[] { 50.00m,  "Gold",     true };
            yield return new object[] { 49.99m,  "Gold",     false };
            yield return new object[] { 100.00m, "Standard", true };
            yield return new object[] { 99.99m,  "Standard", false };
            yield return new object[] { 500.00m, "Bronze",   false };
        }

        [Theory]
        [MemberData(nameof(GetShippingTestData))]
        public void QualifiesForFreeShipping_WithMemberData_ReturnsExpected(decimal orderTotal, string customerTier, bool expectedResult)
        {
            bool actualResult = _calculator.QualifiesForFreeShipping(orderTotal, customerTier);
            Assert.Equal(expectedResult, actualResult);
        }
    }

    // ClassData: separate class that implements IEnumerable<object[]>
    public class DiscountTestDataClass : IEnumerable<object[]>
    {
        public IEnumerator<object[]> GetEnumerator()
        {
            yield return new object[] { 100.00m, 10m, 90.00m };
            yield return new object[] { 200.00m, 25m, 150.00m };
            yield return new object[] { 50.00m,  100m, 0.00m  };
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
    }

    public class OrderCalculatorClassDataTests
    {
        private readonly OrderCalculator _calculator = new OrderCalculator();

        [Theory]
        [ClassData(typeof(DiscountTestDataClass))]
        public void CalculateTotal_WithClassData_ReturnsCorrectTotal(decimal subtotal, decimal discountPercent, decimal expectedTotal)
        {
            decimal actualTotal = _calculator.CalculateTotal(subtotal, discountPercent);
            Assert.Equal(expectedTotal, actualTotal);
        }
    }
}

// io.thecodeforge — csharp tutorial

using Xunit;

// Define a collection that forces sequential execution
[CollectionDefinition("DatabaseTests", DisableParallelization = true)]
public class DatabaseTestCollection { }

// All test classes in this collection run one at a time
[Collection("DatabaseTests")]
public class OrderRepositoryTests
{
    [Fact]
    public void SaveOrder_ReturnsConfirmedId()
    {
        // This test won't run while other "DatabaseTests" are running
        // Prevents connection pool exhaustion and row locks
        Assert.True(true);
    }
}

[Collection("DatabaseTests")]
public class InvoiceRepositoryTests
{
    [Fact]
    public void CreateInvoice_CreatesRecord()
    {
        // Same sequential guarantee
        Assert.True(true);
    }
}

// io.thecodeforge — csharp tutorial

using Xunit.Sdk;

public static class CustomAssertions
{
    public static void HttpStatusOk(HttpResponseMessage response)
    {
        if (response.StatusCode != System.Net.HttpStatusCode.OK)
        {
            var body = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
            throw new XunitException(
                $"Expected 200 OK, got {(int)response.StatusCode} {response.ReasonPhrase}.\n" +
                $"Response body: {body}");
        }
    }
}

public class PaymentApiTests
{
    [Fact]
    public async Task ProcessPayment_ReturnsOk()
    {
        var response = await new HttpClient().PostAsync("http://localhost/api/pay", null);
        CustomAssertions.HttpStatusOk(response);  // precise failure message every time
    }
}

// io.thecodeforge — csharp tutorial

using Xunit;

public class SharedDatabasePool
{
    private static readonly Lazy<Database> _pool = 
        new(() => new Database("Server=prod;Trusted_Connection=true;"));

    public Database Instance => _pool.Value;
}

[CollectionDefinition("SharedDb")]
public class SharedDbCollection : ICollectionFixture<SharedDatabasePool> { }

[Collection("SharedDb")]
public class UserTests
{
    private readonly Database _db;
    public UserTests(SharedDatabasePool pool) => _db = pool.Instance;

    [Fact]
    public void UserExists_ReturnsTrue()
    {
        Assert.True(_db.Query("SELECT 1") == 1);
    }
}

[Collection("SharedDb")]
public class OrderTests
{
    private readonly Database _db;
    public OrderTests(SharedDatabasePool pool) => _db = pool.Instance; // same pool, zero rebuild

    [Fact]
    public void OrderCount_MatchesExpected()
    {
        Assert.Equal(100, _db.Query("SELECT COUNT(*) FROM Orders"));
    }
}

// io.thecodeforge — csharp tutorial

public class LeakyFixture
{
    public List<string> Items { get; } = new();
}

public class FragileTests : IClassFixture<LeakyFixture>
{
    [Fact]
    public void Add_Item_First()
    {
        var fixture = new LeakyFixture();
        fixture.Items.Add("A");
        Assert.Single(fixture.Items);
    }

    [Fact]
    public void Add_Item_Second_Fails()
    {
        // ❌ This test sees "A" from Add_Item_First!
        var fixture = new LeakyFixture();
        fixture.Items.Add("B");
        Assert.Single(fixture.Items); // Fails: 2 items
    }
}

// io.thecodeforge — csharp tutorial

public static class TestConfig
{
    private static readonly Lazy<MySettings> _settings = 
        new(() => new MySettings { DbConnection = "Server=test;" });

    public static MySettings Instance => _settings.Value;
}

public class LightweightTests
{
    [Fact]
    public void Config_Loads_Once()
    {
        var config = TestConfig.Instance;
        Assert.Equal("Server=test;", config.DbConnection);
    }
}

public class MySettings
{
    public string DbConnection { get; set; } = string.Empty;
}

// io.thecodeforge — csharp tutorial
public class CalculatorTests
{
    // BAD: manual loop — first failure stops all
    [Fact]
    public void Add_ManualIteration_Bad()
    {
        var data = new[] { (1, 2, 3), (4, 5, 9), (0, 0, 0) };
        foreach (var (a, b, expected) in data)
        {
            var result = new Calculator().Add(a, b);
            Assert.Equal(expected, result);
        }
    }

    // GOOD: each case is a separate test
    [Theory]
    [InlineData(1, 2, 3)]
    [InlineData(4, 5, 9)]
    [InlineData(0, 0, 0)]
    public void Add_WithTheory_Good(int a, int b, int expected)
        => Assert.Equal(expected, new Calculator().Add(a, b));
}

public class CalculatorTheoryData : TheoryData<int, int, int>
{
    public CalculatorTheoryData()
    {
        Add(1, 2, 3);
        Add(2, 3, 5);
        Add(10, -5, 5);
    }
}

public class CalculatorTests
{
    [Theory]
    [ClassData(typeof(CalculatorTheoryData))]
    public void Add_ReturnsSum(int a, int b, int expected)
    {
        var calculator = new Calculator();
        var result = calculator.Add(a, b);
        Assert.Equal(expected, result);
    }

    public static IEnumerable<object[]> AddData =>
        new List<object[]>
        {
            new object[] { 1, 2, 3 },
            new object[] { 2, 3, 5 },
            new object[] { 10, -5, 5 }
        };

    [Theory]
    [MemberData(nameof(AddData))]
    public void Add_ReturnsSum_MemberData(int a, int b, int expected)
    {
        var calculator = new Calculator();
        var result = calculator.Add(a, b);
        Assert.Equal(expected, result);
    }

    public class CalculatorData : IEnumerable<object[]>
    {
        public IEnumerator<object[]> GetEnumerator()
        {
            yield return new object[] { 1, 2, 3 };
            yield return new object[] { 2, 3, 5 };
            yield return new object[] { 10, -5, 5 };
        }

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }

    [Theory]
    [ClassData(typeof(CalculatorData))]
    public void Add_ReturnsSum_ClassData(int a, int b, int expected)
    {
        var calculator = new Calculator();
        var result = calculator.Add(a, b);
        Assert.Equal(expected, result);
    }
}

using Xunit;
using Xunit.Abstractions;

public class CalculatorTests
{
    private readonly ITestOutputHelper _output;

    public CalculatorTests(ITestOutputHelper output)
    {
        _output = output;
    }

    [Fact]
    public void Add_ReturnsSum()
    {
        _output.WriteLine("Starting test Add_ReturnsSum");
        var calculator = new Calculator();
        var result = calculator.Add(1, 2);
        _output.WriteLine($"Result: {result}");
        Assert.Equal(3, result);
    }

    [Theory]
    [InlineData(1, 2, 3)]
    [InlineData(2, 3, 5)]
    public void Add_ReturnsSum_Theory(int a, int b, int expected)
    {
        _output.WriteLine($"Testing {a} + {b} = {expected}");
        var calculator = new Calculator();
        var result = calculator.Add(a, b);
        Assert.Equal(expected, result);
    }
}

// AssemblyInfo.cs or a global using file
[assembly: CollectionBehavior(DisableTestParallelization = false, MaxParallelThreads = 4)]

// Test collection definition
[CollectionDefinition("Database Tests")]
public class DatabaseTestCollection : ICollectionFixture<DatabaseFixture>
{
}

public class DatabaseFixture : IDisposable
{
    public DatabaseFixture()
    {
        // Initialize shared resource
    }

    public void Dispose()
    {
        // Clean up
    }
}

[Collection("Database Tests")]
public class DatabaseTests
{
    private readonly DatabaseFixture _fixture;

    public DatabaseTests(DatabaseFixture fixture)
    {
        _fixture = fixture;
    }

    [Fact]
    public void Test1()
    {
        // Use _fixture
    }

    [Fact]
    public void Test2()
    {
        // Use _fixture
    }
}