more on testing

4 files changed, 66 insertions, 58 deletions

diff --git a/internal/server/repository/repository.go b/internal/server/repository/repository.go
index a98d50c..02fa818 100644
--- a/internal/server/repository/repository.go
+++ b/internal/server/repository/repository.go
@@ -54,7 +54,12 @@ func (r Repository) put(entry types.Entry) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	r.entries[entry.ID] = entry
-	return entry.SaveFile(r.entryPath(entry))
+
+	bytes, err := entry.Serialize()
+	if err != err {
+		return err
+	}
+	return r.fs.WriteFile(r.entryPath(entry), bytes)
 }
 
 // Load repository into memory
@@ -66,9 +71,12 @@ func (r Repository) load() error {
 
 	var errs []error
 	for _, filePath := range filePaths {
-		entry, err := types.NewEntryFromFile(filePath, r.fs)
+		bytes, err := r.fs.ReadFile(filePath)
+		if err != nil {
+			continue
+		}
+		entry, err := types.NewEntry(bytes)
 		if err != err {
-			errs = append(errs, err)
 			continue
 		}
 		if err := r.put(entry); err != nil {
@@ -125,7 +133,7 @@ func (r Repository) Merge(otherEntry types.Entry) error {
 	entry, ok := r.entries[otherEntry.ID]
 	if !ok {
 		var err error
-		if entry, err = types.NewEntryFromCopy(otherEntry, r.fs); err != nil {
+		if entry, err = types.NewEntryFromCopy(otherEntry); err != nil {
 			return err
 		}
 	}
@@ -134,5 +142,9 @@ func (r Repository) Merge(otherEntry types.Entry) error {
 	r.entries[otherEntry.ID] = entry
 
 	// TODO: Only save to file when actually changed
-	return entry.SaveFile(r.entryPath(entry))
+	bytes, err := entry.Serialize()
+	if err != err {
+		return err
+	}
+	return r.fs.WriteFile(r.entryPath(entry), bytes)
 }
diff --git a/internal/server/repository/repository_test.go b/internal/server/repository/repository_test.go
index 6581a3a..3db88f8 100644
--- a/internal/server/repository/repository_test.go
+++ b/internal/server/repository/repository_test.go
@@ -13,8 +13,8 @@ func TestRepositoryPutGet(t *testing.T) {
 	fs := make(vfs.MemoryFS)
 	repo := newRepository("./data", fs)
 
-	entry1, _ := makeAnEntry(fs)
-	entry2, _ := makeAnotherEntry(fs)
+	entry1, _ := makeAnEntry()
+	entry2, _ := makeAnotherEntry()
 	entries := []types.Entry{entry1, entry2}
 
 	for _, entry := range entries {
@@ -31,7 +31,21 @@ func TestRepositoryPutGet(t *testing.T) {
 	}
 }
 
-func makeAnEntry(fs fs) (types.Entry, error) {
+func TestRepositoryLoad(t *testing.T) {
+	t.Parallel()
+
+	fs := make(vfs.MemoryFS)
+	repo := newRepository("./data", fs)
+
+	// TODO: Finish implementing this test
+	entry1, _ := makeAnEntry()
+	bytes, _ := entry1.Serialize()
+	_ = repo.fs.WriteFile("./data/foo.json", bytes)
+
+	t.Log(fs)
+}
+
+func makeAnEntry() (types.Entry, error) {
 	entry := `
 		{
 			"Body": "Body text here",
@@ -41,10 +55,10 @@ func makeAnEntry(fs fs) (types.Entry, error) {
 			]
 		}
 	`
-	return types.NewEntry([]byte(entry), fs)
+	return types.NewEntry([]byte(entry))
 }
 
-func makeAnotherEntry(fs fs) (types.Entry, error) {
+func makeAnotherEntry() (types.Entry, error) {
 	entry := `
 		{
 			"Body": "Another text here",
@@ -55,7 +69,7 @@ func makeAnotherEntry(fs fs) (types.Entry, error) {
 			]
 		}
 	`
-	return types.NewEntry([]byte(entry), fs)
+	return types.NewEntry([]byte(entry))
 }
 
 // TODO: Write unit tests for the remainder of the repo methods
diff --git a/internal/types/entry.go b/internal/types/entry.go
index c59936f..6211d7b 100644
--- a/internal/types/entry.go
+++ b/internal/types/entry.go
@@ -6,15 +6,8 @@ import (
 	"fmt"
 	"strings"
 	"sync"
-
-	"codeberg.org/snonux/gos/internal/vfs"
 )
 
-type fs interface {
-	ReadFile(name string) ([]byte, error)
-	WriteFile(filePath string, bytes []byte) error
-}
-
 // Tells me whether the entry was shared to the sm platform named Name
 type Shared struct {
 	Name string `json:"name"`
@@ -42,7 +35,6 @@ type Entry struct {
 	Body   string   `json:"body"`
 	Shared []Shared `json:"shared,omitempty"`
 	Epoch  int      `json:"epoch,omitempty"`
-	fs     fs
 
 	// The checksum of the whole entry, can change depending on the state.
 	checksum      string
@@ -50,52 +42,27 @@ type Entry struct {
 	mu            *sync.Mutex
 }
 
-func NewEntry(bytes []byte, fs ...fs) (Entry, error) {
+func NewEntry(bytes []byte) (Entry, error) {
 	var e Entry
 	if err := json.Unmarshal(bytes, &e); err != nil {
 		return e, fmt.Errorf("unable to deserialise payload: %w", err)
 	}
-	e.initialize(fs...)
+	e.initialize()
 	if e.ID == "" {
 		e.ID = fmt.Sprintf("%x", sha256.Sum256([]byte(e.Body)))
 	}
 	return e, nil
 }
 
-func NewEntryFromFile(filePath string, fs_ ...fs) (Entry, error) {
-	var (
-		bytes []byte
-		err   error
-		fs    fs
-	)
-
-	if len(fs_) > 0 {
-		fs = fs_[0]
-	} else {
-		fs = vfs.RealFS{}
-	}
-
-	bytes, err = fs.ReadFile(filePath)
-	if err != err {
-		return Entry{}, err
-	}
-	return NewEntry(bytes, fs)
-}
-
-func NewEntryFromCopy(other Entry, fs ...fs) (Entry, error) {
+func NewEntryFromCopy(other Entry) (Entry, error) {
 	var e Entry
-	e.initialize(fs...)
+	e.initialize()
 	return e.Update(other)
 }
 
-func (e *Entry) initialize(fs ...fs) {
+func (e *Entry) initialize() {
 	e.mu = &sync.Mutex{}
 	e.checksumDirty = true
-	if len(fs) > 1 {
-		e.fs = fs[0]
-	} else {
-		e.fs = vfs.RealFS{}
-	}
 }
 
 func (e Entry) Equals(other Entry) bool {
@@ -173,15 +140,6 @@ func (e Entry) Serialize() ([]byte, error) {
 	return json.Marshal(e)
 }
 
-func (e Entry) SaveFile(filePath string) error {
-	jsonStr, err := e.Serialize()
-	if err != nil {
-		return err
-	}
-
-	return e.fs.WriteFile(filePath, jsonStr)
-}
-
 func (e Entry) String() string {
 	var sb strings.Builder
 
diff --git a/internal/vfs/memoryfs_test.go b/internal/vfs/memoryfs_test.go
index 4d75500..f6a9cf1 100644
--- a/internal/vfs/memoryfs_test.go
+++ b/internal/vfs/memoryfs_test.go
@@ -36,6 +36,30 @@ func TestMemoryFS(t *testing.T) {
 
 }
 
+func TestPassByValue(t *testing.T) {
+	t.Parallel()
+	fs := make(MemoryFS)
+
+	writeFiles := map[string]string{
+		"/data/dir/foo.json":        "hello world",
+		"/data/dir/subdir/bar.json": "hello solar system",
+		"/data/dir/subdir/baz.json": "hello universe",
+		"/data/dir/subdir/bay.txt":  "hello bar keeper",
+	}
+
+	// Should work, as the underlying data type is a map.
+	func(fs MemoryFS) {
+		for path, content := range writeFiles {
+			bytes := []byte(content)
+			_ = fs.WriteFile(path, bytes)
+		}
+	}(fs)
+
+	t.Run("files are there", func(t *testing.T) {
+		testFilesAreThere(t, fs, writeFiles)
+	})
+}
+
 func testFilesAreThere(t *testing.T, fs MemoryFS, writeFiles map[string]string) {
 	for path, content := range writeFiles {
 		bytes, err := fs.ReadFile(path)