elasticsearch ElasticSearch NEST 5.6.1单元测试查询

我为elastic search编写了一系列查询，我想为它们编写一个单元测试。通过这篇文章，我可以进行一次普遍的嘲弄。但是当我试图查看从我的查询生成的Json时，我没有以任何方式获得它。 我试图关注这篇文章，但它只与旧版本的Nest相关，因为

ConnectionStatus

和

RequestInformation

方法不再适用于

ISearchResponse

对象

我的测试结果如下：

[TestMethod]
 public void VerifyElasticFuncJson()
{
//Arrange
var elasticService = new Mock<IElasticService>();
var elasticClient = new Mock<IElasticClient>();
var clinet = new ElasticClient();
var searchResponse = new Mock<ISearchResponse<ElasticLog>>();
elasticService.Setup(es => es.GetConnection())
    .Returns(elasticClient.Object);

elasticClient.Setup(ec => ec.Search(It.IsAny<Func<SearchDescriptor<ElasticLog>, 
                          ISearchRequest>>())).
                          Returns(searchResponse.Object);

//Act
var service = new ElasticCusipInfoQuery(elasticService.Object);
var FindFunc = service.MatchCusip("CusipA", HostName.GSMSIMPAPPR01, 
                                        LogType.Serilog);
var con = GetConnection();
var search =  con.Search<ElasticLog>(sd => sd
             .Type(LogType.Serilog)
             .Index("logstash-*")
             .Query(q => q
             .Bool(b => b
                    .Must(FindFunc)
                    )
               )     
             );
 **HERE I want to get the JSON** and assert it look as expected**
}

[TestMethod]
public void VerifyElasticFuncJson（）
{
//安排
var elasticService=new Mock（）；
var elasticClient=new Mock（）；
var clinet=新的ElasticClient（）；
var searchResponse=new Mock（）；
elasticService.Setup（es=>es.GetConnection（））
.Returns（elasticClient.Object）；
elasticClient.Setup（ec=>ec.Search（It.IsAny（）））。
返回（searchResponse.Object）；
//表演
var服务=新的ElasticCusipInfo查询（elasticService.Object）；
var FindFunc=service.MatchCusip（“CusipA”，HostName.GSMSIMPAPPR01，
LogType.Serilog）；
var con=GetConnection（）；
var search=con.search（sd=>sd
.Type（LogType.Serilog）
.索引（“logstash-*”）
.Query（q=>q
.Bool（b=>b
.Must（FindFunc）
)
)     
);
**在这里，我想得到JSON**并断言它看起来与预期的一样**
}

---

是否有其他方法可以实现我的要求？

最好的方法是使用内存连接中的

捕获请求字节，并将其与预期的JSON进行比较。这就是NEST的单元测试所做的。差不多

private static void Main()
{
    var pool = new SingleNodeConnectionPool(new Uri("http://localhost:9200"));
    var connectionSettings = new ConnectionSettings(pool, new InMemoryConnection())
        .DefaultIndex("default")
        .DisableDirectStreaming();

    var client = new ElasticClient(connectionSettings);

    // Act
    var searchResponse = client.Search<Question>(s => s
       .Query(q => (q
         .Match(m => m
               .Field(f => f.Title)
               .Query("Kibana")
         ) || q
         .Match(m => m
               .Field(f => f.Title)
               .Query("Elasticsearch")
               .Boost(2)
         )) && +q
         .Range(t => t
               .Field(f => f.Score)
               .GreaterThan(0)
         )
       )
    );

    var actual = searchResponse.RequestJson();

    var expected = new 
    {
        query = new {
            @bool = new {
                must = new object[] {
                    new {
                        @bool = new {
                            should = new object[] {
                                new {
                                    match = new {
                                        title = new {
                                            query = "Kibana"
                                        }
                                    }
                                },
                                new {
                                    match = new {
                                        title = new {
                                            query = "Elasticsearch",
                                            boost = 2d
                                        }
                                    }
                                }
                            },
                        }
                    },
                    new {
                        @bool = new {
                            filter = new [] {
                                new {
                                    range = new {
                                        score = new {
                                            gt = 0d
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    };

    // Assert
    Console.WriteLine(JObject.DeepEquals(JToken.FromObject(expected), JToken.Parse(actual)));
}

public static class Extensions
{
    public static string RequestJson(this IResponse response) =>
        Encoding.UTF8.GetString(response.ApiCall.RequestBodyInBytes);
}

private static void Main（）
{
变量池=新的SingleNodeConnectionPool（新Uri（“http://localhost:9200"));
var connectionSettings=新连接设置（池，新InMemoryConnection（））
.DefaultIndex（“默认”）
.DisableDirectStreaming（）；
var客户端=新的ElasticClient（连接设置）；
//表演
var searchResponse=client.Search（s=>s
.Query（q=>（q
.Match（m=>m
.Field（f=>f.Title）
.Query（“Kibana”）
)| | q
.Match（m=>m
.Field（f=>f.Title）
.Query（“Elasticsearch”）
.Boost（2）
))&&+q
.范围（t=>t
.Field（f=>f.Score）
.大于（0）
)
)
);
var-actual=searchResponse.RequestJson（）；
预期风险值=新
{
查询=新建{
@bool=新{
必须=新对象[]{
新的{
@bool=新{
应=新对象[]{
新的{
匹配=新{
标题=新{
query=“Kibana”
}
}
},
新的{
匹配=新{
标题=新{
query=“Elasticsearch”，
升压=2d
}
}
}
},
}
},
新的{
@bool=新{
过滤器=新[]{
新的{
范围=新{
分数=新{
gt=0d
}
}
}
}
}
}
}
}
}
};
//断言
WriteLine（JObject.DeepEquals（JToken.FromObject（预期），JToken.Parse（实际））；
}
公共静态类扩展
{
公共静态字符串RequestJson（此IResponse响应）=>
Encoding.UTF8.GetString（response.ApiCall.RequestBodyInBytes）；
}

我对预期的JSON使用了匿名类型，因为它比转义的JSON字符串更容易使用

需要注意的是，即使Json对象中存在重复的对象键（只要最后一个键/值匹配），Json.NET的
JObject.DeepEquals（…）
也将返回
true
。不过，如果只是序列化嵌套搜索，可能不会遇到这种情况，但需要注意的是

如果要让许多测试检查序列化，您需要创建一个
ConnectionSettings
实例并与所有人共享，这样您就可以利用其中的内部缓存，并且您的测试将比在每个测试中实例化一个新实例更快地运行。
谢谢，我想你也回答了Nest 2.x上的帖子。我没有
RequestJson（）
中用于
ISearchResponse
对象的方法…我使用的是Nest 5.6。也许这与道歉有关，我想把它添加到回答中，这只是一个扩展方法：）现在添加：）不用担心，很乐意帮助：）一个后续问题。如果我想查询一个嵌套的字段，我如何以这种方式进行查询？例如，
filled.Host
我无法使用json定义的属性，也无法在名称中添加一个点作为wellBest来单独提问。带点的字段名可以用字典或JObject处理。查看嵌套查询文档：