Validate MiniLcm types

backend/FwLite/MiniLcm.Tests/Validators/EntryValidatorTests.cs

@@ -11,24 +11,114 @@ public class EntryValidatorTests
     public void Succeeds_WhenSenseEntryIdIsGuidEmpty()
     {
         var entryId = Guid.NewGuid();
-        var entry = new Entry() { Id = entryId, Senses = [new Sense() { EntryId = Guid.Empty, }] };
+        var entry = new Entry() { Id = entryId, LexemeForm = new MultiString(){{"en", "lexeme"}}, Senses = [new Sense() { EntryId = Guid.Empty, }] };
         _validator.TestValidate(entry).ShouldNotHaveAnyValidationErrors();
     }
 
     [Fact]
     public void Succeeds_WhenSenseEntryIdMatchesEntry()
     {
-
         var entryId = Guid.NewGuid();
-        var entry = new Entry() { Id = entryId, Senses = [new Sense() { EntryId = entryId, }] };
+        var entry = new Entry() { Id = entryId, LexemeForm = new MultiString(){{"en", "lexeme"}}, Senses = [new Sense() { EntryId = entryId, }] };
         _validator.TestValidate(entry).ShouldNotHaveAnyValidationErrors();
     }
 
     [Fact]
     public void Fails_WhenSenseEntryIdDoesNotMatchEntry()
     {
         var entryId = Guid.NewGuid();
-        var entry = new Entry() { Id = entryId, Senses = [new Sense() { EntryId = Guid.NewGuid(), }] };
+        var entry = new Entry() { Id = entryId, LexemeForm = new MultiString(){{"en", "lexeme"}}, Senses = [new Sense() { EntryId = Guid.NewGuid(), }] };
         _validator.TestValidate(entry).ShouldHaveValidationErrorFor("Senses[0].EntryId");
     }
+
+    [Fact]
+    public void Succeeds_WhenDeletedAtIsNull()
+    {
+        var entryId = Guid.NewGuid();
+        var entry = new Entry() { Id = entryId, DeletedAt = null, LexemeForm = new MultiString(){{"en", "lexeme"}}, Senses = [new Sense() { EntryId = entryId, }] };
+        _validator.TestValidate(entry).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Fact]
+    public void Fails_WhenDeletedAtIsNotNull()
+    {
+        var entryId = Guid.NewGuid();
+        var now = DateTime.UtcNow;
+        var entry = new Entry() { Id = entryId, DeletedAt = now, LexemeForm = new MultiString(){{"en", "lexeme"}}, Senses = [new Sense() { EntryId = Guid.Empty, }] };
+        _validator.TestValidate(entry).ShouldHaveValidationErrorFor("DeletedAt");
+    }
+
+    [Fact]
+    public void Succeeds_WhenLexemeFormIsPresent()
+    {
+        var entry = new Entry() { Id = Guid.NewGuid(), LexemeForm = new MultiString(){{"en", "lexeme"}} };
+        _validator.TestValidate(entry).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Fact]
+    public void Fails_WhenLexemeFormIsMissing()
+    {
+        var entry = new Entry() { Id = Guid.NewGuid() };
+        _validator.TestValidate(entry).ShouldHaveValidationErrorFor("LexemeForm");
+    }
+
+    [Fact]
+    public void Fails_WhenLexemeFormHasNoContent()
+    {
+        // Technically the same as Fails_WhenLexemeFormIsMissing -- should we combine them?
+        var entry = new Entry() { Id = Guid.NewGuid(), LexemeForm = new MultiString() };
+        _validator.TestValidate(entry).ShouldHaveValidationErrorFor("LexemeForm");
+    }
+
+    [Fact]
+    public void Fails_WhenLexemeFormHasWsWithEmptyContent()
+    {
+        var entry = new Entry() { Id = Guid.NewGuid(), LexemeForm = new MultiString(){{"en", ""}} };
+        _validator.TestValidate(entry).ShouldHaveValidationErrorFor("LexemeForm");
+    }
+
+    [Theory]
+    [InlineData("CitationForm")]
+    [InlineData("LiteralMeaning")]
+    [InlineData("Note")]
+    public void Succeeds_WhenNonEmptyFieldIsPresent(string fieldName)
+    {
+        var entry = new Entry() { Id = Guid.NewGuid(), LexemeForm = new MultiString(){{"en", "lexeme"}} };
+        SetProperty(entry, fieldName, "content");
+        _validator.TestValidate(entry).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Theory]
+    [InlineData("CitationForm")]
+    [InlineData("LiteralMeaning")]
+    [InlineData("Note")]
+    public void Succeeds_WhenNonEmptyFieldHasNoContent(string fieldName)
+    {
+        var entry = new Entry() { Id = Guid.NewGuid(), LexemeForm = new MultiString(){{"en", "lexeme"}} };
+        MakePropertyEmpty(entry, fieldName);
+        _validator.TestValidate(entry).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Theory]
+    [InlineData("CitationForm")]
+    [InlineData("LiteralMeaning")]
+    [InlineData("Note")]
+    public void Fails_WhenNonEmptyFieldHasWsWithEmptyContent(string fieldName)
+    {
+        var entry = new Entry() { Id = Guid.NewGuid(), LexemeForm = new MultiString(){{"en", "lexeme"}} };
+        SetProperty(entry, fieldName, "");
+        _validator.TestValidate(entry).ShouldHaveValidationErrorFor(fieldName);
+    }
+
+    private void SetProperty(Entry entry, string propName, string content)
+    {
+        var propInfo = typeof(Entry).GetProperty(propName);
+        propInfo?.SetValue(entry, new MultiString(){{"en", content}});
+    }
+
+    private void MakePropertyEmpty(Entry entry, string propName)
+    {
+        var propInfo = typeof(Entry).GetProperty(propName);
+        propInfo?.SetValue(entry, new MultiString());
+    }
 }

