Bagian 4: Authentication dan Testing

// RENTAN: equals berhenti pada karakter pertama yang berbeda, sehingga
// lama pembandingan membocorkan panjang awalan token yang benar.
boolean sah = tokenDiterima.equals(tokenRahasia);

// AMAN: MessageDigest.isEqual membandingkan seluruh byte dengan lama konstan.
boolean cocokKonstan = MessageDigest.isEqual(
        tokenRahasia.getBytes(StandardCharsets.UTF_8),
        tokenDiterima.getBytes(StandardCharsets.UTF_8));

import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

/**
 * Tanda tangan HMAC-SHA256 untuk token akses: menghitung dan memverifikasi
 * tanda tangan atas muatan token dengan kunci rahasia yang hanya dipegang
 * penerbit. Pembandingan memakai MessageDigest.isEqual sehingga lama
 * verifikasi tidak bergantung pada isi tanda tangan yang diperiksa.
 */
public final class TandaTangan {

    private TandaTangan() {
        // Kelas utilitas: seluruh anggota static, tidak perlu instance.
    }

    private static final char[] HEX = "0123456789abcdef".toCharArray();

    /**
     * Menghitung HMAC-SHA256 atas data dengan kunci rahasia.
     * Hasilnya teks heksadesimal kecil sepanjang 64 karakter (32 byte).
     */
    public static String hmacHex(String kunciRahasia, String data) {
        try {
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(
                    kunciRahasia.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
            return keHex(mac.doFinal(data.getBytes(StandardCharsets.UTF_8)));
        } catch (GeneralSecurityException e) {
            // HmacSHA256 wajib tersedia pada setiap implementasi JDK.
            throw new IllegalStateException("mesin HMAC tidak tersedia", e);
        }
    }

    /**
     * Memverifikasi tanda tangan atas muatan. Pembandingan memakai
     * MessageDigest.isEqual yang membandingkan seluruh byte tanpa berhenti
     * di byte pertama yang berbeda, sehingga waktu pembandingan tidak
     * membocorkan isi tanda tangan.
     */
    public static boolean cocok(String kunciRahasia, String muatan, String tandaDiterima) {
        String tandaDihitung = hmacHex(kunciRahasia, muatan);
        return MessageDigest.isEqual(
                tandaDihitung.getBytes(StandardCharsets.UTF_8),
                tandaDiterima.getBytes(StandardCharsets.UTF_8));
    }

    /** Mengubah byte menjadi teks heksadesimal kecil, dua karakter per byte. */
    private static String keHex(byte[] bytes) {
        StringBuilder hasil = new StringBuilder(bytes.length * 2);
        for (byte b : bytes) {
            hasil.append(HEX[(b >> 4) & 0xf]).append(HEX[b & 0xf]);
        }
        return hasil.toString();
    }
}

/**
 * Token akses bertanda tangan HMAC: muatan berisi nama pemegang dan saldo
 * permintaan, keduanya tidak bisa diubah klien tanpa merusak tanda tangan.
 * Bentuknya menyerupai JWT yang disederhanakan — muatan plus tanda tangan,
 * tanpa bagian header dan tanpa pengodean base64url — sehingga strukturnya
 * terbaca langsung.
 */
public record TokenAkses(String nama, int saldo) {

    public TokenAkses {
        if (nama == null || nama.strip().isEmpty()) {
            throw new IllegalArgumentException("nama token tidak boleh kosong");
        }
        if (nama.contains(":")) {
            throw new IllegalArgumentException("nama token tidak boleh mengandung ':'");
        }
        if (saldo < 0) {
            throw new IllegalArgumentException("saldo token tidak boleh negatif");
        }
        nama = nama.strip();
    }

    /** Muatan yang ditandatangani: nama dan saldo awal dipisah titik dua. */
    public String muatan() {
        return nama + ":" + saldo;
    }

    /** Token lengkap siap dikirim klien: muatan plus tanda tangan HMAC. */
    public String terbitkan(String kunciRahasia) {
        return muatan() + ":" + TandaTangan.hmacHex(kunciRahasia, muatan());
    }
}

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * Pintu autentikasi di depan router: memeriksa header Authorization sebelum
 * permintaan diteruskan ke handler target. Token berformat
 * "nama:saldo:tandaTangan" dengan tanda tangan HMAC-SHA256 atas muatan.
 * Permintaan tanpa token, dengan token palsu, atau dari token yang saldonya
 * habis dijawab 401 Unauthorized tanpa pernah menyentuh router.
 */
public class FilterAuth implements HttpHandler {

    private final HttpHandler target;
    private final String kunciRahasia;

    /**
     * Saldo tersisa per token. Handler bawaan HttpServer berjalan sekuensial
     * pada satu thread dispatcher sehingga HashMap cukup; bila server
     * dipasang executor, ganti ke ConcurrentHashMap.
     */
    private final Map<String, Integer> sisaSaldo = new HashMap<>();

    public FilterAuth(HttpHandler target, String kunciRahasia) {
        this.target = target;
        this.kunciRahasia = kunciRahasia;
    }

    @Override
    public void handle(HttpExchange exchange) throws IOException {
        try {
            verifikasi(exchange);
        } catch (ApiException e) {
            tolak(exchange, e.status(), e.getMessage());
            return;   // permintaan ditolak: router tidak dipanggil
        }
        target.handle(exchange);   // router punya penanganan galat dan penutupan exchange sendiri
    }

    /**
     * Memeriksa token akses pada header Authorization.
     * Melempar ApiException 401 bila permintaan tidak sah.
     */
    private void verifikasi(HttpExchange ex) {
        String header = ex.getRequestHeaders().getFirst("Authorization");
        if (header == null || header.isBlank()) {
            throw new ApiException(401, "header Authorization wajib berisi token akses");
        }
        if (!header.startsWith("Bearer ")) {
            throw new ApiException(401, "header Authorization harus berformat 'Bearer <token>',"
                    + " diterima: '" + header + "'");
        }
        String token = header.substring("Bearer ".length()).strip();

        // Tanda tangan heksadesimal tidak memuat ':', jadi titik dua terakhir
        // pasti menjadi pemisah antara muatan dan tanda tangan.
        int posisiTanda = token.lastIndexOf(':');
        if (posisiTanda < 0) {
            throw new ApiException(401, "token tidak berformat nama:saldo:tandaTangan");
        }
        String muatan = token.substring(0, posisiTanda);
        String tanda = token.substring(posisiTanda + 1);
        if (!TandaTangan.cocok(kunciRahasia, muatan, tanda)) {
            throw new ApiException(401, "tanda tangan token tidak cocok");
        }

        String[] bagi = muatan.split(":", 2);
        if (bagi.length != 2 || bagi[0].isBlank()) {
            throw new ApiException(401, "muatan token tidak berformat nama:saldo");
        }
        int saldoAwal;
        try {
            saldoAwal = Integer.parseInt(bagi[1]);
        } catch (NumberFormatException e) {
            throw new ApiException(401, "saldo pada muatan token bukan angka");
        }

        // Hanya permintaan bertoken sah yang mengurangi saldo.
        int sisa = sisaSaldo.getOrDefault(token, saldoAwal);
        if (sisa <= 0) {
            throw new ApiException(401, "saldo token '" + bagi[0] + "' habis");
        }
        sisaSaldo.put(token, sisa - 1);
    }

    /**
     * Menulis respons penolakan: body JSON, header WWW-Authenticate yang
     * diwajibkan RFC 7235 untuk setiap respons 401, lalu menutup exchange.
     */
    private static void tolak(HttpExchange ex, int status, String pesan) throws IOException {
        ex.getRequestBody().readAllBytes();   // buang body belum terbaca agar koneksi tetap sehat
        byte[] isi = JsonMini.error(pesan).getBytes(StandardCharsets.UTF_8);
        ex.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8");
        ex.getResponseHeaders().set("WWW-Authenticate", "Bearer realm=\"api-tugas\"");
        ex.sendResponseHeaders(status, isi.length);
        try (OutputStream os = ex.getResponseBody()) {
            os.write(isi);
        } finally {
            ex.close();
        }
    }
}

import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.Locale;

/**
 * Harness pengujian end-to-end seluruh API tugas: server dengan filter
 * autentikasi dan klien HttpClient berbagi satu proses yang sama. Dua puluh
 * dua pemeriksaan menutup autentikasi, CRUD, validasi, saldo token, dan
 * persistensi berkas. Exit code 1 bila ada kegagalan.
 */
public class UjiApi {

