Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 1 | # Copyright 2017-present Open Networking Foundation |
| 2 | # |
| 3 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | # you may not use this file except in compliance with the License. |
| 5 | # You may obtain a copy of the License at |
| 6 | # |
| 7 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | # |
| 9 | # Unless required by applicable law or agreed to in writing, software |
| 10 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | # See the License for the specific language governing permissions and |
| 13 | # limitations under the License. |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 14 | # voltctl common functions |
| 15 | |
| 16 | *** Settings *** |
| 17 | Documentation Library for various utilities |
| 18 | Library SSHLibrary |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 19 | Library String |
| 20 | Library DateTime |
| 21 | Library Process |
| 22 | Library Collections |
| 23 | Library RequestsLibrary |
| 24 | Library OperatingSystem |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 25 | Resource ./utils.robot |
Matteo Scandolo | eb26a84 | 2020-05-08 10:06:24 -0700 | [diff] [blame] | 26 | Resource ./flows.robot |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 27 | |
| 28 | *** Keywords *** |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 29 | Test Empty Device List |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 30 | [Documentation] Verify that there are no devices in the system |
| 31 | ${rc} ${output}= Run and Return Rc and Output ${VOLTCTL_CONFIG}; voltctl device list -o json |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 32 | Should Be Equal As Integers ${rc} 0 |
| 33 | ${jsondata}= To Json ${output} |
| 34 | Log ${jsondata} |
| 35 | ${length}= Get Length ${jsondata} |
David Bainbridge | f81cd64 | 2019-11-20 00:14:47 +0000 | [diff] [blame] | 36 | Should Be Equal As Integers ${length} 0 |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 37 | |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 38 | Create Device |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 39 | [Arguments] ${ip} ${port} ${type}=openolt |
You Wang | 2b55064 | 2019-10-07 14:39:48 -0700 | [diff] [blame] | 40 | [Documentation] Creates a device in VOLTHA |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 41 | #create/preprovision device |
Gilles Depatie | 675a206 | 2019-10-22 12:44:42 -0400 | [diff] [blame] | 42 | ${rc} ${device_id}= Run and Return Rc and Output |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 43 | ... ${VOLTCTL_CONFIG}; voltctl device create -t ${type} -H ${ip}:${port} |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 44 | Should Be Equal As Integers ${rc} 0 |
| 45 | [Return] ${device_id} |
| 46 | |
| 47 | Enable Device |
| 48 | [Arguments] ${device_id} |
Zack Williams | ec53a1b | 2019-09-16 15:50:52 -0700 | [diff] [blame] | 49 | [Documentation] Enables a device in VOLTHA |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 50 | ${rc} ${output}= Run and Return Rc and Output |
| 51 | ... ${VOLTCTL_CONFIG}; voltctl device enable ${device_id} |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 52 | Should Be Equal As Integers ${rc} 0 |
| 53 | |
Suchitra Vemuri | 6db8941 | 2019-11-14 14:52:54 -0800 | [diff] [blame] | 54 | Disable Device |
| 55 | [Arguments] ${device_id} |
Hardik Windlass | aaea340 | 2020-03-10 19:45:45 +0530 | [diff] [blame] | 56 | [Documentation] Disables a device in VOLTHA |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 57 | ${rc} ${output}= Run and Return Rc and Output |
| 58 | ... ${VOLTCTL_CONFIG}; voltctl device disable ${device_id} |
Suchitra Vemuri | 6db8941 | 2019-11-14 14:52:54 -0800 | [diff] [blame] | 59 | Should Be Equal As Integers ${rc} 0 |
| 60 | |
Hardik Windlass | aaea340 | 2020-03-10 19:45:45 +0530 | [diff] [blame] | 61 | Delete Device |
| 62 | [Arguments] ${device_id} |
| 63 | [Documentation] Deletes a device in VOLTHA |
| 64 | ${rc} ${output}= Run and Return Rc and Output |
| 65 | ... ${VOLTCTL_CONFIG}; voltctl device delete ${device_id} |
| 66 | Should Be Equal As Integers ${rc} 0 |
| 67 | |
Hema | df00368 | 2020-04-28 21:22:22 +0530 | [diff] [blame] | 68 | Reboot Device |
| 69 | [Arguments] ${device_id} |
| 70 | [Documentation] Reboot the OLT using voltctl command |
| 71 | ${rc} ${output}= Run and Return Rc and Output |
| 72 | ... ${VOLTCTL_CONFIG}; voltctl device reboot ${device_id} |
| 73 | Should Be Equal As Integers ${rc} 0 |
| 74 | |
David Bainbridge | f81cd64 | 2019-11-20 00:14:47 +0000 | [diff] [blame] | 75 | Disable Devices In Voltha |
| 76 | [Documentation] Disables all the known devices in voltha |
| 77 | [Arguments] ${filter} |
| 78 | ${arg}= Set Variable ${EMPTY} |
| 79 | ${arg}= Run Keyword If len('${filter}'.strip()) != 0 Set Variable --filter ${filter} |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 80 | ${rc} ${devices}= Run and Return Rc and Output |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 81 | ... ${VOLTCTL_CONFIG}; voltctl device list -m 8MB ${arg} --orderby Root -q | xargs echo -n |
David Bainbridge | f81cd64 | 2019-11-20 00:14:47 +0000 | [diff] [blame] | 82 | Should Be Equal As Integers ${rc} 0 |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 83 | ${rc} ${output}= Run Keyword If len('${devices}') != 0 Run and Return Rc and Output |
| 84 | ... ${VOLTCTL_CONFIG}; voltctl device disable ${devices} |
David Bainbridge | f81cd64 | 2019-11-20 00:14:47 +0000 | [diff] [blame] | 85 | Run Keyword If len('${devices}') != 0 Should Be Equal As Integers ${rc} 0 |
| 86 | |
| 87 | Test Devices Disabled In Voltha |
| 88 | [Documentation] Tests to verify that all devices in VOLTHA are disabled |
| 89 | [Arguments] ${filter} |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 90 | ${rc} ${count}= Run and Return Rc and Output |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 91 | ... ${VOLTCTL_CONFIG}; voltctl device list -m 8MB --filter '${filter},AdminState!=DISABLED' -q | wc -l |
David Bainbridge | f81cd64 | 2019-11-20 00:14:47 +0000 | [diff] [blame] | 92 | Should Be Equal As Integers ${rc} 0 |
| 93 | Should Be Equal As Integers ${count} 0 |
| 94 | |
| 95 | Delete Devices In Voltha |
| 96 | [Documentation] Disables all the known devices in voltha |
| 97 | [Arguments] ${filter} |
| 98 | ${arg}= Set Variable ${EMPTY} |
| 99 | ${arg}= Run Keyword If len('${filter}'.strip()) != 0 Set Variable --filter ${filter} |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 100 | ${rc} ${devices}= Run and Return Rc and Output |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 101 | ... ${VOLTCTL_CONFIG}; voltctl device list ${arg} -m 8MB --orderby Root -q | xargs echo -n |
David Bainbridge | f81cd64 | 2019-11-20 00:14:47 +0000 | [diff] [blame] | 102 | Should Be Equal As Integers ${rc} 0 |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 103 | ${rc} ${output}= Run Keyword If len('${devices}') != 0 Run and Return Rc and Output |
| 104 | ... ${VOLTCTL_CONFIG}; voltctl device delete ${devices} |
David Bainbridge | f81cd64 | 2019-11-20 00:14:47 +0000 | [diff] [blame] | 105 | Run Keyword If len('${devices}') != 0 Should Be Equal As Integers ${rc} 0 |
| 106 | |
Suchitra Vemuri | 00d147d | 2019-09-13 13:07:32 -0700 | [diff] [blame] | 107 | Get Device Flows from Voltha |
| 108 | [Arguments] ${device_id} |
Zack Williams | ec53a1b | 2019-09-16 15:50:52 -0700 | [diff] [blame] | 109 | [Documentation] Gets device flows from VOLTHA |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 110 | ${rc} ${output}= Run and Return Rc and Output |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 111 | ... ${VOLTCTL_CONFIG}; voltctl device flows ${device_id} -m 8MB |
Suchitra Vemuri | 00d147d | 2019-09-13 13:07:32 -0700 | [diff] [blame] | 112 | Should Be Equal As Integers ${rc} 0 |
| 113 | [Return] ${output} |
| 114 | |
| 115 | Get Logical Device Output from Voltha |
| 116 | [Arguments] ${device_id} |
Zack Williams | ec53a1b | 2019-09-16 15:50:52 -0700 | [diff] [blame] | 117 | [Documentation] Gets logicaldevice flows and ports from VOLTHA |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 118 | ${rc1} ${flows}= Run and Return Rc and Output |
| 119 | ... ${VOLTCTL_CONFIG}; voltctl logicaldevice flows ${device_id} |
| 120 | ${rc2} ${ports}= Run and Return Rc and Output |
David K. Bainbridge | bd5ebd2 | 2020-02-04 10:01:18 -0800 | [diff] [blame] | 121 | ... ${VOLTCTL_CONFIG}; voltctl logicaldevice port list ${device_id} |
Suchitra Vemuri | 00d147d | 2019-09-13 13:07:32 -0700 | [diff] [blame] | 122 | Log ${flows} |
| 123 | Log ${ports} |
| 124 | Should Be Equal As Integers ${rc1} 0 |
| 125 | Should Be Equal As Integers ${rc2} 0 |
| 126 | |
| 127 | Get Device Output from Voltha |
| 128 | [Arguments] ${device_id} |
Zack Williams | ec53a1b | 2019-09-16 15:50:52 -0700 | [diff] [blame] | 129 | [Documentation] Gets device flows and ports from VOLTHA |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 130 | ${rc1} ${flows}= Run and Return Rc and Output |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 131 | ... ${VOLTCTL_CONFIG}; voltctl device flows ${device_id} -m 8MB |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 132 | ${rc2} ${ports}= Run and Return Rc and Output |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 133 | ... ${VOLTCTL_CONFIG}; voltctl device port list ${device_id} -m 8MB |
Suchitra Vemuri | 00d147d | 2019-09-13 13:07:32 -0700 | [diff] [blame] | 134 | Log ${flows} |
| 135 | Log ${ports} |
| 136 | Should Be Equal As Integers ${rc1} 0 |
| 137 | Should Be Equal As Integers ${rc2} 0 |
| 138 | |
Suchitra Vemuri | 1a970a6 | 2019-11-26 12:52:16 -0800 | [diff] [blame] | 139 | Get Device List from Voltha |
| 140 | [Documentation] Gets Device List Output from Voltha |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 141 | ${rc1} ${devices}= Run and Return Rc and Output ${VOLTCTL_CONFIG}; voltctl device list -m 8MB |
Suchitra Vemuri | 1a970a6 | 2019-11-26 12:52:16 -0800 | [diff] [blame] | 142 | Log ${devices} |
| 143 | Should Be Equal As Integers ${rc1} 0 |
| 144 | |
Matteo Scandolo | 616daab | 2020-05-13 11:49:24 -0700 | [diff] [blame] | 145 | Get Device List from Voltha by type |
| 146 | [Documentation] Gets Device List Output from Voltha applying filtering by device type |
| 147 | [Arguments] ${type} |
| 148 | ${rc1} ${devices}= Run and Return Rc and Output |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 149 | ... ${VOLTCTL_CONFIG}; voltctl device list -m 8MB -f Type=${type} -o json |
Matteo Scandolo | 616daab | 2020-05-13 11:49:24 -0700 | [diff] [blame] | 150 | Log ${devices} |
| 151 | Should Be Equal As Integers ${rc1} 0 |
| 152 | Return From Keyword ${devices} |
| 153 | |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 154 | Get Logical Device List from Voltha |
| 155 | [Documentation] Gets Logical Device List Output from Voltha (in json format) |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 156 | ${rc1} ${devices}= Run and Return Rc and Output |
| 157 | ... ${VOLTCTL_CONFIG}; voltctl logicaldevice list -m 8MB -o json |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 158 | Log ${devices} |
| 159 | Should Be Equal As Integers ${rc1} 0 |
| 160 | Return From Keyword ${devices} |
| 161 | |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 162 | Validate Device |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 163 | [Documentation] |
ubuntu | 6b6e7d4 | 2020-03-02 12:35:42 -0800 | [diff] [blame] | 164 | ... Parses the output of "voltctl device list" and inspects a device ${id}, specified as either |
| 165 | ... the serial number or device ID. Arguments are matched for device states of: "admin_state", |
| 166 | ... "oper_status", and "connect_status" |
| 167 | [Arguments] ${admin_state} ${oper_status} ${connect_status} |
| 168 | ... ${id}=${EMPTY} ${onu_reason}=${EMPTY} ${onu}=False |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 169 | ${rc} ${output}= Run and Return Rc and Output ${VOLTCTL_CONFIG}; voltctl device list -m 8MB -o json |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 170 | Should Be Equal As Integers ${rc} 0 |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 171 | ${jsondata}= To Json ${output} |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 172 | ${length}= Get Length ${jsondata} |
ubuntu | 6b6e7d4 | 2020-03-02 12:35:42 -0800 | [diff] [blame] | 173 | ${matched}= Set Variable False |
Zack Williams | ec53a1b | 2019-09-16 15:50:52 -0700 | [diff] [blame] | 174 | FOR ${INDEX} IN RANGE 0 ${length} |
| 175 | ${value}= Get From List ${jsondata} ${INDEX} |
Scott Baker | 780b65f | 2020-05-22 14:03:15 -0700 | [diff] [blame] | 176 | ${jsonCamelCaseFieldnames}= Run Keyword And Return Status |
| 177 | ... Dictionary Should Contain Key ${value} adminState |
| 178 | ${astate}= Run Keyword If ${jsonCamelCaseFieldNames} |
| 179 | ... Get From Dictionary ${value} adminState |
| 180 | ... ELSE |
| 181 | ... Get From Dictionary ${value} adminstate |
| 182 | ${opstatus}= Run Keyword If ${jsonCamelCaseFieldNames} |
| 183 | ... Get From Dictionary ${value} operStatus |
| 184 | ... ELSE |
| 185 | ... Get From Dictionary ${value} operstatus |
| 186 | ${cstatus}= Run Keyword If ${jsonCamelCaseFieldNames} |
| 187 | ... Get From Dictionary ${value} connectStatus |
| 188 | ... ELSE |
| 189 | ... Get From Dictionary ${value} connectstatus |
| 190 | ${sn}= Run Keyword If ${jsonCamelCaseFieldNames} |
| 191 | ... Get From Dictionary ${value} serialNumber |
| 192 | ... ELSE |
| 193 | ... Get From Dictionary ${value} serialnumber |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 194 | ${devId}= Get From Dictionary ${value} id |
Zack Williams | ec53a1b | 2019-09-16 15:50:52 -0700 | [diff] [blame] | 195 | ${mib_state}= Get From Dictionary ${value} reason |
ubuntu | 6b6e7d4 | 2020-03-02 12:35:42 -0800 | [diff] [blame] | 196 | ${matched}= Set Variable If '${sn}' == '${id}' or '${devId}' == '${id}' True False |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 197 | Exit For Loop If ${matched} |
Zack Williams | ec53a1b | 2019-09-16 15:50:52 -0700 | [diff] [blame] | 198 | END |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 199 | Should Be True ${matched} No match found for ${id} to validate device |
Matteo Scandolo | 5e10b28 | 2019-11-25 10:54:32 -0700 | [diff] [blame] | 200 | Log ${value} |
ubuntu | 6b6e7d4 | 2020-03-02 12:35:42 -0800 | [diff] [blame] | 201 | Should Be Equal '${astate}' '${admin_state}' Device ${sn} admin_state != ${admin_state} |
Gilles Depatie | 675a206 | 2019-10-22 12:44:42 -0400 | [diff] [blame] | 202 | ... values=False |
ubuntu | 6b6e7d4 | 2020-03-02 12:35:42 -0800 | [diff] [blame] | 203 | Should Be Equal '${opstatus}' '${oper_status}' Device ${sn} oper_status != ${oper_status} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 204 | ... values=False |
ubuntu | 6b6e7d4 | 2020-03-02 12:35:42 -0800 | [diff] [blame] | 205 | Should Be Equal '${cstatus}' '${connect_status}' Device ${sn} conn_status != ${connect_status} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 206 | ... values=False |
| 207 | Run Keyword If '${onu}' == 'True' Should Be Equal '${mib_state}' '${onu_reason}' |
ubuntu | 6b6e7d4 | 2020-03-02 12:35:42 -0800 | [diff] [blame] | 208 | ... Device ${sn} mib_state incorrect (${mib_state}) values=False |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 209 | |
| 210 | Validate OLT Device |
ubuntu | 6b6e7d4 | 2020-03-02 12:35:42 -0800 | [diff] [blame] | 211 | [Arguments] ${admin_state} ${oper_status} ${connect_status} ${id}=${EMPTY} |
| 212 | [Documentation] Parses the output of "voltctl device list" and inspects device ${id}, specified |
| 213 | ... as either its serial numbner or device ID. Match on OLT Serial number or Device Id and inspect states |
| 214 | Validate Device ${admin_state} ${oper_status} ${connect_status} ${id} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 215 | |
Suchitra Vemuri | a6879aa | 2020-11-03 11:03:11 -0800 | [diff] [blame] | 216 | Validate OLT Devices |
| 217 | [Arguments] ${admin_state} ${oper_status} ${connect_status} ${ids}=${EMPTY} |
| 218 | [Documentation] Parses the output of "voltctl device list" and inspects device ${id}, specified |
| 219 | ... as either its serial numbner or device ID. Match on OLT Serial number or Device Id and inspect states |
| 220 | FOR ${I} IN RANGE 0 ${olt_count} |
| 221 | ${olt_serial_number}= Get From Dictionary ${olt_ids}[${I}] sn |
| 222 | ${olt_device_id}= Get OLTDeviceID From OLT List ${olt_serial_number} |
| 223 | Validate Device ${admin_state} ${oper_status} ${connect_status} ${olt_device_id} |
| 224 | END |
| 225 | |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 226 | Validate ONU Devices |
| 227 | [Arguments] ${admin_state} ${oper_status} ${connect_status} ${List_ONU_Serial} |
Andy Bavier | f1f26ed | 2020-03-18 10:59:07 -0700 | [diff] [blame] | 228 | ... ${onu_reason}=omci-flows-pushed |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 229 | [Documentation] Parses the output of "voltctl device list" and inspects device ${List_ONU_Serial} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 230 | ... Iteratively match on each Serial number contained in ${List_ONU_Serial} and inspect |
| 231 | ... states including MIB state |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 232 | FOR ${serial_number} IN @{List_ONU_Serial} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 233 | Validate Device ${admin_state} ${oper_status} ${connect_status} ${serial_number} |
Andy Bavier | f1f26ed | 2020-03-18 10:59:07 -0700 | [diff] [blame] | 234 | ... onu_reason=${onu_reason} onu=True |
Debasish | 28130d0 | 2020-03-16 11:05:26 +0000 | [diff] [blame] | 235 | END |
| 236 | |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 237 | Validate Device Port Types |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 238 | [Documentation] |
David K. Bainbridge | bd5ebd2 | 2020-02-04 10:01:18 -0800 | [diff] [blame] | 239 | ... Parses the output of voltctl device port list <device_id> and matches the port types listed |
Andy Bavier | 90eb1a1 | 2020-03-26 11:54:35 -0700 | [diff] [blame] | 240 | [Arguments] ${device_id} ${pon_type} ${ethernet_type} ${all_active}=True |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 241 | ${rc} ${output}= Run and Return Rc and Output |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 242 | ... ${VOLTCTL_CONFIG}; voltctl device port list ${device_id} -m 8MB -o json |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 243 | Should Be Equal As Integers ${rc} 0 |
| 244 | ${jsondata}= To Json ${output} |
| 245 | Log ${jsondata} |
| 246 | ${length}= Get Length ${jsondata} |
| 247 | FOR ${INDEX} IN RANGE 0 ${length} |
| 248 | ${value}= Get From List ${jsondata} ${INDEX} |
Scott Baker | 780b65f | 2020-05-22 14:03:15 -0700 | [diff] [blame] | 249 | ${jsonCamelCaseFieldnames}= Run Keyword And Return Status |
| 250 | ... Dictionary Should Contain Key ${value} adminState |
| 251 | ${astate}= Run Keyword If ${jsonCamelCaseFieldNames} |
Hardik Windlass | 2b37e71 | 2020-06-12 02:13:17 +0530 | [diff] [blame] | 252 | ... Get From Dictionary ${value} adminState |
Scott Baker | 780b65f | 2020-05-22 14:03:15 -0700 | [diff] [blame] | 253 | ... ELSE |
Hardik Windlass | 2b37e71 | 2020-06-12 02:13:17 +0530 | [diff] [blame] | 254 | ... Get From Dictionary ${value} adminstate |
Scott Baker | 780b65f | 2020-05-22 14:03:15 -0700 | [diff] [blame] | 255 | ${opstatus}= Run Keyword If ${jsonCamelCaseFieldNames} |
| 256 | ... Get From Dictionary ${value} operStatus |
| 257 | ... ELSE |
Hardik Windlass | 2b37e71 | 2020-06-12 02:13:17 +0530 | [diff] [blame] | 258 | ... Get From Dictionary ${value} operstatus |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 259 | ${type}= Get From Dictionary ${value} type |
Hema | f64d34c | 2020-03-25 00:40:17 +0530 | [diff] [blame] | 260 | Should Be Equal '${astate}' 'ENABLED' Device ${device_id} port admin_state != ENABLED values=False |
Andy Bavier | 90eb1a1 | 2020-03-26 11:54:35 -0700 | [diff] [blame] | 261 | Run Keyword If ${all_active} Should Be Equal '${opstatus}' 'ACTIVE' |
| 262 | ... Device ${device_id} port oper_status != ACTIVE values=False |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 263 | Should Be True '${type}' == '${pon_type}' or '${type}' == '${ethernet_type}' |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 264 | ... Device ${device_id} port type is neither ${pon_type} or ${ethernet_type} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 265 | END |
| 266 | |
| 267 | Validate OLT Port Types |
David K. Bainbridge | bd5ebd2 | 2020-02-04 10:01:18 -0800 | [diff] [blame] | 268 | [Documentation] Parses the output of voltctl device port list ${olt_device_id} and matches the port types listed |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 269 | [Arguments] ${pon_type} ${ethernet_type} |
| 270 | Validate Device Port Types ${olt_device_id} ${pon_type} ${ethernet_type} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 271 | |
| 272 | Validate ONU Port Types |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 273 | [Arguments] ${List_ONU_Serial} ${pon_type} ${ethernet_type} |
David K. Bainbridge | bd5ebd2 | 2020-02-04 10:01:18 -0800 | [diff] [blame] | 274 | [Documentation] Parses the output of voltctl device port list for each ONU SN listed in ${List_ONU_Serial} |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 275 | ... and matches the port types listed |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 276 | FOR ${serial_number} IN @{List_ONU_Serial} |
| 277 | ${onu_dev_id}= Get Device ID From SN ${serial_number} |
Andy Bavier | 90eb1a1 | 2020-03-26 11:54:35 -0700 | [diff] [blame] | 278 | # Only first UNI port is ACTIVE; the rest are in DISCOVERED operstatus |
| 279 | Validate Device Port Types ${onu_dev_id} ${pon_type} ${ethernet_type} all_active=False |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 280 | END |
| 281 | |
| 282 | Validate Device Flows |
Hardik Windlass | a3d04b9 | 2020-02-17 15:06:05 +0000 | [diff] [blame] | 283 | [Arguments] ${device_id} ${flow_count}=${EMPTY} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 284 | [Documentation] Parses the output of voltctl device flows <device_id> and expects flow count > 0 |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 285 | ${rc} ${output}= Run and Return Rc and Output |
| 286 | ... ${VOLTCTL_CONFIG}; voltctl device flows ${device_id} -m 8MB -o json |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 287 | Should Be Equal As Integers ${rc} 0 |
| 288 | ${jsondata}= To Json ${output} |
| 289 | Log ${jsondata} |
| 290 | ${length}= Get Length ${jsondata} |
| 291 | Log 'Number of flows = ' ${length} |
Hardik Windlass | a3d04b9 | 2020-02-17 15:06:05 +0000 | [diff] [blame] | 292 | Run Keyword If '${flow_count}' == '${EMPTY}' Should Be True ${length} > 0 |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 293 | ... Number of flows for ${device_id} was 0 |
Hardik Windlass | a3d04b9 | 2020-02-17 15:06:05 +0000 | [diff] [blame] | 294 | ... ELSE Should Be True ${length} == ${flow_count} |
| 295 | ... Number of flows for ${device_id} was not ${flow_count} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 296 | |
| 297 | Validate OLT Flows |
Suchitra Vemuri | a6879aa | 2020-11-03 11:03:11 -0800 | [diff] [blame] | 298 | [Arguments] ${flow_count}=${EMPTY} ${olt_device_id}=${EMPTY} |
Hardik Windlass | a3d04b9 | 2020-02-17 15:06:05 +0000 | [diff] [blame] | 299 | [Documentation] Parses the output of voltctl device flows ${olt_device_id} |
| 300 | ... and expects flow count == ${flow_count} |
| 301 | Validate Device Flows ${olt_device_id} ${flow_count} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 302 | |
| 303 | Validate ONU Flows |
Hardik Windlass | a3d04b9 | 2020-02-17 15:06:05 +0000 | [diff] [blame] | 304 | [Arguments] ${List_ONU_Serial} ${flow_count}=${EMPTY} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 305 | [Documentation] Parses the output of voltctl device flows for each ONU SN listed in ${List_ONU_Serial} |
Hardik Windlass | a3d04b9 | 2020-02-17 15:06:05 +0000 | [diff] [blame] | 306 | ... and expects flow count == ${flow_count} |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 307 | FOR ${serial_number} IN @{List_ONU_Serial} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 308 | ${onu_dev_id}= Get Device ID From SN ${serial_number} |
Hardik Windlass | a3d04b9 | 2020-02-17 15:06:05 +0000 | [diff] [blame] | 309 | Validate Device Flows ${onu_dev_id} ${flow_count} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 310 | END |
| 311 | |
TorstenThieme | 401af43 | 2020-06-11 15:53:53 +0000 | [diff] [blame] | 312 | Validate ONU Devices With Duration |
| 313 | [Documentation] |
| 314 | ... Parses the output of "voltctl device list" and inspects all devices ${List_ONU_Serial}, |
| 315 | ... Iteratively match on each Serial number contained in ${List_ONU_Serial} and inspect |
| 316 | ... states including MIB state. |
| 317 | [Arguments] ${admin_state} ${oper_status} ${connect_status} ${onu_reason} |
| 318 | ... ${List_ONU_Serial} ${startTime} ${print2console}=False ${output_file}=${EMPTY} |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 319 | ${rc} ${output}= Run and Return Rc and Output ${VOLTCTL_CONFIG}; voltctl device list -m 8MB -o json |
TorstenThieme | 401af43 | 2020-06-11 15:53:53 +0000 | [diff] [blame] | 320 | Should Be Equal As Integers ${rc} 0 |
| 321 | ${timeCurrent} = Get Current Date |
| 322 | ${timeTotalMs} = Subtract Date From Date ${timeCurrent} ${startTime} result_format=number |
| 323 | ${jsondata}= To Json ${output} |
| 324 | ${length}= Get Length ${jsondata} |
| 325 | FOR ${INDEX} IN RANGE 0 ${length} |
| 326 | ${matched}= Set Variable False |
| 327 | ${value}= Get From List ${jsondata} ${INDEX} |
| 328 | ${jsonCamelCaseFieldnames}= Run Keyword And Return Status |
| 329 | ... Dictionary Should Contain Key ${value} adminState |
| 330 | ${astate}= Run Keyword If ${jsonCamelCaseFieldNames} |
| 331 | ... Get From Dictionary ${value} adminState |
| 332 | ... ELSE |
| 333 | ... Get From Dictionary ${value} adminstate |
| 334 | ${opstatus}= Run Keyword If ${jsonCamelCaseFieldNames} |
| 335 | ... Get From Dictionary ${value} operStatus |
| 336 | ... ELSE |
| 337 | ... Get From Dictionary ${value} operstatus |
| 338 | ${cstatus}= Run Keyword If ${jsonCamelCaseFieldNames} |
| 339 | ... Get From Dictionary ${value} connectStatus |
| 340 | ... ELSE |
| 341 | ... Get From Dictionary ${value} connectstatus |
| 342 | ${sn}= Run Keyword If ${jsonCamelCaseFieldNames} |
| 343 | ... Get From Dictionary ${value} serialNumber |
| 344 | ... ELSE |
| 345 | ... Get From Dictionary ${value} serialnumber |
| 346 | ${mib_state}= Get From Dictionary ${value} reason |
| 347 | ${onu_id}= Get Index From List ${List_ONU_Serial} ${sn} |
| 348 | ${matched}= Set Variable If -1 != ${onu_id} True False |
| 349 | ${matched}= Set Variable If '${astate}' == '${admin_state}' ${matched} False |
| 350 | ${matched}= Set Variable If '${opstatus}' == '${oper_status}' ${matched} False |
| 351 | ${matched}= Set Variable If '${cstatus}' == '${connect_status}' ${matched} False |
| 352 | ${matched}= Set Variable If '${mib_state}' == '${onu_reason}' ${matched} False |
| 353 | Run Keyword If ${matched} and ${print2console} Log |
| 354 | ... \r\nONU ${sn} reached the state ${onu_reason} after ${timeTotalMs} sec. console=yes |
| 355 | Run Keyword If ${matched} and ('${output_file}'!='${EMPTY}') Append To File ${output_file} |
| 356 | ... \r\nONU ${sn} reached the state ${onu_reason} after ${timeTotalMs} sec. |
| 357 | Run Keyword If ${matched} Remove Values From List ${List_ONU_Serial} ${sn} |
| 358 | END |
| 359 | Should Be Empty ${List_ONU_Serial} List ${List_ONU_Serial} not empty |
| 360 | |
TorstenThieme | 9949b17 | 2020-06-16 10:00:15 +0000 | [diff] [blame] | 361 | Validate ONU Devices MIB State With Duration |
| 362 | [Documentation] |
| 363 | ... Parses the output of "voltctl device list" and inspects all devices ${List_ONU_Serial}, |
| 364 | ... Iteratively match on each Serial number contained in ${List_ONU_Serial} and inspect MIB state. |
| 365 | [Arguments] ${onu_reason} |
| 366 | ... ${List_ONU_Serial} ${startTime} ${print2console}=False ${output_file}=${EMPTY} |
| 367 | ${type} = Set Variable brcm_openomci_onu |
Andrea Campanella | 80655eb | 2020-07-10 15:49:22 +0200 | [diff] [blame] | 368 | ${voltctl_commad} = Catenate SEPARATOR= |
| 369 | ... voltctl device list -m 8MB -f Type=${type} -f Reason=${onu_reason} --format '{{.SerialNumber}}' |
| 370 | ${rc} ${output}= Run and Return Rc and Output ${voltctl_commad} |
TorstenThieme | 9949b17 | 2020-06-16 10:00:15 +0000 | [diff] [blame] | 371 | Should Be Equal As Integers ${rc} 0 |
| 372 | ${timeCurrent} = Get Current Date |
| 373 | ${timeTotalMs} = Subtract Date From Date ${timeCurrent} ${startTime} result_format=number |
| 374 | @{outputdata} = Split String ${output} |
| 375 | ${outputlength} = Get Length ${outputdata} |
| 376 | ${onulength} = Get Length ${List_ONU_Serial} |
| 377 | ${Matches} = Run Keyword If ${outputlength}<=${onulength} |
| 378 | ... Compare Lists ${outputdata} ${List_ONU_Serial} |
| 379 | ... ELSE Compare Lists ${List_ONU_Serial} ${outputdata} |
| 380 | ${length} = Get Length ${Matches} |
| 381 | FOR ${INDEX} IN RANGE 0 ${length} |
| 382 | ${sn}= Get From List ${Matches} ${INDEX} |
| 383 | Run Keyword If ${print2console} Log |
| 384 | ... \r\nONU ${sn} reached the state ${onu_reason} after ${timeTotalMs} sec. console=yes |
| 385 | Run Keyword If ('${output_file}'!='${EMPTY}') Append To File ${output_file} |
| 386 | ... \r\nONU ${sn} reached the state ${onu_reason} after ${timeTotalMs} sec. |
| 387 | Remove Values From List ${List_ONU_Serial} ${sn} |
| 388 | END |
| 389 | Should Be Empty ${List_ONU_Serial} List ${List_ONU_Serial} not empty |
| 390 | |
| 391 | Compare Lists |
| 392 | [Documentation] |
| 393 | ... Compares both lists and put all matches in the returned list |
| 394 | [Arguments] ${ListIterate} ${ListCompare} |
| 395 | @{list} = Create List |
| 396 | ${length} = Get Length ${ListIterate} |
| 397 | FOR ${INDEX} IN RANGE 0 ${length} |
| 398 | ${sn}= Get From List ${ListIterate} ${INDEX} |
| 399 | ${onu_id}= Get Index From List ${ListCompare} ${sn} |
| 400 | Run Keyword If -1 != ${onu_id} Append To List ${list} ${sn} |
| 401 | END |
| 402 | [Return] ${list} |
| 403 | |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 404 | Validate Logical Device |
| 405 | [Documentation] Validate Logical Device is listed |
| 406 | ${rc} ${output}= Run and Return Rc and Output ${VOLTCTL_CONFIG}; voltctl logicaldevice list -o json |
| 407 | Should Be Equal As Integers ${rc} 0 |
| 408 | ${jsondata}= To Json ${output} |
| 409 | Log ${jsondata} |
| 410 | ${length}= Get Length ${jsondata} |
| 411 | FOR ${INDEX} IN RANGE 0 ${length} |
| 412 | ${value}= Get From List ${jsondata} ${INDEX} |
| 413 | ${devid}= Get From Dictionary ${value} id |
Scott Baker | 2ab2a0c | 2020-06-05 12:51:47 -0700 | [diff] [blame] | 414 | ${rootdev}= Get From Dictionary ${value} rootDeviceId |
| 415 | ${desc}= Get From Dictionary ${value} desc |
| 416 | ${sn}= Get From Dictionary ${desc} serialNum |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 417 | Exit For Loop |
| 418 | END |
| 419 | Should Be Equal '${rootdev}' '${olt_device_id}' Root Device does not match ${olt_device_id} values=False |
| 420 | Should Be Equal '${sn}' '${BBSIM_OLT_SN}' Logical Device ${sn} does not match ${BBSIM_OLT_SN} |
| 421 | ... values=False |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 422 | [Return] ${devid} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 423 | |
| 424 | Validate Logical Device Ports |
| 425 | [Arguments] ${logical_device_id} |
| 426 | [Documentation] Validate Logical Device Ports are listed and are > 0 |
| 427 | ${rc} ${output}= Run and Return Rc and Output |
David K. Bainbridge | bd5ebd2 | 2020-02-04 10:01:18 -0800 | [diff] [blame] | 428 | ... ${VOLTCTL_CONFIG}; voltctl logicaldevice port list ${logical_device_id} -o json |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 429 | Should Be Equal As Integers ${rc} 0 |
| 430 | ${jsondata}= To Json ${output} |
| 431 | Log ${jsondata} |
| 432 | ${length}= Get Length ${jsondata} |
| 433 | Should Be True ${length} > 0 Number of ports for ${logical_device_id} was 0 |
| 434 | |
| 435 | Validate Logical Device Flows |
| 436 | [Arguments] ${logical_device_id} |
| 437 | [Documentation] Validate Logical Device Flows are listed and are > 0 |
| 438 | ${rc} ${output}= Run and Return Rc and Output |
| 439 | ... ${VOLTCTL_CONFIG}; voltctl logicaldevice flows ${logical_device_id} -o json |
| 440 | Should Be Equal As Integers ${rc} 0 |
| 441 | ${jsondata}= To Json ${output} |
| 442 | Log ${jsondata} |
| 443 | ${length}= Get Length ${jsondata} |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 444 | Should Be True ${length} > 0 Number of flows for ${logical_device_id} was 0 |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 445 | |
Hardik Windlass | 16cdf96 | 2020-04-29 15:26:50 +0530 | [diff] [blame] | 446 | Retrieve OLT PON Ports |
| 447 | [Arguments] ${olt_device_id} |
| 448 | [Documentation] Retrieves the list of PON ports from the OLT device |
| 449 | ${rc} ${output}= Run and Return Rc and Output |
| 450 | ... ${VOLTCTL_CONFIG}; voltctl device port list ${olt_device_id} -o json |
| 451 | Should Be Equal As Integers ${rc} 0 |
| 452 | ${jsondata}= To Json ${output} |
| 453 | Log ${jsondata} |
| 454 | ${length}= Get Length ${jsondata} |
| 455 | ${olt_pon_list}= Create List |
| 456 | FOR ${INDEX} IN RANGE 0 ${length} |
| 457 | ${value}= Get From List ${jsondata} ${INDEX} |
| 458 | ${type}= Get From Dictionary ${value} type |
| 459 | ${portno}= Get From Dictionary ${value} portNo |
| 460 | ${peers}= Get From Dictionary ${value} peers |
| 461 | ${len_peers}= Get Length ${peers} |
| 462 | Run Keyword If '${type}' == 'PON_OLT' and ${len_peers} > 0 |
| 463 | ... Append To List ${olt_pon_list} ${portno} |
| 464 | END |
| 465 | [Return] ${olt_pon_list} |
| 466 | |
| 467 | Retrieve Peer List From OLT PON Port |
| 468 | [Arguments] ${olt_device_id} ${pon_port} |
| 469 | [Documentation] Retrieves the list of peer device ids list from the OLT PON port |
| 470 | ${rc} ${output}= Run and Return Rc and Output |
| 471 | ... ${VOLTCTL_CONFIG}; voltctl device port list ${olt_device_id} -o json |
| 472 | Should Be Equal As Integers ${rc} 0 |
| 473 | ${jsondata}= To Json ${output} |
| 474 | Log ${jsondata} |
| 475 | ${length}= Get Length ${jsondata} |
| 476 | ${matched}= Set Variable False |
| 477 | FOR ${INDEX} IN RANGE 0 ${length} |
| 478 | ${value}= Get From List ${jsondata} ${INDEX} |
| 479 | ${type}= Get From Dictionary ${value} type |
| 480 | ${portno}= Get From Dictionary ${value} portNo |
| 481 | ${peers}= Get From Dictionary ${value} peers |
| 482 | ${matched}= Set Variable If '${type}' == 'PON_OLT' and '${portno}' == '${pon_port}' True False |
| 483 | Exit For Loop If ${matched} |
| 484 | END |
| 485 | Should Be True ${matched} No PON port found for OLT ${olt_device_id} |
| 486 | ${length}= Get Length ${peers} |
| 487 | ${olt_peer_list}= Create List |
| 488 | FOR ${INDEX} IN RANGE 0 ${length} |
| 489 | ${value}= Get From List ${peers} ${INDEX} |
| 490 | ${peer_id}= Get From Dictionary ${value} deviceId |
| 491 | Append To List ${olt_peer_list} ${peer_id} |
| 492 | END |
| 493 | [Return] ${olt_peer_list} |
| 494 | |
| 495 | Validate OLT PON Port Status |
| 496 | [Arguments] ${olt_device_id} ${pon_port} ${admin_state} ${oper_status} |
| 497 | [Documentation] Verifies the state of the PON port of the OLT |
| 498 | ${rc} ${output}= Run and Return Rc and Output |
| 499 | ... ${VOLTCTL_CONFIG}; voltctl device port list ${olt_device_id} -o json |
| 500 | Should Be Equal As Integers ${rc} 0 |
| 501 | ${jsondata}= To Json ${output} |
| 502 | Log ${jsondata} |
| 503 | ${length}= Get Length ${jsondata} |
| 504 | ${matched}= Set Variable False |
| 505 | FOR ${INDEX} IN RANGE 0 ${length} |
| 506 | ${value}= Get From List ${jsondata} ${INDEX} |
| 507 | ${type}= Get From Dictionary ${value} type |
| 508 | ${portno}= Get From Dictionary ${value} portNo |
| 509 | ${astate}= Get From Dictionary ${value} adminState |
| 510 | ${opstatus}= Get From Dictionary ${value} operStatus |
| 511 | ${matched}= Set Variable If '${type}' == 'PON_OLT' and '${portno}' == '${pon_port}' True False |
| 512 | Exit For Loop If ${matched} |
| 513 | END |
| 514 | Should Be True ${matched} No PON port found for OLT ${olt_device_id} ${pon_port} |
| 515 | Log ${value} |
| 516 | Should Be Equal '${astate}' '${admin_state}' OLT PON Port admin_state != ${admin_state} |
| 517 | ... values=False |
| 518 | Should Be Equal '${opstatus}' '${oper_status}' OLT PON Port oper_status != ${oper_status} |
| 519 | ... values=False |
| 520 | |
| 521 | DisableOrEnable OLT PON Port |
| 522 | [Arguments] ${operation} ${olt_device_id} ${portno} |
| 523 | [Documentation] Disables or Enables the PON port of the OLT |
| 524 | ${rc} ${output}= Run and Return Rc and Output |
| 525 | ... ${VOLTCTL_CONFIG}; voltctl device port ${operation} ${olt_device_id} ${portno} |
| 526 | Should Be Equal As Integers ${rc} 0 |
| 527 | |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 528 | Retrieve Peer List From OLT |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 529 | [Arguments] ${olt_peer_list} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 530 | [Documentation] Retrieve the list of peer device id list from port list |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 531 | ${rc} ${output}= Run and Return Rc and Output |
David K. Bainbridge | bd5ebd2 | 2020-02-04 10:01:18 -0800 | [diff] [blame] | 532 | ... ${VOLTCTL_CONFIG}; voltctl device port list ${olt_device_id} -o json |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 533 | Should Be Equal As Integers ${rc} 0 |
| 534 | ${jsondata}= To Json ${output} |
| 535 | Log ${jsondata} |
| 536 | ${length}= Get Length ${jsondata} |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 537 | ${matched}= Set Variable False |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 538 | FOR ${INDEX} IN RANGE 0 ${length} |
| 539 | ${value}= Get From List ${jsondata} ${INDEX} |
| 540 | ${type}= Get From Dictionary ${value} type |
| 541 | ${peers}= Get From Dictionary ${value} peers |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 542 | ${matched}= Set Variable If '${type}' == 'PON_OLT' True False |
| 543 | Exit For Loop If ${matched} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 544 | END |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 545 | Should Be True ${matched} No PON port found for OLT ${olt_device_id} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 546 | ${length}= Get Length ${peers} |
| 547 | FOR ${INDEX} IN RANGE 0 ${length} |
| 548 | ${value}= Get From List ${peers} ${INDEX} |
Hardik Windlass | 16cdf96 | 2020-04-29 15:26:50 +0530 | [diff] [blame] | 549 | ${peer_id}= Get From Dictionary ${value} deviceId |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 550 | Append To List ${olt_peer_list} ${peer_id} |
| 551 | END |
| 552 | |
| 553 | Validate OLT Peer Id List |
| 554 | [Arguments] ${olt_peer_id_list} |
| 555 | [Documentation] Match each entry in the ${olt_peer_id_list} against ONU device ids. |
| 556 | FOR ${peer_id} IN @{olt_peer_id_list} |
| 557 | Match OLT Peer Id ${peer_id} |
| 558 | END |
| 559 | |
| 560 | Match OLT Peer Id |
| 561 | [Arguments] ${olt_peer_id} |
| 562 | [Documentation] Lookup the OLT Peer Id in against the list of ONU device Ids |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 563 | ${rc} ${output}= Run and Return Rc and Output ${VOLTCTL_CONFIG}; voltctl device list -o json |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 564 | Should Be Equal As Integers ${rc} 0 |
| 565 | ${jsondata}= To Json ${output} |
| 566 | Log ${jsondata} |
| 567 | ${length}= Get Length ${jsondata} |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 568 | ${matched}= Set Variable False |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 569 | FOR ${INDEX} IN RANGE 0 ${length} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 570 | ${value}= Get From List ${jsondata} ${INDEX} |
| 571 | ${devid}= Get From Dictionary ${value} id |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 572 | ${matched}= Set Variable If '${devid}' == '${olt_peer_id}' True False |
| 573 | Exit For Loop If ${matched} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 574 | END |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 575 | Should Be True ${matched} Peer id ${olt_peer_id} does not match any ONU device id |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 576 | |
| 577 | Validate ONU Peer Id |
| 578 | [Arguments] ${olt_device_id} ${List_ONU_Serial} |
| 579 | [Documentation] Match each ONU peer to that of the OLT device id |
| 580 | FOR ${onu_serial} IN @{List_ONU_Serial} |
| 581 | ${onu_dev_id}= Get Device ID From SN ${onu_serial} |
| 582 | Match ONU Peer Id ${onu_dev_id} |
| 583 | END |
| 584 | |
| 585 | Match ONU Peer Id |
| 586 | [Arguments] ${onu_dev_id} |
| 587 | [Documentation] Match an ONU peer to that of the OLT device id |
David K. Bainbridge | bd5ebd2 | 2020-02-04 10:01:18 -0800 | [diff] [blame] | 588 | ${rc} ${output}= Run and Return Rc and Output |
| 589 | ... ${VOLTCTL_CONFIG}; voltctl device port list ${onu_dev_id} -o json |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 590 | Should Be Equal As Integers ${rc} 0 |
| 591 | ${jsondata}= To Json ${output} |
| 592 | Log ${jsondata} |
| 593 | ${length}= Get Length ${jsondata} |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 594 | ${matched}= Set Variable False |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 595 | FOR ${INDEX} IN RANGE 0 ${length} |
| 596 | ${value}= Get From List ${jsondata} ${INDEX} |
| 597 | ${type}= Get From Dictionary ${value} type |
| 598 | ${peers}= Get From Dictionary ${value} peers |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 599 | ${matched}= Set Variable If '${type}' == 'PON_ONU' True False |
| 600 | Exit For Loop If ${matched} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 601 | END |
Andy Bavier | b63f6d2 | 2020-03-12 15:34:37 -0700 | [diff] [blame] | 602 | Should Be True ${matched} No PON port found for ONU ${onu_dev_id} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 603 | ${length}= Get Length ${peers} |
| 604 | FOR ${INDEX} IN RANGE 0 ${length} |
| 605 | ${value}= Get From List ${peers} ${INDEX} |
Hardik Windlass | 16cdf96 | 2020-04-29 15:26:50 +0530 | [diff] [blame] | 606 | ${peer_id}= Get From Dictionary ${value} deviceId |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 607 | END |
| 608 | Should Be Equal '${peer_id}' '${olt_device_id}' |
| 609 | ... Mismatch between ONU peer ${peer_id} and OLT device id ${olt_device_id} values=False |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 610 | |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 611 | Get Device ID From SN |
| 612 | [Arguments] ${serial_number} |
| 613 | [Documentation] Gets the device id by matching for ${serial_number} |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 614 | ${rc} ${id}= Run and Return Rc and Output |
Andy Bavier | 8fca045 | 2019-12-16 15:30:11 -0700 | [diff] [blame] | 615 | ... ${VOLTCTL_CONFIG}; voltctl device list --filter=SerialNumber=${serial_number} --format='{{.Id}}' |
| 616 | Should Be Equal As Integers ${rc} 0 |
| 617 | Log ${id} |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 618 | [Return] ${id} |
| 619 | |
Suchitra Vemuri | 00d147d | 2019-09-13 13:07:32 -0700 | [diff] [blame] | 620 | Get Logical Device ID From SN |
| 621 | [Arguments] ${serial_number} |
| 622 | [Documentation] Gets the device id by matching for ${serial_number} |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 623 | ${rc} ${id}= Run and Return Rc and Output |
Scott Baker | 2ab2a0c | 2020-06-05 12:51:47 -0700 | [diff] [blame] | 624 | ... ${VOLTCTL_CONFIG}; voltctl logicaldevice list --filter=Desc.SerialNum=${serial_number} --format='{{.Id}}' |
Andy Bavier | 8fca045 | 2019-12-16 15:30:11 -0700 | [diff] [blame] | 625 | Should Be Equal As Integers ${rc} 0 |
| 626 | Log ${id} |
Suchitra Vemuri | 00d147d | 2019-09-13 13:07:32 -0700 | [diff] [blame] | 627 | [Return] ${id} |
| 628 | |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 629 | Build ONU SN List |
Suchitra Vemuri | a6879aa | 2020-11-03 11:03:11 -0800 | [diff] [blame] | 630 | [Arguments] ${serial_numbers} ${num_onus}=${num_all_onus} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 631 | [Documentation] Appends all ONU SNs to the ${serial_numbers} list |
| 632 | FOR ${INDEX} IN RANGE 0 ${num_onus} |
| 633 | Append To List ${serial_numbers} ${hosts.src[${INDEX}].onu} |
| 634 | END |
| 635 | |
| 636 | Get SN From Device ID |
| 637 | [Arguments] ${device_id} |
| 638 | [Documentation] Gets the device id by matching for ${device_id} |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 639 | ${rc} ${sn}= Run and Return Rc and Output |
Andy Bavier | 8fca045 | 2019-12-16 15:30:11 -0700 | [diff] [blame] | 640 | ... ${VOLTCTL_CONFIG}; voltctl device list --filter=Id=${device_id} --format='{{.SerialNumber}}' |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 641 | Should Be Equal As Integers ${rc} 0 |
Andy Bavier | 8fca045 | 2019-12-16 15:30:11 -0700 | [diff] [blame] | 642 | Log ${sn} |
Gilles Depatie | b5682f8 | 2019-10-31 10:39:45 -0400 | [diff] [blame] | 643 | [Return] ${sn} |
| 644 | |
Scott Baker | 60e570d | 2020-02-02 22:10:13 -0800 | [diff] [blame] | 645 | Get Parent ID From Device ID |
| 646 | [Arguments] ${device_id} |
| 647 | [Documentation] Gets the device id by matching for ${device_id} |
| 648 | ${rc} ${pid}= Run and Return Rc and Output |
| 649 | ... ${VOLTCTL_CONFIG}; voltctl device list --filter=Id=${device_id} --format='{{.ParentId}}' |
| 650 | Should Be Equal As Integers ${rc} 0 |
| 651 | Log ${pid} |
| 652 | [Return] ${pid} |
| 653 | |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 654 | Validate Device Removed |
| 655 | [Arguments] ${id} |
| 656 | [Documentation] Verifys that device, ${serial_number}, has been removed |
Zack Williams | a8fe75a | 2020-01-10 14:25:27 -0700 | [diff] [blame] | 657 | ${rc} ${output}= Run and Return Rc and Output ${VOLTCTL_CONFIG}; voltctl device list -o json |
Andy Bavier | 8fca045 | 2019-12-16 15:30:11 -0700 | [diff] [blame] | 658 | Should Be Equal As Integers ${rc} 0 |
Kailash | 6f5acb6 | 2019-08-28 14:38:45 -0700 | [diff] [blame] | 659 | ${jsondata}= To Json ${output} |
| 660 | Log ${jsondata} |
| 661 | ${length}= Get Length ${jsondata} |
| 662 | @{ids}= Create List |
Zack Williams | ec53a1b | 2019-09-16 15:50:52 -0700 | [diff] [blame] | 663 | FOR ${INDEX} IN RANGE 0 ${length} |
| 664 | ${value}= Get From List ${jsondata} ${INDEX} |
| 665 | ${device_id}= Get From Dictionary ${value} id |
| 666 | Append To List ${ids} ${device_id} |
| 667 | END |
Suchitra Vemuri | 00d147d | 2019-09-13 13:07:32 -0700 | [diff] [blame] | 668 | List Should Not Contain Value ${ids} ${id} |
Suchitra Vemuri | cd2f64f | 2020-02-18 18:30:27 -0800 | [diff] [blame] | 669 | |
| 670 | Reboot ONU |
Suchitra Vemuri | a6879aa | 2020-11-03 11:03:11 -0800 | [diff] [blame] | 671 | [Arguments] ${onu_id} ${src} ${dst} |
Suchitra Vemuri | cd2f64f | 2020-02-18 18:30:27 -0800 | [diff] [blame] | 672 | [Documentation] Using voltctl command reboot ONU and verify that ONU comes up to running state |
| 673 | ${rc} ${devices}= Run and Return Rc and Output ${VOLTCTL_CONFIG}; voltctl device reboot ${onu_id} |
| 674 | Should Be Equal As Integers ${rc} 0 |
Suchitra Vemuri | a6879aa | 2020-11-03 11:03:11 -0800 | [diff] [blame] | 675 | Run Keyword and Ignore Error Wait Until Keyword Succeeds 60s 1s Validate Device |
| 676 | ... ENABLED DISCOVERED UNREACHABLE ${onu_id} onu=True |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 677 | |
| 678 | Assert ONUs in Voltha |
| 679 | [Arguments] ${count} |
| 680 | [Documentation] Check that a certain number of devices reached the ACTIVE/ENABLE state |
| 681 | ${rc1} ${devices}= Run and Return Rc and Output |
Matteo Scandolo | f831b0e | 2020-06-26 11:57:17 -0700 | [diff] [blame] | 682 | ... ${VOLTCTL_CONFIG}; voltctl -m 8M device list | grep -v OLT | grep ACTIVE | wc -l |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 683 | Should Be Equal As Integers ${rc1} 0 |
| 684 | Should Be Equal As Integers ${devices} ${count} |
| 685 | |
| 686 | Wait for ONUs in VOLTHA |
| 687 | [Arguments] ${count} |
| 688 | [Documentation] Waits until a certain number of devices reached the ACTIVE/ENABLE state |
| 689 | Wait Until Keyword Succeeds 10m 5s Assert ONUs In Voltha ${count} |
| 690 | |
| 691 | Count Logical Devices flows |
| 692 | [Documentation] Count the flows across logical devices in VOLTHA |
| 693 | [Arguments] ${targetFlows} |
| 694 | ${output}= Get Logical Device List From Voltha |
| 695 | ${logical_devices}= To Json ${output} |
| 696 | ${total_flows}= Set Variable 0 |
| 697 | FOR ${device} IN @{logical_devices} |
| 698 | ${rc} ${flows}= Run and Return Rc and Output |
| 699 | ... ${VOLTCTL_CONFIG}; voltctl logicaldevice flows ${device['id']} | grep -v ID | wc -l |
| 700 | Should Be Equal As Integers ${rc} 0 |
| 701 | ${total_flows}= Evaluate ${total_flows} + ${flows} |
| 702 | END |
Matteo Scandolo | 616daab | 2020-05-13 11:49:24 -0700 | [diff] [blame] | 703 | ${msg}= Format String Found {total_flows} flows of {targetFlows} expected |
| 704 | ... total_flows=${total_flows} targetFlows=${targetFlows} |
| 705 | Log ${msg} |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 706 | Should Be Equal As Integers ${targetFlows} ${total_flows} |
| 707 | |
| 708 | Wait for Logical Devices flows |
| 709 | [Documentation] Waits until the flows have been provisioned in the logical device |
| 710 | [Arguments] ${workflow} ${uni_count} ${olt_count} ${provisioned} |
Andrea Campanella | 70cf0a7 | 2020-05-27 10:55:15 +0200 | [diff] [blame] | 711 | ... ${withEapol} ${withDhcp} ${withIgmp} ${withLldp} |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 712 | ${targetFlows}= Calculate flows by workflow ${workflow} ${uni_count} ${olt_count} ${provisioned} |
Andrea Campanella | 70cf0a7 | 2020-05-27 10:55:15 +0200 | [diff] [blame] | 713 | ... ${withEapol} ${withDhcp} ${withIgmp} ${withLldp} |
Matteo Scandolo | 142e627 | 2020-04-29 17:36:59 -0700 | [diff] [blame] | 714 | Log ${targetFlows} |
| 715 | # TODO extend Validate Logical Device Flows to check the correct number of flows |
| 716 | Wait Until Keyword Succeeds 10m 5s Count Logical Devices flows ${targetFlows} |
| 717 | |
Matteo Scandolo | 616daab | 2020-05-13 11:49:24 -0700 | [diff] [blame] | 718 | Count OpenOLT Device Flows |
| 719 | [Documentation] Count the flows across openolt devices in VOLTHA |
| 720 | [Arguments] ${targetFlows} |
| 721 | ${output}= Get Device List from Voltha by type openolt |
| 722 | ${devices}= To Json ${output} |
| 723 | ${total_flows}= Set Variable 0 |
| 724 | FOR ${device} IN @{devices} |
| 725 | ${rc} ${flows}= Run and Return Rc and Output |
| 726 | ... ${VOLTCTL_CONFIG}; voltctl device flows ${device['id']} | grep -v ID | wc -l |
| 727 | Should Be Equal As Integers ${rc} 0 |
| 728 | ${total_flows}= Evaluate ${total_flows} + ${flows} |
| 729 | END |
| 730 | ${msg}= Format String Found {total_flows} flows of {targetFlows} expected |
| 731 | ... total_flows=${total_flows} targetFlows=${targetFlows} |
| 732 | Log ${msg} |
| 733 | Should Be Equal As Integers ${targetFlows} ${total_flows} |
| 734 | |
| 735 | Wait for OpenOLT Devices flows |
| 736 | [Documentation] Waits until the flows have been provisioned in the openolt devices |
| 737 | [Arguments] ${workflow} ${uni_count} ${olt_count} ${provisioned} |
Andrea Campanella | 70cf0a7 | 2020-05-27 10:55:15 +0200 | [diff] [blame] | 738 | ... ${withEapol} ${withDhcp} ${withIgmp} ${withLldp} |
Matteo Scandolo | 96dbe43 | 2020-05-28 10:51:57 -0700 | [diff] [blame] | 739 | ${beforeFlows}= Calculate flows by workflow ${workflow} ${uni_count} ${olt_count} ${provisioned} |
| 740 | ... ${withEapol} ${withDhcp} ${withIgmp} ${withLldp} |
Matteo Scandolo | da854b0 | 2020-09-01 16:20:51 -0700 | [diff] [blame] | 741 | # In the physical device we only have 2 data plane flows (on the PON) instead of 4 |
Matteo Scandolo | 96dbe43 | 2020-05-28 10:51:57 -0700 | [diff] [blame] | 742 | ${afterFlows}= Evaluate ${beforeFlows} - (${uni_count} * 2) |
Matteo Scandolo | da854b0 | 2020-09-01 16:20:51 -0700 | [diff] [blame] | 743 | # In the TT workflow we have multiple service, |
| 744 | # so we need to remove 6 flows per each UNI that are only on the ONU device |
| 745 | ${ttFlows}= Evaluate ${beforeFlows} - (${uni_count} * 6) |
| 746 | ${afterFlows}= Set Variable If $workflow=='tt' ${ttFlows} ${afterFlows} |
Matteo Scandolo | 96dbe43 | 2020-05-28 10:51:57 -0700 | [diff] [blame] | 747 | ${targetFlows}= Set Variable If $provisioned=='true' ${afterFlows} ${beforeFlows} |
Matteo Scandolo | 616daab | 2020-05-13 11:49:24 -0700 | [diff] [blame] | 748 | Log ${targetFlows} |
Hardik Windlass | 2b37e71 | 2020-06-12 02:13:17 +0530 | [diff] [blame] | 749 | Wait Until Keyword Succeeds 10m 5s Count OpenOLT Device Flows ${targetFlows} |