如果 Switch 语句中不存在 xml 节点，如何通过断言使 groovy 脚本失败

Question

这是我的脚本，

import groovy.xml.*

def xml = '''<ROOT>
<Profile>12</Profile>
<Rate>3072</Rate>
<AudioRate>0</AudioRate>
<GPS>15</GPS>
</ROOT>'''

def Xmlnodes = new XmlParser().parseText(xml)

Xmlnodes.each { setting -> 

switch (setting.name()) {
    case 'Profile': break;
    case 'Rate': break;
    case 'GPS': break;
    default: log.info "Unknown Unit Config Element: " + setting.name()
          }   
}

由于 switch 语句中不存在 AudioRate 节点，我如何使此脚本失败

Answer 1

如果您想验证 XML 是否至少包含一个 <AudioRate/> 元素，则不必在 switch 中执行此操作。

您可以添加一个 assert 来检查您的 XML 中是否至少存在一个 <AudioRate/> 元素，如下所示：

assert Xmlnodes.'**'.findAll { it.name() == 'AudioRate' }.size() > 0

如果您有所需节点名称的列表，如果其中一些名称不在 XML[=59= 中，您可以使用以下代码使测试失败]:

// required node names
['Profile','Rate','AudioRate','GPS'].each { nodeName ->
    assert Xmlnodes.'**'.findAll { it.name() == nodeName }.size() > 0
}

更新：

我想我误解了你的要求，而不是检查你的 XML 至少有所有必需的元素你正在寻找一个检查来验证 XML 只包含允许的元素。如果是这种情况，您可以使用 switch 通过在 default 中添加一个 assert false 来完成。

Xmlnodes.each { setting ->
  switch (setting.name()) {
    case 'Profile': break;
    case 'Rate': break;
    case 'GPS': break;
    default: 
         log.info "Unknown Unit Config Element: " + setting.name()
         assert false
  }   
}

或者以更 Groovy 的方式，检查所有 XML 节点名称是否在允许列表中:

assert ['Profile','Rate','GPS'].containsAll(Xmlnodes*.name())​

更新 2：

根据您在聊天中的评论，如果您想首先检查 <Screen> 的所有子节点名称（如果至少存在）是否在允许列表中，然后执行允许的检查<ROOT> 节点中的名称，您可以执行以下操作：

def xml = '''<ROOT> 
    <Profile>12</Profile> 
    <Rate>3072</Rate> 
    <AudioRate>0</AudioRate> 
    <GPS>15</GPS> 
    <Screen> 
        <Video>12</Video> 
        <Rate>600</Rate> 
        <Camera>1</Camera> 
    </Screen> 
    <Screen> 
        <Devices> 
            <audioDevice>1</audioDevice> 
        </Devices> 
    </Screen>
</ROOT>'''

def Xmlnodes = new XmlParser().parseText(xml)

// <Screen> nodes exists...
if(Xmlnodes.Screen){
    // [Video, Rate, Camera, Devices] --> [Video,Rate,Camera] are from first <Screen> [Devices] are from the second <Screen>
    println Xmlnodes.Screen*.collect { it.name() }.sum() 

    // get all childnode names for all the possible <Screen> elements in one list and
    // check that all names are allowed
    assert ['Video', 'Rate', 'Camera', 'Devices'].containsAll(Xmlnodes.Screen*.collect { it.name() }.sum() )
}

// check that only allowed names are in xml
assert ['Profile','Rate','GPS','AudioRate','Screen'].containsAll(Xmlnodes*.name())

更新 3：

既然你在上一条评论中说你还想知道 XML 上未知标签的名称，那么你可以执行 - 从您预定义的节点名称列表中进行操作，这样其余的就是未知元素；这是我最后一次尝试：

def Xmlnodes = new XmlParser().parseText(xml)

def screenUnknown = []

// <Screen> nodes exists...
if(Xmlnodes.Screen){
    // get all unknown elements
    screenUnknown = Xmlnodes.Screen*.collect { it.name() }.sum() - ['Video', 'Rate', 'Camera', 'Devices']
}

// get all unknown nodes in root
def rootUnknown = Xmlnodes*.name() -  ['Profile','Rate','GPS','AudioRate','Screen']

println "unknown in <Root>: ${rootUnknown}"
println "unknown in <Screen>: ${screenUnknown}"

// optionally you can make an assert to check
// that there aren't unknown elements
assert rootUnknown.size() == 0, 'THE ARE UNKNOWN ELEMENTS IN <ROOT>'
assert screenUnknown.size()  == 0,  'THE ARE UNKNOWN ELEMENTS IN <SCREEN>'

希望对您有所帮助，

Answer 2

也许是这样的？

...
def Xmlnodes = new XmlParser().parseText(xml)

Xmlnodes.each { setting -> 
    assert setting.name() in ['Profile','Rate','GPS'] : "Unknown Unit Config Element: ${setting.name()}"
}