public void TestIsMatchWithContentPattern(bool isMatchResult)
{
var contnetPatternMock = NewMock <IHttpRequestContentPattern>();
const string method = "post";
const string path = "/";
var contentBytes = new byte[0];
const string contentType = "application/json";
contnetPatternMock.Setup(x => x.IsMatch(contentBytes, contentType)).Returns(isMatchResult);
var httpRequestMock = new HttpRequestMock
{
Method = MethodPattern.Standart(method),
Path = PathPattern.Smart(path),
Content = contnetPatternMock.Object,
Query = QueryPattern.Any(),
Headers = HeadersPattern.Any()
};
var httpRequestPattern = new HttpRequestPattern(httpRequestMock);
var httpRequestInfo = new HttpRequest
{
Method = method,
Path = path,
ContentBytes = contentBytes,
ContentType = contentType
};
httpRequestPattern.IsMatch(httpRequestInfo).ShouldBeEquivalentTo(isMatchResult);
}
public override void SetUp()
{
base.SetUp();
httpRequestMockBuilder = new HttpRequestMockBuilder();
httpRequestMockBuilder.Method(MethodPattern.Standart("GET"));
httpRequestMockBuilder.Path(PathPattern.Smart("/"));
}
internal HttpRequestMockBuilder()
{
httpRequestMock = new HttpRequestMock
{
Method = MethodPattern.Any(),
Path = PathPattern.Any(),
Query = QueryPattern.Any(),
Content = ContentPattern.Any(),
Headers = HeadersPattern.Any()
};
httpResponseMockBuilder = new HttpResponseMockBuilder(200);
}
public Expression OptimizeMethodCall(ReadOnlyCollection <string> fieldNames,
ParameterExpression recordParameter, MethodCallExpression methodCall)
{
Validation.CheckArgumentNotNull(fieldNames, "fieldNames");
Validation.CheckArgumentNotNull(methodCall, "methodCall");
MethodPattern pattern = GetMethodPattern(methodCall);
if (pattern == MethodPattern.Unsupported)
{
// Cannot optimize this method.
return(methodCall);
}
// if the input record (arguments[0]) is not the record parameter, we cannot
// leverage field names to optimize the shaper
if (recordParameter != methodCall.Arguments[0])
{
return(methodCall);
}
Expression ordinalExpression;
if (!TryGetOrdinalExpression(fieldNames, methodCall, pattern, out ordinalExpression))
{
return(methodCall);
}
Type returnType = methodCall.Method.GetGenericArguments().Single();
bool canAssignNull = returnType.IsClass ||
(returnType.IsGenericType &&
typeof(Nullable <>) == returnType.GetGenericTypeDefinition());
// argument[0].GetValue(ordinal)
Expression result = Expression.Call(methodCall.Arguments[0], s_getValue, ordinalExpression);
if (canAssignNull)
{
// (returnType)(argument[0].IsDBNull(ordinal) ? null : result)
result = Expression.Condition(
Expression.Call(methodCall.Arguments[0], s_isDBNull, ordinalExpression),
Expression.Constant(null, typeof(object)),
result);
}
// (returnType)result
result = Expression.Convert(result, returnType);
return(result);
}
private static HttpRequestMock CreateMock(string method)
{
return(new HttpRequestMock
{
Method = MethodPattern.Standart(method),
Path = PathPattern.Smart("/"),
Query = QueryPattern.Any(),
Content = ContentPattern.Any(),
Headers = HeadersPattern.Any(),
Response = new HttpResponseMock
{
RepeatCount = 1
}
});
}
public void TestIsMatch(string method, string expectedMethod, bool expected)
{
const string pathPattern = "/";
var httpRequestMock = new HttpRequestMock
{
Method = MethodPattern.Standart(method),
Path = PathPattern.Smart(pathPattern),
Query = QueryPattern.Any(),
Headers = HeadersPattern.Any(),
Content = ContentPattern.Any()
};
var httpRequestPattern = new HttpRequestPattern(httpRequestMock);
var httpRequestInfo = new HttpRequest
{
Method = expectedMethod,
Path = pathPattern
};
httpRequestPattern.IsMatch(httpRequestInfo).ShouldBeEquivalentTo(expected);
}
public static IHttpRequestMock Method(this IHttpRequestMock httpRequestMock, HttpRequestMockMethod method)
{
return(httpRequestMock.Method(MethodPattern.Standart(method)));
}
private static bool TryGetOrdinalExpression(ReadOnlyCollection <string> fieldNames, MethodCallExpression methodCall, MethodPattern pattern, out Expression ordinalExpression)
{
ordinalExpression = null;
// check if we can determine an expression defining the ordinal
if (pattern == MethodPattern.FieldOrdinal)
{
ordinalExpression = methodCall.Arguments[1];
return(true);
}
else if (pattern == MethodPattern.FieldName)
{
// check for a constant name that appears in the field names
Expression nameArgument = methodCall.Arguments[1];
if (nameArgument.NodeType == ExpressionType.Constant)
{
string name = (string)((ConstantExpression)nameArgument).Value;
if (null == name)
{
// cannot retrieve the ordinal if we don't know the name
return(false);
}
int ordinal = 0;
for (; ordinal < fieldNames.Count && name != fieldNames[ordinal]; ordinal++)
{
;
}
if (ordinal < fieldNames.Count)
{
ordinalExpression = Expression.Constant(ordinal);
return(true);
}
}
}
return(false);
}
