Merge pull request #18 from luboshl/fix/nullable-propert-without-setter

Fix getting nullability info for property with getter only

src/Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
 
   <PropertyGroup>
-    <VersionPrefix>1.2.0</VersionPrefix>
+    <VersionPrefix>1.2.1</VersionPrefix>
     <!-- VersionSuffix used for local builds -->
     <VersionSuffix>dev</VersionSuffix>
     <!-- VersionSuffix to be used for CI builds -->

src/MiniValidationPlus/NonNullablePropertyHelper.cs

@@ -24,7 +24,7 @@ public bool IsNonNullableReferenceType(PropertyInfo propertyInfo)
             }
 
             var nullabilityInfo = nullabilityContext.Create(propertyInfo);
-            return nullabilityInfo.WriteState is not NullabilityState.Nullable;
+            return nullabilityInfo.ReadState is not NullabilityState.Nullable;
         }
     }
 }

tests/MiniValidationPlus.UnitTests/NonNullablePropertyHelperTests.cs

@@ -36,6 +36,7 @@ public void IsNonNullableReferenceType_Identifies_Correct_Properties_Of_Class()
         Assert.Contains(nameof(ClassModel.IntNullable), other);
         Assert.Contains(nameof(ClassModel.StringNullable), other);
         Assert.Contains(nameof(ClassModel.AnotherNullable), other);
+        Assert.Contains(nameof(ClassModel.StringNullableWithoutSetter), other);
     }
 
     [Fact]
@@ -70,12 +71,14 @@ public void IsNonNullableReferenceType_Identifies_Correct_Properties_Of_Record()
         Assert.Contains(nameof(RecordModel.AnotherNullable), other);
     }
 
+    [SuppressMessage("ReSharper", "UnassignedGetOnlyAutoProperty")]
     private class ClassModel
     {
         public int IntNonNullable { get; set; }
         public int? IntNullable { get; set; }
         public string StringNonNullable { get; set; } = null!;
         public string? StringNullable { get; set; }
+        public string? StringNullableWithoutSetter { get; }
         public AnotherModel AnotherNonNullable { get; set; } = new();
         public AnotherModel? AnotherNullable { get; set; }
     }

tests/MiniValidationPlus.UnitTests/TestTypes.cs

@@ -284,4 +284,29 @@ class TestTypeForTypeDescriptor
 
     [MaxLength(1)]
     public string? AnotherProperty { get; set; } = "Test";
-}
+}
+
+class TestTypeWithPropertiesWithoutSetter
+{
+    public string NonNullableString { get; }
+
+    public string? NullableString { get; }
+
+    [Required(AllowEmptyStrings = false)]
+    public string RequiredNonNullableString { get; }
+
+    [Required(AllowEmptyStrings = false)]
+    public string? RequiredNullableString { get; }
+
+    public TestTypeWithPropertiesWithoutSetter(
+        string nonNullableString = "Default",
+        string? nullableString = "Default",
+        string requiredNonNullableString = "Default", 
+        string? requiredNullableString = "Default")
+    {
+        NonNullableString = nonNullableString;
+        NullableString = nullableString;
+        RequiredNonNullableString = requiredNonNullableString;
+        RequiredNullableString = requiredNullableString;
+    }
+}

tests/MiniValidationPlus.UnitTests/TryValidate.cs

@@ -162,6 +162,138 @@ public void NonNullable_Invalid_When_Null_On_Record()
         Assert.False(result);
         Assert.Single(errors);
     }
+
+    [Fact]
+    public void PropertyWithoutSetter_NonNullable_Valid_When_NonEmpty()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(nonNullableString: "test");
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.True(result);
+        Assert.Empty(errors);
+    }   
+
+    [Fact]
+    public void PropertyWithoutSetter_NonNullable_Valid_When_Empty()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(nonNullableString: string.Empty);
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.True(result);
+        Assert.Empty(errors);
+    }   
+
+    [Fact]
+    public void PropertyWithoutSetter_NonNullable_Invalid_When_Null()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(nonNullableString: null!);
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.False(result);
+        Assert.Single(errors);
+    }
+
+    [Fact]
+    public void PropertyWithoutSetter_Nullable_Valid_When_NonEmpty()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(nullableString: "test");
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.True(result);
+        Assert.Empty(errors);
+    }   
+
+    [Fact]
+    public void PropertyWithoutSetter_Nullable_Valid_When_Empty()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(nullableString: string.Empty);
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.True(result);
+        Assert.Empty(errors);
+    }   
+
+    [Fact]
+    public void PropertyWithoutSetter_Nullable_Valid_When_Null()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(nullableString: null!);
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.True(result);
+        Assert.Empty(errors);
+    }
+
+    [Fact]
+    public void PropertyWithoutSetter_RequiredNonNullable_Valid_When_NonEmpty()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(requiredNonNullableString: "test");
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.True(result);
+        Assert.Empty(errors);
+    }   
+
+    [Fact]
+    public void PropertyWithoutSetter_RequiredNonNullable_Invalid_When_Empty()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(requiredNonNullableString: string.Empty);
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.False(result);
+        Assert.Single(errors);
+    }   
+
+    [Fact]
+    public void PropertyWithoutSetter_RequiredNonNullable_Invalid_When_Null()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(requiredNonNullableString: null!);
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.False(result);
+        Assert.Single(errors);
+    }
+
+    [Fact]
+    public void PropertyWithoutSetter_RequiredNullable_Valid_When_NonEmpty()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(requiredNullableString: "test");
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.True(result);
+        Assert.Empty(errors);
+    }   
+
+    [Fact]
+    public void PropertyWithoutSetter_RequiredNullable_Invalid_When_Empty()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(requiredNullableString: string.Empty);
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.False(result);
+        Assert.Single(errors);
+    }   
+
+    [Fact]
+    public void PropertyWithoutSetter_RequiredNullable_Invalid_When_Null()
+    {
+        var thingToValidate = new TestTypeWithPropertiesWithoutSetter(requiredNullableString: null!);
+
+        var result = MiniValidatorPlus.TryValidate(thingToValidate, out var errors);
+
+        Assert.False(result);
+        Assert.Single(errors);
+    }
 #endif
 
     [Fact]