protected override void ExpectResponse(IIndexResponse response)
        {
            response.ShouldBeValid();

            var searchResponse = Client.Search <Document>(s => s
                                                          .Index(CallIsolatedValue)
                                                          .Query(q => q
                                                                 .Match(m => m
                                                                        .Field(a => a.Attachment.Content)
                                                                        .Query("NEST mapper")
                                                                        )
                                                                 )
                                                          );

            searchResponse.ShouldBeValid();
            searchResponse.Documents.Count().Should().Be(1);

            searchResponse = Client.Search <Document>(s => s
                                                      .Index(CallIsolatedValue)
                                                      .StoredFields(f => f.Field(d => d.Attachment.ContentType))
                                                      .Query(q => q
                                                             .MatchAll()
                                                             )
                                                      );

            searchResponse.ShouldBeValid();
            searchResponse.Documents.Count().Should().Be(1);

            // mapper attachment extracts content type
            searchResponse.Hits.First()
            .Fields
            .ValueOf <Document, string>(d => d.Attachment.ContentType)
            .Should().Be("application/pdf");
        }
        protected override void ExpectResponse(IIndexResponse response)
        {
            response.ShouldBeValid();

            // search on language (document is detected as French)
            var searchResponse = Client.Search <Document>(s => s
                                                          .StoredFields(f => f
                                                                        .Field(d => d.Attachment.Name)
                                                                        .Field(d => d.Attachment.Author)
                                                                        .Field(d => d.Attachment.Content)
                                                                        .Field(d => d.Attachment.ContentLength)
                                                                        .Field(d => d.Attachment.ContentType)
                                                                        .Field(d => d.Attachment.Date)
                                                                        .Field(d => d.Attachment.Keywords)
                                                                        .Field(d => d.Attachment.Language)
                                                                        .Field(d => d.Attachment.Title)
                                                                        )
                                                          .Index(CallIsolatedValue)
                                                          .Query(q => q
                                                                 .MatchAll()
                                                                 )
                                                          );

            var documents = new List <Document>();

            // try to set all the metadata
            foreach (var hit in searchResponse.Hits)
            {
                var document = new Document {
                    Attachment = new Nest.Attachment()
                };
                document.Attachment.Name          = hit.Fields.ValueOf <Document, string>(d => d.Attachment.Name);
                document.Attachment.Author        = hit.Fields.ValueOf <Document, string>(d => d.Attachment.Author);
                document.Attachment.Content       = hit.Fields.ValueOf <Document, string>(d => d.Attachment.Content);
                document.Attachment.ContentLength = hit.Fields.ValueOf <Document, long?>(d => d.Attachment.ContentLength);
                document.Attachment.ContentType   = hit.Fields.ValueOf <Document, string>(d => d.Attachment.ContentType);
                document.Attachment.Date          = hit.Fields.ValueOf <Document, DateTime?>(d => d.Attachment.Date);
                document.Attachment.Keywords      = hit.Fields.ValueOf <Document, string>(d => d.Attachment.Keywords);
                document.Attachment.Language      = hit.Fields.ValueOf <Document, string>(d => d.Attachment.Language);
                document.Attachment.Title         = hit.Fields.ValueOf <Document, string>(d => d.Attachment.Title);
                documents.Add(document);
            }

            documents.Should().NotBeEmpty();
            documents.Count.Should().Be(1);

            var firstDocument = documents[0];

            // This is the only metadata that can be extracted from the sample doc
            firstDocument.Attachment.Title.Should().Be("Attachment Test Document");
            firstDocument.Attachment.ContentType.Should().Be("application/pdf");
            firstDocument.Attachment.Author.Should().Be("Russ Cam");
            firstDocument.Attachment.Keywords.Should().Be("nest,test,document");
            firstDocument.Attachment.Date.Should().Be(new DateTime(2016, 12, 08, 3, 5, 13, DateTimeKind.Utc));
            firstDocument.Attachment.ContentLength.Should().Be(315745);
            firstDocument.Attachment.Content.Should().Contain("mapper-attachment support");
            firstDocument.Attachment.Language.Should().Be("fr");
        }
        protected override void ExpectResponse(IIndexResponse response)
        {
            response.ShouldBeValid();

            // search on attachment name
            var searchResponse = Client.Search <Document>(s => s
                                                          .Index(CallIsolatedValue)
                                                          .Query(q => q
                                                                 .Match(m => m
                                                                        .Field(a => a.Attachment.Name)
                                                                        .Query("name")
                                                                        )
                                                                 )
                                                          );

            searchResponse.ShouldBeValid();
            searchResponse.Documents.Count().Should().Be(1);

            // search on content type
            searchResponse = Client.Search <Document>(s => s
                                                      .Index(CallIsolatedValue)
                                                      .Query(q => q
                                                             .Match(m => m
                                                                    .Field(a => a.Attachment.ContentType)
                                                                    .Query("pdf")
                                                                    )
                                                             )
                                                      );

            searchResponse.ShouldBeValid();
            searchResponse.Documents.Count().Should().Be(1);

            // search on language
            searchResponse = Client.Search <Document>(s => s
                                                      .Index(CallIsolatedValue)
                                                      .Query(q => q
                                                             .Match(m => m
                                                                    .Field(a => a.Attachment.Language)
                                                                    .Query("en")
                                                                    )
                                                             )
                                                      );

            searchResponse.ShouldBeValid();
            searchResponse.Documents.Count().Should().Be(1);
        }
        protected override void ExpectResponse(IIndexResponse response)
        {
            response.ShouldBeValid();

            var searchResponse = Client.Search <Document>(s => s
                                                          .Index(CallIsolatedValue)
                                                          .Query(q => q
                                                                 .Match(m => m
                                                                        .Field(a => a.Attachment.Content)
                                                                        .Query("NEST mapper")
                                                                        )
                                                                 )
                                                          );

            searchResponse.ShouldBeValid();
            searchResponse.Documents.Count().Should().Be(1);
        }
        protected override void ExpectResponse(IIndexResponse response)
        {
            response.ShouldBeValid();

            // search on language (document is detected as French)
            var searchResponse = Client.Search <Document>(s => s
                                                          .Index(CallIsolatedValue)
                                                          .Query(q => q
                                                                 .Match(m => m
                                                                        .Field(a => a.Attachment.Language)
                                                                        .Query("fr")
                                                                        )
                                                                 )
                                                          );

            searchResponse.ShouldBeValid();
            searchResponse.Documents.Count().Should().Be(1);
        }
