Added rhino test extensions

dnewman · dnewman · commit c68b0bc3373f · 2010-02-02T13:48:46.000+11:00
diff --git a/lib/Rhino-3.6/Rhino.Mocks.dll b/lib/Rhino-3.6/Rhino.Mocks.dll
diff --git a/lib/Rhino-3.6/Rhino.Mocks.xml b/lib/Rhino-3.6/Rhino.Mocks.xml
diff --git a/lib/Rhino-3.6/acknowledgements.txt b/lib/Rhino-3.6/acknowledgements.txt
@@ -0,0 +1,2 @@
+Rhino Mocks is using Castle Dynamic Proxy (http://www.castleproject.org/dynamicproxy/index.html) to handle proxying the types it needs to mock.
+The Dynamic Proxy project has been invaluable resource and made creating Rhino Mocks possible.
diff --git a/lib/Rhino-3.6/license.txt b/lib/Rhino-3.6/license.txt
@@ -0,0 +1,25 @@
+Copyright (c) 2005 - 2009 Ayende Rahien (ayende@ayende.com)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+    * Neither the name of Ayende Rahien nor the names of its
+    contributors may be used to endorse or promote products derived from this
+    software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/Shouldly/Create.cs b/src/Shouldly/Create.cs
@@ -0,0 +1,22 @@
+﻿using Rhino.Mocks;
+
+namespace Shouldly
+{
+    public static class Create
+    {
+        public static T Mock<T>() where T : class
+        {
+            return MockRepository.GenerateMock<T>();
+        }
+
+        public static T Stub<T>() where T : class
+        {
+            return MockRepository.GenerateStub<T>();
+        }
+
+        public static T Partial<T>(params object[] constructorArgs) where T : class
+        {
+            return new MockRepository().PartialMock<T>(constructorArgs);
+        }
+    }
+}
diff --git a/src/Shouldly/ObjectHelpers.cs b/src/Shouldly/ObjectHelpers.cs
@@ -0,0 +1,10 @@
+﻿namespace Shouldly
+{
+    public static class ObjectHelpers
+    {
+        public static T As<T>(this object o)
+        {
+            return (T)o;
+        }
+    }
+}
diff --git a/src/Shouldly/ShouldBeStringTestExtensions.cs b/src/Shouldly/ShouldBeStringTestExtensions.cs
@@ -1,5 +1,9 @@
-﻿using System.Diagnostics;
+﻿using System;
+using System.Diagnostics;
+using System.IO;
+using System.Text.RegularExpressions;
 using NUnit.Framework;
+using Shouldly;
 
 namespace Shouldly
 {
@@ -9,12 +13,38 @@ public static class ShouldBeStringTestExtensions
     {
         public static void ShouldBeCloseTo(this string actual, object expected)
         {
-            actual.Quotify()
-                  .StripWhitespace()
-                  .AssertAwesomely(Is.EqualTo(
-                    (expected ?? "NULL").ToString()
-                            .Quotify()
-                            .StripWhitespace()), actual, expected);
+//            const string pattern = @"\s+";
+//            var testActual = Regex.Split(actual, pattern);
+//            var testExpected = Regex.Split((expected ?? "NULL").ToString(), pattern);
+//
+//            var actualIndex = 0;
+//            var expectedIndex = 0; //new StringReader((expected ?? "NULL").ToString());
+//
+//            var actualBuffer = actual;
+//            var expectedBuffer = (expected ?? "NULL").ToString();
+//
+//            var stringsAreMatching = true;
+//            while (stringsAreMatching)
+//            {
+//                var actualNextBreak = Regex.Match(actualBuffer, pattern).Index;
+//                var expectedNextBreak = Regex.Match(expectedBuffer, pattern).Index;
+//                if (actualNextBreak > -1 && expectedNextBreak > -1)
+//                {
+//                    actualIndex += actualNextBreak;
+//                    expectedIndex += expectedNextBreak;
+//
+//                    var actualTest = actualBuffer.Substring(0, actualNextBreak);
+//                    var expectedTest = expectedBuffer.Substring(0, expectedNextBreak);
+//                    stringsAreMatching = actualTest.Equals(expectedTest, StringComparison.CurrentCultureIgnoreCase);
+//
+//                    actualBuffer = actualBuffer.Substring(actualNextBreak);
+//                    expectedBuffer = expectedBuffer.Substring(actualNextBreak);
+//                }
+//            }
+            var strippedActual = actual.Quotify().StripWhitespace();
+            var strippedExpected = (expected ?? "NULL").ToString().Quotify().StripWhitespace();
+
+            strippedActual.AssertAwesomely(Is.EqualTo(strippedExpected), actual, expected);
         }
 
         public static void ShouldContain(this string actual, string expected)
@@ -26,10 +56,5 @@ public static void ShouldNotContain(this string actual, string expected)
         {
             actual.AssertAwesomely(Is.Not.StringContaining(expected).IgnoreCase, actual, expected);
         }
-
-        public static void ShouldBeGreaterThan(this int actual, int expected)
-        {
-            actual.AssertAwesomely(Is.GreaterThan(expected), actual, expected);
-        }
     }
 }
diff --git a/src/Shouldly/ShouldBeTestExtensions.cs b/src/Shouldly/ShouldBeTestExtensions.cs
@@ -26,5 +26,15 @@ public static void ShouldBe(this double actual, double expected, double toleranc
         {
             actual.AssertAwesomely(Is.EqualTo(expected).Within(tolerance), actual, expected);
         }
+
+        public static void ShouldBeGreaterThan(this object actual, object expected)
+        {
+            actual.AssertAwesomely(Is.GreaterThan(expected), actual, expected);
+        }
+
+        public static void ShouldBeLessThan(this object actual, object expected)
+        {
+            actual.AssertAwesomely(Is.LessThan(expected), actual, expected);
+        }
     }
 }
