空手道API框架有没有迭代子值的方法

Question

我的方法取得了90%的成功，但当响应在一个子键中有多个条目时，逻辑就会失败，我无法将一个通用逻辑放在适当的位置，该逻辑将在所有情况下运行。

响应样本为

{
  "items": [
             {
              "id":1,
              "name": "John",
              "sections": [
                          { 
                           "id":1,
                           "description": "John smith" 
                          }
                      ]
           }
         ]
}

现在，我的用例说您搜索John文本，然后items数组将包含许多对象，这些对象的项是。名称或项目。部分。说明应包含“John”关键字

我放置的匹配逻辑运行良好，因为我正在迭代项[]。名称和项目。第[]节。描述

主要的挑战来自于[*]节。说明包含如下所示的多个部分

{
  "items": [
             {
              "id":1,
              "name": "John",
              "sections": [
                          { 
                           "id":1,
                           "description": "John smith" 
                          },
                          { 
                           "id":1,
                           "description": "remain smith of the first object" 
                          }
                      ]
           }
         ]
}

逻辑现在应该适用于项目[]。名称或项目。第[]节。说明（章节[*]的多个条目。说明）

我面临的问题是当我迭代项[]时。名称

它给了我所有的名字和所有的章节。在单独的数组中的描述我想要的是它应该一个接一个地给我。

例如，第一个结果集应提供以下信息

[
"John"
]

and 

[
"John smith"
"remain smith of the first object" 
]

这样我就可以运行现有的逻辑来检查John是否可用。当前，我的逻辑在描述的第一个条目上运行，它不会检查下一个条目或部分。描述，这是以下匹配对象失败的原因，因为“john”出现在描述的第二个条目中

{
  "items": [
             {
              "id":11,
              "name": "SMITH",
              "sections": [
                          { 
                           "id":11,
                           "description": "SMITH" 
                          },
                          { 
                           "id":11,
                           "description": "JOHN Carter" 
                          }
                      ]
           }
         ]
}

我目前使用的匹配逻辑是-

* def matchText = 
"""
function (nameArr, sectionArr, matchingWord)
{
for(var i = 0; i < nameArr.length; i++)
var regEx = new RegExp(matchingWord, 'gi')
var nameMatch = nameArr[i].match(regEx)
var secMatch = sectionArr[i].match(regEx)
if (nameMatch ==null && secMatch == null) {
return false;
}
}
return true;
}
"""
* def getName = get response.items[*].name
* def getDescription = get response.items[*].sections[*].description
* assert matchText(getName,getDescription,'john')

所以，当名称中的长度相同时，这种逻辑就起作用了

Answer 1

示例代码：

Feature: Validation

    Scenario:
        * def resp =
            """
            {
                "items": [
                    {
                        "id": 11,
                        "name": "JOHN",
                        "sections": [
                            {
                                "id": 11,
                                "description": "SMITH"
                            },
                            {
                                "id": 11,
                                "description": "JOHN Carter"
                            }
                        ]
                    }
                ]
            }
            """
    * def names = []
    * def fun =
        """
        function(x){ 
            var json  = x.sections; 
            var temp = x.name
            for(var i = 0; i < json.length; i++) {
                var obj = json[i];
                temp = temp + "," + obj.description
            }                
             karate.appendTo(names, temp);
            }
        """
    * def items = get resp.items[*]
    * karate.forEach(items, fun)
    * match each names == '#regex .*JOHN.*'