public void Given_that_request_is_present_When_sending_Then_request_status_code_is_set()
{
var content = "some response content";
var statusCode = 201;
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(statusCode)
.SetStatusDescriptor("OK")
.SetResponse(content)
.Build();
var mockSocket = new Mock <IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny <HttpRequest>()))
.Returns(mockResponse);
var mockRequest = new HttpRequest("");
var target = new HttpClient(mockSocket.Object);
// execution
var result = target.Send(mockRequest);
// assertion
Assert.AreEqual(statusCode, mockRequest.StatusCode, "The request status code is not correct");
}
public void Given_that_http_status_code_2xx_And_http_headers_are_returned_When_sending_Then_response_is_returned()
{
var content = "some response content";
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(200)
.SetStatusDescriptor("OK")
.SetResponse(content)
.AddHeader("Header-one: header stuff")
.AddHeader("Second-header: more header stuff")
.Build();
var mockSocket = new Mock <IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny <HttpRequest>()))
.Returns(mockResponse);
var target = new HttpClient(mockSocket.Object);
// execution
var result = target.Send(new HttpRequest(""));
// assertion
Assert.AreEqual(content, result, "The http reponse was not correct");
}
public void Given_that_request_is_present_and_status_code_indicates_error_When_sending_Then_request_Success_is_set_false()
{
var content = "some response content";
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(404)
.SetStatusDescriptor("OK")
.SetResponse(content)
.Build();
var mockSocket = new Mock <IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny <HttpRequest>()))
.Returns(mockResponse);
var mockRequest = new HttpRequest("");
var target = new HttpClient(mockSocket.Object);
// execution/assertion
TestDelegate method = () => target.Send(mockRequest);
var exception = (HttpRequestException)Assert.Throws(typeof(HttpRequestException), method,
"Correct exception not thrown");
Assert.IsFalse(exception.Request.Success, "The request success property is not correct");
}
public void Given_that_request_is_present_and_status_code_indicates_success_When_sending_Then_request_Success_is_set_true()
{
var content = "some response content";
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(200)
.SetStatusDescriptor("OK")
.SetResponse(content)
.Build();
var mockSocket = new Mock <IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny <HttpRequest>()))
.Returns(mockResponse);
var mockRequest = new HttpRequest("");
var target = new HttpClient(mockSocket.Object);
// execution
var result = target.Send(mockRequest);
// assertion
Assert.IsTrue(mockRequest.Success, "The request success property is not correct");
}
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next)
{
await next.Invoke();
if (context.GetFirst(out HttpResponseMessage httpResponseMessage))
{
var code = (int)httpResponseMessage.StatusCode;
if ((Sanitize500s && Between(code, 500, 599)) ||
(Sanitize400s && Between(code, 400, 499)) ||
(Sanitize300s && Between(code, 300, 399)) ||
SanitizeResponseCodes.Contains(code))
{
if (SaveOriginalContent)
{
var originalResponse = new ResponseSanitizerContent();
originalResponse.Copy(httpResponseMessage);
context.Add(originalResponse);
}
HttpResponseBuilder.HttpResponseMessage(httpResponseMessage)
.WithNoContent()
.WithReasonPhrase(string.Empty)
.If(ReturnErrorReference,
resp => resp.WithStringContent($"{{\"errorReference\":\"{context.Id}\"}}"))
.If(ReplacementResponseCode.HasValue,
resp => resp.WithStatusCode(ReplacementResponseCode.Value));
}
}
}
/**
* Fetch data, retrying in the event that that the service provider returns an error and we think
* we can recover by restarting the protocol flow.
*/
private HttpResponseBuilder fetchWithRetry()
{
int attempts = 0;
bool retry;
HttpResponseBuilder response = null;
do
{
retry = false;
++attempts;
try
{
response = attemptFetch();
}
catch (OAuthProtocolException pe)
{
retry = handleProtocolException(pe, attempts);
if (!retry)
{
if (pe.getProblemCode() != null)
{
throw responseParams.oauthRequestException(pe.getProblemCode(),
"Service provider rejected request", pe);
}
throw responseParams.oauthRequestException(OAuthError.UNKNOWN_PROBLEM,
"Service provider rejected request", pe);
}
}
} while (retry);
return(response);
}
public override void OnAuthorization(HttpActionContext actionContext)
{
if (IsAuthenticated(actionContext))
{
base.OnAuthorization(actionContext);
}
else
{
actionContext.Response = HttpResponseBuilder.CreateUnauthorizedResponse(actionContext.Request);
}
}
/// <summary>
/// Builds an HttpResponse out of the given underlying response
/// </summary>
/// <param name="underlyingResponse">The underlying HttpWebResponse to copy values from</param>
/// <returns>An HttpResponse based on the given underlying response</returns>
private HttpResponseData BuildResponse(HttpWebResponse underlyingResponse)
{
ExceptionUtilities.CheckArgumentNotNull(underlyingResponse, "underlyingResponse");
using (Stream underlyingStream = underlyingResponse.GetResponseStream())
{
return(HttpResponseBuilder.BuildResponse(
underlyingResponse.StatusCode,
underlyingResponse.Headers.AllKeys.ToDictionary(k => k, k => underlyingResponse.Headers[k]),
underlyingStream));
}
}
public HttpResponseMessage GetToken(string username, string password)
{
String userId = String.Empty;
if (IsAuthenticated(username, password, out userId))
{
String token = new AuthenticationHelper().GenerateJwtToken(username, userId);
return(HttpResponseBuilder.CreateOKResponse(Request, token));
}
return(HttpResponseBuilder.CreateUnauthorizedResponse(Request));
}
/**
* Access token data is returned to the gadget as json key/value pairs:
*
* { "user_id": "12345678" }
*/
private HttpResponseBuilder formatAccessTokenData()
{
HttpResponseBuilder builder = new HttpResponseBuilder();
builder.setHeader("Content-Type", "application/json; charset=utf-8");
builder.setHttpStatusCode((int)HttpStatusCode.OK);
// no need to cache this, these requests should be fairly rare, and the results should be
// cached in gadget.
builder.setStrictNoCache();
JsonObject json = new JsonObject(accessTokenData);
builder.setResponseString(json.ToString());
return(builder);
}
public static HttpHandlerBuilder ReturnDocs(this HttpResponseBuilder builder, IEnumerable <object> documents)
{
var docs = documents.ToList();
var response = new
{
hits = new
{
hits = docs.Select(doc => new { _source = doc }).ToList(),
total = docs.Count
}
};
return(builder.Respond(response));
}
private HttpResponse RouteRequest()
{
var routes = this.Routes
.Where(x => Regex.Match(Request.Url, x.UrlRegex).Success)
.ToList();
if (!routes.Any())
{
return(HttpResponseBuilder.NotFound());
}
var route = routes.FirstOrDefault(x => x.Method == Request.Method);
if (route == null)
{
return new HttpResponse()
{
StatusCode = ResponseStatusCode.MethodNotAllowed
}
}
;
#region FIleSystemHandler
// extract the path if there is one
//var match = Regex.Match(request.Url, route.UrlRegex);
//if (match.Groups.Count > 1)
//{
// request.Path = match.Groups[1].Value;
//}
//else
//{
// request.Path = request.Url;
//}
#endregion
// trigger the route handler...
try
{
return(route.Callable(Request));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
return(HttpResponseBuilder.InternalServerError());
}
}
public void BuildResponseOkTest()
{
var request = new HttpRequestMessage();
request.SetConfiguration(new HttpConfiguration());
var serviceResponse = new FakeServiceResponse {
Result = true
};
var builder = new HttpResponseBuilder();
var response = builder.BuildResponse(request, serviceResponse);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual("true", response.Content.ReadAsStringAsync().Result);
}
private static HttpResponseMessage ExecProductServiceFunc(Func <ProductService, HttpResponseMessage> func, TraceWriter log)
{
try
{
return(func.Invoke(new ProductService(new ResourceService())));
}
catch (CannotGetResourceException e)
{
log.Error(e.Message, e);
return(HttpResponseBuilder <string> .Build(HttpStatusCode.ServiceUnavailable, e.Message));
}
catch (System.Exception e)
{
log.Error(e.Message, e);
return(HttpResponseBuilder <string> .Build(HttpStatusCode.InternalServerError, e.Message));
}
}
/**
* Get honest-to-goodness user data.
*
* @throws OAuthProtocolException if the service provider returns an OAuth
* related error instead of user data.
*/
private HttpResponseBuilder fetchData()
{
HttpResponseBuilder builder;
if (accessTokenData != null)
{
// This is a request for access token data, return it.
builder = formatAccessTokenData();
}
else
{
sRequest signed = sanitizeAndSign(realRequest, null);
sResponse response = fetchFromServer(signed);
checkForProtocolProblem(response);
builder = new HttpResponseBuilder(response);
}
return(builder);
}
public HttpResponse Handle(HttpRequest request)
{
this.getParams = WebUtilities.RetrieveGetParameters(request.Url);
this.postParams = WebUtilities.RetrievePostParameters(request.Content);
this.requestMethod = request.Method.ToString();
Tuple <string, string> controllerAndActionNames = this.GetControllerAndActionName(request.Url);
if (controllerAndActionNames == null)
{
return(HttpResponseBuilder.NotFound());
}
this.controllerName = controllerAndActionNames.Item1;
this.actionName = controllerAndActionNames.Item2;
MethodInfo method = this.GetControllerMethod(this.controllerName, this.actionName, this.requestMethod);
if (method == null)
{
throw new NotSupportedException("Method not supported!");
}
this.SetMethodParameters(method);
IInvocable actionResult = (IInvocable)this.GetControllerMethod(
this.controllerName,
this.actionName,
this.requestMethod)
.Invoke(
this.GetController(this.GetControllerTypeName(this.controllerName)),
this.methodParams);
string content = actionResult.Invoke();
HttpResponse response = new HttpResponse()
{
ContentAsUTF8 = content
};
return(response);
}
public HttpResponse Handle(HttpRequest request)
{
this.Request = request;
string urlPart;
// extract the path if there is one
var match = Regex.Match(request.Url, this.RouteUrlRegex);
if (match.Groups.Count > 1)
{
urlPart = match.Groups[1].Value;
}
else
{
urlPart = request.Url;
}
//var urlPart = request.Path;
urlPart = SanitarizePath(urlPart);
// make sure the first part of the path is not "/" or "\"
if (urlPart.Length > 0)
{
var firstChar = urlPart.ElementAt(0);
if (firstChar == '/' || firstChar == '\\')
{
urlPart = "." + urlPart;
}
}
var localPath = Path.Combine(this.BasePath, urlPart);
if (Directory.Exists(localPath))
{
return(this.HandleDirectory(localPath));
}
else if (File.Exists(localPath))
{
return(HandleFile(localPath));
}
else
{
return(HttpResponseBuilder.NotFound());
}
}
public void BuildResponseEntityInvalidTest()
{
var request = new HttpRequestMessage();
request.SetConfiguration(new HttpConfiguration());
var serviceResponse = new FakeServiceResponse
{
Result = false,
Exception = new ValidationException("test")
};
var builder = new HttpResponseBuilder();
var response = builder.BuildResponse(request, serviceResponse);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
Assert.AreEqual("test", response.Content.ReadAsStringAsync().Result);
}
public void should_be_able_parse_token_response()
{
var content = "{" +
"\"access_token\":\"TOKEN_VALUE\"," +
"\"token_type\":\"JWT\"," +
"\"expires_in\":3600," +
"\"refresh_token\":\"tGzv3JOkF0XG5Qx2TlKWIA\"" +
"}";
var response = new HttpResponseBuilder().WithContent(content).Build();
_sender.SetupResponse(response);
ActorRequestsForAccessToken();
var token = _actor.AsksFor(LastResponse.Content <OAuthToken>());
Check.That(token.AccessToken).IsEqualTo("TOKEN_VALUE");
Check.That(token.TokenType).IsEqualTo("JWT");
Check.That(token.ExpiresIn).IsEqualTo(3600);
Check.That(token.RefreshToken).IsEqualTo("tGzv3JOkF0XG5Qx2TlKWIA");
}
public HttpResponse Handle(HttpRequest request, string fileDirectory)
{
try
{
HttpFile file = this.ServeFile(request, fileDirectory);
HttpResponse response = new HttpResponse
{
Content = file.Content,
Header = { ContentType = file.MimeType },
};
return(response);
}
catch (FileNotFoundException fnfe)
{
Console.WriteLine(fnfe.ToString());
return(HttpResponseBuilder.NotFound());
}
}
/**
* Fetch data and build a response to return to the client. We try to always return something
* reasonable to the calling app no matter what kind of madness happens along the way. If an
* unchecked exception occurs, well, then the client is out of luck.
*/
private sResponse fetchNoThrow()
{
HttpResponseBuilder response = null;
try
{
accessorInfo = fetcherConfig.getTokenStore().getOAuthAccessor(
realRequest.getSecurityToken(), realRequest.getOAuthArguments(), clientState,
responseParams);
response = fetchWithRetry();
}
catch (OAuthResponseParams.OAuthRequestException e)
{
// No data for us.
responseParams.logDetailedWarning("OAuth fetch fatal error", e);
responseParams.setSendTraceToClient(true);
if (response == null)
{
response = new HttpResponseBuilder()
.setHttpStatusCode(sResponse.SC_FORBIDDEN);
responseParams.addToResponse(response);
return(response.create());
}
}
// OK, got some data back, annotate it as necessary.
if (response.getHttpStatusCode() >= 400)
{
responseParams.logDetailedWarning("OAuth fetch fatal error");
responseParams.setSendTraceToClient(true);
}
else if (responseParams.getAznUrl() != null && responseParams.sawErrorResponse())
{
responseParams.logDetailedWarning("OAuth fetch error, reprompting for user approval");
responseParams.setSendTraceToClient(true);
}
responseParams.addToResponse(response);
return(response.create());
}
public static IHttpClientWrapper MockHttpClientWrapper()
{
var httpClientWrapper = new Mock <IHttpClientWrapper>();
httpClientWrapper
.Setup(x => x.GetAsync(It.IsRegex("competitions$")))
.Returns(() =>
Task.FromResult(HttpResponseBuilder.Build(ServiceResponses.Competitions.All147Competitions)));
httpClientWrapper
.Setup(x => x.GetAsync(It.IsRegex("\\/teams")))
.Returns(() =>
Task.FromResult(HttpResponseBuilder.Build(ServiceResponses.Competitions.CompetitionTeams)));
httpClientWrapper
.Setup(x => x.GetAsync(It.IsRegex("teams\\/")))
.Returns(() =>
Task.FromResult(HttpResponseBuilder.Build(ServiceResponses.Teams.TeamDetail)));
return(httpClientWrapper.Object);
}
private async Task <HttpResponseModel> Send(HttpRequestModel request)
{
using (var reqMsg = HttpRequestMessageBuilder.BuildHttpRequestMessage(request))
{
var cancellationToken = GetCancellationToken(request.ResponseTimeoutOverride);
var transactionId = GetNextTransactionId();
var sentAtUtc = DateTimeOffset.UtcNow;
var respMsg = await SendNow(reqMsg, cancellationToken);
var resp = HttpResponseBuilder
.BuildHttpResponseModel(
transactionId,
sentAtUtc,
DateTimeOffset.UtcNow,
request.ShouldBufferResponseBody,
respMsg);
return(await resp);
}
}
public void Given_that_http_status_code_1xx_is_returned_When_sending_Then_HttpUnhandledStatusException_thrown()
{
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(100)
.SetStatusDescriptor("Redirection")
.SetResponse("Some response")
.Build();
var mockSocket = new Mock <IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny <HttpRequest>()))
.Returns(mockResponse);
var target = new HttpClient(mockSocket.Object);
// execution/assertion
TestDelegate testMethod = () => target.Send(new HttpRequest(""));
var exception = Assert.Throws(typeof(HttpRequestException), testMethod);
Assert.AreEqual("100 Redirection", exception.Message, "Exception message is not correct");
}
public void Given_url_and_port_and_arguments_are_set_When_sending_Then_request_is_sent_via_socket()
{
// setup
var mockHostname = "www.test.com";
var mockPath = "/resource.html";
var mockUrl = mockHostname + mockPath;
var mockPort = 8080;
var mockSocket = new Mock<IHttpSocket>();
var mockRequest = new HttpRequestBuilder()
.SetUrl(mockUrl)
.SetPort(mockPort)
.Build();
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(200)
.SetResponse("response")
.Build();
mockSocket
.Setup(s => s.Request(It.IsAny<HttpRequest>()))
.Returns(mockResponse);
var target = new HttpClient(mockSocket.Object);
// execution
target.Send(mockRequest);
// assertion
mockSocket.Verify(
s => s.Request(It.Is<HttpRequest>(
hr => hr.Hostname == mockHostname &&
hr.Path == mockPath &&
hr.Port == mockPort &&
hr.Method == HttpMethod.GET)),
Times.Once(),
"Request not sent via socket");
}
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next)
{
if (context.GetFirst(out HttpRequestMessage httpRequestMessage))
{
var redirectUri = FindMatchingRedirect(httpRequestMessage.RequestUri);
if (redirectUri != null)
{
var redirected = new Redirected(
httpRequestMessage, redirectUri);
context.Add(redirected);
httpRequestMessage.RequestUri = redirectUri;
}
else
{
if (Return404IfNotFound)
{
var response = HttpResponseBuilder
.HttpResponseMessage()
.WithStatusCode(404)
.WithContent(new StringContent(
"{\"RouteRedirect\": \"No matching route\"}",
Encoding.ASCII,
"appliation/json"))
.Build();
context.Add(response);
return;
}
}
await next.Invoke();
}
else
{
throw new PipelineDependencyException <HttpRequestMessage>(this);
}
}
public void Given_url_and_port_and_arguments_are_set_When_sending_Then_request_is_sent_via_socket()
{
// setup
var mockHostname = "www.test.com";
var mockPath = "/resource.html";
var mockUrl = mockHostname + mockPath;
var mockPort = 8080;
var mockSocket = new Mock <IHttpSocket>();
var mockRequest = new HttpRequestBuilder()
.SetUrl(mockUrl)
.SetPort(mockPort)
.Build();
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(200)
.SetResponse("response")
.Build();
mockSocket
.Setup(s => s.Request(It.IsAny <HttpRequest>()))
.Returns(mockResponse);
var target = new HttpClient(mockSocket.Object);
// execution
target.Send(mockRequest);
// assertion
mockSocket.Verify(
s => s.Request(It.Is <HttpRequest>(
hr => hr.Hostname == mockHostname &&
hr.Path == mockPath &&
hr.Port == mockPort &&
hr.Method == HttpMethod.GET)),
Times.Once(),
"Request not sent via socket");
}
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next)
{
if (context.GetFirst(out HttpRequestMessage httpRequestMessage))
{
if (RefusedMethods.Any(x => x == httpRequestMessage.Method))
{
var response = HttpResponseBuilder
.HttpResponseMessage()
.WithReasonPhrase("Method refused")
.WithStatusCode(403);
context.Add(response);
}
else
{
await next.Invoke();
}
}
else
{
throw new PipelineDependencyException <HttpRequestMessage>(this);
}
}
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next)
{
if (context.GetFirst(out HttpRequestMessage httpRequestMessage))
{
if (httpRequestMessage.Content?.Headers.ContentLength > MaxRequestSize)
{
var response = HttpResponseBuilder
.HttpResponseMessage()
.WithReasonPhrase("Content too large")
.WithStatusCode(500);
context.Add(response);
}
else
{
await next.Invoke();
}
}
else
{
throw new PipelineDependencyException <HttpRequestMessage>(this);
}
}
private HttpResponse RouteRequest()
{
var routes = this.Routes
.Where(x => Regex.Match(Request.Url, x.UrlRegex).Success)
.ToList();
if (!routes.Any())
{
return(HttpResponseBuilder.NotFound());
}
var route = routes.FirstOrDefault(x => x.Method == Request.Method);
if (route == null)
{
return new HttpResponse()
{
StatusCode = ResponseStatusCode.MethodNotAllowed
}
}
;
// trigger the route handler...
try
{
return(route.Callable(Request));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
return(HttpResponseBuilder.InternalServerError());
}
}
public void addToResponse(HttpResponseBuilder response)
{
if (!newClientState.isEmpty())
{
try
{
response.setMetadata(CLIENT_STATE, newClientState.getEncryptedState());
}
catch (BlobCrypterException e)
{
// Configuration error somewhere, this should never happen.
throw e;
}
}
if (!String.IsNullOrEmpty(aznUrl))
{
response.setMetadata(APPROVAL_URL, aznUrl);
}
if (error != null)
{
response.setMetadata(ERROR_CODE, error);
}
if (errorText != null || sendTraceToClient)
{
StringBuilder verboseError = new StringBuilder();
if (errorText != null)
{
verboseError.Append(errorText);
}
if (sendTraceToClient)
{
verboseError.Append('\n');
verboseError.Append(getRequestTrace());
}
response.setMetadata(ERROR_TEXT, verboseError.ToString());
}
}
public void Given_that_http_status_code_1xx_is_returned_When_sending_Then_HttpUnhandledStatusException_thrown()
{
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(100)
.SetStatusDescriptor("Redirection")
.SetResponse("Some response")
.Build();
var mockSocket = new Mock<IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny<HttpRequest>()))
.Returns(mockResponse);
var target = new HttpClient(mockSocket.Object);
// execution/assertion
TestDelegate testMethod = () => target.Send(new HttpRequest(""));
var exception = Assert.Throws(typeof(HttpRequestException), testMethod);
Assert.AreEqual("100 Redirection", exception.Message, "Exception message is not correct");
}
public void Given_that_http_status_code_2xx_And_http_headers_are_returned_When_sending_Then_response_is_returned()
{
var content = "some response content";
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(200)
.SetStatusDescriptor("OK")
.SetResponse(content)
.AddHeader("Header-one: header stuff")
.AddHeader("Second-header: more header stuff")
.Build();
var mockSocket = new Mock<IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny<HttpRequest>()))
.Returns(mockResponse);
var target = new HttpClient(mockSocket.Object);
// execution
var result = target.Send(new HttpRequest(""));
// assertion
Assert.AreEqual(content, result, "The http reponse was not correct");
}
public void Given_that_request_is_present_When_sending_Then_request_status_code_is_set()
{
var content = "some response content";
var statusCode = 201;
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(statusCode)
.SetStatusDescriptor("OK")
.SetResponse(content)
.Build();
var mockSocket = new Mock<IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny<HttpRequest>()))
.Returns(mockResponse);
var mockRequest = new HttpRequest("");
var target = new HttpClient(mockSocket.Object);
// execution
var result = target.Send(mockRequest);
// assertion
Assert.AreEqual(statusCode, mockRequest.StatusCode, "The request status code is not correct");
}
public void Given_that_request_is_present_and_status_code_indicates_error_When_sending_Then_request_Success_is_set_false()
{
var content = "some response content";
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(404)
.SetStatusDescriptor("OK")
.SetResponse(content)
.Build();
var mockSocket = new Mock<IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny<HttpRequest>()))
.Returns(mockResponse);
var mockRequest = new HttpRequest("");
var target = new HttpClient(mockSocket.Object);
// execution/assertion
TestDelegate method = () => target.Send(mockRequest);
var exception = (HttpRequestException)Assert.Throws(typeof (HttpRequestException), method,
"Correct exception not thrown");
Assert.IsFalse(exception.Request.Success, "The request success property is not correct");
}
public void Given_that_request_is_present_and_status_code_indicates_success_When_sending_Then_request_Success_is_set_true()
{
var content = "some response content";
var mockResponse = new HttpResponseBuilder()
.SetStatusCode(200)
.SetStatusDescriptor("OK")
.SetResponse(content)
.Build();
var mockSocket = new Mock<IHttpSocket>();
mockSocket
.Setup(s => s.Request(It.IsAny<HttpRequest>()))
.Returns(mockResponse);
var mockRequest = new HttpRequest("");
var target = new HttpClient(mockSocket.Object);
// execution
var result = target.Send(mockRequest);
// assertion
Assert.IsTrue(mockRequest.Success, "The request success property is not correct");
}