    /**
     * Kunci penandatanganan untuk pengujian. Di produksi, kunci dibaca dari
     * variabel lingkungan (misalnya System.getenv("API_KEY")) dan tidak
     * pernah ditulis di dalam kode sumber.
     */
    private static final String KUNCI = "kunci-uji-2026";

    private static int lulus = 0;
    private static int gagal = 0;

    public static void main(String[] args) throws Exception {
        Path berkas = Path.of("uji-tugas.txt");
        Files.deleteIfExists(berkas);   // mulai bersih agar uji dapat diulang

        HttpClient klien = HttpClient.newHttpClient();
        String tokenBudi = new TokenAkses("budi", 20).terbitkan(KUNCI);
        String tokenSiti = new TokenAkses("siti", 20).terbitkan(KUNCI);

        System.out.println("== Babak 1: permintaan tanpa token sah ==");
        HttpServer server = buatServer(berkas);
        try {
            String dasar = dasar(server);
            ujiTanpaToken(klien, dasar);
            ujiSkemaSalah(klien, dasar);
            ujiTokenPalsu(klien, dasar);
            ujiMuatanDiganti(klien, dasar, tokenBudi);
            ujiKunciLain(klien, dasar);

            System.out.println();
            System.out.println("== Babak 2: CRUD dan validasi dengan token sah ==");
            ujiBuatBaca(klien, dasar, tokenBudi);
            ujiUbahHapus(klien, dasar, tokenBudi);
            ujiValidasi(klien, dasar, tokenBudi);

            System.out.println();
            System.out.println("== Babak 3: saldo token habis ==");
            ujiSaldo(klien, dasar);
        } finally {
            server.stop(0);
        }

        System.out.println();
        System.out.println("== Babak 4: server baru memuat ulang berkas ==");
        HttpServer serverBaru = buatServer(berkas);
        try {
            ujiPersistensi(klien, dasar(serverBaru), tokenSiti);
        } finally {
            serverBaru.stop(0);
        }

        System.out.println();
        System.out.println("Ringkasan: " + lulus + " lulus, " + gagal + " gagal");
        if (gagal > 0) {
            System.exit(1);
        }
    }

    /** Server uji: router tugas dibungkus filter autentikasi, port dipilih sistem operasi. */
    private static HttpServer buatServer(Path berkas) throws IOException {
        HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
        server.createContext("/", new FilterAuth(
                new RouterTugas(new RepositoryBerkas(berkas)), KUNCI));
        server.start();
        return server;
    }

    /** Alamat dasar server; nomor port tidak dicetak agar keluaran deterministik. */
    private static String dasar(HttpServer server) {
        return "http://127.0.0.1:" + server.getAddress().getPort();
    }

    /** Satu pernyataan uji: catat PASS bila kondisi benar, FAIL bila salah. */
    private static void cek(String nama, boolean kondisi) {
        if (kondisi) {
            lulus++;
            System.out.println("PASS: " + nama);
        } else {
            gagal++;
            System.out.println("FAIL: " + nama);
        }
    }

    /**
     * Mengirim satu permintaan; nilai authorization null berarti tanpa header
     * Authorization sama sekali.
     */
    private static HttpResponse<String> minta(HttpClient klien, String dasar, String authorization,
            String metode, String path, String body) throws IOException, InterruptedException {
        HttpRequest.Builder b = HttpRequest.newBuilder()
                .uri(URI.create(dasar + path))
                .timeout(Duration.ofSeconds(5));
        if (authorization != null) {
            b.header("Authorization", authorization);
        }
        if (body == null) {
            b.method(metode, HttpRequest.BodyPublishers.noBody());
        } else {
            b.header("Content-Type", "application/json")
                    .method(metode, HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8));
        }
        return klien.send(b.build(), HttpResponse.BodyHandlers.ofString());
    }

