public void Can_send_multi_reply_HelloGet_requests()
{
var client = new JsonServiceClient(Config.AbsoluteBaseUri)
{
RequestFilter = req =>
req.Headers[HttpHeaders.XHttpMethodOverride] = HttpMethods.Get
};
var requests = new[]
{
new HelloGet {
Name = "Foo"
},
new HelloGet {
Name = "Bar"
},
new HelloGet {
Name = "Baz"
},
};
client.Get(new HelloGet {
Name = "aaa"
});
var responses = client.SendAll(requests);
var results = responses.Map(x => x.Result);
Assert.That(results, Is.EquivalentTo(new[] {
"Hello, Foo!", "Hello, Bar!", "Hello, Baz!"
}));
}
public void Can_send_multi_reply_HelloAllCustom_requests()
{
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
var requests = new[]
{
new HelloAllCustom {
Name = "Foo"
},
new HelloAllCustom {
Name = "Bar"
},
new HelloAllCustom {
Name = "Baz"
},
};
var responses = client.SendAll(requests);
responses.PrintDump();
var results = responses.Map(x => x.Result);
Assert.That(results, Is.EquivalentTo(new[] {
"Custom, Foo!", "Custom, Bar!", "Custom, Baz!"
}));
}
public void Can_send_multi_reply_HelloAll_requests()
{
ReplyAllService.TimesExecuted = 0;
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
var requests = new[]
{
new HelloAll {
Name = "Foo"
},
new HelloAll {
Name = "Bar"
},
new HelloAll {
Name = "Baz"
},
};
var responses = client.SendAll(requests);
responses.PrintDump();
var results = responses.Map(x => x.Result);
Assert.That(results, Is.EquivalentTo(new[] {
"Hello, Foo!", "Hello, Bar!", "Hello, Baz!"
}));
Assert.That(ReplyAllService.TimesExecuted, Is.EqualTo(requests.Length));
}
public void Can_Cancel_in_AsyncFilter_in_AutoBatch_Request()
{
AppHost.CancelledAt = -1;
var client = new JsonServiceClient(Config.ListeningOn)
{
ResponseFilter = res =>
{
Assert.That(res.StatusCode, Is.EqualTo(HttpStatusCode.PartialContent));
}
};
var responseBatch = client.SendAll(new[]
{
new TestAsyncFilter {
CancelAt = 1
},
new TestAsyncFilter {
CancelAt = 1
},
new TestAsyncFilter {
CancelAt = 1
},
});
Assert.That(responseBatch, Is.Null);
Assert.That(AppHost.CancelledAt, Is.EqualTo(1));
}
public void Does_throw_WebServiceException_on_Error()
{
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
//var client = new JsonServiceClient("http://localhost:55799/");
var requests = new[]
{
new BatchThrows {
Id = 1, Name = "Foo"
},
new BatchThrows {
Id = 2, Name = "Bar"
},
new BatchThrows {
Id = 3, Name = "Baz"
},
};
try
{
var responses = client.SendAll(requests);
Assert.Fail("Should throw");
}
catch (WebServiceException ex)
{
ex.ResponseStatus.PrintDump();
Assert.That(ex.ErrorCode, Is.EqualTo(typeof(Exception).Name));
Assert.That(ex.ResponseStatus.ErrorCode, Is.EqualTo(typeof(Exception).Name));
Assert.That(ex.ResponseStatus.Message, Is.EqualTo("Batch Throws"));
Assert.That(ex.ResponseHeaders[HttpHeaders.XAutoBatchCompleted], Is.EqualTo("0"));
}
}
public void Does_log_autobatch_request()
{
var client = new JsonServiceClient(Config.ListeningOn)
{
RequestFilter = req => req.Referer = Config.ListeningOn
};
var request = new[]
{
new RequestLogsTest {
Name = "foo1"
},
new RequestLogsTest {
Name = "bar1"
}
};
var response = client.SendAll(request);
var json = Config.ListeningOn.CombineWith("requestlogs").GetJsonFromUrl();
var requestLogs = json.FromJson <RequestLogsResponse>();
var requestLog = requestLogs.Results.First();
var loggedRequests = requestLog.RequestDto.ConvertTo <List <RequestLogsTest> >();
Assert.That(request is IEnumerable <RequestLogsTest>);
Assert.That(loggedRequests is IEnumerable <RequestLogsTest>);
Assert.That(loggedRequests.First().Name, Is.EqualTo("foo1"));
Assert.That(loggedRequests.Last().Name, Is.EqualTo("bar1"));
Assert.That(requestLog.Referer, Is.EqualTo(Config.ListeningOn));
}
public void Does_log_autobatch_error_response()
{
var client = new JsonServiceClient(Config.ListeningOn)
{
RequestFilter = req => req.Referer = Config.ListeningOn
};
var request = new[]
{
new RequestLogsErrorTest {
Message = "foo1"
},
new RequestLogsErrorTest {
Message = "bar1"
}
};
try
{
var response = client.SendAll(request);
}
catch (WebServiceException)
{
var json = Config.ListeningOn.CombineWith("requestlogs").GetJsonFromUrl();
var requestLogs = json.FromJson <RequestLogsResponse>();
var requestLog = requestLogs.Results.First();
Assert.That(requestLog.ErrorResponse != null);
Assert.That(requestLog.ErrorResponse is ErrorResponse);
var responseStatus = requestLog.ErrorResponse.GetResponseStatus();
Assert.That(responseStatus.Message == "Error: foo1");
}
}
public void Does_Execute_all_RequestFilters_in_AutoBatch_Request()
{
var responseBatch = client.SendAll(new[]
{
new TestAsyncFilter(),
new TestAsyncFilter(),
new TestAsyncFilter(),
});
Assert.That(responseBatch.Count, Is.EqualTo(3));
foreach (var response in responseBatch)
{
Assert.That(response.Results, Is.EquivalentTo(new[]
{
"GlobalRequestFiltersAsync#0",
"GlobalRequestFiltersAsync#1",
"GlobalRequestFiltersAsync#2",
"Service#TestAsyncFilter",
}));
}
}
public void Does_not_repeat()
{
//var client = new JsonServiceClient("http://localhost:55799/");
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
var batch = new[] { new NoRepeat {
Id = Guid.NewGuid()
}, new NoRepeat {
Id = Guid.NewGuid()
} };
var results = client.SendAll(batch);
var guids = results.Select(r => r.Id);
Assert.IsTrue(guids.SequenceEqual(batch.Select(b => b.Id)));
}
void ConcreteSyncApiUsage(JsonServiceClient client)
{
UsageNone none = client.Send <UsageNone>(new UsageNone());
UsageReturn @return = client.Send(new UsageReturn());
client.Send(new UsageVoid());
List <UsageReturn> @returnAll = client.SendAll(new[] { new UsageReturn() });
client.Publish(new UsageNone());
client.Publish(new UsageReturn());
client.Publish(new UsageVoid());
client.PublishAll(new[] { new UsageNone() });
client.PublishAll(new [] { new UsageReturn() });
client.PublishAll(new [] { new UsageVoid() });
}
public void Custom_multi_requests_set_AutoBatchIndex()
{
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
WebHeaderCollection responseHeaders = null;
client.ResponseFilter = response => { responseHeaders = response.Headers; };
var responses = client.SendAll(new[]
{
new GetCustomAutoBatchIndex(),
new GetCustomAutoBatchIndex()
});
Assert.AreEqual("0", responses[0].Index);
Assert.AreEqual("0", responses[0].Meta["GlobalResponseFilterAutoBatchIndex"]);
Assert.AreEqual("1", responses[1].Index);
Assert.AreEqual("1", responses[1].Meta["GlobalResponseFilterAutoBatchIndex"]);
Assert.AreEqual("1", responseHeaders["GlobalRequestFilterAutoBatchIndex"]);
}
public void Sending_multiple_HelloAllTransaction_does_rollback_transaction()
{
using (var db = appHost.Resolve <IDbConnectionFactory>().Open())
{
db.DropAndCreateTable <HelloAllTransaction>();
}
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
var requests = new[]
{
new HelloAllTransaction {
Name = "Foo"
},
new HelloAllTransaction {
Name = "Bar"
},
new HelloAllTransaction {
Name = "Baz"
},
};
try
{
var responses = client.SendAll(requests);
Assert.Fail("Should throw on Bar");
}
catch (WebServiceException ex)
{
Assert.That(ex.ErrorCode, Is.EqualTo(typeof(ArgumentException).Name));
}
using (var db = appHost.Resolve <IDbConnectionFactory>().Open())
{
var allRequests = db.Select <HelloAllTransaction>();
Assert.That(allRequests.Count, Is.EqualTo(0));
}
}