diff --git a/src/Shouldly/ShouldThrowTestExtensions.cs b/src/Shouldly/ShouldThrowTestExtensions.cs
@@ -5,7 +5,6 @@
 namespace Shouldly
 {
     [DebuggerStepThrough]
-    [ShouldlyMethods]
     public static class Should
     {
         public static string Throw<EXCEPTION>(Action actual) where EXCEPTION : Exception
@@ -20,6 +19,5 @@ public static string Throw<EXCEPTION>(Action actual) where EXCEPTION : Exception
             }
             throw new AssertionException(new ShouldlyMessage(actual).ToString());
         }
-
     }
 }
diff --git a/src/Shouldly/Shouldly.csproj b/src/Shouldly/Shouldly.csproj
@@ -34,6 +34,10 @@
     <Reference Include="nunit.framework">
       <HintPath>..\..\lib\NUnit-2.5.3.9345\nunit.framework.dll</HintPath>
     </Reference>
+    <Reference Include="Rhino.Mocks, Version=3.6.0.0, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\Rhino-3.6\Rhino.Mocks.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
@@ -51,13 +55,16 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Create.cs" />
+    <Compile Include="ObjectHelpers.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ShouldBeEnumerableTestExtensions.cs" />
     <Compile Include="ShouldBeStringTestExtensions.cs" />
     <Compile Include="ShouldBeTestExtensions.cs" />
     <Compile Include="ShouldlyCoreExtensions.cs" />
     <Compile Include="ShouldlyMessage.cs" />
     <Compile Include="ShouldlyMethodsAttribute.cs" />
+    <Compile Include="ShouldlyRhinoExtensions.cs" />
     <Compile Include="ShouldThrowTestExtensions.cs" />
     <Compile Include="StringHelpers.cs" />
   </ItemGroup>