    /** Mencetak status dan body respons secara ringkas, tanpa nomor port. */
    private static void lihat(String keterangan, HttpResponse<String> r) {
        System.out.printf(Locale.US, "  %-24s -> %d %s%n",
                keterangan, r.statusCode(), r.body());
    }

    private static void ujiTanpaToken(HttpClient klien, String dasar) throws Exception {
        HttpResponse<String> r = minta(klien, dasar, null, "GET", "/api/tugas", null);
        lihat("tanpa Authorization", r);
        cek("permintaan tanpa token dijawab 401",
                r.statusCode() == 401 && r.body().contains("Authorization"));
        cek("respons 401 menyertakan header WWW-Authenticate",
                r.headers().firstValue("WWW-Authenticate").isPresent());
    }

    private static void ujiSkemaSalah(HttpClient klien, String dasar) throws Exception {
        HttpResponse<String> r = minta(klien, dasar, "Basic teks-asli", "GET", "/api/tugas", null);
        lihat("skema Basic", r);
        cek("skema selain Bearer dijawab 401",
                r.statusCode() == 401 && r.body().contains("Bearer"));
    }

    private static void ujiTokenPalsu(HttpClient klien, String dasar) throws Exception {
        HttpResponse<String> r = minta(klien, dasar, "Bearer bukan-token", "GET", "/api/tugas", null);
        lihat("token tanpa tanda tangan", r);
        cek("token tanpa tanda tangan dijawab 401",
                r.statusCode() == 401 && r.body().contains("format"));
    }

    private static void ujiMuatanDiganti(HttpClient klien, String dasar, String tokenSah)
            throws Exception {
        // Muatan saldo diganti diam-diam menjadi 99; tanda tangan asli dipertahankan.
        String dipalsukan = "budi:99:" + tokenSah.substring(tokenSah.lastIndexOf(':') + 1);
        HttpResponse<String> r = minta(klien, dasar, "Bearer " + dipalsukan, "GET", "/api/tugas", null);
        lihat("muatan diganti", r);
        cek("muatan yang diganti dijawab 401",
                r.statusCode() == 401 && r.body().contains("tanda tangan"));
    }

    private static void ujiKunciLain(HttpClient klien, String dasar) throws Exception {
        String tokenLain = new TokenAkses("budi", 20).terbitkan("kunci-yang-salah");
        HttpResponse<String> r = minta(klien, dasar, "Bearer " + tokenLain, "GET", "/api/tugas", null);
        lihat("kunci penandatangan lain", r);
        cek("token tertanda kunci lain dijawab 401",
                r.statusCode() == 401 && r.body().contains("tanda tangan"));
    }

    private static void ujiBuatBaca(HttpClient klien, String dasar, String token) throws Exception {
        String otorisasi = "Bearer " + token;
        HttpResponse<String> buat = minta(klien, dasar, otorisasi, "POST", "/api/tugas",
                "{\"judul\":\"Belajar HttpServer\",\"pemilik\":\"Budi\","
                        + "\"status\":\"SELESAI\",\"tenggat\":\"2026-01-20\"}");
        cek("POST dengan token sah menghasilkan 201 dan id 1",
                buat.statusCode() == 201 && buat.body().contains("\"id\":1"));
        cek("status SELESAI dari klien diabaikan, server menetapkan TODO",
                buat.body().contains("\"status\":\"TODO\""));

        HttpResponse<String> detail = minta(klien, dasar, otorisasi, "GET", "/api/tugas/1", null);
        cek("GET detail mengembalikan tugas yang tersimpan",
                detail.statusCode() == 200 && detail.body().contains("Belajar HttpServer"));
    }