backend/FwLite/MiniLcm.Tests/Validators/ExampleSentenceValidatorTests.cs

@@ -0,0 +1,91 @@
+using FluentValidation.TestHelper;
+using MiniLcm.Validators;
+
+namespace MiniLcm.Tests.Validators;
+
+public class ExampleSentenceValidatorTests
+{
+    private readonly ExampleSentenceValidator _validator = new();
+
+    [Fact]
+    public void Succeeds_WhenDeletedAtIsNull()
+    {
+        var example = new ExampleSentence() { Id = Guid.NewGuid(), Sentence = new MultiString(){{"en", "sentence"}}, DeletedAt = null };
+        _validator.TestValidate(example).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Fact]
+    public void Fails_WhenDeletedAtIsNotNull()
+    {
+        var example = new ExampleSentence() { Id = Guid.NewGuid(), Sentence = new MultiString(){{"en", "sentence"}}, DeletedAt = DateTimeOffset.UtcNow };
+        _validator.TestValidate(example).ShouldHaveValidationErrorFor("DeletedAt");
+    }
+
+    [Fact]
+    public void Succeeds_WhenSentenceIsPresent()
+    {
+        var example = new ExampleSentence() { Id = Guid.NewGuid(), Sentence = new MultiString(){{"en", "sentence"}} };
+        _validator.TestValidate(example).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Fact]
+    public void Fails_WhenSentenceIsMissing()
+    {
+        var example = new ExampleSentence() { Id = Guid.NewGuid() };
+        _validator.TestValidate(example).ShouldHaveValidationErrorFor("Sentence");
+    }
+
+    [Fact]
+    public void Fails_WhenSentenceHasNoContent()
+    {
+        // Technically the same as Fails_WhenSentenceIsMissing -- should we combine them?
+        var example = new ExampleSentence() { Id = Guid.NewGuid(), Sentence = new MultiString() };
+        _validator.TestValidate(example).ShouldHaveValidationErrorFor("Sentence");
+    }
+
+    [Fact]
+    public void Fails_WhenSentenceHasWsWithEmptyContent()
+    {
+        var example = new ExampleSentence() { Id = Guid.NewGuid(), Sentence = new MultiString(){{"en", ""}} };
+        _validator.TestValidate(example).ShouldHaveValidationErrorFor("Sentence");
+    }
+
+    [Theory]
+    [InlineData("Translation")]
+    public void Succeeds_WhenNonEmptyFieldIsPresent(string fieldName)
+    {
+        var example = new ExampleSentence() { Id = Guid.NewGuid(), Sentence = new MultiString(){{"en", "sentence"}} };
+        SetProperty(example, fieldName, "content");
+        _validator.TestValidate(example).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Theory]
+    [InlineData("Translation")]
+    public void Succeeds_WhenNonEmptyFieldHasNoContent(string fieldName)
+    {
+        var example = new ExampleSentence() { Id = Guid.NewGuid(), Sentence = new MultiString(){{"en", "sentence"}} };
+        MakePropertyEmpty(example, fieldName);
+        _validator.TestValidate(example).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Theory]
+    [InlineData("Translation")]
+    public void Fails_WhenNonEmptyFieldHasWsWithEmptyContent(string fieldName)
+    {
+        var example = new ExampleSentence() { Id = Guid.NewGuid(), Sentence = new MultiString(){{"en", "sentence"}} };
+        SetProperty(example, fieldName, "");
+        _validator.TestValidate(example).ShouldHaveValidationErrorFor(fieldName);
+    }
+
+    private void SetProperty(ExampleSentence example, string propName, string content)
+    {
+        var propInfo = typeof(ExampleSentence).GetProperty(propName);
+        propInfo?.SetValue(example, new MultiString(){{"en", content}});
+    }
+
+    private void MakePropertyEmpty(ExampleSentence example, string propName)
+    {
+        var propInfo = typeof(ExampleSentence).GetProperty(propName);
+        propInfo?.SetValue(example, new MultiString());
+    }
+}

