[WordService] Add XML docs and tests

Author: imnasnainaec

Backend.Tests/Services/WordServiceTests.cs

@@ -24,6 +24,35 @@ public void Setup()
             _wordService = new WordService(_wordRepo);
         }
 
+        [Test]
+        public void TestImportWordsDoesNotChangeTimestamps()
+        {
+            const string existingCreated = "existing-created";
+            const string existingModified = "existing-modified";
+
+            var importedWords = _wordService.ImportWords([
+                new Word { ProjectId = ProjId },
+                new Word { ProjectId = ProjId, Created = existingCreated, Modified = existingModified },
+            ]).Result;
+
+            Assert.That(importedWords, Has.Count.EqualTo(2));
+            Assert.That(importedWords[0].Created, Is.Not.Empty);
+            Assert.That(importedWords[0].Modified, Is.Not.Empty);
+            Assert.That(importedWords[1].Created, Is.EqualTo(existingCreated));
+            Assert.That(importedWords[1].Modified, Is.EqualTo(existingModified));
+            Assert.That(_wordRepo.GetAllFrontier(ProjId).Result, Has.Count.EqualTo(2));
+        }
+
+        [Test]
+        public void TestImportWordsEmptyInputReturnsEmptyAndDoesNotChangeRepo()
+        {
+            var importedWords = _wordService.ImportWords([]).Result;
+
+            Assert.That(importedWords, Is.Empty);
+            Assert.That(_wordRepo.GetAllFrontier(ProjId).Result, Is.Empty);
+            Assert.That(_wordRepo.GetAllWords(ProjId).Result, Is.Empty);
+        }
+
         [Test]
         public void TestCreateAddsUserId()
         {
@@ -39,6 +68,28 @@ public void TestCreateDoesNotAddDuplicateUserId()
             Assert.That(word.EditedBy, Has.Count.EqualTo(1));
         }
 
+        [Test]
+        public void TestCreateBlankUserIdDoesNotAppendEditedBy()
+        {
+            var word = _wordService.Create("", new Word { EditedBy = ["other"] }).Result;
+
+            Assert.That(word.EditedBy, Has.Count.EqualTo(1));
+            Assert.That(word.EditedBy.Last(), Is.EqualTo("other"));
+        }
+
+        [Test]
+        public void TestCreatePreservesCreatedAndUpdatesModified()
+        {
+            const string existingCreated = "existing-created";
+            const string existingModified = "existing-modified";
+
+            var createdWord = _wordService.Create(UserId,
+                new Word { ProjectId = ProjId, Created = existingCreated, Modified = existingModified }).Result;
+
+            Assert.That(createdWord.Created, Is.EqualTo(existingCreated));
+            Assert.That(createdWord.Modified, Is.Not.EqualTo(existingModified));
+        }
+
         [Test]
         public void TestDeleteAudioBadInput()
         {
@@ -48,10 +99,8 @@ public void TestDeleteAudioBadInput()
             Assert.That(_wordService.DeleteAudio("non-proj-id", UserId, wordInFrontier.Id, fileName).Result, Is.Null);
             Assert.That(_wordService.DeleteAudio(ProjId, UserId, "non-word-id", fileName).Result, Is.Null);
 
-            var ex = Assert.Throws<AggregateException>(() =>
-            {
-                _ = _wordService.DeleteAudio(ProjId, UserId, wordInFrontier.Id, "non-file-name").Result;
-            });
+            var ex = Assert.Throws<AggregateException>(
+                () => _wordService.DeleteAudio(ProjId, UserId, wordInFrontier.Id, "non-file-name").Wait());
             Assert.That(ex?.InnerException, Is.InstanceOf<ArgumentException>());
         }
 
@@ -126,6 +175,22 @@ public void TestDeleteFrontierWordCopiesToWordsAndRemovesFrontier()
             Assert.That(_wordRepo.GetAllFrontier(ProjId).Result, Is.Empty);
         }
 
+        [Test]
+        public void TestDeleteFrontierWordPreservesHistoryAndAppendsDeletedId()
+        {
+            var word = _wordRepo.Create(new Word { ProjectId = ProjId, History = ["older-1", "older-2"] }).Result;
+
+            var deletedId = _wordService.DeleteFrontierWord(ProjId, UserId, word.Id).Result;
+            Assert.That(deletedId, Is.Not.Null);
+            var deletedWord = _wordRepo.GetWord(ProjId, deletedId).Result;
+            var expectedHistoryPrefix = new[] { "older-1", "older-2" };
+
+            Assert.That(deletedWord, Is.Not.Null);
+            Assert.That(deletedWord.History, Has.Count.EqualTo(3));
+            Assert.That(deletedWord.History.Take(2), Is.EqualTo(expectedHistoryPrefix));
+            Assert.That(deletedWord.History.Last(), Is.EqualTo(word.Id));
+        }
+
         [Test]
         public void TestRestoreFrontierWordAlreadyInFrontierThrows()
         {
@@ -137,10 +202,20 @@ public void TestRestoreFrontierWordAlreadyInFrontierThrows()
                 Throws.TypeOf<AggregateException>());
         }
 
