Add convenience and lazy message require functions

Author: andrej-dyck

.github/workflows/build.yml

@@ -24,4 +24,6 @@ jobs:
     - name: Build
       run: dotnet build --no-restore
     - name: Test
-      run: dotnet test --no-build --verbosity normal
+      run: dotnet test --no-build --verbosity normal --collect:"XPlat Code Coverage"
+    - name: Codecov
+      uses: codecov/codecov-action@v2

DotNet.Extensions.Require.Test/PreconditionsTests.cs

@@ -1,25 +1,116 @@
 using NUnit.Framework;
+using NUnit.Framework.Internal;
 
 namespace DotNet.Extensions.Require.Test;
 
-public sealed class PreconditionsTests
+public abstract class PreconditionsTests
 {
+    protected abstract T Require<T>(T subject, bool condition, string expectation = "");
+
     [Test]
     public void Require_ThrowsArgumentException_WhenConditionIsFalse() =>
         Assert.Throws<ArgumentException>(
-            () => 1.Require(condition: false, "message")
+            () => Require(subject: 1, condition: false, "message")
         )?.WithMessage("message");
 
     [Test]
     public void Require_DoesNotThrow_WhenConditionIsTrue() =>
         Assert.DoesNotThrow(
-            () => 1.Require(condition: true, string.Empty)
+            () => Require(subject: 1, condition: true)
         );
 
     [Test]
     public void Require_Returns_TheValueOnWhichItIsCalled_WhenConditionIsTrue() =>
         Assert.AreEqual(
             expected: 1,
-            actual: 1.Require(condition: true, string.Empty)
+            actual: Require(subject: 1, condition: true)
+        );
+}
+
+[TestFixture]
+public sealed class BasicRequire : PreconditionsTests
+{
+    protected override T Require<T>(T subject, bool condition, string expectation = "") =>
+        subject.Require(condition, expectation);
+}
+
+public sealed class RequireWithLazyMessage : PreconditionsTests
+{
+    protected override T Require<T>(T subject, bool condition, string expectation = "") =>
+        subject.Require(condition, expectation: () => expectation);
+
+    [Test]
+    public void Require_DoesNotCreateExpectationMessage_WhenConditionIsTrue() =>
+        Assert.DoesNotThrow(
+            () => 1.Require(condition: true, () => throw new NUnitException("must not be called"))
+        );
+}
+
+public sealed class RequireWithLazilyConstructedMessage : PreconditionsTests
+{
+    protected override T Require<T>(T subject, bool condition, string expectation = "") =>
+        subject.Require(condition, expectation: _ => expectation);
+
+    [Test]
+    public void Require_CanUseTheValue_ToConstructTheExpectation() =>
+        Assert.Throws<ArgumentException>(
+            () => 1.Require(condition: false, value => $"message with {value}")
+        )?.WithMessage("message with 1");
+
+    [Test]
+    public void Require_DoesNotBuildExpectationMessage_WhenConditionIsTrue() =>
+        Assert.DoesNotThrow(
+            () => 1.Require(condition: true, value => throw new NUnitException($"must not be called for {value}"))
+        );
+}
+
+public abstract class RequireWithPredicate : PreconditionsTests
+{
+    protected abstract T Require<T>(T subject, Predicate<T> requirement, string expectation = "");
+
+    protected override T Require<T>(T subject, bool condition, string expectation = "") =>
+        Require(subject, requirement: _ => condition, expectation);
+
+    [Test]
+    public void RequirePredicate_WillBeGivenTheValue() =>
+        Assert.DoesNotThrow(
+            () => 1.Require(requirement: value => value == 1, string.Empty)
+        );
+}
+
+[TestFixture]
+public sealed class RequireWithPredicateAndConstantMessage : RequireWithPredicate
+{
+    protected override T Require<T>(T subject, Predicate<T> requirement, string expectation = "") =>
+        subject.Require(requirement, expectation);
+}
+
+public sealed class RequireWithPredicateAndLazyMessage : RequireWithPredicate
+{
+    protected override T Require<T>(T subject, Predicate<T> requirement, string expectation = "") =>
+        subject.Require(requirement, expectation: () => expectation);
+
+    [Test]
+    public void Require_DoesNotCreateExpectationMessage_WhenRequirementYieldsTrue() =>
+        Assert.DoesNotThrow(
+            () => 1.Require(requirement: _ => true, () => throw new NUnitException("must not be called"))
+        );
+}
+
+public sealed class RequireWithPredicateAndLazilyConstructedMessage : RequireWithPredicate
+{
+    protected override T Require<T>(T subject, Predicate<T> requirement, string expectation = "") =>
+        subject.Require(requirement, expectation: _ => expectation);
+
+    [Test]
+    public void Require_CanUseTheValue_ToConstructTheExpectation() =>
+        Assert.Throws<ArgumentException>(
+            () => 1.Require(requirement: _ => false, value => $"message with {value}")
+        )?.WithMessage("message with 1");
+
+    [Test]
+    public void Require_DoesNotBuildExpectationMessage_WhenConditionIsTrue() =>
+        Assert.DoesNotThrow(
+            () => 1.Require(requirement: _ => true, value => throw new NUnitException($"must not be called for {value}"))
         );
 }

