Question

我的方法获得了90％的成功，但是当响应在子键之一中有多个条目时，逻辑就会失败，并且我无法放置一种适用于所有情况的通用逻辑。

响应样本为

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

现在我的用例说，您搜索John文本，然后items数组将包含许多对象，这些对象的item.name或items.sections.description应该包含“ John”关键字

我输入的匹配逻辑工作正常，因为我正在遍历items []。name和items.sections []。description

主要挑战来自以下部分：[*]。description中包含如下多个部分

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

该逻辑现在应该起作用 items []。name或items.sections []。description（节[*]。description的多个条目）

我面临的问题是迭代items []。name和items []。sections [*]。description

它给了我所有名称和所有sections.description在单独的数组中，我想要的是它应该给我一个一个。

例如第一个结果集应该在下面给我

[
"John"
]

and 

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

这样我可以运行我现有的逻辑来检查John是否可用。目前，我的逻辑在描述的第一个条目上运行，并且不检查下一个条目或section.description，这是匹配对象下方失败的原因，因为在描述的第二个条目中存在“ 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')

因此，当您在name＆sections.description中具有相同的长度时，但是当sections.description具有多个数组时，此逻辑将无法正确迭代，因此此逻辑有效。这就是我想将名称视为一个对象并将sections.description视为另一个对象的唯一原因，即使其中有多个子ID。

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.*'

空手道API框架有什么方法可以遍历子值

1 个答案: