Data annotation attribute to check that a collection property does not have any duplicate items.

Author: ScottLilly

CSharpExtender/Attributes/UniqueItemsAttribute.cs

@@ -17,8 +17,8 @@ protected override ValidationResult IsValid(object value, ValidationContext vali
             return ValidationResult.Success;
         }
 
-        // Ensure the value is a collection
-        // Need to explicitly check for a string as it is enumerable
+        // Ensure the value is a collection.
+        // Need to explicitly check for string, as it is enumerable.
         if (value is string || value is not IEnumerable collection)
         {
             return new ValidationResult("The UniqueItemsAttribute must be applied to a collection.");
@@ -37,24 +37,23 @@ protected override ValidationResult IsValid(object value, ValidationContext vali
             {
                 if (AreItemsEqual(items[i], items[j]))
                 {
-                    return new ValidationResult(ErrorMessage ??
-                        $"The list contains duplicate items at indices {i} and {j}.");
+                    // Use ErrorMessage if provided; otherwise, use default
+                    string errorMessage = ErrorMessage ??
+                        $"The list contains duplicate items at indices {i} and {j}.";
+                    return new ValidationResult(errorMessage);
                 }
             }
         }
 
         return ValidationResult.Success;
     }
 
-    private static bool AreItemsEqual(object item1, object item2)
+    private bool AreItemsEqual(object item1, object item2)
     {
-        // If both items are null, they are considered equal
         if (item1 == null && item2 == null)
         {
             return true;
         }
-
-        // If one is null and the other is not, they are not equal
         if (item1 == null || item2 == null)
         {
             return false;

Test.CSharpExtender/Attributes/Test_UniqueItemsAttribute.cs

@@ -45,14 +45,26 @@ public void UniqueItemsAttribute_UniqueStrings_ReturnsSuccess()
     }
 
     [Fact]
-    public void UniqueItemsAttribute_DuplicateStrings_ReturnsError()
+    public void UniqueItemsAttribute_DuplicateStrings_DefaultErrorMessage()
     {
         var model = new { Items = new List<string> { "apple", "apple", "cherry" } };
         var attribute = new UniqueItemsAttribute();
         var result = attribute.GetValidationResult(model.Items, GetValidationContext(model));
 
         Assert.NotEqual(ValidationResult.Success, result);
         Assert.Contains("duplicate items", result.ErrorMessage);
+        Assert.Contains("indices 0 and 1", result.ErrorMessage);
+    }
+
+    [Fact]
+    public void UniqueItemsAttribute_DuplicateStrings_CustomErrorMessage()
+    {
+        var model = new { Items = new List<string> { "apple", "apple", "cherry" } };
+        var attribute = new UniqueItemsAttribute { ErrorMessage = "All items must be unique in the list." };
+        var result = attribute.GetValidationResult(model.Items, GetValidationContext(model));
+
+        Assert.NotEqual(ValidationResult.Success, result);
+        Assert.Equal("All items must be unique in the list.", result.ErrorMessage);
     }
 
     [Fact]
@@ -66,14 +78,26 @@ public void UniqueItemsAttribute_UniqueNumbers_ReturnsSuccess()
     }
 
     [Fact]
-    public void UniqueItemsAttribute_DuplicateNumbers_ReturnsError()
+    public void UniqueItemsAttribute_DuplicateNumbers_DefaultErrorMessage()
     {
         var model = new { Items = new List<int> { 1, 2, 2 } };
         var attribute = new UniqueItemsAttribute();
         var result = attribute.GetValidationResult(model.Items, GetValidationContext(model));
 
         Assert.NotEqual(ValidationResult.Success, result);
         Assert.Contains("duplicate items", result.ErrorMessage);
+        Assert.Contains("indices 1 and 2", result.ErrorMessage);
+    }
+
+    [Fact]
+    public void UniqueItemsAttribute_DuplicateNumbers_CustomErrorMessage()
+    {
+        var model = new { Items = new List<int> { 1, 2, 2 } };
+        var attribute = new UniqueItemsAttribute { ErrorMessage = "Numbers must be unique." };
+        var result = attribute.GetValidationResult(model.Items, GetValidationContext(model));
+
+        Assert.NotEqual(ValidationResult.Success, result);
+        Assert.Equal("Numbers must be unique.", result.ErrorMessage);
     }
 
     [Fact]
@@ -83,8 +107,8 @@ public void UniqueItemsAttribute_UniqueComplexObjects_ReturnsSuccess()
         {
             Items = new List<TestItem>
             {
-                new(1, "apple"),
-                new(2, "banana")
+                new TestItem(1, "apple"),
+                new TestItem(2, "banana")
             }
         };
 
@@ -95,26 +119,46 @@ public void UniqueItemsAttribute_UniqueComplexObjects_ReturnsSuccess()
     }
 
     [Fact]
-    public void UniqueItemsAttribute_DuplicateComplexObjects_ReturnsError()
+    public void UniqueItemsAttribute_DuplicateComplexObjects_DefaultErrorMessage()
     {
         var model = new
         {
             Items = new List<TestItem>
             {
-                new(1, "apple"),
-                new(1, "apple")
+                new TestItem(1, "apple"),
+                new TestItem(1, "apple")
             }
         };
 
         var attribute = new UniqueItemsAttribute();
         var result = attribute.GetValidationResult(model.Items, GetValidationContext(model));
-
+        
         Assert.NotEqual(ValidationResult.Success, result);
         Assert.Contains("duplicate items", result.ErrorMessage);
+        Assert.Contains("indices 0 and 1", result.ErrorMessage);
     }
 
     [Fact]
-    public void UniqueItemsAttribute_NonCollection_ThrowsError()
+    public void UniqueItemsAttribute_DuplicateComplexObjects_CustomErrorMessage()
+    {
+        var model = new
+        {
+            Items = new List<TestItem>
+            {
+                new TestItem(1, "apple"),
+                new TestItem(1, "apple")
+            }
+        };
+
+        var attribute = new UniqueItemsAttribute { ErrorMessage = "Objects in the list must have unique values." };
+        var result = attribute.GetValidationResult(model.Items, GetValidationContext(model));
+        
+        Assert.NotEqual(ValidationResult.Success, result);
+        Assert.Equal("Objects in the list must have unique values.", result.ErrorMessage);
+    }
+
+    [Fact]
+    public void UniqueItemsAttribute_SingleString_ReturnsError()
     {
         var model = new { Items = "not a list" };
         var attribute = new UniqueItemsAttribute();
@@ -123,4 +167,15 @@ public void UniqueItemsAttribute_NonCollection_ThrowsError()
         Assert.NotEqual(ValidationResult.Success, result);
         Assert.Contains("must be applied to a collection", result.ErrorMessage);
     }
+
+    [Fact]
+    public void UniqueItemsAttribute_NonCollectionNonString_ReturnsError()
+    {
+        var model = new { Items = 42 }; // An int, not a string or collection
+        var attribute = new UniqueItemsAttribute();
+        var result = attribute.GetValidationResult(model.Items, GetValidationContext(model));
+
+        Assert.NotEqual(ValidationResult.Success, result);
+        Assert.Contains("must be applied to a collection", result.ErrorMessage);
+    }
 }