Test Double

// checkout.hpp -- the abstraction and the unit under test.

// Catalog yields the unit price, in cents, of a product.
class Catalog {
public:
  virtual ~Catalog() = default;
  virtual auto unit_price(const std::string& sku) const -> int = 0;
};

struct Line {
  std::string sku;
  int quantity;
};

auto total(const Catalog& catalog, const std::vector<Line>& lines) -> int;

// A fake: a working Catalog backed by a map of fixed prices.
class FakeCatalog final : public Catalog {
public:
  explicit FakeCatalog(std::map<std::string, int> prices)
    : m_prices(std::move(prices)) {}

  auto unit_price(const std::string& sku) const -> int override {
    return m_prices.at(sku);
  }

private:
  std::map<std::string, int> m_prices;
};

TEST_CASE("total sums the priced line items") {
  // Arrange
  const FakeCatalog catalog{{{"APPLE", 50}, {"BREAD", 220}}};
  const std::vector<Line> lines{{"APPLE", 3}, {"BREAD", 1}};

  // Act
  const int result = total(catalog, lines);

  // Assert
  REQUIRE(result == 370);
}

package checkout

// Catalog yields the unit price, in cents, of a product.
type Catalog interface {
  UnitPrice(sku string) int
}

// Line is a requested quantity of a product.
type Line struct {
  SKU      string
  Quantity int
}

// Total returns the price, in cents, of the given lines.
func Total(catalog Catalog, lines []Line) int {
  var total int
  for _, line := range lines {
    total += catalog.UnitPrice(line.SKU) * line.Quantity
  }
  return total
}

package checkout_test // external package: only the exported API is visible

// fakeCatalog is a working Catalog backed by a table of fixed prices.
type fakeCatalog map[string]int

func (c fakeCatalog) UnitPrice(sku string) int { return c[sku] }

func TestTotal(t *testing.T) {
  t.Parallel()

  // Arrange
  catalog := fakeCatalog{"APPLE": 50, "BREAD": 220}
  testCases := []struct {
    name  string
    lines []checkout.Line
    want  int
  }{
    {
      name:  "sums the priced line items",
      lines: []checkout.Line{{SKU: "APPLE", Quantity: 3}, {SKU: "BREAD", Quantity: 1}},
      want:  370,
    }, {
      name:  "an empty order costs nothing",
      lines: nil,
      want:  0,
    },
  }

  for _, tc := range testCases {
    t.Run(tc.name, func(t *testing.T) {
      // Act
      total := checkout.Total(catalog, tc.lines)

      // Assert
      if got, want := total, tc.want; !cmp.Equal(got, want) {
        t.Errorf("Total(%v) = %d, want %d", tc.lines, got, want)
      }
    })
  }
}

# checkout.py -- the abstraction and the unit under test.
from dataclasses import dataclass
from typing import Protocol


# Catalog yields the unit price, in cents, of a product.
class Catalog(Protocol):
  def unit_price(self, sku: str) -> int: ...


@dataclass(frozen=True)
class Line:
  sku: str
  quantity: int


def total(catalog: Catalog, lines: list[Line]) -> int:
  return sum(catalog.unit_price(line.sku) * line.quantity for line in lines)

from checkout import Line, total


# A fake: a working Catalog backed by a dict of fixed prices.
class FakeCatalog:
  def __init__(self, prices: dict[str, int]) -> None:
    self._prices = prices

  def unit_price(self, sku: str) -> int:
    return self._prices[sku]


def test_total_sums_the_priced_line_items():
  # Arrange
  catalog = FakeCatalog({"APPLE": 50, "BREAD": 220})
  lines = [Line("APPLE", 3), Line("BREAD", 1)]

  # Act
  result = total(catalog, lines)

  # Assert
  assert result == 370

// src/lib.rs -- the abstraction and the unit under test.

/// Catalog yields the unit price, in cents, of a product.
pub trait Catalog {
  fn unit_price(&self, sku: &str) -> u32;
}

pub struct Line {
  pub sku: String,
  pub quantity: u32,
}

/// Returns the price, in cents, of the given lines.
pub fn total(catalog: &impl Catalog, lines: &[Line]) -> u32 {
  lines
    .iter()
    .map(|line| catalog.unit_price(&line.sku) * line.quantity)
    .sum()
}

// tests/checkout.rs -- a separate crate that sees only the public API.
use std::collections::HashMap;

use checkout::{total, Catalog, Line};

// A fake: a working Catalog backed by a map of fixed prices.
struct FakeCatalog(HashMap<String, u32>);

impl Catalog for FakeCatalog {
  fn unit_price(&self, sku: &str) -> u32 {
    self.0[sku]
  }
}

#[test]
fn total_sums_the_priced_line_items() {
  // Arrange
  let catalog = FakeCatalog(HashMap::from([
    ("APPLE".to_string(), 50),
    ("BREAD".to_string(), 220),
  ]));
  let lines = [
    Line { sku: "APPLE".to_string(), quantity: 3 },
    Line { sku: "BREAD".to_string(), quantity: 1 },
  ];

  // Act
  let result = total(&catalog, &lines);

  // Assert
  assert_eq!(result, 370);
}