private static RequestMockResponse ConfigureRequestMockResponse( this RequestExpectation requestExpectation, HttpStatusCode responStatusCode, HttpRequestContentType responseContentType, object responseContent, IDictionary <string, string> responseHeaders, Func <HttpRequestMessage, HttpResponseMessage> responseBuilder) { requestExpectation.Response.ResponseStatusCode = responStatusCode; requestExpectation.Response.ResponseContentType = Helper.ParseResponseContentType(responseContentType); requestExpectation.Response.ResponseContent = responseContent; requestExpectation.Response.ResponseBuilder = responseBuilder; if (responseHeaders == null) { return(requestExpectation.Response); } foreach (var responseHeader in responseHeaders) { requestExpectation.Response.ResponseHeaders.Add(responseHeader.Key, responseHeader.Value); } return(requestExpectation.Response); }
public void HashCodeIgnoringUriCasing() { var comparer = new RequestExpectationEqualityComparer(new HttpClientTestingFactorySettings { IgnoreUriCasing = true }); // Because GetHashCode may result in different values across different platforms or even processes // we can't actually do much validation here beyond asserting general contracts. var expectation = new RequestExpectation(HttpMethod.Get, new Uri("https://www.foo.com")); // Consistency Assert.AreEqual(comparer.GetHashCode(expectation), comparer.GetHashCode(expectation)); // Equivalence var expectationCopy = new RequestExpectation(HttpMethod.Get, new Uri("https://www.foo.com")); Assert.AreEqual(comparer.GetHashCode(expectation), comparer.GetHashCode(expectationCopy)); // Case-insensitivity var expectationCaseDifferent = new RequestExpectation(HttpMethod.Get, new Uri("https://www.FOO.com")); Assert.AreEqual(comparer.GetHashCode(expectation), comparer.GetHashCode(expectationCopy)); // Non-colliding var otherExpectation = new RequestExpectation(HttpMethod.Post, new Uri("https://www.bar.com")); Assert.AreNotEqual(comparer.GetHashCode(expectation), comparer.GetHashCode(otherExpectation)); }
private static RequestExpectation CreateHttpServerExpectation(HttpServerMock serverMock, HttpMethod requestMethod, string requetsUri, string name, uint times, HttpRequestContentType expectedContentType, object expectedRequestContent, IDictionary <string, string> expectedRequestHeaders, Func <HttpRequestMessage, bool> requestValidator) { var expectation = new RequestExpectation(requetsUri) { RequestHttpMethod = requestMethod, ExpectedRequestContent = expectedRequestContent, ExpectedRequestContentType = Helper.ParseRequestContentType(expectedContentType), Repeats = times, RequestValidator = requestValidator, Name = name }; if (expectedRequestHeaders != null) { foreach (var expectedRequestHeader in expectedRequestHeaders) { expectation.ExpectedRequestHeaders.Add(expectedRequestHeader.Key, expectedRequestHeader.Value); } } serverMock.ServerRequestsState.RequestExpectations.Add(expectation); return(expectation); }
/// <summary> /// Validators the specified expectation. /// </summary> /// <param name="expectation">The expectation.</param> /// <param name="requestValidator">The request validator.</param> /// <returns></returns> /// <exception cref="System.ArgumentNullException">expectation</exception> public static RequestExpectation Validator(this RequestExpectation expectation, Func <HttpRequestMessage, bool> requestValidator) { if (expectation == null) { throw new ArgumentNullException("expectation"); } expectation.RequestValidator = requestValidator; return(expectation); }
/// <summary> /// Expecteds the number of calls. /// </summary> /// <param name="expectation">The expectation.</param> /// <param name="repetitions">The repetitions.</param> /// <returns></returns> /// <exception cref="System.ArgumentNullException">expectation</exception> public static RequestExpectation ExpectedNumberOfCalls(this RequestExpectation expectation, uint repetitions) { if (expectation == null) { throw new ArgumentNullException("expectation"); } expectation.Repeats = repetitions; return(expectation); }
public void Constructor_ValidAbsoluteUrl_Ok() { const string AbsoluteUrl = "http://192.168.1.1/users/23/data"; var requestMock = new RequestExpectation(AbsoluteUrl); Assert.IsNull(requestMock.RequestRegex, "The request Regex should be null."); Assert.IsFalse(requestMock.IsRequestUriARegex, "The request URI should not be a Regex."); Assert.IsNotNull(requestMock.RequestUri, "The request uri should not be null."); Assert.AreEqual(AbsoluteUrl, requestMock.RequestUrl, "The request Url is not the expected."); Assert.AreEqual(AbsoluteUrl, requestMock.RequestUri.AbsoluteUri, "The request Url is not the expected."); }
public void Constructor_ValidRegex_Ok() { const string RegexUrl = "^/users/[0-9]{2}/data$"; var requestMock = new RequestExpectation(RegexUrl); Assert.IsNotNull(requestMock.RequestRegex, "The request Regex should not be null."); Assert.IsTrue(requestMock.IsRequestUriARegex, "The request URI should be a Regex."); Assert.IsNull(requestMock.RequestUri, "The request uri should be null."); Assert.AreEqual(RegexUrl, requestMock.RequestUrl, "The request Url is not the expected."); Assert.AreEqual(RegexUrl, requestMock.RequestRegex.ToString(), "The request regex is not the expected."); }
public void Constructor() { // Validation Assert.ThrowsException <ArgumentNullException>(() => new RequestExpectation(null, this.uri)); Assert.ThrowsException <ArgumentNullException>(() => new RequestExpectation(this.method, null)); // Public members var expectation = new RequestExpectation(this.method, this.uri); Assert.AreEqual(this.method, expectation.HttpMethod); Assert.AreEqual(this.uri, expectation.Uri); }
/// <summary> /// Expecteds the content. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="expectation">The expectation.</param> /// <param name="content">The content.</param> /// <param name="contentType">Type of the content.</param> /// <returns></returns> /// <exception cref="System.ArgumentNullException">expectation</exception> public static RequestExpectation ExpectedContent <T>(this RequestExpectation expectation, T content, HttpRequestContentType contentType) where T : class { if (expectation == null) { throw new ArgumentNullException("expectation"); } expectation.ExpectedRequestContent = content; expectation.ExpectedRequestContentType = Helper.ParseRequestContentType(contentType); return(expectation); }
public void EqualsStrictUriCasing() { var comparer = new RequestExpectationEqualityComparer(new HttpClientTestingFactorySettings { IgnoreUriCasing = false }); var expectation = new RequestExpectation(HttpMethod.Get, new Uri("https://www.foo.com/bar")); Assert.IsTrue(comparer.Equals(null, null)); Assert.IsFalse(comparer.Equals(expectation, null)); Assert.IsFalse(comparer.Equals(null, expectation)); Assert.IsTrue(comparer.Equals(expectation, expectation)); Assert.IsTrue(comparer.Equals(expectation, new RequestExpectation(HttpMethod.Get, new Uri("https://www.foo.com/bar")))); Assert.IsFalse(comparer.Equals(expectation, new RequestExpectation(HttpMethod.Get, new Uri("https://www.foo.com/BAR")))); Assert.IsFalse(comparer.Equals(expectation, new RequestExpectation(HttpMethod.Get, new Uri("https://www.bar.com/bar")))); Assert.IsFalse(comparer.Equals(expectation, new RequestExpectation(HttpMethod.Post, new Uri("https://www.foo.com/bar")))); }
/// <summary> /// Add a header to the HTTP request expectation. /// </summary> /// <param name="expectation">The HTTP request expectation.</param> /// <param name="headerName">Name of the header.</param> /// <param name="headerValue">The header value.</param> /// <returns>The HTTP request expectation.</returns> /// <exception cref="System.ArgumentNullException">expectation</exception> public static RequestExpectation ExpectedRequestHeader(this RequestExpectation expectation, string headerName, string headerValue) { if (expectation == null) { throw new ArgumentNullException("expectation"); } if (expectation.ExpectedRequestHeaders.ContainsKey(headerName)) { expectation.ExpectedRequestHeaders[headerName] = headerValue; return(expectation); } expectation.ExpectedRequestHeaders.Add(headerName, headerValue); return(expectation); }
/// <summary> /// Responses the specified expectation. /// </summary> /// <param name="expectation">The expectation.</param> /// <param name="responseBuilder">The response builder.</param> /// <exception cref="System.ArgumentNullException">expectation</exception> public static void Response( this RequestExpectation expectation, Func <HttpRequestMessage, HttpResponseMessage> responseBuilder) { if (expectation == null) { throw new ArgumentNullException("expectation"); } ConfigureRequestMockResponse( expectation, HttpStatusCode.NotImplemented, HttpRequestContentType.None, null, null, responseBuilder); }
/// <summary> /// Responses the specified expectation. /// </summary> /// <param name="expectation">The expectation.</param> /// <param name="responseStatusCode">The response status code.</param> /// <param name="responseHeaders">The response headers.</param> /// <returns></returns> /// <exception cref="System.ArgumentNullException">expectation</exception> public static RequestMockResponse Response( this RequestExpectation expectation, HttpStatusCode responseStatusCode, IDictionary <string, string> responseHeaders = null) { if (expectation == null) { throw new ArgumentNullException("expectation"); } return(ConfigureRequestMockResponse( expectation, responseStatusCode, HttpRequestContentType.None, null, responseHeaders, null)); }
/// <summary> /// Add a collection of headers to the HTTP request expectation. /// </summary> /// <param name="expectation">The HTTP request expectation.</param> /// <param name="headers">The new headers.</param> /// <returns>The HTTP request expectation.</returns> /// <exception cref="System.ArgumentNullException">expectation</exception> public static RequestExpectation ExpectedRequestHeaders(this RequestExpectation expectation, IDictionary <string, string> headers) { if (expectation == null) { throw new ArgumentNullException("expectation"); } if (headers == null) { return(expectation); } foreach (var expectedHeader in headers) { expectation.ExpectedRequestHeader(expectedHeader.Key, expectedHeader.Value); } return(expectation); }
public void HashCodeStrictUriCasing() { var comparer = new RequestExpectationEqualityComparer(new HttpClientTestingFactorySettings { IgnoreUriCasing = false }); // Because GetHashCode may result in different values across different platforms or even processes // we can't actually do much validation here beyond asserting general contracts. var expectation = new RequestExpectation(HttpMethod.Get, new Uri("https://www.foo.com/bar")); // Consistency Assert.AreEqual(comparer.GetHashCode(expectation), comparer.GetHashCode(expectation)); // Equivalence Assert.AreEqual(comparer.GetHashCode(expectation), comparer.GetHashCode(new RequestExpectation(HttpMethod.Get, new Uri("https://www.foo.com/bar")))); // Case-sensitivity Assert.AreNotEqual(comparer.GetHashCode(expectation), comparer.GetHashCode(new RequestExpectation(HttpMethod.Get, new Uri("https://www.foo.com/BAR")))); // Non-colliding Assert.AreNotEqual(comparer.GetHashCode(expectation), comparer.GetHashCode(new RequestExpectation(HttpMethod.Post, new Uri("https://www.baz.com/bar")))); }
/// <summary> /// Expecteds the type of the content. /// </summary> /// <param name="expectation">The expectation.</param> /// <param name="contentType">Type of the content.</param> /// <returns></returns> public static RequestExpectation ExpectedContentType(this RequestExpectation expectation, HttpRequestContentType contentType) { expectation.ExpectedRequestContentType = Helper.ParseRequestContentType(contentType); return(expectation); }
/// <summary> /// Timeds the out. /// </summary> /// <param name="expectation">The expectation.</param> public static void TimedOut(this RequestExpectation expectation) { expectation.IsRequestTimedOut = true; }