Test Code

// ❌ Only asserts the callback was called
// (double fire, wrong payload, and onError all pass)
expect(onSuccess).toHaveBeenCalled();

// ✅ Pin the count, the arguments, and the silent paths
expect(onSuccess).toHaveBeenCalledTimes(1);
expect(onSuccess).toHaveBeenCalledWith({ userId: 123 });
expect(onError).not.toHaveBeenCalled();

# ❌ Only asserts the callback was called
# (double call, wrong payload, and on_error all pass)
expect(on_success).to have_received(:call)

# ✅ Pin the count, the arguments, and the silent paths
expect(on_success).to have_received(:call).with(user_id: 123).once
expect(on_error).not_to have_received(:call)

// ❌ Only asserts individual fields
expect(result.id).toBe(1);
expect(result.name).toBe("Alice");
expect(result.role).toBe("member");

// ✅ Pin the whole structure (any unintended change fails)
expect(result).toStrictEqual({ id: 1, name: "Alice", role: "member" });

// ✅ Check the keys in addition to individual fields
// (missing or extra keys — dropped or unintentionally added fields — also fail)
expect(Object.keys(result).sort()).toEqual(["id", "name", "role"]);
expect(result.id).toBe(1);
expect(result.name).toBe("Alice");
expect(result.role).toBe("member");

# ❌ Only asserts individual attributes
expect(result[:id]).to eq(1)
expect(result[:name]).to eq("Alice")
expect(result[:role]).to eq("member")

# ✅ Pin the whole structure (any unintended change fails)
expect(result).to eq({ id: 1, name: "Alice", role: "member" })

# ✅ Check the keys in addition to individual attributes
# (missing or extra keys — dropped or unintentionally added fields — also fail)
expect(result.keys).to contain_exactly(:id, :name, :role)
expect(result[:id]).to eq(1)
expect(result[:name]).to eq("Alice")
expect(result[:role]).to eq("member")

// ❌ Asserts only the count (any two items pass)
expect(result.items.length).toBe(2);

// ✅ Pin the whole expected value (any broken item, price, or total fails)
expect(result).toStrictEqual({
  items: [
    { id: 1, name: "Coffee", price: 500 },
    { id: 2, name: "Beans", price: 1200 },
  ],
  total: 1700,
});

# ❌ Asserts only the count (any two items pass)
expect(result[:items].length).to eq(2)

# ✅ Pin the whole expected value (any broken item, price, or total fails)
expect(result).to eq({
  items: [
    { id: 1, name: "Coffee", price: 500 },
    { id: 2, name: "Beans", price: 1200 }
  ],
  total: 1700
})

// ❌ Passes even when the value is not true ("yes" or 1 also passes)
expect(active).toBeTruthy();

// ✅ Assert the exact value and type
expect(active).toBe(true);
expect(count).toBe(0);

# ❌ Passes even when the value is not true ("yes" or 1 also passes)
expect(active?).to be_truthy

# ✅ Assert the exact value and type
expect(active?).to be true
expect(count).to eq 0

// Implementation under test: builds a mail body whose expiry date
// is seven days from the current time
const mailService = {
  createInviteMailBody(toEmail, inviteLink) {
    const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
    const expiryDate = expiresAt.toISOString().slice(0, 10); // e.g. "2026-07-08"
    return `Dear ${toEmail},\n${inviteLink}\nThis link expires on ${expiryDate}.`;
  },
};

const expectedBody = `Dear ${toEmail},\n${inviteLink}\nThis link expires on 2026-07-08.`;

// ❌ Mocks the logic under test itself
// (only asserts the mock's return value — a broken implementation passes)
jest.spyOn(mailService, "createInviteMailBody").mockReturnValue(expectedBody);
expect(mailService.createInviteMailBody(toEmail, inviteLink)).toBe(expectedBody);

// ✅ Mock only the external boundary (the clock), run the real logic
// (the expiry is pinned to 2026-07-08 — a bug in the implementation fails)
jest.useFakeTimers().setSystemTime(new Date("2026-07-01T00:00:00Z"));
expect(mailService.createInviteMailBody(toEmail, inviteLink)).toBe(expectedBody);

# Implementation under test: builds a mail body whose expiry date
# is seven days from the current time
class MailService
  def create_invite_mail_body(to_email, invite_link)
    expiry_date = (Time.zone.now + 7.days).strftime("%Y-%m-%d") # e.g. "2026-07-08"
    "Dear #{to_email},\n#{invite_link}\nThis link expires on #{expiry_date}."
  end
end

expected_body = "Dear #{to_email},\n#{invite_link}\nThis link expires on 2026-07-08."

# ❌ Mocks the logic under test itself
# (only asserts the mock's return value — a broken implementation passes)
allow(mail_service).to receive(:create_invite_mail_body).and_return(expected_body)
expect(mail_service.create_invite_mail_body(to_email, invite_link)).to eq(expected_body)

# ✅ Mock only the external boundary (the clock), run the real logic
# (the expiry is pinned to 2026-07-08 — a bug in the implementation fails)
travel_to Time.zone.local(2026, 7, 1) do
  expect(mail_service.create_invite_mail_body(to_email, invite_link)).to eq(expected_body)
end