Add filesystem package with OSFileSystem implementation and MockFileSystem for testing

Author: fumiya-kume

internal/config/mock_file_system.go internal/config/file_system_mock.gointernal/config/mock_file_system.go renamed to internal/config/file_system_mock.go

@@ -1,4 +1,4 @@
-package main
+package filesystem
 
 import (
 	"os"
@@ -15,25 +15,31 @@ type FileSystem interface {
 	WriteFile(name string, content string) error
 }
 
-type fileSystem struct{}
+// OSFileSystem is a concrete implementation of the FileSystem interface
+type OSFileSystem struct{}
 
-func (f *fileSystem) UserHomeDir() (string, error) {
+// NewOSFileSystem creates a new instance of OSFileSystem
+func NewOSFileSystem() *OSFileSystem {
+	return &OSFileSystem{}
+}
+
+func (f *OSFileSystem) UserHomeDir() (string, error) {
 	return os.UserHomeDir()
 }
 
-func (f *fileSystem) Stat(name string) (os.FileInfo, error) {
+func (f *OSFileSystem) Stat(name string) (os.FileInfo, error) {
 	return os.Stat(name)
 }
 
-func (f *fileSystem) Create(name string) (*os.File, error) {
+func (f *OSFileSystem) Create(name string) (*os.File, error) {
 	return os.Create(name)
 }
 
-func (f *fileSystem) WriteFile(name string, content string) error {
+func (f *OSFileSystem) WriteFile(name string, content string) error {
 	return os.WriteFile(name, []byte(content), 0644)
 }
 
-func (f *fileSystem) ReadFile(name string) (string, error) {
+func (f *OSFileSystem) ReadFile(name string) (string, error) {
 	content, err := os.ReadFile(name)
 	if err != nil {
 		return "", err
@@ -42,7 +48,7 @@ func (f *fileSystem) ReadFile(name string) (string, error) {
 }
 
 // createConfigFileIfMissing checks for the existence of the config file and creates it if it doesn't exist
-func createConfigFileIfMissing(fs FileSystem) error {
+func CreateConfigFileIfMissing(fs FileSystem) error {
 	if _, err := fs.Stat(config.ConfigFilePath); os.IsNotExist(err) {
 		file, err := fs.Create(config.ConfigFilePath)
 		if err != nil {
@@ -54,6 +60,6 @@ func createConfigFileIfMissing(fs FileSystem) error {
 }
 
 // readConfigFileString reads the config file and returns its content as a string
-func readConfigFileString(fs FileSystem) (string, error) {
+func ReadConfigFileString(fs FileSystem) (string, error) {
 	return fs.ReadFile(config.ConfigFilePath)
 }

file_system.go internal/filesystem/file_system.gofile_system.go renamed to internal/filesystem/file_system.go

@@ -1,45 +1,45 @@
-package main
+package filesystem
 
 import (
 	"os"
 )
 
 // MockFileSystem is a mock implementation of the FileSystem interface
 type MockFileSystem struct {
-	homeDir           string
-	statError         error
-	createErr         error
-	configFileContent string
-	writeFileErr      error
-	writeFileContent  string
+	HomeDir           string
+	StatError         error
+	CreateErr         error
+	ConfigFileContent string
+	WriteFileErr      error
+	WriteFileContent  string
 }
 
 func (m *MockFileSystem) UserHomeDir() (string, error) {
-	return m.homeDir, nil
+	return m.HomeDir, nil
 }
 
 func (m *MockFileSystem) Stat(name string) (os.FileInfo, error) {
-	if m.statError != nil {
-		return nil, m.statError
+	if m.StatError != nil {
+		return nil, m.StatError
 	}
-	if m.configFileContent != "" {
+	if m.ConfigFileContent != "" {
 		return nil, os.ErrNotExist
 	}
 	return nil, nil
 }
 
 func (m *MockFileSystem) Create(name string) (*os.File, error) {
-	return nil, m.createErr
+	return nil, m.CreateErr
 }
 
 func (m *MockFileSystem) ReadFile(name string) (string, error) {
-	if m.statError != nil {
-		return "", m.statError
+	if m.StatError != nil {
+		return "", m.StatError
 	}
-	return m.configFileContent, nil
+	return m.ConfigFileContent, nil
 }
 
 func (m *MockFileSystem) WriteFile(name string, content string) error {
-	m.writeFileContent = content
-	return m.writeFileErr
-}
+	m.WriteFileContent = content
+	return m.WriteFileErr
+}

file_system_mock.go internal/filesystem/file_system_mock.gofile_system_mock.go renamed to internal/filesystem/file_system_mock.go

@@ -1,56 +1,58 @@
-package main
+package filesystem_test
 
 import (
 	"errors"
 	"os"
 	"testing"
+
+	"github.com/fumiya-kume/mdefaults/internal/filesystem"
 )
 
 func TestSetupConfigFile_CreatesFileIfNotExist(t *testing.T) {
-	fs := &MockFileSystem{
-		homeDir:   "/mock/home",
-		statError: os.ErrNotExist,
-		createErr: nil,
+	fs := &filesystem.MockFileSystem{
+		HomeDir:   "/mock/home",
+		StatError: os.ErrNotExist,
+		CreateErr: nil,
 	}
 
-	err := createConfigFileIfMissing(fs)
+	err := filesystem.CreateConfigFileIfMissing(fs)
 	if err != nil {
 		t.Fatalf("Failed to create config file: %v", err)
 	}
 }
 
 func TestSetupConfigFile_DoesNotCreateFileIfExists(t *testing.T) {
-	fs := &MockFileSystem{
-		homeDir:   "/mock/home",
-		statError: nil,
-		createErr: nil,
+	fs := &filesystem.MockFileSystem{
+		HomeDir:   "/mock/home",
+		StatError: nil,
+		CreateErr: nil,
 	}
 
-	err := createConfigFileIfMissing(fs)
+	err := filesystem.CreateConfigFileIfMissing(fs)
 	if err != nil {
 		t.Fatalf("Failed to create config file: %v", err)
 	}
 }
 
 func TestSetupConfigFile_HandleUserHomeDirError(t *testing.T) {
-	fs := &MockFileSystem{
-		homeDir:   "",
-		statError: nil,
-		createErr: nil,
+	fs := &filesystem.MockFileSystem{
+		HomeDir:   "",
+		StatError: nil,
+		CreateErr: nil,
 	}
 
-	err := createConfigFileIfMissing(fs)
+	err := filesystem.CreateConfigFileIfMissing(fs)
 	if err != nil {
 		t.Fatalf("Failed to create config file: %v", err)
 	}
 }
 
 func TestReadConfigFileString_Success(t *testing.T) {
-	mockFS := &MockFileSystem{
-		configFileContent: "com.apple.dock autohide 1\ncom.apple.finder ShowPathbar true\n",
+	mockFS := &filesystem.MockFileSystem{
+		ConfigFileContent: "com.apple.dock autohide 1\ncom.apple.finder ShowPathbar true\n",
 	}
 
-	content, err := readConfigFileString(mockFS)
+	content, err := filesystem.ReadConfigFileString(mockFS)
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
@@ -62,11 +64,11 @@ func TestReadConfigFileString_Success(t *testing.T) {
 }
 
 func TestReadConfigFileString_Empty(t *testing.T) {
-	mockFS := &MockFileSystem{
-		configFileContent: "",
+	mockFS := &filesystem.MockFileSystem{
+		ConfigFileContent: "",
 	}
 
-	content, err := readConfigFileString(mockFS)
+	content, err := filesystem.ReadConfigFileString(mockFS)
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
@@ -78,26 +80,26 @@ func TestReadConfigFileString_Empty(t *testing.T) {
 }
 
 func TestReadConfigFileString_Error(t *testing.T) {
-	mockFS := &MockFileSystem{
-		statError: errors.New("read error"),
+	mockFS := &filesystem.MockFileSystem{
+		StatError: errors.New("read error"),
 	}
 
-	_, err := readConfigFileString(mockFS)
+	_, err := filesystem.ReadConfigFileString(mockFS)
 	if err == nil {
 		t.Fatal("Expected error, got nil")
 	}
 
-	if !errors.Is(err, mockFS.statError) {
-		t.Errorf("Expected error %v, got %v", mockFS.statError, err)
+	if !errors.Is(err, mockFS.StatError) {
+		t.Errorf("Expected error %v, got %v", mockFS.StatError, err)
 	}
 }
 
 func TestReadConfigFileString_MalformedContent(t *testing.T) {
-	mockFS := &MockFileSystem{
-		configFileContent: "com.apple.dock autohide\nmalformed line without key\ncom.apple.finder ShowPathbar true\n",
+	mockFS := &filesystem.MockFileSystem{
+		ConfigFileContent: "com.apple.dock autohide\nmalformed line without key\ncom.apple.finder ShowPathbar true\n",
 	}
 
-	content, err := readConfigFileString(mockFS)
+	content, err := filesystem.ReadConfigFileString(mockFS)
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
@@ -106,4 +108,4 @@ func TestReadConfigFileString_MalformedContent(t *testing.T) {
 	if content != expectedContent {
 		t.Errorf("Expected content %q, got %q", expectedContent, content)
 	}
-}
+}