Bagian 4: Testing dan Deployment

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.time.LocalDate;
import java.util.Base64;
import java.util.List;

/**
 * Harness pengujian bertingkat aplikasi web manajemen tugas. Tingkat 1
 * menguji unit tanpa jaringan: ValidasiWeb, LayananTugasWeb dengan repository
 * memori, dan RepositoryTugasWebBerkas. Tingkat 2 menguji integrasi HTTP
 * in-process: FilterTokenWeb membungkus RouterWeb di atas HttpServer yang
 * mendengarkan 127.0.0.1 pada port pilihan sistem operasi (nomor port tidak
 * dicetak agar keluaran deterministik), lalu satu HttpClient mengirim seluruh
 * permintaan secara sekuensial. Exit code 1 bila ada kegagalan.
 */
public class UjiAplikasiWeb {

    /** Hari operasional beku: aturan "tenggat lampau" diuji tanpa LocalDate.now(). */
    private static final LocalDate HARI = LocalDate.of(2026, 1, 15);

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

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

        System.out.println("== Tingkat 1: unit tanpa jaringan ==");
        ujiValidasi();
        ujiLayanan();
        ujiRepositoryBerkas(berkasRepo);

        System.out.println();
        System.out.println("== Tingkat 2: integrasi HTTP dengan filter aktif ==");
        HttpClient klien = HttpClient.newHttpClient();
        HttpServer server = mulai(berkasIntegrasi);
        try {
            String dasar = dasar(server);
            ujiAutentikasi(klien, dasar);
            ujiCrud(klien, dasar);
        } finally {
            server.stop(0);
        }

        System.out.println();
        System.out.println("== Tingkat 2 (lanjutan): server baru memuat berkas ==");
        HttpServer serverBaru = mulai(berkasIntegrasi);
        try {
            ujiPersistensi(klien, dasar(serverBaru));
        } finally {
            serverBaru.stop(0);
        }

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

    /** Tingkat 1a: validasi bentuk field mengumpulkan galat, bukan berhenti di awal. */
    private static void ujiValidasi() {
        List<String> sah = ValidasiWeb.periksa(new PermintaanTugas(
                "Belajar arsitektur berlapis", "Budi", "2026-02-01"));
        periksa("validasi: muatan sah tidak memuat galat", sah.isEmpty());

        List<String> judul = ValidasiWeb.periksa(new PermintaanTugas(
                "ab", "Budi", "2026-02-01"));
        periksa("validasi: judul terlalu pendek ditolak",
                judul.size() == 1 && judul.get(0).startsWith("judul"));

        List<String> pemilik = ValidasiWeb.periksa(new PermintaanTugas(
                "Menulis dokumentasi API", "", "2026-02-01"));
        periksa("validasi: pemilik kosong ditolak",
                pemilik.size() == 1 && pemilik.get(0).startsWith("pemilik"));

        List<String> tenggat = ValidasiWeb.periksa(new PermintaanTugas(
                "Menulis dokumentasi API", "Budi", "besok"));
        periksa("validasi: tenggat bukan format ISO ditolak",
                tenggat.size() == 1 && tenggat.get(0).startsWith("tenggat"));

        List<String> pipa = ValidasiWeb.periksa(new PermintaanTugas(
                "Riset|keamanan", "Budi", "2026-02-01"));
        periksa("validasi: karakter pipa ditolak",
                pipa.size() == 1 && pipa.get(0).contains("|"));

        List<String> semuaSalah = ValidasiWeb.periksa(new PermintaanTugas(
                "ab", "", "besok"));
        periksa("validasi: tiga galat terkumpul sekaligus", semuaSalah.size() == 3);
    }