    private static void ujiUbahHapus(HttpClient klien, String dasar, String token) throws Exception {
        String otorisasi = "Bearer " + token;
        HttpResponse<String> ubah = minta(klien, dasar, otorisasi, "PUT", "/api/tugas/1",
                "{\"judul\":\"Belajar HttpServer\",\"pemilik\":\"Budi\","
                        + "\"status\":\"SELESAI\",\"tenggat\":\"2026-01-20\"}");
        cek("PUT mengubah status menjadi SELESAI",
                ubah.statusCode() == 200 && ubah.body().contains("\"status\":\"SELESAI\""));

        HttpResponse<String> hapus = minta(klien, dasar, otorisasi, "DELETE", "/api/tugas/1", null);
        cek("DELETE menghapus tugas dan menjawab 200",
                hapus.statusCode() == 200 && hapus.body().contains("dihapus"));

        HttpResponse<String> hilang = minta(klien, dasar, otorisasi, "GET", "/api/tugas/1", null);
        cek("tugas yang terhapus dijawab 404",
                hilang.statusCode() == 404 && hilang.body().contains("tidak ditemukan"));

        // Dua tugas baru untuk babak persistensi; id tidak mengulang id yang dihapus.
        minta(klien, dasar, otorisasi, "POST", "/api/tugas",
                "{\"judul\":\"Belajar HttpServer\",\"pemilik\":\"Budi\",\"tenggat\":\"2026-01-20\"}");
        HttpResponse<String> siti = minta(klien, dasar, otorisasi, "POST", "/api/tugas",
                "{\"judul\":\"Tulis dokumentasi API\",\"pemilik\":\"Siti\",\"tenggat\":\"2026-02-01\"}");
        cek("id baru berlanjut tanpa mengulang id terhapus",
                siti.statusCode() == 201 && siti.body().contains("\"id\":3"));

        HttpResponse<String> daftar = minta(klien, dasar, otorisasi, "GET", "/api/tugas", null);
        cek("daftar berisi dua tugas tersisa",
                daftar.statusCode() == 200 && daftar.body().split("\"id\":", -1).length == 3);
    }

    private static void ujiValidasi(HttpClient klien, String dasar, String token) throws Exception {
        String otorisasi = "Bearer " + token;
        HttpResponse<String> tanpaPemilik = minta(klien, dasar, otorisasi, "POST", "/api/tugas",
                "{\"judul\":\"Tugas tanpa pemilik\",\"tenggat\":\"2026-01-22\"}");
        cek("payload tanpa pemilik dijawab 400",
                tanpaPemilik.statusCode() == 400
                        && tanpaPemilik.body().contains("pemilik wajib diisi"));

        HttpResponse<String> rusak = minta(klien, dasar, otorisasi, "POST", "/api/tugas",
                "{\"judul\":");
        cek("JSON rusak dijawab 400",
                rusak.statusCode() == 400 && rusak.body().contains("JSON tidak valid"));

        HttpResponse<String> tambal = minta(klien, dasar, otorisasi, "PATCH", "/api/tugas/2", null);
        cek("PATCH dijawab 405",
                tambal.statusCode() == 405 && tambal.body().contains("PATCH"));

        HttpResponse<String> asing = minta(klien, dasar, otorisasi, "GET", "/api/pengguna", null);
        cek("endpoint tidak dikenal dijawab 404",
                asing.statusCode() == 404 && asing.body().contains("endpoint"));
    }

    private static void ujiSaldo(HttpClient klien, String dasar) throws Exception {
        String tokenKuota = new TokenAkses("kuota", 2).terbitkan(KUNCI);
        HttpResponse<String> pertama = minta(klien, dasar, "Bearer " + tokenKuota,
                "GET", "/api/tugas", null);
        HttpResponse<String> kedua = minta(klien, dasar, "Bearer " + tokenKuota,
                "GET", "/api/tugas/2", null);
        cek("token bersaldo 2 melayani dua permintaan pertama",
                pertama.statusCode() == 200 && kedua.statusCode() == 200);

        HttpResponse<String> ketiga = minta(klien, dasar, "Bearer " + tokenKuota,
                "GET", "/api/tugas", null);
        lihat("permintaan ketiga", ketiga);
        cek("permintaan ketiga dijawab 401 karena saldo habis",
                ketiga.statusCode() == 401 && ketiga.body().contains("saldo"));
    }

