decompression_test.go

package embeddedpostgres

import (
	"archive/tar"
	"errors"
	"fmt"
	"io"
	"os"
	"path"
	"path/filepath"
	"syscall"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/xi2/xz"
)

func Test_decompressTarXz(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "temp_tar_test")
	if err != nil {
		panic(err)
	}
	if err := syscall.Rmdir(tempDir); err != nil {
		panic(err)
	}

	archive, cleanUp := createTempXzArchive()
	defer cleanUp()

	err = decompressTarXz(defaultTarReader, archive, tempDir)

	assert.NoError(t, err)

	expectedExtractedFileLocation := filepath.Join(tempDir, "dir1", "dir2", "some_content")
	assert.FileExists(t, expectedExtractedFileLocation)

	fileContentBytes, err := os.ReadFile(expectedExtractedFileLocation)
	assert.NoError(t, err)

	assert.Equal(t, "b33r is g00d", string(fileContentBytes))
}

func Test_decompressTarXz_ErrorWhenFileNotExists(t *testing.T) {
	err := decompressTarXz(defaultTarReader, "/does-not-exist", "/also-fake")

	assert.Error(t, err)
	assert.Contains(
		t,
		err.Error(),
		"unable to extract postgres archive /does-not-exist to /also-fake, if running parallel tests, configure RuntimePath to isolate testing directories",
	)
}

func Test_decompressTarXz_ErrorWhenErrorDuringRead(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "temp_tar_test")
	if err != nil {
		panic(err)
	}
	if err := syscall.Rmdir(tempDir); err != nil {
		panic(err)
	}

	archive, cleanUp := createTempXzArchive()
	defer cleanUp()

	err = decompressTarXz(func(reader *xz.Reader) (func() (*tar.Header, error), func() io.Reader) {
		return func() (*tar.Header, error) {
			return nil, errors.New("oh noes")
		}, nil
	}, archive, tempDir)

	assert.EqualError(t, err, "unable to extract postgres archive: oh noes")
}

func Test_decompressTarXz_ErrorWhenFailedToReadFileToCopy(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "temp_tar_test")
	if err != nil {
		panic(err)
	}

	archive, cleanUp := createTempXzArchive()
	defer cleanUp()

	blockingFile := filepath.Join(tempDir, "blocking")

	if err = os.WriteFile(blockingFile, []byte("wazz"), 0000); err != nil {
		panic(err)
	}

	fileBlockingExtractTarReader := func(reader *xz.Reader) (func() (*tar.Header, error), func() io.Reader) {
		shouldReadFile := true

		return func() (*tar.Header, error) {
				if shouldReadFile {
					shouldReadFile = false

					return &tar.Header{
						Typeflag: tar.TypeReg,
						Name:     "blocking",
					}, nil
				}

				return nil, io.EOF
			}, func() io.Reader {
				open, _ := os.Open("file_not_exists")
				return open
			}
	}

	err = decompressTarXz(fileBlockingExtractTarReader, archive, tempDir)

	assert.Regexp(t, "^unable to extract postgres archive:.+$", err)
}

func Test_decompressTarXz_ErrorWhenFileToCopyToNotExists(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "temp_tar_test")
	if err != nil {
		panic(err)
	}
	if err := syscall.Rmdir(tempDir); err != nil {
		panic(err)
	}

	archive, cleanUp := createTempXzArchive()
	defer cleanUp()

	fileBlockingExtractTarReader := func(reader *xz.Reader) (func() (*tar.Header, error), func() io.Reader) {
		shouldReadFile := true

		return func() (*tar.Header, error) {
				if shouldReadFile {
					shouldReadFile = false

					return &tar.Header{
						Typeflag: tar.TypeReg,
						Name:     "some_dir/wazz/dazz/fazz",
					}, nil
				}

				return nil, io.EOF
			}, func() io.Reader {
				open, _ := os.Open("file_not_exists")
				return open
			}
	}

	err = decompressTarXz(fileBlockingExtractTarReader, archive, tempDir)

	assert.Regexp(t, "^unable to extract postgres archive:.+$", err)
}

func Test_decompressTarXz_ErrorWhenArchiveCorrupted(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "temp_tar_test")
	if err != nil {
		panic(err)
	}
	if err := syscall.Rmdir(tempDir); err != nil {
		panic(err)
	}

	archive, cleanup := createTempXzArchive()

	defer cleanup()

	file, err := os.OpenFile(archive, os.O_WRONLY, 0664)
	if err != nil {
		panic(err)
	}

	if _, err := file.Seek(35, 0); err != nil {
		panic(err)
	}

	if _, err := file.WriteString("someJunk"); err != nil {
		panic(err)
	}

	if err := file.Close(); err != nil {
		panic(err)
	}

	err = decompressTarXz(defaultTarReader, archive, tempDir)

	assert.EqualError(t, err, "unable to extract postgres archive: xz: data is corrupt")
}

func Test_decompressTarXz_ErrorWithInvalidDestination(t *testing.T) {
	archive, cleanUp := createTempXzArchive()
	defer cleanUp()

	tempDir, err := os.MkdirTemp("", "temp_tar_test")
	require.NoError(t, err)
	defer func() {
		os.RemoveAll(tempDir)
	}()

	op := fmt.Sprintf(path.Join(tempDir, "%c"), rune(0))

	err = decompressTarXz(defaultTarReader, archive, op)
	assert.EqualError(
		t,
		err,
		fmt.Sprintf("unable to extract postgres archive: mkdir %s: invalid argument", op),
	)
}