diff --git a/src/Shouldly/ShouldlyRhinoExtensions.cs b/src/Shouldly/ShouldlyRhinoExtensions.cs
@@ -0,0 +1,44 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Linq.Expressions;
+using NUnit.Framework;
+using Rhino.Mocks;
+using Rhino.Mocks.Exceptions;
+
+namespace Shouldly
+{
+    public static class ShouldlyRhinoExtensions
+    {
+        public static void ShouldHaveBeenCalled<T>(this T mock, Expression<Action<T>> action)
+        {
+            try
+            {
+                mock.AssertWasCalled(action.Compile());
+            }
+            catch (ExpectationViolationException)
+            {
+                var methodCalls = mock.GetArgumentsForCallsMadeOn(action.Compile());
+
+                var body = action.Body.As<MethodCallExpression>();
+
+                var expectedCall = MethodCall(body.Method.Name, body.Arguments.Cast<object>());
+                var recordedCalls = methodCalls.Select(args => MethodCall(body.Method.Name, args));
+
+                throw new AssertionException(string.Format(
+@"*Expecting*
+    {0}
+*Recorded*
+{1}", expectedCall, recordedCalls.Select((c, i) => string.Format(@"{0: 0}: {1}", i, c)).DelimitWith("\n")));
+            }
+        }
+
+        private static string MethodCall(string name, IEnumerable<object> arguments)
+        {
+            return string.Format("{0}({1})", 
+                                 name, 
+                                 arguments.Select(a => a.Inspect()).CommaDelimited());
+        }
+   }
+}
diff --git a/src/Shouldly/StringHelpers.cs b/src/Shouldly/StringHelpers.cs
@@ -1,4 +1,5 @@
-﻿using System.Collections;
+﻿using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -17,6 +18,11 @@ public static string DelimitWith<T>(this IEnumerable<T> enumerable, string separ
             return string.Join(separator, enumerable.Select(i => Equals(i, default(T)) ? null : i.ToString()).ToArray());
         }
 
+        public static string Inspect(this Enum value)
+        {
+            return value.GetType().Name +"."+ value;
+        }
+
         public static string Inspect(this object value)
         {
             if (value is string)
@@ -28,6 +34,9 @@ public static string Inspect(this object value)
                 return "[" + objects.Select(o => o.Inspect()).CommaDelimited() + "]";
             }
 
+            if (value is Enum)
+                return value.As<Enum>().Inspect();
+
             return value == null ? "null" : value.ToString();
         }
 
diff --git a/src/Tests/Should.cs b/src/Tests/Should.cs
@@ -0,0 +1,14 @@
+﻿using System;
+using NUnit.Framework;
+using Shouldly;
+
+namespace Tests
+{
+    public static class Should
+    {
+        public static void Error(Action action, string errorMessage)
+        {
+            Shouldly.Should.Throw<AssertionException>(action).ShouldBeCloseTo(errorMessage);
+        }
+    }
+}
diff --git a/src/Tests/ShouldBeEnumerableTests.cs b/src/Tests/ShouldBeEnumerableTests.cs
@@ -16,7 +16,7 @@ public void ShouldContain_WhenTrue_ShouldNotThrow()
         [Test]
         public void ShouldContain_WhenFalse_ShouldErrorWithMessage()
         {
-            ShouldHaveError(() =>
+            Should.Error(() =>
                 new[] { 1, 2, 3 }.ShouldContain(5),
                 "new[]{1,2,3} should contain 5 but was [1, 2, 3]");
         }
@@ -30,14 +30,9 @@ public void ShouldNotContain_WhenTrue_ShouldNotThrow()
         [Test]
         public void ShouldNotContain_WhenFalse_ShouldErrorWithMessage()
         {
-            ShouldHaveError(() => 
+            Should.Error(() => 
                 new[] { 1, 2, 3 }.ShouldNotContain(2),
                 "new[]{1,2,3} should not contain 2 but was [1, 2, 3]");
         }
-
-        private void ShouldHaveError(Action action, string errorMessage)
-        {
-            Should.Throw<AssertionException>(action).ShouldBeCloseTo(errorMessage);
-        }
     }
 }
diff --git a/src/Tests/ShouldBeStringTests.cs b/src/Tests/ShouldBeStringTests.cs
@@ -0,0 +1,34 @@
+﻿using NUnit.Framework;
+using Shouldly;
+
+namespace Tests
+{
+    [TestFixture]
+    public class ShouldBeStringTests
+    {
+        [Test]
+        public void ShouldBeCloseTo_IsPrettyLoose()
+        {
+            "Fun   with space   and \"quotes\""
+                .ShouldBeCloseTo("Fun with space and 'quotes'");
+        }
+
+        [Test]
+        public void ShouldBeCloseTo_ShowsYouWhereTheStringsDiffer()
+        {
+            var result = "a string".CompareTo("another string");
+
+
+
+            const string testMessage = "muhst eat braiiinnzzzz";
+            Should.Error(() =>
+            testMessage
+                .ShouldBeCloseTo("must eat brains"),
+@"testMessage
+    should be close to
+'must eat brains'
+    but was
+'muhst eat braiiinnzzzz'");
+        }
+    }
+}
diff --git a/src/Tests/ShouldBeTests.cs b/src/Tests/ShouldBeTests.cs
@@ -28,11 +28,10 @@ public void Should_WithNumbers_ShouldAllowTolerance()
         }
 
         [Test]
-        public void ShouldBeCloseTo_WithText_IsPrettyLoose()
+        public void ShouldBe_GreaterThan()
         {
-            "Fun   with space   and \"quotes\""
-                .ShouldBeCloseTo("Fun with space and 'quotes'");
+            7.ShouldBeGreaterThan(1);
+            1.ShouldBeLessThan(7);
         }
-
     }
 }