    /** Tingkat 1b: aturan bisnis layanan dengan repository memori dan hari beku. */
    private static void ujiLayanan() {
        LayananTugasWeb layanan = new LayananTugasWeb(
                new RepositoryTugasWebMemori(), HARI);

        TugasWeb tugas = layanan.buat(new PermintaanTugas(
                "Belajar arsitektur berlapis", "Budi", "2026-02-01"));
        periksa("layanan: buat menetapkan status TODO",
                tugas.status() == StatusTugasWeb.TODO);
        periksa("layanan: buat menetapkan id mulai 1", tugas.id() == 1);

        periksa("layanan: tenggat lampau ditolak status 400",
                menolak(() -> layanan.buat(new PermintaanTugas(
                        "Riset keamanan", "Dewi", "2026-01-01")),
                        ValidasiGagalException.class, 400));

        TugasWeb selesai = layanan.tandaiSelesai(1);
        periksa("layanan: tandaiSelesai memindahkan status ke SELESAI",
                selesai.status() == StatusTugasWeb.SELESAI);
        periksa("layanan: tandaiSelesai kedua kali ditolak status 409",
                menolak(() -> layanan.tandaiSelesai(1),
                        AturanBisnisException.class, 409));

        TugasWeb revisi = layanan.ubah(1, new PermintaanTugas(
                "Belajar arsitektur berlapis (revisi)", "Budi", "2026-02-08"));
        periksa("layanan: ubah mempertahankan status dan id",
                revisi.status() == StatusTugasWeb.SELESAI && revisi.id() == 1);

        periksa("layanan: cari id tidak ada melempar status 404",
                menolak(() -> layanan.cari(99),
                        TugasTidakDitemukanException.class, 404));

        LayananTugasWeb kuota = new LayananTugasWeb(
                new RepositoryTugasWebMemori(), HARI);
        for (int i = 1; i <= LayananTugasWeb.BATAS_TUGAS_AKTIF; i++) {
            kuota.buat(new PermintaanTugas("Tugas kantor " + i, "Dewi", "2026-03-02"));
        }
        periksa("layanan: tugas keenam pemilik sama ditolak status 409",
                menolak(() -> kuota.buat(new PermintaanTugas(
                        "Tugas kantor 6", "Dewi", "2026-03-02")),
                        AturanBisnisException.class, 409));
    }

    /** Tingkat 1c: repository berkas menulis, memuat kembali, dan meneruskan id. */
    private static void ujiRepositoryBerkas(Path berkas) throws IOException {
        RepositoryTugasWebBerkas repository = new RepositoryTugasWebBerkas(berkas);
        repository.simpanBaru(new TugasWeb(0, "Belajar arsitektur berlapis", "Budi",
                StatusTugasWeb.TODO, LocalDate.of(2026, 2, 1)));

        periksa("repository: mutasi menulis berkas", Files.exists(berkas));
        periksa("repository: baris berkas berformat pipa",
                Files.readAllLines(berkas, StandardCharsets.UTF_8).get(0)
                        .equals("1|Belajar arsitektur berlapis|Budi|TODO|2026-02-01"));

        RepositoryTugasWebBerkas termuat = new RepositoryTugasWebBerkas(berkas);
        periksa("repository: berkas dimuat kembali",
                termuat.jumlahTermuat() == 1 && termuat.cari(1).isPresent());
        periksa("repository: id berlanjut dari tertinggi",
                termuat.simpanBaru(new TugasWeb(0, "Riset keamanan aplikasi web",
                        "Dewi", StatusTugasWeb.TODO, LocalDate.of(2026, 1, 25))).id() == 2);
    }

    /** Tingkat 2a: gerbang keamanan menolak permintaan tanpa identitas sah. */
    private static void ujiAutentikasi(HttpClient klien, String dasar)
            throws IOException, InterruptedException {
        HttpResponse<String> tanpa = minta(klien, dasar, null, "GET", "/api/tugas", null);
        periksa("integrasi: tanpa kredensial dijawab 401", tanpa.statusCode() == 401);
        periksa("integrasi: penolakan memuat WWW-Authenticate",
                tanpa.headers().firstValue("WWW-Authenticate").isPresent());

        HttpResponse<String> salah = minta(klien, dasar,
                basic("budi", "sandi-salah"), "GET", "/api/tugas", null);
        periksa("integrasi: sandi salah dijawab 401 dengan body JSON",
                salah.statusCode() == 401 && salah.body().contains("\"status\":401"));
    }

