Testing & TDD Workflow

Apply Test-Driven Development methodology to ensure reliability and confidence when adding new features.

TDD Workflow

Follow this cycle for all new features:

1. Write the Test First

Frontend (JavaScript/TypeScript)

Use Vitest for all frontend tests
Name tests clearly and descriptively

Backend (C#/.NET)

Use xUnit or MsTest (based on project)
Follow the same naming conventions

Test Naming Convention

shouldDoSomethingWhenCondition()

2. Generate Code

Write the minimal code needed to make the test pass
Use GitHub Copilot to help implement based on the test
Keep implementations simple and focused

3. Run Tests and Iterate

Run the test suite
Fix failures
Refactor if needed
Repeat until all tests pass

Testing Best Practices

Coverage

Write tests for all new features and bug fixes
Ensure tests cover edge cases and error handling
Test both happy paths and error scenarios

Test Quality

Keep tests focused and isolated
One assertion concept per test
Use descriptive test names that explain the scenario
NEVER change the original code to make it easier to test

Test Structure (AAA Pattern)

// Arrange - Set up test data and conditions
// Act - Execute the code being tested
// Assert - Verify the results

Examples

Frontend Test (Vitest)

import { describe, it, expect } from 'vitest'
import { calculateTotal } from './cart'

describe('calculateTotal', () => {
	it('shouldReturnZeroWhenCartIsEmpty', () => {
		// Arrange
		const cart = []

		// Act
		const total = calculateTotal(cart)

		// Assert
		expect(total).toBe(0)
	})

	it('shouldCalculateTotalWithMultipleItems', () => {
		// Arrange
		const cart = [
			{ price: 10, quantity: 2 },
			{ price: 5, quantity: 3 }
		]

		// Act
		const total = calculateTotal(cart)

		// Assert
		expect(total).toBe(35)
	})

	it('shouldThrowErrorWhenItemHasNegativePrice', () => {
		// Arrange
		const cart = [{ price: -10, quantity: 1 }]

		// Act & Assert
		expect(() => calculateTotal(cart)).toThrow('Price cannot be negative')
	})
})

Backend Test (xUnit)

using Xunit;

public class CartCalculatorTests
{
    [Fact]
    public void ShouldReturnZeroWhenCartIsEmpty()
    {
        // Arrange
        var cart = new List<CartItem>();
        var calculator = new CartCalculator();

        // Act
        var total = calculator.CalculateTotal(cart);

        // Assert
        Assert.Equal(0, total);
    }

    [Fact]
    public void ShouldCalculateTotalWithMultipleItems()
    {
        // Arrange
        var cart = new List<CartItem>
        {
            new CartItem { Price = 10, Quantity = 2 },
            new CartItem { Price = 5, Quantity = 3 }
        };
        var calculator = new CartCalculator();

        // Act
        var total = calculator.CalculateTotal(cart);

        // Assert
        Assert.Equal(35, total);
    }

    [Fact]
    public void ShouldThrowExceptionWhenItemHasNegativePrice()
    {
        // Arrange
        var cart = new List<CartItem> { new CartItem { Price = -10, Quantity = 1 } };
        var calculator = new CartCalculator();

        // Act & Assert
        Assert.Throws<ArgumentException>(() => calculator.CalculateTotal(cart));
    }
}

TDD Benefits

Following this workflow ensures:

✅ Code is testable by design
✅ Better code coverage
✅ Fewer bugs in production
✅ Confidence when refactoring
✅ Living documentation through tests
✅ Faster development in the long run

When to Apply

Apply TDD when:

Implementing new features
Fixing bugs (write a failing test first)
Refactoring existing code
User requests testing implementation
Starting a new project or module

testing-tdd