public void FailEarlyIfTimeoutIsExhausted_Async()
{
using (var fake = new AutoFake())
{
var dateTimeProvider = ProvideDateTimeProvider(fake);
var config = ProvideConfiguration(dateTimeProvider);
var connection = ProvideConnection(fake, config, dateTimeProvider);
var getCall = FakeCalls.GetCall(fake);
var ok = Task.FromResult(FakeResponse.Ok(config));
var bad = Task.FromResult(FakeResponse.Bad(config));
getCall.ReturnsNextFromSequence(
bad,
bad,
ok
);
var seenNodes = new List <Uri>();
getCall.Invokes((Uri u, IRequestConfiguration o) => seenNodes.Add(u));
var pingCall = FakeCalls.PingAtConnectionLevelAsync(fake);
pingCall.Returns(ok);
var client1 = fake.Resolve <ElasticsearchClient>();
//event though the third node should have returned ok, the first 2 calls took a minute
var e = Assert.Throws <MaxRetryException>(async() => await client1.InfoAsync());
e.Message.Should()
.StartWith("Retry timeout 00:01:20 was hit after retrying 1 times:");
IElasticsearchResponse response = null;
Assert.DoesNotThrow(async() => response = await client1.InfoAsync());
response.Should().NotBeNull();
response.Success.Should().BeTrue();
}
}
public void ServerExceptionIsCaught_KeepResponse(int status, string exceptionType, string exceptionMessage)
{
var response = CreateServerExceptionResponse(status, exceptionType, exceptionMessage);
using (var fake = new AutoFake(callsDoNothing: true))
{
var connectionConfiguration = new ConnectionConfiguration()
.ExposeRawResponse(true);
fake.Provide <IConnectionConfigurationValues>(connectionConfiguration);
FakeCalls.ProvideDefaultTransport(fake);
var getCall = FakeCalls.GetSyncCall(fake);
getCall.Returns(FakeResponse.Bad(connectionConfiguration, response: response));
var client = fake.Resolve <ElasticsearchClient>();
var result = client.Info();
result.Success.Should().BeFalse();
AssertServerErrorsOnResponse(result, status, exceptionType, exceptionMessage);
result.ResponseRaw.Should().NotBeNull();
getCall.MustHaveHappened(Repeated.Exactly.Once);
}
}
public StaticConnectionPoolTests()
{
_connectionPool = new StaticConnectionPool(_uris);
_config = new ConnectionConfiguration(_connectionPool);
_ok = FakeResponse.Ok(_config);
_bad = FakeResponse.Bad(_config);
}
public void ByteArray_Bad_KeepResponse(object responseValue)
{
using (var request = new MemorySetup <byte[]>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
this.ShouldStreamOfCopy(request, success: false);
}
public void String_Bad_DiscardResponse(object responseValue)
{
using (var request = new MemorySetup <string>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
this.ShouldStreamOfCopy(request, success: false, keepRaw: false);
}
public void Stream_Bad_KeepResponse(object responseValue)
{
using (var request = new MemorySetup <Stream>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
this.ShouldDirectlyStream(request, success: false);
}
public void Typed_Bad_KeepResponse(object responseValue)
{
using (var request = new MemorySetup <StandardResponse>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
this.ShouldStreamOfCopy(request, false);
}
public async Task DynamicDictionary_Bad_DiscardResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <DynamicDictionary>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
).Init())
this.ShouldDirectlyStream(request, false);
}
public async Task String_Bad_KeepResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <string>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
).Init())
this.ShouldStreamOfCopy(request, false);
}
public async Task ByteArray_Bad_DiscardResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <byte[]>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
).Init())
this.ShouldStreamOfCopy(request, success: false, keepRaw: false);
}
public void VoidResponse_Bad_DiscardResponse(object responseValue)
{
using (var request = new MemorySetup <VoidResponse>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
//voidResponse NEVER reads the body so Raw is always false
this.ShouldDirectlyStream(request, success: false);
}
public void DynamicDictionary_Bad_DiscardResponse(object responseValue)
{
using (var request = new MemorySetup <DynamicDictionary>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream),
client => client.Info()
))
this.ShouldDirectlyStream(request, false);
}
public async void DeadNodesAreNotVisited_AndPingedAppropiately_Async()
{
using (var fake = new AutoFake())
{
var dateTimeProvider = ProvideDateTimeProvider(fake);
var config = ProvideConfiguration(dateTimeProvider);
var connection = ProvideConnection(fake, config);
var getCall = FakeCalls.GetCall(fake);
var ok = Task.FromResult(FakeResponse.Ok(config));
var bad = Task.FromResult(FakeResponse.Bad(config));
getCall.ReturnsNextFromSequence(
ok, //info 1 - 9204
bad, //info 2 - 9203 DEAD
ok, //info 2 retry - 9202
ok, //info 3 - 9201
ok, //info 4 - 9204
ok, //info 5 - 9202
ok, //info 6 - 9201
ok, //info 7 - 9204
ok, //info 8 - 9203 (Now > Timeout)
ok //info 9 - 9202
);
var seenNodes = new List <Uri>();
getCall.Invokes((Uri u, IRequestConnectionConfiguration o) => seenNodes.Add(u));
var pingCall = FakeCalls.PingAtConnectionLevelAsync(fake);
pingCall.Returns(ok);
var client1 = fake.Resolve <ElasticsearchClient>();
await client1.InfoAsync(); //info call 1
await client1.InfoAsync(); //info call 2
await client1.InfoAsync(); //info call 3
await client1.InfoAsync(); //info call 4
await client1.InfoAsync(); //info call 5
await client1.InfoAsync(); //info call 6
await client1.InfoAsync(); //info call 7
await client1.InfoAsync(); //info call 8
await client1.InfoAsync(); //info call 9
AssertSeenNodesAreInExpectedOrder(seenNodes);
//4 nodes first time usage + 1 time after the first time 9203 came back to live
pingCall.MustHaveHappened(Repeated.Exactly.Times(5));
}
}
public void VoidResponse_Bad_KeepResponse(object responseValue)
{
using (var request = new MemorySetup <VoidResponse>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
//voidResponse NEVER reads the body so Raw is always false
//and no intermediate stream should be created
this.ShouldDirectlyStream(request, success: false);
}
public void String_Bad_KeepResponse(object responseValue)
{
using (var request = new Requester <string>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
{
var r = request.Result;
r.Success.Should().BeFalse();
Encoding.UTF8.GetBytes(r.Response).Should().NotBeNull().And.BeEquivalentTo(request.ResponseBytes);
r.ResponseRaw.Should().NotBeNull().And.BeEquivalentTo(request.ResponseBytes);
}
}
public void SniffIsCalledAfterItHasGoneOutOfDate_NotWhenItSeesA503()
{
using (var fake = new AutoFake())
{
var dateTimeProvider = fake.Resolve <IDateTimeProvider>();
var nowCall = A.CallTo(() => dateTimeProvider.Now());
nowCall.ReturnsNextFromSequence(
DateTime.UtcNow, //initial sniff time (set even if not sniff_on_startup
DateTime.UtcNow, //info call 1
DateTime.UtcNow, //info call 2
DateTime.UtcNow.AddMinutes(10), //info call 3
DateTime.UtcNow.AddMinutes(10), //set now after sniff 3
DateTime.UtcNow.AddMinutes(10), //info call 4
DateTime.UtcNow.AddMinutes(12) //info call 5
);
var uris = new[] { new Uri("http://localhost:9200") };
var connectionPool = new SniffingConnectionPool(uris);
var config = new ConnectionConfiguration(connectionPool)
.SniffLifeSpan(TimeSpan.FromMinutes(4))
.ExposeRawResponse();
fake.Provide <IConnectionConfigurationValues>(config);
var transport = FakeCalls.ProvideDefaultTransport(fake, dateTimeProvider);
var pingCall = FakeCalls.PingAtConnectionLevel(fake);
pingCall.Returns(FakeResponse.Ok(config));
var sniffCall = FakeCalls.Sniff(fake, config, uris);
var getCall = FakeCalls.GetSyncCall(fake);
getCall.ReturnsNextFromSequence(
FakeResponse.Ok(config), //info 1
FakeResponse.Ok(config), //info 2
FakeResponse.Ok(config), //info 3
FakeResponse.Ok(config), //sniff
FakeResponse.Ok(config), //info 4
FakeResponse.Bad(config) //info 5
);
var client1 = fake.Resolve <ElasticsearchClient>();
var result = client1.Info(); //info call 1
result = client1.Info(); //info call 2
result = client1.Info(); //info call 3
result = client1.Info(); //info call 4
result = client1.Info(); //info call 5
sniffCall.MustHaveHappened(Repeated.Exactly.Once);
nowCall.MustHaveHappened(Repeated.Exactly.Times(7));
//var nowCall = A.CallTo(() => fake.Resolve<IDateTimeProvider>().Sniff(A<Uri>._, A<int>._));
}
}
public void Typed_Bad_DiscardResponse(object responseValue)
{
using (var request = new Requester <Document>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
{
var r = request.Result;
r.Success.Should().BeFalse();
Assert.IsNull(r.Response);
r.ResponseRaw.Should().BeNull();
}
}
public void ByteArray_Bad_DiscardResponse(object responseValue)
{
using (var request = new Requester <byte[]>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
{
var r = request.Result;
r.Success.Should().BeFalse();
r.Response.Should().NotBeNull().And.BeEquivalentTo(request.ResponseBytes);
r.ResponseRaw.Should().BeNull();
}
}
public void Typed_Bad_KeepResponse(object responseValue)
{
using (var request = new Requester <Document>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
{
var r = request.Result;
r.Success.Should().BeFalse();
Assert.IsNull(r.Response);
r.ResponseRaw.Should().NotBeNull().And.BeEquivalentTo(request.ResponseBytes);
}
}
public void DynamicDictionary_Bad_DiscardResponse(object responseValue)
{
using (var request = new Requester <DynamicDictionary>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream),
client => client.Info()
))
{
var r = request.Result;
r.Success.Should().BeFalse();
Assert.IsNull(r.Response);
r.ResponseRaw.Should().BeNull();
}
}
public void VoidResponse_Bad_KeepResponse(object responseValue)
{
using (var request = new Requester <VoidResponse>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
{
var r = request.Result;
r.Success.Should().BeFalse();
//Response and rawresponse should ALWAYS be null for VoidResponse responses
r.Response.Should().BeNull();
r.ResponseRaw.Should().BeNull();
}
}
public void SniffOnConnectionFaultCausesSniffOn503()
{
using (var fake = new AutoFake())
{
var dateTimeProvider = fake.Resolve <IDateTimeProvider>();
var nowCall = A.CallTo(() => dateTimeProvider.Now());
nowCall.Invokes(() =>
{
});
nowCall.Returns(DateTime.UtcNow);
var nodes = new[] { new Uri("http://localhost:9200") };
var connectionPool = new SniffingConnectionPool(nodes);
var config = new ConnectionConfiguration(connectionPool)
.SniffOnConnectionFault();
fake.Provide <IConnectionConfigurationValues>(config);
var transport = FakeCalls.ProvideDefaultTransport(fake, dateTimeProvider);
var connection = fake.Resolve <IConnection>();
var sniffNewNodes = new[]
{
new Uri("http://localhost:9200"),
new Uri("http://localhost:9201")
};
var pingCall = FakeCalls.PingAtConnectionLevel(fake);
pingCall.Returns(FakeResponse.Ok(config));
var sniffCall = FakeCalls.Sniff(fake, config, sniffNewNodes);
var getCall = FakeCalls.GetSyncCall(fake);
getCall.ReturnsNextFromSequence(
FakeResponse.Ok(config), //info 1
FakeResponse.Ok(config), //info 2
FakeResponse.Ok(config), //info 3
FakeResponse.Ok(config), //info 4
FakeResponse.Bad(config) //info 5
);
var client1 = fake.Resolve <ElasticsearchClient>();
client1.Info(); //info call 1
client1.Info(); //info call 2
client1.Info(); //info call 3
client1.Info(); //info call 4
Assert.Throws <MaxRetryException>(() => client1.Info()); //info call 5
sniffCall.MustHaveHappened(Repeated.Exactly.Once);
nowCall.MustHaveHappened(Repeated.Exactly.Times(8));
}
}
public void ShouldRetryOn503_Async()
{
using (var fake = new AutoFake(callsDoNothing: true))
{
fake.Provide <IConnectionConfigurationValues>(_connectionConfig);
FakeCalls.ProvideDefaultTransport(fake);
var getCall = FakeCalls.GetCall(fake);
getCall.Returns(Task.FromResult(FakeResponse.Bad(_connectionConfig)));
var client = fake.Resolve <ElasticsearchClient>();
Assert.Throws <MaxRetryException>(async() => await client.InfoAsync());
getCall.MustHaveHappened(Repeated.Exactly.Times(_retries + 1));
}
}
public void ShouldNotRetryWhenMaxRetriesIs0_Async()
{
using (var fake = new AutoFake(callsDoNothing: true))
{
var connectionConfiguration = new ConnectionConfiguration().MaximumRetries(0);
fake.Provide <IConnectionConfigurationValues>(connectionConfiguration);
FakeCalls.ProvideDefaultTransport(fake);
var getCall = FakeCalls.GetCall(fake);
getCall.Returns(FakeResponse.Bad(connectionConfiguration));
var client = fake.Resolve <ElasticsearchClient>();
Assert.DoesNotThrow(async() => await client.InfoAsync());
getCall.MustHaveHappened(Repeated.Exactly.Once);
}
}
public async void DynamicDictionary_Bad_KeepResponse(object responseValue)
{
using (var request = new AsyncRequester <DynamicDictionary>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream),
client => client.InfoAsync()
))
{
await request.Init();
var r = request.Result;
r.Success.Should().BeFalse();
Assert.IsNull(r.Response);
r.ResponseRaw.Should().NotBeNull().And.BeEquivalentTo(request.ResponseBytes);
}
}
public void ShouldRetryOnSniff500()
{
using (var fake = new AutoFake(callsDoNothing: true))
{
var uris = new[]
{
new Uri("http://localhost:9200"),
new Uri("http://localhost:9201"),
new Uri("http://localhost:9202")
};
var connectionPool = new SniffingConnectionPool(uris, randomizeOnStartup: false);
var config = new ConnectionConfiguration(connectionPool)
.SniffOnConnectionFault();
fake.Provide <IConnectionConfigurationValues>(config);
FakeCalls.ProvideDefaultTransport(fake);
var pingCall = FakeCalls.PingAtConnectionLevel(fake);
pingCall.Returns(FakeResponse.Ok(config));
var sniffCall = FakeCalls.Sniff(fake);
var seenPorts = new List <int>();
sniffCall.ReturnsLazily((Uri u, IRequestConfiguration c) =>
{
seenPorts.Add(u.Port);
return(FakeResponse.Bad(config));
});
var getCall = FakeCalls.GetSyncCall(fake);
getCall.Returns(FakeResponse.Bad(config));
var client = fake.Resolve <ElasticsearchClient>();
var e = Assert.Throws <MaxRetryException>(() => client.Info());
sniffCall.MustHaveHappened(Repeated.Exactly.Times(uris.Count()));
getCall.MustHaveHappened(Repeated.Exactly.Once);
//make sure that if a ping throws an exception it wont
//keep retrying to ping the same node but failover to the next
seenPorts.ShouldAllBeEquivalentTo(uris.Select(u => u.Port));
var sniffException = e.InnerException as SniffException;
sniffException.Should().NotBeNull();
}
}
private void Call(int status, string exceptionType, string exceptionMessage, AutoFake fake, MemoryStream response, bool exposeRawResponse = false)
{
var connectionConfiguration = new ConnectionConfiguration()
.ThrowOnElasticsearchServerExceptions()
.ExposeRawResponse(exposeRawResponse);
fake.Provide <IConnectionConfigurationValues>(connectionConfiguration);
FakeCalls.ProvideDefaultTransport(fake);
var getCall = FakeCalls.GetSyncCall(fake);
getCall.Returns(FakeResponse.Bad(connectionConfiguration, response: response));
var client = fake.Resolve <ElasticsearchClient>();
var e = Assert.Throws <ElasticsearchServerException>(() => client.Info());
AssertServerErrorsException(e, status, exceptionType, exceptionMessage);
getCall.MustHaveHappened(Repeated.Exactly.Once);
}
public void Stream_Bad_DiscardResponse(object responseValue)
{
using (var request = new Requester <Stream>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
{
var r = request.Result;
r.Success.Should().BeFalse();
using (r.Response)
using (var ms = new MemoryStream())
{
r.Response.CopyTo(ms);
var bytes = ms.ToArray();
bytes.Should().NotBeNull().And.BeEquivalentTo(request.ResponseBytes);
}
r.ResponseRaw.Should().BeNull();
}
}
private ElasticsearchResponse <DynamicDictionary> Call(int status, string exceptionType, string exceptionMessage, AutoFake fake, MemoryStream response, bool exposeRawResponse = false)
{
var connectionConfiguration = new ConnectionConfiguration()
.ExposeRawResponse(exposeRawResponse);
fake.Provide <IConnectionConfigurationValues>(connectionConfiguration);
FakeCalls.ProvideDefaultTransport(fake);
var getCall = FakeCalls.GetSyncCall(fake);
getCall.Returns(FakeResponse.Bad(connectionConfiguration, response: response));
var client = fake.Resolve <ElasticsearchClient>();
var result = client.Info();
result.Success.Should().BeFalse();
AssertServerErrorsOnResponse(result, status, exceptionType, exceptionMessage);
getCall.MustHaveHappened(Repeated.Exactly.Once);
return(result);
}
public void ShouldThrowAndNotRetrySniffInformationIsTooOld401()
{
using (var fake = new AutoFake(callsDoNothing: true))
{
var uris = new[]
{
new Uri("http://localhost:9200"),
new Uri("http://localhost:9201"),
new Uri("http://localhost:9202")
};
var connectionPool = new SniffingConnectionPool(uris, randomizeOnStartup: false);
var config = new ConnectionConfiguration(connectionPool)
.SniffLifeSpan(new TimeSpan(1))
.ThrowOnElasticsearchServerExceptions();
fake.Provide <IConnectionConfigurationValues>(config);
FakeCalls.ProvideDefaultTransport(fake);
var pingCall = FakeCalls.PingAtConnectionLevel(fake);
pingCall.Returns(FakeResponse.Ok(config));
var sniffCall = FakeCalls.Sniff(fake);
var seenPorts = new List <int>();
sniffCall.ReturnsLazily((Uri u, IRequestConfiguration c) =>
{
seenPorts.Add(u.Port);
return(FakeResponse.Any(config, 401));
});
var getCall = FakeCalls.GetSyncCall(fake);
getCall.Returns(FakeResponse.Bad(config));
var client = fake.Resolve <ElasticsearchClient>();
var e = Assert.Throws <ElasticsearchServerException>(() => client.Info());
e.Status.Should().Be(401);
sniffCall.MustHaveHappened(Repeated.Exactly.Once);
getCall.MustNotHaveHappened();
}
}
