public void Should_read_byte_from_underlaying_stream_when_reading_byte()
{
// Given
var stream = CreateFakeStream();
var request = RequestStream.FromStream(stream, 0, 1, false);
// When
request.ReadByte();
// Then
A.CallTo(() => stream.ReadByte()).MustHaveHappened();
}
public void Should_throw_notsupportedexception_when_setting_length()
{
// Given
var stream = new ConfigurableMemoryStream();
var request = RequestStream.FromStream(stream, 0, 1, false);
// When
var exception = Record.Exception(() => request.SetLength(10L));
// Then
exception.ShouldBeOfType <NotSupportedException>();
}
public void Should_seek_in_the_underlaying_stream_when_seek_is_called()
{
// Given
var stream = new ConfigurableMemoryStream();
var request = RequestStream.FromStream(stream, 0, 1, false);
// When
request.Seek(10L, SeekOrigin.Current);
// Then
stream.HasBeenSeeked.ShouldBeTrue();
}
public void Should_throw_invalidoperationexception_when_position_is_set_to_greater_than_length_of_stream()
{
// Given
var stream = new ConfigurableMemoryStream(Length: 100L);
var request = RequestStream.FromStream(stream, 0, 1, false);
// When
var exception = Record.Exception(() => request.Position = 1000);
// Then
exception.ShouldBeOfType <InvalidOperationException>();
}
public void Should_flush_underlaying_stream()
{
// Given
var stream = new ConfigurableMemoryStream();
var request = RequestStream.FromStream(stream, 0, 1, false);
// When
request.Flush();
// Then
stream.HasBeenFlushed.ShouldBeTrue();
}
public void Should_set_position_of_underlaying_stream()
{
// Given
var stream = new ConfigurableMemoryStream(Length: 2000L);
var request = RequestStream.FromStream(stream, 2000L, 2001L, false);
// When
request.Position = 1234L;
// Then
stream.Position.ShouldEqual(1234L);
}
public void Should_throw_argumentoutofrangexception_when_setting_position_to_less_than_zero()
{
// Given
var stream = new ConfigurableMemoryStream();
var request = RequestStream.FromStream(stream, 2000L, 2001L, false);
// When
var exception = Record.Exception(() => request.Position = -1);
// Then
exception.ShouldBeOfType <InvalidOperationException>();
}
public void Should_return_length_of_underlaying_stream()
{
// Given
var stream = new ConfigurableMemoryStream(Length: 1234L);
var request = RequestStream.FromStream(stream, 0, 1235, false);
// When
var result = request.Length;
// Then
result.ShouldEqual(1234L);
}
public void Should_return_false_when_queried_about_supporting_timeout()
{
// Given
var stream = new ConfigurableMemoryStream();
var request = RequestStream.FromStream(stream, 0, 1, false);
// When
var result = request.CanTimeout;
// Then
result.ShouldBeFalse();
}
public void Should_return_true_when_queried_about_supporting_seeking()
{
// Given
var stream = new ConfigurableMemoryStream();
var request = RequestStream.FromStream(stream, 0, 1, false);
// When
var result = request.CanSeek;
// Then
result.ShouldBeTrue();
}
public void Should_throw_argumentoutofrangeexception_when_thresholdLength_is_less_than_zero()
{
// Given
var stream = new ConfigurableMemoryStream();
const int tresholdLength = -1;
// When
var exception = Record.Exception(() => RequestStream.FromStream(stream, 0, tresholdLength));
// Then
exception.ShouldBeOfType <ArgumentOutOfRangeException>();
}
public void Should_return_length_of_underlaying_stream()
{
// Given
A.CallTo(() => this.stream.Length).Returns(1234L);
var request = RequestStream.FromStream(this.stream, 0, 1235, false);
// When
var result = request.Length;
// Then
result.ShouldEqual(1234L);
}
public void Should_work_even_with_a_non_seekable_stream()
{
// Given
var stream = new ConfigurableMemoryStream(Seekable: false);
var request = RequestStream.FromStream(stream, 0, 1, false);
// When
var result = request.CanRead;
// Then
result.ShouldBeTrue();
}
public void ValidateSignatureFromHeaderWithContent(string secretKey, string headerName)
{
var signature = this.Request.Headers[headerName].FirstOrDefault() ?? string.Empty;
var content = RequestStream.FromStream(this.Request.Body).AsString() ?? string.Empty;
var result = SignatureUtility.ValidateSignature(signature, secretKey, content);
if (result == false)
{
throw new UnauthorizedException();
}
}
public void Should_write_to_underlaying_stream_when_write_is_called()
{
// Given
var buffer = new byte[1];
var request = RequestStream.FromStream(this.stream, 0, 1, false);
// When
request.Write(buffer, 0, buffer.Length);
// Then
A.CallTo(() => this.stream.Write(buffer, 0, buffer.Length)).MustHaveHappened();
}
public void Should_return_state_of_underlaying_stream_when_queried_about_supporting_writing()
{
// Given
A.CallTo(() => this.stream.CanWrite).Returns(true);
var request = RequestStream.FromStream(this.stream, 0, 1, false);
// When
var result = request.CanWrite;
// Then
result.ShouldBeTrue();
}
public void Should_return_the_new_position_of_the_underlaying_stream_when_seek_is_called()
{
// Given
A.CallTo(() => this.stream.Seek(A <long> .Ignored, A <SeekOrigin> .Ignored)).Returns(100L);
var request = RequestStream.FromStream(this.stream, 0, 1, false);
// When
var result = request.Seek(10L, SeekOrigin.Current);
// Then
result.ShouldEqual(100L);
}
public void Should_return_read_byte_from_underlaying_stream_when_readbyte_is_called()
{
// Given
A.CallTo(() => this.stream.ReadByte()).Returns(5);
var request = RequestStream.FromStream(this.stream, 0, 1, false);
// When
var result = request.ReadByte();
// Then
result.ShouldEqual(5);
}
public void Should_throw_invalidoperationexception_when_position_is_set_to_greater_than_length_of_stream()
{
// Given
A.CallTo(() => this.stream.Length).Returns(100L);
var request = RequestStream.FromStream(this.stream, 0, 1, false);
// When
var exception = Record.Exception(() => request.Position = 1000);
// Then
exception.ShouldBeOfType <InvalidOperationException>();
}
public void Should_set_position_of_underlaying_stream()
{
// Given
A.CallTo(() => this.stream.Length).Returns(2000L);
var request = RequestStream.FromStream(this.stream, 0, 2001, false);
// When
request.Position = 1234L;
// Then
this.stream.Position.ShouldEqual(1234L);
}
public void Should_not_dispose_wrapped_stream_when_not_switched()
{
// Given
var stream = new ConfigurableMemoryStream();
var instance = RequestStream.FromStream(stream, 0, 1, true);
// When
instance.Dispose();
// Then
stream.HasBeenDisposed.ShouldBeFalse();
}
public void Should_call_endwrite_on_underlaying_stream_when_endwrite_is_called()
{
// Given
var asyncResult = A.Fake <IAsyncResult>();
var request = RequestStream.FromStream(this.stream, 0, 10, true);
// When
request.EndWrite(asyncResult);
// Then
A.CallTo(() => this.stream.EndWrite(asyncResult)).MustHaveHappened();
}
public void Should_call_endread_on_underlaying_stream_when_endread_is_called()
{
// Given
var stream = CreateFakeStream();
var asyncResult = A.Fake <IAsyncResult>();
var request = RequestStream.FromStream(stream, 0, 10, true);
// When
request.EndRead(asyncResult);
// Then
A.CallTo(() => stream.EndRead(asyncResult)).MustHaveHappened();
}
public void Should_read_from_underlaying_stream_when_read_is_called()
{
// Given
var stream = CreateFakeStream();
var buffer = new byte[1];
var request = RequestStream.FromStream(stream, 0, 1, false);
// When
request.Read(buffer, 0, buffer.Length);
// Then
A.CallTo(() => stream.Read(buffer, 0, buffer.Length)).MustHaveHappened();
}
private Request ConvertRequestToNancyRequest(IRequest request)
{
var expectedRequestLength =
GetExpectedRequestLength(request.Headers);
return(new Request(
request.Method,
request.Uri.LocalPath,
ConvertToNancyHeaders(request.Headers),
RequestStream.FromStream(request.Body, expectedRequestLength, true),
request.Uri.Scheme,
request.Uri.Query));
}
public void Should_return_position_of_underlaying_stream()
{
// Given
var request = RequestStream.FromStream(this.stream, 0, 1, false);
A.CallTo(() => this.stream.Position).Returns(1234L);
// When
var result = request.Position;
// Then
result.ShouldEqual(1234L);
}
private static Request CreateNancyRequest(HttpContextBase context)
{
var expectedRequestLength =
GetExpectedRequestLength(context.Request.Headers.ToDictionary());
return(new Request(
(context.Request.Form["_method"] ?? context.Request.HttpMethod).ToUpperInvariant(),
context.Request.AppRelativeCurrentExecutionFilePath.Replace("~", string.Empty),
context.Request.Headers.ToDictionary(),
RequestStream.FromStream(context.Request.InputStream, expectedRequestLength, true),
context.Request.Url.Scheme,
context.Request.Url.Query));
}
private Request ConvertRequestToNancyRequest(HttpListenerRequest request)
{
var baseUri = this.GetBaseUri(request);
if (baseUri == null)
{
throw new InvalidOperationException(string.Format("Unable to locate base URI for request: {0}", request.Url));
}
var expectedRequestLength =
GetExpectedRequestLength(request.Headers.ToDictionary());
var relativeUrl = baseUri.MakeAppLocalPath(request.Url);
var nancyUrl = new Url
{
Scheme = request.Url.Scheme,
HostName = request.Url.Host,
Port = request.Url.IsDefaultPort ? null : (int?)request.Url.Port,
BasePath = baseUri.AbsolutePath.TrimEnd('/'),
Path = HttpUtility.UrlDecode(relativeUrl),
Query = request.Url.Query,
};
byte[] certificate = null;
if (this.configuration.EnableClientCertificates)
{
var x509Certificate = request.GetClientCertificate();
if (x509Certificate != null)
{
certificate = x509Certificate.RawData;
}
}
// NOTE: For HTTP/2 we want fieldCount = 1,
// otherwise (HTTP/1.0 and HTTP/1.1) we want fieldCount = 2
var fieldCount = request.ProtocolVersion.Major == 2 ? 1 : 2;
var protocolVersion = string.Format("HTTP/{0}", request.ProtocolVersion.ToString(fieldCount));
return(new Request(
request.HttpMethod,
nancyUrl,
RequestStream.FromStream(request.InputStream, expectedRequestLength, StaticConfiguration.DisableRequestStreamSwitching ?? false),
request.Headers.ToDictionary(),
(request.RemoteEndPoint != null) ? request.RemoteEndPoint.Address.ToString() : null,
certificate,
protocolVersion));
}
private static async Task <Nancy.Response> ProcessWriteMethod(NancyModule module, HttpMethod method, string inUri, IRequestProvider requestProvider)
{
var result = new Nancy.Response();
HttpResponseMessage response = null;
var responseContent = string.Empty;
try
{
var hc = new HttpClient()
{
BaseAddress = new Uri(inUri)
};
string jsonString = RequestStream.FromStream(module.Request.Body).AsString();
dynamic jsonObj = string.IsNullOrEmpty(jsonString) ?
new ExpandoObject() :
JsonConvert.DeserializeObject <ExpandoObject>(jsonString);
jsonObj.UserId = await InputModule.GetUserId(module, requestProvider);
var content = new StringContent(JsonConvert.SerializeObject(jsonObj));
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
var message = new HttpRequestMessage(
method,
InputModule.GetPath(module.Context.Request)
)
{
Content = content
};
foreach (var kvp in module.Context.Request.Headers.ToList())
{
if (Array.IndexOf(new string[] { "Content-Length", "Content-Type" }, kvp.Key) < 0)
{
message.Headers.Add(kvp.Key, string.Join(',', kvp.Value));
}
}
response = await hc.SendAsync(message);
responseContent = await response.Content.ReadAsStringAsync();
response.EnsureSuccessStatusCode();
result = new TextResponse(HttpStatusCode.OK, responseContent);
}
catch (Exception ex)
{
result = new TextResponse(HttpStatusCode.BadRequest, (response != null) ? responseContent : ex.ToString());
}
return(result);
}
private static Request CreateNancyRequestFromIncomingWebRequest(IncomingWebRequestContext webRequest, Stream requestBody, OperationContext context)
{
var address =
((RemoteEndpointMessageProperty)
OperationContext.Current.IncomingMessageProperties[RemoteEndpointMessageProperty.Name]);
var baseUri =
GetUrlAndPathComponents(webRequest.UriTemplateMatch.BaseUri);
if (!baseUri.OriginalString.EndsWith("/"))
{
baseUri = new Uri(string.Concat(baseUri.OriginalString, "/"));
}
var relativeUri =
baseUri.MakeRelativeUri(GetUrlAndPathComponents(webRequest.UriTemplateMatch.RequestUri));
var expectedRequestLength =
GetExpectedRequestLength(webRequest.Headers.ToDictionary());
var nancyUrl = new Url {
BasePath = webRequest.UriTemplateMatch.BaseUri.AbsolutePath,
Scheme = webRequest.UriTemplateMatch.RequestUri.Scheme,
HostName = webRequest.UriTemplateMatch.BaseUri.Host,
Port = webRequest.UriTemplateMatch.RequestUri.IsDefaultPort ? null : (int?)webRequest.UriTemplateMatch.RequestUri.Port,
Path = string.Concat("/", relativeUri),
Query = webRequest.UriTemplateMatch.RequestUri.Query
};
byte[] certificate = null;
if (context.ServiceSecurityContext != null && context.ServiceSecurityContext.AuthorizationContext.ClaimSets.Count > 0)
{
var claimset =
context.ServiceSecurityContext.AuthorizationContext.ClaimSets.FirstOrDefault(
c => c is X509CertificateClaimSet) as X509CertificateClaimSet;
if (claimset != null)
{
certificate = claimset.X509Certificate.RawData;
}
}
return(new Request(
webRequest.Method,
nancyUrl,
RequestStream.FromStream(requestBody, expectedRequestLength, false),
webRequest.Headers.ToDictionary(),
address.Address,
certificate));
}
