Merge pull request #41

Simplified the syntax for registration of randomization rules

Author: TonyTroeff

README.md

@@ -98,11 +98,11 @@ public class PersonRandomizer : ComplexRandomizer<Person>
 {
     public PersonRandomizer()
     {
-        this.AddRandomizationRule(p => p.Id, new GuidRandomizer());
-        this.AddRandomizationRule(p => p.Name, new StringRandomizer());
-        this.AddRandomizationRule(p => p.Age, new NumberRandomizer());
-        this.AddRandomizationRule(p => p.IsEmployed, new BooleanRandomizer());
-        this.AddRandomizationRule(p => p.EventDate, new DateTimeOffsetRandomizer());
+        this.Randomize(p => p.Id, new GuidRandomizer());
+        this.Randomize(p => p.Name, new StringRandomizer());
+        this.Randomize(p => p.Age, new NumberRandomizer());
+        this.Randomize(p => p.IsEmployed, new BooleanRandomizer());
+        this.Randomize(p => p.EventDate, new DateTimeOffsetRandomizer());
     }
 }
 ```
@@ -161,5 +161,4 @@ The order will be preserved - the value setter of a given randomization rule wil
 
 - We do not recommend using `complex randomizers` with abstract classes or interfaces.
 While it is possible to make such a setup work, there may be some intricacies along the way.
-The `AddRandomizationRule` and `OverrideRandomizationRule` methods are publicly exposed so extension methods can be extracted (or even inheritance will get the job done for some simple cases).
 Another idea that is especially useful when dealing with many derived types that have behavioral but not structural differences, is to make the `complex randomizer` generic.

src/TryAtSoftware.Randomizer.Core/ComplexRandomizer.cs

@@ -2,9 +2,10 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq.Expressions;
 using TryAtSoftware.Randomizer.Core.Interfaces;
 
-public class ComplexRandomizer<TEntity> : IComplexRandomizer<TEntity>
+public class ComplexRandomizer<TEntity> : IConfigurableComplexRandomizer<TEntity>
 {
     private readonly List<string> _orderedMembers = new ();
     private readonly HashSet<string> _randomizedMembers = new ();
@@ -24,20 +25,6 @@ public ComplexRandomizer(IInstanceBuilder<TEntity> instanceBuilder)
     /// <inheritdoc />
     public IInstanceBuilder<TEntity> InstanceBuilder { get; }
 
-    /// <inheritdoc />
-    public void AddRandomizationRule(IRandomizationRule<TEntity> rule)
-    {
-        if (string.IsNullOrWhiteSpace(rule.PropertyName) || this._randomizedMembers.Contains(rule.PropertyName)) return;
-        this.SetRuleInternally(rule);
-    }
-
-    /// <inheritdoc />
-    public void OverrideRandomizationRule(IRandomizationRule<TEntity> rule)
-    {
-        if (string.IsNullOrWhiteSpace(rule.PropertyName)) return;
-        this.SetRuleInternally(rule);
-    }
-
     /// <inheritdoc />
     public TEntity PrepareRandomValue()
     {
@@ -55,6 +42,31 @@ public TEntity PrepareRandomValue()
         return instance;
     }
 
+    /// <inheritdoc />
+    public void Randomize(IRandomizationRule<TEntity> rule)
+    {
+        if (rule is null) throw new ArgumentNullException(nameof(rule));
+        this.SetRuleInternally(rule);
+    }
+
+    /// <inheritdoc />
+    public void Randomize<TValue>(Expression<Func<TEntity, TValue>> propertySelector, IRandomizer<TValue> randomizer)
+    {
+        if (propertySelector is null) throw new ArgumentNullException(nameof(propertySelector));
+        if (randomizer is null) throw new ArgumentNullException(nameof(randomizer));
+        
+        this.SetRuleInternally(new RandomizationRule<TEntity,TValue>(propertySelector, randomizer));
+    }
+
+    /// <inheritdoc />
+    public void Randomize<TValue>(Expression<Func<TEntity, TValue>> propertySelector, Func<TEntity, IRandomizer<TValue>?> getRandomizer)
+    {
+        if (propertySelector is null) throw new ArgumentNullException(nameof(propertySelector));
+        if (getRandomizer is null) throw new ArgumentNullException(nameof(getRandomizer));
+        
+        this.SetRuleInternally(new RandomizationRule<TEntity,TValue>(propertySelector, getRandomizer));
+    }
+
     private void SetRuleInternally(IRandomizationRule<TEntity> rule)
     {
         if (string.IsNullOrWhiteSpace(rule.PropertyName)) return;

src/TryAtSoftware.Randomizer.Core/Helpers/ExpressionsHelper.cs

@@ -1,9 +1,16 @@
 namespace TryAtSoftware.Randomizer.Core.Interfaces;
 
+using System;
+using System.Linq.Expressions;
+
 public interface IComplexRandomizer<out TEntity> : IRandomizer<TEntity>
 {
     IInstanceBuilder<TEntity> InstanceBuilder { get; }
+}
 
-    void AddRandomizationRule(IRandomizationRule<TEntity> rule);
-    void OverrideRandomizationRule(IRandomizationRule<TEntity> rule);
+public interface IConfigurableComplexRandomizer<TEntity> : IComplexRandomizer<TEntity>
+{
+    void Randomize(IRandomizationRule<TEntity> rule);
+    void Randomize<TValue>(Expression<Func<TEntity, TValue>> propertySelector, IRandomizer<TValue> randomizer);
+    void Randomize<TValue>(Expression<Func<TEntity, TValue>> propertySelector, Func<TEntity, IRandomizer<TValue>?> getRandomizer);
 }

src/TryAtSoftware.Randomizer.Core/Interfaces/IComplexRandomizer.cs

@@ -1,53 +1,9 @@
 namespace TryAtSoftware.Randomizer.Core;
 
-using System;
-using System.Linq.Expressions;
 using TryAtSoftware.Randomizer.Core.Interfaces;
 using TryAtSoftware.Randomizer.Core.Primitives;
 
 public static class RandomizationExtensions
 {
     public static IRandomizer<TValue> AsConstantRandomizer<TValue>(this TValue value) => new ConstantValueRandomizer<TValue>(value);
-
-    public static void AddRandomizationRule<TEntity, TValue>(
-        this IComplexRandomizer<TEntity> complexRandomizer,
-        Expression<Func<TEntity, TValue>> propertySelector,
-        IRandomizer<TValue> randomizer)
-    {
-        var rule = BuildRandomizationRule(propertySelector, randomizer);
-        complexRandomizer.AddRandomizationRule(rule);
-    }
-    
-    public static void AddRandomizationRule<TEntity, TValue>(
-        this IComplexRandomizer<TEntity> complexRandomizer,
-        Expression<Func<TEntity, TValue>> propertySelector,
-        Func<TEntity, IRandomizer<TValue>?> getRandomizer)
-    {
-        var rule = BuildRandomizationRule(propertySelector, getRandomizer);
-        complexRandomizer.AddRandomizationRule(rule);
-    }
-
-    public static void OverrideRandomizationRule<TEntity, TValue>(
-        this IComplexRandomizer<TEntity> complexRandomizer,
-        Expression<Func<TEntity, TValue>> propertySelector,
-        IRandomizer<TValue> randomizer)
-    {
-        var rule = BuildRandomizationRule(propertySelector, randomizer);
-        complexRandomizer.OverrideRandomizationRule(rule);
-    }
-
-    public static void OverrideRandomizationRule<TEntity, TValue>(
-        this IComplexRandomizer<TEntity> complexRandomizer,
-        Expression<Func<TEntity, TValue>> propertySelector,
-        Func<TEntity, IRandomizer<TValue>?> getRandomizer)
-    {
-        var rule = BuildRandomizationRule(propertySelector, getRandomizer);
-        complexRandomizer.OverrideRandomizationRule(rule);
-    }
-
-    private static IRandomizationRule<TEntity> BuildRandomizationRule<TEntity, TValue>(Expression<Func<TEntity, TValue>> propertySelector, IRandomizer<TValue> randomizer)
-        => new RandomizationRule<TEntity, TValue>(propertySelector, randomizer);
-
-    private static IRandomizationRule<TEntity> BuildRandomizationRule<TEntity, TValue>(Expression<Func<TEntity, TValue>> propertySelector, Func<TEntity, IRandomizer<TValue>?> getRandomizer)
-        => new RandomizationRule<TEntity, TValue>(propertySelector, getRandomizer);
 }

src/TryAtSoftware.Randomizer.Core/RandomizationExtensions.cs

@@ -2,7 +2,7 @@
 
 using System;
 using System.Linq.Expressions;
-using TryAtSoftware.Randomizer.Core.Helpers;
+using TryAtSoftware.Extensions.Reflection;
 using TryAtSoftware.Randomizer.Core.Interfaces;
 using TryAtSoftware.Randomizer.Core.Primitives;
 
@@ -52,7 +52,7 @@ private static string ExtractPropertyName(Expression<Func<TEntity, TValue>> prop
     {
         if (propertySelector is null) throw new ArgumentNullException(nameof(propertySelector));
 
-        var property = propertySelector.GetPropertyInfo();
-        return property.Name;
+        var memberInfo = propertySelector.GetMemberInfo();
+        return memberInfo.Name;
     }
 }

src/TryAtSoftware.Randomizer.Core/RandomizationRule.cs

@@ -17,11 +17,11 @@ public void ComplexRandomizerShouldWorkCorrectly()
     {
         var instanceBuilder = new PersonInstanceBuilder();
         var complexRandomizer = new ComplexRandomizer<Person>(instanceBuilder);
-        complexRandomizer.AddRandomizationRule(p => p.Id, new GuidRandomizer());
-        complexRandomizer.AddRandomizationRule(p => p.Name, new StringRandomizer());
-        complexRandomizer.AddRandomizationRule(p => p.Age, new NumberRandomizer());
-        complexRandomizer.AddRandomizationRule(p => p.IsEmployed, new BooleanRandomizer());
-        complexRandomizer.AddRandomizationRule(p => p.EventDate, new DateTimeOffsetRandomizer());
+        complexRandomizer.Randomize(p => p.Id, new GuidRandomizer());
+        complexRandomizer.Randomize(p => p.Name, new StringRandomizer());
+        complexRandomizer.Randomize(p => p.Age, new NumberRandomizer());
+        complexRandomizer.Randomize(p => p.IsEmployed, new BooleanRandomizer());
+        complexRandomizer.Randomize(p => p.EventDate, new DateTimeOffsetRandomizer());
 
         var firstPerson = complexRandomizer.PrepareRandomValue();
         Assert.NotNull(firstPerson);
@@ -35,9 +35,9 @@ public void ComplexRandomizerShouldWorkCorrectly()
     public void ComplexInstanceBuildingProcessShouldBeExecutedCorrectly()
     {
         var complexRandomizer = new ComplexRandomizer<Car>();
-        complexRandomizer.AddRandomizationRule(x => x.Make, new StringRandomizer());
-        complexRandomizer.AddRandomizationRule(x => x.Model, new StringRandomizer());
-        complexRandomizer.AddRandomizationRule(x => x.Year, new NumberRandomizer());
+        complexRandomizer.Randomize(x => x.Make, new StringRandomizer());
+        complexRandomizer.Randomize(x => x.Model, new StringRandomizer());
+        complexRandomizer.Randomize(x => x.Year, new NumberRandomizer());
 
         var firstCar = complexRandomizer.PrepareRandomValue();
         Assert.NotNull(firstCar);
@@ -83,7 +83,7 @@ public void OrderOfRandomizationRulesShouldBeAccepted()
             for (var j = 0; j < randomizationRuleBuilders.Count; j++)
             {
                 var rule = randomizationRuleBuilders[j].Invoke(valueSetters[valueSetterIndices[j]]);
-                complexRandomizer.AddRandomizationRule(rule);
+                complexRandomizer.Randomize(rule);
             }
 
             var person = complexRandomizer.PrepareRandomValue();

tests/TryAtSoftware.Randomizer.Core.Tests/ComplexInitialization/ComplexInitializationTests.cs

@@ -0,0 +1,45 @@
+namespace TryAtSoftware.Randomizer.Core.Tests;
+
+using System;
+using TryAtSoftware.Randomizer.Core.Primitives;
+using TryAtSoftware.Randomizer.Core.Tests.Models;
+using Xunit;
+
+public class ComplexRandomizerTests
+{
+    [Fact]
+    public void RandomizeShouldThrowExceptionWhenInvalidParametersAreProvided()
+    {
+        var randomizer = new ComplexRandomizer<Person>();
+        Assert.Throws<ArgumentNullException>(() => randomizer.Randomize(null!));
+        Assert.Throws<ArgumentNullException>(() => randomizer.Randomize(null!, new StringRandomizer()));
+        Assert.Throws<ArgumentNullException>(() => randomizer.Randomize<string>(x => x.Name, randomizer: null!));
+        Assert.Throws<ArgumentNullException>(() => randomizer.Randomize(null!, _ => new StringRandomizer()));
+        Assert.Throws<ArgumentNullException>(() => randomizer.Randomize<string>(x => x.Name, getRandomizer: null!));
+    }
+
+    [Fact]
+    public void RandomizationRulesShouldBeAddedSuccessfully()
+    {
+        var randomizer = new ComplexRandomizer<Person>();
+        randomizer.Randomize(x => x.Id, new GuidRandomizer());
+        randomizer.Randomize(x => x.Name, _ => new StringRandomizer());
+        randomizer.Randomize(new RandomizationRule<Person, int>(x => x.Age, new NumberRandomizer(min: 10, max: 50)));
+
+        var person = randomizer.PrepareRandomValue();
+        Assert.NotEqual(Guid.Empty, person.Id);
+        Assert.False(string.IsNullOrWhiteSpace(person.Name));
+        Assert.NotEqual(0, person.Age);
+    }
+
+    [Fact]
+    public void RandomizationRulesShouldBeOverriddenSuccessfully()
+    {
+        var randomizer = new ComplexRandomizer<Person>();
+        randomizer.Randomize(x => x.Age, new NumberRandomizer(min: 10, max: 20));
+        randomizer.Randomize(x => x.Age, new NumberRandomizer(min: 100, max: 200));
+
+        var person = randomizer.PrepareRandomValue();
+        Assert.True(100 <= person.Age && person.Age < 200);
+    }
+}