+        [Test]
+        public void TestRestoreFrontierWordDeletedWordThrows()
+        {
+            var deletedWord = _wordRepo.Add(new Word { ProjectId = ProjId, Accessibility = Status.Deleted }).Result;
+
+            var ex = Assert.Throws<AggregateException>(
+                () => _wordService.RestoreFrontierWord(ProjId, deletedWord.Id).Wait());
+            Assert.That(ex?.InnerException, Is.InstanceOf<ArgumentException>());
+        }
+
         [Test]
         public void TestRestoreFrontierWordMissingWordReturnsFalse()
         {
-            var word = _wordRepo.Add(new Word { ProjectId = ProjId }).Result;
+            _wordRepo.Add(new Word { ProjectId = ProjId }).Wait();
 
             var result = _wordService.RestoreFrontierWord(ProjId, "NotAnId").Result;
 
@@ -206,6 +281,19 @@ public void TestUpdateUsingCitationForm()
             Assert.That(vernUpdate.UsingCitationForm, Is.False);
         }
 
+        [Test]
+        public void TestUpdateDoesNotDuplicateExistingHistoryId()
+        {
+            var word = _wordRepo.Create(new Word { ProjectId = ProjId }).Result;
+            var oldId = word.Id;
+            word.History.Add(oldId);
+
+            var updatedWord = _wordService.Update(UserId, word).Result;
+
+            Assert.That(updatedWord, Is.Not.Null);
+            Assert.That(updatedWord.History.Count(id => id == oldId), Is.EqualTo(1));
+        }
+
         [Test]
         public void TestFindContainingWordNoFrontier()
         {
@@ -291,5 +379,137 @@ public void TestFindContainingWordSameVernEmptySensesSameDoms()
             var dupId = _wordService.FindContainingWord(newWord).Result;
             Assert.That(dupId, Is.EqualTo(oldWord.Id));
         }