DotNet.Extensions.Require/DotNet.Extensions.Require.csproj

@@ -5,7 +5,7 @@
         <Description>☑ Require Expressions - A precondition checks library for .Net 📦 via extensions methods on types.</Description>
         <PackageTags>preconditions;require;guard;code-contracts;argument-checks;extension-methods</PackageTags>
 
-        <Version>1.0.1-alpha</Version>
+        <Version>1.0.0</Version>
         <Authors>Andrej Dyck</Authors>
 
         <PackageReadmeFile>README.md</PackageReadmeFile>

DotNet.Extensions.Require/Preconditions.cs

@@ -4,4 +4,19 @@ public static class Preconditions
 {
     public static T Require<T>(this T @this, bool condition, string expectation) =>
         condition ? @this : throw new ArgumentException(expectation);
+
+    public static T Require<T>(this T @this, bool condition, Func<string> expectation) =>
+        condition ? @this : throw new ArgumentException(expectation());
+
+    public static T Require<T>(this T @this, bool condition, Func<T, string> expectation) =>
+        condition ? @this : throw new ArgumentException(expectation(@this));
+
+    public static T Require<T>(this T @this, Predicate<T> requirement, string expectation) =>
+        requirement(@this) ? @this : throw new ArgumentException(expectation);
+
+    public static T Require<T>(this T @this, Predicate<T> requirement, Func<string> expectation) =>
+        requirement(@this) ? @this : throw new ArgumentException(expectation());
+
+    public static T Require<T>(this T @this, Predicate<T> requirement, Func<T, string> expectation) =>
+        requirement(@this) ? @this : throw new ArgumentException(expectation(@this));
 }

README.md

@@ -1,17 +1,18 @@
 # Require Expressions for .Net
 
 ![build](https://github.com/andrej-dyck/template-gradle-kotlin/actions/workflows/gradle-ci.yml/badge.svg?branch=main)
+[![codecov](https://codecov.io/gh/andrej-dyck/dotnet-extensions-require/branch/main/graph/badge.svg?token=9IL6K5CX37)](https://codecov.io/gh/andrej-dyck/dotnet-extensions-require)
 [![NuGet](https://badgen.net/nuget/v/Require-Expressions)](https://www.nuget.org/packages/Require-Expressions/)
 
 A small library that provides _pre-condition_ checks as an extension method on types. 
 This allows the client code to check a condition on arguments and use the value directly if no exception is thrown.
 
 ```csharp
 Reservation Request(DateTime now, DateTime reservationDate, int seats) => 
-  new Reservation(
-    reservationDate.Require(d => d > now, d => $"Reservation date {d} must be in the future"),
-    seats.Require(seats > 0, () => "Expected positive number of seats")
-  );
+    new Reservation(
+        reservationDate.Require(d => d > now, d => $"Reservation date {d} must be in the future"),
+        seats.Require(seats > 0, () => "Expected positive number of seats")
+    );
 ```
 
 ## NuGet Package
@@ -22,14 +23,40 @@ dotnet add package Require-Expressions
 
 ## Examples
 
-**Basic `Require` Function**
+**Basic `Require` function**
 ```csharp
 var requestedSeats = seats.Require(
     condition: seats > 0,
     expectation: "expected: seats > 0"
 );
 ```
 
+**`Require` functions with lazily constructed expectation messages**
+```csharp
+var requestedSeats = seats.Require(
+    condition: seats > 0,
+    expectation: () => "expected: seats > 0"
+);
+
+var requestedDate = reservationDate.Require(
+    condition: reservationDate > now,
+    expectation: d => $"Reservation date {d} must be in the future"
+);
+```
+
+**`Require` functions with predicate for convenience**
+```csharp
+var requestedSeats = seats.Require(
+    condition: s => s > 0,
+    expectation: "expected: seats > 0"
+);
+
+var requestedDate = reservationDate.Require(
+    requirement: d => d > now,
+    expectation: d => $"Reservation date {d} must be in the future"
+);
+```
+
 ## Q&A
 
 **Why yet another preconditions library?**