테스트를 언어별로 비교하기

// build.gradle.kts 의존성:
// testImplementation("io.kotest:kotest-runner-junit5:5.8.0")
// testImplementation("io.kotest:kotest-assertions-core:5.8.0")

import io.kotest.core.spec.style.DescribeSpec
import io.kotest.matchers.shouldBe
import io.kotest.matchers.collections.shouldHaveSize
import io.kotest.matchers.shouldThrow

class CalculatorTest : DescribeSpec({
    val calc = Calculator()

    describe("덧셈") {
        it("양수 + 양수") {
            calc.add(2, 3) shouldBe 5
        }
        it("음수 포함") {
            calc.add(-1, 1) shouldBe 0
        }
    }

    describe("나눗셈") {
        it("정상 나눗셈") {
            calc.divide(10, 2) shouldBe 5.0
        }
        it("0으로 나누면 예외") {
            shouldThrow<ArithmeticException> {
                calc.divide(10, 0)
            }
        }
    }
})

// JUnit5 스타일
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.*

class CalcJUnit {
    @Test
    fun `두 수의 합`() {   // 백틱으로 한글 테스트명 가능
        assertEquals(5, Calculator().add(2, 3))
    }
}

class Calculator {
    fun add(a: Int, b: Int) = a + b
    fun divide(a: Int, b: Int): Double {
        if (b == 0) throw ArithmeticException("0으로 나눌 수 없음")
        return a.toDouble() / b
    }
}

# test_calculator.py
import pytest
from calculator import add, divide

# 기본 테스트
def test_add_positive():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, 1) == 0

# 예외 테스트
def test_divide_by_zero():
    with pytest.raises(ZeroDivisionError, match="division by zero"):
        divide(10, 0)

# @pytest.mark.parametrize — 여러 케이스 자동 실행
@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (100, -50, 50),
])
def test_add_cases(a, b, expected):
    assert add(a, b) == expected

# fixture — 테스트 전후 설정/정리
@pytest.fixture
def sample_data():
    data = {"users": ["Alice", "Bob"], "count": 2}
    yield data          # 여기서 테스트 실행됨
    # yield 이후는 teardown
    print("\n정리 완료")

def test_with_fixture(sample_data):
    assert sample_data["count"] == 2
    assert "Alice" in sample_data["users"]

# tmp_path fixture (pytest 내장)
def test_file_write(tmp_path):
    file = tmp_path / "test.txt"
    file.write_text("hello")
    assert file.read_text() == "hello"

# monkeypatch — 의존성 교체
def test_with_mock(monkeypatch):
    monkeypatch.setattr("builtins.input", lambda _: "42")
    # input()이 항상 "42"를 반환

// go get github.com/stretchr/testify
package main

import (
	"testing"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/stretchr/testify/mock"
)

// 인터페이스 정의
type UserRepo interface {
	FindByID(id int) (*User, error)
	Save(u *User) error
}

// Mock 구현
type MockUserRepo struct {
	mock.Mock
}

func (m *MockUserRepo) FindByID(id int) (*User, error) {
	args := m.Called(id)
	return args.Get(0).(*User), args.Error(1)
}

func (m *MockUserRepo) Save(u *User) error {
	return m.Called(u).Error(0)
}

// 서비스
type UserService struct{ repo UserRepo }

func (s *UserService) GetUser(id int) (*User, error) {
	return s.repo.FindByID(id)
}

// 테스트
func TestGetUser(t *testing.T) {
	mockRepo := new(MockUserRepo)
	expected := &User{ID: 1, Name: "Alice"}

	// Mock 설정
	mockRepo.On("FindByID", 1).Return(expected, nil)

	svc := &UserService{repo: mockRepo}
	user, err := svc.GetUser(1)

	// assert — 실패해도 계속
	assert.NoError(t, err)
	assert.Equal(t, expected.Name, user.Name)
	assert.NotNil(t, user)

	// require — 실패 시 즉시 중단
	require.NotNil(t, user)

	// Mock 호출 검증
	mockRepo.AssertExpectations(t)
	mockRepo.AssertCalled(t, "FindByID", 1)
}

import org.junit.jupiter.api.*;
import org.testcontainers.containers.*;
import org.testcontainers.junit.jupiter.*;
import org.testcontainers.utility.DockerImageName;
import java.sql.*;

// TestContainers — 실제 PostgreSQL 컨테이너
@Testcontainers
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class UserRepositoryIT {

    @Container
    static PostgreSQLContainer<?> postgres =
        new PostgreSQLContainer<>(DockerImageName.parse("postgres:15"))
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");

    Connection connection;

    @BeforeAll
    void setup() throws SQLException {
        connection = DriverManager.getConnection(
            postgres.getJdbcUrl(),
            postgres.getUsername(),
            postgres.getPassword());

        // 스키마 생성
        connection.createStatement().execute("""
            CREATE TABLE users (
                id SERIAL PRIMARY KEY,
                name VARCHAR(100) NOT NULL,
                email VARCHAR(255) UNIQUE
            )
            """);
    }

    @Test
    @DisplayName("사용자 저장 & 조회")
    void saveAndFind() throws SQLException {
        // Given
        var insert = connection.prepareStatement(
            "INSERT INTO users (name, email) VALUES (?, ?)");
        insert.setString(1, "Alice");
        insert.setString(2, "alice@test.com");
        insert.executeUpdate();

        // When
        var select = connection.prepareStatement(
            "SELECT * FROM users WHERE email = ?");
        select.setString(1, "alice@test.com");
        var rs = select.executeQuery();

        // Then
        assertTrue(rs.next());
        assertEquals("Alice", rs.getString("name"));
    }

    @AfterAll
    void teardown() throws SQLException {
        if (connection != null) connection.close();
    }
}

// Redis 컨테이너 예시:
// @Container
// static GenericContainer<?> redis =
//     new GenericContainer<>("redis:7")
//         .withExposedPorts(6379);

<?php
use PHPUnit\Framework\TestCase;

final class SluggerTest extends TestCase {
    public function testItCreatesSlug(): void {
        $this->assertSame('hello-php', str_replace(' ', '-', strtolower('Hello PHP')));
    }
}

// 동등성 단언
if (1 + 1 <= 1) throw new Error("assert failed");

// 동등성 단언
if (1 + 1 <= 1) throw new Error("assert failed");

// 동등성 단언
using System;

if (1 + 1 <= 1) throw new Exception("assert failed");
Console.WriteLine(true);

// 동등성 단언
#include <cassert>

int main() {
    assert(1 + 1 > 1);
}

// 동등성 단언
fn main() {
    assert!(1 + 1 > 1);
}