From 5396b617985937d9c7718203f0f6ae3277feda49 Mon Sep 17 00:00:00 2001 From: Hibri Marzook Date: Mon, 11 Aug 2025 20:22:10 +0100 Subject: [PATCH 1/2] Remove Rhino mocks and replace with moq --- .../EndpointMatchingRuleTests.cs | 480 ++++++++---------- .../HttpMock.Unit.Tests.csproj | 14 + .../RequestMatcherTests.cs | 60 +++ src/HttpMock.Unit.Tests/packages.config | 4 + 4 files changed, 300 insertions(+), 258 deletions(-) create mode 100644 src/HttpMock.Unit.Tests/RequestMatcherTests.cs diff --git a/src/HttpMock.Unit.Tests/EndpointMatchingRuleTests.cs b/src/HttpMock.Unit.Tests/EndpointMatchingRuleTests.cs index b9e0d1d..34f342a 100644 --- a/src/HttpMock.Unit.Tests/EndpointMatchingRuleTests.cs +++ b/src/HttpMock.Unit.Tests/EndpointMatchingRuleTests.cs @@ -1,298 +1,262 @@ using System.Collections.Generic; using Kayak.Http; +using Moq; using NUnit.Framework; -using Rhino.Mocks; namespace HttpMock.Unit.Tests { - [TestFixture] - public class EndpointMatchingRuleTests - { - [Test] - public void urls_match_it_returns_true( ) { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.QueryParams = new Dictionary(); - - var httpRequestHead = new HttpRequestHead { Uri = "test" }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead)); - } - - [Test] - public void urls_and_methods_the_same_it_returns_true() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "PUT"; - requestHandler.QueryParams = new Dictionary(); - - var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "PUT" }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead)); - } - - [Test] - public void urls_and_methods_differ_it_returns_false() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary(); - var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "PUT" }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead), Is.False); - } - - [Test] - public void urls_differ_and_methods_match_it_returns_false() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "pest"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary(); - var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "GET" }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead), Is.False); - } - - [Test] - public void urls_and_methods_match_queryparams_differ_it_returns_false() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary { { "myParam", "one" } }; - - var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "GET" }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead), Is.False); - } - - [Test] - public void urls_and_methods_match_and_queryparams_exist_it_returns_true() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary { { "myParam", "one" } }; - - var httpRequestHead = new HttpRequestHead { Uri = "test?oauth_consumer_key=test-api&elvis=alive&moonlandings=faked&myParam=one", Method = "GET" }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead)); - } - - [Test] - public void urls_and_methods_match_and_queryparams_does_not_exist_it_returns_false() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary { { "myParam", "one" } }; - - var httpRequestHead = new HttpRequestHead { Uri = "test?oauth_consumer_key=test-api&elvis=alive&moonlandings=faked", Method = "GET" }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead), Is.False); - } - - - [Test] - public void urls_and_methods_match_and_no_query_params_are_set_but_request_has_query_params_returns_true() - { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary (); - - var httpRequestHead = new HttpRequestHead { Uri = "test?oauth_consumer_key=test-api&elvis=alive&moonlandings=faked", Method = "GET" }; - var endpointMatchingRule = new EndpointMatchingRule(); - - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead), Is.True); - } - - [Test] - public void urls_and_methods_and_queryparams_match_it_returns_true() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary{{"myParam", "one"}}; - - var httpRequestHead = new HttpRequestHead { Uri = "test?myParam=one", Method = "GET" }; - - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead)); - } - - [Test] - public void urls_and_methods_match_headers_differ_it_returns_false() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary(); - requestHandler.RequestHeaders = new Dictionary { { "myHeader", "one" } }; - - var httpRequestHead = new HttpRequestHead - { - Uri = "test", - Method = "GET", - Headers = new Dictionary - { - { "myHeader", "two" } - } - }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead), Is.False); - } - - [Test] - public void urls_and_methods_match_and_headers_match_it_returns_true() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary(); - requestHandler.RequestHeaders = new Dictionary { { "myHeader", "one" } }; - - var httpRequestHead = new HttpRequestHead - { - Uri = "test", - Method = "GET", - Headers = new Dictionary - { - { "myHeader", "one" }, - { "anotherHeader", "two" } - } - }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead)); - } - - [Test] - public void urls_and_methods_match_and_header_does_not_exist_it_returns_false() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary(); - requestHandler.RequestHeaders = new Dictionary { { "myHeader", "one" } }; - - var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "GET" }; - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead), Is.False); - } - - [Test] - public void should_do_a_case_insensitive_match_on_query_string_parameter_values() { - - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary { { "myParam", "one" } }; - - var httpRequestHead = new HttpRequestHead { Uri = "test?myParam=OnE", Method = "GET" }; - - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead)); - } - - [Test] - public void should_do_a_case_insensitive_match_on_header_names_and_values() { - - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary(); - requestHandler.RequestHeaders = new Dictionary { { "myHeader", "one" } }; - - var httpRequestHead = new HttpRequestHead - { - Uri = "test", - Method = "GET", - Headers = new Dictionary - { - { "MYheaDER", "OnE" } - } - }; - - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead)); - } - - [Test] - public void should_match_when_the_query_string_has_a_trailing_ampersand() - { - - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "test"; - requestHandler.Method = "GET"; - requestHandler.QueryParams = new Dictionary { { "a", "b" } ,{"c","d"}}; - - var httpRequestHead = new HttpRequestHead { Uri = "test?a=b&c=d&", Method = "GET" }; - - var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead)); - - } + [TestFixture] + public class EndpointMatchingRuleTests + { + private Mock _mockRequestHandler; + + [SetUp] + public void SetUp() + { + _mockRequestHandler = new Mock(); + } + [Test] - public void should_match_urls_containings_regex_reserved_characters() + public void urls_match_it_returns_true() { - var requestHandler = MockRepository.GenerateStub(); - requestHandler.Path = "/test()"; - requestHandler.QueryParams = new Dictionary(); + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); - var httpRequestHead = new HttpRequestHead { Uri = "/test()" }; + var httpRequestHead = new HttpRequestHead { Uri = "test" }; var endpointMatchingRule = new EndpointMatchingRule(); - Assert.That(endpointMatchingRule.IsEndpointMatch(requestHandler, httpRequestHead)); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead)); } - } + [Test] + public void urls_and_methods_the_same_it_returns_true() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("PUT"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); + + var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "PUT" }; + var endpointMatchingRule = new EndpointMatchingRule(); + + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead)); + } + + [Test] + public void urls_and_methods_differ_it_returns_false() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); + + var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "PUT" }; + var endpointMatchingRule = new EndpointMatchingRule(); + + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead), Is.False); + } + + [Test] + public void urls_differ_and_methods_match_it_returns_false() + { + _mockRequestHandler.Setup(m => m.Path).Returns("pest"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); + + var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "GET" }; + var endpointMatchingRule = new EndpointMatchingRule(); + + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead), Is.False); + } + + [Test] + public void urls_and_methods_match_queryparams_differ_it_returns_false() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams) + .Returns(new Dictionary { { "myParam", "one" } }); + + var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "GET" }; + var endpointMatchingRule = new EndpointMatchingRule(); + + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead), Is.False); + } + + [Test] + public void urls_and_methods_match_and_queryparams_exist_it_returns_true() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams) + .Returns(new Dictionary { { "myParam", "one" } }); + + var httpRequestHead = new HttpRequestHead + { Uri = "test?oauth_consumer_key=test-api&elvis=alive&moonlandings=faked&myParam=one", Method = "GET" }; + var endpointMatchingRule = new EndpointMatchingRule(); + + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead)); + } - [TestFixture] - public class RequestMatcherTests - { [Test] - public void Should_match_a_handler() + public void urls_and_methods_match_and_queryparams_does_not_exist_it_returns_false() { - var expectedRequest = MockRepository.GenerateStub(); - expectedRequest.Method = "GET"; - expectedRequest.Path = "/path"; - expectedRequest.QueryParams = new Dictionary(); - expectedRequest.Stub(s => s.CanVerifyConstraintsFor("")).IgnoreArguments().Return(true); + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams) + .Returns(new Dictionary { { "myParam", "one" } }); - var requestMatcher = new RequestMatcher(new EndpointMatchingRule()); + var httpRequestHead = new HttpRequestHead + { Uri = "test?oauth_consumer_key=test-api&elvis=alive&moonlandings=faked", Method = "GET" }; + var endpointMatchingRule = new EndpointMatchingRule(); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead), Is.False); + } - var requestHandlerList = new List{expectedRequest}; + [Test] + public void urls_and_methods_match_and_no_query_params_are_set_but_request_has_query_params_returns_true() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); - var httpRequestHead = new HttpRequestHead{Method = "GET", Path = "/path/", Uri = "/path"}; + var httpRequestHead = new HttpRequestHead + { Uri = "test?oauth_consumer_key=test-api&elvis=alive&moonlandings=faked", Method = "GET" }; + var endpointMatchingRule = new EndpointMatchingRule(); - var matchedRequest = requestMatcher.Match(httpRequestHead, requestHandlerList); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead), Is.True); + } + [Test] + public void urls_and_methods_and_queryparams_match_it_returns_true() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams) + .Returns(new Dictionary { { "myParam", "one" } }); - Assert.That(matchedRequest.Path, Is.EqualTo(expectedRequest.Path)); + var httpRequestHead = new HttpRequestHead { Uri = "test?myParam=one", Method = "GET" }; + + var endpointMatchingRule = new EndpointMatchingRule(); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead)); + } + + [Test] + public void urls_and_methods_match_headers_differ_it_returns_false() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); + _mockRequestHandler.Setup(m => m.RequestHeaders) + .Returns(new Dictionary { { "myHeader", "one" } }); + + var httpRequestHead = new HttpRequestHead + { + Uri = "test", + Method = "GET", + Headers = new Dictionary + { + { "myHeader", "two" } + } + }; + var endpointMatchingRule = new EndpointMatchingRule(); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead), Is.False); } + [Test] + public void urls_and_methods_match_and_headers_match_it_returns_true() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); + _mockRequestHandler.Setup(m => m.RequestHeaders) + .Returns(new Dictionary { { "myHeader", "one" } }); + + var httpRequestHead = new HttpRequestHead + { + Uri = "test", + Method = "GET", + Headers = new Dictionary + { + { "myHeader", "one" }, + { "anotherHeader", "two" } + } + }; + var endpointMatchingRule = new EndpointMatchingRule(); + + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead)); + } [Test] - public void Should_match_a_specific_handler() + public void urls_and_methods_match_and_header_does_not_exist_it_returns_false() { - var expectedRequest = MockRepository.GenerateStub(); - expectedRequest.Method = "GET"; - expectedRequest.Path = "/path/specific"; - expectedRequest.QueryParams = new Dictionary(); - expectedRequest.Stub(s => s.CanVerifyConstraintsFor("")).IgnoreArguments().Return(true); + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); + _mockRequestHandler.Setup(m => m.RequestHeaders) + .Returns(new Dictionary { { "myHeader", "one" } }); + var httpRequestHead = new HttpRequestHead { Uri = "test", Method = "GET" }; + var endpointMatchingRule = new EndpointMatchingRule(); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead), Is.False); + } - var otherRequest = MockRepository.GenerateStub(); - otherRequest.Method = "GET"; - otherRequest.Path = "/path/"; - otherRequest.QueryParams = new Dictionary(); - otherRequest.Stub(s => s.CanVerifyConstraintsFor("")).IgnoreArguments().Return(true); + [Test] + public void should_do_a_case_insensitive_match_on_query_string_parameter_values() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams) + .Returns(new Dictionary { { "myParam", "one" } }); - var requestMatcher = new RequestMatcher(new EndpointMatchingRule()); + var httpRequestHead = new HttpRequestHead { Uri = "test?myParam=OnE", Method = "GET" }; + var endpointMatchingRule = new EndpointMatchingRule(); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead)); + } - var requestHandlerList = new List { otherRequest, expectedRequest }; + [Test] + public void should_do_a_case_insensitive_match_on_header_names_and_values() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); + _mockRequestHandler.Setup(m => m.RequestHeaders) + .Returns(new Dictionary { { "myHeader", "one" } }); + + var httpRequestHead = new HttpRequestHead + { + Uri = "test", + Method = "GET", + Headers = new Dictionary + { + { "MYheaDER", "OnE" } + } + }; + var endpointMatchingRule = new EndpointMatchingRule(); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead)); + } - var httpRequestHead = new HttpRequestHead { Method = "GET", Path = "/path/specific", Uri = "/path/specific" }; + [Test] + public void should_match_when_the_query_string_has_a_trailing_ampersand() + { + _mockRequestHandler.Setup(m => m.Path).Returns("test"); + _mockRequestHandler.Setup(m => m.Method).Returns("GET"); + _mockRequestHandler.Setup(m => m.QueryParams) + .Returns(new Dictionary { { "a", "b" }, { "c", "d" } }); - var matchedRequest = requestMatcher.Match(httpRequestHead, requestHandlerList); + var httpRequestHead = new HttpRequestHead { Uri = "test?a=b&c=d&", Method = "GET" }; + var endpointMatchingRule = new EndpointMatchingRule(); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead)); + } + [Test] + public void should_match_urls_containings_regex_reserved_characters() + { + _mockRequestHandler.Setup(m => m.Path).Returns("/test()"); + _mockRequestHandler.Setup(m => m.QueryParams).Returns(new Dictionary()); - Assert.That(matchedRequest.Path, Is.EqualTo(expectedRequest.Path)); + var httpRequestHead = new HttpRequestHead { Uri = "/test()" }; + var endpointMatchingRule = new EndpointMatchingRule(); + Assert.That(endpointMatchingRule.IsEndpointMatch(_mockRequestHandler.Object, httpRequestHead)); } } } \ No newline at end of file diff --git a/src/HttpMock.Unit.Tests/HttpMock.Unit.Tests.csproj b/src/HttpMock.Unit.Tests/HttpMock.Unit.Tests.csproj index ce232a3..b2af668 100644 --- a/src/HttpMock.Unit.Tests/HttpMock.Unit.Tests.csproj +++ b/src/HttpMock.Unit.Tests/HttpMock.Unit.Tests.csproj @@ -36,15 +36,28 @@ false + + ..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll + ..\..\packages\Kayak.0.7.2\lib\Kayak.dll + + ..\..\packages\Moq.4.20.72\lib\net462\Moq.dll + ..\..\packages\NUnit.3.13.1\lib\net45\nunit.framework.dll True + + + ..\..\packages\System.Runtime.CompilerServices.Unsafe.4.5.3\lib\net461\System.Runtime.CompilerServices.Unsafe.dll + + + ..\..\packages\System.Threading.Tasks.Extensions.4.5.4\lib\net461\System.Threading.Tasks.Extensions.dll + @@ -59,6 +72,7 @@ + diff --git a/src/HttpMock.Unit.Tests/RequestMatcherTests.cs b/src/HttpMock.Unit.Tests/RequestMatcherTests.cs new file mode 100644 index 0000000..800f317 --- /dev/null +++ b/src/HttpMock.Unit.Tests/RequestMatcherTests.cs @@ -0,0 +1,60 @@ +using System.Collections.Generic; +using Kayak.Http; +using Moq; +using NUnit.Framework; + +namespace HttpMock.Unit.Tests +{ + [TestFixture] + public class RequestMatcherTests + { + [Test] + public void Should_match_a_handler() + { + var expectedRequest = new Mock(); + expectedRequest.SetupGet(x => x.Method).Returns("GET"); + expectedRequest.SetupGet(x => x.Path).Returns("/path"); + expectedRequest.SetupGet(x => x.QueryParams).Returns(new Dictionary()); + expectedRequest.Setup(x => x.CanVerifyConstraintsFor(It.IsAny())).Returns(true); + + var requestMatcher = new RequestMatcher(new EndpointMatchingRule()); + var requestHandlerList = new List { expectedRequest.Object }; + + + var httpRequestHead = new HttpRequestHead { Method = "GET", Path = "/path/", Uri = "/path" }; + + var matchedRequest = requestMatcher.Match(httpRequestHead, requestHandlerList); + + + Assert.That(matchedRequest.Path, Is.EqualTo("/path")); + } + + + [Test] + public void Should_match_a_specific_handler() + { + var expectedRequest = new Mock(); + expectedRequest.SetupGet(x => x.Method).Returns("GET"); + expectedRequest.SetupGet(x => x.Path).Returns("/path/specific"); + expectedRequest.SetupGet(x => x.QueryParams).Returns(new Dictionary()); + expectedRequest.Setup(x => x.CanVerifyConstraintsFor(It.IsAny())).Returns(true); + + var otherRequest = new Mock(); + otherRequest.SetupGet(x => x.Method).Returns("GET"); + otherRequest.SetupGet(x => x.Path).Returns("/path/"); + otherRequest.SetupGet(x => x.QueryParams).Returns(new Dictionary()); + otherRequest.Setup(x => x.CanVerifyConstraintsFor(It.IsAny())).Returns(true); + + var requestMatcher = new RequestMatcher(new EndpointMatchingRule()); + var requestHandlerList = new List { otherRequest.Object, expectedRequest.Object }; + + + var httpRequestHead = new HttpRequestHead { Method = "GET", Path = "/path/specific", Uri = "/path/specific" }; + + var matchedRequest = requestMatcher.Match(httpRequestHead, requestHandlerList); + + + Assert.That(matchedRequest.Path, Is.EqualTo("/path/specific")); + } + } +} \ No newline at end of file diff --git a/src/HttpMock.Unit.Tests/packages.config b/src/HttpMock.Unit.Tests/packages.config index 3884e82..5a8dd47 100644 --- a/src/HttpMock.Unit.Tests/packages.config +++ b/src/HttpMock.Unit.Tests/packages.config @@ -1,7 +1,11 @@  + + + + \ No newline at end of file From 209d8109624736f0bc8f2d2a5c8206ff502e74aa Mon Sep 17 00:00:00 2001 From: Hibri Marzook Date: Tue, 12 Aug 2025 11:05:33 +0100 Subject: [PATCH 2/2] Remove last few refs to Rhino --- .../HttpMock.Unit.Tests.csproj | 3 - .../RequestProcessorTests.cs | 70 ++++++++++--------- 2 files changed, 37 insertions(+), 36 deletions(-) diff --git a/src/HttpMock.Unit.Tests/HttpMock.Unit.Tests.csproj b/src/HttpMock.Unit.Tests/HttpMock.Unit.Tests.csproj index b2af668..20263e6 100644 --- a/src/HttpMock.Unit.Tests/HttpMock.Unit.Tests.csproj +++ b/src/HttpMock.Unit.Tests/HttpMock.Unit.Tests.csproj @@ -63,9 +63,6 @@ - - ..\..\packages\RhinoMocks.3.6.1\lib\net\Rhino.Mocks.dll - diff --git a/src/HttpMock.Unit.Tests/RequestProcessorTests.cs b/src/HttpMock.Unit.Tests/RequestProcessorTests.cs index 0fd03f8..15ae241 100644 --- a/src/HttpMock.Unit.Tests/RequestProcessorTests.cs +++ b/src/HttpMock.Unit.Tests/RequestProcessorTests.cs @@ -1,33 +1,36 @@ -using System; -using System.Collections.Generic; +using System.Collections.Generic; +using System.Linq; using Kayak; using Kayak.Http; +using Moq; using NUnit.Framework; -using Rhino.Mocks; namespace HttpMock.Unit.Tests { [TestFixture] public class RequestProcessorTests { private RequestProcessor _processor; - private IDataProducer _dataProducer; - private IHttpResponseDelegate _httpResponseDelegate; - private IMatchingRule _ruleThatReturnsFirstHandler; - private IMatchingRule _ruleThatReturnsNoHandlers; + private Mock _dataProducer; + private Mock _httpResponseDelegate; + private Mock _ruleThatReturnsFirstHandler; + private Mock _ruleThatReturnsNoHandlers; private RequestHandlerFactory _requestHandlerFactory; [SetUp] public void SetUp() { - _processor = new RequestProcessor(_ruleThatReturnsFirstHandler, new RequestHandlerList()); + _dataProducer = new Mock(); + _httpResponseDelegate = new Mock(); + _ruleThatReturnsFirstHandler = new Mock(); + _ruleThatReturnsNoHandlers = new Mock(); + + _processor = new RequestProcessor(_ruleThatReturnsFirstHandler.Object, new RequestHandlerList()); _requestHandlerFactory = new RequestHandlerFactory(_processor); - _dataProducer = MockRepository.GenerateStub(); - _httpResponseDelegate = MockRepository.GenerateStub(); - _ruleThatReturnsFirstHandler = MockRepository.GenerateStub(); - _ruleThatReturnsFirstHandler.Stub(x => x.IsEndpointMatch(null, new HttpRequestHead())).IgnoreArguments().Return(true).Repeat.Once(); + _ruleThatReturnsFirstHandler + .SetupSequence(x => x.IsEndpointMatch(It.IsAny(), It.IsAny())) + .Returns(true) + .Returns(false); - _ruleThatReturnsNoHandlers = MockRepository.GenerateStub(); - _ruleThatReturnsNoHandlers.Stub(x => x.IsEndpointMatch(null, new HttpRequestHead())).IgnoreArguments().Return(false); } [Test] @@ -68,23 +71,23 @@ public void Custom_verb_should_return_handler_with_custom_method_set() { [Test] public void If_no_handlers_found_should_fire_onresponse_with_a_404() { - _processor = new RequestProcessor(_ruleThatReturnsNoHandlers, new RequestHandlerList()); + _processor = new RequestProcessor(_ruleThatReturnsNoHandlers.Object, new RequestHandlerList()); _processor.Add(_requestHandlerFactory.Get("test")); - _processor.OnRequest(new HttpRequestHead(), _dataProducer, _httpResponseDelegate); - _httpResponseDelegate.AssertWasCalled(x => x.OnResponse(Arg.Matches(y => y.Status == "404 NotFound"), Arg.Is.Null)); + _processor.OnRequest(new HttpRequestHead(), _dataProducer.Object, _httpResponseDelegate.Object); + _httpResponseDelegate.Verify(x => x.OnResponse(It.Is(y => y.Status == "404 NotFound"),It.Is( p => p ==null) )); } [Test] public void If_a_handler_found_should_fire_onresponse_with_that_repsonse() { - _processor = new RequestProcessor(_ruleThatReturnsFirstHandler, new RequestHandlerList()); + _processor = new RequestProcessor(_ruleThatReturnsFirstHandler.Object, new RequestHandlerList()); RequestHandler requestHandler = _requestHandlerFactory.Get("test"); _processor.Add(requestHandler); Dictionary headers = new Dictionary(); - _processor.OnRequest(new HttpRequestHead{ Headers = headers}, _dataProducer, _httpResponseDelegate); + _processor.OnRequest(new HttpRequestHead{ Headers = headers}, _dataProducer.Object, _httpResponseDelegate.Object); - _httpResponseDelegate.AssertWasCalled( + _httpResponseDelegate.Verify( x => x.OnResponse(requestHandler.ResponseBuilder.BuildHeaders(), requestHandler.ResponseBuilder.BuildBody(headers))); } @@ -92,14 +95,14 @@ public void If_a_handler_found_should_fire_onresponse_with_that_repsonse() { [Test] public void Matching_HEAD_handler_should_output_handlers_expected_response_with_null_body() { - _processor = new RequestProcessor(_ruleThatReturnsFirstHandler, new RequestHandlerList()); + _processor = new RequestProcessor(_ruleThatReturnsFirstHandler.Object, new RequestHandlerList()); RequestHandler requestHandler = _requestHandlerFactory.Head("test"); _processor.Add(requestHandler); var httpRequestHead = new HttpRequestHead { Method = "HEAD", Headers = new Dictionary() }; - _processor.OnRequest(httpRequestHead, _dataProducer, _httpResponseDelegate); + _processor.OnRequest(httpRequestHead, _dataProducer.Object, _httpResponseDelegate.Object); - _httpResponseDelegate.AssertWasCalled(x => x.OnResponse(requestHandler.ResponseBuilder.BuildHeaders(), null)); + _httpResponseDelegate.Verify(x => x.OnResponse(requestHandler.ResponseBuilder.BuildHeaders(), null)); } [Test] @@ -124,13 +127,13 @@ public void When_a_handler_is_hit_handlers_request_count_is_incremented() { string expectedPath = "/blah/test"; string expectedMethod = "GET"; - var requestProcessor = new RequestProcessor(_ruleThatReturnsFirstHandler, new RequestHandlerList()); + var requestProcessor = new RequestProcessor(_ruleThatReturnsFirstHandler.Object, new RequestHandlerList()); requestProcessor.Add(_requestHandlerFactory.Get(expectedPath)); var httpRequestHead = new HttpRequestHead { Headers = new Dictionary() }; httpRequestHead.Path = expectedPath; httpRequestHead.Method = expectedPath; - requestProcessor.OnRequest(httpRequestHead, _dataProducer, _httpResponseDelegate); + requestProcessor.OnRequest(httpRequestHead, _dataProducer.Object, _httpResponseDelegate.Object); var handler = requestProcessor.FindHandler(expectedMethod, expectedPath); Assert.That(handler.RequestCount(), Is.EqualTo(1)); @@ -144,18 +147,19 @@ public void Returns_mock_not_found_when_handler_constraints_cannot_be_verified() var handlerWithConstraints = new RequestHandler("", null); handlerWithConstraints.WithUrlConstraint(uri => uri.Contains(excludePhrase) == false); - var matchingRule = MockRepository.GenerateMock(); - matchingRule.Stub(m => m.IsEndpointMatch(Arg.Is.Anything, Arg.Is.Anything)).Return(true); + var matchingRule = new Mock(); + matchingRule + .Setup(m => m.IsEndpointMatch(It.IsAny(), It.IsAny())) + .Returns(true); - var p = new RequestProcessor(matchingRule, new RequestHandlerList { handlerWithConstraints }); + var p = new RequestProcessor(matchingRule.Object, new RequestHandlerList { handlerWithConstraints }); - var response = MockRepository.GenerateMock(); - p.OnRequest(new HttpRequestHead{Uri = "http://blah.com/cheese/" + excludePhrase}, null, response); + var response = new Mock(); + p.OnRequest(new HttpRequestHead{Uri = "http://blah.com/cheese/" + excludePhrase}, null, response.Object); - var notFoundResponse = (HttpResponseHead)response.GetArgumentsForCallsMadeOn( - r => r.OnResponse(Arg.Is.Anything, Arg.Is.Anything))[0][0]; + var notFoundResponse = (HttpResponseHead) response.Invocations.First().Arguments.First(); - Assert.That(notFoundResponse.Status == "404 NotFound"); + Assert.That(notFoundResponse.Status, Is.EqualTo( "404 NotFound")); } } }