+
+        [Test]
+        public void TestFindContainingWordIgnoresWordsNotInFrontier()
+        {
+            var oldWordInWordsOnly = Util.RandomWord(ProjId);
+            oldWordInWordsOnly = _wordRepo.Add(oldWordInWordsOnly).Result;
+
+            var newWord = Util.RandomWord(ProjId);
+            newWord.Vernacular = oldWordInWordsOnly.Vernacular;
+            newWord.Senses = oldWordInWordsOnly.Senses.Select(s => s.Clone()).ToList();
+
+            var dupId = _wordService.FindContainingWord(newWord).Result;
+
+            Assert.That(dupId, Is.Null);
+        }
+
+        [Test]
+        public void TestMergeReplaceFrontierUpdatesAndDeletes()
+        {
+            var childToReplace = _wordRepo.Create(Util.RandomWord(ProjId)).Result;
+            var childToDelete = _wordRepo.Create(Util.RandomWord(ProjId)).Result;
+            var parent = Util.RandomWord(ProjId);
+            parent.Id = childToReplace.Id;
+            parent.Vernacular = "merged-vern";
+
+            var mergedParents = _wordService
+                .MergeReplaceFrontier(ProjId, UserId, [parent], [childToReplace.Id, childToDelete.Id]).Result;
+
+            Assert.That(mergedParents, Is.Not.Null);
+            Assert.That(mergedParents, Has.Count.EqualTo(1));
+
+            var mergedParent = mergedParents.Single();
+            Assert.That(mergedParent.Id, Is.Not.EqualTo(childToReplace.Id));
+            Assert.That(mergedParent.History.Last(), Is.EqualTo(childToReplace.Id));
+            Assert.That(mergedParent.EditedBy.Last(), Is.EqualTo(UserId));
+
+            var frontier = _wordRepo.GetAllFrontier(ProjId).Result;
+            Assert.That(frontier, Has.Count.EqualTo(1));
+            Assert.That(frontier.Single().Id, Is.EqualTo(mergedParent.Id));
+
+            var deletedCopy = _wordRepo.GetAllWords(ProjId).Result
+                .Find(w => w.Accessibility == Status.Deleted && w.History.Contains(childToDelete.Id));
+            Assert.That(deletedCopy, Is.Not.Null);
+            Assert.That(deletedCopy.EditedBy.Last(), Is.EqualTo(UserId));
+        }
+
+        [Test]
+        public void TestMergeReplaceFrontierWrongProjectThrows()
+        {
+            var parent = Util.RandomWord("other-project");
+
+            var ex = Assert.Throws<AggregateException>(
+                () => _wordService.MergeReplaceFrontier(ProjId, UserId, [parent], []).Wait());
+            Assert.That(ex?.InnerException, Is.InstanceOf<ArgumentException>());
+        }
+
+        [Test]
+        public void TestMergeReplaceFrontierDeleteOnlyReturnsEmpty()
+        {
+            var kid1 = _wordRepo.Create(new Word { ProjectId = ProjId }).Result;
+            var kid2 = _wordRepo.Create(new Word { ProjectId = ProjId }).Result;
+
+            var mergedParents = _wordService.MergeReplaceFrontier(ProjId, UserId, [], [kid1.Id, kid2.Id]).Result;
+
+            Assert.That(mergedParents, Is.Not.Null);
+            Assert.That(mergedParents, Is.Empty);
+            Assert.That(_wordRepo.GetAllFrontier(ProjId).Result, Is.Empty);
+
+            var allWords = _wordRepo.GetAllWords(ProjId).Result;
+            Assert.That(allWords.Any(w => w.Accessibility == Status.Deleted && w.History.Contains(kid1.Id)), Is.True);
+            Assert.That(allWords.Any(w => w.Accessibility == Status.Deleted && w.History.Contains(kid2.Id)), Is.True);
+        }
+
+        [Test]
+        public void TestRevertMergeReplaceFrontierDeletesAndRestores()
+        {
+            var wordToRestore = _wordRepo.Add(new Word { ProjectId = ProjId }).Result;
+            var frontierWordToDelete = _wordRepo.Create(new Word { ProjectId = ProjId }).Result;
+
+            var result = _wordService.RevertMergeReplaceFrontier(
+                ProjId, UserId, [wordToRestore.Id], [frontierWordToDelete.Id]).Result;
+
+            Assert.That(result, Is.True);
+            Assert.That(_wordRepo.IsInFrontier(ProjId, wordToRestore.Id).Result, Is.True);
+            Assert.That(_wordRepo.IsInFrontier(ProjId, frontierWordToDelete.Id).Result, Is.False);
+
+            var deletedCopy = _wordRepo.GetAllWords(ProjId).Result
+                .Find(w => w.Accessibility == Status.Deleted && w.History.Contains(frontierWordToDelete.Id));
+            Assert.That(deletedCopy, Is.Not.Null);
+            Assert.That(deletedCopy.EditedBy.Last(), Is.EqualTo(UserId));
+        }
+
+        [Test]
+        public void TestRevertMergeReplaceFrontierMissingRestoreReturnsFalse()
+        {
+            var frontierWordToDelete = _wordRepo.Create(new Word { ProjectId = ProjId }).Result;
+
+            var result = _wordService.RevertMergeReplaceFrontier(
+                ProjId, UserId, ["missing-id"], [frontierWordToDelete.Id]).Result;
+
+            Assert.That(result, Is.False);
+            Assert.That(_wordRepo.IsInFrontier(ProjId, frontierWordToDelete.Id).Result, Is.False);
+        }
+
+        [Test]
+        public void TestRevertMergeReplaceFrontierOverlappingIdsThrows()
+        {
+            var word = _wordRepo.Create(new Word { ProjectId = ProjId }).Result;
+
+            var ex = Assert.Throws<AggregateException>(
+                () => _wordService.RevertMergeReplaceFrontier(ProjId, UserId, [word.Id], [word.Id]).Wait());
+            Assert.That(ex?.InnerException, Is.InstanceOf<ArgumentException>());
+        }
+
+        [Test]
+        public void TestRevertMergeReplaceFrontierNoOpReturnsTrueAndLeavesStateUnchanged()
+        {
+            _wordRepo.Create(new Word { ProjectId = ProjId }).Wait();
+            _wordRepo.Add(new Word { ProjectId = ProjId }).Wait();
+
+            var wordsBefore = _wordRepo.GetAllWords(ProjId).Result.Select(w => w.Id).OrderBy(id => id).ToList();
+            var frontierBefore = _wordRepo.GetAllFrontier(ProjId).Result.Select(w => w.Id).OrderBy(id => id).ToList();
+
+            var result = _wordService.RevertMergeReplaceFrontier(ProjId, UserId, [], []).Result;
+
+            var wordsAfter = _wordRepo.GetAllWords(ProjId).Result.Select(w => w.Id).OrderBy(id => id).ToList();
+            var frontierAfter = _wordRepo.GetAllFrontier(ProjId).Result.Select(w => w.Id).OrderBy(id => id).ToList();
+
+            Assert.That(result, Is.True);
+            Assert.That(wordsAfter, Is.EqualTo(wordsBefore));
+            Assert.That(frontierAfter, Is.EqualTo(frontierBefore));
+        }
     }
 }