public void Loop_CustomInterceptor()
{
//Arrange
const string initialValue = "33";
var maxInt = int.MaxValue.ToString(CultureInfo.InvariantCulture);
var initialValues = new List <string> {
"1", "2", "3", "4", maxInt, "6"
};
var request = new RequestMock(initialValue, RequestStepMock.Step1, initialValues, new TimeSpan(0, 0, 3));
var customErrorHandler = new SubErrorHandlerMock();
var interceptor = new SubInterceptorMock();
const RequestStepMock passedSteps =
RequestStepMock.Step1 |
RequestStepMock.Step2 |
RequestStepMock.Step3 |
RequestStepMock.Step4 |
RequestStepMock.Step5;
//Act
RequestPipelineMock.ExecuteLoop(request, new TimeSpan(0, 0, 2), null, null, customErrorHandler, interceptor);
//Assert
Assert.IsTrue(request.Done, "Заявка должна была дойти до конца.");
Assert.IsFalse(interceptor.DefaultMethod, "Должен был отработать кастомный интерсептор.");
Assert.AreEqual(interceptor.LastStep, passedSteps, "Должны перехватываться все предыдущие шаги в цепочке.");
}
public void InvokeChain_CustomErrorHandler()
{
//Arrange
var initialValue = int.MaxValue.ToString(CultureInfo.InvariantCulture);
var request = new RequestMock(initialValue, RequestStepMock.Step1);
var defaultHandler = new ErrorHandlerMock();
var customHandler = new ErrorHandlerMock();
//Act
RequestPipelineMock.ExecuteChain(
request,
new TimeSpan(0, 0, 2),
TimeoutLifetime.Step,
defaultHandler,
customErrorHandler: customHandler);
//Assert
Assert.IsFalse(request.Done, "Цепочка вызовов не должна была дойти до конца.");
Assert.AreEqual(request.StrValue, initialValue, "Инициализация не выполнилась.");
Assert.IsNull(defaultHandler.Error, "Обработчик по умолчанию не должен был отработать.");
Assert.IsNotNull(customHandler.Error, "Кастомный обработчик отработал неправильно.");
Assert.IsTrue(customHandler.Error is OverflowException, "IStepExecutor должен возвращать исходную ошибку.");
Assert.IsTrue(customHandler.Error.Message == "Arithmetic operation resulted in an overflow.");
}
public void InvokeChain_Continue()
{
//Arrange
const string initialValue = "11";
var request = new RequestMock(initialValue, RequestStepMock.Step3)
{
Value = 6
};
var customHandler = new ErrorHandlerMock();
var interceptor = new InterceptorMock();
const RequestStepMock passedSteps =
RequestStepMock.Step3 |
RequestStepMock.Step4 |
RequestStepMock.Done;
//Act
RequestPipelineMock.ExecuteChain(request, new TimeSpan(0, 60, 1), TimeoutLifetime.Step,
null, null, customHandler, interceptor);
//Assert
Assert.IsNull(customHandler.Error, "Ошибок быть не должно.");
Assert.IsFalse(interceptor.DefaultMethod, "Должен был отработать кастомный интерсептор.");
Assert.IsTrue(request.Default == initialValue, "Заявка должна быть правильно прионициализированна.");
Assert.IsTrue(request.StrValue.IsNullOrEmpty(), "Первый шаг не должен был пройти");
Assert.IsTrue(request.Value == 12, "Неправильный результат заявки.");
Assert.AreEqual(interceptor.LastStep, passedSteps, "Должны перехватываться все предыдущие шаги в цепочке.");
}
public void InvokeChain()
{
//Arrange
var request = new RequestMock("3", RequestStepMock.Step1);
//Act
RequestPipelineMock.ExecuteChain(request, new TimeSpan(0, 0, 2), TimeoutLifetime.Step);
//Assert
Assert.IsTrue(request.Done, "Цепочка вызовов не дошла до конца.");
Assert.AreEqual(request.StrValue, "3", "Инициализация не выполнилась.");
Assert.AreEqual(request.Value, 6, "Парсинг или умножение прошло не по плану");
}
public void InvokeChain_Timeout()
{
//Arrange
const string initialValue = "33";
var request = new RequestMock(initialValue, RequestStepMock.Step1, null, new TimeSpan(0, 0, 2));
var customHandler = new ErrorHandlerMock();
//Act
RequestPipelineMock.ExecuteChain(request, new TimeSpan(0, 0, 1), TimeoutLifetime.Step, customErrorHandler: customHandler);
//Assert
Assert.IsFalse(request.Done, "Цепочка вызовов не должна была дойти до конца.");
Assert.IsNotNull(customHandler.Error, "Кастомный обработчик отработал неправильно.");
Assert.IsTrue(customHandler.Error is OperationCanceledException, "IStepExecutor должен возвращать исходную ошибку.");
Assert.IsTrue(customHandler.Error.Message == "The operation was canceled.");
}
public void ExecuteSubFunction_WithPostRequest()
{
PrivateInvoke.SetNonPublicField(FunctionState, "_postBackID", 100);
RequestMock.Stub(stub => stub.HttpMethod).Return("POST").Repeat.Any();
using (MockRepository.Ordered())
{
ExecutionStateContextMock.Expect(mock => mock.SetReturnState(SubFunction, false, null));
ExecutionStateContextMock.Expect(mock => mock.SetExecutionState(NullExecutionState.Null));
}
MockRepository.ReplayAll();
_executionState.ExecuteSubFunction(WxeContext);
MockRepository.VerifyAll();
}
public void Loop_AllOk()
{
//Arrange
const string initialValue = "33";
var initialValues = new List <string> {
"1", "2", "9", "4", "5", "6"
};
var request = new RequestMock(initialValue, RequestStepMock.Step1, initialValues, new TimeSpan(0, 0, 2));
//Act
RequestPipelineMock.ExecuteLoop(request, new TimeSpan(0, 0, 3));
//Assert
Assert.IsTrue(request.Done, "Заявка должна была дойти до конца.");
Assert.IsFalse(request.Strings == null || request.Strings.Count < 1, "Инициализация строк прошла неудачно.");
Assert.IsFalse(request.Values == null || request.Values.Count < 1, "Цикл не прошел совсем.");
Assert.IsTrue(request.Strings.Count == request.Values.Count, "Количество строк и значений различаются.");
}
public void InvokeChain_DefaultErrorHandler()
{
//Arrange
var initialValue = int.MaxValue.ToString(CultureInfo.InvariantCulture);
var request = new RequestMock(initialValue, RequestStepMock.Step1);
var handler = new ErrorHandlerMock();
//Act
RequestPipelineMock.ExecuteChain(request, new TimeSpan(0, 0, 2), TimeoutLifetime.Step, handler);
//Assert
Assert.IsFalse(request.Done, "Цепочка вызовов не должна была дойти до конца.");
Assert.AreEqual(request.StrValue, initialValue, "Инициализация не выполнилась.");
Assert.IsNull(request.Error, "Кастомный обработчик не должен был обработать исключение.");
Assert.IsNotNull(handler.Error, "Исключение перехватить не удалось.");
Assert.IsTrue(handler.Error is OverflowException, "Исполнитель должен возвращать исходную ошибку.");
Assert.IsTrue(handler.Error.Message == "Arithmetic operation resulted in an overflow.");
}
public void ExecuteSubFunction_WithGetRequest()
{
PrivateInvoke.SetNonPublicField(FunctionState, "_postBackID", 100);
RequestMock.Stub(stub => stub.HttpMethod).Return("GET").Repeat.Any();
using (MockRepository.Ordered())
{
ExecutionStateContextMock.Expect(mock => mock.SetReturnState(SubFunction, true, PostBackCollection));
ExecutionStateContextMock.Expect(mock => mock.SetExecutionState(NullExecutionState.Null));
}
MockRepository.ReplayAll();
_executionState.ExecuteSubFunction(WxeContext);
MockRepository.VerifyAll();
Assert.That(PostBackCollection[WxePageInfo.PostBackSequenceNumberID], Is.EqualTo("100"));
}
public override void SetUp ()
{
base.SetUp();
UrlMappingConfiguration.Current.Mappings.Add (new UrlMappingEntry (RootFunction.GetType(), "~/root.wxe"));
UrlMappingConfiguration.Current.Mappings.Add (new UrlMappingEntry (SubFunction.GetType(), "~/sub.wxe"));
Uri uri = new Uri ("http://localhost/root.wxe");
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("~/sub.wxe")).Return ("/session/sub.wxe").Repeat.Any();
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("/session/sub.wxe")).Return ("/session/sub.wxe").Repeat.Any ();
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("~/root.wxe")).Return ("/session/root.wxe").Repeat.Any ();
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("/root.wxe")).Return ("/session/root.wxe").Repeat.Any();
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("/session/root.wxe")).Return ("/session/root.wxe").Repeat.Any();
ResponseMock.Stub (stub => stub.ContentEncoding).Return (Encoding.Default).Repeat.Any();
RequestMock.Stub (stub => stub.Url).Return (uri).Repeat.Any();
RequestMock.Stub (stub => stub.ContentEncoding).Return (Encoding.Default).Repeat.Any();
}
public void InvokeChain_DefaultInterceptor()
{
//Arrange
const string initialValue = "11";
var request = new RequestMock(initialValue, RequestStepMock.Step1, null, new TimeSpan(0, 0, 2));
var customHandler = new ErrorHandlerMock();
var interceptor = new InterceptorMock();
const RequestStepMock passedSteps =
RequestStepMock.Step1 |
RequestStepMock.Step2 |
RequestStepMock.Step3 |
RequestStepMock.Step4;
//Act
RequestPipelineMock.ExecuteChain(request, new TimeSpan(0, 0, 1), TimeoutLifetime.Step,
null, interceptor, customHandler);
//Assert
Assert.IsNotNull(customHandler.Error, "Кастомный обработчик отработал неправильно.");
Assert.IsTrue(customHandler.Error is OperationCanceledException, "IStepExecutor должен возвращать исходную ошибку.");
Assert.IsFalse(interceptor.DefaultMethod, "Должен был отработать кастомный интерсептор.");
Assert.AreEqual(interceptor.LastStep, passedSteps, "Должны перехватываться все предыдущие шаги в цепочке.");
}
public void Loop_CustomErrorHandler()
{
//Arrange
const string initialValue = "33";
var maxInt = int.MaxValue.ToString(CultureInfo.InvariantCulture);
var initialValues = new List <string> {
"1", "2", "3", "4", maxInt, "6"
};
var request = new RequestMock(initialValue, RequestStepMock.Step1, initialValues, new TimeSpan(0, 0, 3));
var customErrorHandler = new SubErrorHandlerMock();
//Act
RequestPipelineMock.ExecuteLoop(request, new TimeSpan(0, 0, 2), null, customErrorHandler: customErrorHandler);
//Assert
Assert.IsTrue(request.Done, "Заявка должна была дойти до конца.");
Assert.IsFalse(request.Strings == null || request.Strings.Count < 1, "Инициализация строк прошла неудачно.");
Assert.IsFalse(request.Values == null || request.Values.Count < 1, "Цикл не прошел совсем.");
Assert.IsTrue(request.Values.Count == request.Strings.Count - 2, "При возникновении ошибки цикл должен пережодить на следующую итерацию.");
Assert.IsTrue(customErrorHandler.Errors.Count == 2, "Цикл должен обрабатывать ошибки каждой итерации.");
Assert.IsTrue(customErrorHandler.Errors[0] is OperationCanceledException, "Сначала должен быть таймаут");
Assert.IsTrue(customErrorHandler.Errors[1] is OverflowException, "Потом должено быть переполнение");
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var httpResponse = new HttpResponseMessage(this.serverRequestsState.DefaultRespondStatusCode);
string requestContent = await request.Content.ReadAsStringAsync();
RequestMock requestMock = this.FindExpectationForRequest(request, requestContent); // ?? this.FindBehaviorForRequest(request, requestContent);
if (requestMock != null)
{
if (requestMock.IsRequestTimedOut)
{
Thread.Sleep(120000);
return(httpResponse);
}
BuildResponseFromRequestMock(requestMock, request, ref httpResponse);
return(httpResponse);
}
this.AddUnexpectedRequest(request);
return(httpResponse);
}
public void SetUp()
{
responseMock = new ResponseMock();
requestMock = new RequestMock(responseMock);
requestFactoryMock = new RequestFactoryMock(requestMock);
}
public static RequestMock ArrangePut(this RequestMock requestMock, Action <IRequestBuilder, IResponseBuilder> configure)
{
return(requestMock.Arrange("PUT", configure));
}
////private RequestMock FindBehaviorForRequest(HttpRequestMessage request, string requestContent)
////{
//// foreach (var behavior in this.serverRequestsState.RequestBehaviors)
//// {
//// if (!IsMockForRequest(behavior, request, requestContent))
//// {
//// continue;
//// }
//// behavior.IncrementRequestMockCall();
//// return behavior;
//// }
//// return null;
////}
private static void BuildResponseFromRequestMock(RequestMock mock, HttpRequestMessage httpRequest, ref HttpResponseMessage httpResponse)
{
if (mock.Response.ResponseBuilder != null)
{
httpResponse = mock.Response.ResponseBuilder(httpRequest);
return;
}
httpResponse.StatusCode = mock.Response.ResponseStatusCode;
if (mock.Response.ResponseContent != null)
{
// TODO: In the future it must return any content type.
if (Helper.IsJsonRequest(mock.Response.ResponseContentType))
{
string responseContent;
if (mock.Response.ResponseContent is string)
{
responseContent = ((string)mock.Response.ResponseContent);
}
else
{
responseContent = JsonConvert.SerializeObject(mock.Response.ResponseContent);
}
httpResponse.Content = new StringContent(responseContent, Encoding.UTF8, ConvertFromHContentTypeToString(HttpRequestContentType.Json));
}
else if (Helper.IsXmlRequest(mock.Response.ResponseContentType))
{
// TODO: Shit code. It must be improved. At this moment, it works but it's a shit.
// ----------------------------------------------------------------------------------------------------------------------
string responseContent;
if (mock.Response.ResponseContent is string)
{
responseContent = ((string)mock.Response.ResponseContent);
}
else
{
responseContent = JsonConvert.SerializeObject(mock.Response.ResponseContent);
responseContent = JsonConvert.DeserializeXNode(responseContent, "Root").ToString();
}
httpResponse.Content = new StringContent(responseContent, Encoding.UTF8, ConvertFromHContentTypeToString(HttpRequestContentType.Xml));
// ----------------------------------------------------------------------------------------------------------------------
}
else
{
// TODO: Throw an exception???
}
}
else
{
httpResponse.Content = new ByteArrayContent(new byte[0]);
}
foreach (var responseHeader in mock.Response.ResponseHeaders)
{
if (httpResponse.Headers.TryAddWithoutValidation(responseHeader.Key, responseHeader.Value) == false)
{
if (httpResponse.Content != null && httpResponse.Content.Headers != null)
{
httpResponse.Content.Headers.TryAddWithoutValidation(responseHeader.Key, responseHeader.Value);
}
}
}
}
public void MemcacheSocketTest([Values(0, 2, 10)] int maxByteSentByServer)
{
using (var serverMock = new ServerMock())
{
var endPoint = serverMock.ListenEndPoint;
serverMock.MaxSent = maxByteSentByServer;
// random header
var requestHeader = new MemcacheRequestHeader
{
Cas = 1,
DataType = 2,
ExtraLength = 5,
KeyLength = 3,
Opaque = 42,
Opcode = Opcode.Increment,
TotalBodyLength = 12,
};
// body with the size defined in the header
var requestBody = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
// build the request buffer
var requestBuffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(requestBuffer);
Array.Copy(requestBody, 0, requestBuffer, MemcacheRequestHeader.Size, requestHeader.TotalBodyLength);
// build the response header
var responseHeader = new MemcacheResponseHeader
{
Cas = 8,
DataType = 12,
ExtraLength = 3,
KeyLength = 0,
// must be the same or it will crash : TODO add a test to ensure we detect this fail
Opaque = requestHeader.Opaque,
Status = Status.UnknownCommand,
Opcode = Opcode.Prepend,
TotalBodyLength = 15,
};
// body with the size defined in the header
var responseExtra = new byte[] { 1, 2, 3 };
var responseMessage = new byte[] { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
// build the request buffer
var responseBody = new byte[responseHeader.TotalBodyLength];
Array.Copy(responseExtra, 0, responseBody, 0, responseHeader.ExtraLength);
Array.Copy(responseMessage, 0, responseBody, responseHeader.ExtraLength, responseHeader.TotalBodyLength - responseHeader.ExtraLength);
// set the things to answer to the server
serverMock.ResponseBody = responseBody;
responseHeader.ToData(serverMock.ResponseHeader);
var request = new RequestMock
{
QueryBuffer = requestBuffer,
RequestId = requestHeader.Opaque
/*ResponseHeader = responseHeader,
* Message = responseMessage,
* Extra = responseExtra,*/
};
using (var transport = new MemcacheTransport(endPoint, new MemcacheClientConfiguration(), _ => { }, _ => { }, false, null))
{
Assert.IsTrue(transport.TrySend(request));
Assert.IsTrue(request.Mutex.Wait(TimeSpan.FromSeconds(10)), "The request has not been completed on less than 10 sec");
// and now, assert that we sent what we had to send and we received what the server sent
Assert.AreEqual(requestHeader, serverMock.LastReceivedHeader, "Sent header differ from header received by the server");
CollectionAssert.AreEqual(requestBody, serverMock.LastReceivedBody, "Sent body is different than received by the server");
Assert.AreEqual(responseHeader, request.ResponseHeader, "Received header differ from header sent by the server");
CollectionAssert.AreEqual(responseExtra, request.Extra, "Received extra is different than sent by the server");
CollectionAssert.AreEqual(responseMessage, request.Message, "Received message is different than sent by the server");
}
}
}
public RequestFactoryMock(RequestMock requestMock)
{
this.requestMock = requestMock;
}
public void SetUp()
{
responseMock = new ResponseMock();
requestMock = new RequestMock(responseMock);
requestFactoryMock = new RequestFactoryMock(requestMock);
}
public static RequestMock ArrangeAny(this RequestMock requestMock, Action <IRequestBuilder, IResponseBuilder> configure)
{
return(requestMock.Arrange(RequestMock.AnyMethod, configure));
}
public static RequestMock ArrangeDelete(this RequestMock requestMock, Action <IRequestBuilder, IResponseBuilder> configure)
{
return(requestMock.Arrange("DELETE", configure));
}
public RequestFactoryMock(RequestMock requestMock)
{
this.requestMock = requestMock;
}
private static bool IsMockForRequest(RequestMock mock, HttpRequestMessage request, string requestContent)
{
// It checks if the request method is the expected.
if (mock.RequestHttpMethod.ToString() != request.Method.Method)
{
return(false);
}
// It validates the URI.
if (mock.IsRequestUriARegex)
{
if (!mock.RequestRegex.IsMatch(request.RequestUri.PathAndQuery))
{
return(false);
}
}
else
{
// https://msdn.microsoft.com/en-us/library/system.uri.pathandquery(v=vs.110).aspx
var comparisonResult = Uri.Compare(
mock.RequestUri,
request.RequestUri,
UriComponents.PathAndQuery,
UriFormat.SafeUnescaped,
StringComparison.OrdinalIgnoreCase);
if (comparisonResult != 0)
{
return(false);
}
// https://msdn.microsoft.com/en-us/library/system.uri.userinfo(v=vs.110).aspx
comparisonResult = Uri.Compare(
mock.RequestUri,
request.RequestUri,
UriComponents.UserInfo,
UriFormat.SafeUnescaped,
StringComparison.OrdinalIgnoreCase);
if (comparisonResult != 0)
{
return(false);
}
// https://msdn.microsoft.com/en-us/library/system.uri.fragment(v=vs.110).aspx
comparisonResult = Uri.Compare(
mock.RequestUri,
request.RequestUri,
UriComponents.Fragment,
UriFormat.SafeUnescaped,
StringComparison.OrdinalIgnoreCase);
if (comparisonResult != 0)
{
return(false);
}
}
// It validates the request headers.
foreach (var expectedHeader in mock.ExpectedRequestHeaders)
{
IEnumerable <string> headerValues;
if (request.Headers.TryGetValues(expectedHeader.Key, out headerValues) || request.Content.Headers.TryGetValues(expectedHeader.Key, out headerValues))
{
if (headerValues.Contains(expectedHeader.Value))
{
continue;
}
}
return(false);
}
// It validates the request content type.
if (string.IsNullOrWhiteSpace(mock.ExpectedRequestContentType) == false)
{
if (request.Content.Headers.ContentType == null)
{
return(false);
}
var expectedContentTypes = mock.ExpectedRequestContentType.Split(',');
if (!expectedContentTypes.Contains(request.Content.Headers.ContentType.ToString()))
{
return(false);
}
////if (!request.Content.Headers.ContentType.Equals(new MediaTypeHeaderValue(mock.ExpectedRequestContentType)))
////{
//// return false;
////}
}
// It validates the expected request content.
// TODO: At this moment, it only compares JSON requests, in the future, it should be able to compare XML, FormUrlEncode and Text requests.
if (mock.ExpectedRequestContent != null)
{
if (string.IsNullOrWhiteSpace(requestContent))
{
return(false);
}
if (Helper.IsJsonRequest(request.Content.Headers.ContentType.ToString()))
{
var requestJson = JToken.Parse(requestContent);
JToken expectedJson;
if (mock.ExpectedRequestContent is string)
{
expectedJson = JToken.Parse(((string)mock.ExpectedRequestContent));
}
else
{
expectedJson = JToken.FromObject(mock.ExpectedRequestContent);
}
if (!JToken.DeepEquals(requestJson, expectedJson))
{
return(false);
}
}
else if (Helper.IsXmlRequest(request.Content.Headers.ContentType.ToString()))
{
// TODO: Shit code. It must be improved. At this moment, it works but it's a shit.
// ----------------------------------------------------------------------------------------------------------------------
JToken expectedJson;
if (mock.ExpectedRequestContent is string)
{
var xmlContent = XDocument.Parse((string)mock.ExpectedRequestContent);
expectedJson = JToken.Parse(JsonConvert.SerializeXNode(xmlContent.Root)).First.First;
}
else
{
var xmlContent = JsonConvert.DeserializeXNode(JsonConvert.SerializeObject(mock.ExpectedRequestContent), "Root");
expectedJson = JToken.Parse(JsonConvert.SerializeXNode(xmlContent.Root)).First.First;
}
var requestJson = JToken.Parse(JsonConvert.SerializeXNode(XDocument.Parse(requestContent))).First.First;
if (!JToken.DeepEquals(requestJson, expectedJson))
{
return(false);
}
// ----------------------------------------------------------------------------------------------------------------------
}
else
{
if (mock.ExpectedRequestContent is string)
{
if (requestContent != mock.ExpectedRequestContent.ToString())
{
return(false);
}
}
// TODO: Throw an exception???
}
////case HContentType.FormUrlEncoded:
//// {
//// // TODO: Shit code. It must be improved. At this moment, it works but it's a shit.
//// // ----------------------------------------------------------------------------------------------------------------------
//// var urlEncodedContent = request.Content.ReadAsFormDataAsync().Result;
//// for (int i = 0; i < urlEncodedContent.Count; i++)
//// {
//// }
//// var json = JToken.Parse(JsonConvert.SerializeObject(urlEncodedContent));
//// break;
//// // ----------------------------------------------------------------------------------------------------------------------
//// }
}
// It executes the custom request validator configured by the user.
if (mock.RequestValidator != null && !mock.RequestValidator(request))
{
return(false);
}
return(true);
}