backend/FwLite/MiniLcm.Tests/Validators/SenseValidatorTests.cs

@@ -0,0 +1,65 @@
+using FluentValidation.TestHelper;
+using MiniLcm.Validators;
+
+namespace MiniLcm.Tests.Validators;
+
+public class SenseValidatorTests
+{
+    private readonly SenseValidator _validator = new();
+
+    [Fact]
+    public void Succeeds_WhenDeletedAtIsNull()
+    {
+        var sense = new Sense() { Id = Guid.NewGuid(), DeletedAt = null };
+        _validator.TestValidate(sense).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Fact]
+    public void Fails_WhenDeletedAtIsNotNull()
+    {
+        var sense = new Sense() { Id = Guid.NewGuid(), DeletedAt = DateTimeOffset.UtcNow };
+        _validator.TestValidate(sense).ShouldHaveValidationErrorFor("DeletedAt");
+    }
+
+    [Theory]
+    [InlineData("Definition")]
+    [InlineData("Gloss")]
+    public void Succeeds_WhenNonEmptyFieldIsPresent(string fieldName)
+    {
+        var sense = new Sense() { Id = Guid.NewGuid() };
+        SetProperty(sense, fieldName, "content");
+        _validator.TestValidate(sense).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Theory]
+    [InlineData("Definition")]
+    [InlineData("Gloss")]
+    public void Succeeds_WhenNonEmptyFieldHasNoContent(string fieldName)
+    {
+        var sense = new Sense() { Id = Guid.NewGuid() };
+        MakePropertyEmpty(sense, fieldName);
+        _validator.TestValidate(sense).ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Theory]
+    [InlineData("Definition")]
+    [InlineData("Gloss")]
+    public void Fails_WhenNonEmptyFieldHasWsWithEmptyContent(string fieldName)
+    {
+        var sense = new Sense() { Id = Guid.NewGuid() };
+        SetProperty(sense, fieldName, "");
+        _validator.TestValidate(sense).ShouldHaveValidationErrorFor(fieldName);
+    }
+
+    private void SetProperty(Sense sense, string propName, string content)
+    {
+        var propInfo = typeof(Sense).GetProperty(propName);
+        propInfo?.SetValue(sense, new MultiString(){{"en", content}});
+    }
+
+    private void MakePropertyEmpty(Sense sense, string propName)
+    {
+        var propInfo = typeof(Sense).GetProperty(propName);
+        propInfo?.SetValue(sense, new MultiString());
+    }
+}

backend/FwLite/MiniLcm/Validators/EntryValidator.cs

@@ -7,7 +7,39 @@ public class EntryValidator : AbstractValidator<Entry>
 {
     public EntryValidator()
     {
+        RuleFor(e => e.DeletedAt).Null();
+        RuleFor(e => e.LexemeForm).Required();
+        RuleFor(e => e.CitationForm).NoEmptyValues();
+        RuleFor(e => e.LiteralMeaning).NoEmptyValues();
+        RuleFor(e => e.Note).NoEmptyValues();
         RuleForEach(e => e.Senses).SetValidator(entry => new SenseValidator(entry));
-        //todo just a stub as an example for senses
+        RuleForEach(e => e.Components).Must(NotBeComponentSelfReference);
+        RuleForEach(e => e.Components).Must(HaveCorrectComponentEntryReference);
+        RuleForEach(e => e.ComplexForms).Must(NotBeComplexFormSelfReference);
+        RuleForEach(e => e.ComplexForms).Must(HaveCorrectComplexFormEntryReference);
+        // RuleForEach(e => e.Components).SetValidator(entry => new ComplexFormComponentValidator(entry)); // TODO: Not implemented yet
+        // RuleForEach(e => e.ComplexForms).SetValidator(entry => new ComplexFormComponentValidator(entry)); // TODO: Not implemented yet
+        // TODO: ComplexFormComponentValidator(entry) might need to know the "direction" of the entry it's validating, i.e. one class for "I'm a component" and another for "I'm the complex entry"
+        RuleForEach(e => e.ComplexFormTypes).SetValidator(new ComplexFormTypeValidator());
+    }
+
+    private bool NotBeComponentSelfReference(Entry entry, ComplexFormComponent component)
+    {
+        return component.ComponentEntryId != entry.Id;
+    }
+
+    private bool HaveCorrectComponentEntryReference(Entry entry, ComplexFormComponent component)
+    {
+        return component.ComplexFormEntryId == entry.Id;
+    }
+
+    private bool NotBeComplexFormSelfReference(Entry entry, ComplexFormComponent component)
+    {
+        return component.ComplexFormEntryId != entry.Id;
+    }
+
+    private bool HaveCorrectComplexFormEntryReference(Entry entry, ComplexFormComponent component)
+    {
+        return component.ComponentEntryId == entry.Id;
     }
 }

