Bagian 5: Refactoring dan Testing

{
    "name": "budi/pengelola-daftar-tugas",
    "description": "Pengelola daftar tugas berbasis CLI dengan penyimpanan JSON dan test suite PHPUnit.",
    "type": "project",
    "license": "MIT",
    "require": {
        "php": ">=8.3"
    },
    "require-dev": {
        "phpunit/phpunit": "^12.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "App\\Tests\\": "tests/"
        }
    },
    "scripts": {
        "test": "phpunit"
    }
}

<?php

declare(strict_types=1);

namespace App;

/**
 * Satu tugas sebagai value object immutable.
 *
 * Class ini readonly: seluruh properti tidak bisa diubah setelah
 * konstruktor selesai. Operasi "mengubah" tugas berarti membuat
 * instance baru, sehingga tidak ada kode lain yang bisa memermak
 * tugas secara diam-diam lewat referensi yang sama.
 */
final readonly class Task
{
    public function __construct(
        public int $id,
        public string $judul,
        public bool $selesai = false,
    ) {
    }

    /**
     * Kembalikan salinan tugas ini dengan status selesai.
     *
     * Instance asli tidak tersentuh — pemanggil memperoleh objek
     * baru, persis pola operasi array pada Bagian 2 dan 3.
     */
    public function tandaiSelesai(): self
    {
        return new self($this->id, $this->judul, true);
    }

    /** Bangun ulang tugas dari array hasil json_decode. */
    public static function dariArray(array $data): self
    {
        return new self(
            id: (int) ($data['id'] ?? 0),
            judul: (string) ($data['judul'] ?? ''),
            selesai: (bool) ($data['selesai'] ?? false),
        );
    }

    /** Bentuk array untuk disimpan ke JSON. */
    public function toArray(): array
    {
        return [
            'id' => $this->id,
            'judul' => $this->judul,
            'selesai' => $this->selesai,
        ];
    }
}

<?php

declare(strict_types=1);

namespace App;

/**
 * Penyimpanan dan pengambilan tugas dari berkas JSON.
 *
 * Jalur berkas disuntikkan lewat konstruktor (dependency injection),
 * sehingga pengujian bisa memakai berkas sementara tanpa menyentuh
 * data sungguhan — tidak ada lagi jalur yang tertanam di dalam fungsi.
 */
final class TaskRepository
{
    public function __construct(
        private readonly string $berkas,
    ) {
    }

    /**
     * Kembalikan seluruh tugas tersimpan.
     *
     * @return list<Task>
     */
    public function semua(): array
    {
        return array_map(
            static fn (array $data): Task => Task::dariArray($data),
            $this->bacaBerkas(),
        );
    }

    /**
     * Tambah tugas baru dan simpan; kembalikan tugas yang tersimpan.
     */
    public function tambah(string $judul): Task
    {
        $judul = trim($judul);

        if ($judul === '') {
            throw new \InvalidArgumentException('Judul tugas tidak boleh kosong.');
        }

        $baris = $this->bacaBerkas();
        $baru = new Task($this->idBerikutnya($baris), $judul);

        $baris[] = $baru->toArray();
        $this->tulisBerkas($baris);

        return $baru;
    }

    /**
     * Tandai tugas selesai dan simpan; kembalikan versi terbarunya.
     */
    public function tandaiSelesai(int $id): Task
    {
        $baris = $this->bacaBerkas();

        foreach ($baris as $i => $data) {
            if ((int) $data['id'] === $id) {
                $baris[$i] = Task::dariArray($data)->tandaiSelesai()->toArray();
                $this->tulisBerkas($baris);

                return Task::dariArray($baris[$i]);
            }
        }

        throw new \RuntimeException("Tugas dengan ID {$id} tidak ditemukan.");
    }

    /**
     * Hapus tugas dan simpan.
     */
    public function hapus(int $id): void
    {
        $baris = $this->bacaBerkas();

        foreach ($baris as $i => $data) {
            if ((int) $data['id'] === $id) {
                array_splice($baris, $i, 1);
                $this->tulisBerkas($baris);

                return;
            }
        }

        throw new \RuntimeException("Tugas dengan ID {$id} tidak ditemukan.");
    }

    /**
     * ID berikutnya: selalu terbesar yang ada ditambah satu.
     *
     * @param list<array> $baris
     */
    private function idBerikutnya(array $baris): int
    {
        $terbesar = 0;

        foreach ($baris as $data) {
            $terbesar = max($terbesar, (int) $data['id']);
        }

        return $terbesar + 1;
    }

    /**
     * Baca berkas JSON mentah sebagai daftar baris tugas.
     *
     * @return list<array>
     */
    private function bacaBerkas(): array
    {
        if (!is_file($this->berkas)) {
            return [];
        }

        $isi = file_get_contents($this->berkas);

        if ($isi === false) {
            throw new \RuntimeException("Gagal membaca berkas tugas: {$this->berkas}");
        }

        if (!json_validate($isi)) {
            throw new \RuntimeException('Berkas tugas rusak: JSON tidak valid.');
        }

        $baris = json_decode($isi, true);

        if (!is_array($baris)) {
            throw new \RuntimeException('Berkas tugas rusak: format tidak dikenal.');
        }

        return $baris;
    }

