Test Fixture

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"slices"
	"strings"
)

// Katalog menyimpan daftar nama produk sebagai berkas JSON di dalam
// sebuah direktori.
type Katalog struct {
	direktori string
}

// KatalogBaru menyiapkan katalog yang menyimpan datanya di dalam
// direktori tersebut.
func KatalogBaru(direktori string) (*Katalog, error) {
	if err := os.MkdirAll(direktori, 0o755); err != nil {
		return nil, fmt.Errorf("siapkan direktori: %w", err)
	}
	return &Katalog{direktori: direktori}, nil
}

// Simpan menyimpan daftar nama produk dengan kunci id.
func (k *Katalog) Simpan(id string, nama []string) error {
	berkas := filepath.Join(k.direktori, id+".json")
	data, err := json.Marshal(nama)
	if err != nil {
		return fmt.Errorf("marshal %s: %w", id, err)
	}
	if err := os.WriteFile(berkas, data, 0o644); err != nil {
		return fmt.Errorf("tulis %s: %w", berkas, err)
	}
	return nil
}

// Muat membaca kembali daftar nama produk dengan kunci id.
func (k *Katalog) Muat(id string) ([]string, error) {
	berkas := filepath.Join(k.direktori, id+".json")
	data, err := os.ReadFile(berkas)
	if err != nil {
		return nil, fmt.Errorf("baca %s: %w", berkas, err)
	}
	var nama []string
	if err := json.Unmarshal(data, &nama); err != nil {
		return nil, fmt.Errorf("unmarshal %s: %w", id, err)
	}
	return nama, nil
}

// DaftarID mengembalikan seluruh id yang tersimpan, terurut naik.
func (k *Katalog) DaftarID() ([]string, error) {
	entri, err := os.ReadDir(k.direktori)
	if err != nil {
		return nil, fmt.Errorf("baca direktori: %w", err)
	}
	var ids []string
	for _, e := range entri {
		if filepath.Ext(e.Name()) == ".json" {
			ids = append(ids, strings.TrimSuffix(e.Name(), ".json"))
		}
	}
	slices.Sort(ids)
	return ids, nil
}

// Impor membaca nama produk baris demi baris dari sebuah berkas di
// dalam fsys, menyimpannya dengan kunci id, lalu mengembalikan nama
// yang dibaca. fs.FS memungkinkan sumber berkas nyata, berkas hasil
// embed, maupun berkas palsu buatan fstest.MapFS.
func (k *Katalog) Impor(fsys fs.FS, id, namaBerkas string) ([]string, error) {
	f, err := fsys.Open(namaBerkas)
	if err != nil {
		return nil, fmt.Errorf("buka %s: %w", namaBerkas, err)
	}
	defer f.Close()

	var nama []string
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		if teks := scanner.Text(); teks != "" {
			nama = append(nama, teks)
		}
	}
	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("baca %s: %w", namaBerkas, err)
	}
	if err := k.Simpan(id, nama); err != nil {
		return nil, err
	}
	return nama, nil
}

package main

import (
	"slices"
	"testing"
	"testing/fstest"
)

// fixtureKatalog menyiapkan seluruh bahan uji: katalog di direktori
// sementara beserta daftar contoh nama produk.
type fixtureKatalog struct {
	katalog *Katalog
	contoh  []string
}

// fixtureKatalogBaru bertindak sebagai setup: direktori sementara
// dibuat lewat t.TempDir dan katalog disiapkan di sana. Pembersihan
// (teardown) direktori berlangsung otomatis saat test selesai.
func fixtureKatalogBaru(t *testing.T) *fixtureKatalog {
	t.Helper()
	k, err := KatalogBaru(t.TempDir())
	if err != nil {
		t.Fatalf("siapkan fixture: %v", err)
	}
	return &fixtureKatalog{
		katalog: k,
		contoh:  []string{"Buku Tulis", "Pensil", "Penghapus"},
	}
}

func TestSimpanMuat(t *testing.T) {
	f := fixtureKatalogBaru(t)
	if err := f.katalog.Simpan("P001", f.contoh); err != nil {
		t.Fatalf("Simpan: %v", err)
	}
	got, err := f.katalog.Muat("P001")
	if err != nil {
		t.Fatalf("Muat: %v", err)
	}
	if !slices.Equal(got, f.contoh) {
		t.Errorf("got %v; want %v", got, f.contoh)
	}
}

func TestDaftarID(t *testing.T) {
	f := fixtureKatalogBaru(t)
	for _, id := range []string{"P002", "P001", "P003"} {
		if err := f.katalog.Simpan(id, f.contoh); err != nil {
			t.Fatalf("Simpan(%s): %v", id, err)
		}
	}
	got, err := f.katalog.DaftarID()
	if err != nil {
		t.Fatalf("DaftarID: %v", err)
	}
	want := []string{"P001", "P002", "P003"}
	if !slices.Equal(got, want) {
		t.Errorf("got %v; want %v", got, want)
	}
}

func TestImpor(t *testing.T) {
	f := fixtureKatalogBaru(t)
	fsys := fstest.MapFS{
		"P001.txt": &fstest.MapFile{Data: []byte("Buku Tulis\nPensil\nPenghapus\n")},
	}
	got, err := f.katalog.Impor(fsys, "P001", "P001.txt")
	if err != nil {
		t.Fatalf("Impor: %v", err)
	}
	if !slices.Equal(got, f.contoh) {
		t.Errorf("got %v; want %v", got, f.contoh)
	}
	disimpan, err := f.katalog.Muat("P001")
	if err != nil {
		t.Fatalf("Muat: %v", err)
	}
	if !slices.Equal(disimpan, f.contoh) {
		t.Errorf("disimpan %v; want %v", disimpan, f.contoh)
	}
}

func TestMuatIDHilang(t *testing.T) {
	f := fixtureKatalogBaru(t)
	_, err := f.katalog.Muat("TIDAK-ADA")
	if err == nil {
		t.Fatal("Muat id hilang: got nil; want error")
	}
}

go test -v ./...

=== RUN   TestSimpanMuat
--- PASS: TestSimpanMuat (0.00s)
=== RUN   TestDaftarID
--- PASS: TestDaftarID (0.00s)
=== RUN   TestImpor
--- PASS: TestImpor (0.00s)
=== RUN   TestMuatIDHilang
--- PASS: TestMuatIDHilang (0.00s)
PASS