backend/FwLite/MiniLcm/Validators/ExampleSentenceValidator.cs

@@ -0,0 +1,20 @@
+using FluentValidation;
+using MiniLcm.Models;
+
+namespace MiniLcm.Validators;
+
+public class ExampleSentenceValidator : AbstractValidator<ExampleSentence>
+{
+    public ExampleSentenceValidator()
+    {
+        RuleFor(es => es.DeletedAt).Null();
+        RuleFor(es => es.Sentence).Required();
+        RuleFor(es => es.Translation).NoEmptyValues();
+    }
+
+    public ExampleSentenceValidator(Sense sense) : this()
+    {
+        //it's ok if SenseId is an Empty guid
+        RuleFor(es => es.SenseId).Equal(sense.Id).When(es => es.SenseId != Guid.Empty).WithMessage(examplesentence => $"ExampleSentence (Id: {examplesentence.Id}) EntryId must match Sense {sense.Id}, but instead was {examplesentence.SenseId}");
+    }
+}

backend/FwLite/MiniLcm/Validators/PartOfSpeechIdValidator.cs

@@ -0,0 +1,18 @@
+using FluentValidation;
+using MiniLcm.Models;
+
+namespace MiniLcm.Validators;
+
+public class PartOfSpeechIdValidator : AbstractValidator<Guid?>
+{
+    public PartOfSpeechIdValidator()
+    {
+        RuleFor(id => id).Must(BeCanonicalGuid);
+    }
+
+    private bool BeCanonicalGuid(Guid? id)
+    {
+        // TODO: Load GOLDEtic.xml into app as a resource and add singleton providing access to it, then look up GUIDs there
+        return true;
+    }
+}

backend/FwLite/MiniLcm/Validators/SemanticDomainValidator.cs

@@ -0,0 +1,21 @@
+using FluentValidation;
+using MiniLcm.Models;
+
+namespace MiniLcm.Validators;
+
+public class SemanticDomainValidator : AbstractValidator<SemanticDomain>
+{
+    public SemanticDomainValidator()
+    {
+        RuleFor(s => s.Code).NotNull().NotEmpty();
+        RuleFor(s => s.DeletedAt).Null();
+        RuleFor(s => s.Id).Must(BeCanonicalGuid).When(s => s.Predefined);
+        RuleFor(s => s.Name).Required();
+    }
+
+    private bool BeCanonicalGuid(Guid id)
+    {
+        // TODO: Load SemDom.xml into app as a resource and add singleton providing access to it, then look up GUIDs there
+        return true;
+    }
+}

backend/FwLite/MiniLcm/Validators/SenseValidator.cs

@@ -7,7 +7,13 @@ public class SenseValidator : AbstractValidator<Sense>
 {
     public SenseValidator()
     {
-        //todo add validation for the other properties
+        RuleFor(s => s.DeletedAt).Null();
+        RuleFor(s => s.Definition).NoEmptyValues();
+        RuleFor(s => s.Gloss).NoEmptyValues();
+        // RuleFor(s => s.PartOfSpeech).Empty(); // TODO: Comment out if we're not yet ready to move away from strings
+        RuleFor(s => s.PartOfSpeechId).SetValidator(new PartOfSpeechIdValidator());
+        RuleForEach(s => s.SemanticDomains).SetValidator(new SemanticDomainValidator());
+        RuleForEach(s => s.ExampleSentences).SetValidator(sense => new ExampleSentenceValidator(sense));
     }
 
     public SenseValidator(Entry entry): this()