    private static void ujiPersistensi(HttpClient klien, String dasar, String token) throws Exception {
        String otorisasi = "Bearer " + token;
        HttpResponse<String> daftar = minta(klien, dasar, otorisasi, "GET", "/api/tugas", null);
        cek("tugas bertahan melewati restart server",
                daftar.statusCode() == 200 && daftar.body().contains("Tulis dokumentasi API"));

        HttpResponse<String> lanjutan = minta(klien, dasar, otorisasi, "POST", "/api/tugas",
                "{\"judul\":\"Rapat tim mingguan\",\"pemilik\":\"Dewi\",\"tenggat\":\"2026-02-10\"}");
        cek("id berlanjut dari isi berkas setelah restart",
                lanjutan.statusCode() == 201 && lanjutan.body().contains("\"id\":4"));
    }
}

== Babak 1: permintaan tanpa token sah ==
  tanpa Authorization      -> 401 {"error":"header Authorization wajib berisi token akses"}
PASS: permintaan tanpa token dijawab 401
PASS: respons 401 menyertakan header WWW-Authenticate
  skema Basic              -> 401 {"error":"header Authorization harus berformat 'Bearer <token>', diterima: 'Basic teks-asli'"}
PASS: skema selain Bearer dijawab 401
  token tanpa tanda tangan -> 401 {"error":"token tidak berformat nama:saldo:tandaTangan"}
PASS: token tanpa tanda tangan dijawab 401
  muatan diganti           -> 401 {"error":"tanda tangan token tidak cocok"}
PASS: muatan yang diganti dijawab 401
  kunci penandatangan lain -> 401 {"error":"tanda tangan token tidak cocok"}
PASS: token tertanda kunci lain dijawab 401

== Babak 2: CRUD dan validasi dengan token sah ==
PASS: POST dengan token sah menghasilkan 201 dan id 1
PASS: status SELESAI dari klien diabaikan, server menetapkan TODO
PASS: GET detail mengembalikan tugas yang tersimpan
PASS: PUT mengubah status menjadi SELESAI
PASS: DELETE menghapus tugas dan menjawab 200
PASS: tugas yang terhapus dijawab 404
PASS: id baru berlanjut tanpa mengulang id terhapus
PASS: daftar berisi dua tugas tersisa
PASS: payload tanpa pemilik dijawab 400
PASS: JSON rusak dijawab 400
PASS: PATCH dijawab 405
PASS: endpoint tidak dikenal dijawab 404

== Babak 3: saldo token habis ==
PASS: token bersaldo 2 melayani dua permintaan pertama
  permintaan ketiga        -> 401 {"error":"saldo token 'kuota' habis"}
PASS: permintaan ketiga dijawab 401 karena saldo habis

== Babak 4: server baru memuat ulang berkas ==
PASS: tugas bertahan melewati restart server
PASS: id berlanjut dari isi berkas setelah restart

Ringkasan: 22 lulus, 0 gagal

import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

class FilterAuthTest {

    private HttpServer server;
    private HttpClient klien;
    private String dasar;

    @BeforeEach
    void naikkanServer() throws IOException {
        server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
        server.createContext("/", new FilterAuth(
                new RouterTugas(new RepositoryMemori()), "kunci-uji-2026"));
        server.start();
        dasar = "http://127.0.0.1:" + server.getAddress().getPort();
        klien = HttpClient.newHttpClient();
    }

    @AfterEach
    void matikanServer() {
        server.stop(0);
    }

    @Test
    void permintaanTanpaTokenDijawab401() throws Exception {
        HttpResponse<String> r = klien.send(
                HttpRequest.newBuilder(URI.create(dasar + "/api/tugas")).build(),
                HttpResponse.BodyHandlers.ofString());
        assertEquals(401, r.statusCode());
        assertTrue(r.headers().firstValue("WWW-Authenticate").isPresent());
    }

    @Test
    void muatanYangDigantiDitolak() throws Exception {
        String sah = new TokenAkses("budi", 20).terbitkan("kunci-uji-2026");
        String dipalsukan = "budi:99:" + sah.substring(sah.lastIndexOf(':') + 1);
        HttpResponse<String> r = klien.send(
                HttpRequest.newBuilder(URI.create(dasar + "/api/tugas"))
                        .header("Authorization", "Bearer " + dipalsukan).build(),
                HttpResponse.BodyHandlers.ofString());
        assertEquals(401, r.statusCode());
        assertTrue(r.body().contains("tanda tangan"));
    }
}