public HttpStub AddStub()
{
var stub = new HttpStub();
Stubs.Add(stub);
return(stub);
}
public void HttpStub_ReturnsProxy_ReturnsHttpProxyStub()
{
var predicateInvokingProxyStub = new ContainsPredicate <HttpPredicateFields>(new HttpPredicateFields
{
Path = "/aTestPath"
});
var proxyGeneratorPredicate = new MatchesPredicate <HttpPredicateFields>(new HttpPredicateFields
{
Path = "/aTestPath",
Method = Method.Get,
QueryParameters = new Dictionary <string, string> {
{ "q", "value" }
}
});
var proxyToUrl = new Uri("http://someTestDestination.com");
var proxyModeToUse = ProxyMode.ProxyTransparent;
var stub = new HttpStub();
stub.On(predicateInvokingProxyStub)
.ReturnsProxy(proxyToUrl, proxyModeToUse, new [] { proxyGeneratorPredicate });
var proxyResponse = stub.Responses.First() as ProxyResponse <ProxyResponseFields <HttpPredicateFields> >;
Assert.AreEqual(proxyToUrl, proxyResponse.Fields.To);
Assert.AreEqual(proxyModeToUse, proxyResponse.Fields.Mode);
Assert.AreEqual(proxyGeneratorPredicate, proxyResponse.Fields.PredicateGenerators.First());
}
public static void Main(string[] args)
{
var PORT = 8000;
Console.WriteLine("Welcome to the Http stub");
var stub = new HttpStub(PORT);
stub.Start();
}
public void OnPathEquals_AddsPredicate_PathSet()
{
const string expectedPath = "/test";
var stub = new HttpStub();
stub.OnPathEquals(expectedPath);
var predicate = stub.Predicates.First() as EqualsPredicate<HttpPredicateFields>;
Assert.IsNotNull(predicate);
Assert.AreEqual(expectedPath, predicate.Fields.Path);
}
public void OnPathAndMethodEqual_AddsPredicate_MethodSet()
{
const Method expectedMethod = Method.Post;
var stub = new HttpStub();
stub.OnPathAndMethodEqual("/test", expectedMethod);
var predicate = stub.Predicates.First() as EqualsPredicate<HttpPredicateFields>;
Assert.IsNotNull(predicate);
Assert.AreEqual(expectedMethod, predicate.Fields.Method);
}
public void HttpStub_ReturnsBinary_AddsResponse_ContentTypePdf()
{
var stub = new HttpStub();
var bytes = new byte[] { 3, 3, 5, 2, 23, 5, 21, 1 };
stub.ReturnsBinary(HttpStatusCode.OK, bytes, "application/pdf");
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual("application/pdf", response.Fields.Headers["Content-Type"]);
}
public void HttpStub_On_AddsPredicate()
{
var expectedPredicate = new EqualsPredicate <HttpPredicateFields>(new HttpPredicateFields());
var stub = new HttpStub();
stub.On(expectedPredicate);
var predicate = stub.Predicates.First() as EqualsPredicate <HttpPredicateFields>;
Assert.AreEqual(expectedPredicate, predicate);
}
public void ConstantFalseDoesNotCauseConnection()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy);
var query = new ElasticQuery <Robot>(provider).Where(f => false);
((IEnumerable)query).GetEnumerator();
Assert.Empty(httpStub.Requests);
}
}
public void HttpStub_Returns_AddsResponse()
{
var expectedResponse = new IsResponse <HttpResponseFields>(new HttpResponseFields());
var stub = new HttpStub();
stub.Returns(expectedResponse);
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.AreEqual(expectedResponse, response);
}
public void HttpStub_InjectedFunction_AddsPredicate_InjectedFunctionSet()
{
const string injectedFunction = "function(config) { return true; }";
var stub = new HttpStub();
stub.OnInjectedFunction(injectedFunction);
var predicate = stub.Predicates.First() as InjectPredicate;
Assert.IsNotNull(predicate);
Assert.AreEqual(injectedFunction, predicate.InjectedFunction);
}
public void ReturnsStatus_AddsResponse_StatusCodeSet()
{
const HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
var stub = new HttpStub();
stub.ReturnsStatus(expectedStatusCode);
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(expectedStatusCode, response.Fields.StatusCode);
}
public void QueryEvaluationWithNoNullResponseThrowsInvalidOperationException()
{
using (var httpStub = new HttpStub(c => { }))
{
var context = MakeElasticContext(httpStub.Uri);
Assert.Throws <InvalidOperationException>(() => context.Query <Robot>().FirstOrDefault());
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/robots/_search", request.RawUrl);
}
}
public void QueryEvaluationCausesPostToConnectionEndpoint()
{
using (var httpStub = new HttpStub(ZeroHits))
{
var context = MakeElasticContext(httpStub.Uri);
var dummy = context.Query <Robot>().FirstOrDefault();
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/robots/_search", request.RawUrl);
}
}
public void OnPathAndMethodEqual_AddsPredicate_MethodSet()
{
const Method expectedMethod = Method.Post;
var stub = new HttpStub();
stub.OnPathAndMethodEqual("/test", expectedMethod);
var predicate = stub.Predicates.First() as EqualsPredicate <HttpPredicateFields>;
Assert.IsNotNull(predicate);
Assert.AreEqual(expectedMethod, predicate.Fields.Method);
}
public void OnPathAndMethodEqual_AddsPredicate_PathSet()
{
const string expectedPath = "/test";
var stub = new HttpStub();
stub.OnPathAndMethodEqual(expectedPath, Method.Get);
var predicate = stub.Predicates.First() as EqualsPredicate <HttpPredicateFields>;
Assert.IsNotNull(predicate);
Assert.AreEqual(expectedPath, predicate.Fields.Path);
}
public void ReturnsXml_AddsResponse_ResponseObjectSerializedAndSet()
{
const string expectedResponseObject = "<string>Test Response</string>";
var stub = new HttpStub();
stub.ReturnsXml(HttpStatusCode.OK, "Test Response");
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.IsTrue(response.Fields.ResponseObject.ToString().Contains(expectedResponseObject));
}
public void ReturnsXml_AddsResponse_DefaultsToUtf8Encoding()
{
const string expectedEncoding = "utf-8";
var stub = new HttpStub();
stub.ReturnsXml(HttpStatusCode.OK, "Test Response");
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.IsTrue(response.Fields.ResponseObject.ToString().Contains(expectedEncoding));
}
public void ReturnsXmlWithEncoding_AddsResponse_WithSpecifiedEncoding()
{
const string expectedEncoding = "utf-16";
var stub = new HttpStub();
stub.ReturnsXml(HttpStatusCode.OK, "Test Response", Encoding.Unicode);
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.IsTrue(response.Fields.ResponseObject.ToString().Contains(expectedEncoding));
}
public void ReturnsBody_AddsResponse_ResponseObjectSet()
{
const string expectedBody = "test";
var stub = new HttpStub();
stub.ReturnsBody(HttpStatusCode.OK, expectedBody);
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(expectedBody, response.Fields.ResponseObject.ToString());
}
public void ProviderExecuteTCausesPostToConnectionEndpoint()
{
using (var httpStub = new HttpStub(ZeroHits))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy, "prefix");
var query = new ElasticQuery <Robot>(provider);
provider.Execute <IEnumerable <Robot> >(query.Expression);
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/robots/_search", request.RawUrl);
}
}
public void QueryImplicitGetEnumeratorCausesConnection()
{
using (var httpStub = new HttpStub(ZeroHits))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy, "prefix");
var query = new ElasticQuery <Robot>(provider);
var enumerator = query.GetEnumerator();
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/robots/_search", request.RawUrl);
Assert.NotNull(enumerator);
}
}
public void Returns_AddsResponse_ContentTypeHeaderSet()
{
var headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
};
var stub = new HttpStub();
stub.Returns(HttpStatusCode.OK, headers, "test");
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(headers, response.Fields.Headers);
}
public async void AcceptEncodingIsGzip()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var context = MakeElasticContext(httpStub.Uri);
var dummy = context.Query <Robot>().FirstOrDefault();
Assert.Null(dummy);
await httpStub.Completion;
var request = httpStub.Requests.Single();
Assert.Contains("Accept-Encoding", request.Headers.AllKeys);
Assert.Equal("gzip", request.Headers["Accept-Encoding"]);
}
}
public async void ProviderExecuteCausesPostToConnectionEndpoint()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy);
var query = new ElasticQuery <Robot>(provider);
provider.Execute(query.Expression);
await httpStub.Completion;
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/_all/robots/_search", request.RawUrl);
}
}
public void Returns_AddsResponse()
{
var headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
};
var expectedResponse = new IsResponse <HttpResponseFields>(new HttpResponseFields());
var stub = new HttpStub();
stub.Returns(expectedResponse);
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.AreEqual(expectedResponse, response);
}
public async void QueryExplicitIEnumerableGetEnumeratorCausesConnection()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy);
var query = new ElasticQuery <Robot>(provider);
var enumerator = ((IEnumerable)query).GetEnumerator();
await httpStub.Completion;
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/_all/robots/_search", request.RawUrl);
Assert.NotNull(enumerator);
}
}
public void Returns_AddsResponse_StatusCodeSet()
{
const HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
var headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
};
var stub = new HttpStub();
stub.Returns(expectedStatusCode, headers, "test");
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(expectedStatusCode, response.Fields.StatusCode);
}
public void On_AddsPredicate()
{
var headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
};
var expectedPredicate = new EqualsPredicate <HttpPredicateFields>(new HttpPredicateFields());
var stub = new HttpStub();
stub.On(expectedPredicate);
var predicate = stub.Predicates.First() as EqualsPredicate <HttpPredicateFields>;
Assert.AreEqual(expectedPredicate, predicate);
}
public void Returns_AddsResponse_ResponseObjectSet()
{
const string expectedResponseObject = "Test Response";
var headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
};
var stub = new HttpStub();
stub.Returns(HttpStatusCode.OK, headers, expectedResponseObject);
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(expectedResponseObject, response.Fields.ResponseObject);
}
public void HttpStub_Returns_AddsResponse_LatencySet()
{
const HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
const int expectedLatencyInMilliseconds = 1000;
var headers = new Dictionary <string, object> {
{ "Content-Type", "application/json" }
};
var stub = new HttpStub();
stub.Returns(expectedStatusCode, headers, "test", latencyInMilliseconds: expectedLatencyInMilliseconds);
var response = stub.Responses.First() as IsResponse <HttpResponseFields>;
Assert.IsNotNull(response);
Assert.IsNotNull(response.Behavior);
Assert.IsNotNull(response.Behavior.LatencyInMilliseconds);
Assert.AreEqual(expectedLatencyInMilliseconds, response.Behavior.LatencyInMilliseconds);
}
public void Returns_AddsResponse_ResponseObjectSet()
{
const string expectedResponseObject = "Test Response";
var headers = new Dictionary<string, string> { { "Content-Type", "application/json" } };
var stub = new HttpStub();
stub.Returns(HttpStatusCode.OK, headers, expectedResponseObject);
var response = stub.Responses.First() as IsResponse<HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(expectedResponseObject, response.Fields.ResponseObject);
}
public void ReturnsXml_AddsResponse_DefaultsToUtf8Encoding()
{
const string expectedEncoding = "utf-8";
var stub = new HttpStub();
stub.ReturnsXml(HttpStatusCode.OK, "Test Response");
var response = stub.Responses.First() as IsResponse<HttpResponseFields>;
Assert.IsNotNull(response);
Assert.IsTrue(response.Fields.ResponseObject.ToString().Contains(expectedEncoding));
}
public void Constructor_InitializesPredicatesCollection()
{
var stub = new HttpStub();
Assert.IsNotNull(stub.Predicates);
}
public void ReturnsXml_AddsResponse_ResponseObjectSerializedAndSet()
{
const string expectedResponseObject = "<string>Test Response</string>";
var stub = new HttpStub();
stub.ReturnsXml(HttpStatusCode.OK, "Test Response");
var response = stub.Responses.First() as IsResponse<HttpResponseFields>;
Assert.IsNotNull(response);
Assert.IsTrue(response.Fields.ResponseObject.ToString().Contains(expectedResponseObject));
}
public void ReturnsXml_AddsResponse_StatusCodeSet()
{
const HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
var stub = new HttpStub();
stub.ReturnsXml(expectedStatusCode, "test");
var response = stub.Responses.First() as IsResponse<HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(expectedStatusCode, response.Fields.StatusCode);
}
public void Returns_AddsResponse()
{
var headers = new Dictionary<string, string> { { "Content-Type", "application/json" } };
var expectedResponse = new IsResponse<HttpResponseFields>(new HttpResponseFields());
var stub = new HttpStub();
stub.Returns(expectedResponse);
var response = stub.Responses.First() as IsResponse<HttpResponseFields>;
Assert.AreEqual(expectedResponse, response);
}
public void Returns_AddsResponse_ContentTypeHeaderSet()
{
var headers = new Dictionary<string, string> { { "Content-Type", "application/json" } };
var stub = new HttpStub();
stub.Returns(HttpStatusCode.OK, headers, "test");
var response = stub.Responses.First() as IsResponse<HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(headers, response.Fields.Headers);
}
public void Returns_AddsResponse_StatusCodeSet()
{
const HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
var headers = new Dictionary<string, string> { {"Content-Type", "application/json"} };
var stub = new HttpStub();
stub.Returns(expectedStatusCode, headers, "test");
var response = stub.Responses.First() as IsResponse<HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(expectedStatusCode, response.Fields.StatusCode);
}
public void Constructor_InitializesResponsesCollection()
{
var stub = new HttpStub();
Assert.IsNotNull(stub.Responses);
}
public void On_AddsPredicate()
{
var headers = new Dictionary<string, string> { { "Content-Type", "application/json" } };
var expectedPredicate = new EqualsPredicate<HttpPredicateFields>(new HttpPredicateFields());
var stub = new HttpStub();
stub.On(expectedPredicate);
var predicate = stub.Predicates.First() as EqualsPredicate<HttpPredicateFields>;
Assert.AreEqual(expectedPredicate, predicate);
}
public void HttpStub_Constructor_InitializesResponsesCollection()
{
var stub = new HttpStub();
Assert.IsNotNull(stub.Responses);
}
public HttpStub AddStub()
{
var stub = new HttpStub();
Stubs.Add(stub);
return stub;
}
public void ReturnsBody_AddsResponse_ResponseObjectSet()
{
const string expectedBody = "test";
var stub = new HttpStub();
stub.ReturnsBody(HttpStatusCode.OK, expectedBody);
var response = stub.Responses.First() as IsResponse<HttpResponseFields>;
Assert.IsNotNull(response);
Assert.AreEqual(expectedBody, response.Fields.ResponseObject.ToString());
}
public void ReturnsXmlWithEncoding_AddsResponse_WithSpecifiedEncoding()
{
const string expectedEncoding = "utf-16";
var stub = new HttpStub();
stub.ReturnsXml(HttpStatusCode.OK, "Test Response", Encoding.Unicode);
var response = stub.Responses.First() as IsResponse<HttpResponseFields>;
Assert.IsNotNull(response);
Assert.IsTrue(response.Fields.ResponseObject.ToString().Contains(expectedEncoding));
}
