m8sh/database/pebble/files_test.go

package pebble

import (
	"bytes"
	"testing"

	"github.com/d1nch8g/mesh/database"
	"github.com/google/uuid"
	"github.com/stretchr/testify/require"
)

func TestFiles_Put(t *testing.T) {
	db, cleanup := openDB(t)
	defer cleanup()

	files := db.Files()

	t.Run("put small file", func(t *testing.T) {
		id, err := files.Put(bytes.NewReader([]byte("hello")))
		require.NoError(t, err)
		require.NotEqual(t, uuid.Nil, id)
	})

	t.Run("put empty file", func(t *testing.T) {
		id, err := files.Put(bytes.NewReader([]byte{}))
		require.NoError(t, err)
		require.NotEqual(t, uuid.Nil, id)
	})

	t.Run("put file larger than one chunk", func(t *testing.T) {
		data := bytes.Repeat([]byte("a"), fileChunkSize+1)
		id, err := files.Put(bytes.NewReader(data))
		require.NoError(t, err)
		require.NotEqual(t, uuid.Nil, id)
	})

	t.Run("put multiple files generates different ids", func(t *testing.T) {
		id1, err := files.Put(bytes.NewReader([]byte("first")))
		require.NoError(t, err)
		id2, err := files.Put(bytes.NewReader([]byte("second")))
		require.NoError(t, err)
		require.NotEqual(t, id1, id2)
	})
}

func TestFiles_Get(t *testing.T) {
	db, cleanup := openDB(t)
	defer cleanup()

	files := db.Files()

	t.Run("get existing file", func(t *testing.T) {
		id, err := files.Put(bytes.NewReader([]byte("hello world")))
		require.NoError(t, err)

		var buf bytes.Buffer
		err = files.Get(id, &buf)
		require.NoError(t, err)
		require.Equal(t, "hello world", buf.String())
	})

	t.Run("get non-existing file", func(t *testing.T) {
		var buf bytes.Buffer
		err := files.Get(uuid.New(), &buf)
		require.ErrorIs(t, err, database.ErrNotFound)
	})

	t.Run("get empty file", func(t *testing.T) {
		id, err := files.Put(bytes.NewReader([]byte{}))
		require.NoError(t, err)

		var buf bytes.Buffer
		err = files.Get(id, &buf)
		require.NoError(t, err)
		require.Equal(t, "", buf.String())
	})

	t.Run("get multi-chunk file", func(t *testing.T) {
		data := bytes.Repeat([]byte("b"), fileChunkSize+100)
		id, err := files.Put(bytes.NewReader(data))
		require.NoError(t, err)

		var buf bytes.Buffer
		err = files.Get(id, &buf)
		require.NoError(t, err)
		require.Equal(t, len(data), buf.Len())
		require.Equal(t, data, buf.Bytes())
	})
}

func TestFiles_Delete(t *testing.T) {
	db, cleanup := openDB(t)
	defer cleanup()

	files := db.Files()

	t.Run("delete existing file", func(t *testing.T) {
		id, err := files.Put(bytes.NewReader([]byte("delete me")))
		require.NoError(t, err)

		err = files.Delete(id)
		require.NoError(t, err)

		// Verify deleted.
		var buf bytes.Buffer
		err = files.Get(id, &buf)
		require.ErrorIs(t, err, database.ErrNotFound)
	})

	t.Run("delete non-existing file", func(t *testing.T) {
		err := files.Delete(uuid.New())
		require.ErrorIs(t, err, database.ErrNotFound)
	})

	t.Run("delete multi-chunk file", func(t *testing.T) {
		data := bytes.Repeat([]byte("c"), fileChunkSize*2+50)
		id, err := files.Put(bytes.NewReader(data))
		require.NoError(t, err)

		err = files.Delete(id)
		require.NoError(t, err)

		var buf bytes.Buffer
		err = files.Get(id, &buf)
		require.ErrorIs(t, err, database.ErrNotFound)
	})
}

func TestFiles_Size(t *testing.T) {
	db, cleanup := openDB(t)
	defer cleanup()

	files := db.Files()

	t.Run("size of existing file", func(t *testing.T) {
		id, err := files.Put(bytes.NewReader([]byte("hello")))
		require.NoError(t, err)

		size, err := files.Size(id)
		require.NoError(t, err)
		require.Equal(t, int64(5), size)
	})

	t.Run("size of non-existing file", func(t *testing.T) {
		_, err := files.Size(uuid.New())
		require.ErrorIs(t, err, database.ErrNotFound)
	})

	t.Run("size of empty file", func(t *testing.T) {
		id, err := files.Put(bytes.NewReader([]byte{}))
		require.NoError(t, err)

		size, err := files.Size(id)
		require.NoError(t, err)
		require.Equal(t, int64(0), size)
	})

	t.Run("size of multi-chunk file", func(t *testing.T) {
		data := bytes.Repeat([]byte("d"), fileChunkSize*2+777)
		id, err := files.Put(bytes.NewReader(data))
		require.NoError(t, err)

		size, err := files.Size(id)
		require.NoError(t, err)
		require.Equal(t, int64(len(data)), size)
	})
}

func TestFiles_AfterClosePanics(t *testing.T) {
	path := t.TempDir() + "/db"
	db, err := New(path)
	require.NoError(t, err)

	files := db.Files()
	id, err := files.Put(bytes.NewReader([]byte("data")))
	require.NoError(t, err)

	require.NoError(t, db.Close())

	require.Panics(t, func() {
		_, _ = files.Put(bytes.NewReader([]byte("more")))
	})

	require.Panics(t, func() {
		var buf bytes.Buffer
		_ = files.Get(id, &buf)
	})

	require.Panics(t, func() {
		_ = files.Delete(id)
	})

	require.Panics(t, func() {
		_, _ = files.Size(id)
	})
}