Beispiel #6
0
        protected override void ExpectResponse(IIndexResponse response)
        {
            response.ShouldBeValid();

            var getResponse = Client.Get <Project>(response.Id, g => g.Routing(CallIsolatedValue));

            getResponse.ShouldBeValid();
            getResponse.Source.Should().NotBeNull();
            getResponse.Source.LeadDeveloper.Should().NotBeNull();

            var geoIp = getResponse.Source.LeadDeveloper.GeoIp;

            geoIp.Should().NotBeNull();
            geoIp.ContinentName.Should().Be("Europe");
            geoIp.CityName.Should().Be("Reykjavik");
            geoIp.CountryIsoCode.Should().Be("IS");
            geoIp.RegionName.Should().Be("Capital Region");
            geoIp.Location.Should().NotBeNull();
            geoIp.Location.Latitude.Should().Be(64.1383);
            geoIp.Location.Longitude.Should().Be(-21.8959);
        }
        protected override void ExpectResponse(IIndexResponse response)
        {
            response.ShouldBeValid();

            var getResponse = this.Client.Get <IngestedAttachment>(response.Id, g => g.Index(CallIsolatedValue));

            getResponse.ShouldBeValid();
            getResponse.Source.Should().NotBeNull();

            getResponse.Source.Attachment.Should().NotBeNull();

            var attachment = getResponse.Source.Attachment;

            attachment.Title.Should().Be("Attachment Test Document");
            attachment.Keywords.Should().Be("nest,test,document");
            attachment.Date.Should().Be(new DateTime(2016, 12, 08, 3, 5, 13, DateTimeKind.Utc));
            attachment.ContentType.Should().Be("application/pdf");
            attachment.Author.Should().Be("Russ Cam");
            attachment.Language.Should().Be("fr");
            attachment.ContentLength.Should().Be(96);
            attachment.Content.Should().Contain("mapper-attachment support");
        }