some more tests for SpecificationBase

Author: Shamar

Code/Epic.Prelude/Specifications/SpecificationBase.cs

@@ -130,7 +130,7 @@ public bool IsSatisfiedBy (TCandidate candidate)
         public ISpecification<TCandidate> And (ISpecification<TCandidate> other)
         {
             ThrowIfNull(other);
-            if (other is Any<TCandidate> || this.Equals(other))
+            if (other is No<TCandidate> || this.Equals(other))
                 return other;
             if (other is Any<TCandidate>)
                 return this;

Code/Epic.Prelude/VisitableBase.cs

@@ -85,7 +85,7 @@ protected TResult AcceptMe<TResult, TVisitable>(TVisitable visitable, IVisitor<T
                 // this would be a bug.
                 throw new ArgumentOutOfRangeException("visitable", "You must provide the current instance.");
             }
-            if(!typeof(TVisitable).Equals(this.GetType()))
+            if(!typeof(TVisitable).IsInterface && !typeof(TVisitable).Equals(this.GetType()))
             {
                 string message = string.Format("VisitableBase.AcceptMe() must be called only from leafs of the hierarchy tree.");
                 throw new InvalidOperationException(message);

Code/UnitTests/Epic.Prelude.UnitTests/Fakes/SampleSpecification.cs

@@ -37,12 +37,19 @@ public class SampleSpecification<TCandidate> : Specifications.SpecificationBase<
         where TCandidate : class
     {
         public int EqualsACalled;
+        public int IsSatisfiedByACalled;
+        private readonly Func<TCandidate, bool> _satifactionRule;
         private readonly Func<ISampleSpecification<TCandidate>, ISampleSpecification<TCandidate>, bool> _equalityComparison;
         public SampleSpecification (Func<ISampleSpecification<TCandidate>, ISampleSpecification<TCandidate>, bool> equalityComparison)
         {
             _equalityComparison = equalityComparison;
         }
 
+        public SampleSpecification(Func<TCandidate, bool> satifactionRule)
+        {
+            _satifactionRule = satifactionRule;
+        }
+
         public SampleSpecification ()
         {
         }
@@ -56,7 +63,8 @@ protected override bool EqualsA (ISampleSpecification<TCandidate> otherSpecifica
 
         protected override bool IsSatisfiedByA (TCandidate candidate)
         {
-            throw new System.NotImplementedException ();
+            IsSatisfiedByACalled++;
+            return _satifactionRule(candidate);
         }
         #endregion
     }

Code/UnitTests/Epic.Prelude.UnitTests/Specifications/SpecificationBaseQA.cs

@@ -23,6 +23,8 @@
 //
 using NUnit.Framework;
 using System;
+using Rhino.Mocks;
+using Epic.Math;
 
 namespace Epic.Specifications
 {
@@ -31,7 +33,7 @@ interface DummySpec<T> : ISpecification<T>, IEquatable<DummySpec<T>>
     {
     }
     [TestFixture()]
-    public class SpecificationBaseQA
+    public class SpecificationBaseQA : RhinoMocksFixtureBase
     {
         [Test]
         public void Initialize_aSpecificationTooAbstract_throwsTypeInitializationException()
@@ -88,6 +90,7 @@ public void Equals_toItself_isTrue()
             Assert.IsTrue (toTest.Equals(toTest as Object));
             Assert.IsTrue (toTest.Equals(toTest as Fakes.ISampleSpecification<string>));
             Assert.IsTrue (toTest.Equals(toTest as ISpecification<string>));
+            Assert.AreEqual(typeof(Fakes.ISampleSpecification<string>).GetHashCode(), toTest.GetHashCode());
         }
 
         [Test]
@@ -120,6 +123,69 @@ public void Equals_toAnotherSpecificationOfTheSameType_callEqualsA()
             Assert.AreEqual(3, toTest.EqualsACalled); 
             Assert.AreEqual(3, other.EqualsACalled);
         }
+
+        [Test]
+        public void Accept_withValidArguments_delegateVisitToTheRightVisitor()
+        {
+            // arrange:
+            Fakes.ISampleSpecification<string> toTest = new Fakes.SampleSpecification<string>();
+            object expectedResult = new object();
+            IVisitContext context = GenerateStrictMock<IVisitContext>();
+            IVisitor<object, Fakes.ISampleSpecification<string>> specificationVisitor = GenerateStrictMock<IVisitor<object, Fakes.ISampleSpecification<string>>>();
+            specificationVisitor.Expect(v => v.Visit(toTest, context)).Return(expectedResult).Repeat.Once();
+            IVisitor<object> visitor = GenerateStrictMock<IVisitor<object>>();
+            visitor.Expect(v => v.GetVisitor(toTest)).Return(specificationVisitor).Repeat.Once ();
+
+            // act:
+            object result = toTest.Accept(visitor, context);
+
+            // assert:
+            Assert.AreSame(expectedResult, result);
+        }
+
+        [Test]
+        public void IsSatisfiedBy_null_isFalse()
+        {
+            // arrange:
+            Fakes.SampleSpecification<string> toTest = new Fakes.SampleSpecification<string>();
+
+            // act:
+            bool result = toTest.IsSatisfiedBy(null);
+
+            // assert:
+            Assert.IsFalse(result);
+            Assert.AreEqual(0, toTest.IsSatisfiedByACalled);
+        }
+
+        [Test]
+        public void IsSatifiedBy_aCandidate_callIsSatisfiedByA()
+        {
+            // arrange:
+            string candidate = "test";
+            Fakes.SampleSpecification<string> toTest1 = new Fakes.SampleSpecification<string>(s => true);
+            Fakes.SampleSpecification<string> toTest2 = new Fakes.SampleSpecification<string>(s => false);
+
+            // assert:
+            Assert.IsTrue(toTest1.IsSatisfiedBy(candidate));
+            Assert.AreEqual(1, toTest1.IsSatisfiedByACalled);
+            Assert.IsFalse(toTest2.IsSatisfiedBy(candidate));
+            Assert.AreEqual(1, toTest2.IsSatisfiedByACalled);
+        }
+
+        [Test]
+        public void ApplyTo_aCandidate_callIsSatisfiedByA()
+        {
+            // arrange:
+            string candidate = "test";
+            Fakes.SampleSpecification<string> toTest1 = new Fakes.SampleSpecification<string>(s => true);
+            Fakes.SampleSpecification<string> toTest2 = new Fakes.SampleSpecification<string>(s => false);
+
+            // assert:
+            Assert.IsTrue((toTest1 as IMapping<string, bool>).ApplyTo(candidate));
+            Assert.AreEqual(1, toTest1.IsSatisfiedByACalled);
+            Assert.IsFalse((toTest2 as IMapping<string, bool>).ApplyTo(candidate));
+            Assert.AreEqual(1, toTest2.IsSatisfiedByACalled);
+        }
     }
 }