1 # Copyright (c) 2021 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
14 """Module with keywords that publish parts of result structure."""
16 from robot.libraries.BuiltIn import BuiltIn
18 from resources.libraries.python.model.util import descend, get_export_data
21 def export_dut_type_and_version(dut_type=u"unknown", dut_version=u"unknown"):
22 """Export the arguments as dut type and version.
24 Robot tends to convert "none" into None, hence the unusual default values.
26 If either argument is missing, the value from robot variable is used.
27 If argument is present, the value is also stored to robot suite variable.
29 :param dut_type: DUT type, e.g. VPP or DPDK.
30 :param dut_version: DUT version as determined by the caller.
31 :type dut_type: Optional[str]
32 :type dut_version: Optiona[str]
33 :raises RuntimeError: If value is neither in argument not robot variable.
35 if dut_type == u"unknown":
36 dut_type = BuiltIn().get_variable_value(u"\\${DUT_TYPE}", u"unknown")
37 if dut_type == u"unknown":
38 raise RuntimeError(u"Dut type not provided.")
40 # We want to set a variable in higher level suite setup
41 # to be available to test setup several levels lower.
42 # Documentation [0] looks like "children" is a keyword argument,
43 # but code [1] lines 1458 and 1511-1512 show
44 # it is just last stringy argument.
45 # [0] http://robotframework.org/robotframework/
46 # 3.1.2/libraries/BuiltIn.html#Set%20Suite%20Variable
47 # [1] https://github.com/robotframework/robotframework/blob/
48 # v3.1.2/src/robot/libraries/BuiltIn.py
49 BuiltIn().set_suite_variable(
50 u"\\${DUT_TYPE}", dut_type, u"children=True"
52 if dut_version == u"unknown":
53 dut_version = BuiltIn().get_variable_value(u"\\${DUT_VERSION}", u"unknown")
54 if dut_type == u"unknown":
55 raise RuntimeError(u"Dut version not provided.")
57 BuiltIn().set_suite_variable(
58 u"\\${DUT_VERSION}", dut_version, u"children=True"
60 data = get_export_data()
61 data[u"dut_type"] = dut_type
62 data[u"dut_version"] = dut_version
65 def append_mrr_value(mrr_value, unit):
66 """Store mrr value to proper place so it is dumped into json.
68 The value is appended only when unit is not empty.
70 :param mrr_value: Forwarding rate from MRR trial.
71 :param unit: Unit of measurement for the rate.
72 :type mrr_value: float
77 data = get_export_data()
78 data[u"result"][u"type"] = u"mrr"
79 rate_node = descend(descend(data[u"result"], u"receive_rate"), "rate")
80 rate_node[u"unit"] = str(unit)
81 values_list = descend(rate_node, u"values", list)
82 values_list.append(float(mrr_value))
83 # TODO: Fill in the bandwidth part for pps?
86 def export_search_bound(text, value, unit, bandwidth=None):
87 """Store bound value and unit.
89 This function works for both NDRPDR and SOAK, decided by text.
91 If a node does not exist, it is created.
92 If a previous value exists, it is overwritten silently.
93 Result type is set (overwritten) to ndrpdr (or soak).
95 Text is used to determine whether it is ndr or pdr, upper or lower bound,
96 as the Robot caller has the information only there.
98 :param text: Info from Robot caller to determime bound type.
99 :param value: The bound value in packets (or connections) per second.
100 :param unit: Rate unit the bound is measured (or estimated) in.
101 :param bandwidth: The same value recomputed into L1 bits per second.
105 :type bandwidth: Optional[float]
108 text = str(text).lower()
109 result_type = u"soak" if u"plrsearch" in text else u"ndrpdr"
110 upper_or_lower = u"upper" if u"upper" in text else u"lower"
111 ndr_or_pdr = u"ndr" if u"ndr" in text else u"pdr"
113 data = get_export_data()
114 result_node = data[u"result"]
115 result_node[u"type"] = result_type
116 rate_item = dict(rate=dict(value=value, unit=unit))
118 rate_item[u"bandwidth"] = dict(value=float(bandwidth), unit=u"bps")
119 if result_type == u"soak":
120 descend(result_node, u"critical_rate")[upper_or_lower] = rate_item
122 descend(result_node, ndr_or_pdr)[upper_or_lower] = rate_item
125 def _add_latency(result_node, percent, whichward, latency_string):
126 """Descend to a corresponding node and add values from latency string.
128 This is an internal block, moved out from export_ndrpdr_latency,
129 as it can be called up to 4 times.
131 :param result_node: UTI tree node to descend from.
132 :param percent: Percent value to use in node key (90, 50, 10, 0).
133 :param whichward: "forward" or "reverse".
134 :param latency_item: Unidir output from TRex utility, min/avg/max/hdrh.
135 :type result_node: dict
140 l_min, l_avg, l_max, l_hdrh = latency_string.split(u"/", 3)
141 whichward_node = descend(result_node, f"latency_{whichward}")
142 percent_node = descend(whichward_node, f"pdr_{percent}")
143 percent_node[u"min"] = int(l_min)
144 percent_node[u"avg"] = int(l_avg)
145 percent_node[u"max"] = int(l_max)
146 percent_node[u"hdrh"] = l_hdrh
147 percent_node[u"unit"] = u"us"
150 def export_ndrpdr_latency(text, latency):
151 """Store NDRPDR hdrh latency data.
153 If "latency" node does not exist, it is created.
154 If a previous value exists, it is overwritten silently.
156 Text is used to determine what percentage of PDR is the load,
157 as the Robot caller has the information only there.
159 Reverse data may be missing, we assume the test was unidirectional.
161 :param text: Info from Robot caller to determime load.
162 :param latency: Output from TRex utility, min/avg/max/hdrh.
164 :type latency: 1-tuple or 2-tuple of str
166 data = get_export_data()
167 result_node = data[u"result"]
175 _add_latency(result_node, percent, u"forward", latency[0])
176 # Else TRex does not support latency measurement for this traffic profile.
179 _add_latency(result_node, percent, u"reverse", latency[1])