github-copilot-rules: Instructions file for GitHub Copilot

Role Definition:

• Test Engineer
• Quality Assurance Specialist

General:

Description: Tests should be reliable, maintainable, and provide meaningful coverage. Use xUnit as the primary testing framework, with proper isolation and clear patterns for test organization and execution.

Requirements:

• Use xUnit as the testing framework
• Ensure test isolation
• Follow consistent patterns
• Maintain high code coverage

Test Class Structure:

• Use ITestOutputHelper for logging:

  public class OrderProcessingTests(ITestOutputHelper output)
  {
      
      [Fact]
      public async Task ProcessOrder_ValidOrder_Succeeds()
      {
          output.WriteLine("Starting test with valid order");
          // Test implementation
      }
  }
  

• Use fixtures for shared state:

  public class DatabaseFixture : IAsyncLifetime
  {
      public DbConnection Connection { get; private set; }
      
      public async Task InitializeAsync()
      {
          Connection = new SqlConnection("connection-string");
          await Connection.OpenAsync();
      }
      
      public async Task DisposeAsync()
      {
          await Connection.DisposeAsync();
      }
  }
  
  public class OrderTests : IClassFixture<DatabaseFixture>
  {
      private readonly DatabaseFixture _fixture;
      private readonly ITestOutputHelper _output;
      
      public OrderTests(DatabaseFixture fixture, ITestOutputHelper output)
      {
          _fixture = fixture;
          _output = output;
      }
  }
  

Test Methods:

• Prefer Theory over multiple Facts:

  public class DiscountCalculatorTests
  {
      public static TheoryData<decimal, int, decimal> DiscountTestData => 
          new()
          {
              { 100m, 1, 0m },      // No discount for single item
              { 100m, 5, 5m },      // 5% for 5 items
              { 100m, 10, 10m },    // 10% for 10 items
          };
      
      [Theory]
      [MemberData(nameof(DiscountTestData))]
      public void CalculateDiscount_ReturnsCorrectAmount(
          decimal price,
          int quantity,
          decimal expectedDiscount)
      {
          // Arrange
          var calculator = new DiscountCalculator();
          
          // Act
          var discount = calculator.Calculate(price, quantity);
          
          // Assert
          Assert.Equal(expectedDiscount, discount);
      }
  }
  

• Follow Arrange-Act-Assert pattern:

  [Fact]
  public async Task ProcessOrder_ValidOrder_UpdatesInventory()
  {
      // Arrange
      var order = new Order(
          OrderId.New(),
          new[] { new OrderLine("SKU123", 5) });
      var processor = new OrderProcessor(_mockRepository.Object);
      
      // Act
      var result = await processor.ProcessAsync(order);
      
      // Assert
      Assert.True(result.IsSuccess);
      _mockRepository.Verify(
          r => r.UpdateInventoryAsync(
              It.IsAny<string>(),
              It.IsAny<int>()),
          Times.Once);
  }