public void Get_via_internal_routing_and_AutoRedirect_off_shows_302()
{
using (var hostInfo = DreamTestHelper.CreateRandomPortHost()) {
var mock = MockService.CreateMockService(hostInfo);
var redirectCalled = 0;
var redirectUri = new XUri("mock://foo/bar");
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response) {
var msg = "nothing here";
if (context.Uri.LastSegment == "redirect")
{
_log.Debug("called redirect");
redirectCalled++;
response.Return(DreamMessage.Redirect(redirectUri));
return;
}
_log.DebugFormat("called uri: {0} => {1}", context.Uri, msg);
response.Return(DreamMessage.NotFound(msg));
};
var uri = mock.AtLocalMachine.At("redirect");
_log.DebugFormat("calling redirect service at {0}", uri);
var r = Plug.New(uri).WithHeader("h", "y").WithoutAutoRedirects().Get(new Result <DreamMessage>()).Wait();
Assert.AreEqual(DreamStatus.Found, r.Status, r.HasDocument ? r.ToDocument()["message"].AsText : "request failed: " + r.Status);
Assert.AreEqual(1, redirectCalled, "redirect called incorrectly");
Assert.AreEqual(redirectUri.ToString(), r.Headers.Location.ToString());
}
}
public void Fetch_cookie_from_dreamcontext_jar_with_local_uri()
{
using (DreamHostInfo hostInfo = DreamTestHelper.CreateRandomPortHost(new XDoc("config").Elem("uri.public", "/foo/bar"))) {
MockServiceInfo mock = MockService.CreateMockService(hostInfo);
List <DreamCookie> cookies = null;
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response2) {
context.Service.Cookies.Update(new DreamCookie("public", "bar", mock.AtLocalHost.Uri), null);
context.Service.Cookies.Update(new DreamCookie("local", "baz", mock.AtLocalMachine.Uri), null);
cookies = context.Service.Cookies.Fetch(mock.AtLocalHost.Uri);
response2.Return(DreamMessage.Ok());
};
mock.AtLocalHost.Post();
bool foundPublic = false;
bool foundLocal = false;
foreach (DreamCookie cookie in cookies)
{
switch (cookie.Name)
{
case "public":
foundPublic = true;
break;
case "local":
foundLocal = true;
break;
}
}
Assert.IsTrue(foundPublic, "didn't find public");
Assert.IsTrue(foundLocal, "didn't find local");
}
}
public void FixtureSetup()
{
_hostInfo = DreamTestHelper.CreateRandomPortHost(new XDoc("config")
.Elem("ip", "foo")
.Elem("ip", "bar"));
_service1 = MockService.CreateMockService(_hostInfo);
_service2 = MockService.CreateMockService(_hostInfo);
}
private MockServiceInfo GetMockService()
{
if (_mockService == null)
{
_hostInfo = DreamTestHelper.CreateRandomPortHost(new XDoc("config"));
_mockService = MockService.CreateMockService(_hostInfo);
}
return(_mockService);
}
public void Get_via_internal_routing_follows_301_but_expects_query_to_be_in_location()
{
using (var hostInfo = DreamTestHelper.CreateRandomPortHost()) {
var mock = MockService.CreateMockService(hostInfo);
var redirectCalled = 0;
var targetCalled = 0;
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response) {
var msg = "nothing here";
var q = context.Uri.GetParam("q");
var forward = context.Uri.GetParam("forward");
if (context.Uri.LastSegment == "redirect")
{
_log.Debug("called redirect");
var redirect = context.Service.Self.Uri.At("target").AsPublicUri();
if (forward == "true")
{
redirect = redirect.With("q", q);
}
redirectCalled++;
var headers = new DreamHeaders();
headers.Add(DreamHeaders.LOCATION, redirect.ToString());
response.Return(new DreamMessage(DreamStatus.MovedPermanently, headers));
return;
}
if (context.Uri.LastSegment == "target")
{
_log.Debug("called target");
if (q == "x")
{
_log.Debug("target request had query");
targetCalled++;
response.Return(DreamMessage.Ok());
return;
}
response.Return(DreamMessage.BadRequest("missing query param"));
return;
}
_log.DebugFormat("called uri: {0} => {1}", context.Uri, msg);
response.Return(DreamMessage.NotFound(msg));
};
var uri = mock.AtLocalMachine.At("redirect");
_log.DebugFormat("calling redirect service at {0}", uri);
var r = Plug.New(uri).With("q", "x").Get(new Result <DreamMessage>()).Wait();
Assert.AreEqual(DreamStatus.BadRequest, r.Status);
Assert.AreEqual(1, redirectCalled, "redirect without forward called incorrectly");
Assert.AreEqual(0, targetCalled, "target without forward called incorrectly");
redirectCalled = 0;
targetCalled = 0;
r = Plug.New(uri).With("q", "x").With("forward", "true").Get(new Result <DreamMessage>()).Wait();
Assert.IsTrue(r.IsSuccessful, r.HasDocument ? r.ToDocument()["message"].AsText : "request failed: " + r.Status);
Assert.AreEqual(1, redirectCalled, "redirect with forward called incorrectly");
Assert.AreEqual(1, targetCalled, "target with forward called incorrectly");
}
}
public void SetCookie_header_passed_from_service_to_external_but_rooted_at_external()
{
using (DreamHostInfo hostInfo = DreamTestHelper.CreateRandomPortHost(new XDoc("config").Elem("uri.public", "/foo/bar"))) {
MockServiceInfo mock = MockService.CreateMockService(hostInfo);
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response2) {
DreamMessage msg = DreamMessage.Ok();
msg.Cookies.Add(DreamCookie.NewSetCookie("foo", "bar", context.Uri.AsPublicUri().WithoutPathQueryFragment()));
response2.Return(msg);
};
mock.AtLocalHost.Post();
List <DreamCookie> cookies = Plug.GlobalCookies.Fetch(mock.AtLocalHost);
Assert.AreEqual(1, cookies.Count);
Assert.AreEqual("/", cookies[0].Path);
}
}
public void Incoming_IfNoneMatch_is_unquoted()
{
var hostinfo = DreamTestHelper.CreateRandomPortHost(new XDoc("config"));
var mockService = MockService.CreateMockService(hostinfo);
mockService.Service.CatchAllCallback = (ctx, req, res) => res.Return(DreamMessage.Ok(MimeType.TEXT, req.Headers.IfNoneMatch));
var request = WebRequest.Create(mockService.AtLocalHost.ToString());
request.Headers[DreamHeaders.IF_NONE_MATCH] = "\"foo\"";
var response = request.GetResponse();
var reader = new StreamReader(response.GetResponseStream());
var content = reader.ReadToEnd();
Assert.AreEqual("foo", content);
}
public void Get_via_http_hits_dream_via_local_pathway()
{
using (var hostInfo = DreamTestHelper.CreateRandomPortHost()) {
var mock = MockService.CreateMockService(hostInfo);
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response) {
if (!string.IsNullOrEmpty(request.Headers.DreamPublicUri))
{
throw new DreamBadRequestException(string.Format("got origin header '{0}', indicating we didn't arrive via local://", request.Headers.DreamOrigin));
}
response.Return(DreamMessage.Ok());
};
var r = mock.AtLocalHost.Get(new Result <DreamMessage>()).Wait();
Assert.IsTrue(r.IsSuccessful, r.HasDocument ? r.ToDocument()["message"].AsText : "request failed: " + r.Status);
}
}
public void SetCookie_header_passed_from_service_to_external_uses_public_uri()
{
using (DreamHostInfo hostInfo = DreamTestHelper.CreateRandomPortHost()) {
MockServiceInfo mock = MockService.CreateMockService(hostInfo);
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response2) {
DreamMessage msg = DreamMessage.Ok();
msg.Cookies.Add(DreamCookie.NewSetCookie("foo", "bar", context.Uri));
response2.Return(msg);
};
mock.AtLocalHost.Post();
List <DreamCookie> cookies = Plug.GlobalCookies.Fetch(mock.AtLocalHost);
Assert.AreEqual(1, cookies.Count);
Assert.AreEqual(mock.AtLocalHost.Uri, cookies[0].Uri);
}
}
public void Get_via_internal_routing_follows_301_and_forwards_headers()
{
using (var hostInfo = DreamTestHelper.CreateRandomPortHost()) {
var mock = MockService.CreateMockService(hostInfo);
var redirectCalled = 0;
var targetCalled = 0;
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response) {
var msg = "nothing here";
var h = request.Headers["h"];
if (context.Uri.LastSegment == "redirect")
{
_log.Debug("called redirect");
if (h == "y")
{
redirectCalled++;
var headers = new DreamHeaders();
headers.Add(DreamHeaders.LOCATION, context.Service.Self.Uri.At("target").AsPublicUri().ToString());
response.Return(new DreamMessage(DreamStatus.MovedPermanently, headers));
return;
}
msg = "redirect request lacked header";
}
if (context.Uri.LastSegment == "target")
{
_log.Debug("called target");
if (h == "y")
{
_log.Debug("target request had header");
targetCalled++;
response.Return(DreamMessage.Ok());
return;
}
msg = "target request lacked header ({1}";
}
_log.DebugFormat("called uri: {0} => {1}", context.Uri, msg);
response.Return(DreamMessage.NotFound(msg));
};
var uri = mock.AtLocalMachine.At("redirect");
_log.DebugFormat("calling redirect service at {0}", uri);
var r = Plug.New(uri).WithHeader("h", "y").Get(new Result <DreamMessage>()).Wait();
Assert.IsTrue(r.IsSuccessful, r.HasDocument ? r.ToDocument()["message"].AsText : "request failed: " + r.Status);
Assert.AreEqual(1, redirectCalled, "redirect called incorrectly");
Assert.AreEqual(1, targetCalled, "target called incorrectly");
}
}
public void AutoRedirect_only_follows_specified_times()
{
using (var hostInfo = DreamTestHelper.CreateRandomPortHost()) {
var mock = MockService.CreateMockService(hostInfo);
var totalCalls = 0;
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response) {
totalCalls++;
_log.DebugFormat("call {0} to redirect", totalCalls);
response.Return(DreamMessage.Redirect(context.Uri.WithoutQuery().With("c", totalCalls.ToString())));
};
var uri = mock.AtLocalMachine.At("redirect");
var redirects = 10;
var expectedCalls = redirects + 1;
var r = Plug.New(uri).WithAutoRedirects(10).Get(new Result <DreamMessage>()).Wait();
Assert.AreEqual(DreamStatus.Found, r.Status);
Assert.AreEqual(expectedCalls, totalCalls, "redirect without forward called incorrectly");
Assert.AreEqual(uri.With("c", expectedCalls.ToString()).ToString(), r.Headers.Location.ToString());
}
}
public void SetCookie_header_passed_from_service_over_webrequest_uses_public_uri()
{
using (DreamHostInfo hostInfo = DreamTestHelper.CreateRandomPortHost()) {
MockServiceInfo mock = MockService.CreateMockService(hostInfo);
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response2) {
DreamMessage msg = DreamMessage.Ok();
msg.Cookies.Add(DreamCookie.NewSetCookie("foo", "bar", context.Uri));
response2.Return(msg);
};
XUri localUri = mock.AtLocalHost.Uri;
HttpWebRequest r = WebRequest.Create(localUri.ToString()) as HttpWebRequest;
CookieContainer cookies = new CookieContainer();
r.CookieContainer = cookies;
r.Method = "GET";
HttpWebResponse response = (HttpWebResponse)r.GetResponse();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(1, response.Cookies.Count);
Assert.AreEqual("localhost", response.Cookies[0].Domain);
Assert.AreEqual(mock.AtLocalHost.Uri.Path, response.Cookies[0].Path);
}
}
private void SetupService(bool memorizeAliases)
{
DreamHostInfo host;
if (memorizeAliases)
{
host = _hostAliasMemorize = DreamTestHelper.CreateRandomPortHost();
}
else
{
host = _hostNoAliasMemorize = DreamTestHelper.CreateRandomPortHost(new XDoc("config").Elem("memorize-aliases", false));
}
_service = MockService.CreateMockService(host);
_calledPaths = new List <string>();
_service.Service.CatchAllCallback = (context, request, result) => {
_calledPaths.Add(context.GetSuffixes(UriPathFormat.Original).First());
var call = context.GetParam("call", null);
if (!string.IsNullOrEmpty(call))
{
Plug.New(call).Get();
}
result.Return(DreamMessage.Ok());
};
_external = new XUri("http://external1/").WithPort(_service.AtLocalHost.Uri.Port).At(_service.AtLocalHost.Uri.Segments);
//_ext2 = new XUri("http://external2/").WithPort(_service.AtLocalHost.Uri.Port).At(_service.AtLocalHost.Uri.Segments);
_externalCalled = 0;
MockPlug.Register(_external, (plug, verb, uri, request, response) => {
_externalCalled++;
response.Return(DreamMessage.Ok());
}, 100);
//_ext2called = 0;
//MockPlug.Register(_ext2, (plug, verb, uri, request, response) => {
// _ext2called++;
// response.Return(DreamMessage.Ok());
//}, 100);
Plug.New(_external).Get();
//Plug.New(_ext2).Get();
//return _calledPaths;
}
public void SetCookie_header_passed_between_services_uses_local_uri_on_host_non_root_public_uri()
{
using (DreamHostInfo hostInfo = DreamTestHelper.CreateRandomPortHost(new XDoc("config").Elem("uri.public", "/foo/bar"))) {
MockServiceInfo mock1 = MockService.CreateMockService(hostInfo);
MockServiceInfo mock2 = MockService.CreateMockService(hostInfo);
List <DreamCookie> cookies = null;
mock1.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response2) {
DreamMessage r = Plug.New(mock2.AtLocalMachine).Post(DreamMessage.Ok());
cookies = context.Service.Cookies.Fetch(mock2.AtLocalMachine);
Assert.AreEqual(1, cookies.Count);
Assert.AreEqual(mock2.AtLocalMachine.Uri, cookies[0].Uri);
response2.Return(DreamMessage.Ok());
};
mock2.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response2) {
DreamMessage msg = DreamMessage.Ok();
msg.Cookies.Add(DreamCookie.NewSetCookie("foo", "bar", context.Uri));
response2.Return(msg);
};
mock1.AtLocalHost.Post();
Assert.AreEqual(1, cookies.Count);
}
}
public void Can_provide_list_of_args_as_repeated_params_to_feature()
{
MockServiceInfo mock = MockService.CreateMockService(_hostInfo);
mock.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response2) {
XDoc msg = new XDoc("ids");
foreach (KeyValuePair <string, string> kv in context.GetParams())
{
if (kv.Key == "id")
{
msg.Elem("id", kv.Value);
}
}
response2.Return(DreamMessage.Ok(msg));
};
Plug p = mock.AtLocalHost;
int n = 100;
List <string> ids = new List <string>();
for (int i = 0; i < n; i++)
{
p = p.With("id", i);
ids.Add(i.ToString());
}
DreamMessage result = p.GetAsync().Wait();
Assert.IsTrue(result.IsSuccessful);
List <string> seen = new List <string>();
foreach (XDoc id in result.ToDocument()["id"])
{
string v = id.AsText;
Assert.Contains(v, ids);
Assert.IsFalse(seen.Contains(v));
seen.Add(v);
}
Assert.AreEqual(ids.Count, seen.Count);
}
private void Upload_Files(bool local)
{
using (var hostInfo = DreamTestHelper.CreateRandomPortHost()) {
var mock = MockService.CreateMockService(hostInfo);
mock.Service.CatchAllCallbackAsync = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> response) {
return(Coroutine.Invoke(Upload_Helper, context, request, response));
};
var mockPlug = local
? mock.AtLocalHost
: Plug.New(mock.AtLocalHost.Uri.WithScheme("ext-http")).WithTimeout(TimeSpan.FromMinutes(10));
for (var i = 0; i <= 4; i++)
{
Stream stream = new MockAsyncReadableStream(150 * 1024 * 1024);
_log.DebugFormat("uploading {0}", i);
var response = mockPlug.Put(new DreamMessage(DreamStatus.Ok, null, MimeType.BINARY, stream.Length, stream), new Result <DreamMessage>()).Wait();
if (!response.IsSuccessful)
{
_log.DebugFormat("upload failed");
Assert.Fail(string.Format("unable to upload: {0}", response.ToText()));
}
}
}
}
public void Hitting_connect_limit_returns_service_unavailable()
{
// TODO (steveb): test fails under Mono 2.8.2
int connectLimit = 5;
using (var hostInfo = DreamTestHelper.CreateRandomPortHost(new XDoc("config").Elem("connect-limit", connectLimit))) {
var mockService = MockService.CreateMockService(hostInfo);
int hitCounter = 0;
mockService.Service.CatchAllCallback = delegate(DreamContext context, DreamMessage request, Result <DreamMessage> r) {
int current = Interlocked.Increment(ref hitCounter);
_log.DebugFormat("service call {0}", current);
Thread.Sleep(1500);
r.Return(DreamMessage.Ok());
};
List <Result <DreamMessage> > responses = new List <Result <DreamMessage> >();
for (int i = 0; i < connectLimit * 2; i++)
{
responses.Add(Plug.New(mockService.AtLocalHost.Uri.WithScheme("ext-http")).At(StringUtil.CreateAlphaNumericKey(6)).GetAsync());
Thread.Sleep(100);
}
for (int i = 0; i < responses.Count; i++)
{
DreamMessage response = responses[i].Wait();
if (i < connectLimit)
{
Assert.IsTrue(response.IsSuccessful);
}
else if (!response.IsSuccessful)
{
Assert.AreEqual(DreamStatus.ServiceUnavailable, response.Status);
}
}
Assert.LessOrEqual(hitCounter, connectLimit);
}
}
/// <summary>
/// Create a new mock service instance.
/// </summary>
/// <param name="hostInfo">Host info.</param>
/// <returns>New mock service info instance.</returns>
public static MockServiceInfo CreateMockService(this DreamHostInfo hostInfo)
{
return(MockService.CreateMockService(hostInfo));
}
/// <summary>
/// Create a new mock service instance.
/// </summary>
/// <param name="hostInfo">Host info.</param>
/// <param name="extraConfig">Additional service configuration.</param>
/// <returns>New mock service info instance.</returns>
public static MockServiceInfo CreateMockService(this DreamHostInfo hostInfo, XDoc extraConfig)
{
return(MockService.CreateMockService(hostInfo, extraConfig));
}
/// <summary>
/// Create a new mock service instance.
/// </summary>
/// <param name="hostInfo">Host info.</param>
/// <param name="extraConfig">Additional service configuration.</param>
/// <param name="privateStorage">Use private storage</param>
/// <returns>New mock service info instance.</returns>
public static MockServiceInfo CreateMockService(this DreamHostInfo hostInfo, XDoc extraConfig, bool privateStorage)
{
return(MockService.CreateMockService(hostInfo, extraConfig, privateStorage));
}
