Unit testing

// src/main/kotlin/Pricing.kt
fun discountedCents(priceCents: Int, percent: Int): Int = priceCents * (100 - percent) / 100

// src/test/kotlin/PricingTest.kt
import kotlin.test.Test
import kotlin.test.assertEquals

class PricingTest {
    @Test
    fun `discount is applied`() {
        val price = 3_000                               // arrange
        val result = discountedCents(price, percent = 10) // act
        assertEquals(2_700, result)                     // assert: expected first
    }
}

// src/main/java/shop/Pricing.java
static int discountedCents(int priceCents, int percent) {
    return priceCents * (100 - percent) / 100;
}

// src/test/java/shop/PricingTest.java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class PricingTest {
    @Test
    void discountIsApplied() {
        int price = 3_000;                              // arrange
        int result = Pricing.discountedCents(price, 10); // act
        assertEquals(2_700, result);                    // assert: expected first
    }
}

// src/pricing.ts
export function discountedCents(priceCents: number, percent: number): number {
  return Math.floor((priceCents * (100 - percent)) / 100);
}

// src/pricing.test.ts
import { expect, it } from "vitest";
import { discountedCents } from "./pricing";

it("applies the discount", () => {
  const price = 3_000;                                  // arrange
  const result = discountedCents(price, 10);            // act
  expect(result).toBe(2_700);                           // assert
});

fun isValidPassword(password: String) = password.length >= 8 && password.any { it.isDigit() }

class PasswordTest {
    @ParameterizedTest
    @CsvSource(
        "sunshine1, true",
        "short1, false",          // too short
        "1234567, false",         // 7 characters
        "12345678, true",         // exactly 8
        "sunshinesun, false",     // no digit
        "'', false",
    )
    fun `password rules`(password: String, expected: Boolean) {
        assertEquals(expected, isValidPassword(password))
    }
}

static boolean isValidPassword(String password) {
    return password.length() >= 8 && password.chars().anyMatch(Character::isDigit);
}

class PasswordTest {
    @ParameterizedTest
    @CsvSource({
        "sunshine1, true",
        "short1, false",          // too short
        "1234567, false",         // 7 characters
        "12345678, true",         // exactly 8
        "sunshinesun, false",     // no digit
        "'', false",
    })
    void passwordRules(String password, boolean expected) {
        assertEquals(expected, isValidPassword(password));
    }
}

export const isValidPassword = (password: string): boolean =>
  password.length >= 8 && /[0-9]/.test(password);

it.each([
  ["sunshine1", true],
  ["short1", false],          // too short
  ["1234567", false],         // 7 characters
  ["12345678", true],         // exactly 8
  ["sunshinesun", false],     // no digit
  ["", false],
])("password %j is valid: %s", (password, expected) => {
  expect(isValidPassword(password)).toBe(expected);
});

interface PaymentGateway {
    suspend fun charge(cents: Int): String
}

class Checkout(private val payments: PaymentGateway) {
    suspend fun pay(cents: Int): String =
        try { "Paid: ${payments.charge(cents)}" } catch (e: IOException) { "Payment failed" }
}

class FakeGateway : PaymentGateway {
    var shouldFail = false
    val charged = mutableListOf<Int>()
    override suspend fun charge(cents: Int): String {
        if (shouldFail) throw IOException("offline")
        charged += cents
        return "test-1"
    }
}

class CheckoutTest {
    @Test
    fun `shows failure when payment fails`() = runTest {
        val gateway = FakeGateway().apply { shouldFail = true }
        val checkout = Checkout(gateway)

        assertEquals("Payment failed", checkout.pay(1_000))
        assertTrue(gateway.charged.isEmpty())
    }
}

interface PaymentGateway {
    String charge(int cents) throws IOException;
}

final class Checkout {
    private final PaymentGateway payments;
    Checkout(PaymentGateway payments) { this.payments = payments; }

    String pay(int cents) {
        try { return "Paid: " + payments.charge(cents); }
        catch (IOException e) { return "Payment failed"; }
    }
}

final class FakeGateway implements PaymentGateway {
    boolean shouldFail = false;
    final List<Integer> charged = new ArrayList<>();
    public String charge(int cents) throws IOException {
        if (shouldFail) throw new IOException("offline");
        charged.add(cents);
        return "test-1";
    }
}

class CheckoutTest {
    @Test
    void showsFailureWhenPaymentFails() {
        FakeGateway gateway = new FakeGateway();
        gateway.shouldFail = true;
        Checkout checkout = new Checkout(gateway);

        assertEquals("Payment failed", checkout.pay(1_000));
        assertTrue(gateway.charged.isEmpty());
    }
}

export interface PaymentGateway {
  charge(cents: number): Promise<string>;
}

export class Checkout {
  constructor(private readonly payments: PaymentGateway) {}

  async pay(cents: number): Promise<string> {
    try { return `Paid: ${await this.payments.charge(cents)}`; }
    catch { return "Payment failed"; }
  }
}

class FakeGateway implements PaymentGateway {
  shouldFail = false;
  readonly charged: number[] = [];
  async charge(cents: number): Promise<string> {
    if (this.shouldFail) throw new Error("offline");
    this.charged.push(cents);
    return "test-1";
  }
}

it("shows a failure when payment fails", async () => {
  const gateway = new FakeGateway();
  gateway.shouldFail = true;
  const checkout = new Checkout(gateway);

  expect(await checkout.pay(1_000)).toBe("Payment failed");
  expect(gateway.charged).toEqual([]);
});