Add CompositeExceptionClassifier

Introduce a composite classifier that delegates to
multiple IDbExceptionClassifier instances, returning
true if any inner classifier matches the error type.

Author: Giorgi

DbExceptionClassifier/Common/CompositeExceptionClassifier.cs

@@ -0,0 +1,13 @@
+using System.Data.Common;
+
+namespace DbExceptionClassifier.Common;
+
+public class CompositeExceptionClassifier(params IDbExceptionClassifier[] classifiers) : IDbExceptionClassifier
+{
+    public bool IsReferenceConstraintError(DbException exception) => classifiers.Any(c => c.IsReferenceConstraintError(exception));
+    public bool IsCannotInsertNullError(DbException exception) => classifiers.Any(c => c.IsCannotInsertNullError(exception));
+    public bool IsNumericOverflowError(DbException exception) => classifiers.Any(c => c.IsNumericOverflowError(exception));
+    public bool IsUniqueConstraintError(DbException exception) => classifiers.Any(c => c.IsUniqueConstraintError(exception));
+    public bool IsMaxLengthExceededError(DbException exception) => classifiers.Any(c => c.IsMaxLengthExceededError(exception));
+    public bool IsDeadlockError(DbException exception) => classifiers.Any(c => c.IsDeadlockError(exception));
+}

EntityFramework.Exceptions/Tests/CompositeExceptionClassifierTests.cs

@@ -0,0 +1,98 @@
+using System.Data.Common;
+using DbExceptionClassifier.Common;
+using Xunit;
+
+namespace EntityFramework.Exceptions.Tests;
+
+public class CompositeExceptionClassifierTests
+{
+    [Fact]
+    public void ReturnsTrueWhenAnyClassifierMatches()
+    {
+        var classifier = new CompositeExceptionClassifier(
+            new StubClassifier(),
+            new StubClassifier(uniqueConstraint: true)
+        );
+
+        Assert.True(classifier.IsUniqueConstraintError(new StubDbException()));
+    }
+
+    [Fact]
+    public void ReturnsFalseWhenNoClassifierMatches()
+    {
+        var classifier = new CompositeExceptionClassifier(
+            new StubClassifier(),
+            new StubClassifier()
+        );
+
+        Assert.False(classifier.IsUniqueConstraintError(new StubDbException()));
+    }
+
+    [Fact]
+    public void ReturnsFalseWhenEmpty()
+    {
+        var classifier = new CompositeExceptionClassifier();
+
+        Assert.False(classifier.IsUniqueConstraintError(new StubDbException()));
+        Assert.False(classifier.IsReferenceConstraintError(new StubDbException()));
+        Assert.False(classifier.IsCannotInsertNullError(new StubDbException()));
+        Assert.False(classifier.IsMaxLengthExceededError(new StubDbException()));
+        Assert.False(classifier.IsNumericOverflowError(new StubDbException()));
+        Assert.False(classifier.IsDeadlockError(new StubDbException()));
+    }
+
+    [Fact]
+    public void DelegatesAllMethodsCorrectly()
+    {
+        var classifier = new CompositeExceptionClassifier(new StubClassifier(
+            uniqueConstraint: true,
+            referenceConstraint: true,
+            cannotInsertNull: true,
+            maxLengthExceeded: true,
+            numericOverflow: true,
+            deadlock: true
+        ));
+
+        var exception = new StubDbException();
+
+        Assert.True(classifier.IsUniqueConstraintError(exception));
+        Assert.True(classifier.IsReferenceConstraintError(exception));
+        Assert.True(classifier.IsCannotInsertNullError(exception));
+        Assert.True(classifier.IsMaxLengthExceededError(exception));
+        Assert.True(classifier.IsNumericOverflowError(exception));
+        Assert.True(classifier.IsDeadlockError(exception));
+    }
+
+    [Fact]
+    public void MatchesCorrectErrorTypeAcrossClassifiers()
+    {
+        var classifier = new CompositeExceptionClassifier(
+            new StubClassifier(uniqueConstraint: true),
+            new StubClassifier(referenceConstraint: true)
+        );
+
+        var exception = new StubDbException();
+
+        Assert.True(classifier.IsUniqueConstraintError(exception));
+        Assert.True(classifier.IsReferenceConstraintError(exception));
+        Assert.False(classifier.IsDeadlockError(exception));
+    }
+
+    private class StubDbException : DbException;
+
+    private class StubClassifier(
+        bool uniqueConstraint = false,
+        bool referenceConstraint = false,
+        bool cannotInsertNull = false,
+        bool maxLengthExceeded = false,
+        bool numericOverflow = false,
+        bool deadlock = false) : IDbExceptionClassifier
+    {
+        public bool IsUniqueConstraintError(DbException exception) => uniqueConstraint;
+        public bool IsReferenceConstraintError(DbException exception) => referenceConstraint;
+        public bool IsCannotInsertNullError(DbException exception) => cannotInsertNull;
+        public bool IsMaxLengthExceededError(DbException exception) => maxLengthExceeded;
+        public bool IsNumericOverflowError(DbException exception) => numericOverflow;
+        public bool IsDeadlockError(DbException exception) => deadlock;
+    }
+}