public void ThenSetValue_Perform_SetHttpStatusLineTest()
{
string textValue = "GET https://www.telerik.com/UpdateCheck.aspx?isBeta=False HTTP/1.1";
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <HttpMessage> mockHttpMessage = new Mock <HttpMessage>();
Mock <HttpStatusLine> mockHttpStatusLine = new Mock <HttpStatusLine>();
Mock <VariableString> mockTextString = new Mock <VariableString>(It.IsAny <string>(), null);
EventInfo eventInfo = mockEventInfo.Object;
HttpMessage httpMessage = mockHttpMessage.Object;
HttpStatusLine httpStatusLine = mockHttpStatusLine.Object;
VariableString textString = mockTextString.Object;
mockTextString.Setup(mock => mock.GetText(It.IsAny <Variables>())).Returns(textValue);
mockEventInfo.Setup(mock => mock.Message).Returns(httpMessage);
mockHttpMessage.SetupSet(mock => mock.StatusLine = It.IsAny <HttpStatusLine>()).Callback((HttpStatusLine statusLine) =>
{
Assert.AreEqual(textValue, statusLine.ToString());
});
ThenSetValue then = new ThenSetValue()
{
Text = textString,
DestinationMessageValue = MessageValue.HttpStatusLine
};
Assert.AreEqual(ThenResponse.Continue, then.Perform(eventInfo));
mockHttpMessage.VerifySet(mock => mock.StatusLine = It.IsAny <HttpStatusLine>(), Times.Once);
}
public void ThenSetValue_Perform_SetHttpVersionTest()
{
string textValue = "Http/2";
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <HttpMessage> mockHttpMessage = new Mock <HttpMessage>();
Mock <HttpStatusLine> mockHttpStatusLine = new Mock <HttpStatusLine>();
Mock <VariableString> mockTextString = new Mock <VariableString>(It.IsAny <string>(), null);
EventInfo eventInfo = mockEventInfo.Object;
HttpMessage httpMessage = mockHttpMessage.Object;
HttpStatusLine httpStatusLine = mockHttpStatusLine.Object;
VariableString textString = mockTextString.Object;
mockTextString.Setup(mock => mock.GetText(It.IsAny <Variables>())).Returns(textValue);
mockEventInfo.Setup(mock => mock.Message).Returns(httpMessage);
mockHttpMessage.Setup(mock => mock.StatusLine).Returns(httpStatusLine);
mockHttpStatusLine.SetupSet(mock => mock.Version = It.IsAny <string>());
ThenSetValue then = new ThenSetValue()
{
Text = textString,
DestinationMessageValue = MessageValue.HttpVersion
};
Assert.AreEqual(ThenResponse.Continue, then.Perform(eventInfo));
mockHttpStatusLine.VerifySet(mock => mock.Version = It.IsAny <string>(), Times.Once);
}
public void OriginTest()
{
const string source = "HTTP/1.1 200 Connection Established\r\n";
HttpStatusLine.TryParse(source, out var line);
line.Source.Is(line.Source);
}
public static HttpResponse FromString(string value)
{
var result = new HttpResponse();
result.Line = HttpStatusLine.FromString(result.Load(value));
return(result);
}
public void Parse_BufferIsInvalid_ThrowsBadHttpDataException(string input)
{
// Arrange
var buffer = input.ToAsciiBytes();
// Act & Assert
var ex = Assert.Throws <BadHttpDataException>(() => HttpStatusLine.Parse(buffer, 3));
}
public void Parse_BufferIsNull_ThrowsArgumentNullException(int start)
{
// Arrange
// Act & Assert
var ex = Assert.Throws <ArgumentNullException>(() => HttpStatusLine.Parse(null, start));
Assert.That(ex.ParamName, Is.EqualTo("buffer"));
}
public void Parse_StartIsOutOfRange_ThrowsArgumentOutOfRangeException(int start)
{
// Arrange
// Act & Assert
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => HttpStatusLine.Parse(new byte[10], start));
Assert.That(ex.ParamName, Is.EqualTo("start"));
}
public void Constructor_HeadersIsNull_ThrowsArgumentNullException()
{
// Arrange
var line = new HttpStatusLine(HttpStatusCode.OK);
// Act & Assert
var ex = Assert.Throws <ArgumentNullException>(() => new HttpResponseMetadata(line, null));
Assert.That(ex.ParamName, Is.EqualTo("headers"));
}
public void NoReasonPhraseTest()
{
const string source = "HTTP/1.1 200 \r\n";
HttpStatusLine.TryParse(source, out var line);
line.HttpVersion.Is(HttpVersion.Version11);
line.StatusCode.Is(HttpStatusCode.OK);
line.ReasonPhrase.Is("");
line.ToString().Is(source);
}
public void OriginTest()
{
var statusLine = new HttpStatusLine(HttpVersion.Version11, HttpStatusCode.OK, "OK");
var headers = HttpHeaders.Empty;
headers.ContentLength.Value = 8;
var response = new HttpResponse(statusLine, headers, Encoding.ASCII.GetBytes("hogehoge"), HttpHeaders.Empty);
response.GetOrigin().IsNot(response.GetOrigin());
response.ToString().Is(response.ToString());
}
/// <summary>
/// スタートラインを解釈
/// </summary>
/// <param name="startLine"></param>
protected override void ParseStartLine(string startLine)
{
var isParseSucceeded = HttpStatusLine.TryParse(startLine, out var statusLine);
this.StatusLine = statusLine;
if (!isParseSucceeded)
{
Debug.WriteLine($"###start###{startLine}###end###");
throw new BadGatewayException("Invalid Status Line");
}
}
public void CreateInstanceTest()
{
var statusLine = new HttpStatusLine(HttpVersion.Version11, HttpStatusCode.OK, "OK");
var headers = HttpHeaders.Empty;
var response = new HttpResponse(statusLine, headers, new byte[0], HttpHeaders.Empty);
response.ToString().Is(
@"HTTP/1.1 200 OK
");
}
static public void TestParseHttpStatusLine()
{
// Test a well-formatted status line
var sl = "HTTP/1.0 200 OK";
var sl_nl = sl + "\r\n";
HttpStatusLine hsl = TcpCommon.ParseHttpStatusLine(sl_nl);
Assert.AreEqual("1.0", hsl.ProtocolVersion);
Assert.AreEqual(sl, hsl.StatusLine);
Assert.AreEqual(200, hsl.StatusCode);
}
public void Constructor_CustomCodeWithoutReason_RunsOkReasonIsUnknown()
{
// Arrange
// Act
var line = new HttpStatusLine((HttpStatusCode)1488);
// Assert
Assert.That(line.Version, Is.EqualTo("HTTP/1.1"));
Assert.That((int)line.Code, Is.EqualTo(1488));
Assert.That(line.Reason, Is.EqualTo("Unknown"));
}
public void Constructor_CustomCodeAndReason_RunsOk()
{
// Arrange
// Act
var line = new HttpStatusLine("HTTP/1.1", (HttpStatusCode)1488, "Special Reason");
// Assert
Assert.That(line.Version, Is.EqualTo("HTTP/1.1"));
Assert.That((int)line.Code, Is.EqualTo(1488));
Assert.That(line.Reason, Is.EqualTo("Special Reason"));
}
public void Constructor_ValidArguments_RunsOk()
{
// Arrange
var line = new HttpStatusLine(HttpStatusCode.OK);
var headersArray = new[]
{
new HttpHeader("Server", "nginx/1.8.0"),
new HttpHeader("Date", "Fri, 20 Apr 2018 07:15:11 GMT"),
new HttpHeader("Content-Type", "text/html; charset=UTF-8"),
new HttpHeader("Transfer-Encoding", "chunked"),
new HttpHeader("Connection", "keep-alive"),
new HttpHeader("Vary", "Accept-Encoding"),
new HttpHeader("X-Powered-By", "PHP/5.4.45"),
new HttpHeader("X-Pingback", "http://www.allitebooks.com/xmlrpc.php"),
};
var headers = new HttpHeaderCollection(headersArray);
// Act
var responseMetadata = new HttpResponseMetadata(line, headers);
// Assert
Assert.That(responseMetadata.Line.Version, Is.EqualTo("HTTP/1.1"));
Assert.That((int)responseMetadata.Line.Code, Is.EqualTo(200));
Assert.That(responseMetadata.Line.Reason, Is.EqualTo("OK"));
Assert.That(responseMetadata.Headers.Count(), Is.EqualTo(8));
Assert.That(responseMetadata.Headers.ElementAt(0), Is.SameAs(headersArray[0]));
Assert.That(responseMetadata.Headers.ElementAt(1), Is.SameAs(headersArray[1]));
Assert.That(responseMetadata.Headers.ElementAt(2), Is.SameAs(headersArray[2]));
Assert.That(responseMetadata.Headers.ElementAt(3), Is.SameAs(headersArray[3]));
Assert.That(responseMetadata.Headers.ElementAt(4), Is.SameAs(headersArray[4]));
Assert.That(responseMetadata.Headers.ElementAt(5), Is.SameAs(headersArray[5]));
var expectedString = @"HTTP/1.1 200 OK
Server: nginx/1.8.0
Date: Fri, 20 Apr 2018 07:15:11 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
Vary: Accept-Encoding
X-Powered-By: PHP/5.4.45
X-Pingback: http://www.allitebooks.com/xmlrpc.php
";
var toString = responseMetadata.ToString();
Assert.That(toString, Is.EqualTo(expectedString));
var bytes = responseMetadata.Serialize();
Assert.That(bytes, Is.EquivalentTo(expectedString.ToAsciiBytes()));
}
public HttpStatusLine Parse(string line)
{
HttpStatusLine statusLine = null;
if (!string.IsNullOrEmpty(line))
{
string[] sections = line.Split(new char[] { ' ' }, 3);
if (sections.Length == 3)
{
statusLine = ParseResponseStatusLine(sections) ?? ParseRequestStatusLine(sections);
}
}
return(statusLine);
}
public void ToBytesTest()
{
var statusLine = new HttpStatusLine(HttpVersion.Version11, HttpStatusCode.OK, "OK");
var headers = HttpHeaders.Empty;
headers.ContentLength.Value = 8;
var response = new HttpResponse(statusLine, headers, Encoding.ASCII.GetBytes("hogehoge"), HttpHeaders.Empty);
response.ToBytes().Is(Encoding.ASCII.GetBytes(
@"HTTP/1.1 200 OK
Content-Length: 8
hogehoge"));
}
public void Constructor_3ArgumentsValid_RunsOk(string version, HttpStatusCode code, string reason)
{
// Arrange
// Act
var line = new HttpStatusLine(version, code, reason);
// Assert
Assert.That(line.Version, Is.EqualTo(version));
Assert.That(line.Code, Is.EqualTo(code));
Assert.That(line.Reason, Is.EqualTo(reason));
Assert.That(line.ToString(), Is.EqualTo($"{version} {(int)code} {reason}\r\n"));
Assert.That(line.ByteCount, Is.EqualTo($"{version} {(int)code} {reason}\r\n".Length));
Assert.That(line.ToArray(), Is.EquivalentTo($"{version} {(int)code} {reason}\r\n".ToAsciiBytes()));
}
public void Constructor_1ArgumentValid_RunsOk()
{
// Arrange
// Act
var line = new HttpStatusLine(HttpStatusCode.ExpectationFailed);
// Assert
Assert.That(line.Version, Is.EqualTo("HTTP/1.1"));
Assert.That(line.Code, Is.EqualTo(HttpStatusCode.ExpectationFailed));
Assert.That(line.Reason, Is.EqualTo("Expectation Failed"));
Assert.That(line.ToString(), Is.EqualTo("HTTP/1.1 417 Expectation Failed\r\n"));
Assert.That(line.ByteCount, Is.EqualTo("HTTP/1.1 417 Expectation Failed\r\n".Length));
Assert.That(line.ToArray(), Is.EquivalentTo("HTTP/1.1 417 Expectation Failed\r\n".ToAsciiBytes()));
}
static public void TestHttpResponseLine()
{
// Test the mixing of structured and unstructured
// line-based reads
var msg = "Captain Copyright";
var http_msg = "HTTP/1.0 200 OK\r\n\r\n" + msg + "\r\n";
using (var hs = new HttpSocket(
new EchoSocket(false, http_msg).socket))
{
var hsl = new HttpStatusLine(hs);
Assert.AreEqual(200, hsl.StatusCode);
/*var hh = */ new HttpHeaders(hs);
var line = hs.ReadAsciiLine();
Assert.AreEqual(msg, line);
}
}
public static void TestHttpResponseLine()
{
// Test the mixing of structured and unstructured
// line-based reads
var msg = "Captain Copyright";
var http_msg = "HTTP/1.0 200 OK\r\n\r\n" + msg + "\r\n";
using (var hs = new HttpSocket(
new EchoSocket(false, http_msg).socket))
{
var hsl = new HttpStatusLine(hs);
Assert.AreEqual(200, hsl.StatusCode);
/*var hh = */new HttpHeaders(hs);
var line = hs.ReadAsciiLine();
Assert.AreEqual(msg, line);
}
}
public void GetOriginTest()
{
var statusLine = new HttpStatusLine(HttpVersion.Version11, HttpStatusCode.OK, "OK");
var headers = HttpHeaders.Empty;
headers.ContentLength.Value = 0;
var response = new HttpResponse(statusLine, headers, new byte[0], HttpHeaders.Empty);
response.ToString().Is(
@"HTTP/1.1 200 OK
Content-Length: 0
");
response.GetOrigin().ToString().Is(
@"HTTP/1.1 200 OK
");
}
public void AfterReceivedHeadersTest()
{
var statusLine = new HttpStatusLine(HttpVersion.Version11, HttpStatusCode.OK, "OK");
HttpHeaders.TryParse(
@"Content-Encoding: gzip
Transfer-Encoding: gzip, chunked
", out var headers);
var response = new HttpResponse(statusLine, headers, null, HttpHeaders.Empty);
response.ToString().Is(
@"HTTP/1.1 200 OK
Content-Encoding: gzip
Transfer-Encoding: gzip, chunked
");
}
static public void TestHttpResponseBinary()
{
// Test the mixing of line-based and raw-based reads
var msg = "123";
var http_msg = "HTTP/1.0 200 OK\r\n\r\n" + msg;
using (var hs = new HttpSocket(
new EchoSocket(false, http_msg).socket))
{
var hsl = new HttpStatusLine(hs);
Assert.AreEqual(200, hsl.StatusCode);
/*var hh = */ new HttpHeaders(hs);
uint r = hs.ReadBinary();
Assert.AreEqual(r, 3);
Assert.AreEqual('1', hs.Buffer[0]);
Assert.AreEqual('2', hs.Buffer[1]);
Assert.AreEqual('3', hs.Buffer[2]);
}
}
public static void TestHttpResponseBinary()
{
// Test the mixing of line-based and raw-based reads
var msg = "123";
var http_msg = "HTTP/1.0 200 OK\r\n\r\n" + msg;
using (var hs = new HttpSocket(
new EchoSocket(false, http_msg).socket))
{
var hsl = new HttpStatusLine(hs);
Assert.AreEqual(200, hsl.StatusCode);
/*var hh = */new HttpHeaders(hs);
uint r = hs.ReadBinary();
Assert.AreEqual(r, 3);
Assert.AreEqual('1', hs.Buffer[0]);
Assert.AreEqual('2', hs.Buffer[1]);
Assert.AreEqual('3', hs.Buffer[2]);
}
}
public void Parse_ValidArguments_ParsesCorrectly(string input, string expectedVersion, HttpStatusCode expectedCode, string expectedReason)
{
// Arrange
var buffer = input.ToAsciiBytes();
// Act
var line = HttpStatusLine.Parse(buffer, 3);
// Assert
Assert.That(line.Version, Is.EqualTo(expectedVersion));
Assert.That(line.Code, Is.EqualTo(expectedCode));
Assert.That(line.Reason, Is.EqualTo(expectedReason));
var expectedString = $"{expectedVersion} {(int)expectedCode} {expectedReason}\r\n";
Assert.That(line.ToString(), Is.EqualTo(expectedString));
Assert.That(line.ByteCount, Is.EqualTo(expectedString.Length));
Assert.That(line.ToArray(), Is.EquivalentTo(expectedString.ToAsciiBytes()));
}
private HttpStatusLine ParseResponseStatusLine(string[] sections)
{
HttpStatusLine statusLine = null;
if (sections[0].StartsWith("http", System.StringComparison.InvariantCultureIgnoreCase))
{
string version = sections[0];
int statusCode = 0;
string statusMessage = sections[2];
if (int.TryParse(sections[1], out statusCode))
{
statusLine = new HttpResponseStatusLine()
{
Version = sections[0],
StatusCode = statusCode,
StatusMessage = sections[2]
};
}
}
return(statusLine);
}
public HttpStatusLineBuilder(HttpStatusLine line)
{
this.Version = line.Version;
this.Code = line.Code;
this.Reason = line.Reason;
}
public override bool IsMatch(EventInfo eventInfo)
{
bool matches = false;
switch (MessageValue)
{
case MessageValue.DataDirection:
case MessageValue.LocalAddress:
case MessageValue.LocalPort:
case MessageValue.Protocol:
case MessageValue.SourceRemoteAddress:
case MessageValue.SourceRemotePort:
matches = true;
break;
case MessageValue.DestinationRemoteAddress:
matches = eventInfo.ProxyConnection.HasTargetConnection;
break;
case MessageValue.DestinationRemotePort:
matches = eventInfo.ProxyConnection.HasTargetConnection;
break;
case MessageValue.HttpBody:
{
HttpBody httpBody = (eventInfo.Message as HttpMessage)?.Body;
if (httpBody != null)
{
if (MessageValueType != MessageValueType.Text && Identifier != null)
{
switch (MessageValueType)
{
case MessageValueType.Json:
matches = httpBody.Text.GetJsonValue(Identifier.GetText(eventInfo.Variables)) != null;
break;
case MessageValueType.Xml:
matches = httpBody.Text.GetXmlValue(Identifier.GetText(eventInfo.Variables)) != null;
break;
}
}
else
{
matches = true;
}
}
else
{
matches = false;
}
}
break;
case MessageValue.HttpHeaders:
matches = ((eventInfo.Message as HttpMessage)?.Headers?.Count ?? 0) > 0;
break;
case MessageValue.HttpHeader:
matches = (eventInfo.Message as HttpMessage)?.Headers.Contains(Identifier.GetText(eventInfo.Variables)) ?? false;
break;
case MessageValue.HttpMethod:
matches = !string.IsNullOrEmpty(((eventInfo.Message as HttpMessage)?.StatusLine as HttpRequestStatusLine)?.Method);
break;
case MessageValue.HttpRequestUri:
matches = !string.IsNullOrEmpty(((eventInfo.Message as HttpMessage)?.StatusLine as HttpRequestStatusLine)?.Uri);
break;
case MessageValue.HttpVersion:
HttpStatusLine requestStatusLine = (eventInfo.Message as HttpMessage)?.StatusLine;
if (requestStatusLine is HttpRequestStatusLine)
{
matches = !string.IsNullOrEmpty((requestStatusLine as HttpRequestStatusLine)?.Version);
}
else
{
matches = !string.IsNullOrEmpty((requestStatusLine as HttpResponseStatusLine)?.Version);
}
break;
case MessageValue.HttpStatusLine:
matches = (eventInfo.Message as HttpMessage)?.StatusLine != null;
break;
case MessageValue.HttpStatusCode:
matches = ((eventInfo.Message as HttpMessage)?.StatusLine as HttpResponseStatusLine)?.StatusCode != null;
break;
case MessageValue.HttpStatusMessage:
matches = !string.IsNullOrEmpty(((eventInfo.Message as HttpMessage)?.StatusLine as HttpResponseStatusLine)?.StatusMessage);
break;
case MessageValue.Message:
matches = !string.IsNullOrEmpty(eventInfo.Message?.ToString());
break;
}
return(matches);
}
/// <summary>
/// HTTPステータス、ヘッダ、ボディを元に初期化。
/// </summary>
/// <param name="statusLine">HTTPステータスライン。</param>
/// <param name="headers">HTTPレスポンスヘッダ。</param>
/// <param name="body">HTTPレスポンスボディ。</param>
public HttpResponse(HttpStatusLine statusLine, HttpHeaders headers, byte[] body)
{
this.StatusLine = statusLine;
this.Headers = headers;
this.Body = body;
}
public Tuple <int, HttpMessage> Parse(byte[] bytes, bool useFullBody = false)
{
_fullBytesPos = 0;
this._bytes = bytes;
bool complete = false;
useFullBody |= GeneralSettings.IgnoreContentLength;
_autoUpdateContentLength = GeneralSettings.AutoUpdateContentLength;
_statusLine = ParseStatusLine();
if (_statusLine != null)
{
_headers = ParseHeaders();
if (_headers != null)
{
int rawBodyByteSize = bytes.Length - _fullBytesPos;
string definedContentLengthStr = _headers.GetOrDefault("Content-Length");
int definedContentLength = 0;
if (definedContentLength == 0)
{
_autoUpdateContentLength = false;
}
int.TryParse(definedContentLengthStr, out definedContentLength);
if (definedContentLength <= rawBodyByteSize)
{
if (_headers.GetOrDefault("Transfer-Encoding") == "chunked")
{
_body = ParseBodyChunks();
if (_body != null)
{
complete = true;
}
}
else
{
if (useFullBody)
{
definedContentLength = rawBodyByteSize;
}
if (definedContentLength > 0)
{
_body = ParseBody <HttpBody>(definedContentLength);
_fullBytesPos += definedContentLength;
if (_body != null)
{
if (_autoUpdateContentLength)
{
_headers["Content-Length"] = definedContentLength.ToString();
}
complete = true;
}
}
else
{
complete = true;
}
}
}
}
}
if (complete)
{
_message = new HttpMessage()
{
Body = _body,
Complete = complete,
TextEncoding = TextEncoding,
Headers = _headers,
StatusLine = _statusLine,
NewLine = _newLineStr,
Type = _type
};
}
return(new Tuple <int, HttpMessage>(_fullBytesPos, _message));
}