diff --git a/src/Tests/ShouldlyRhinoTests.cs b/src/Tests/ShouldlyRhinoTests.cs
diff --git a/src/Tests/Tests.csproj b/src/Tests/Tests.csproj

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+Rhino Mocks is using Castle Dynamic Proxy (http://www.castleproject.org/dynamicproxy/index.html) to handle proxying the types it needs to mock.`
	`2`	`+The Dynamic Proxy project has been invaluable resource and made creating Rhino Mocks possible.`
Original file line number	Diff line number	Diff line change
`@@ -26,5 +26,15 @@ public static void ShouldBe(this double actual, double expected, double toleranc`
`26`	`26`	`{`
`27`	`27`	`actual.AssertAwesomely(Is.EqualTo(expected).Within(tolerance), actual, expected);`
`28`	`28`	`}`
	`29`	`+`
	`30`	`+ public static void ShouldBeGreaterThan(this object actual, object expected)`
	`31`	`+ {`
	`32`	`+ actual.AssertAwesomely(Is.GreaterThan(expected), actual, expected);`
	`33`	`+ }`
	`34`	`+`
	`35`	`+ public static void ShouldBeLessThan(this object actual, object expected)`
	`36`	`+ {`
	`37`	`+ actual.AssertAwesomely(Is.LessThan(expected), actual, expected);`
	`38`	`+ }`
`29`	`39`	`}`
`30`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@`
`5`	`5`	`namespace Shouldly`
`6`	`6`	`{`
`7`	`7`	`[DebuggerStepThrough]`
`8`		`- [ShouldlyMethods]`
`9`	`8`	`public static class Should`
`10`	`9`	`{`
`11`	`10`	`public static string Throw<EXCEPTION>(Action actual) where EXCEPTION : Exception`
`@@ -20,6 +19,5 @@ public static string Throw<EXCEPTION>(Action actual) where EXCEPTION : Exception`
`20`	`19`	`}`
`21`	`20`	`throw new AssertionException(new ShouldlyMessage(actual).ToString());`
`22`	`21`	`}`
`23`		`-`
`24`	`22`	`}`
`25`	`23`	`}`