Chọn pattern từ pressure thật

Mục tiêu và setup thất bại trước

Giữ lại checkout behavior bằng regression tests trước khi tách class. Dùng fake provider có ledger theo operation/idempotency key, cho phép nhận lệnh, tạo charge rồi làm mất response; ghi riêng số request attempts và số charge thực tế. Khai báo giả định provider có hỗ trợ idempotency hoặc tra cứu kết quả theo reference.

Kiểm tra thứ tự Decorator bằng Java thuần

Đây là test nhỏ hoàn chỉnh để kiểm tra cách lồng wrapper. breakerProbe chỉ ghi trace, không có trạng thái open/half-open; retryTwice không phải retry policy production. Chương trình không thực hiện thanh toán và không chứng minh idempotency.

import java.util.ArrayList;
import java.util.List;

public class DecoratorOrderCheck {
    @FunctionalInterface
    interface Call {
        String run();
    }

    static class TemporaryFailure extends RuntimeException {}

    static Call metrics(Call next, List<String> trace) {
        return () -> {
            trace.add("metrics:enter");
            try {
                return next.run();
            } finally {
                trace.add("metrics:exit");
            }
        };
    }

    // A tracing probe, NOT a real circuit breaker state machine.
    static Call breakerProbe(Call next, List<String> trace) {
        return () -> {
            trace.add("breaker:enter");
            try {
                return next.run();
            } finally {
                trace.add("breaker:exit");
            }
        };
    }

    // Test-only retry: no delay, jitter, deadline or payment effects.
    static Call retryTwice(Call next, List<String> trace) {
        return () -> {
            for (int attempt = 1; attempt <= 2; attempt++) {
                trace.add("retry:" + attempt);
                try {
                    return next.run();
                } catch (TemporaryFailure failure) {
                    if (attempt == 2) {
                        throw failure;
                    }
                }
            }
            throw new AssertionError("unreachable");
        };
    }

    static void check(boolean retryOutside, List<String> expected) {
        List<String> trace = new ArrayList<>();
        int[] attempts = {0};
        Call vendor = () -> {
            trace.add("vendor:" + ++attempts[0]);
            if (attempts[0] == 1) {
                throw new TemporaryFailure();
            }
            return "ok";
        };
        Call inner = retryOutside
            ? retryTwice(breakerProbe(vendor, trace), trace)
            : breakerProbe(retryTwice(vendor, trace), trace);
        String result = metrics(inner, trace).run();
        if (!"ok".equals(result) || !expected.equals(trace)) {
            throw new AssertionError(trace);
        }
        System.out.println(
            (retryOutside ? "retry-outside-breaker" : "breaker-outside-retry")
            + ": PASS");
    }

    public static void main(String[] args) {
        check(true, List.of(
            "metrics:enter", "retry:1", "breaker:enter",
            "vendor:1", "breaker:exit", "retry:2", "breaker:enter",
            "vendor:2", "breaker:exit", "metrics:exit"));
        check(false, List.of(
            "metrics:enter", "breaker:enter", "retry:1",
            "vendor:1", "retry:2", "vendor:2",
            "breaker:exit", "metrics:exit"));
    }
}

javac --release 21 DecoratorOrderCheck.java
java DecoratorOrderCheck

Kết quả kỳ vọng: hai dòng retry-outside-breaker: PASS và breaker-outside-retry: PASS. Trong trace đầu, probe được vào hai lần; trong trace sau, một lần. Thêm state machine breaker thật và deadline tests ở bài làm của bạn.

Deliverables: responsibility/boundary map; diff trước/sau; contract-test report cho từng adapter; dependency-rule result; hai ordering traces và provider ledger khi mất response. Log “đã retry thành công” không thay bằng chứng không double-charge.

Mục tiêu, setup và phạm vi

Giữ nguyên chuỗi nguồn PENDING → RESERVED → PAYMENT_AUTHORIZED → CONFIRMED. Tự định nghĩa compensation states và legal edges theo nghiệp vụ; nguồn không cung cấp tên hay ma trận compensation đầy đủ. So sánh hai implementation enum/transition table và State objects trên cùng test suite.

Setup: tạo một order ở version 0; dùng hai connections/workers và barrier để cả hai đọc cùng version trước khi update. Kiểm thử trên database/isolation level của dự án, không chỉ dùng mock repository.

CREATE TABLE pattern_order (
    id VARCHAR(64) PRIMARY KEY,
    state VARCHAR(32) NOT NULL,
    version BIGINT NOT NULL
);
INSERT INTO pattern_order (id, state, version)
VALUES ('order-1', 'PENDING', 0);

-- Both workers must read version 0 before either worker writes.
SELECT state, version FROM pattern_order WHERE id = 'order-1';

-- Both workers issue this statement with the SAME expected version.
UPDATE pattern_order
SET state = 'RESERVED', version = version + 1
WHERE id = 'order-1'
  AND state = 'PENDING'
  AND version = 0;

-- Inspect the affected-row count using JDBC executeUpdate().
-- One successful committed write: 1 row; the stale write: 0 rows.

Expected observation: với hai lần update dùng cùng expected version, không có writer khác và transaction thắng commit thành công, một write cập nhật 1 row; write stale không được ghi đè. Database/isolation level có thể trả conflict/serialization failure thay vì 0 rows; implementation phải xử lý theo contract và chỉ coi thành công sau commit.

Giới hạn: predicate chỉ bảo vệ local state. Hai workers gọi payment trước khi claim/update vẫn có thể tạo hai external effects. Thêm idempotency protocol, trạng thái đang xử lý/unknown và reconciliation theo yêu cầu bài toán; không giữ một DB transaction mở qua network call chỉ để che vấn đề.

Acceptance gate

• Mọi legal edge thành công đúng một lần theo contract; mọi illegal edge bị từ chối và không phát sinh effect.
• Hai workers đọc cùng version: chỉ một transition commit; worker còn lại ghi nhận stale/conflict, đọc lại và quyết định theo command contract.
• Phát lại cùng command không tạo thêm external effect; command khác cùng key nhưng payload không tương thích phải được phát hiện.
• Crash sau provider effect nhưng trước local confirmation có recovery; compensation thất bại có trạng thái, retry/owner và ledger kiểm chứng.

Deliverables: transition matrix; hai implementation; báo cáo so code size/discoverability/testability; legal/illegal-edge tests; concurrent write report với version trước/sau; idempotency và compensation/reconciliation evidence. SQL trên là điểm bắt đầu, chưa phải toàn bộ order state machine.

Mục tiêu và cách làm

Chọn một module có thay đổi hoặc incident thật. Ghi lại behavior hiện có, tests bảo vệ và một thay đổi kế tiếp có thể kiểm chứng. So phương án không refactor, refactor nhỏ và pattern candidate trước khi chọn.

Checklist review bổ sung

• Nêu đúng problem, forces và scope; không lẫn GoF với architecture pattern.
• Chỉ rõ contract/invariant, owner của orchestration và transaction/external boundaries.
• So với simpler alternative; ghi indirection, config và operational cost tăng thêm.
• Có regression tests trước/sau, failure injection và evidence của thay đổi kế tiếp.
• Rollback nêu cả code/config lẫn dữ liệu, workflow đang chạy và effect đã phát sinh.

Acceptance / deliverables: decision record có đủ problem, rate of change, coupling, candidate, simpler alternative, migration, failure modes và rollback; diff đủ nhỏ để review; test report và một next-change comparison. Quyết định giữ nguyên thiết kế cũng hợp lệ khi evidence chưa ủng hộ abstraction mới.