goext/zipext/zip_test.go

package zipext

import (
	"archive/zip"
	"bytes"
	"io"
	"testing"

	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
)

func readZipEntries(t *testing.T, data []byte) map[string][]byte {
	t.Helper()

	r, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
	tst.AssertNoErr(t, err)

	out := make(map[string][]byte, len(r.File))
	for _, f := range r.File {
		rc, err := f.Open()
		tst.AssertNoErr(t, err)

		body, err := io.ReadAll(rc)
		tst.AssertNoErr(t, err)

		err = rc.Close()
		tst.AssertNoErr(t, err)

		out[f.Name] = body
	}
	return out
}

func TestNewMemoryZipZipOnlyEmpty(t *testing.T) {
	mz := NewMemoryZip(true, false)

	data, err := mz.GetZip()
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, len(data) > 0)

	entries := readZipEntries(t, data)
	tst.AssertEqual(t, len(entries), 0)
}

func TestMemoryZipAddSingleFile(t *testing.T) {
	mz := NewMemoryZip(true, false)

	payload := []byte("Hello World")
	err := mz.AddFile("hello.txt", payload)
	tst.AssertNoErr(t, err)

	data, err := mz.GetZip()
	tst.AssertNoErr(t, err)

	entries := readZipEntries(t, data)
	tst.AssertEqual(t, len(entries), 1)

	got, ok := entries["hello.txt"]
	tst.AssertTrue(t, ok)
	tst.AssertArrayEqual(t, got, payload)
}

func TestMemoryZipAddMultipleFiles(t *testing.T) {
	mz := NewMemoryZip(true, false)

	files := map[string][]byte{
		"a.txt":          []byte("aaa"),
		"sub/b.txt":      []byte("bbbb"),
		"sub/dir/c.bin":  {0, 1, 2, 3, 4, 5, 250, 251, 252, 253, 254, 255},
		"empty.txt":      {},
		"d/e/f/g/h.json": []byte(`{"k":"v"}`),
	}

	for name, body := range files {
		err := mz.AddFile(name, body)
		tst.AssertNoErr(t, err)
	}

	data, err := mz.GetZip()
	tst.AssertNoErr(t, err)

	entries := readZipEntries(t, data)
	tst.AssertEqual(t, len(entries), len(files))

	for name, expected := range files {
		got, ok := entries[name]
		tst.AssertTrue(t, ok)
		tst.AssertArrayEqual(t, got, expected)
	}
}

func TestMemoryZipAddDuplicatePaths(t *testing.T) {
	mz := NewMemoryZip(true, false)

	err := mz.AddFile("dup.txt", []byte("first"))
	tst.AssertNoErr(t, err)

	err = mz.AddFile("dup.txt", []byte("second"))
	tst.AssertNoErr(t, err)

	data, err := mz.GetZip()
	tst.AssertNoErr(t, err)

	r, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, len(r.File), 2)
}

func TestMemoryZipAddLargerData(t *testing.T) {
	mz := NewMemoryZip(true, false)

	payload := make([]byte, 64*1024)
	for i := range payload {
		payload[i] = byte(i % 251)
	}

	err := mz.AddFile("big.bin", payload)
	tst.AssertNoErr(t, err)

	data, err := mz.GetZip()
	tst.AssertNoErr(t, err)

	entries := readZipEntries(t, data)
	tst.AssertEqual(t, len(entries), 1)
	tst.AssertArrayEqual(t, entries["big.bin"], payload)
}

func TestMemoryZipGetZipClosesWriter(t *testing.T) {
	mz := NewMemoryZip(true, false)

	err := mz.AddFile("a.txt", []byte("data"))
	tst.AssertNoErr(t, err)

	tst.AssertTrue(t, mz.open)

	_, err = mz.GetZip()
	tst.AssertNoErr(t, err)

	tst.AssertFalse(t, mz.open)
}

func TestMemoryZipGetZipIdempotent(t *testing.T) {
	mz := NewMemoryZip(true, false)

	err := mz.AddFile("a.txt", []byte("data"))
	tst.AssertNoErr(t, err)

	first, err := mz.GetZip()
	tst.AssertNoErr(t, err)

	second, err := mz.GetZip()
	tst.AssertNoErr(t, err)

	tst.AssertArrayEqual(t, first, second)
}

func TestMemoryZipAddFileAfterCloseFails(t *testing.T) {
	mz := NewMemoryZip(true, false)

	err := mz.Close()
	tst.AssertNoErr(t, err)

	err = mz.AddFile("a.txt", []byte("data"))
	tst.AssertTrue(t, err == errAlreadyClosed)
}

func TestMemoryZipAddFileAfterGetZipFails(t *testing.T) {
	mz := NewMemoryZip(true, false)

	_, err := mz.GetZip()
	tst.AssertNoErr(t, err)

	err = mz.AddFile("a.txt", []byte("data"))
	tst.AssertTrue(t, err == errAlreadyClosed)
}

func TestMemoryZipDoubleCloseIsNoop(t *testing.T) {
	mz := NewMemoryZip(true, false)

	err := mz.Close()
	tst.AssertNoErr(t, err)

	err = mz.Close()
	tst.AssertNoErr(t, err)
}

func TestMemoryZipGetZipNotEnabled(t *testing.T) {
	mz := NewMemoryZip(false, false)

	_, err := mz.GetZip()
	tst.AssertTrue(t, err == errZipNotEnabled)
}

func TestMemoryZipGetTarGzNotEnabled(t *testing.T) {
	mz := NewMemoryZip(true, false)

	_, err := mz.GetTarGz()
	tst.AssertTrue(t, err == errTgzNotEnabled)
}

func TestMemoryZipBothDisabledClose(t *testing.T) {
	mz := NewMemoryZip(false, false)

	err := mz.AddFile("a.txt", []byte("data"))
	tst.AssertNoErr(t, err)

	err = mz.Close()
	tst.AssertNoErr(t, err)

	_, err = mz.GetZip()
	tst.AssertTrue(t, err == errZipNotEnabled)

	_, err = mz.GetTarGz()
	tst.AssertTrue(t, err == errTgzNotEnabled)
}

func TestMemoryZipBothDisabledAddFileAfterCloseFails(t *testing.T) {
	mz := NewMemoryZip(false, false)

	err := mz.Close()
	tst.AssertNoErr(t, err)

	err = mz.AddFile("a.txt", []byte("data"))
	tst.AssertTrue(t, err == errAlreadyClosed)
}

func TestMemoryZipNewMemoryZipFlags(t *testing.T) {
	z1 := NewMemoryZip(true, false)
	tst.AssertTrue(t, z1.zipEnabled)
	tst.AssertFalse(t, z1.tarEnabled)
	tst.AssertTrue(t, z1.open)

	z2 := NewMemoryZip(false, false)
	tst.AssertFalse(t, z2.zipEnabled)
	tst.AssertFalse(t, z2.tarEnabled)
	tst.AssertTrue(t, z2.open)
}

func TestMemoryZipZipBytesAreValidZipMagic(t *testing.T) {
	mz := NewMemoryZip(true, false)

	err := mz.AddFile("x.txt", []byte("y"))
	tst.AssertNoErr(t, err)

	data, err := mz.GetZip()
	tst.AssertNoErr(t, err)

	tst.AssertTrue(t, len(data) >= 4)
	tst.AssertEqual(t, data[0], byte(0x50))
	tst.AssertEqual(t, data[1], byte(0x4B))
}