public void Can_pick_appropriate_MockPlug_based_on_most_specific_headers() { var a = MockPlug.Setup(new XUri("http://mock/foo")).WithHeader("bar", "a"); var b = MockPlug.Setup(new XUri("http://mock/foo")).WithHeader("bar", "a").WithHeader("x", "1").WithHeader("y", "2"); var c = MockPlug.Setup(new XUri("http://mock/foo")).WithHeader("bar", "a").WithHeader("x", "1"); Assert.IsTrue(Plug.New("http://mock/foo/").WithHeader("bar", "a").WithHeader("x", "1").WithHeader("y", "2").Get(new Result <DreamMessage>()).Wait().IsSuccessful); a.Verify(2.Seconds(), Times.Never()); c.Verify(0.Seconds(), Times.Never()); b.Verify(Times.Once()); }
public void Can_pick_appropriate_MockPlug_based_on_header_values_via_callback() { var a = MockPlug.Setup(new XUri("http://mock/foo")).WithHeader("bar", x => x == "a"); var b = MockPlug.Setup(new XUri("http://mock/foo")).WithHeader("bar", x => x == "b"); var c = MockPlug.Setup(new XUri("http://mock/foo")).WithHeader("bar", x => x == "c"); Assert.IsTrue(Plug.New("http://mock/foo/").WithHeader("bar", "b").Get(new Result <DreamMessage>()).Wait().IsSuccessful); a.Verify(2.Seconds(), Times.Never()); c.Verify(0.Seconds(), Times.Never()); b.Verify(Times.Once()); }
public void Can_pick_appropriate_MockPlug_based_on_headers() { var bar = MockPlug.Setup(new XUri("http://mock/foo")).WithHeader("bar", "a"); var eek = MockPlug.Setup(new XUri("http://mock/foo")).WithHeader("eek", "b"); var baz = MockPlug.Setup(new XUri("http://mock/foo")).WithHeader("baz", "c"); Assert.IsTrue(Plug.New("http://mock/foo/").WithHeader("eek", "b").Get(new Result <DreamMessage>()).Wait().IsSuccessful); bar.Verify(2.Seconds(), Times.Never()); baz.Verify(0.Seconds(), Times.Never()); eek.Verify(Times.Once()); }
public void Extraneous_args_are_not_considered_in_matching() { var a = MockPlug.Setup(new XUri("http://mock/foo")).With("bar", "a"); var b = MockPlug.Setup(new XUri("http://mock/foo")).With("bar", "a").With("x", "1"); var c = MockPlug.Setup(new XUri("http://mock/foo")).With("bar", "a").With("x", "2").With("y", "2"); Assert.IsTrue(Plug.New("http://mock/foo/").With("bar", "a").With("x", "1").With("y", "2").Get(new Result <DreamMessage>()).Wait().IsSuccessful); a.Verify(2.Seconds(), Times.Never()); c.Verify(0.Seconds(), Times.Never()); b.Verify(Times.Once()); }
public void Can_pick_appropriate_MockPlug_based_on_subpath() { var a = MockPlug.Setup(new XUri("http://mock/foo")).At("bar"); var b = MockPlug.Setup(new XUri("http://mock/foo")).At("eek"); var c = MockPlug.Setup(new XUri("http://mock/foo")).At("baz"); Assert.IsTrue(Plug.New("http://mock/foo/eek").Get(new Result <DreamMessage>()).Wait().IsSuccessful); a.Verify(2.Seconds(), Times.Never()); c.Verify(0.Seconds(), Times.Never()); b.Verify(Times.Once()); }
public void Specific_verb_gets_picked_over_wildcard2() { var a = MockPlug.Setup(new XUri("http://mock/foo")).Verb("DELETE"); var b = MockPlug.Setup(new XUri("http://mock/foo")).Verb("GET"); var c = MockPlug.Setup(new XUri("http://mock/foo")); Assert.IsTrue(Plug.New("http://mock/foo").Get(new Result <DreamMessage>()).Wait().IsSuccessful); a.Verify(2.Seconds(), Times.Never()); c.Verify(0.Seconds(), Times.Never()); b.Verify(Times.Once()); }
public void Considers_missordered_expectations_as_unmet() { AutoMockPlug autoPlug = MockPlug.Register(new XUri("http://auto/plugx")); autoPlug.Expect("POST", new XUri("http://auto/plugx/a")); autoPlug.Expect("PUT", new XUri("http://auto/plugx/b"), new XDoc("foo")); Async.Fork(() => { Plug.New("http://auto/plugx/b").Put(new XDoc("foo")); Plug.New("http://auto/plugx/a").Post(); }, new Result()); Assert.IsFalse(autoPlug.WaitAndVerify(TimeSpan.FromSeconds(1)), autoPlug.VerificationFailure); Assert.AreEqual(0, autoPlug.MetExpectationCount); }
public void Should_be_able_to_call_same_url_with_different_headers() { AutoMockPlug autoPlug = MockPlug.Register(new XUri("http://auto/plug")); autoPlug.Expect().Verb("GET").Uri(new XUri("http://auto/plug/a")).RequestHeader("Foo", ""); autoPlug.Expect().Verb("GET").Uri(new XUri("http://auto/plug/a")).RequestHeader("Foo", "baz"); Plug p = Plug.New("http://auto/plug/a"); Async.Fork(() => { p.WithHeader("Foo", "").GetAsync().Block(); p.WithHeader("Foo", "baz").GetAsync().Block(); }, new Result()); Assert.IsTrue(autoPlug.WaitAndVerify(TimeSpan.FromSeconds(1)), autoPlug.VerificationFailure); }
public void Returns_callback_gets_response_headers_if_added_after_callback() { var success = new XDoc("yay"); MockPlug.Setup(new XUri("http://mock/foo")) .Returns(invocation => { return(invocation.ResponseHeaders["foo"] != "bar" ? DreamMessage.BadRequest("wrong response header") : DreamMessage.Ok(success)); }) .WithResponseHeader("foo", "bar"); var msg = Plug.New("http://mock/foo/").Get(new Result <DreamMessage>()).Wait(); Assert.IsTrue(msg.IsSuccessful, msg.ToDocument().ToPrettyString()); Assert.AreEqual(success, msg.ToDocument()); }
public void Complains_about_unmet_expectations_after_timeout() { AutoMockPlug autoPlug = MockPlug.Register(new XUri("http://auto/plug")); autoPlug.Expect("POST", new XUri("http://auto/plug/a")); autoPlug.Expect("PUT", new XUri("http://auto/plug/b"), new XDoc("foo")); Assert.IsFalse(autoPlug.WaitAndVerify(TimeSpan.FromSeconds(1)), autoPlug.VerificationFailure); autoPlug.Reset(); autoPlug.Expect("POST", new XUri("http://auto/plug/a")); autoPlug.Expect("PUT", new XUri("http://auto/plug/b"), new XDoc("foo")); Async.Fork(() => Plug.New("http://auto/plug/a").Post(), new Result()); Assert.IsFalse(autoPlug.WaitAndVerify(TimeSpan.FromSeconds(1)), autoPlug.VerificationFailure); Assert.AreEqual(1, autoPlug.MetExpectationCount); }
public void Can_differentiate_multiple_plugs_and_their_call_counts() { var bar = MockPlug.Setup(new XUri("http://mock/foo")).At("bar").ExpectAtLeastOneCall(); var eek = MockPlug.Setup(new XUri("http://mock/foo")).At("eek").With("a", "b").ExpectCalls(Times.Exactly(3)); var baz = MockPlug.Setup(new XUri("http://mock/foo")).At("eek").With("b", "c").ExpectAtLeastOneCall(); Assert.IsTrue(Plug.New("http://mock/foo/bar").Get(new Result <DreamMessage>()).Wait().IsSuccessful); Assert.IsTrue(Plug.New("http://mock/foo/bar").Get(new Result <DreamMessage>()).Wait().IsSuccessful); Assert.IsTrue(Plug.New("http://mock/foo/eek").With("a", "b").Get(new Result <DreamMessage>()).Wait().IsSuccessful); Assert.IsTrue(Plug.New("http://mock/foo/eek").With("a", "b").Get(new Result <DreamMessage>()).Wait().IsSuccessful); Assert.IsTrue(Plug.New("http://mock/foo/eek").With("a", "b").Get(new Result <DreamMessage>()).Wait().IsSuccessful); Assert.IsTrue(Plug.New("http://mock/foo/eek").With("b", "c").Get(new Result <DreamMessage>()).Wait().IsSuccessful); bar.Verify(); baz.Verify(); eek.Verify(); }
public void PostAsync_from_nested_async_workers() { AutoResetEvent resetEvent = new AutoResetEvent(false); MockPlug.Register(new XUri("http://foo/bar"), delegate(Plug p, string v, XUri u, DreamMessage r, Result <DreamMessage> r2) { resetEvent.Set(); r2.Return(DreamMessage.Ok()); }); Plug.New("http://foo/bar").PostAsync(); Assert.IsTrue(resetEvent.WaitOne(1000, false), "no async failed"); Async.Fork(() => Async.Fork(() => Plug.New("http://foo/bar").PostAsync(), new Result()), new Result()); Assert.IsTrue(resetEvent.WaitOne(1000, false), "async failed"); Async.Fork(() => Async.Fork(() => Plug.New("http://foo/bar").PostAsync(), new Result()), new Result()); Assert.IsTrue(resetEvent.WaitOne(1000, false), "nested async failed"); Async.Fork(() => Async.Fork(() => Async.Fork(() => Plug.New("http://foo/bar").PostAsync(), new Result()), new Result()), new Result()); Assert.IsTrue(resetEvent.WaitOne(1000, false), "double async failed"); }
public void Can_mock_a_request_with_a_stream_body() { var tmp = Path.GetTempFileName(); var payload = "blahblah"; File.WriteAllText(tmp, payload); var message = DreamMessage.FromFile(tmp); var uri = new XUri("http://mock/post/stream"); MockPlug.Setup(uri).Verb("POST") .WithMessage(m => m.ToText() == payload) .ExpectAtLeastOneCall(); var response = Plug.New(uri).Post(message, new Result <DreamMessage>()).Wait(); response.AssertSuccess(); MockPlug.VerifyAll(1.Seconds()); }
public void Result_timeout_superceeds_plug_timeout_and_results_in_RequestConnectionTimeout() { MockPlug.Register(new XUri("mock://mock"), (plug, verb, uri, request, response) => { Thread.Sleep(TimeSpan.FromSeconds(10)); response.Return(DreamMessage.Ok()); }); var stopwatch = Stopwatch.StartNew(); var r = Plug.New(MockPlug.DefaultUri) .WithTimeout(TimeSpan.FromSeconds(20)) .InvokeEx(Verb.GET, DreamMessage.Ok(), new Result <DreamMessage>(1.Seconds())).Block(); stopwatch.Stop(); Assert.LessOrEqual(stopwatch.Elapsed.Seconds, 2); Assert.IsFalse(r.HasTimedOut); Assert.IsFalse(r.HasException); Assert.AreEqual(DreamStatus.RequestConnectionTimeout, r.Value.Status); }
public void Collects_excess_expectations() { AutoMockPlug autoPlug = MockPlug.Register(new XUri("http://auto/plug")); autoPlug.Expect("POST"); Async.Fork(() => { Plug.New("http://auto/plug/a").PostAsync().Block(); Plug.New("http://auto/plug/b").PostAsync().Block(); Plug.New("http://auto/plug/c").PostAsync().Block(); Plug.New("http://auto/plug/d").PostAsync().Block(); }, new Result()); Assert.IsFalse(autoPlug.WaitAndVerify(TimeSpan.FromSeconds(15)), autoPlug.VerificationFailure); Assert.IsTrue(autoPlug.HasInterceptsInExcessOfExpectations); Assert.AreEqual(3, autoPlug.ExcessInterceptions.Length); Assert.AreEqual("http://auto/plug/b", autoPlug.ExcessInterceptions[0].Uri.ToString()); Assert.AreEqual("http://auto/plug/c", autoPlug.ExcessInterceptions[1].Uri.ToString()); Assert.AreEqual("http://auto/plug/d", autoPlug.ExcessInterceptions[2].Uri.ToString()); }
public void Register_twice_throws() { XUri uri = new XUri("http://www.mindtouch.com/foo"); MockPlug.Register(uri, delegate(Plug p, string v, XUri u, DreamMessage r, Result <DreamMessage> r2) { r2.Return(DreamMessage.Ok()); }); try { MockPlug.Register(uri, delegate(Plug p, string v, XUri u, DreamMessage r, Result <DreamMessage> r2) { r2.Return(DreamMessage.Ok()); }); } catch (ArgumentException) { return; } catch (Exception e) { Assert.Fail("wrong exception: " + e); } Assert.Fail("no exception`"); }
/// <summary> /// Setup a new <see cref="MockPlug"/> interceptor candidate for a uri and its child paths. /// </summary> /// <remarks> /// This mechanism has not been completed and is only a WIP. /// Must further configure ordered <see cref="IMockInvokeExpectationParameter"/> parameters to make validation possible. /// Note: endPointScore is only set on the first set for a specific baseUri. Subsequent values are ignored. /// </remarks> /// <param name="baseUri">Base Uri to intercept.</param> /// <param name="name">Debug name for setup</param> /// <param name="endPointScore">The score to return to <see cref="IPlugEndpoint.GetScoreWithNormalizedUri"/> for this uri.</param> /// <returns>A new interceptor instance that may intercept the uri, depending on its additional matching parameters.</returns> public static IMockPlug Setup(XUri baseUri, string name, int endPointScore) { List <MockPlug> mocks; var key = baseUri.SchemeHostPortPath; lock (_mocks) { if (!_mocks.TryGetValue(key, out mocks)) { mocks = new List <MockPlug>(); MockInvokeDelegate callback = (plug, verb, uri, request, response) => { _log.DebugFormat("checking setups for match on {0}:{1}", verb, uri); MockPlug bestMatch = null; var matchScore = 0; foreach (var match in mocks) { var score = match.GetMatchScore(verb, uri, request); if (score > matchScore) { bestMatch = match; matchScore = score; } } if (bestMatch == null) { _log.Debug("no match"); response.Return(DreamMessage.Ok(new XDoc("empty"))); } else { _log.DebugFormat("[{0}] matched", bestMatch.Name); response.Return(bestMatch.Invoke(verb, uri, request)); } }; MockEndpoint.Instance.Register(new MockInvokee(baseUri, callback, endPointScore)); MockEndpoint.Instance.AllDeregistered += Instance_AllDeregistered; _mocks.Add(key, mocks); } } var mock = new MockPlug(baseUri, name); mocks.Add(mock); return(mock); }
public void Waits_until_expectations_are_met_after_each_reset() { AutoMockPlug autoPlug = MockPlug.Register(new XUri("http://auto/plug")); autoPlug.Expect("POST", new XUri("http://auto/plug/a")); autoPlug.Expect("PUT", new XUri("http://auto/plug/b"), new XDoc("foo")); Async.Fork(() => { Plug.New("http://auto/plug/a").Post(); Plug.New("http://auto/plug/b").Put(new XDoc("foo")); }, new Result()); Assert.IsTrue(autoPlug.WaitAndVerify(TimeSpan.FromSeconds(2)), autoPlug.VerificationFailure); autoPlug.Reset(); autoPlug.Expect("GET", new XUri("http://auto/plug/c")); autoPlug.Expect("GET", new XUri("http://auto/plug/d")); Async.Fork(() => { Plug.New("http://auto/plug/c").Get(); Plug.New("http://auto/plug/d").Get(); }, new Result()); Assert.IsTrue(autoPlug.WaitAndVerify(TimeSpan.FromSeconds(2)), autoPlug.VerificationFailure); }
public void Deregister_allows_reregister_of_uri() { XUri uri = new XUri("http://www.mindtouch.com/foo"); int firstCalled = 0; MockPlug.Register(uri, delegate(Plug p, string v, XUri u, DreamMessage r, Result <DreamMessage> r2) { firstCalled++; r2.Return(DreamMessage.Ok()); }); Assert.IsTrue(Plug.New(uri).GetAsync().Wait().IsSuccessful); Assert.AreEqual(1, firstCalled); MockPlug.Deregister(uri); int secondCalled = 0; MockPlug.Register(uri, delegate(Plug p, string v, XUri u, DreamMessage r, Result <DreamMessage> r2) { secondCalled++; r2.Return(DreamMessage.Ok()); }); Assert.IsTrue(Plug.New(uri).GetAsync().Wait().IsSuccessful); Assert.AreEqual(1, firstCalled); Assert.AreEqual(1, secondCalled); }
private void SetupService(bool memorizeAliases) { DreamHostInfo host; if (memorizeAliases) { host = _hostAliasMemorize = DreamTestHelper.CreateRandomPortHost(); } else { host = _hostNoAliasMemorize = DreamTestHelper.CreateRandomPortHost(new XDoc("config").Elem("memorize-aliases", false)); } _service = MockService.CreateMockService(host); _calledPaths = new List <string>(); _service.Service.CatchAllCallback = (context, request, result) => { _calledPaths.Add(context.GetSuffixes(UriPathFormat.Original).First()); var call = context.GetParam("call", null); if (!string.IsNullOrEmpty(call)) { Plug.New(call).Get(); } result.Return(DreamMessage.Ok()); }; _external = new XUri("http://external1/").WithPort(_service.AtLocalHost.Uri.Port).At(_service.AtLocalHost.Uri.Segments); //_ext2 = new XUri("http://external2/").WithPort(_service.AtLocalHost.Uri.Port).At(_service.AtLocalHost.Uri.Segments); _externalCalled = 0; MockPlug.Register(_external, (plug, verb, uri, request, response) => { _externalCalled++; response.Return(DreamMessage.Ok()); }, 100); //_ext2called = 0; //MockPlug.Register(_ext2, (plug, verb, uri, request, response) => { // _ext2called++; // response.Return(DreamMessage.Ok()); //}, 100); Plug.New(_external).Get(); //Plug.New(_ext2).Get(); //return _calledPaths; }
public void Result_timeout_is_used_for_message_memorization_and_results_in_ResponseDataTransferTimeout() { var blockingStream = new MockBlockingStream(); MockPlug.Register(new XUri("mock://mock"), (plug, verb, uri, request, response) => { _log.Debug("returning blocking stream"); response.Return(new DreamMessage(DreamStatus.Ok, null, MimeType.TEXT, -1, blockingStream)); }); var stopwatch = Stopwatch.StartNew(); _log.Debug("calling plug"); var r = Plug.New(MockPlug.DefaultUri) .WithTimeout(1.Seconds()) .Get(new Result <DreamMessage>(3.Seconds())).Block(); _log.Debug("plug done"); stopwatch.Stop(); blockingStream.Unblock(); Assert.GreaterOrEqual(stopwatch.Elapsed.Seconds, 3); Assert.LessOrEqual(stopwatch.Elapsed.Seconds, 4); Assert.IsFalse(r.HasTimedOut); Assert.IsFalse(r.HasException); Assert.AreEqual(DreamStatus.ResponseDataTransferTimeout, r.Value.Status); }
public void MockPlug_can_verify_call_via_VerifyAll() { MockPlug.Setup(new XUri("http://mock/foo")).ExpectCalls(Times.AtLeastOnce()); Assert.IsTrue(Plug.New("http://mock/foo").Get(new Result <DreamMessage>()).Wait().IsSuccessful); MockPlug.VerifyAll(); }
public void Teardown() { MockPlug.DeregisterAll(); }
/// <summary> /// Setup a new <see cref="MockPlug"/> interceptor candidate for a uri and its child paths. /// </summary> /// <remarks> /// This mechanism has not been completed and is only a WIP. /// Must further configure ordered <see cref="IMockInvokeExpectationParameter"/> parameters to make validation possible. /// </remarks> /// <param name="baseUri">Base Uri to intercept.</param> /// <param name="name">Debug name for setup</param> /// <returns>A new interceptor instance that may intercept the uri, depending on its additional matching parameters.</returns> public static IMockPlug Setup(XUri baseUri, string name) { List<MockPlug> mocks; var key = baseUri.SchemeHostPortPath; lock(_mocks) { if(!_mocks.TryGetValue(key, out mocks)) { mocks = new List<MockPlug>(); MockEndpoint.Instance.Register(baseUri, (plug, verb, uri, request, response) => { _log.DebugFormat("checking setups for match on {0}:{1}", verb, uri); MockPlug bestMatch = null; var matchScore = 0; foreach(var match in mocks) { var score = match.GetMatchScore(verb, uri, request); if(score > matchScore) { bestMatch = match; matchScore = score; } } if(bestMatch == null) { _log.Debug("no match"); response.Return(DreamMessage.Ok(new XDoc("empty"))); } else { _log.DebugFormat("[{0}] matched", bestMatch.Name); response.Return(bestMatch.Invoke(verb, uri, request)); } }); MockEndpoint.Instance.AllDeregistered += Instance_AllDeregistered; _mocks.Add(key, mocks); } } var mock = new MockPlug(baseUri, name); mocks.Add(mock); return mock; }
public void Can_verify_lack_of_call() { var mock = MockPlug.Setup(new XUri("http://mock/foo")).ExpectCalls(Times.Never()); mock.Verify(TimeSpan.FromSeconds(3)); }
public void MockPlug_without_call_expectation_does_not_throw_on_Verify() { var mock = MockPlug.Setup(new XUri("http://mock/foo")); mock.Verify(TimeSpan.FromSeconds(3)); }
public void Autoplug_without_expectations_wait_for_timeout() { AutoMockPlug autoPlug = MockPlug.Register(new XUri("http://auto/plug")); Assert.IsTrue(autoPlug.WaitAndVerify(TimeSpan.FromSeconds(1)), autoPlug.VerificationFailure); }
public void PerTestCleanup() { MockPlug.DeregisterAll(); }