[I] public void AvailableOnResponse()
{
/**
* We'll use a Sniffing connection pool here since it sniffs on startup and pings before
* first usage, so we can get an audit trail with a few events out
*/
var pool = new SniffingConnectionPool(new [] { TestConnectionSettings.CreateUri() });
var connectionSettings = new ConnectionSettings(pool)
.DefaultMappingFor <Project>(i => i
.IndexName("project")
);
var client = new ElasticClient(connectionSettings);
/**
* After issuing the following request
*/
var response = client.Search <Project>(s => s
.MatchAll()
);
/**
* The audit trail is provided in the <<debug-information, Debug information>> in a human
* readable fashion, similar to
*
* ....
* Valid NEST response built from a successful low level call on POST: /project/doc/_search
* # Audit trail of this API call:
* - [1] SniffOnStartup: Took: 00:00:00.0360264
* - [2] SniffSuccess: Node: http://localhost:9200/ Took: 00:00:00.0310228
* - [3] PingSuccess: Node: http://127.0.0.1:9200/ Took: 00:00:00.0115074
* - [4] HealthyResponse: Node: http://127.0.0.1:9200/ Took: 00:00:00.1477640
* # Request:
* <Request stream not captured or already read to completion by serializer. Set DisableDirectStreaming() on ConnectionSettings to force it to be set on the response.>
* # Response:
* <Response stream not captured or already read to completion by serializer. Set DisableDirectStreaming() on ConnectionSettings to force it to be set on the response.>
* ....
*
* to help with troubleshootin
*/
var debug = response.DebugInformation;
/**
* But can also be accessed manually:
*/
response.ApiCall.AuditTrail.Count.Should().Be(4, "{0}", debug);
response.ApiCall.AuditTrail[0].Event.Should().Be(AuditEvent.SniffOnStartup, "{0}", debug);
response.ApiCall.AuditTrail[1].Event.Should().Be(AuditEvent.SniffSuccess, "{0}", debug);
response.ApiCall.AuditTrail[2].Event.Should().Be(AuditEvent.PingSuccess, "{0}", debug);
response.ApiCall.AuditTrail[3].Event.Should().Be(AuditEvent.HealthyResponse, "{0}", debug);
/**
* Each audit has a started and ended `DateTime` on it that will provide
* some understanding of how long it took
*/
response.ApiCall.AuditTrail
.Should().OnlyContain(a => a.Ended - a.Started > TimeSpan.Zero);
}
// hide
private IRequestPipeline CreatePipeline(
Func <IEnumerable <Uri>, IConnectionPool> setupPool, Func <ConnectionSettings, ConnectionSettings> settingsSelector = null, IDateTimeProvider dateTimeProvider = null, InMemoryConnection connection = null)
{
var pool = setupPool(new[] { TestConnectionSettings.CreateUri(), TestConnectionSettings.CreateUri(9201) });
var settings = new ConnectionSettings(pool, connection ?? new InMemoryConnection());
settings = settingsSelector?.Invoke(settings) ?? settings;
return(new FixedPipelineFactory(settings, dateTimeProvider ?? DateTimeProvider.Default).Pipeline);
}
private RequestPipeline CreatePipeline()
{
var uri = TestConnectionSettings.CreateUri(this._cluster.Nodes.First().Port ?? 9200);
this._settings = new ConnectionSettings(new SniffingConnectionPool(new[] { uri }));
var pipeline = new RequestPipeline(this._settings, DateTimeProvider.Default, new RecyclableMemoryStreamFactory(), new SearchRequestParameters());
return(pipeline);
}
//[I]
public void ServerTestWhenThrowExceptionsDisabled()
{
var settings = new ConnectionSettings(TestConnectionSettings.CreateUri(_port));
var client = new ElasticClient(settings);
var response = client.GetMapping <Project>(s => s.Index("doesntexist"));
// HttpClient does not throw on "known error" status codes (i.e. 404) thus OriginalException should not be set
response.ApiCall.OriginalException.Should().BeNull();
}
//[I]
public void ServerTestWhenThrowExceptionsEnabled()
{
var settings = new ConnectionSettings(TestConnectionSettings.CreateUri(_port))
.ThrowExceptions();
var client = new ElasticClient(settings);
var exception = Assert.Throws <ElasticsearchClientException>(() => client.GetMapping <Project>(s => s.Index("doesntexist")));
// HttpClient does not throw on "known error" status codes (i.e. 404) thus the inner exception should not be set
exception.InnerException.Should().BeNull();
exception.Response.Should().NotBeNull();
}
public void ExpressionsAreCachedButSeeDifferentTypes()
{
var client = TestClient.Default;
var fieldNameOnA = client.Infer.Field(Field <A>(p => p.C.Name));
var fieldNameOnB = client.Infer.Field(Field <B>(p => p.C.Name));
/**
* Here we have two similarly shaped expressions, one coming from A and one from B
* that will resolve to the same field name, as expected
*/
fieldNameOnA.Should().Be("c.name");
fieldNameOnB.Should().Be("c.name");
/**
* now we create a new connection settings with a re-map for `C` on class `A` to `"d"`
* now when we resolve the field path for property `C` on `A`, it will be different than
* for property `C` on `B`
*/
var newConnectionSettings = new TestConnectionSettings()
.DefaultMappingFor <A>(m => m
.PropertyName(p => p.C, "d")
);
var newClient = new ElasticClient(newConnectionSettings);
fieldNameOnA = newClient.Infer.Field(Field <A>(p => p.C.Name));
fieldNameOnB = newClient.Infer.Field(Field <B>(p => p.C.Name));
fieldNameOnA.Should().Be("d.name");
fieldNameOnB.Should().Be("c.name");
/** however we didn't break inference on the first client instance using its separate connection settings */
fieldNameOnA = client.Infer.Field(Field <A>(p => p.C.Name));
fieldNameOnB = client.Infer.Field(Field <B>(p => p.C.Name));
fieldNameOnA.Should().Be("c.name");
fieldNameOnB.Should().Be("c.name");
}
