create-tests-swift

Swift Testing Guide

This guide outlines Swift testing principles and practices, focusing on creating effective unit tests for Swift code.

actions:

• type: suggest message: |

  Swift Testing Guidelines

  In this project, every public function must have unit tests. We follow these guidelines:

  Test Structure

  Naming Convention

  • Test class name: [ClassUnderTest]Tests
  • Test method name: test_[FunctionUnderTest]_[Scenario]_[ExpectedResult]

  Example:

  class UserAuthenticationTests: XCTestCase {
      func test_authenticate_withValidCredentials_shouldReturnToken() { ... }
      func test_authenticate_withInvalidPassword_shouldThrowAuthError() { ... }
  }
  

  Arrangement

  Every test should follow the Arrange-Act-Assert (AAA) pattern:

  func test_addItem_withValidProduct_shouldAddToCart() {
      // Arrange
      let cart = ShoppingCart(id: CartID())
      let product = Product(id: ProductID(), name: "Test Product", price: Money(amount: 10, currency: .usd))
      
      // Act
      try! cart.addItem(product: product, quantity: 1)
      
      // Assert
      XCTAssertEqual(cart.items.count, 1)
      XCTAssertEqual(cart.total()?.amount, 10)
  }
  

  Types of Tests

  1. Unit Tests

  • Tests a single unit of code in isolation
  • Uses mocks/stubs for dependencies
  • Fast and reliable
  • Located in target's matching test target (e.g., DomainTests for Domain code)

  func test_placeOrder_withValidItems_shouldCreateOrderSuccessfully() {
      // Arrange
      let mockOrderRepository = MockOrderRepository()
      let mockProductRepository = MockProductRepository()
      let orderService = OrderService(
          orderRepository: mockOrderRepository,
          productRepository: mockProductRepository
      )
      
      let items = [OrderItem(productID: ProductID(), quantity: 1, price: Money(amount: 10, currency: .usd))]
      
      // Act
      let result = orderService.placeOrder(items: items, customerID: CustomerID())
      
      // Assert
      XCTAssertTrue(result.isSuccess)
      XCTAssertEqual(mockOrderRepository.savedOrders.count, 1)
  }
  

  2. Integration Tests

  • Tests interaction between multiple components
  • Typically involves real implementations rather than mocks
  • Located in separate test targets

  func test_orderFlow_endToEnd_shouldProcessOrderSuccessfully() {
      // Tests the full order flow from cart to confirmation
      // Uses real implementations for most components
  }
  

  Mocking Guidelines

  • Create mocks for protocols, not for concrete classes
  • Use protocol-based dependencies to make testing easier
  • Name mocks clearly with the Mock prefix

  protocol OrderRepository {
      func save(_ order: Order) throws
      func findByID(_ id: OrderID) -> Order?
  }
  
  class MockOrderRepository: OrderRepository {
      var savedOrders: [Order] = []
      var ordersToReturn: [OrderID: Order] = [:]
      
      func save(_ order: Order) throws {
          savedOrders.append(order)
      }
      
      func findByID(_ id: OrderID) -> Order? {
          return ordersToReturn[id]
      }
  }
  

  Testing Value Objects

  Test both valid and invalid initialization:

  func test_emailInitialization_withValidEmail_shouldSucceed() {
      // Arrange & Act
      let email = Email(value: "[email protected]")
      
      // Assert
      XCTAssertNotNil(email)
      XCTAssertEqual(email?.value, "[email protected]")
  }
  
  func test_emailInitialization_withInvalidEmail_shouldReturnNil() {
      // Arrange & Act
      let email = Email(value: "invalid-email")
      
      // Assert
      XCTAssertNil(email)
  }