    /**
     * Tulis seluruh baris tugas ke berkas JSON.
     *
     * @param list<array> $baris
     */
    private function tulisBerkas(array $baris): void
    {
        $json = json_encode(
            $baris,
            JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR,
        );

        if (file_put_contents($this->berkas, $json . "\n", LOCK_EX) === false) {
            throw new \RuntimeException("Gagal menulis berkas tugas: {$this->berkas}");
        }
    }
}

<?php

declare(strict_types=1);

namespace App\Tests;

use App\Task;
use App\TaskRepository;
use PHPUnit\Framework\TestCase;

// Tanpa vendor/ hasil `composer install`, kita muat class secara manual.
// Setelah composer install, autoload PSR-4 yang mengambil alih peran ini.
require_once __DIR__ . '/../src/Task.php';
require_once __DIR__ . '/../src/TaskRepository.php';

final class TaskRepositoryTest extends TestCase
{
    private string $berkas;

    private TaskRepository $repository;

    protected function setUp(): void
    {
        // Fixture segar untuk tiap test: berkas unik di direktori
        // temporari, saling tidak mengganggu antar-test.
        $this->berkas = sys_get_temp_dir() . '/tugas-test-' . uniqid('', true) . '.json';
        $this->repository = new TaskRepository($this->berkas);
    }

    protected function tearDown(): void
    {
        if (is_file($this->berkas)) {
            unlink($this->berkas);
        }
    }

    public function testTambahMemberiIdBerurutan(): void
    {
        $pertama = $this->repository->tambah('Belajar PHP dasar');
        $kedua = $this->repository->tambah('Belajar OOP');

        $this->assertSame(1, $pertama->id);
        $this->assertSame(2, $kedua->id);
        $this->assertSame('Belajar PHP dasar', $pertama->judul);
        $this->assertFalse($pertama->selesai);
    }

    public function testSemuaMengembalikanSeluruhTugasTersimpan(): void
    {
        $this->repository->tambah('Belajar PHP dasar');
        $this->repository->tambah('Belajar OOP');

        $semua = $this->repository->semua();

        $this->assertCount(2, $semua);
        $this->assertSame('Belajar PHP dasar', $semua[0]->judul);
        $this->assertSame('Belajar OOP', $semua[1]->judul);
    }

    public function testSemuaMengembalikanKosongBilaBerkasBelumAda(): void
    {
        $this->assertSame([], $this->repository->semua());
    }

    public function testTandaiSelesaiMenyimpanStatusBaru(): void
    {
        $this->repository->tambah('Belajar PHP dasar');

        $hasil = $this->repository->tandaiSelesai(1);

        $this->assertTrue($hasil->selesai);
        $this->assertSame(1, $hasil->id);
        $this->assertTrue($this->repository->semua()[0]->selesai);
    }

    public function testHapusMengeluarkanTugasDariPenyimpanan(): void
    {
        $this->repository->tambah('Belajar PHP dasar');
        $this->repository->tambah('Belajar OOP');

        $this->repository->hapus(1);

        $semua = $this->repository->semua();
        $this->assertCount(1, $semua);
        $this->assertSame('Belajar OOP', $semua[0]->judul);
    }

    public function testTambahJudulKosongMelemparException(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('Judul tugas tidak boleh kosong.');

        $this->repository->tambah('   ');
    }

    public function testHapusIdTakDikenalMelemparException(): void
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('ID 99');

        $this->repository->hapus(99);
    }

    public function testTandaiSelesaiIdTakDikenalMelemparException(): void
    {
        $this->expectException(\RuntimeException::class);

        $this->repository->tandaiSelesai(42);
    }

    public function testBerkasRusakMelemparException(): void
    {
        file_put_contents($this->berkas, '[{"id":1,"judul":"Belajar PHP dasar"');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('JSON tidak valid');

        $this->repository->semua();
    }

    public function testPenyimpananBertahanAntarInstanceRepository(): void
    {
        $this->repository->tambah('Belajar PHP dasar');

        // Instance baru pada jalur berkas yang sama harus melihat
        // data yang sama — inilah arti persistensi.
        $repositoryBaru = new TaskRepository($this->berkas);

        $semua = $repositoryBaru->semua();
        $this->assertCount(1, $semua);
        $this->assertSame('Belajar PHP dasar', $semua[0]->judul);
    }

    public function testBerkasDisimpanSebagaiJsonMudahDibaca(): void
    {
        $this->repository->tambah('Belajar PHP dasar');

        $isi = (string) file_get_contents($this->berkas);

        $this->assertStringContainsString('"judul": "Belajar PHP dasar"', $isi);
        $this->assertStringContainsString('"selesai": false', $isi);
    }

    public function testTaskImmutableSaatTandaiSelesai(): void
    {
        $asli = new Task(id: 7, judul: 'Tugas contoh');
        $baru = $asli->tandaiSelesai();

        $this->assertNotSame($asli, $baru);
        $this->assertFalse($asli->selesai);
        $this->assertTrue($baru->selesai);
        $this->assertSame(7, $baru->id);
        $this->assertSame('Tugas contoh', $baru->judul);
    }

    public function testTaskRoundTripMelaluiArray(): void
    {
        $asli = new Task(id: 3, judul: 'Belajar PHP dasar', selesai: true);

        $hasil = Task::dariArray($asli->toArray());

        $this->assertSame(3, $hasil->id);
        $this->assertSame('Belajar PHP dasar', $hasil->judul);
        $this->assertTrue($hasil->selesai);
    }
}