    /** Tingkat 2b: CRUD, validasi, dan otorisasi melalui HTTP sungguhan. */
    private static void ujiCrud(HttpClient klien, String dasar)
            throws IOException, InterruptedException {
        String budi = basic("budi", "sandi-budi");
        String siti = basic("siti", "sandi-siti");

        HttpResponse<String> galat = minta(klien, dasar, budi, "POST", "/api/tugas",
                "{\"judul\":\"ab\",\"pemilik\":\"\",\"tenggat\":\"besok\"}");
        periksa("integrasi: muatan salah dijawab 400 dengan rincian",
                galat.statusCode() == 400 && galat.body().contains("\"galat\":["));

        HttpResponse<String> dibuat = minta(klien, dasar, budi, "POST", "/api/tugas",
                "{\"judul\":\"Belajar arsitektur berlapis\",\"pemilik\":\"Budi\","
                        + "\"tenggat\":\"2026-02-01\"}");
        periksa("integrasi: POST sah dijawab 201 dengan Location",
                dibuat.statusCode() == 201
                        && dibuat.headers().firstValue("Location").orElse("")
                                .equals("/api/tugas/1"));

        minta(klien, dasar, budi, "POST", "/api/tugas",
                "{\"judul\":\"Riset keamanan aplikasi web\",\"pemilik\":\"Dewi\","
                        + "\"tenggat\":\"2026-01-25\"}");

        HttpResponse<String> daftar = minta(klien, dasar, budi, "GET", "/api/tugas", null);
        periksa("integrasi: GET daftar menampilkan dua tugas",
                daftar.statusCode() == 200 && daftar.body().contains("\"id\":2"));

        HttpResponse<String> hilang = minta(klien, dasar, budi, "GET", "/api/tugas/99", null);
        periksa("integrasi: id tidak ada dijawab 404", hilang.statusCode() == 404);

        HttpResponse<String> asing = minta(klien, dasar, budi, "PATCH", "/api/tugas/1", null);
        periksa("integrasi: metode asing dijawab 405", asing.statusCode() == 405);

        HttpResponse<String> terlarang = minta(klien, dasar, budi,
                "DELETE", "/api/tugas/1", null);
        periksa("integrasi: DELETE oleh ANGGOTA dijawab 403",
                terlarang.statusCode() == 403);

        HttpResponse<String> terhapus = minta(klien, dasar, siti,
                "DELETE", "/api/tugas/1", null);
        periksa("integrasi: DELETE oleh ADMIN dijawab 204",
                terhapus.statusCode() == 204);
    }

    /** Tingkat 2c: server baru atas berkas yang sama membuktikan persistensi. */
    private static void ujiPersistensi(HttpClient klien, String dasar)
            throws IOException, InterruptedException {
        String siti = basic("siti", "sandi-siti");

        HttpResponse<String> daftar = minta(klien, dasar, siti, "GET", "/api/tugas", null);
        periksa("persistensi: tugas tersisa termuat setelah restart",
                daftar.statusCode() == 200 && daftar.body().contains("\"id\":2")
                        && !daftar.body().contains("\"id\":1"));

        HttpResponse<String> lanjut = minta(klien, dasar, siti, "POST", "/api/tugas",
                "{\"judul\":\"Menulis dokumentasi API\",\"pemilik\":\"Siti\","
                        + "\"tenggat\":\"2026-01-20\"}");
        periksa("persistensi: id baru berlanjut setelah restart",
                lanjut.statusCode() == 201
                        && lanjut.headers().firstValue("Location").orElse("")
                                .equals("/api/tugas/3"));
    }

    /** Server uji: filter keamanan membungkus router di atas repository berkas. */
    private static HttpServer mulai(Path berkas) throws IOException {
        LayananTugasWeb layanan = new LayananTugasWeb(
                new RepositoryTugasWebBerkas(berkas), HARI);
        HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
        server.createContext("/", new FilterTokenWeb(new RouterWeb(layanan),
                new PenggunaWeb("budi", "sandi-budi", PenggunaWeb.Peran.ANGGOTA),
                new PenggunaWeb("siti", "sandi-siti", PenggunaWeb.Peran.ADMIN)));
        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();
    }

    /** Header Authorization Basic dari pasangan nama dan sandi. */
    private static String basic(String nama, String sandi) {
        byte[] oktet = (nama + ":" + sandi).getBytes(StandardCharsets.UTF_8);
        return "Basic " + Base64.getEncoder().encodeToString(oktet);
    }

    /**
     * Mengirim satu permintaan; 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());
    }

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

    /**
     * Menjalankan perintah; true bila melempar exception bertepatan jenis dan
     * status. Perbandingan getClass() menolak exception salah jenis, dan status
     * dibaca lewat ApiException sehingga angka HTTP ikut diperiksa.
     */
    private static boolean menolak(Perintah perintah,
            Class<? extends ApiException> jenis, int status) {
        try {
            perintah.jalankan();
            return false;
        } catch (Exception e) {
            return e.getClass() == jenis && ((ApiException) e).status() == status;
        }
    }

    /** Antarmuka satu method agar blok uji bisa melempar exception terperiksa. */
    interface Perintah {
        void jalankan() throws Exception;
    }
}

