public void HttpSocketAdapter_GetResponseHeader_SocketException()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
serverSocket.SendString("HTTP/1.1 200 OK\r\n", Encoding.ASCII);
HttpSocketAdapter clientSocket = new HttpSocketAdapter("GET", new Uri("http://bing.com"), serverSocket);
Task <int> responseCodeTask = clientSocket.GetResponseStatusCode();
Task <string> responseHeaderTask = clientSocket.GetResponseHeader("test header");
Task responseCompleteTask = clientSocket.WaitForResponseComplete();
TaskAssert.Completed(responseCodeTask, "GetResponseStatusCode should have failed.");
AssertWithMessage.Equal(200, responseCodeTask.Result, "Wrong result for GetResponseStatusCode");
// Act
serverSocket.ThrowExceptionFromReceiveAsync();
// Assert
TaskAssert.Faulted(responseHeaderTask, "GetResponseHeader should have failed.");
TaskAssert.Faulted(responseCompleteTask, "WaitForResponseComplete should have failed.");
AssertWithMessage.Equal("An error occurred.", responseHeaderTask.Exception.InnerException.Message, "Wrong exception for GetResponseHeader");
AssertWithMessage.Equal("An error occurred.", responseCompleteTask.Exception.InnerException.Message, "Wrong exception for WaitForResponseComplete");
}
public void SocketReader_ReadBytesIntoResponseHandler_WaitsForHandlerToComplete()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
socket.SendString("This is a test. This sentence isn't read.", Encoding.UTF8);
MockResponseHandler handler = new MockResponseHandler(Encoding.UTF8);
handler.Block = true;
SocketReader reader = new SocketReader(socket);
// Act
Task <int> result = reader.ReadBytesIntoResponseHandler(15, handler.HandlerMethod, _dontCancel);
// Assert
TaskAssert.NotCompleted(result, "Before handler is unblocked.");
// Act
handler.Block = false;
// Assert
TaskAssert.ResultEquals(result, 15, "After handler is unblocked.");
Assert.Equal("This is a test.", handler.Response);
}
public void SocketReader_ReadBytesIntoResponseHandler_ReadsMoreBytes()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
socket.SendString("This is a test. This is the next sentence.", Encoding.ASCII);
MockResponseHandler handler = new MockResponseHandler(Encoding.ASCII);
SocketReader reader = new SocketReader(socket);
// Act
Task <int> result = reader.ReadBytesIntoResponseHandler(15, handler.HandlerMethod, _dontCancel);
// Assert
TaskAssert.ResultEquals(result, 15);
Assert.Equal("This is a test.", handler.Response);
// Act
result = reader.ReadBytesIntoResponseHandler(27, handler.HandlerMethod, _dontCancel);
// Assert
TaskAssert.ResultEquals(result, 27);
Assert.Equal("This is a test. This is the next sentence.", handler.Response);
}
public void SocketReader_ReadLine_WaitsForMoreDataWhenLineIncomplete()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
SocketReader reader = new SocketReader(socket);
// Act
Task <string> result = reader.ReadLine(_dontCancel);
// Assert
TaskAssert.NotCompleted(result, "Before sending data.");
// Act
socket.SendString("This is the first part of the string. ", Encoding.ASCII);
// Assert
TaskAssert.NotCompleted(result, "After sending first sentence.");
// Act
socket.SendString("This is the second part of the string.\r", Encoding.ASCII);
// Assert
TaskAssert.NotCompleted(result, "After sending second sentence.");
// Act
socket.SendString("\nThis is an extra, third sentence.\r\n", Encoding.ASCII);
// Assert
TaskAssert.ResultEquals(result, "This is the first part of the string. This is the second part of the string.", "After sending data.");
}
public void ScriptInjectionFilterStream_ExceptionOnSubsequentWrite()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
serverSocket.SendString("HTTP/1.1 200 OK\r\n", Encoding.ASCII);
MockScriptInjectionFilterContext filterContext = new MockScriptInjectionFilterContext();
ScriptInjectionFilterStream filterStream = CreateFilterStream(serverSocket, filterContext);
byte[] bytesToSend = Encoding.UTF8.GetBytes("<html><head></head><body></body></html>");
// Act I - Write some bytes
filterStream.Write(bytesToSend, 0, 20);
// Assert
Assert.Contains("<html><head></head><", serverSocket.SentContent);
AssertWithMessage.Equal(0, filterContext.GetResponseBody(Encoding.UTF8).Length, "No content should be sent to the response yet.");
Assert.False(serverSocket.IsClosed, "Server connection should not have been closed.");
// Act II - Attempt to write more bytes
serverSocket.ThrowExceptionOnNextSendAsync();
Task result = filterStream.WriteAsync(bytesToSend, 20, bytesToSend.Length - 20);
// Assert
TaskAssert.Faulted(result, "Exception should have been re-thrown");
Assert.Equal("SendAsync after ThrowExceptionOnNextSendAsync was called.", result.Exception.InnerException.Message);
}
public void SocketReader_ReadBytesIntoResponseHandler_StopsReadingBytesIfCancelled()
{
// Arrange
string stringToSend = "123456789";
byte[] bufferToSend = Encoding.ASCII.GetBytes(stringToSend);
MockSocketAdapter socket = new MockSocketAdapter();
socket.SendBytes(bufferToSend, 0, bufferToSend.Length);
MockResponseHandler handler = new MockResponseHandler(Encoding.ASCII);
CancellationTokenSource cts = new CancellationTokenSource();
SocketReader reader = new SocketReader(socket);
Task <int> task = reader.ReadBytesIntoResponseHandler(bufferToSend.Length + 1, handler.HandlerMethod, cts.Token);
// Act
cts.Cancel();
// Assert
TaskAssert.ResultEquals(task, bufferToSend.Length);
Assert.Equal(stringToSend, handler.Response);
}
public void ScriptInjectionFilterStream_CompletePassthroughProcess()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
MockScriptInjectionFilterContext filterContext = new MockScriptInjectionFilterContext(contentType: "text/css");
ScriptInjectionFilterStream filterStream = CreateFilterStream(serverSocket, filterContext);
byte[] bytesToSend = Encoding.UTF8.GetBytes("body { font-size: xxlarge; } p { background-color: red }");
// Act I - Write some bytes
filterStream.Write(bytesToSend, 0, 20);
// Assert
Assert.Equal("body { font-size: xx", filterContext.GetResponseBody(Encoding.UTF8));
Assert.True(serverSocket.IsClosed, "Server connection should be closed.");
// Act II - Write some more bytes
filterStream.Write(bytesToSend, 20, bytesToSend.Length - 20);
// Assert
Assert.Equal("body { font-size: xxlarge; } p { background-color: red }", filterContext.GetResponseBody(Encoding.UTF8));
// Act III - Wait for complete
Task completeTask = filterStream.FlushAsync();
// Assert
TaskAssert.Completed(completeTask, "Flush should complete immediately, because the filter is not being used.");
}
public void ScriptInjectionFilterStream_BecomesPassthroughOnTimeout()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
MockScriptInjectionFilterContext filterContext = new MockScriptInjectionFilterContext();
ScriptInjectionFilterStream filterStream = CreateFilterStream(serverSocket, filterContext);
byte[] bytesToSend = Encoding.UTF8.GetBytes("<html><head></head><body></body></html>");
// Act I - Send some bytes
Task writeTask = filterStream.WriteAsync(bytesToSend, 0, 20);
// Assert
TaskAssert.NotCompleted(writeTask, "Should be waiting for server to respond");
// Act II - Wait for the request to time out
System.Threading.Thread.Sleep(1100);
// Assert
TaskAssert.Completed(writeTask, "Write should complete when server fails to respond");
Assert.True(serverSocket.IsClosed, "Should become passthrough");
Assert.Equal("<html><head></head><", filterContext.GetResponseBody(Encoding.UTF8));
AssertWithMessage.Equal(true, filterStream.ScriptInjectionTimedOut, "ScriptInjectionTimedOut");
}
public void HttpSocketAdapter_ReadsContentIntoResponseHandler()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
serverSocket.SendString("HTTP/1.1 200 OK\r\n", Encoding.ASCII);
serverSocket.SendString("Content-Length: 40\r\n\r\n", Encoding.ASCII);
serverSocket.SendString("1234567890", Encoding.Unicode);
HttpSocketAdapter clientSocket = new HttpSocketAdapter("GET", new Uri("http://bing.com"), serverSocket);
MockResponseHandler handler = new MockResponseHandler(Encoding.Unicode);
// Act
clientSocket.SetResponseHandler(handler.HandlerMethod);
// Assert
Assert.Equal("1234567890", handler.Response);
// Act
Task responseComplete = clientSocket.WaitForResponseComplete();
// Assert
TaskAssert.NotCompleted(responseComplete, "After sending first chunk of data");
// Act - Send too much data to complete Content-Length
serverSocket.SendString("abcdefghijklmnopqrstuvwxyz", Encoding.Unicode);
// Assert - Only Content-Length was read
Assert.Equal("1234567890abcdefghij", handler.Response);
TaskAssert.Completed(responseComplete, "After sending remaining data");
}
public void SocketReader_ReadBytesIntoResponseHandler_WaitsForData()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
MockResponseHandler handler = new MockResponseHandler(Encoding.Unicode);
SocketReader reader = new SocketReader(socket);
// Act
Task <int> result = reader.ReadBytesIntoResponseHandler(30, handler.HandlerMethod, _dontCancel);
// Assert
TaskAssert.NotCompleted(result, "Before any data sent");
// Act
socket.SendString("This is ", Encoding.Unicode);
// Assert
TaskAssert.NotCompleted(result, "After some data sent");
// Act
socket.SendString("a test. And then some.", Encoding.Unicode);
// Assert
TaskAssert.ResultEquals(result, 30, "After all data sent");
Assert.Equal("This is a test.", handler.Response);
}
public void HttpSocketAdapter_ReadsChunkedContentIntoResponseHandler()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
serverSocket.SendString("HTTP/1.1 200 OK\r\n", Encoding.ASCII);
serverSocket.SendString("Transfer-Encoding: chunked\r\n\r\n", Encoding.ASCII);
HttpSocketAdapter clientSocket = new HttpSocketAdapter("GET", new Uri("http://bing.com"), serverSocket);
MockResponseHandler handler = new MockResponseHandler(Encoding.ASCII);
// Act
clientSocket.SetResponseHandler(handler.HandlerMethod);
// Assert
Assert.Equal("", handler.Response);
// Act
serverSocket.SendString("C\r\nHello, world\r\n", Encoding.ASCII);
// Assert
Assert.Equal("Hello, world", handler.Response);
// Act
Task responseComplete = clientSocket.WaitForResponseComplete();
// Assert
TaskAssert.NotCompleted(responseComplete, "After sending 'Hello, World'");
// Act
serverSocket.SendString("8\r\nwide", Encoding.ASCII);
// Assert
Assert.Equal("Hello, worldwide", handler.Response);
TaskAssert.NotCompleted(responseComplete, "After sending 'wide'");
// Act
serverSocket.SendString("!!\r\n", Encoding.ASCII);
// Assert
Assert.Equal("Hello, worldwide!!\r\n", handler.Response);
TaskAssert.NotCompleted(responseComplete, "after sending '!!\r\n'");
// Act
serverSocket.SendString("\r\n", Encoding.ASCII);
// Assert
Assert.Equal("Hello, worldwide!!\r\n", handler.Response);
TaskAssert.NotCompleted(responseComplete, "after sending '\r\n'");
// Act
serverSocket.SendString("0\r\n", Encoding.ASCII);
// Assert
Assert.Equal("Hello, worldwide!!\r\n", handler.Response);
TaskAssert.Completed(responseComplete, "after completing the response");
}
public void SocketReader_ReadLine_IgnoresUnmatchedLineFeed()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
socket.SendString("This is a test\rof an unmatched \n\r\n", Encoding.ASCII);
SocketReader reader = new SocketReader(socket);
// Act
Task <string> result = reader.ReadLine(_dontCancel);
// Assert
TaskAssert.ResultEquals(result, "This is a test\rof an unmatched \n");
}
public void SocketReader_ReadLine_ReadsOneLine()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
socket.SendString("This is a test.\r\nThis is left out.\r\n", Encoding.ASCII);
SocketReader reader = new SocketReader(socket);
// Act
Task <string> result = reader.ReadLine(_dontCancel);
// Assert
TaskAssert.ResultEquals(result, "This is a test.");
}
public void HttpSocketAdapter_GetResponseStatusCode_MalformedStatusLine()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
serverSocket.SendString("Hello\r\n", Encoding.ASCII);
HttpSocketAdapter clientSocket = new HttpSocketAdapter("GET", new Uri("http://bing.com"), serverSocket);
// Act
Task <int> result = clientSocket.GetResponseStatusCode();
// Assert
TaskAssert.ResultEquals(result, 500);
}
public void SocketReader_ReadChar_ReturnsZeroIfCancelled()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
CancellationTokenSource cts = new CancellationTokenSource();
SocketReader reader = new SocketReader(socket);
Task <char> task = reader.ReadChar(cts.Token);
// Act
cts.Cancel();
// Assert
TaskAssert.ResultEquals(task, '\0');
}
public void SocketReader_ReadLine_ReturnsEmptyStringWhenCancelled()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
CancellationTokenSource cts = new CancellationTokenSource();
SocketReader reader = new SocketReader(socket);
Task <string> lineResult = reader.ReadLine(cts.Token);
// Act
cts.Cancel();
// Assert
TaskAssert.ResultEquals(lineResult, String.Empty, "Task should return empty string when canceled.");
}
public void HttpSocketAdapter_WritesRequestLineAndHeaders()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
HttpSocketAdapter clientSocket = new HttpSocketAdapter("GET", new Uri("http://localhost:1234/Hello.aspx?Name=%22Value%22#Fragment"), serverSocket);
// Act
clientSocket.CompleteRequest();
// Assert
Assert.StartsWith("GET /Hello.aspx?Name=%22Value%22#Fragment HTTP/1.1\r\n", serverSocket.SentContent);
Assert.Contains("Host: localhost:1234\r\n", serverSocket.SentContent);
Assert.Contains("Transfer-Encoding: chunked\r\n", serverSocket.SentContent);
Assert.EndsWith("\r\n\r\n0\r\n\r\n", serverSocket.SentContent);
}
public void SocketReader_ReadChar_KeepsWaitingIfNotEnoughDataIsReturned()
{
// Arrange
byte[] sendBuffer = Encoding.UTF32.GetBytes("ΨΣ"); // Greek Psi, Sigma
MockSocketAdapter socket = new MockSocketAdapter();
SocketReader reader = new SocketReader(socket);
reader.SetEncoding(Encoding.UTF32);
// Act
Task <char> result = reader.ReadChar(_dontCancel); // Try to read first character
// Assert
TaskAssert.NotCompleted(result, "Before sending any bytes");
// Act
socket.SendBytes(sendBuffer, 0, 1); // Send 1 byte
// Assert
TaskAssert.NotCompleted(result, "After sending 1 byte");
// Act
socket.SendBytes(sendBuffer, 1, 2); // Send 2 more bytes
// Assert
TaskAssert.NotCompleted(result, "After sending 2 more bytes");
// Act
socket.SendBytes(sendBuffer, 3, 2); // Send 2 more bytes
// Assert
TaskAssert.ResultEquals(result, 'Ψ', "After sending all bytes of first character.");
// Act
result = reader.ReadChar(_dontCancel); // Try to read second character
// Assert
TaskAssert.NotCompleted(result, "Before sending remaining bytes");
// Act
socket.SendBytes(sendBuffer, 5, 3); // Send remaining 3 bytes
// Assert
TaskAssert.ResultEquals(result, 'Σ', "After sending remaining bytes");
}
public void ScriptInjectionFilterStream_CompleteFilterProcess()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
MockScriptInjectionFilterContext filterContext = new MockScriptInjectionFilterContext();
ScriptInjectionFilterStream filterStream = CreateFilterStream(serverSocket, filterContext);
byte[] bytesToSend = Encoding.UTF8.GetBytes("<html><head></head><body></body></html>");
// Act I - Write some bytes
Task writeTask = filterStream.WriteAsync(bytesToSend, 0, 20);
// Assert
TaskAssert.NotCompleted(writeTask, "Write task should not complete until a successful response comes from the server.");
// Act Ia - Response from the server
serverSocket.SendString("HTTP/1.1 200 OK\r\n", Encoding.ASCII);
// Assert
TaskAssert.Completed(writeTask, "The write task should complete after we receive the response line from the server.");
Assert.Contains("<html><head></head><", serverSocket.SentContent);
AssertWithMessage.Equal(0, filterContext.GetResponseBody(Encoding.UTF8).Length, "No content should be sent to the response yet.");
Assert.False(serverSocket.IsClosed, "Server connection should not have been closed.");
// Act II - Write some more bytes
filterStream.Write(bytesToSend, 20, bytesToSend.Length - 20);
// Assert
Assert.Contains("body></body></html>", serverSocket.SentContent);
AssertWithMessage.Equal(0, filterContext.GetResponseBody(Encoding.UTF8).Length, "No content should be sent to the response yet.");
Assert.False(serverSocket.IsClosed, "Server connection should not have been closed.");
// Act III - Wait for complete
Task completeTask = filterStream.FlushAsync();
// Assert
TaskAssert.NotCompleted(completeTask, "Before response from server.");
// Act IV - Send response from server
serverSocket.SendString("Content-Length: 17\r\n\r\nXFiltered content", Encoding.ASCII);
// Assert
Assert.Equal("Filtered content", filterContext.GetResponseBody(Encoding.ASCII));
TaskAssert.Completed(completeTask, "After response from server.");
Assert.False(filterStream.ScriptInjectionTimedOut);
}
public void SocketReader_ReadChar_ReadsOneCharacter()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
socket.SendString("ab", Encoding.Unicode);
SocketReader reader = new SocketReader(socket);
reader.SetEncoding(Encoding.Unicode);
// Act
Task <char> result = reader.ReadChar(_dontCancel);
// Assert
TaskAssert.ResultEquals(result, 'a');
}
public void ScriptInjectionFilterStream_PassesCssDirectlyToOutput()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
MockScriptInjectionFilterContext filterContext = new MockScriptInjectionFilterContext();
ScriptInjectionFilterStream filterStream = CreateFilterStream(serverSocket, filterContext);
byte[] bytesToSend = Encoding.UTF8.GetBytes("body { font-weight: bold; }");
// Act
filterStream.Write(bytesToSend, 0, bytesToSend.Length);
// Assert
AssertWithMessage.Equal(0, serverSocket.SentContent.Length, "Non-HTML content shouldn't be sent to the filter.");
Assert.True(serverSocket.IsClosed, "Connection to VS was not closed when non-HTML content was detected.");
Assert.Equal("body { font-weight: bold; }", filterContext.GetResponseBody(Encoding.UTF8));
}
public void HttpSocketAdapter_AddsCustomHeaders()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
HttpSocketAdapter clientSocket = new HttpSocketAdapter("POST", new Uri("http://bing.com"), serverSocket);
// Act
clientSocket.AddRequestHeader("Content-Encoding", "UTF-16");
clientSocket.CompleteRequest();
// Assert
Assert.StartsWith("POST / HTTP/1.1\r\n", serverSocket.SentContent);
Assert.Contains("Host: bing.com:80\r\n", serverSocket.SentContent);
Assert.Contains("Transfer-Encoding: chunked\r\n", serverSocket.SentContent);
Assert.Contains("Content-Encoding: UTF-16\r\n", serverSocket.SentContent);
Assert.EndsWith("\r\n\r\n0\r\n\r\n", serverSocket.SentContent);
}
public void HttpSocketAdapter_GetResponseStatusCode_ReturnsStatusCode()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
HttpSocketAdapter clientSocket = new HttpSocketAdapter("GET", new Uri("http://bing.com"), serverSocket);
// Act
Task <int> result = clientSocket.GetResponseStatusCode();
// Assert
TaskAssert.NotCompleted(result, "Before status line was sent.");
// Act
serverSocket.SendString("HTTP/1.1 200 OK\r\n", Encoding.ASCII);
// Assert
TaskAssert.ResultEquals(result, 200, "After status line was sent.");
}
public void SocketReader_ReadLine_WaitsForDataReadingOneLine()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
SocketReader reader = new SocketReader(socket);
// Act
Task <string> result = reader.ReadLine(_dontCancel);
// Assert
TaskAssert.NotCompleted(result, "Before sending data.");
// Act
socket.SendString("This is a test.\r\n", Encoding.ASCII);
// Assert
TaskAssert.ResultEquals(result, "This is a test.", "After sending data.");
}
public void SocketReader_ReadLine_ReadsLineLongerThanBuffer()
{
// Arrange
string lineToSend = new String('Σ', count: 20000);
MockSocketAdapter socket = new MockSocketAdapter();
socket.SendString(lineToSend + "\r\n", Encoding.Unicode);
SocketReader reader = new SocketReader(socket);
reader.SetEncoding(Encoding.Unicode);
// Act
Task <string> result = reader.ReadLine(_dontCancel);
// Assert
TaskAssert.ResultEquals(result, lineToSend);
}
public void HttpSocketAdapter_ThrowsExceptionForMalformedChunkedResponse()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
serverSocket.SendString("HTTP/1.1 200 OK\r\n", Encoding.ASCII);
serverSocket.SendString("Transfer-Encoding: chunked\r\n\r\n", Encoding.ASCII);
HttpSocketAdapter clientSocket = new HttpSocketAdapter("GET", new Uri("http://bing.com"), serverSocket);
MockResponseHandler handler = new MockResponseHandler(Encoding.ASCII);
clientSocket.SetResponseHandler(handler.HandlerMethod);
// Act
serverSocket.SendString("Hi!\r\n", Encoding.ASCII);
// Assert
TaskAssert.Faulted(clientSocket.WaitForResponseComplete(), "ResponseReader should throw an exception if the response is malformed. Otherwise, the response will be blank and there will be nothing pointing to why it happened.");
}
public void ScriptInjectionFilterStream_ExceptionOnFirstWrite()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
MockScriptInjectionFilterContext filterContext = new MockScriptInjectionFilterContext();
ScriptInjectionFilterStream filterStream = CreateFilterStream(serverSocket, filterContext);
byte[] bytesToSend = Encoding.UTF8.GetBytes("<html><head></head><body></body></html>");
// Act - Attempt to write some bytes
serverSocket.ThrowExceptionOnNextSendAsync();
Task writeTask = filterStream.WriteAsync(bytesToSend, 0, 20);
// Assert
TaskAssert.NotFaulted(writeTask, "Task should not be faulted. Filter should switch to passthrough mode.");
Assert.Equal("<html><head></head><", filterContext.GetResponseBody(Encoding.UTF8));
Assert.True(serverSocket.IsClosed, "Server connection should be closed.");
}
public void ScriptInjectionFilterStream_ChecksResponseContentType()
{
// Arrange
MockSocketAdapter serverSocket = new MockSocketAdapter();
serverSocket.SendString("HTTP/1.1 200 OK\r\n", Encoding.ASCII);
MockScriptInjectionFilterContext filterContext = new MockScriptInjectionFilterContext(contentType: "text/javascript");
ScriptInjectionFilterStream filterStream = CreateFilterStream(serverSocket, filterContext);
byte[] bytesToSend = Encoding.UTF8.GetBytes("var myhtml = \"<html></html>\";");
// Act
filterStream.Write(bytesToSend, 0, bytesToSend.Length);
// Assert
AssertWithMessage.Equal(0, serverSocket.SentContent.Length, "Non-HTML content shouldn't be sent to the filter.");
Assert.True(serverSocket.IsClosed, "Connection to VS was not closed when non-HTML content was detected.");
Assert.Equal("var myhtml = \"<html></html>\";", filterContext.GetResponseBody(Encoding.UTF8));
}
public void SocketReader_ReadChar_DoesNotWaitForDataReadingSecondCharacter()
{
// Arrange
MockSocketAdapter socket = new MockSocketAdapter();
socket.SendString("ab", Encoding.UTF8);
SocketReader reader = new SocketReader(socket);
reader.SetEncoding(Encoding.UTF8);
Task <char> result1 = reader.ReadChar(_dontCancel);
TaskAssert.ResultEquals(result1, 'a', "SocketReader did not read the first character in the buffer.");
// Act
Task <char> result2 = reader.ReadChar(_dontCancel);
// Assert
TaskAssert.ResultEquals(result2, 'b');
}
public void SocketReader_ReadBytesIntoResponseHandler_ContinuesWaitingForBytes()
{
// Arrange
string stringToSend = "123456789";
byte[] bufferToSend = Encoding.ASCII.GetBytes(stringToSend);
MockSocketAdapter socket = new MockSocketAdapter();
socket.SendBytes(bufferToSend, 0, bufferToSend.Length);
MockResponseHandler handler = new MockResponseHandler(Encoding.ASCII);
SocketReader reader = new SocketReader(socket);
// Act
Task <int> task = reader.ReadBytesIntoResponseHandler(bufferToSend.Length + 1, handler.HandlerMethod, _dontCancel);
// Assert
TaskAssert.NotCompleted(task);
}
