new game, fs repo layer

2025-09-23 18:36:22 +03:00
parent 84578dc61c
commit 4d733ae741
18 changed files with 880 additions and 54 deletions
@@ -0,0 +1,178 @@
+package fs
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewFileStorageSuccess(t *testing.T) {
+	root, cleanup := createWorkDir(t)
+	defer cleanup()
+	_, err := NewFileStorage(root)
+	assert.NoError(t, err)
+}
+
+func TestLock(t *testing.T) {
+	root, cleanup := createWorkDir(t)
+	defer cleanup()
+	fs, err := NewFileStorage(root)
+	assert.NoError(t, err, "create file storage")
+	unlock, err := fs.Lock()
+	assert.NoError(t, err, "acquire lock")
+	exists, err := fileExists(filepath.Join(root, lockFile))
+	assert.NoError(t, err, "check that the lock file should exist")
+	assert.True(t, exists, "lock file must exists")
+	err = unlock()
+	assert.NoError(t, err, "unlocking existing lock")
+	exists, err = fileExists(filepath.Join(root, lockFile))
+	assert.NoError(t, err, "check that the lock file does not exist")
+	assert.False(t, exists, "lock file must be removed")
+}
+
+func TestWrite(t *testing.T) {
+	root, cleanup := createWorkDir(t)
+	defer cleanup()
+	fs, err := NewFileStorage(root)
+	assert.NoError(t, err, "create file storage: %s", err)
+	unlock, err := fs.Lock()
+	assert.NoError(t, err, "acquire lock: %s", err)
+
+	dirName := "some-dir"
+	if err := os.Mkdir(filepath.Join(root, dirName), os.ModePerm); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, tc := range []struct {
+		path string
+		err  string
+	}{
+		{path: "file-1.ext"},
+		{path: "/dir/file-2.ext"},
+		{path: "dir/subdir/file-3.ext"},
+		{path: lockFile, err: "write to the lock file"},
+		{path: dirName, err: "wrong type"},
+		{path: "/" + dirName, err: "wrong type"},
+	} {
+		t.Run(tc.path, func(t *testing.T) {
+			err = fs.Write(tc.path, []byte{0, 1, 2, 3})
+			if tc.err == "" {
+				if err != nil {
+					assert.Fail(t, "not expecting an error", "write to file %s: %s", tc.path, err)
+				} else {
+					exists, err := fileExists(filepath.Join(root, tc.path))
+					assert.NoError(t, err, "check is written file exists")
+					assert.True(t, exists, "the written file should exist")
+				}
+			} else if tc.err != "" {
+				if err == nil {
+					assert.Fail(t, "expecting an error, got none", "write to file %s", tc.path)
+				} else {
+					assert.True(t, strings.Contains(err.Error(), tc.err), "expect: %q got: %q", tc.err, err.Error())
+				}
+			}
+		})
+	}
+
+	err = unlock()
+	assert.NoError(t, err, "unlocking existing lock")
+}
+
+func TestRead(t *testing.T) {
+	root, cleanup := createWorkDir(t)
+	defer cleanup()
+	fs, err := NewFileStorage(root)
+	assert.NoError(t, err, "create file storage: %s", err)
+
+	dirName := "some-dir"
+	if err := os.Mkdir(filepath.Join(root, dirName), os.ModePerm); err != nil {
+		t.Fatal(err)
+	}
+
+	fileName := "some-file.ext"
+	if err := os.WriteFile(filepath.Join(root, fileName), []byte{1, 2, 3, 4}, os.ModePerm); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, tc := range []struct {
+		path string
+		lock bool
+		err  string
+	}{
+		{path: fileName},
+		{path: "/" + fileName},
+		{path: fileName, lock: true, err: "lock must be released"},
+		{path: lockFile, err: "read from the lock file"},
+		{path: "dir/subdir/file-3.ext", err: "no such file"},
+		{path: lockFile, err: "read from the lock file"},
+		{path: dirName, err: "is a directory"},
+	} {
+		t.Run(tc.path, func(t *testing.T) {
+			if tc.lock {
+				unlock, err := fs.Lock()
+				if err != nil {
+					t.Fatalf("acquire lock: %s", err)
+				}
+				defer func() {
+					if err := unlock(); err != nil {
+						t.Fatalf("release lock: %s", err)
+					}
+				}()
+			}
+			_, err = fs.Read(tc.path)
+			if tc.err == "" {
+				if err != nil {
+					assert.Fail(t, "read: not expecting an error, got: "+err.Error())
+				} else {
+					exists, err := fileExists(filepath.Join(root, tc.path))
+					assert.NoError(t, err, "check is written file exists")
+					assert.True(t, exists, "the written file should exist")
+				}
+			} else if tc.err != "" {
+				if err == nil {
+					assert.Fail(t, "read: expecting an error, got none")
+				} else {
+					assert.True(t, strings.Contains(err.Error(), tc.err), "expect: %q got: %q", tc.err, err.Error())
+				}
+			}
+		})
+	}
+}
+
+func TestWriteErrorWithoutLock(t *testing.T) {
+	root, cleanup := createWorkDir(t)
+	defer cleanup()
+	fs, err := NewFileStorage(root)
+	assert.NoError(t, err, "create file storage")
+	err = fs.Write("some/path", []byte{0, 1, 2, 3})
+	assert.Error(t, err, "should return error when no lock acquired")
+	assert.True(t, strings.Contains(err.Error(), "lock must be acquired"), "should return missing lock error")
+}
+
+func TestNewFileStorageErrorNotExists(t *testing.T) {
+	_, err := NewFileStorage(filepath.Join(os.TempDir(), "non-existent-dir"))
+	assert.Error(t, err)
+}
+
+func TestNewFileStorageErrorNotADirectory(t *testing.T) {
+	f, err := os.CreateTemp("", "fs-test-file")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := f.Close(); err != nil {
+		t.Fatal(err)
+	}
+	_, err = NewFileStorage(f.Name())
+	assert.Error(t, err)
+	if err := os.Remove(f.Name()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestNewFileStorageErrorNoAccess(t *testing.T) {
+	_, err := NewFileStorage(nonWritableDir)
+	assert.Error(t, err)
+}