can test updating shared flag merge

2 files changed, 68 insertions, 45 deletions

diff --git a/internal/server/repository/repository.go b/internal/server/repository/repository.go
index 8f9ce09..0fbff97 100644
--- a/internal/server/repository/repository.go
+++ b/internal/server/repository/repository.go
@@ -65,18 +65,6 @@ func newRepository(conf server.ServerConfig, fs fs) Repository {
 	}
 }
 
-func (r Repository) Put(ent types.Entry) error {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.entries[ent.ID] = ent
-
-	bytes, err := ent.JSONMarshal()
-	if err != err {
-		return err
-	}
-	return r.fs.WriteFile(r.entryPath(ent), bytes)
-}
-
 // Load repository into memory if not done yet.
 func (r Repository) load() error {
 	if *r.loaded {
@@ -140,6 +128,21 @@ func (r Repository) ListBytes() ([]byte, error) {
 	return json.Marshal(pairs)
 }
 
+// put writes exact the same entry to the repository. Whereas merge
+// Is a bit more refined, tries to merge the same entry wich are slightly
+// different into the same entry.
+func (r Repository) put(ent types.Entry) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.entries[ent.ID] = ent
+
+	bytes, err := ent.JSONMarshal()
+	if err != err {
+		return err
+	}
+	return r.fs.WriteFile(r.entryPath(ent), bytes)
+}
+
 func (r Repository) Get(id string) (types.Entry, error) {
 	if !r.getIdRe.MatchString(id) {
 		return types.Entry{}, fmt.Errorf("invalid id %s", id)
@@ -185,6 +188,11 @@ func (r Repository) entryPath(ent types.Entry) string {
 	return fmt.Sprintf("%s/%s/%s.json", r.conf.DataDir, time.Now().Format("2006"), ent.ID)
 }
 
+func (r Repository) Update(ent types.Entry) error {
+	// Update is just an alias for the merge, makes the intention clearer.
+	return r.Merge(ent)
+}
+
 func (r Repository) Merge(otherEnt types.Entry) error {
 	_ = r.load()
 	r.mu.Lock()
diff --git a/internal/server/repository/repository_test.go b/internal/server/repository/repository_test.go
index e96df0c..fa1168c 100644
--- a/internal/server/repository/repository_test.go
+++ b/internal/server/repository/repository_test.go
@@ -18,7 +18,7 @@ func TestRepositoryPutGet(t *testing.T) {
 
 	for _, ent := range makeEntries(t) {
 		t.Run(ent.ID, func(t *testing.T) {
-			_ = repo.Put(ent)
+			_ = repo.put(ent)
 			entGot, err := repo.Get(ent.ID)
 			if err != nil {
 				t.Error(err)
@@ -69,7 +69,7 @@ func TestRepositoryList(t *testing.T) {
 	entries := makeEntries(t)
 
 	for _, ent := range entries {
-		_ = repo.Put(ent)
+		_ = repo.put(ent)
 	}
 
 	pairs, _ := repo.List()
@@ -98,7 +98,7 @@ func TestRepositoryHasSameEntry(t *testing.T) {
 	fs := make(vfs.MemoryFS)
 	repo := newRepository(server.ServerConfig{DataDir: "./data"}, fs)
 	ent, _ := makeAnEntry()
-	_ = repo.Put(ent)
+	_ = repo.put(ent)
 
 	pair := entryPair{ent.ID, ent.Checksum()}
 	if !repo.hasSameEntry(pair) {
@@ -117,7 +117,7 @@ func TestRepositoryMerge(t *testing.T) {
 	fs := make(vfs.MemoryFS)
 	repo := newRepository(server.ServerConfig{DataDir: "./data"}, fs)
 	ent1, _ := makeAnEntry()
-	_ = repo.Put(ent1)
+	_ = repo.put(ent1)
 
 	ent2, _ := makeAnotherEntry()
 	// Need to have the same IDs so that the entries will actually be merged
@@ -149,9 +149,9 @@ func TestRepositoryMergeFromPartner(t *testing.T) {
 	repo2 := newRepository(server.ServerConfig{DataDir: "./data2"}, fs2)
 
 	ent1, _ := makeAnEntry()
-	_ = repo1.Put(ent1)
+	_ = repo1.put(ent1)
 	ent2, _ := makeAnotherEntry()
-	_ = repo2.Put(ent2)
+	_ = repo2.put(ent2)
 
 	getPair := func(ctx context.Context, partner string, pairs *[]entryPair) error {
 		var (
@@ -244,33 +244,48 @@ func TestRepositoryMergeFromPartner(t *testing.T) {
 		}
 	})
 
-	// t.Run("Change shared flag and merge to partner", func(t *testing.T) {
-	// 	// Validate the corrent test setup
-	// 	if ent1.Shared[1].Name != "LinkedIn" || ent1.Shared[1].Is != false {
-	// 		t.Error("for the test expected LinkedIn not to be shared", ent1.Shared[1])
-	// 	}
-
-	// 	// Simulate that the entry was shared to LinkedIn social media!
-	// 	ent1.Shared[1].Is = true
-
-	// 	// Before merging, repos should be out of sync.
-	// 	err := compare(repo1, repo2)
-	// 	if err == nil {
-	// 		t.Error("Expected both repositories to be out of sync")
-	// 	} else {
-	// 		t.Log("as expected repos are out of sync", err)
-	// 	}
-
-	// 	// Partner is merging the repo.
-	// 	if err := repo2.mergeFromPartner(context.Background(), "repo1", getPair, getEntry); err != nil {
-	// 		t.Error(err)
-	// 	}
-
-	// 	// Now, partners should be in sync.
-	// 	if err := compare(repo1, repo2); err != nil {
-	// 		t.Error(err)
-	// 	}
-	// })
+	t.Run("Change shared flag and merge to partner", func(t *testing.T) {
+		ent, err := repo1.Get(ent1.ID)
+		if err != nil {
+			t.Error(err)
+		}
+
+		// Validate the corrent test setup
+		if ent.Shared[1].Name != "LinkedIn" || ent.Shared[1].Is != false {
+			t.Error("for the test expected LinkedIn not to be shared", ent.Shared[1])
+		}
+
+		// Simulate that the entry was shared to LinkedIn social media!
+		ent.Shared[1].Is = true
+		if err := repo1.Update(ent); err != nil {
+			t.Error(err)
+		}
+
+		// Before merging, repos should be out of sync.
+		if err := compare(repo1, repo2); err == nil {
+			t.Log("as expected repos are out of sync", err)
+		}
+
+		// Partner is merging the repo.
+		if err := repo1.mergeFromPartner(context.Background(), "repo2", getPair, getEntry); err != nil {
+			t.Error(err)
+		}
+
+		// Still out of sync, as we merged the repos the wrong direction.
+		if err := compare(repo1, repo2); err == nil {
+			t.Log("as expected repos are out of sync", err)
+		}
+
+		// Partner is merging the repo the right direction.
+		if err := repo2.mergeFromPartner(context.Background(), "repo1", getPair, getEntry); err != nil {
+			t.Error(err)
+		}
+
+		// Now, partners should be in sync.
+		if err := compare(repo1, repo2); err != nil {
+			t.Error(err)
+		}
+	})
 }
 
 func makeEntries(t *testing.T) []types.Entry {