== Tingkat 1: unit tanpa jaringan ==
PASS: validasi: muatan sah tidak memuat galat
PASS: validasi: judul terlalu pendek ditolak
PASS: validasi: pemilik kosong ditolak
PASS: validasi: tenggat bukan format ISO ditolak
PASS: validasi: karakter pipa ditolak
PASS: validasi: tiga galat terkumpul sekaligus
PASS: layanan: buat menetapkan status TODO
PASS: layanan: buat menetapkan id mulai 1
PASS: layanan: tenggat lampau ditolak status 400
PASS: layanan: tandaiSelesai memindahkan status ke SELESAI
PASS: layanan: tandaiSelesai kedua kali ditolak status 409
PASS: layanan: ubah mempertahankan status dan id
PASS: layanan: cari id tidak ada melempar status 404
PASS: layanan: tugas keenam pemilik sama ditolak status 409
PASS: repository: mutasi menulis berkas
PASS: repository: baris berkas berformat pipa
PASS: repository: berkas dimuat kembali
PASS: repository: id berlanjut dari tertinggi

== Tingkat 2: integrasi HTTP dengan filter aktif ==
PASS: integrasi: tanpa kredensial dijawab 401
PASS: integrasi: penolakan memuat WWW-Authenticate
PASS: integrasi: sandi salah dijawab 401 dengan body JSON
PASS: integrasi: muatan salah dijawab 400 dengan rincian
PASS: integrasi: POST sah dijawab 201 dengan Location
PASS: integrasi: GET daftar menampilkan dua tugas
PASS: integrasi: id tidak ada dijawab 404
PASS: integrasi: metode asing dijawab 405
PASS: integrasi: DELETE oleh ANGGOTA dijawab 403
PASS: integrasi: DELETE oleh ADMIN dijawab 204

== Tingkat 2 (lanjutan): server baru memuat berkas ==
PASS: persistensi: tugas tersisa termuat setelah restart
PASS: persistensi: id baru berlanjut setelah restart

Ringkasan: 30 lulus, 0 gagal

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

import java.time.LocalDate;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class UjiLayananTugas {

    @Test
    void tenggatLampauDitolak() {
        LayananTugas layanan = new LayananTugas(
                new RepositoryTugasMemori(), LocalDate.of(2026, 1, 15));
        ValidasiGagalException galat = assertThrows(ValidasiGagalException.class,
                () -> layanan.buat(new PermintaanTugasDto("Riset keamanan", "Dewi", "2026-01-01")));
        assertEquals(400, galat.status());
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.web.servlet.MockMvc;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest(TugasController.class)
class UjiWebTugas {

    @Autowired
    private MockMvc mockMvc;

    @MockitoBean
    private LayananTugas layanan;

    @Test
    void idTidakAdaDijawab404() throws Exception {
        when(layanan.cari(99)).thenThrow(new TugasTidakDitemukanException(99));
        mockMvc.perform(get("/api/tugas/99"))
                .andExpect(status().isNotFound());
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UjiAplikasiPenuh {

    @Autowired
    private TestRestTemplate klien;

    @Test
    void tanpaKredensialDijawab401() {
        ResponseEntity<String> respons = klien.getForEntity("/api/tugas", String.class);
        assertEquals(HttpStatus.UNAUTHORIZED, respons.getStatusCode());
    }

    @Test
    void muatanSalahDijawab400() {
        ResponseEntity<String> respons = klien.withBasicAuth("budi", "sandi-budi")
                .postForEntity("/api/tugas",
                        new PermintaanTugasDto("ab", "", "besok"), String.class);
        assertEquals(HttpStatus.BAD_REQUEST, respons.getStatusCode());
    }
}

$ javac -d kelas *.java
$ jar --create --file aplikasi-web.jar --main-class AplikasiWeb -C kelas .
$ jar --list --file aplikasi-web.jar
META-INF/
META-INF/MANIFEST.MF
ApiException.class
AplikasiWeb.class
AturanBisnisException.class
FilterTokenWeb.class
JsonWeb$Pembaca.class
JsonWeb.class
LayananTugasWeb.class
PenggunaWeb$Peran.class
PenggunaWeb.class
PermintaanTugas.class
RepositoryTugasWeb.class
RepositoryTugasWebBerkas.class
RepositoryTugasWebMemori.class
RouterWeb$Endpoint.class
RouterWeb$ResponsWeb.class
RouterWeb.class
StatusTugasWeb.class
TugasTidakDitemukanException.class
TugasWeb.class
UjiAplikasiWeb$Perintah.class
UjiAplikasiWeb.class
ValidasiGagalException.class
ValidasiWeb.class

$ java -jar aplikasi-web.jar
=== AplikasiWeb Bagian 3: persistensi + keamanan ===
[Bootstrap] tugas-web.txt disiapkan bersih
[Bootstrap] pengguna terdaftar: budi (ANGGOTA), siti (ADMIN)

== Sesi 1: server pertama ==
[Bootstrap] repository berkas siap: 0 tugas termuat
GET     /api/tugas      -> 401 WWW-Authenticate=Basic realm="tugas-web", charset="UTF-8" {"status":401,"pesan":"header Authorization wajib berformat 'Basic <kredensial>'"}
GET     /api/tugas      -> 401 WWW-Authenticate=Basic realm="tugas-web", charset="UTF-8" {"status":401,"pesan":"header Authorization wajib berformat 'Basic <kredensial>'"}
GET     /api/tugas      -> 401 {"status":401,"pesan":"nama atau sandi salah"}
POST    /api/tugas      -> 201 {"id":1,"judul":"Belajar arsitektur berlapis","pemilik":"Budi","status":"TODO","tenggat":"2026-02-01"}
POST    /api/tugas      -> 201 {"id":2,"judul":"Riset keamanan aplikasi web","pemilik":"Dewi","status":"TODO","tenggat":"2026-01-25"}
DELETE  /api/tugas/1    -> 403 {"status":403,"pesan":"menghapus tugas memerlukan peran ADMIN (terautentikasi sebagai budi)"}
DELETE  /api/tugas/1    -> 204 (tanpa body)
GET     /api/tugas      -> 200 [{"id":2,"judul":"Riset keamanan aplikasi web","pemilik":"Dewi","status":"TODO","tenggat":"2026-01-25"}]

== Sesi 2: server baru memuat berkas yang sama ==
[Bootstrap] repository berkas siap: 1 tugas termuat
GET     /api/tugas      -> 200 [{"id":2,"judul":"Riset keamanan aplikasi web","pemilik":"Dewi","status":"TODO","tenggat":"2026-01-25"}]
POST    /api/tugas      -> 201 {"id":3,"judul":"Menulis dokumentasi API","pemilik":"Siti","status":"TODO","tenggat":"2026-01-20"}

[Bootstrap] kedua server berhenti; data bertahan di tugas-web.txt

$ java -cp aplikasi-web.jar UjiAplikasiWeb
== Tingkat 1: unit tanpa jaringan ==
PASS: validasi: muatan sah tidak memuat galat
PASS: validasi: judul terlalu pendek ditolak
PASS: validasi: pemilik kosong ditolak
PASS: validasi: tenggat bukan format ISO ditolak
PASS: validasi: karakter pipa ditolak
PASS: validasi: tiga galat terkumpul sekaligus
PASS: layanan: buat menetapkan status TODO
PASS: layanan: buat menetapkan id mulai 1
PASS: layanan: tenggat lampau ditolak status 400
PASS: layanan: tandaiSelesai memindahkan status ke SELESAI
PASS: layanan: tandaiSelesai kedua kali ditolak status 409
PASS: layanan: ubah mempertahankan status dan id
PASS: layanan: cari id tidak ada melempar status 404
PASS: layanan: tugas keenam pemilik sama ditolak status 409
PASS: repository: mutasi menulis berkas
PASS: repository: baris berkas berformat pipa
PASS: repository: berkas dimuat kembali
PASS: repository: id berlanjut dari tertinggi

== Tingkat 2: integrasi HTTP dengan filter aktif ==
PASS: integrasi: tanpa kredensial dijawab 401
PASS: integrasi: penolakan memuat WWW-Authenticate
PASS: integrasi: sandi salah dijawab 401 dengan body JSON
PASS: integrasi: muatan salah dijawab 400 dengan rincian
PASS: integrasi: POST sah dijawab 201 dengan Location
PASS: integrasi: GET daftar menampilkan dua tugas
PASS: integrasi: id tidak ada dijawab 404
PASS: integrasi: metode asing dijawab 405
PASS: integrasi: DELETE oleh ANGGOTA dijawab 403
PASS: integrasi: DELETE oleh ADMIN dijawab 204

== Tingkat 2 (lanjutan): server baru memuat berkas ==
PASS: persistensi: tugas tersisa termuat setelah restart
PASS: persistensi: id baru berlanjut setelah restart

Ringkasan: 30 lulus, 0 gagal

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

FROM maven:3.9-eclipse-temurin-25 AS bangun
WORKDIR /app
COPY pom.xml .
RUN mvn --no-transfer-progress dependency:go-offline
COPY src ./src
RUN mvn --no-transfer-progress package

FROM eclipse-temurin:25-jre
WORKDIR /app
COPY --from=bangun /app/target/aplikasi-web-spring-boot-1.0.0.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]