Gitiles
Code Review Sign In
gerrit.opencord.org / cord-tester / 4da7016512b64b619ae741536740a39beeb21571 / . / src / test / cordSubscriber / cordSubscriberTest.py
blob: 4fcd5901371c1f6be65089c99ad048be80081f49 [file] [log] [blame]
Matteo Scandolo48d3d2d2017-08-08 13:05:27 -0700[diff] [blame]1
2# Copyright 2017-present Open Networking Foundation
3#
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8# http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15
16
A R Karthicke237aee2016-12-01 17:46:43 -0800[diff] [blame]17#
A R Karthick07608ef2016-08-23 16:51:19 -0700[diff] [blame]18# Copyright 2016-present Ciena Corporation
19#
20# Licensed under the Apache License, Version 2.0 (the "License");
21# you may not use this file except in compliance with the License.
22# You may obtain a copy of the License at
A R Karthicke237aee2016-12-01 17:46:43 -0800[diff] [blame]23#
A R Karthick07608ef2016-08-23 16:51:19 -0700[diff] [blame]24# http://www.apache.org/licenses/LICENSE-2.0
A R Karthicke237aee2016-12-01 17:46:43 -0800[diff] [blame]25#
A R Karthick07608ef2016-08-23 16:51:19 -0700[diff] [blame]26# Unless required by applicable law or agreed to in writing, software
27# distributed under the License is distributed on an "AS IS" BASIS,
28# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
29# See the License for the specific language governing permissions and
30# limitations under the License.
31#
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]32import unittest
33from nose.tools import *
34from nose.twistedtools import reactor, deferred
35from twisted.internet import defer
A.R Karthick401a1ed2017-05-18 11:08:27 -0700[diff] [blame]36from scapy.all import IP
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]37import time, monotonic
38import os, sys
39import tempfile
40import random
41import threading
42import json
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]43import requests
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]44from Stats import Stats
45from OnosCtrl import OnosCtrl
46from DHCP import DHCPTest
47from EapTLS import TLSAuthTest
48from Channels import Channels, IgmpChannel
49from subscriberDb import SubscriberDB
50from threadPool import ThreadPool
A.R Karthick95d044e2016-06-10 18:44:36 -0700[diff] [blame]51from portmaps import g_subscriber_port_map
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]52from OltConfig import *
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]53from CordTestServer import cord_test_onos_restart, cord_test_shell, cord_test_radius_restart
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]54from CordTestUtils import log_test, get_controller
A R Karthick9313b762016-11-07 13:14:35 -0800[diff] [blame]55from CordLogger import CordLogger
A R Karthick9dc6e922017-07-12 14:40:16 -0700[diff] [blame]56from CordTestConfig import setup_module, teardown_module
A R Karthickb608d402017-06-02 11:48:41 -0700[diff] [blame]57from CordContainer import Onos
A R Karthicke7232092017-09-07 18:01:33 -0700[diff] [blame]58from VolthaCtrl import VolthaCtrl
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]59from CordTestUtils import get_mac, get_controller
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]60
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]61log_test.setLevel('INFO')
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]62
63class Subscriber(Channels):
64 PORT_TX_DEFAULT = 2
65 PORT_RX_DEFAULT = 1
66 INTF_TX_DEFAULT = 'veth2'
67 INTF_RX_DEFAULT = 'veth0'
68 STATS_RX = 0
69 STATS_TX = 1
70 STATS_JOIN = 2
71 STATS_LEAVE = 3
72 SUBSCRIBER_SERVICES = 'DHCP IGMP TLS'
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]73
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]74 def __init__(self, name = 'sub', service = SUBSCRIBER_SERVICES, port_map = None,
75 num = 1, channel_start = 0,
76 tx_port = PORT_TX_DEFAULT, rx_port = PORT_RX_DEFAULT,
77 iface = INTF_RX_DEFAULT, iface_mcast = INTF_TX_DEFAULT,
78 mcast_cb = None, loginType = 'wireless'):
79 self.tx_port = tx_port
80 self.rx_port = rx_port
81 self.port_map = port_map or g_subscriber_port_map
82 try:
83 self.tx_intf = self.port_map[tx_port]
84 self.rx_intf = self.port_map[rx_port]
85 except:
86 self.tx_intf = self.port_map[self.PORT_TX_DEFAULT]
87 self.rx_intf = self.port_map[self.PORT_RX_DEFAULT]
88
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]89 log_test.info('Subscriber %s, rx interface %s, uplink interface %s' %(name, self.rx_intf, self.tx_intf))
A.R Karthick95d044e2016-06-10 18:44:36 -0700[diff] [blame]90 Channels.__init__(self, num, channel_start = channel_start,
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]91 iface = self.rx_intf, iface_mcast = self.tx_intf, mcast_cb = mcast_cb)
92 self.name = name
93 self.service = service
94 self.service_map = {}
95 services = self.service.strip().split(' ')
96 for s in services:
97 self.service_map[s] = True
98 self.loginType = loginType
99 ##start streaming channels
100 self.join_map = {}
101 ##accumulated join recv stats
102 self.join_rx_stats = Stats()
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]103 self.recv_timeout = False
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]104
105 def has_service(self, service):
106 if self.service_map.has_key(service):
107 return self.service_map[service]
108 if self.service_map.has_key(service.upper()):
109 return self.service_map[service.upper()]
110 return False
111
112 def channel_join_update(self, chan, join_time):
113 self.join_map[chan] = ( Stats(), Stats(), Stats(), Stats() )
114 self.channel_update(chan, self.STATS_JOIN, 1, t = join_time)
115
116 def channel_join(self, chan = 0, delay = 2):
117 '''Join a channel and create a send/recv stats map'''
118 if self.join_map.has_key(chan):
119 del self.join_map[chan]
120 self.delay = delay
121 chan, join_time = self.join(chan)
122 self.channel_join_update(chan, join_time)
123 return chan
124
A.R Karthick517f7812017-05-18 11:22:46 -0700[diff] [blame]125 def channel_join_next(self, delay = 2, leave_flag = True):
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]126 '''Joins the next channel leaving the last channel'''
127 if self.last_chan:
128 if self.join_map.has_key(self.last_chan):
129 del self.join_map[self.last_chan]
130 self.delay = delay
A.R Karthick517f7812017-05-18 11:22:46 -0700[diff] [blame]131 chan, join_time = self.join_next(leave_flag = leave_flag)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]132 self.channel_join_update(chan, join_time)
133 return chan
134
135 def channel_jump(self, delay = 2):
136 '''Jumps randomly to the next channel leaving the last channel'''
137 if self.last_chan is not None:
138 if self.join_map.has_key(self.last_chan):
139 del self.join_map[self.last_chan]
140 self.delay = delay
141 chan, join_time = self.jump()
142 self.channel_join_update(chan, join_time)
143 return chan
144
A R Karthick78d1f492017-05-19 14:24:17 -0700[diff] [blame]145 def channel_leave(self, chan = 0, force = False):
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]146 if self.join_map.has_key(chan):
147 del self.join_map[chan]
A R Karthick78d1f492017-05-19 14:24:17 -0700[diff] [blame]148 self.leave(chan, force = force)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]149
150 def channel_update(self, chan, stats_type, packets, t=0):
151 if type(chan) == type(0):
152 chan_list = (chan,)
153 else:
154 chan_list = chan
A.R Karthick95d044e2016-06-10 18:44:36 -0700[diff] [blame]155 for c in chan_list:
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]156 if self.join_map.has_key(c):
157 self.join_map[c][stats_type].update(packets = packets, t = t)
158
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]159 def channel_receive(self, chan, cb = None, count = 1, timeout = 5):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]160 log_test.info('Subscriber %s on port %s receiving from group %s, channel %d' %
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]161 (self.name, self.rx_intf, self.gaddr(chan), chan))
162 r = self.recv(chan, cb = cb, count = count, timeout = timeout)
A R Karthicka013a272016-08-16 16:40:19 -0700[diff] [blame]163 if len(r) == 0:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]164 log_test.info('Subscriber %s on port %s timed out' %(self.name, self.rx_intf))
A R Karthicka013a272016-08-16 16:40:19 -0700[diff] [blame]165 else:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]166 log_test.info('Subscriber %s on port %s received %d packets' %(self.name, self.rx_intf, len(r)))
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]167 if self.recv_timeout:
168 ##Negative test case is disabled for now
169 assert_equal(len(r), 0)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]170
171 def recv_channel_cb(self, pkt):
172 ##First verify that we have received the packet for the joined instance
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]173 log_test.info('Packet received for group %s, subscriber %s, port %s' %
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]174 (pkt[IP].dst, self.name, self.rx_intf))
175 if self.recv_timeout:
176 return
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]177 chan = self.caddr(pkt[IP].dst)
178 assert_equal(chan in self.join_map.keys(), True)
179 recv_time = monotonic.monotonic() * 1000000
180 join_time = self.join_map[chan][self.STATS_JOIN].start
181 delta = recv_time - join_time
182 self.join_rx_stats.update(packets=1, t = delta, usecs = True)
183 self.channel_update(chan, self.STATS_RX, 1, t = delta)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]184 log_test.debug('Packet received in %.3f usecs for group %s after join' %(delta, pkt[IP].dst))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]185
186class subscriber_pool:
187
188 def __init__(self, subscriber, test_cbs):
189 self.subscriber = subscriber
190 self.test_cbs = test_cbs
191
192 def pool_cb(self):
193 for cb in self.test_cbs:
194 if cb:
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]195 self.test_status = cb(self.subscriber)
196 if self.test_status is not True:
197 ## This is chaning for other sub status has to check again
198 self.test_status = True
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]199 log_test.info('This service is failed and other services will not run for this subscriber')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]200 break
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]201 log_test.info('This Subscriber is tested for multiple service eligibility ')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]202 self.test_status = True
203
A.R Karthick95d044e2016-06-10 18:44:36 -0700[diff] [blame]204
A R Karthick9313b762016-11-07 13:14:35 -0800[diff] [blame]205class subscriber_exchange(CordLogger):
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]206
A.R Karthick95d044e2016-06-10 18:44:36 -0700[diff] [blame]207 apps = ('org.opencord.aaa', 'org.onosproject.dhcp')
208 olt_apps = () #'org.opencord.cordmcast')
A R Karthicka013a272016-08-16 16:40:19 -0700[diff] [blame]209 vtn_app = 'org.opencord.vtn'
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]210 table_app = 'org.ciena.cordigmp'
211 dhcp_server_config = {
212 "ip": "10.1.11.50",
213 "mac": "ca:fe:ca:fe:ca:fe",
214 "subnet": "255.255.252.0",
215 "broadcast": "10.1.11.255",
216 "router": "10.1.8.1",
217 "domain": "8.8.8.8",
218 "ttl": "63",
219 "delay": "2",
220 "startip": "10.1.11.51",
221 "endip": "10.1.11.100"
222 }
223
224 aaa_loaded = False
225 test_path = os.path.dirname(os.path.realpath(__file__))
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]226 table_app_file = os.path.join(test_path, '..', 'apps/ciena-cordigmp-multitable-2.0-SNAPSHOT.oar')
227 app_file = os.path.join(test_path, '..', 'apps/ciena-cordigmp-2.0-SNAPSHOT.oar')
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]228 olt_app_file = os.path.join(test_path, '..', 'apps/olt-app-1.2-SNAPSHOT.oar')
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]229 app_files = [os.path.join(test_path, '..', 'apps/cord-config-3.0-SNAPSHOT.oar'), os.path.join(test_path, '..', 'apps/olt-app-3.0-SNAPSHOT.oar'), os.path.join(test_path, '..', 'apps/mcast-1.3.0-SNAPSHOT.oar'), os.path.join(test_path, '..', 'apps/onos-app-igmpproxy-1.1.0-SNAPSHOT.oar')]
230 proxy_config_file = os.path.join(test_path, '..', 'igmpproxy/igmpproxyconfig.json')
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]231 olt_app_name = 'org.onosproject.olt'
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]232 onos_config_path = os.path.join(test_path, '..', 'setup/onos-config')
A.R Karthick5968e0d2017-05-16 14:50:46 -0700[diff] [blame]233 olt_conf_file = os.getenv('OLT_CONFIG_FILE', os.path.join(test_path, '..', 'setup/olt_config.json'))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]234 cpqd_path = os.path.join(test_path, '..', 'setup')
235 ovs_path = cpqd_path
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]236 test_services = ('IGMP', 'TRAFFIC')
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]237 num_joins = 0
238 num_subscribers = 0
A.R Karthick517f7812017-05-18 11:22:46 -0700[diff] [blame]239 leave_flag = True
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]240 num_channels = 0
241 recv_timeout = False
A R Karthick4e0c0912016-08-17 16:57:42 -0700[diff] [blame]242 onos_restartable = bool(int(os.getenv('ONOS_RESTART', 0)))
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]243 INTF_TX_DEFAULT = 'veth2'
244 INTF_RX_DEFAULT = 'veth0'
245 SUBSCRIBER_TIMEOUT = 300
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]246 MAX_PORTS = 100
247 proxy_device_id = OnosCtrl.get_device_id()
248 controller = get_controller()
249 proxy_app = 'org.opencord.igmpproxy'
250 mcast_app = 'org.opencord.mcast'
251 cord_config_app = 'org.opencord.config'
252 host_ip_map = {}
253 configs = {}
254 proxy_interfaces_last = ()
255 interface_to_mac_map = {}
256
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]257
258 CLIENT_CERT = """-----BEGIN CERTIFICATE-----
259MIICuDCCAiGgAwIBAgIBAjANBgkqhkiG9w0BAQUFADCBizELMAkGA1UEBhMCVVMx
260CzAJBgNVBAgTAkNBMRIwEAYDVQQHEwlTb21ld2hlcmUxEzARBgNVBAoTCkNpZW5h
261IEluYy4xHjAcBgkqhkiG9w0BCQEWD2FkbWluQGNpZW5hLmNvbTEmMCQGA1UEAxMd
262RXhhbXBsZSBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMTYwNjA2MjExMjI3WhcN
263MTcwNjAxMjExMjI3WjBnMQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExEzARBgNV
264BAoTCkNpZW5hIEluYy4xFzAVBgNVBAMUDnVzZXJAY2llbmEuY29tMR0wGwYJKoZI
265hvcNAQkBFg51c2VyQGNpZW5hLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkC
266gYEAwvXiSzb9LZ6c7uNziUfKvoHO7wu/uiFC5YUpXbmVGuGZizbVrny0xnR85Dfe
267+9R4diansfDhIhzOUl1XjN3YDeSS9OeF5YWNNE8XDhlz2d3rVzaN6hIhdotBkUjg
268rUewjTg5OFR31QEyG3v8xR3CLgiE9xQELjZbSA07pD79zuUCAwEAAaNPME0wEwYD
269VR0lBAwwCgYIKwYBBQUHAwIwNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL3d3dy5l
270eGFtcGxlLmNvbS9leGFtcGxlX2NhLmNybDANBgkqhkiG9w0BAQUFAAOBgQDAjkrY
2716tDChmKbvr8w6Du/t8vHjTCoCIocHTN0qzWOeb1YsAGX89+TrWIuO1dFyYd+Z0KC
272PDKB5j/ygml9Na+AklSYAVJIjvlzXKZrOaPmhZqDufi+rXWti/utVqY4VMW2+HKC
273nXp37qWeuFLGyR1519Y1d6F/5XzqmvbwURuEug==
274-----END CERTIFICATE-----"""
275
276 CLIENT_CERT_INVALID = '''-----BEGIN CERTIFICATE-----
277MIIDvTCCAqWgAwIBAgIBAjANBgkqhkiG9w0BAQUFADCBizELMAkGA1UEBhMCVVMx
278CzAJBgNVBAgTAkNBMRIwEAYDVQQHEwlTb21ld2hlcmUxEzARBgNVBAoTCkNpZW5h
279IEluYy4xHjAcBgkqhkiG9w0BCQEWD2FkbWluQGNpZW5hLmNvbTEmMCQGA1UEAxMd
280RXhhbXBsZSBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMTYwMzExMTg1MzM2WhcN
281MTcwMzA2MTg1MzM2WjBnMQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExEzARBgNV
282BAoTCkNpZW5hIEluYy4xFzAVBgNVBAMUDnVzZXJAY2llbmEuY29tMR0wGwYJKoZI
283hvcNAQkBFg51c2VyQGNpZW5hLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC
284AQoCggEBAOxemcBsPn9tZsCa5o2JA6sQDC7A6JgCNXXl2VFzKLNNvB9PS6D7ZBsQ
2855An0zEDMNzi51q7lnrYg1XyiE4S8FzMGAFr94RlGMQJUbRD9V/oqszMX4k++iAOK
286tIA1gr3x7Zi+0tkjVSVzXTmgNnhChAamdMsjYUG5+CY9WAicXyy+VEV3zTphZZDR
287OjcjEp4m/TSXVPYPgYDXI40YZKX5BdvqykWtT/tIgZb48RS1NPyN/XkCYzl3bv21
288qx7Mc0fcEbsJBIIRYTUkfxnsilcnmLxSYO+p+DZ9uBLBzcQt+4Rd5pLSfi21WM39
2892Z2oOi3vs/OYAPAqgmi2JWOv3mePa/8CAwEAAaNPME0wEwYDVR0lBAwwCgYIKwYB
290BQUHAwIwNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL3d3dy5leGFtcGxlLmNvbS9l
291eGFtcGxlX2NhLmNybDANBgkqhkiG9w0BAQUFAAOCAQEALBzMPDTIB6sLyPl0T6JV
292MjOkyldAVhXWiQsTjaGQGJUUe1cmUJyZbUZEc13MygXMPOM4x7z6VpXGuq1c/Vxn
293VzQ2fNnbJcIAHi/7G8W5/SQfPesIVDsHTEc4ZspPi5jlS/MVX3HOC+BDbOjdbwqP
294RX0JEr+uOyhjO+lRxG8ilMRACoBUbw1eDuVDoEBgErSUC44pq5ioDw2xelc+Y6hQ
295dmtYwfY0DbvwxHtA495frLyPcastDiT/zre7NL51MyUDPjjYjghNQEwvu66IKbQ3
296T1tJBrgI7/WI+dqhKBFolKGKTDWIHsZXQvZ1snGu/FRYzg1l+R/jT8cRB9BDwhUt
297yg==
298-----END CERTIFICATE-----'''
299
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]300 VOLTHA_HOST = None
A R Karthick18d0fb62017-09-01 18:49:07 -0700[diff] [blame]301 VOLTHA_TEARDOWN = True
A R Karthicke7232092017-09-07 18:01:33 -0700[diff] [blame]302 VOLTHA_REST_PORT = VolthaCtrl.REST_PORT
A R Karthickd52ca8a2017-07-24 17:38:55 -0700[diff] [blame]303 VOLTHA_UPLINK_VLAN_MAP = { 'of:0001000000000001' : '222' }
A R Karthick53442712017-07-27 12:23:30 -0700[diff] [blame]304 VOLTHA_UPLINK_VLAN_START = 333
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]305 VOLTHA_IGMP_ITERATIONS = 100
306 VOLTHA_CONFIG_FAKE = True
307 VOLTHA_OLT_TYPE = 'simulated_olt'
308 VOLTHA_OLT_MAC = '00:0c:e2:31:12:00'
309 VOLTHA_ENABLED = bool(int(os.getenv('VOLTHA_ENABLED', 0)))
A R Karthick9dc6e922017-07-12 14:40:16 -0700[diff] [blame]310 voltha_ctrl = None
311 voltha_device = None
312 voltha_switch_map = None
A R Karthick18d0fb62017-09-01 18:49:07 -0700[diff] [blame]313 voltha_preconfigured = False
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]314
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]315 @classmethod
A R Karthickb608d402017-06-02 11:48:41 -0700[diff] [blame]316 def update_apps_version(cls):
317 version = Onos.getVersion()
318 major = int(version.split('.')[0])
319 minor = int(version.split('.')[1])
320 cordigmp_app_version = '2.0-SNAPSHOT'
321 olt_app_version = '1.2-SNAPSHOT'
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]322 cord_config_app_version = '1.2-SNAPSHOT'
A R Karthickb608d402017-06-02 11:48:41 -0700[diff] [blame]323 if major > 1:
324 cordigmp_app_version = '3.0-SNAPSHOT'
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]325 olt_app_version = '2.0-SNAPSHOT'
326 cord_config_app_version = '2.0-SNAPSHOT'
A R Karthickb608d402017-06-02 11:48:41 -0700[diff] [blame]327 elif major == 1:
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]328 if minor > 10:
A R Karthickb608d402017-06-02 11:48:41 -0700[diff] [blame]329 cordigmp_app_version = '3.0-SNAPSHOT'
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]330 olt_app_version = '2.0-SNAPSHOT'
A R Karthickb608d402017-06-02 11:48:41 -0700[diff] [blame]331 elif minor <= 8:
332 olt_app_version = '1.1-SNAPSHOT'
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]333 cls.cord_config_app_file = os.path.join(cls.test_path, '..', 'apps/cord-config-{}.oar'.format(cord_config_app_version))
A R Karthickb608d402017-06-02 11:48:41 -0700[diff] [blame]334 cls.app_file = os.path.join(cls.test_path, '..', 'apps/ciena-cordigmp-{}.oar'.format(cordigmp_app_version))
335 cls.table_app_file = os.path.join(cls.test_path, '..', 'apps/ciena-cordigmp-multitable-{}.oar'.format(cordigmp_app_version))
336 cls.olt_app_file = os.path.join(cls.test_path, '..', 'apps/olt-app-{}.oar'.format(olt_app_version))
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]337 cls.updated_app_files = [cls.cord_config_app_file,cls.app_file,cls.table_app_file,cls.olt_app_file]
A R Karthickb608d402017-06-02 11:48:41 -0700[diff] [blame]338
339 @classmethod
A R Karthickd44cea12016-07-20 12:16:41 -0700[diff] [blame]340 def load_device_id(cls):
A R Karthickb03cecd2016-07-27 10:27:55 -0700[diff] [blame]341 '''Configure the device id'''
342 did = OnosCtrl.get_device_id()
A R Karthickd44cea12016-07-20 12:16:41 -0700[diff] [blame]343 #Set the default config
344 cls.device_id = did
345 cls.device_dict = { "devices" : {
346 "{}".format(did) : {
347 "basic" : {
Luca Prete9c0cdac2018-07-02 14:40:40 +0200[diff] [blame]348 "driver" : "voltha"
A R Karthickd44cea12016-07-20 12:16:41 -0700[diff] [blame]349 }
350 }
351 },
352 }
353 return did
354
355 @classmethod
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]356 def setUpClass(cls):
357 '''Load the OLT config and activate relevant apps'''
A R Karthickb608d402017-06-02 11:48:41 -0700[diff] [blame]358 cls.update_apps_version()
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]359 cls.olt = OltConfig(olt_conf_file = cls.olt_conf_file)
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]360 if cls.VOLTHA_ENABLED is False:
A R Karthick38d5df42017-07-10 13:33:26 -0700[diff] [blame]361 OnosCtrl.config_device_driver()
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]362 OnosCtrl.cord_olt_config(cls.olt)
A R Karthickb03cecd2016-07-27 10:27:55 -0700[diff] [blame]363 cls.port_map, cls.port_list = cls.olt.olt_port_map()
A R Karthick0f6b6842016-12-06 17:17:44 -0800[diff] [blame]364 cls.switches = cls.port_map['switches']
365 cls.num_ports = cls.port_map['num_ports']
366 if cls.num_ports > 1:
367 cls.num_ports -= 1 ##account for the tx port
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]368 cls.activate_apps(cls.apps + cls.olt_apps, deactivate = True)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]369
370 @classmethod
371 def tearDownClass(cls):
372 '''Deactivate the olt apps and restart OVS back'''
A R Karthick38d5df42017-07-10 13:33:26 -0700[diff] [blame]373 apps = cls.olt_apps
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]374 for app in apps:
375 onos_ctrl = OnosCtrl(app)
376 onos_ctrl.deactivate()
A R Karthick38d5df42017-07-10 13:33:26 -0700[diff] [blame]377 if cls.VOLTHA_ENABLED is False:
378 OnosCtrl.config_device_driver(driver = 'ovs')
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]379 #cls.igmp_proxy_teardown()
380 #Onos.install_cord_apps()
381 #OnosCtrl.install_app(cls.table_app_file,onos_ip=cls.controller)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]382
383 @classmethod
A.R Karthickaa859b22017-06-12 14:50:35 -0700[diff] [blame]384 def activate_apps(cls, apps, deactivate = False):
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]385 for app in apps:
386 onos_ctrl = OnosCtrl(app)
A.R Karthickaa859b22017-06-12 14:50:35 -0700[diff] [blame]387 if deactivate is True:
388 onos_ctrl.deactivate()
389 time.sleep(2)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]390 status, _ = onos_ctrl.activate()
391 assert_equal(status, True)
392 time.sleep(2)
393
394 @classmethod
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]395 log_test.info('In igmp proxy setup function ***************')
396 def igmpproxy_setup(cls,FastLeave='false'):
397 cls.uninstall_cord_config_app()
398 time.sleep(1)
399 cls.install_igmpproxy()
400 cls.igmp_proxy_setup()
401 cls.onos_igmp_proxy_config_load(FastLeave=FastLeave)
402
403 @classmethod
404 def igmp_proxy_teardown(cls):
405 ##reset the ONOS port configuration back to default
406 for config in cls.configs.items():
407 OnosCtrl.delete(config)
408 cls.uninstall_cord_config_app()
409 Onos.install_cord_apps()
410 OnosCtrl.install_app(cls.table_app_file,onos_ip=cls.controller)
411 #for app_file in cls.updated_app_files:
412 #OnosCtrl.install_app(cls.table_app_file)
413 #OnosCtrl.install_app(table_app_file)
414 #OnosCtrl.install_app(olt_app_file)
415
416 @classmethod
417 def uninstall_cord_config_app(cls):
418 log_test.info('Uninstalling org.opencord.config 1.2 version app')
419 OnosCtrl(cls.cord_config_app).deactivate()
420 OnosCtrl.uninstall_app(cls.cord_config_app, onos_ip = cls.controller)
421
422 @classmethod
423 def install_igmpproxy(cls):
424 log_test.info('In install igmp proxy function ***************')
425 for app in cls.app_files:
426 OnosCtrl.install_app(app, onos_ip = cls.controller)
427 OnosCtrl(app).activate()
428
429 @classmethod
430 def igmp_proxy_setup(cls):
431 did = OnosCtrl.get_device_id()
432 cls.proxy_device_id = did
433 cls.olt = OltConfig(olt_conf_file = cls.olt_conf_file)
434 cls.port_map, _ = cls.olt.olt_port_map()
435 #log_test.info('port map is %s'%cls.port_map)
436 if cls.port_map:
437 ##Per subscriber, we use 1 relay port
438 try:
439 proxy_port = cls.port_map[cls.port_map['relay_ports'][0]]
440 except:
441 proxy_port = cls.port_map['uplink']
442 cls.proxy_interface_port = proxy_port
443 cls.proxy_interfaces = (cls.port_map[cls.proxy_interface_port],)
444 else:
445 cls.proxy_interface_port = 100
446 cls.proxy_interfaces = (g_subscriber_port_map[cls.proxy_interface_port],)
447 cls.proxy_interfaces_last = cls.proxy_interfaces
448 if cls.port_map:
449 ##generate a ip/mac client virtual interface config for onos
450 interface_list = []
451 for port in cls.port_map['ports']:
452 port_num = cls.port_map[port]
453 if port_num == cls.port_map['uplink']:
454 continue
455 ip = cls.get_host_ip(port_num)
456 mac = cls.get_mac(port)
457 interface_list.append((port_num, ip, mac))
458 #configure igmp proxy virtual interface
459 proxy_ip = cls.get_host_ip(interface_list[0][0])
460 proxy_mac = cls.get_mac(cls.port_map[cls.proxy_interface_port])
461 interface_list.append((cls.proxy_interface_port, proxy_ip, proxy_mac))
462 cls.onos_interface_load(interface_list)
463
464 @classmethod
465 def onos_interface_load(cls, interface_list):
466 interface_dict = { 'ports': {} }
467 for port_num, ip, mac in interface_list:
468 port_map = interface_dict['ports']
469 port = '{}/{}'.format(cls.proxy_device_id, port_num)
470 port_map[port] = { 'interfaces': [] }
471 interface_list = port_map[port]['interfaces']
472 interface_map = { 'ips' : [ '{}/{}'.format(ip, 24) ],
473 'mac' : mac,
474 'name': 'vir-{}'.format(port_num)
475 }
476 interface_list.append(interface_map)
477 #cls.onos_load_config(interface_dict)
478 cls.configs['interface_config'] = interface_dict
479
480
481 @classmethod
482 def onos_igmp_proxy_config_load(cls, FastLeave = "false"):
483 #cls.proxy_interface_port = 12
484 proxy_connect_point = '{}/{}'.format(cls.proxy_device_id, cls.proxy_interface_port)
485 igmpproxy_dict = { "apps": {
486 "org.onosproject.provider.lldp": {
487 "suppression": {
488 "deviceTypes": ["ROADM"],
489 "annotation": "{\"no-lldp\":null}"
490 }
491 },
492 "org.opencord.igmpproxy": {
493 "igmpproxy": {
494 "globalConnectPointMode": "true",
495 "globalConnectPoint": proxy_connect_point,
496 "UnsolicitedTimeOut": "2",
497 "MaxResp": "10",
498 "KeepAliveInterval": "120",
499 "KeepAliveCount": "3",
500 "LastQueryInterval": "2",
501 "LastQueryCount": "2",
502 "FastLeave": FastLeave,
503 "PeriodicQuery": "true",
504 "IgmpCos": "7",
505 "withRAUpLink": "true",
506 "withRADownLink": "true"
507 }
508 },
509 "org.opencord.mcast": {
510 "multicast": {
511 "ingressVlan": "222",
512 "egressVlan": "17"
513 }
514 }
515 }
516 }
517 device_dict = {'devices':{
518 cls.proxy_device_id: {
519 'basic': {
520 'driver': 'default'
521 },
522 'accessDevice': {
523 'uplink': '2',
524 'vlan': '222',
525 'defaultVlan': '1'
526 }
527 }
528 }
529 }
530 log_test.info('Igmp proxy dict is %s'%igmpproxy_dict)
531 cls.onos_load_config("org.opencord.igmpproxy",igmpproxy_dict)
532 cls.onos_load_config("org.opencord.igmpproxy",device_dict)
533 cls.configs['relay_config'] = igmpproxy_dict
534 cls.configs['device_config'] = device_dict
535
536 def random_mcast_ip(self,start_ip = '224.1.1.1', end_ip = '224.1.254.254'):
537 start = list(map(int, start_ip.split(".")))
538 end = list(map(int, end_ip.split(".")))
539 temp = start
540 ip_range = []
541 ip_range.append(start_ip)
542 while temp != end:
543 start[3] += 1
544 for i in (3, 2, 1):
545 if temp[i] == 255:
546 temp[i] = 0
547 temp[i-1] += 1
548 ip_range.append(".".join(map(str, temp)))
549 return random.choice(ip_range)
550
551 def randomsourceip(self,start_ip = '10.10.0.1', end_ip = '10.10.0.100'):
552 start = list(map(int, start_ip.split(".")))
553 end = list(map(int, end_ip.split(".")))
554 temp = start
555 ip_range = []
556 ip_range.append(start_ip)
557 while temp != end:
558 start[3] += 1
559 for i in (3, 2, 1):
560 if temp[i] == 255:
561 temp[i] = 0
562 temp[i-1] += 1
563 ip_range.append(".".join(map(str, temp)))
564 return random.choice(ip_range)
565
566
567 @classmethod
568 def get_host_ip(cls, port):
569 if cls.host_ip_map.has_key(port):
570 return cls.host_ip_map[port]
571 cls.host_ip_map[port] = '192.168.1.{}'.format(port)
572 return cls.host_ip_map[port]
573
574 @classmethod
575 def get_mac(cls, iface):
576 if cls.interface_to_mac_map.has_key(iface):
577 return cls.interface_to_mac_map[iface]
578 mac = get_mac(iface, pad = 0)
579 cls.interface_to_mac_map[iface] = mac
580 return mac
581
582 @classmethod
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]583 def start_onos(cls, network_cfg = None):
A R Karthicka478df42016-07-27 16:51:08 -0700[diff] [blame]584 if cls.onos_restartable is False:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]585 log_test.info('ONOS restart is disabled. Skipping ONOS restart')
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]586 return
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]587 if cls.VOLTHA_ENABLED is True:
588 log_test.info('ONOS restart skipped as VOLTHA is running')
589 return
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]590 if network_cfg is None:
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]591 network_cfg = cls.device_dict
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]592
593 if type(network_cfg) is tuple:
594 res = []
595 for v in network_cfg:
596 res += v.items()
597 config = dict(res)
598 else:
599 config = network_cfg
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]600 log_test.info('Restarting ONOS with new network configuration')
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]601 return cord_test_onos_restart(config = config)
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]602
603 @classmethod
604 def remove_onos_config(cls):
605 try:
606 os.unlink('{}/network-cfg.json'.format(cls.onos_config_path))
607 except: pass
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]608
609 @classmethod
610 def start_cpqd(cls, mac = '00:11:22:33:44:55'):
611 dpid = mac.replace(':', '')
612 cpqd_file = os.sep.join( (cls.cpqd_path, 'cpqd.sh') )
613 cpqd_cmd = '{} {}'.format(cpqd_file, dpid)
614 ret = os.system(cpqd_cmd)
615 assert_equal(ret, 0)
616 time.sleep(10)
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]617 device_id = 'of:{}{}'.format('0'*4, dpid)
618 return device_id
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]619
620 @classmethod
621 def start_ovs(cls):
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]622 ovs_file = os.sep.join( (cls.ovs_path, 'of-bridge.sh') )
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]623 ret = os.system(ovs_file)
624 assert_equal(ret, 0)
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]625 time.sleep(30)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]626
A R Karthicka013a272016-08-16 16:40:19 -0700[diff] [blame]627 @classmethod
628 def ovs_cleanup(cls):
629 ##For every test case, delete all the OVS groups
630 cmd = 'ovs-ofctl del-groups br-int -OOpenFlow11 >/dev/null 2>&1'
A R Karthicka013a272016-08-16 16:40:19 -0700[diff] [blame]631 try:
A.R Karthick98fc7cf2017-05-17 14:39:46 -0700[diff] [blame]632 cord_test_shell(cmd)
633 ##Since olt config is used for this test, we just fire a careless local cmd as well
A R Karthicka013a272016-08-16 16:40:19 -0700[diff] [blame]634 os.system(cmd)
A.R Karthick98fc7cf2017-05-17 14:39:46 -0700[diff] [blame]635 finally:
636 return
A R Karthicka013a272016-08-16 16:40:19 -0700[diff] [blame]637
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]638 @classmethod
639 def onos_aaa_load(cls):
640 if cls.aaa_loaded:
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]641 return
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]642 aaa_dict = {'apps' : { 'org.opencord.aaa' : { 'AAA' : { 'radiusSecret': 'radius_password',
643 'radiusIp': '172.17.0.2' } } } }
644 radius_ip = os.getenv('ONOS_AAA_IP') or '172.17.0.2'
645 aaa_dict['apps']['org.opencord.aaa']['AAA']['radiusIp'] = radius_ip
646 cls.onos_load_config('org.opencord.aaa', aaa_dict)
647 cls.aaa_loaded = True
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]648
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]649 @classmethod
650 def onos_dhcp_table_load(cls, config = None):
651 dhcp_dict = {'apps' : { 'org.onosproject.dhcp' : { 'dhcp' : copy.copy(cls.dhcp_server_config) } } }
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]652 dhcp_config = dhcp_dict['apps']['org.onosproject.dhcp']['dhcp']
653 if config:
654 for k in config.keys():
655 if dhcp_config.has_key(k):
656 dhcp_config[k] = config[k]
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]657 cls.onos_load_config('org.onosproject.dhcp', dhcp_dict)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]658
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]659 @classmethod
660 def onos_load_config(cls, app, config):
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]661 status, code = OnosCtrl.config(config)
662 if status is False:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]663 log_test.info('JSON config request for app %s returned status %d' %(app, code))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]664 assert_equal(status, True)
665 time.sleep(2)
666
667 def dhcp_sndrcv(self, dhcp, update_seed = False):
668 cip, sip = dhcp.discover(update_seed = update_seed)
669 assert_not_equal(cip, None)
670 assert_not_equal(sip, None)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]671 log_test.info('Got dhcp client IP %s from server %s for mac %s' %
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]672 (cip, sip, dhcp.get_mac(cip)[0]))
673 return cip,sip
674
675 def dhcp_request(self, subscriber, seed_ip = '10.10.10.1', update_seed = False):
676 config = {'startip':'10.10.10.20', 'endip':'10.10.10.200',
677 'ip':'10.10.10.2', 'mac': "ca:fe:ca:fe:ca:fe",
678 'subnet': '255.255.255.0', 'broadcast':'10.10.10.255', 'router':'10.10.10.1'}
679 self.onos_dhcp_table_load(config)
680 dhcp = DHCPTest(seed_ip = seed_ip, iface = subscriber.iface)
681 cip, sip = self.dhcp_sndrcv(dhcp, update_seed = update_seed)
682 return cip, sip
683
684 def recv_channel_cb(self, pkt):
685 ##First verify that we have received the packet for the joined instance
686 chan = self.subscriber.caddr(pkt[IP].dst)
687 assert_equal(chan in self.subscriber.join_map.keys(), True)
688 recv_time = monotonic.monotonic() * 1000000
689 join_time = self.subscriber.join_map[chan][self.subscriber.STATS_JOIN].start
690 delta = recv_time - join_time
691 self.subscriber.join_rx_stats.update(packets=1, t = delta, usecs = True)
692 self.subscriber.channel_update(chan, self.subscriber.STATS_RX, 1, t = delta)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]693 log_test.debug('Packet received in %.3f usecs for group %s after join' %(delta, pkt[IP].dst))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]694 self.test_status = True
695
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]696 def traffic_verify(self, subscriber):
697 if subscriber.has_service('TRAFFIC'):
698 url = 'http://www.google.com'
699 resp = requests.get(url)
700 self.test_status = resp.ok
701 if resp.ok == False:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]702 log_test.info('Subscriber %s failed get from url %s with status code %d'
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]703 %(subscriber.name, url, resp.status_code))
704 else:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]705 log_test.info('GET request from %s succeeded for subscriber %s'
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]706 %(url, subscriber.name))
A R Karthicka013a272016-08-16 16:40:19 -0700[diff] [blame]707 return self.test_status
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]708
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]709 def tls_verify(self, subscriber):
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]710 def tls_fail_cb():
711 log_test.info('TLS verification failed')
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]712 if subscriber.has_service('TLS'):
A.R Karthickaa859b22017-06-12 14:50:35 -0700[diff] [blame]713 #OnosCtrl('org.opencord.aaa').deactivate()
714 #time.sleep(2)
715 #OnosCtrl('org.opencord.aaa').activate()
716 #time.sleep(5)
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]717 tls = TLSAuthTest(fail_cb = tls_fail_cb, intf = subscriber.rx_intf)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]718 log_test.info('Running subscriber %s tls auth test' %subscriber.name)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]719 tls.runTest()
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]720 assert_equal(tls.failTest, False)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]721 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]722 return self.test_status
723 else:
724 self.test_status = True
725 return self.test_status
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]726
727 def dhcp_verify(self, subscriber):
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]728 if subscriber.has_service('DHCP'):
729 cip, sip = self.dhcp_request(subscriber, update_seed = True)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]730 log_test.info('Subscriber %s got client ip %s from server %s' %(subscriber.name, cip, sip))
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]731 subscriber.src_list = [cip]
732 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]733 return self.test_status
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]734 else:
735 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
736 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]737 return self.test_status
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]738
739 def dhcp_jump_verify(self, subscriber):
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]740 if subscriber.has_service('DHCP'):
741 cip, sip = self.dhcp_request(subscriber, seed_ip = '10.10.200.1')
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]742 log_test.info('Subscriber %s got client ip %s from server %s' %(subscriber.name, cip, sip))
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]743 subscriber.src_list = [cip]
744 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]745 return self.test_status
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]746 else:
747 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
748 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]749 return self.test_status
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]750
751 def dhcp_next_verify(self, subscriber):
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]752 if subscriber.has_service('DHCP'):
753 cip, sip = self.dhcp_request(subscriber, seed_ip = '10.10.150.1')
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]754 log_test.info('Subscriber %s got client ip %s from server %s' %(subscriber.name, cip, sip))
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]755 subscriber.src_list = [cip]
756 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]757 return self.test_status
A R Karthick4b72d4b2016-06-15 11:09:17 -0700[diff] [blame]758 else:
759 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
760 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]761 return self.test_status
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]762
763 def igmp_verify(self, subscriber):
764 chan = 0
765 if subscriber.has_service('IGMP'):
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]766 ##We wait for all the subscribers to join before triggering leaves
767 if subscriber.rx_port > 1:
768 time.sleep(5)
769 subscriber.channel_join(chan, delay = 0)
770 self.num_joins += 1
771 while self.num_joins < self.num_subscribers:
772 time.sleep(5)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]773 log_test.info('All subscribers have joined the channel')
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]774 for i in range(10):
775 subscriber.channel_receive(chan, cb = subscriber.recv_channel_cb, count = 10)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]776 log_test.info('Leaving channel %d for subscriber %s' %(chan, subscriber.name))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]777 subscriber.channel_leave(chan)
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]778 time.sleep(5)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]779 log_test.info('Interface %s Join RX stats for subscriber %s, %s' %(subscriber.iface, subscriber.name,subscriber.join_rx_stats))
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]780 #Should not receive packets for this subscriber
781 self.recv_timeout = True
782 subscriber.recv_timeout = True
783 subscriber.channel_receive(chan, cb = subscriber.recv_channel_cb, count = 10)
784 subscriber.recv_timeout = False
785 self.recv_timeout = False
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]786 log_test.info('Joining channel %d for subscriber %s' %(chan, subscriber.name))
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]787 subscriber.channel_join(chan, delay = 0)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]788 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]789 return self.test_status
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]790
791 def igmp_jump_verify(self, subscriber):
792 if subscriber.has_service('IGMP'):
793 for i in xrange(subscriber.num):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]794 log_test.info('Subscriber %s jumping channel' %subscriber.name)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]795 chan = subscriber.channel_jump(delay=0)
796 subscriber.channel_receive(chan, cb = subscriber.recv_channel_cb, count = 1)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]797 log_test.info('Verified receive for channel %d, subscriber %s' %(chan, subscriber.name))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]798 time.sleep(3)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]799 log_test.info('Interface %s Jump RX stats for subscriber %s, %s' %(subscriber.iface, subscriber.name, subscriber.join_rx_stats))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]800 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]801 return self.test_status
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]802
803 def igmp_next_verify(self, subscriber):
804 if subscriber.has_service('IGMP'):
805 for i in xrange(subscriber.num):
806 if i:
A.R Karthick517f7812017-05-18 11:22:46 -0700[diff] [blame]807 chan = subscriber.channel_join_next(delay=0, leave_flag = self.leave_flag)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]808 else:
809 chan = subscriber.channel_join(i, delay=0)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]810 log_test.info('Joined next channel %d for subscriber %s' %(chan, subscriber.name))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]811 subscriber.channel_receive(chan, cb = subscriber.recv_channel_cb, count=1)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]812 log_test.info('Verified receive for channel %d, subscriber %s' %(chan, subscriber.name))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]813 time.sleep(3)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]814 log_test.info('Interface %s Join Next RX stats for subscriber %s, %s' %(subscriber.iface, subscriber.name, subscriber.join_rx_stats))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]815 self.test_status = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]816 return self.test_status
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]817
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]818 def voltha_igmp_next_verify(self, subscriber):
819 if subscriber.has_service('IGMP'):
820 for c in xrange(self.VOLTHA_IGMP_ITERATIONS):
821 for i in xrange(subscriber.num):
822 if i:
823 chan = subscriber.channel_join_next(delay=0, leave_flag = self.leave_flag)
824 time.sleep(0.2)
825 else:
826 chan = subscriber.channel_join(i, delay=0)
827 time.sleep(0.2)
A.R Karthick56e59432017-06-06 18:05:46 -0700[diff] [blame]828 if subscriber.num == 1:
829 subscriber.channel_leave(chan)
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]830 log_test.info('Joined next channel %d for subscriber %s' %(chan, subscriber.name))
831 #subscriber.channel_receive(chan, cb = subscriber.recv_channel_cb, count=1)
832 #log_test.info('Verified receive for channel %d, subscriber %s' %(chan, subscriber.name))
833 self.test_status = True
834 return self.test_status
835
A R Karthick31f1f342017-05-19 13:55:10 -0700[diff] [blame]836 def igmp_leave_verify(self, subscriber):
837 if subscriber.has_service('IGMP'):
838 for chan in xrange(subscriber.num):
A R Karthick78d1f492017-05-19 14:24:17 -0700[diff] [blame]839 subscriber.channel_leave(chan, force = True)
A R Karthick31f1f342017-05-19 13:55:10 -0700[diff] [blame]840 time.sleep(2)
841 log_test.info('Left channel %d for subscriber %s' %(chan, subscriber.name))
842 #self.recv_timeout = True
843 #subscriber.recv_timeout = True
844 #subscriber.channel_receive(chan, cb = subscriber.recv_channel_cb, count=1)
845 #self.recv_timeout = False
846 #subscriber.recv_timeout = False
847 #log_test.info('Verified receive for channel %d, subscriber %s' %(chan, subscriber.name))
848 #time.sleep(1)
849
850 self.test_status = True
851 return self.test_status
852
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]853 def generate_port_list(self, subscribers, channels):
854 return self.port_list[:subscribers]
855
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]856 def subscriber_load(self, create = True, num = 10, num_channels = 1, channel_start = 0, port_list = [], services = None):
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]857 '''Load the subscriber from the database'''
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]858 test_services = services if services else self.test_services
859 self.subscriber_db = SubscriberDB(create = create, services = test_services)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]860 if create is True:
861 self.subscriber_db.generate(num)
862 self.subscriber_info = self.subscriber_db.read(num)
863 self.subscriber_list = []
864 if not port_list:
865 port_list = self.generate_port_list(num, num_channels)
866
867 index = 0
868 for info in self.subscriber_info:
A.R Karthick95d044e2016-06-10 18:44:36 -0700[diff] [blame]869 self.subscriber_list.append(Subscriber(name=info['Name'],
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]870 service=info['Service'],
871 port_map = self.port_map,
872 num=num_channels,
873 channel_start = channel_start,
874 tx_port = port_list[index][0],
875 rx_port = port_list[index][1]))
876 if num_channels > 1:
877 channel_start += num_channels
878 index += 1
879
880 #load the ssm list for all subscriber channels
881 igmpChannel = IgmpChannel()
882 ssm_groups = map(lambda sub: sub.channels, self.subscriber_list)
883 ssm_list = reduce(lambda ssm1, ssm2: ssm1+ssm2, ssm_groups)
884 igmpChannel.igmp_load_ssm_config(ssm_list)
885
A.R Karthick95d044e2016-06-10 18:44:36 -0700[diff] [blame]886 def subscriber_join_verify( self, num_subscribers = 10, num_channels = 1,
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]887 channel_start = 0, cbs = None, port_list = [],
888 services = None, negative_subscriber_auth = None):
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]889 self.test_status = False
A R Karthicka013a272016-08-16 16:40:19 -0700[diff] [blame]890 self.ovs_cleanup()
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]891 subscribers_count = num_subscribers
892 sub_loop_count = num_subscribers
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]893 self.subscriber_load(create = True, num = num_subscribers,
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]894 num_channels = num_channels, channel_start = channel_start, port_list = port_list,
895 services = services)
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]896 self.onos_aaa_load()
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]897 self.thread_pool = ThreadPool(min(100, subscribers_count), queue_size=1, wait_timeout=1)
898
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]899 chan_leave = False #for single channel, multiple subscribers
A R Karthicke237aee2016-12-01 17:46:43 -0800[diff] [blame]900 if cbs is None:
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]901 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify, self.traffic_verify)
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]902 chan_leave = True
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]903 cbs_negative = cbs
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]904 for subscriber in self.subscriber_list:
A.R Karthick4bd5f532017-06-06 11:37:27 -0700[diff] [blame]905 if services and 'IGMP' in services:
906 subscriber.start()
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]907 if negative_subscriber_auth is 'half' and sub_loop_count%2 is not 0:
908 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify, self.traffic_verify)
909 elif negative_subscriber_auth is 'onethird' and sub_loop_count%3 is not 0:
910 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify, self.traffic_verify)
911 else:
912 cbs = cbs_negative
913 sub_loop_count = sub_loop_count - 1
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]914 pool_object = subscriber_pool(subscriber, cbs)
915 self.thread_pool.addTask(pool_object.pool_cb)
916 self.thread_pool.cleanUpThreads()
917 for subscriber in self.subscriber_list:
A.R Karthick4bd5f532017-06-06 11:37:27 -0700[diff] [blame]918 if services and 'IGMP' in services:
919 subscriber.stop()
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]920 if chan_leave is True:
921 subscriber.channel_leave(0)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]922 subscribers_count = 0
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]923 return self.test_status
924
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]925 def tls_invalid_cert(self, subscriber):
926 if subscriber.has_service('TLS'):
927 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]928 log_test.info('Running subscriber %s tls auth test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]929 tls = TLSAuthTest(client_cert = self.CLIENT_CERT_INVALID)
930 tls.runTest()
931 if tls.failTest == True:
932 self.test_status = False
933 return self.test_status
934 else:
935 self.test_status = True
936 return self.test_status
937
938 def tls_no_cert(self, subscriber):
939 if subscriber.has_service('TLS'):
940 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]941 log_test.info('Running subscriber %s tls auth test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]942 tls = TLSAuthTest(client_cert = '')
943 tls.runTest()
944 if tls.failTest == True:
945 self.test_status = False
946 return self.test_status
947 else:
948 self.test_status = True
949 return self.test_status
950
951 def tls_self_signed_cert(self, subscriber):
952 if subscriber.has_service('TLS'):
953 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]954 log_test.info('Running subscriber %s tls auth test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]955 tls = TLSAuthTest(client_cert = self.CLIENT_CERT)
956 tls.runTest()
957 if tls.failTest == False:
958 self.test_status = True
959 return self.test_status
960 else:
961 self.test_status = True
962 return self.test_status
963
964 def tls_non_ca_authrized_cert(self, subscriber):
965 if subscriber.has_service('TLS'):
966 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]967 log_test.info('Running subscriber %s tls auth test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]968 tls = TLSAuthTest(client_cert = self.CLIENT_CERT_NON_CA_AUTHORIZED)
969 tls.runTest()
970 if tls.failTest == False:
971 self.test_status = True
972 return self.test_status
973 else:
974 self.test_status = True
975 return self.test_status
976
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]977 def tls_Nsubscribers_use_same_valid_cert(self, subscriber):
978 if subscriber.has_service('TLS'):
979 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]980 log_test.info('Running subscriber %s tls auth test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]981 num_users = 3
982 for i in xrange(num_users):
983 tls = TLSAuthTest(intf = 'veth{}'.format(i*2))
984 tls.runTest()
985 if tls.failTest == False:
986 self.test_status = True
987 return self.test_status
988 else:
989 self.test_status = True
990 return self.test_status
991
992 def dhcp_discover_scenario(self, subscriber):
993 if subscriber.has_service('DHCP'):
994 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]995 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]996 t1 = self.subscriber_dhcp_1release()
997 self.test_status = True
998 return self.test_status
999 else:
1000 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1001 self.test_status = True
1002 return self.test_status
1003
1004 def subscriber_dhcp_1release(self, iface = INTF_RX_DEFAULT):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1005 config = {'startip':'10.10.100.20', 'endip':'10.10.100.21',
1006 'ip':'10.10.100.2', 'mac': "ca:fe:ca:fe:8a:fe",
1007 'subnet': '255.255.255.0', 'broadcast':'10.10.100.255', 'router':'10.10.100.1'}
1008 self.onos_dhcp_table_load(config)
1009 self.dhcp = DHCPTest(seed_ip = '10.10.100.10', iface = iface)
1010 cip, sip = self.send_recv()
1011 log_test.info('Releasing ip %s to server %s' %(cip, sip))
1012 assert_equal(self.dhcp.release(cip), True)
1013 log_test.info('Triggering DHCP discover again after release')
1014 cip2, sip2 = self.send_recv(update_seed = True)
1015 log_test.info('Verifying released IP was given back on rediscover')
1016 assert_equal(cip, cip2)
1017 log_test.info('Test done. Releasing ip %s to server %s' %(cip2, sip2))
1018 assert_equal(self.dhcp.release(cip2), True)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1019
1020 def dhcp_client_reboot_scenario(self, subscriber):
1021 if subscriber.has_service('DHCP'):
1022 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1023 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1024 tl = self.subscriber_dhcp_client_request_after_reboot()
1025 self.test_status = True
1026 return self.test_status
1027 else:
1028 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1029 self.test_status = True
1030 return self.test_status
1031
1032 def subscriber_dhcp_client_request_after_reboot(self, iface = INTF_RX_DEFAULT):
1033 #''' Client sends DHCP Request after reboot.'''
1034
1035 config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
1036 'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
1037 'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
1038 self.onos_dhcp_table_load(config)
1039 self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
1040 cip, sip, mac, lval = self.dhcp.only_discover()
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1041 log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1042 (cip, sip, mac) )
1043
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1044 log_test.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1045
1046 if (cip == None and mac != None):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1047 log_test.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1048 assert_not_equal(cip, None)
1049
1050 else:
1051 new_cip, new_sip = self.dhcp.only_request(cip, mac)
1052 if new_cip == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1053 log_test.info("Got DHCP server NAK.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1054 os.system('ifconfig '+iface+' down')
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1055 log_test.info('Client goes down.')
1056 log_test.info('Delay for 5 seconds.')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1057
1058 time.sleep(5)
1059
1060 os.system('ifconfig '+iface+' up')
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1061 log_test.info('Client is up now.')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1062
1063 new_cip, new_sip = self.dhcp.only_request(cip, mac)
1064 if new_cip == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1065 log_test.info("Got DHCP server NAK.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1066 assert_not_equal(new_cip, None)
1067 elif new_cip != None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1068 log_test.info("Got DHCP ACK.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1069
1070 def dhcp_client_renew_scenario(self, subscriber):
1071 if subscriber.has_service('DHCP'):
1072 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1073 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1074 tl = self.subscriber_dhcp_client_renew_time()
1075 self.test_status = True
1076 return self.test_status
1077 else:
1078 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1079 self.test_status = True
1080 return self.test_status
1081
1082 def subscriber_dhcp_client_renew_time(self, iface = INTF_RX_DEFAULT):
1083 config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
1084 'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
1085 'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
1086 self.onos_dhcp_table_load(config)
1087 self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
1088 cip, sip, mac , lval = self.dhcp.only_discover()
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1089 log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1090 (cip, sip, mac) )
1091
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1092 log_test.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1093 if (cip == None and mac != None):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1094 log_test.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1095 assert_not_equal(cip, None)
1096 elif cip and sip and mac:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1097 log_test.info("Triggering DHCP Request.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1098 new_cip, new_sip, lval = self.dhcp.only_request(cip, mac, renew_time = True)
1099 if new_cip and new_sip and lval:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1100 log_test.info("Client 's Renewal time is :%s",lval)
1101 log_test.info("Generating delay till renewal time.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1102 time.sleep(lval)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1103 log_test.info("Client Sending Unicast DHCP request.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1104 latest_cip, latest_sip = self.dhcp.only_request(new_cip, mac, unicast = True)
1105 if latest_cip and latest_sip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1106 log_test.info("Got DHCP Ack. Lease Renewed for ip %s and mac %s from server %s." %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1107 (latest_cip, mac, latest_sip) )
1108
1109 elif latest_cip == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1110 log_test.info("Got DHCP NAK. Lease not renewed.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1111 elif new_cip == None or new_sip == None or lval == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1112 log_test.info("Got DHCP NAK.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1113
1114 def dhcp_server_reboot_scenario(self, subscriber):
1115 if subscriber.has_service('DHCP'):
1116 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1117 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1118 tl = self.subscriber_dhcp_server_after_reboot()
1119 self.test_status = True
1120 return self.test_status
1121 else:
1122 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1123 self.test_status = True
1124 return self.test_status
1125
1126 def subscriber_dhcp_server_after_reboot(self, iface = INTF_RX_DEFAULT):
1127 ''' DHCP server goes down.'''
1128 config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
1129 'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
1130 'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
1131 self.onos_dhcp_table_load(config)
1132 self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
1133 cip, sip, mac, lval = self.dhcp.only_discover()
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1134 log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1135 (cip, sip, mac) )
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1136 log_test.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1137 if (cip == None and mac != None):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1138 log_test.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1139 assert_not_equal(cip, None)
1140 else:
1141 new_cip, new_sip = self.dhcp.only_request(cip, mac)
1142 if new_cip == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1143 log_test.info("Got DHCP server NAK.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1144 assert_not_equal(new_cip, None)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1145 log_test.info('Getting DHCP server Down.')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1146 onos_ctrl = OnosCtrl(self.dhcp_app)
1147 onos_ctrl.deactivate()
1148 for i in range(0,4):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1149 log_test.info("Sending DHCP Request.")
1150 log_test.info('')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1151 new_cip, new_sip = self.dhcp.only_request(cip, mac)
1152 if new_cip == None and new_sip == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1153 log_test.info('')
1154 log_test.info("DHCP Request timed out.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1155 elif new_cip and new_sip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1156 log_test.info("Got Reply from DHCP server.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1157 assert_equal(new_cip,None) #Neagtive Test Case
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1158 log_test.info('Getting DHCP server Up.')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1159# self.activate_apps(self.dhcp_app)
1160 onos_ctrl = OnosCtrl(self.dhcp_app)
1161 status, _ = onos_ctrl.activate()
1162 assert_equal(status, True)
1163 time.sleep(3)
1164 for i in range(0,4):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1165 log_test.info("Sending DHCP Request after DHCP server is up.")
1166 log_test.info('')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1167 new_cip, new_sip = self.dhcp.only_request(cip, mac)
1168 if new_cip == None and new_sip == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1169 log_test.info('')
1170 log_test.info("DHCP Request timed out.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1171 elif new_cip and new_sip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1172 log_test.info("Got Reply from DHCP server.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1173 assert_equal(new_cip,None) #Neagtive Test Case
1174
1175 def dhcp_client_rebind_scenario(self, subscriber):
1176 if subscriber.has_service('DHCP'):
1177 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1178 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1179 tl = self.subscriber_dhcp_client_rebind_time()
1180 self.test_status = True
1181 return self.test_status
1182 else:
1183 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1184 self.test_status = True
1185 return self.test_status
1186
1187 def subscriber_dhcp_client_rebind_time(self, iface = INTF_RX_DEFAULT):
1188 config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
1189 'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
1190 'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
1191 self.onos_dhcp_table_load(config)
1192 self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
1193 cip, sip, mac, lval = self.dhcp.only_discover()
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1194 log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1195 (cip, sip, mac) )
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1196 log_test.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1197 if (cip == None and mac != None):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1198 log_test.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1199 assert_not_equal(cip, None)
1200 elif cip and sip and mac:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1201 log_test.info("Triggering DHCP Request.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1202 new_cip, new_sip, lval = self.dhcp.only_request(cip, mac, rebind_time = True)
1203 if new_cip and new_sip and lval:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1204 log_test.info("Client 's Rebind time is :%s",lval)
1205 log_test.info("Generating delay till rebind time.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1206 time.sleep(lval)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1207 log_test.info("Client Sending broadcast DHCP requests for renewing lease or for getting new ip.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1208 self.dhcp.after_T2 = True
1209 for i in range(0,4):
1210 latest_cip, latest_sip = self.dhcp.only_request(new_cip, mac)
1211 if latest_cip and latest_sip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1212 log_test.info("Got DHCP Ack. Lease Renewed for ip %s and mac %s from server %s." %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1213 (latest_cip, mac, latest_sip) )
1214 break
1215 elif latest_cip == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1216 log_test.info("Got DHCP NAK. Lease not renewed.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1217 assert_not_equal(latest_cip, None)
1218 elif new_cip == None or new_sip == None or lval == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1219 log_test.info("Got DHCP NAK.Lease not Renewed.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1220
1221 def dhcp_starvation_scenario(self, subscriber):
1222 if subscriber.has_service('DHCP'):
1223 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1224 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1225 tl = self.subscriber_dhcp_starvation()
1226 self.test_status = True
1227 return self.test_status
1228 else:
1229 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1230 self.test_status = True
1231 return self.test_status
1232
1233 def subscriber_dhcp_starvation(self, iface = INTF_RX_DEFAULT):
1234 '''DHCP starve'''
1235 config = {'startip':'182.17.0.20', 'endip':'182.17.0.69',
1236 'ip':'182.17.0.2', 'mac': "ca:fe:c3:fe:ca:fe",
1237 'subnet': '255.255.255.0', 'broadcast':'182.17.0.255', 'router':'182.17.0.1'}
1238 self.onos_dhcp_table_load(config)
1239 self.dhcp = DHCPTest(seed_ip = '182.17.0.1', iface = iface)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1240 log_test.info('Verifying 1 ')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1241 for x in xrange(50):
1242 mac = RandMAC()._fix()
1243 self.send_recv(mac = mac)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1244 log_test.info('Verifying 2 ')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1245 cip, sip = self.send_recv(update_seed = True, validate = False)
1246 assert_equal(cip, None)
1247 assert_equal(sip, None)
1248
1249 def dhcp_same_client_multi_discovers_scenario(self, subscriber):
1250 if subscriber.has_service('DHCP'):
1251 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1252 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1253 tl = self.subscriber_dhcp_same_client_multiple_discover()
1254 self.test_status = True
1255 return self.test_status
1256 else:
1257 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1258 self.test_status = True
1259 return self.test_status
1260
1261 def subscriber_dhcp_same_client_multiple_discover(self, iface = INTF_RX_DEFAULT):
1262 ''' DHCP Client sending multiple discover . '''
1263 config = {'startip':'10.10.10.20', 'endip':'10.10.10.69',
1264 'ip':'10.10.10.2', 'mac': "ca:fe:ca:fe:ca:fe",
1265 'subnet': '255.255.255.0', 'broadcast':'10.10.10.255', 'router':'10.10.10.1'}
1266 self.onos_dhcp_table_load(config)
1267 self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
1268 cip, sip, mac, lval = self.dhcp.only_discover()
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1269 log_test.info('Got dhcp client IP %s from server %s for mac %s . Not going to send DHCPREQUEST.' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1270 (cip, sip, mac) )
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1271 log_test.info('Triggering DHCP discover again.')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1272 new_cip, new_sip, new_mac , lval = self.dhcp.only_discover()
1273 if cip == new_cip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1274 log_test.info('Got same ip for 2nd DHCP discover for client IP %s from server %s for mac %s. Triggering DHCP Request. '
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1275 % (new_cip, new_sip, new_mac) )
1276 elif cip != new_cip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1277 log_test.info('Ip after 1st discover %s' %cip)
1278 log_test.info('Map after 2nd discover %s' %new_cip)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1279 assert_equal(cip, new_cip)
1280
1281 def dhcp_same_client_multi_request_scenario(self, subscriber):
1282 if subscriber.has_service('DHCP'):
1283 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1284 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1285 tl = self.subscriber_dhcp_same_client_multiple_request()
1286 self.test_status = True
1287 return self.test_status
1288 else:
1289 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1290 self.test_status = True
1291 return self.test_status
1292
1293 def subscriber_dhcp_same_client_multiple_request(self, iface = INTF_RX_DEFAULT):
1294 ''' DHCP Client sending multiple repeat DHCP requests. '''
1295 config = {'startip':'10.10.10.20', 'endip':'10.10.10.69',
1296 'ip':'10.10.10.2', 'mac': "ca:fe:ca:fe:ca:fe",
1297 'subnet': '255.255.255.0', 'broadcast':'10.10.10.255', 'router':'10.10.10.1'}
1298 self.onos_dhcp_table_load(config)
1299 self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1300 log_test.info('Sending DHCP discover and DHCP request.')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1301 cip, sip = self.send_recv()
1302 mac = self.dhcp.get_mac(cip)[0]
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1303 log_test.info("Sending DHCP request again.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1304 new_cip, new_sip = self.dhcp.only_request(cip, mac)
1305 if (new_cip,new_sip) == (cip,sip):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1306 log_test.info('Got same ip for 2nd DHCP Request for client IP %s from server %s for mac %s.'
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1307 % (new_cip, new_sip, mac) )
1308 elif (new_cip,new_sip):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1309 log_test.info('No DHCP ACK')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1310 assert_equal(new_cip, None)
1311 assert_equal(new_sip, None)
1312 else:
1313 print "Something went wrong."
1314
1315 def dhcp_client_desired_ip_scenario(self, subscriber):
1316 if subscriber.has_service('DHCP'):
1317 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1318 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1319 tl = self.subscriber_dhcp_client_desired_address()
1320 self.test_status = True
1321 return self.test_status
1322 else:
1323 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1324 self.test_status = True
1325 return self.test_status
1326
1327 def subscriber_dhcp_client_desired_address(self, iface = INTF_RX_DEFAULT):
1328 '''DHCP Client asking for desired IP address.'''
1329 config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
1330 'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
1331 'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
1332 self.onos_dhcp_table_load(config)
1333 self.dhcp = DHCPTest(seed_ip = '20.20.20.31', iface = iface)
1334 cip, sip, mac , lval = self.dhcp.only_discover(desired = True)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1335 log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1336 (cip, sip, mac) )
1337 if cip == self.dhcp.seed_ip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1338 log_test.info('Got dhcp client IP %s from server %s for mac %s as desired .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1339 (cip, sip, mac) )
1340 elif cip != self.dhcp.seed_ip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1341 log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1342 (cip, sip, mac) )
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1343 log_test.info('The desired ip was: %s .' % self.dhcp.seed_ip)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1344 assert_equal(cip, self.dhcp.seed_ip)
1345
1346 def dhcp_client_request_pkt_with_non_offered_ip_scenario(self, subscriber):
1347 if subscriber.has_service('DHCP'):
1348 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1349 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1350 tl = self.subscriber_dhcp_server_nak_packet()
1351 self.test_status = True
1352 return self.test_status
1353 else:
1354 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1355 self.test_status = True
1356 return self.test_status
1357
1358 def subscriber_dhcp_server_nak_packet(self, iface = INTF_RX_DEFAULT):
1359 config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
1360 'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
1361 'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
1362 self.onos_dhcp_table_load(config)
1363 self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
1364 cip, sip, mac, lval = self.dhcp.only_discover()
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1365 log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1366 (cip, sip, mac) )
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1367 log_test.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1368 if (cip == None and mac != None):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1369 log_test.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1370 assert_not_equal(cip, None)
1371 else:
1372 new_cip, new_sip = self.dhcp.only_request('20.20.20.31', mac)
1373 if new_cip == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1374 log_test.info("Got DHCP server NAK.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1375 assert_equal(new_cip, None) #Negative Test Case
1376
1377 def dhcp_client_requested_out_pool_ip_scenario(self, subscriber):
1378 if subscriber.has_service('DHCP'):
1379 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1380 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1381 tl = self.subscriber_dhcp_client_desired_address_out_of_pool()
1382 self.test_status = True
1383 return self.test_status
1384 else:
1385 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1386 self.test_status = True
1387 return self.test_status
1388
1389 def subscriber_dhcp_client_desired_address_out_of_pool(self, iface = INTF_RX_DEFAULT):
1390 '''DHCP Client asking for desired IP address from out of pool.'''
1391 config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
1392 'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
1393 'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
1394 self.onos_dhcp_table_load(config)
1395 self.dhcp = DHCPTest(seed_ip = '20.20.20.35', iface = iface)
1396 cip, sip, mac, lval = self.dhcp.only_discover(desired = True)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1397 log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1398 (cip, sip, mac) )
1399 if cip == self.dhcp.seed_ip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1400 log_test.info('Got dhcp client IP %s from server %s for mac %s as desired .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1401 (cip, sip, mac) )
1402 assert_equal(cip, self.dhcp.seed_ip) #Negative Test Case
1403
1404 elif cip != self.dhcp.seed_ip:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1405 log_test.info('Got dhcp client IP %s from server %s for mac %s .' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1406 (cip, sip, mac) )
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1407 log_test.info('The desired ip was: %s .' % self.dhcp.seed_ip)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1408 assert_not_equal(cip, self.dhcp.seed_ip)
1409
1410 elif cip == None:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1411 log_test.info('Got DHCP NAK')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1412
1413 def dhcp_client_specific_lease_scenario(self, subscriber):
1414 if subscriber.has_service('DHCP'):
1415 time.sleep(2)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1416 log_test.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1417 tl = self.subscriber_dhcp_specific_lease_packet()
1418 self.test_status = True
1419 return self.test_status
1420 else:
1421 subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
1422 self.test_status = True
1423 return self.test_status
1424
1425 def subscriber_dhcp_specific_lease_packet(self, iface = INTF_RX_DEFAULT):
1426 ''' Client sends DHCP Discover packet for particular lease time.'''
1427 config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
1428 'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
1429 'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
1430 self.onos_dhcp_table_load(config)
1431 self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1432 log_test.info('Sending DHCP discover with lease time of 700')
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1433 cip, sip, mac, lval = self.dhcp.only_discover(lease_time = True)
1434
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1435 log_test.info("Verifying Client 's IP and mac in DHCP Offer packet.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1436 if (cip == None and mac != None):
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1437 log_test.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1438 assert_not_equal(cip, None)
1439 elif lval != 700:
A R Karthick76a497a2017-04-12 10:59:39 -0700[diff] [blame]1440 log_test.info('Getting dhcp client IP %s from server %s for mac %s with lease time %s. That is not 700.' %
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1441 (cip, sip, mac, lval) )
1442 assert_not_equal(lval, 700)
1443
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1444 def test_cord_subscriber_for_joining_channel_and_receiving_stream(self):
ChetanGaonkerf9c2f8b2016-07-19 15:49:41 -0700[diff] [blame]1445 """Test subscriber join and receive for channel surfing"""
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]1446 self.num_subscribers = 5
1447 self.num_channels = 1
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1448 self.igmpproxy_setup()
A R Karthick38d5df42017-07-10 13:33:26 -0700[diff] [blame]1449 test_status = self.subscriber_join_verify(num_subscribers = self.num_subscribers,
1450 num_channels = self.num_channels,
1451 port_list = self.generate_port_list(self.num_subscribers,
1452 self.num_channels))
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1453 test_status = True
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]1454 assert_equal(test_status, True)
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1455 self.igmp_proxy_teardown()
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]1456
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1457 def test_cord_subscriber_for_joining_channel_validating_stream_and_jumping_channel(self):
A R Karthicka478df42016-07-27 16:51:08 -0700[diff] [blame]1458 """Test subscriber join jump for channel surfing"""
A R Karthick0f6b6842016-12-06 17:17:44 -0800[diff] [blame]1459 self.num_subscribers = self.num_ports * len(self.switches)
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]1460 self.num_channels = 10
1461 test_status = self.subscriber_join_verify(num_subscribers = self.num_subscribers,
1462 num_channels = self.num_channels,
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]1463 cbs = (self.tls_verify, self.dhcp_jump_verify,
1464 self.igmp_jump_verify, self.traffic_verify),
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]1465 port_list = self.generate_port_list(self.num_subscribers,
1466 self.num_channels))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]1467 assert_equal(test_status, True)
1468
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1469 def test_cord_subscriber_for_joining_channel_validating_stream_and_joining_next_channel(self):
ChetanGaonkerf9c2f8b2016-07-19 15:49:41 -0700[diff] [blame]1470 """Test subscriber join next for channel surfing"""
A R Karthick0f6b6842016-12-06 17:17:44 -0800[diff] [blame]1471 self.num_subscribers = self.num_ports * len(self.switches)
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]1472 self.num_channels = 10
1473 test_status = self.subscriber_join_verify(num_subscribers = self.num_subscribers,
1474 num_channels = self.num_channels,
A R Karthick65c4d722016-07-18 14:20:17 -0700[diff] [blame]1475 cbs = (self.tls_verify, self.dhcp_next_verify,
1476 self.igmp_next_verify, self.traffic_verify),
A R Karthick338268f2016-06-21 17:12:13 -0700[diff] [blame]1477 port_list = self.generate_port_list(self.num_subscribers,
1478 self.num_channels))
A R Karthickb7e80902016-05-17 09:38:31 -0700[diff] [blame]1479 assert_equal(test_status, True)
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1480
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1481 def test_cord_subscriber_for_joining_channel_validating_stream_and_joining_next_channel_without_leave_for_last_channel(self):
A.R Karthick517f7812017-05-18 11:22:46 -0700[diff] [blame]1482 """Test subscriber join next for channel surfing"""
1483 self.num_subscribers = self.num_ports * len(self.switches)
1484 self.num_channels = 5
1485 self.leave_flag = False
1486 test_status = self.subscriber_join_verify(num_subscribers = self.num_subscribers,
1487 num_channels = self.num_channels,
1488 cbs = (self.tls_verify, self.dhcp_next_verify,
1489 self.igmp_next_verify, self.traffic_verify),
1490 port_list = self.generate_port_list(self.num_subscribers,
1491 self.num_channels))
1492 self.leave_flag = True
1493 assert_equal(test_status, True)
1494
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1495 def test_cord_subscriber_for_channel_leave(self):
A R Karthick31f1f342017-05-19 13:55:10 -0700[diff] [blame]1496 """Test subscriber leaves for all the join nexts before"""
1497 self.num_subscribers = self.num_ports * len(self.switches)
1498 self.num_channels = 5
1499 test_status = self.subscriber_join_verify(num_subscribers = self.num_subscribers,
1500 num_channels = self.num_channels,
1501 cbs = (self.tls_verify, self.dhcp_next_verify,
1502 self.igmp_leave_verify, self.traffic_verify),
1503 port_list = self.generate_port_list(self.num_subscribers,
1504 self.num_channels))
1505 assert_equal(test_status, True)
1506
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1507 #@deferred(SUBSCRIBER_TIMEOUT)
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1508 def test_cord_subscriber_authentication_with_invalid_certificate_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1509 ### """Test subscriber to auth with invalidCertification and join channel"""
1510 num_subscribers = 1
1511 num_channels = 1
1512 df = defer.Deferred()
1513 def sub_auth_invalid_cert(df):
1514 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1515 num_channels = num_channels,
1516 cbs = (self.tls_invalid_cert, self.dhcp_verify,
1517 self.igmp_verify, self.traffic_verify),
1518 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1519 assert_equal(test_status, False)
1520 df.callback(0)
1521 reactor.callLater(0, sub_auth_invalid_cert, df)
1522 return df
1523
1524 #@deferred(SUBSCRIBER_TIMEOUT)
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1525 def test_cord_subscriber_authentication_with_no_certificate_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1526 ### """Test subscriber to auth with No Certification and join channel"""
1527 num_subscribers = 1
1528 num_channels = 1
1529 df = defer.Deferred()
1530 def sub_auth_no_cert(df):
1531 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1532 num_channels = num_channels,
1533 cbs = (self.tls_no_cert, self.dhcp_verify,
1534 self.igmp_verify, self.traffic_verify),
1535 port_list = self.generate_port_list(num_subscribers, num_channels),
1536 negative_subscriber_auth = 'all')
1537 assert_equal(test_status, False)
1538 df.callback(0)
1539 reactor.callLater(0, sub_auth_no_cert, df)
1540 return df
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1541 def test_cord_subscriber_authentication_with_self_signed_certificate_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1542 ### """Test subscriber to auth with Self Signed Certification and join channel"""
1543 num_subscribers = 1
1544 num_channels = 1
1545 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1546 num_channels = num_channels,
1547 cbs = (self.tls_self_signed_cert, self.dhcp_verify,
1548 self.igmp_verify, self.traffic_verify),
1549 port_list = self.generate_port_list(num_subscribers, num_channels),
1550 negative_subscriber_auth = 'all')
1551 assert_equal(test_status, True)
1552
1553 @deferred(SUBSCRIBER_TIMEOUT)
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1554 def test_2_cord_subscribers_authentication_with_valid_and_invalid_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1555 ### """Test 2 subscribers to auth, one of the subscriber with invalidCertification and join channel"""
1556 num_subscribers = 2
1557 num_channels = 1
1558 df = defer.Deferred()
1559 def sub_auth_invalid_cert(df):
1560 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1561 num_channels = num_channels,
1562 cbs = (self.tls_invalid_cert, self.dhcp_verify,self.igmp_verify, self.traffic_verify),
1563 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'half')
1564 assert_equal(test_status, True)
1565 df.callback(0)
1566 reactor.callLater(0, sub_auth_invalid_cert, df)
1567 return df
1568
1569 @deferred(SUBSCRIBER_TIMEOUT)
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1570 def test_2_cord_subscribers_authentication_with_valid_and_no_certificate_scenario_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1571 ### """Test 2 subscribers to auth, one of the subscriber with No Certification and join channel"""
1572 num_subscribers = 2
1573 num_channels = 1
1574 df = defer.Deferred()
1575 def sub_auth_no_cert(df):
1576 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1577 num_channels = num_channels,
1578 cbs = (self.tls_no_cert, self.dhcp_verify,
1579 self.igmp_verify, self.traffic_verify),
1580 port_list = self.generate_port_list(num_subscribers, num_channels),
1581 negative_subscriber_auth = 'half')
1582 assert_equal(test_status, True)
1583 df.callback(0)
1584 reactor.callLater(0, sub_auth_no_cert, df)
1585 return df
1586
1587 @deferred(SUBSCRIBER_TIMEOUT)
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1588 def test_2_cord_subscribers_authentication_with_valid_and_non_ca_authorized_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1589 ### """Test 2 subscribers to auth, one of the subscriber with Non CA authorized Certificate and join channel"""
1590 num_subscribers = 2
1591 num_channels = 1
1592 df = defer.Deferred()
1593 def sub_auth_no_cert(df):
1594 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1595 num_channels = num_channels,
1596 cbs = (self.tls_non_ca_authrized_cert, self.dhcp_verify,
1597 self.igmp_verify, self.traffic_verify),
1598 port_list = self.generate_port_list(num_subscribers, num_channels),
1599 negative_subscriber_auth = 'half')
1600 assert_equal(test_status, True)
1601 df.callback(0)
1602 reactor.callLater(0, sub_auth_no_cert, df)
1603 return df
1604
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1605 def test_cord_subscriber_authentication_with_dhcp_discover_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1606 ### """Test subscriber auth success, DHCP re-discover with DHCP server and join channel"""
1607 num_subscribers = 1
1608 num_channels = 1
1609 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1610 num_channels = num_channels,
1611 cbs = (self.tls_verify, self.dhcp_discover_scenario,
1612 self.igmp_verify, self.traffic_verify),
1613 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1614 assert_equal(test_status, True)
1615
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1616 def test_cord_subscriber_authentication_with_dhcp_client_reboot_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1617 ### """Test subscriber auth success, DHCP client got re-booted and join channel"""
1618 num_subscribers = 1
1619 num_channels = 1
1620 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1621 num_channels = num_channels,
1622 cbs = (self.tls_verify, self.dhcp_client_reboot_scenario,
1623 self.igmp_verify, self.traffic_verify),
1624 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1625 assert_equal(test_status, True)
1626
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1627 def test_cord_subscriber_authentication_with_dhcp_server_reboot_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1628 ### """Test subscriber auth , DHCP server re-boot during DHCP process and join channel"""
1629 num_subscribers = 1
1630 num_channels = 1
1631 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1632 num_channels = num_channels,
1633 cbs = (self.tls_verify, self.dhcp_server_reboot_scenario,
1634 self.igmp_verify, self.traffic_verify),
1635 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1636 assert_equal(test_status, True)
1637
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1638 def test_cord_subscriber_authentication_with_dhcp_client_rebind_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1639 ### """Test subscriber auth , DHCP client rebind IP and join channel"""
1640 num_subscribers = 1
1641 num_channels = 1
1642 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1643 num_channels = num_channels,
1644 cbs = (self.tls_verify, self.dhcp_client_rebind_scenario,
1645 self.igmp_verify, self.traffic_verify),
1646 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1647 assert_equal(test_status, True)
1648
1649
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1650 def test_cord_subscriber_authentication_with_dhcp_starvation_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1651 ### """Test subscriber auth , DHCP starvation and join channel"""
1652 num_subscribers = 1
1653 num_channels = 1
1654 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1655 num_channels = num_channels,
1656 cbs = (self.tls_verify, self.dhcp_starvation_scenario,
1657 self.igmp_verify, self.traffic_verify),
1658 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1659 assert_equal(test_status, True)
1660
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1661 def test_cord_subscriber_authentication_with_multiple_dhcp_discover_for_same_subscriber_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1662 ### """Test subscriber auth , sending same DHCP client discover multiple times and join channel"""
1663 num_subscribers = 1
1664 num_channels = 1
1665 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1666 num_channels = num_channels,
1667 cbs = (self.tls_verify, self.dhcp_same_client_multi_discovers_scenario,
1668 self.igmp_verify, self.traffic_verify),
1669 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1670 assert_equal(test_status, True)
1671
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1672 def test_cord_subscriber_authentication_with_multiple_dhcp_request_for_same_subscriber_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1673 ### """Test subscriber auth , same DHCP client multiple requerts times and join channel"""
1674 num_subscribers = 1
1675 num_channels = 1
1676 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1677 num_channels = num_channels,
1678 cbs = (self.tls_verify, self.dhcp_same_client_multi_request_scenario,
1679 self.igmp_verify, self.traffic_verify),
1680 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1681 assert_equal(test_status, True)
1682
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1683 def test_cord_subscriber_authentication_with_dhcp_client_requested_ip_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1684 ### """Test subscriber auth with DHCP client requesting ip and join channel"""
1685 num_subscribers = 1
1686 num_channels = 1
1687 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1688 num_channels = num_channels,
1689 cbs = (self.tls_verify, self.dhcp_client_desired_ip_scenario,
1690 self.igmp_verify, self.traffic_verify),
1691 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1692 assert_equal(test_status, True)
1693
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1694 def test_cord_subscriber_authentication_with_dhcp_non_offered_ip_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1695 ### """Test subscriber auth with DHCP client request for non-offered ip and join channel"""
1696 num_subscribers = 1
1697 num_channels = 1
1698 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1699 num_channels = num_channels,
1700 cbs = (self.tls_verify, self.dhcp_client_request_pkt_with_non_offered_ip_scenario,
1701 self.igmp_verify, self.traffic_verify),
1702 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1703 assert_equal(test_status, True)
1704
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1705 def test_cord_subscriber_authentication_with_dhcp_request_out_of_pool_ip_by_client_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1706 ### """Test subscriber auth with DHCP client requesting out of pool ip and join channel"""
1707 num_subscribers = 1
1708 num_channels = 1
1709 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1710 num_channels = num_channels,
1711 cbs = (self.tls_verify, self.dhcp_client_requested_out_pool_ip_scenario,
1712 self.igmp_verify, self.traffic_verify),
1713 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1714 assert_equal(test_status, True)
1715
1716
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1717 def test_cord_subscriber_authentication_with_dhcp_specified_lease_time_functionality_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1718 ### """Test subscriber auth with DHCP client specifying lease time and join channel"""
1719 num_subscribers = 1
1720 num_channels = 1
1721 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1722 num_channels = num_channels,
1723 cbs = (self.tls_verify, self.dhcp_client_specific_lease_scenario,
1724 self.igmp_verify, self.traffic_verify),
1725 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1726 assert_equal(test_status, True)
1727
1728 #@deferred(SUBSCRIBER_TIMEOUT)
1729 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1730 def test_1k_subscribers_authentication_with_valid_and_invalid_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1731 ### """Test 1k subscribers to auth, half of the subscribers with invalidCertification and join channel"""
1732 num_subscribers = 1000
1733 num_channels = 1
1734 df = defer.Deferred()
1735 def sub_auth_invalid_cert(df):
1736 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1737 num_channels = num_channels,
1738 cbs = (self.tls_invalid_cert, self.dhcp_verify,
1739 self.igmp_verify, self.traffic_verify),
1740 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'half')
1741 assert_equal(test_status, True)
1742 df.callback(0)
1743 reactor.callLater(0, sub_auth_invalid_cert, df)
1744 return df
1745
1746 @nottest
1747 @deferred(SUBSCRIBER_TIMEOUT)
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1748 def test_1k_subscribers_authentication_with_valid_and_no_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1749 ### """Test 1k subscribers to auth, half of the subscribers with No Certification and join channel"""
1750 num_subscribers = 1000
1751 num_channels = 1
1752 df = defer.Deferred()
1753 def sub_auth_no_cert(df):
1754 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1755 num_channels = num_channels,
1756 cbs = (self.tls_no_cert, self.dhcp_verify, self.igmp_verify),
1757 port_list = self.generate_port_list(num_subscribers, num_channels),
1758 negative_subscriber_auth = 'half')
1759 assert_equal(test_status, True)
1760 df.callback(0)
1761 reactor.callLater(0, sub_auth_no_cert, df)
1762 return df
1763
1764 #@deferred(SUBSCRIBER_TIMEOUT)
1765 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1766 def test_1k_subscribers_authentication_with_valid_and_non_ca_authorized_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1767 ### """Test 1k subscribers to auth, half of the subscribers with Non CA authorized Certificate and join channel"""
1768 num_subscribers = 1000
1769 num_channels = 1
1770 df = defer.Deferred()
1771 def sub_auth_no_cert(df):
1772 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1773 num_channels = num_channels,
1774 cbs = (self.tls_non_ca_authrized_cert, self.dhcp_verify, self.igmp_verify),
1775 port_list = self.generate_port_list(num_subscribers, num_channels),
1776 negative_subscriber_auth = 'half')
1777 assert_equal(test_status, True)
1778 df.callback(0)
1779 reactor.callLater(0, sub_auth_no_cert, df)
1780 return df
1781
1782 #@deferred(SUBSCRIBER_TIMEOUT)
1783 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1784 def test_5k_subscribers_authentication_with_valid_and_invalid_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1785 ### """Test 5k subscribers to auth, half of the subscribers with invalidCertification and join channel"""
1786 num_subscribers = 5000
1787 num_channels = 1
1788 df = defer.Deferred()
1789 def sub_auth_invalid_cert(df):
1790 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1791 num_channels = num_channels,
1792 cbs = (self.tls_invalid_cert, self.dhcp_verify, self.igmp_verify),
1793 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'half')
1794 assert_equal(test_status, True)
1795 df.callback(0)
1796 reactor.callLater(0, sub_auth_invalid_cert, df)
1797 return df
1798
1799 #@deferred(SUBSCRIBER_TIMEOUT)
1800 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1801 def test_5k_subscribers_authentication_with_valid_and_no_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1802 ### """Test 5k subscribers to auth, half of the subscribers with No Certification and join channel"""
1803 num_subscribers = 5000
1804 num_channels = 1
1805 df = defer.Deferred()
1806 def sub_auth_no_cert(df):
1807 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1808 num_channels = num_channels,
1809 cbs = (self.tls_no_cert, self.dhcp_verify, self.igmp_verify),
1810 port_list = self.generate_port_list(num_subscribers, num_channels),
1811 negative_subscriber_auth = 'half')
1812 assert_equal(test_status, True)
1813 df.callback(0)
1814 reactor.callLater(0, sub_auth_no_cert, df)
1815 return df
1816
1817 #@deferred(SUBSCRIBER_TIMEOUT)
1818 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1819 def test_5k_subscribers_authentication_with_valid_and_non_ca_authorized_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1820 ### """Test 5k subscribers to auth, half of the subscribers with Non CA authorized Certificate and join channel"""
1821 num_subscribers = 5000
1822 num_channels = 1
1823 df = defer.Deferred()
1824 def sub_auth_no_cert(df):
1825 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1826 num_channels = num_channels,
1827 cbs = (self.tls_non_ca_authrized_cert, self.dhcp_verify, self.igmp_verify),
1828 port_list = self.generate_port_list(num_subscribers, num_channels),
1829 negative_subscriber_auth = 'half')
1830 assert_equal(test_status, True)
1831 df.callback(0)
1832 reactor.callLater(0, sub_auth_no_cert, df)
1833 return df
1834
1835 #@deferred(SUBSCRIBER_TIMEOUT)
1836 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1837 def test_10k_subscribers_authentication_with_valid_and_invalid_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1838 ### """Test 10k subscribers to auth, half of the subscribers with invalidCertification and join channel"""
1839 num_subscribers = 10000
1840 num_channels = 1
1841 df = defer.Deferred()
1842 def sub_auth_invalid_cert(df):
1843 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1844 num_channels = num_channels,
1845 cbs = (self.tls_invalid_cert, self.dhcp_verify, self.igmp_verify),
1846 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'onethird')
1847 assert_equal(test_status, True)
1848 df.callback(0)
1849 reactor.callLater(0, sub_auth_invalid_cert, df)
1850 return df
1851
1852 #@deferred(SUBSCRIBER_TIMEOUT)
1853 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1854 def test_10k_subscribers_authentication_with_valid_and_no_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1855 ### """Test 10k subscribers to auth, half of the subscribers with No Certification and join channel"""
1856 num_subscribers = 10000
1857 num_channels = 1
1858 df = defer.Deferred()
1859 def sub_auth_no_cert(df):
1860 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1861 num_channels = num_channels,
1862 cbs = (self.tls_no_cert, self.dhcp_verify, self.igmp_verify),
1863 port_list = self.generate_port_list(num_subscribers, num_channels),
1864 negative_subscriber_auth = 'onethird')
1865 assert_equal(test_status, True)
1866 df.callback(0)
1867 reactor.callLater(0, sub_auth_no_cert, df)
1868 return df
1869
1870 #@deferred(SUBSCRIBER_TIMEOUT)
1871 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1872 def test_10k_subscribers_authentication_with_valid_and_non_ca_authorized_certificates_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1873 ### """Test 10k subscribers to auth, half of the subscribers with Non CA authorized Certificate and join channel"""
1874 num_subscribers = 10000
1875 num_channels = 1
1876 df = defer.Deferred()
1877 def sub_auth_no_cert(df):
1878 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1879 num_channels = num_channels,
1880 cbs = (self.tls_non_ca_authrized_cert, self.dhcp_verify, self.igmp_verify),
1881 port_list = self.generate_port_list(num_subscribers, num_channels),
1882 negative_subscriber_auth = 'onethird')
1883 assert_equal(test_status, False)
1884 assert_equal(test_status, True)
1885 df.callback(0)
1886 reactor.callLater(0, sub_auth_no_cert, df)
1887 return df
1888
1889 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1890 def test_1k_cord_subscribers_authentication_with_dhcp_discovers_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1891 ### """Test 1k subscribers auth success, DHCP re-discover with DHCP server and join channel"""
1892 num_subscribers = 1000
1893 num_channels = 1
1894 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1895 num_channels = num_channels,
1896 cbs = (self.tls_verify, self.dhcp_discover_scenario, self.igmp_verify),
1897 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1898 assert_equal(test_status, True)
1899
1900 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1901 def test_1k_cord_subscribers_authentication_with_dhcp_client_reboot_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1902 ### """Test 1k subscribers auth success, DHCP client got re-booted and join channel"""
1903 num_subscribers = 1000
1904 num_channels = 1
1905 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1906 num_channels = num_channels,
1907 cbs = (self.tls_verify, self.dhcp_client_reboot_scenario, self.igmp_verify),
1908 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1909 assert_equal(test_status, True)
1910
1911 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1912 def test_1k_cord_subscribers_authentication_with_dhcp_server_reboot_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1913 ### """Test 1k subscribers auth , DHCP server re-boot during DHCP process and join channel"""
1914 num_subscribers = 1000
1915 num_channels = 1
1916 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1917 num_channels = num_channels,
1918 cbs = (self.tls_verify, self.dhcp_server_reboot_scenario, self.igmp_verify),
1919 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1920 assert_equal(test_status, True)
1921
1922 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1923 def test_1k_cord_subscribers_authentication_with_dhcp_client_rebind_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1924 ### """Test 1k subscribers auth , DHCP client rebind IP and join channel"""
1925 num_subscribers = 1000
1926 num_channels = 1
1927 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1928 num_channels = num_channels,
1929 cbs = (self.tls_verify, self.dhcp_client_rebind_scenario, self.igmp_verify),
1930 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1931 assert_equal(test_status, True)
1932
1933 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1934 def test_1k_cord_subscribers_authentication_with_dhcp_starvation_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1935 ### """Test 1k subscribers auth , DHCP starvation and join channel"""
1936 num_subscribers = 1000
1937 num_channels = 1
1938 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1939 num_channels = num_channels,
1940 cbs = (self.tls_verify, self.dhcp_starvation_scenario, self.igmp_verify),
1941 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1942 assert_equal(test_status, True)
1943
1944 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1945 def test_1k_cord_subscribers_authentication_with_dhcp_client_requested_ip_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1946 ### """Test 1k subscribers auth with DHCP client requesting ip and join channel"""
1947 num_subscribers = 1000
1948 num_channels = 1
1949 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1950 num_channels = num_channels,
1951 cbs = (self.tls_verify, self.dhcp_client_desired_ip_scenario, self.igmp_verify),
1952 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1953 assert_equal(test_status, True)
1954
1955 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]1956 def test_1k_cord_subscribers_authentication_with_dhcp_non_offered_ip_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]1957 ### """Test subscribers auth with DHCP client request for non-offered ip and join channel"""
1958 num_subscribers = 1000
1959 num_channels = 1
1960 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1961 num_channels = num_channels,
1962 cbs = (self.tls_verify, self.dhcp_client_request_pkt_with_non_offered_ip_scenario, self.igmp_verify),
1963 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
1964 assert_equal(test_status, True)
1965
1966 def test_4_cord_subscribers_join_recv_5channel(self):
1967 ###"""Test 4 subscribers join and receive for 5 channels surfing"""
1968 num_subscribers = 4
1969 num_channels = 5
1970 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1971 num_channels = num_channels,
1972 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
1973 port_list = self.generate_port_list(num_subscribers, num_channels),
1974 negative_subscriber_auth = 'all')
1975 assert_equal(test_status, True)
1976
1977 def test_4_cord_subscribers_join_jump_5channel(self):
1978 ###"""Test 4 subscribers jump and receive for 5 channels surfing"""
1979 num_subscribers = 4
1980 num_channels = 5
1981 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1982 num_channels = num_channels,
1983 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
1984 port_list = self.generate_port_list(num_subscribers, num_channels),
1985 negative_subscriber_auth = 'all')
1986 assert_equal(test_status, True)
1987
1988 def test_4_cord_subscribers_join_next_5channel(self):
1989 ###"""Test 4 subscribers join next for 5 channels"""
1990 num_subscribers = 4
1991 num_channels = 5
1992 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
1993 num_channels = num_channels,
1994 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
1995 port_list = self.generate_port_list(num_subscribers, num_channels),
1996 negative_subscriber_auth = 'all')
1997 assert_equal(test_status, True)
1998
1999 def test_10_cord_subscribers_join_recv_5channel(self):
2000 ###"""Test 10 subscribers join and receive for 5 channels surfing"""
2001 num_subscribers = 10
2002 num_channels = 5
2003 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2004 num_channels = num_channels,
2005 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2006 port_list = self.generate_port_list(num_subscribers, num_channels),
2007 negative_subscriber_auth = 'all')
2008 assert_equal(test_status, True)
2009
2010 def test_10_cord_subscribers_join_jump_5channel(self):
2011 ###"""Test 10 subscribers jump and receive for 5 channels surfing"""
2012 num_subscribers = 10
2013 num_channels = 5
2014 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2015 num_channels = num_channels,
2016 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2017 port_list = self.generate_port_list(num_subscribers, num_channels),
2018 negative_subscriber_auth = 'all')
2019 assert_equal(test_status, True)
2020
2021
2022 def test_10_cord_subscribers_join_next_5channel(self):
2023 ###"""Test 10 subscribers join next for 5 channels"""
2024 num_subscribers = 10
2025 num_channels = 5
2026 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2027 num_channels = num_channels,
2028 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2029 port_list = self.generate_port_list(num_subscribers, num_channels),
2030 negative_subscriber_auth = 'all')
2031 assert_equal(test_status, True)
2032
2033
2034
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]2035 def test_cord_subscriber_join_and_recv_stream_surfing_100_channels(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]2036 num_subscribers = 1
2037 num_channels = 100
2038 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2039 num_channels = num_channels,
2040 cbs = (self.tls_verify, self.dhcp_verify,
2041 self.igmp_verify, self.traffic_verify),
2042 port_list = self.generate_port_list(num_subscribers, num_channels),
2043 negative_subscriber_auth = 'all')
2044 assert_equal(test_status, True)
2045
2046 def test_cord_subscriber_join_recv_400channels(self):
2047 num_subscribers = 1
2048 num_channels = 400
2049 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2050 num_channels = num_channels,
2051 cbs = (self.tls_verify, self.dhcp_verify,
2052 self.igmp_verify, self.traffic_verify),
2053 port_list = self.generate_port_list(num_subscribers, num_channels),
2054 negative_subscriber_auth = 'all')
2055 assert_equal(test_status, True)
2056
2057 def test_cord_subscriber_join_recv_800channels(self):
2058 num_subscribers = 1
2059 num_channels = 800
2060 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2061 num_channels = num_channels,
2062 cbs = (self.tls_verify, self.dhcp_verify,
2063 self.igmp_verify, self.traffic_verify),
2064 port_list = self.generate_port_list(num_subscribers, num_channels),
2065 negative_subscriber_auth = 'all')
2066 assert_equal(test_status, True)
2067
2068 def test_cord_subscriber_join_recv_1200channels(self):
2069 num_subscribers = 1
2070 num_channels = 1200
2071 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2072 num_channels = num_channels,
2073 cbs = (self.tls_verify, self.dhcp_verify,
2074 self.igmp_verify, self.traffic_verify),
2075 port_list = self.generate_port_list(num_subscribers, num_channels),
2076 negative_subscriber_auth = 'all')
2077 assert_equal(test_status, True)
2078
2079 def test_cord_subscriber_join_recv_1500channels(self):
2080 num_subscribers = 1
2081 num_channels = 1500
2082 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2083 num_channels = num_channels,
2084 cbs = (self.tls_verify, self.dhcp_verify,
2085 self.igmp_verify, self.traffic_verify),
2086 port_list = self.generate_port_list(num_subscribers, num_channels),
2087 negative_subscriber_auth = 'all')
2088 assert_equal(test_status, True)
2089
2090 def test_cord_subscriber_join_jump_100channels(self):
2091 num_subscribers = 1
2092 num_channels = 100
2093 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2094 num_channels = num_channels,
2095 cbs = (self.tls_verify, self.dhcp_jump_verify,
2096 self.igmp_jump_verify, self.traffic_verify),
2097 port_list = self.generate_port_list(num_subscribers, num_channels),
2098 negative_subscriber_auth = 'all')
2099 assert_equal(test_status, True)
2100 def test_cord_subscriber_join_jump_400channels(self):
2101 num_subscribers = 1
2102 num_channels = 400
2103 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2104 num_channels = num_channels,
2105 cbs = (self.tls_verify, self.dhcp_jump_verify,
2106 self.igmp_jump_verify, self.traffic_verify),
2107 port_list = self.generate_port_list(num_subscribers, num_channels),
2108 negative_subscriber_auth = 'all')
2109 assert_equal(test_status, True)
2110
2111 def test_cord_subscriber_join_jump_800channels(self):
2112 num_subscribers = 1
2113 num_channels = 800
2114 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2115 num_channels = num_channels,
2116 cbs = (self.tls_verify, self.dhcp_jump_verify,
2117 self.igmp_jump_verify, self.traffic_verify),
2118 port_list = self.generate_port_list(num_subscribers, num_channels),
2119 negative_subscriber_auth = 'all')
2120 assert_equal(test_status, True)
2121 def test_cord_subscriber_join_jump_1200channel(sself):
2122 num_subscribers = 1
2123 num_channels = 1200
2124 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2125 num_channels = num_channels,
2126 cbs = (self.tls_verify, self.dhcp_jump_verify,
2127 self.igmp_jump_verify, self.traffic_verify),
2128 port_list = self.generate_port_list(num_subscribers, num_channels),
2129 negative_subscriber_auth = 'all')
2130 assert_equal(test_status, True)
2131 def test_cord_subscriber_join_jump_1500channels(self):
2132 num_subscribers = 1
2133 num_channels = 1500
2134 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2135 num_channels = num_channels,
2136 cbs = (self.tls_verify, self.dhcp_jump_verify,
2137 self.igmp_jump_verify, self.traffic_verify),
2138 port_list = self.generate_port_list(num_subscribers, num_channels),
2139 negative_subscriber_auth = 'all')
2140 assert_equal(test_status, True)
2141
2142 def test_cord_subscriber_join_next_100channels(self):
2143 num_subscribers = 1
2144 num_channels = 100
2145 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2146 num_channels = num_channels,
2147 cbs = (self.tls_verify, self.dhcp_next_verify,
2148 self.igmp_next_verify, self.traffic_verify),
2149 port_list = self.generate_port_list(num_subscribers, num_channels),
2150 negative_subscriber_auth = 'all')
2151 assert_equal(test_status, True)
2152
2153 def test_cord_subscriber_join_next_400channels(self):
2154 num_subscribers = 1
2155 num_channels = 400
2156 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2157 num_channels = num_channels,
2158 cbs = (self.tls_verify, self.dhcp_next_verify,
2159 self.igmp_next_verify, self.traffic_verify),
2160 port_list = self.generate_port_list(num_subscribers, num_channels),
2161 negative_subscriber_auth = 'all')
2162 assert_equal(test_status, True)
2163
2164 def test_cord_subscriber_join_next_800channels(self):
2165 num_subscribers = 1
2166 num_channels = 800
2167 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2168 num_channels = num_channels,
2169 cbs = (self.tls_verify, self.dhcp_next_verify,
2170 self.igmp_next_verify, self.traffic_verify),
2171 port_list = self.generate_port_list(num_subscribers, num_channels),
2172 negative_subscriber_auth = 'all')
2173 assert_equal(test_status, True)
2174
2175
2176 def test_cord_subscriber_join_next_1200channels(self):
2177 num_subscribers = 1
2178 num_channels = 1200
2179 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2180 num_channels = num_channels,
2181 cbs = (self.tls_verify, self.dhcp_next_verify,
2182 self.igmp_next_verify, self.traffic_verify),
2183 port_list = self.generate_port_list(num_subscribers, num_channels),
2184 negative_subscriber_auth = 'all')
2185 assert_equal(test_status, True)
2186
2187 def test_cord_subscriber_join_next_1500channels(self):
2188 num_subscribers = 1
2189 num_channels = 1500
2190 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2191 num_channels = num_channels,
2192 cbs = (self.tls_verify, self.dhcp_next_verify,
2193 self.igmp_next_verify, self.traffic_verify),
2194 port_list = self.generate_port_list(num_subscribers, num_channels),
2195 negative_subscriber_auth = 'all')
2196 assert_equal(test_status, True)
2197
2198 @nottest
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]2199 def test_1k_cord_subscribers_authentication_with_dhcp_request_out_of_pool_ip_by_client_validating_channel_surfing(self):
ChetanGaonkerbd9e3942016-08-05 10:02:20 -0700[diff] [blame]2200 ### """Test 1k subscribers auth with DHCP client requesting out of pool ip and join channel"""
2201 num_subscribers = 1000
2202 num_channels = 1
2203 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2204 num_channels = num_channels,
2205 cbs = (self.tls_verify, self.dhcp_client_requested_out_pool_ip_scenario, self.igmp_verify),
2206 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
2207 assert_equal(test_status, True)
2208
2209 @nottest
2210 def test_1k_cord_subscribers_join_recv_100channel(self):
2211 ###"""Test 1k subscribers join and receive for 100 channels surfing"""
2212 num_subscribers = 1000
2213 num_channels = 100
2214 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2215 num_channels = num_channels,
2216 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2217 port_list = self.generate_port_list(num_subscribers, num_channels),
2218 negative_subscriber_auth = 'all')
2219 assert_equal(test_status, True)
2220
2221 @nottest
2222 def test_1k_cord_subscribers_join_jump_100channel(self):
2223 ###"""Test 1k subscribers jump and receive for 100 channels surfing"""
2224 num_subscribers = 1000
2225 num_channels = 100
2226 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2227 num_channels = num_channels,
2228 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2229 port_list = self.generate_port_list(num_subscribers, num_channels),
2230 negative_subscriber_auth = 'all')
2231 assert_equal(test_status, True)
2232
2233 @nottest
2234 def test_1k_cord_subscribers_join_next_100channel(self):
2235 ###"""Test 1k subscribers join next for 100 channels"""
2236 num_subscribers = 1000
2237 num_channels = 100
2238 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2239 num_channels = num_channels,
2240 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2241 port_list = self.generate_port_list(num_subscribers, num_channels),
2242 negative_subscriber_auth = 'all')
2243 assert_equal(test_status, True)
2244
2245 @nottest
2246 def test_1k_cord_subscribers_join_recv_400channel(self):
2247 ###"""Test 1k subscribers join and receive for 400 channels surfing"""
2248 num_subscribers = 1000
2249 num_channels = 400
2250 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2251 num_channels = num_channels,
2252 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2253 port_list = self.generate_port_list(num_subscribers, num_channels),
2254 negative_subscriber_auth = 'all')
2255 assert_equal(test_status, True)
2256
2257 @nottest
2258 def test_1k_cord_subscribers_join_jump_400channel(self):
2259 ###"""Test 1k subscribers jump and receive for 400 channels surfing"""
2260 num_subscribers = 1000
2261 num_channels = 400
2262 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2263 num_channels = num_channels,
2264 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2265 port_list = self.generate_port_list(num_subscribers, num_channels),
2266 negative_subscriber_auth = 'all')
2267 assert_equal(test_status, True)
2268
2269 @nottest
2270 def test_1k_cord_subscribers_join_next_400channel(self):
2271 ###"""Test 1k subscribers join next for 400 channels"""
2272 num_subscribers = 1000
2273 num_channels = 400
2274 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2275 num_channels = num_channels,
2276 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2277 port_list = self.generate_port_list(num_subscribers, num_channels),
2278 negative_subscriber_auth = 'all')
2279 assert_equal(test_status, True)
2280
2281 @nottest
2282 def test_1k_cord_subscribers_join_recv_800channel(self):
2283 ###"""Test 1k subscribers join and receive for 800 channels surfing"""
2284 num_subscribers = 1000
2285 num_channels = 800
2286 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2287 num_channels = num_channels,
2288 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2289 port_list = self.generate_port_list(num_subscribers, num_channels),
2290 negative_subscriber_auth = 'all')
2291 assert_equal(test_status, True)
2292
2293 @nottest
2294 def test_1k_cord_subscribers_join_jump_800channel(self):
2295 ###"""Test 1k subscribers jump and receive for 800 channels surfing"""
2296 num_subscribers = 1000
2297 num_channels = 800
2298 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2299 num_channels = num_channels,
2300 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2301 port_list = self.generate_port_list(num_subscribers, num_channels),
2302 negative_subscriber_auth = 'all')
2303 assert_equal(test_status, True)
2304
2305 @nottest
2306 def test_1k_cord_subscribers_join_next_800channel(self):
2307 ###"""Test 1k subscribers join next for 800 channels"""
2308 num_subscribers = 1000
2309 num_channels = 800
2310 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2311 num_channels = num_channels,
2312 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2313 port_list = self.generate_port_list(num_subscribers, num_channels),
2314 negative_subscriber_auth = 'all')
2315 assert_equal(test_status, True)
2316
2317 @nottest
2318 def test_1k_cord_subscribers_join_recv_1200channel(self):
2319 ###"""Test 1k subscribers join and receive for 1200 channels surfing"""
2320 num_subscribers = 1000
2321 num_channels = 1200
2322 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2323 num_channels = num_channels,
2324 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2325 port_list = self.generate_port_list(num_subscribers, num_channels),
2326 negative_subscriber_auth = 'all')
2327 assert_equal(test_status, True)
2328
2329 @nottest
2330 def test_1k_cord_subscribers_join_jump_1200channel(self):
2331 ###"""Test 1k subscribers jump and receive for 1200 channels surfing"""
2332 num_subscribers = 1000
2333 num_channels = 1200
2334 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2335 num_channels = num_channels,
2336 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2337 port_list = self.generate_port_list(num_subscribers, num_channels),
2338 negative_subscriber_auth = 'all')
2339 assert_equal(test_status, True)
2340
2341 @nottest
2342 def test_1k_cord_subscribers_join_next_1200channel(self):
2343 ###"""Test 1k subscribers join next for 1200 channels"""
2344 num_subscribers = 1000
2345 num_channels = 1200
2346 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2347 num_channels = num_channels,
2348 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2349 port_list = self.generate_port_list(num_subscribers, num_channels),
2350 negative_subscriber_auth = 'all')
2351 assert_equal(test_status, True)
2352
2353 @nottest
2354 def test_1k_cord_subscribers_join_recv_1500channel(self):
2355 ###"""Test 1k subscribers join and receive for 1500 channels surfing"""
2356 num_subscribers = 1000
2357 num_channels = 1500
2358 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2359 num_channels = num_channels,
2360 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2361 port_list = self.generate_port_list(num_subscribers, num_channels),
2362 negative_subscriber_auth = 'all')
2363 assert_equal(test_status, True)
2364
2365 @nottest
2366 def test_1k_cord_subscribers_join_jump_1500channel(self):
2367 ###"""Test 1k subscribers jump and receive for 1500 channels surfing"""
2368 num_subscribers = 1000
2369 num_channels = 1500
2370 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2371 num_channels = num_channels,
2372 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2373 port_list = self.generate_port_list(num_subscribers, num_channels),
2374 negative_subscriber_auth = 'all')
2375 assert_equal(test_status, True)
2376
2377 @nottest
2378 def test_1k_cord_subscribers_join_next_1500channel(self):
2379 ###"""Test 1k subscribers join next for 1500 channels"""
2380 num_subscribers = 1000
2381 num_channels = 1500
2382 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2383 num_channels = num_channels,
2384 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2385 port_list = self.generate_port_list(num_subscribers, num_channels),
2386 negative_subscriber_auth = 'all')
2387 assert_equal(test_status, True)
2388
2389 @nottest
2390 def test_5k_cord_subscribers_join_recv_100channel(self):
2391 ###"""Test 5k subscribers join and receive for 100 channels surfing"""
2392 num_subscribers = 5000
2393 num_channels = 100
2394 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2395 num_channels = num_channels,
2396 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2397 port_list = self.generate_port_list(num_subscribers, num_channels),
2398 negative_subscriber_auth = 'all')
2399 assert_equal(test_status, True)
2400
2401 @nottest
2402 def test_5k_cord_subscribers_join_jump_100channel(self):
2403 ###"""Test 5k subscribers jump and receive for 100 channels surfing"""
2404 num_subscribers = 5000
2405 num_channels = 100
2406 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2407 num_channels = num_channels,
2408 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2409 port_list = self.generate_port_list(num_subscribers, num_channels),
2410 negative_subscriber_auth = 'all')
2411 assert_equal(test_status, True)
2412
2413 @nottest
2414 def test_5k_cord_subscribers_join_next_100channel(self):
2415 ###"""Test 5k subscribers join next for 100 channels"""
2416 num_subscribers = 5000
2417 num_channels = 100
2418 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2419 num_channels = num_channels,
2420 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2421 port_list = self.generate_port_list(num_subscribers, num_channels),
2422 negative_subscriber_auth = 'all')
2423 assert_equal(test_status, True)
2424
2425 @nottest
2426 def test_5k_cord_subscribers_join_recv_400channel(self):
2427 ###"""Test 5k subscribers join and receive for 400 channels surfing"""
2428 num_subscribers = 5000
2429 num_channels = 400
2430 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2431 num_channels = num_channels,
2432 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2433 port_list = self.generate_port_list(num_subscribers, num_channels),
2434 negative_subscriber_auth = 'all')
2435 assert_equal(test_status, True)
2436
2437 @nottest
2438 def test_5k_cord_subscribers_join_jump_400channel(self):
2439 ###"""Test 5k subscribers jump and receive for 400 channels surfing"""
2440 num_subscribers = 5000
2441 num_channels = 400
2442 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2443 num_channels = num_channels,
2444 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2445 port_list = self.generate_port_list(num_subscribers, num_channels),
2446 negative_subscriber_auth = 'all')
2447 assert_equal(test_status, True)
2448
2449 @nottest
2450 def test_5k_cord_subscribers_join_next_400channel(self):
2451 ###"""Test 5k subscribers join next for 400 channels"""
2452 num_subscribers = 5000
2453 num_channels = 400
2454 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2455 num_channels = num_channels,
2456 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2457 port_list = self.generate_port_list(num_subscribers, num_channels),
2458 negative_subscriber_auth = 'all')
2459 assert_equal(test_status, True)
2460
2461 @nottest
2462 def test_5k_cord_subscribers_join_recv_800channel(self):
2463 ###"""Test 5k subscribers join and receive for 800 channels surfing"""
2464 num_subscribers = 5000
2465 num_channels = 800
2466 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2467 num_channels = num_channels,
2468 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2469 port_list = self.generate_port_list(num_subscribers, num_channels),
2470 negative_subscriber_auth = 'all')
2471 assert_equal(test_status, True)
2472
2473 @nottest
2474 def test_5k_cord_subscribers_join_jump_800channel(self):
2475 ###"""Test 5k subscribers jump and receive for 800 channels surfing"""
2476 num_subscribers = 5000
2477 num_channels = 800
2478 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2479 num_channels = num_channels,
2480 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2481 port_list = self.generate_port_list(num_subscribers, num_channels),
2482 negative_subscriber_auth = 'all')
2483 assert_equal(test_status, True)
2484
2485 @nottest
2486 def test_5k_cord_subscribers_join_next_800channel(self):
2487 ###"""Test 5k subscribers join next for 800 channels"""
2488 num_subscribers = 5000
2489 num_channels = 800
2490 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2491 num_channels = num_channels,
2492 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2493 port_list = self.generate_port_list(num_subscribers, num_channels),
2494 negative_subscriber_auth = 'all')
2495 assert_equal(test_status, True)
2496
2497 @nottest
2498 def test_5k_cord_subscribers_join_recv_1200channel(self):
2499 ###"""Test 5k subscribers join and receive for 1200 channels surfing"""
2500 num_subscribers = 5000
2501 num_channels = 1200
2502 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2503 num_channels = num_channels,
2504 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2505 port_list = self.generate_port_list(num_subscribers, num_channels),
2506 negative_subscriber_auth = 'all')
2507 assert_equal(test_status, True)
2508
2509 @nottest
2510 def test_5k_cord_subscribers_join_jump_1200channel(self):
2511 ###"""Test 5k subscribers jump and receive for 1200 channels surfing"""
2512 num_subscribers = 5000
2513 num_channels = 1200
2514 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2515 num_channels = num_channels,
2516 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2517 port_list = self.generate_port_list(num_subscribers, num_channels),
2518 negative_subscriber_auth = 'all')
2519 assert_equal(test_status, True)
2520
2521 @nottest
2522 def test_5k_cord_subscribers_join_next_1200channel(self):
2523 ###"""Test 5k subscribers join next for 1200 channels"""
2524 num_subscribers = 5000
2525 num_channels = 1200
2526 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2527 num_channels = num_channels,
2528 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2529 port_list = self.generate_port_list(num_subscribers, num_channels),
2530 negative_subscriber_auth = 'all')
2531 assert_equal(test_status, True)
2532
2533 @nottest
2534 def test_5k_cord_subscribers_join_recv_1500channel(self):
2535 ###"""Test 5k subscribers join and receive for 1500 channels surfing"""
2536 num_subscribers = 5000
2537 num_channels = 1500
2538 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2539 num_channels = num_channels,
2540 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2541 port_list = self.generate_port_list(num_subscribers, num_channels),
2542 negative_subscriber_auth = 'all')
2543 assert_equal(test_status, True)
2544
2545 @nottest
2546 def test_5k_cord_subscribers_join_jump_1500channel(self):
2547 ###"""Test 5k subscribers jump and receive for 1500 channels surfing"""
2548 num_subscribers = 5000
2549 num_channels = 1500
2550 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2551 num_channels = num_channels,
2552 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2553 port_list = self.generate_port_list(num_subscribers, num_channels),
2554 negative_subscriber_auth = 'all')
2555 assert_equal(test_status, True)
2556
2557 @nottest
2558 def test_5k_cord_subscribers_join_next_1500channel(self):
2559 ###"""Test 5k subscribers join next for 1500 channels"""
2560 num_subscribers = 5000
2561 num_channels = 1500
2562 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2563 num_channels = num_channels,
2564 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2565 port_list = self.generate_port_list(num_subscribers, num_channels),
2566 negative_subscriber_auth = 'all')
2567 assert_equal(test_status, True)
2568
2569 @nottest
2570 def test_10k_cord_subscribers_join_recv_100channel(self):
2571 ###"""Test 10k subscribers join and receive for 100 channels surfing"""
2572 num_subscribers = 10000
2573 num_channels = 100
2574 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2575 num_channels = num_channels,
2576 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2577 port_list = self.generate_port_list(num_subscribers, num_channels),
2578 negative_subscriber_auth = 'all')
2579 assert_equal(test_status, True)
2580
2581 @nottest
2582 def test_10k_cord_subscribers_join_jump_100channel(self):
2583 ###"""Test 10k subscribers jump and receive for 100 channels surfing"""
2584 num_subscribers = 10000
2585 num_channels = 100
2586 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2587 num_channels = num_channels,
2588 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2589 port_list = self.generate_port_list(num_subscribers, num_channels),
2590 negative_subscriber_auth = 'all')
2591 assert_equal(test_status, True)
2592
2593 @nottest
2594 def test_10k_cord_subscribers_join_next_100channel(self):
2595 ###"""Test 10k subscribers join next for 100 channels"""
2596 num_subscribers = 10000
2597 num_channels = 100
2598 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2599 num_channels = num_channels,
2600 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2601 port_list = self.generate_port_list(num_subscribers, num_channels),
2602 negative_subscriber_auth = 'all')
2603 assert_equal(test_status, True)
2604
2605 @nottest
2606 def test_100k_cord_subscribers_join_recv_100channel(self):
2607 ###"""Test 100k subscribers join and receive for 100 channels surfing"""
2608 num_subscribers = 100000
2609 num_channels = 100
2610 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2611 num_channels = num_channels,
2612 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2613 port_list = self.generate_port_list(num_subscribers, num_channels),
2614 negative_subscriber_auth = 'all')
2615 assert_equal(test_status, True)
2616
2617 @nottest
2618 def test_100k_cord_subscribers_join_jump_100channel(self):
2619 ###"""Test 100k subscribers jump and receive for 100 channels surfing"""
2620 num_subscribers = 100000
2621 num_channels = 100
2622 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2623 num_channels = num_channels,
2624 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2625 port_list = self.generate_port_list(num_subscribers, num_channels),
2626 negative_subscriber_auth = 'all')
2627 assert_equal(test_status, True)
2628
2629 @nottest
2630 def test_100k_cord_subscribers_join_next_100channel(self):
2631 ###"""Test 100k subscribers join next for 100 channels"""
2632 num_subscribers = 100000
2633 num_channels = 100
2634 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2635 num_channels = num_channels,
2636 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2637 port_list = self.generate_port_list(num_subscribers, num_channels),
2638 negative_subscriber_auth = 'all')
2639 assert_equal(test_status, True)
2640
2641 @nottest
2642 def test_10k_cord_subscribers_join_recv_400channel(self):
2643 ###"""Test 10k subscribers join and receive for 400 channels surfing"""
2644 num_subscribers = 10000
2645 num_channels = 400
2646 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2647 num_channels = num_channels,
2648 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2649 port_list = self.generate_port_list(num_subscribers, num_channels),
2650 negative_subscriber_auth = 'all')
2651 assert_equal(test_status, True)
2652
2653 @nottest
2654 def test_10k_cord_subscribers_join_jump_400channel(self):
2655 ###"""Test 10k subscribers jump and receive for 400 channels surfing"""
2656 num_subscribers = 10000
2657 num_channels = 400
2658 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2659 num_channels = num_channels,
2660 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2661 port_list = self.generate_port_list(num_subscribers, num_channels),
2662 negative_subscriber_auth = 'all')
2663 assert_equal(test_status, True)
2664
2665 @nottest
2666 def test_10k_cord_subscribers_join_next_400channel(self):
2667 ###"""Test 10k subscribers join next for 400 channels"""
2668 num_subscribers = 10000
2669 num_channels = 400
2670 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2671 num_channels = num_channels,
2672 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2673 port_list = self.generate_port_list(num_subscribers, num_channels),
2674 negative_subscriber_auth = 'all')
2675 assert_equal(test_status, True)
2676
2677 @nottest
2678 def test_10k_cord_subscribers_join_recv_800channel(self):
2679 ###"""Test 10k subscribers join and receive for 800 channels surfing"""
2680 num_subscribers = 10000
2681 num_channels = 800
2682 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2683 num_channels = num_channels,
2684 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2685 port_list = self.generate_port_list(num_subscribers, num_channels),
2686 negative_subscriber_auth = 'all')
2687 assert_equal(test_status, True)
2688
2689 @nottest
2690 def test_10k_cord_subscribers_join_jump_800channel(self):
2691 ###"""Test 10k subscribers jump and receive for 800 channels surfing"""
2692 num_subscribers = 10000
2693 num_channels = 800
2694 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2695 num_channels = num_channels,
2696 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2697 port_list = self.generate_port_list(num_subscribers, num_channels),
2698 negative_subscriber_auth = 'all')
2699 assert_equal(test_status, True)
2700
2701 @nottest
2702 def test_10k_cord_subscribers_join_next_800channel(self):
2703 ###"""Test 10k subscribers join next for 800 channels"""
2704 num_subscribers = 10000
2705 num_channels = 800
2706 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2707 num_channels = num_channels,
2708 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2709 port_list = self.generate_port_list(num_subscribers, num_channels),
2710 negative_subscriber_auth = 'all')
2711 assert_equal(test_status, True)
2712
2713 @nottest
2714 def test_10k_cord_subscribers_join_recv_1200channel(self):
2715 ###"""Test 10k subscribers join and receive for 1200 channels surfing"""
2716 num_subscribers = 10000
2717 num_channels = 1200
2718 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2719 num_channels = num_channels,
2720 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2721 port_list = self.generate_port_list(num_subscribers, num_channels),
2722 negative_subscriber_auth = 'all')
2723 assert_equal(test_status, True)
2724
2725 @nottest
2726 def test_10k_cord_subscribers_join_jump_1200channel(self):
2727 ###"""Test 10k subscribers jump and receive for 1200 channels surfing"""
2728 num_subscribers = 10000
2729 num_channels = 1200
2730 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2731 num_channels = num_channels,
2732 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2733 port_list = self.generate_port_list(num_subscribers, num_channels),
2734 negative_subscriber_auth = 'all')
2735 assert_equal(test_status, True)
2736
2737 @nottest
2738 def test_10k_cord_subscribers_join_next_1200channel(self):
2739 ###"""Test 10k subscribers join next for 1200 channels"""
2740 num_subscribers = 10000
2741 num_channels = 1200
2742 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2743 num_channels = num_channels,
2744 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2745 port_list = self.generate_port_list(num_subscribers, num_channels),
2746 negative_subscriber_auth = 'all')
2747 assert_equal(test_status, True)
2748
2749 @nottest
2750 def test_10k_cord_subscribers_join_recv_1500channel(self):
2751 ###"""Test 10k subscribers join and receive for 1500 channels surfing"""
2752 num_subscribers = 10000
2753 num_channels = 1500
2754 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2755 num_channels = num_channels,
2756 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2757 port_list = self.generate_port_list(num_subscribers, num_channels),
2758 negative_subscriber_auth = 'all')
2759 assert_equal(test_status, True)
2760
2761 @nottest
2762 def test_10k_cord_subscribers_join_jump_1500channel(self):
2763 ###"""Test 10k subscribers jump and receive for 1500 channels surfing"""
2764 num_subscribers = 10000
2765 num_channels = 1500
2766 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2767 num_channels = num_channels,
2768 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2769 port_list = self.generate_port_list(num_subscribers, num_channels),
2770 negative_subscriber_auth = 'all')
2771 assert_equal(test_status, True)
2772
2773 @nottest
2774 def test_10k_cord_subscribers_join_next_1500channel(self):
2775 ###"""Test 10k subscribers join next for 1500 channels"""
2776 num_subscribers = 10000
2777 num_channels = 1500
2778 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2779 num_channels = num_channels,
2780 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2781 port_list = self.generate_port_list(num_subscribers, num_channels),
2782 negative_subscriber_auth = 'all')
2783 assert_equal(test_status, True)
2784
2785 @nottest
2786 def test_100k_cord_subscribers_join_recv_1500channel(self):
2787 ###"""Test 100k subscribers join and receive for 1500 channels surfing"""
2788 num_subscribers = 100000
2789 num_channels = 1500
2790 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2791 num_channels = num_channels,
2792 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
2793 port_list = self.generate_port_list(num_subscribers, num_channels),
2794 negative_subscriber_auth = 'all')
2795 assert_equal(test_status, True)
2796
2797 @nottest
2798 def test_100k_cord_subscribers_join_jump_1500channel(self):
2799 ###"""Test 10k subscribers jump and receive for 1500 channels surfing"""
2800 num_subscribers = 100000
2801 num_channels = 1500
2802 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2803 num_channels = num_channels,
2804 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
2805 port_list = self.generate_port_list(num_subscribers, num_channels),
2806 negative_subscriber_auth = 'all')
2807 assert_equal(test_status, True)
2808
2809 @nottest
2810 def test_100k_cord_subscribers_join_next_1500channel(self):
2811 ###"""Test 10k subscribers join next for 1500 channels"""
2812 num_subscribers = 100000
2813 num_channels = 1500
2814 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2815 num_channels = num_channels,
2816 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
2817 port_list = self.generate_port_list(num_subscribers, num_channels),
2818 negative_subscriber_auth = 'all')
2819 assert_equal(test_status, True)
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]2820
2821
2822
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]2823 def remove_olt(self, switch_map):
2824 controller = get_controller()
2825 auth = ('karaf', 'karaf')
2826 #remove subscriber for every port on all the voltha devices
2827 for device, device_map in switch_map.iteritems():
2828 uni_ports = device_map['ports']
2829 uplink_vlan = device_map['uplink_vlan']
2830 for port in uni_ports:
2831 rest_url = 'http://{}:8181/onos/olt/oltapp/{}/{}'.format(controller,
2832 device,
2833 port)
2834 resp = requests.delete(rest_url, auth = auth)
2835 if resp.status_code not in [204, 202, 200]:
2836 log_test.error('Error deleting subscriber for device %s on port %s' %(device, port))
2837 else:
2838 log_test.info('Deleted subscriber for device %s on port %s' %(device, port))
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]2839
2840 def config_olt(self, switch_map):
2841 controller = get_controller()
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]2842 auth = ('karaf', 'karaf')
2843 #configure subscriber for every port on all the voltha devices
2844 for device, device_map in switch_map.iteritems():
2845 uni_ports = device_map['ports']
2846 uplink_vlan = device_map['uplink_vlan']
2847 for port in uni_ports:
2848 vlan = port
2849 rest_url = 'http://{}:8181/onos/olt/oltapp/{}/{}/{}'.format(controller,
2850 device,
2851 port,
2852 vlan)
A.R Karthick4bd5f532017-06-06 11:37:27 -0700[diff] [blame]2853 requests.post(rest_url, auth = auth)
2854 #assert_equal(resp.ok, True)
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]2855
A.R Karthick56e59432017-06-06 18:05:46 -0700[diff] [blame]2856 def cord_subscriber_voltha(self, services, cbs = None, num_subscribers = 1, num_channels = 1):
A.R Karthick4c4d0492017-05-26 19:23:05 -0700[diff] [blame]2857 """Test subscriber join next for channel surfing"""
2858 if self.VOLTHA_HOST is None:
2859 log_test.info('Skipping test as no voltha host')
2860 return
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]2861 switch_map = None
2862 olt_configured = False
2863 try:
A R Karthick9dc6e922017-07-12 14:40:16 -0700[diff] [blame]2864 switch_map = self.voltha_switch_map
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]2865 if not switch_map:
2866 log_test.info('No voltha devices found')
2867 return
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]2868 log_test.info('Adding subscribers through OLT app')
2869 self.config_olt(switch_map)
2870 olt_configured = True
2871 time.sleep(5)
A.R Karthick56e59432017-06-06 18:05:46 -0700[diff] [blame]2872 self.num_subscribers = num_subscribers
2873 self.num_channels = num_channels
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]2874 test_status = self.subscriber_join_verify(num_subscribers = self.num_subscribers,
2875 num_channels = self.num_channels,
A.R Karthick56e59432017-06-06 18:05:46 -0700[diff] [blame]2876 cbs = cbs,
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]2877 port_list = self.generate_port_list(self.num_subscribers,
2878 self.num_channels),
2879 services = services)
2880 assert_equal(test_status, True)
2881 finally:
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]2882 if switch_map is not None:
2883 if olt_configured is True:
A.R Karthick8a507cf2017-06-02 18:44:49 -0700[diff] [blame]2884 self.remove_olt(switch_map)
A.R Karthick56e59432017-06-06 18:05:46 -0700[diff] [blame]2885
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]2886 def test_subscriber_for_voltha_and_aaa_app_with_tls(self):
A R Karthick9dc6e922017-07-12 14:40:16 -0700[diff] [blame]2887 """Test subscriber TLS authentication with voltha"""
A.R Karthick56e59432017-06-06 18:05:46 -0700[diff] [blame]2888 if self.VOLTHA_HOST is None:
2889 log_test.info('Skipping test as no voltha host')
2890 return
2891 num_subscribers = 1
2892 num_channels = 1
2893 services = ('TLS',)
2894 cbs = ( self.tls_verify, )
2895 self.cord_subscriber_voltha(services, cbs = cbs,
2896 num_subscribers = num_subscribers,
2897 num_channels = num_channels)
2898
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]2899 def test_subscriber_for_voltha_and_aaa_app_with_tls_and_igmp(self):
A R Karthick9dc6e922017-07-12 14:40:16 -0700[diff] [blame]2900 """Test subscriber TLS and IGMP with voltha with 1 channel"""
A.R Karthick56e59432017-06-06 18:05:46 -0700[diff] [blame]2901 if self.VOLTHA_HOST is None:
2902 log_test.info('Skipping test as no voltha host')
2903 return
2904 num_subscribers = 1
2905 num_channels = 1
2906 services = ('TLS','IGMP',)
2907 cbs = ( self.tls_verify, self.voltha_igmp_next_verify,)
2908 self.cord_subscriber_voltha(services, cbs = cbs,
2909 num_subscribers = num_subscribers,
2910 num_channels = num_channels)
A.R Karthick4f583842017-06-09 17:15:47 -0700[diff] [blame]2911
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]2912 def test_subscriber_for_voltha_and_aaa_app_with_tls_and_igmp_with_three_subscribers_and_three_channels(self):
A R Karthick9dc6e922017-07-12 14:40:16 -0700[diff] [blame]2913 """Test subscriber TLS and IGMP with voltha for channel surfing with 3 subscribers browsing 3 channels each"""
A.R Karthick4f583842017-06-09 17:15:47 -0700[diff] [blame]2914 if self.VOLTHA_HOST is None:
2915 log_test.info('Skipping test as no voltha host')
2916 return
2917 num_subscribers = 3
2918 num_channels = 3
2919 services = ('TLS','IGMP',)
2920 cbs = ( self.tls_verify, self.voltha_igmp_next_verify,)
2921 self.cord_subscriber_voltha(services, cbs = cbs,
2922 num_subscribers = num_subscribers,
2923 num_channels = num_channels)
Anil Kumar Sankab0a95962017-10-06 18:55:58 +0000[diff] [blame]2924
2925 def test_subscribers_to_join_channels_and_recv_traffic_using_igmp_proxy_app(self):
2926 """Test subscriber join and receive for channel surfing"""
2927 self.num_subscribers = 5
2928 self.num_channels = 1
2929 self.igmpproxy_setup()
2930 try:
2931 test_status = self.subscriber_join_verify(num_subscribers = self.num_subscribers,
2932 num_channels = self.num_channels,
2933 port_list = self.generate_port_list(self.num_subscribers,
2934 self.num_channels))
2935 assert_equal(test_status, True)
2936 self.igmp_proxy_teardown()
2937 except:
2938 log_test.info('got some error')
2939 self.igmp_proxy_teardown()
2940 raise
2941
2942 @deferred(SUBSCRIBER_TIMEOUT)
2943 def test_two_subscribers_authentication_with_valid_and_invalid_certificates_validating_channel_surfing_using_igmp_proxy_app(self):
2944 ### """Test 2 subscribers to auth, one of the subscriber with invalidCertification and join channel"""
2945 num_subscribers = 2
2946 num_channels = 1
2947 self.igmpproxy_setup()
2948 df = defer.Deferred()
2949 def sub_auth_invalid_cert(df):
2950 try:
2951 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2952 num_channels = num_channels,
2953 cbs = (self.tls_invalid_cert, self.dhcp_verify,self.igmp_verify, self.traffic_verify),
2954 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'half')
2955 assert_equal(test_status, True)
2956 self.igmp_proxy_teardown()
2957 except:
2958 log_test.info('got some error')
2959 self.igmp_proxy_teardown()
2960 raise
2961 df.callback(0)
2962 reactor.callLater(0, sub_auth_invalid_cert, df)
2963 return df
2964
2965 def test_subscriber_authentication_with_multiple_dhcp_discover_for_same_subscriber_and_validating_channel_surfing_using_igmp_proxy_app(self):
2966 ### """Test subscriber auth , sending same DHCP client discover multiple times and join channel"""
2967 num_subscribers = 1
2968 num_channels = 1
2969 self.igmpproxy_setup()
2970 try:
2971 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2972 num_channels = num_channels,
2973 cbs = (self.tls_verify, self.dhcp_same_client_multi_discovers_scenario,
2974 self.igmp_verify, self.traffic_verify),
2975 port_list = self.generate_port_list(num_subscribers, num_channels), negative negative_subscriber_auth = 'all')
2976 assert_equal(test_status, True)
2977 self.igmp_proxy_teardown()
2978 except:
2979 log_test.info('got some error')
2980 self.igmp_proxy_teardown()
2981 raise
2982
2983 @deferred(SUBSCRIBER_TIMEOUT)
2984 def test_subscriber_authentication_with_dhcp_client_reboot_also_validating_channel_surfing_using_igmp_proxy_app(self):
2985 ### """Test subscriber auth success, DHCP client got re-booted and join channel"""
2986 num_subscribers = 1
2987 num_channels = 1
2988 self.igmpproxy_setup()
2989 df = defer.Deferred()
2990 def sub_auth_invalid_cert(df):
2991 try:
2992 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
2993 num_channels = num_channels,
2994 cbs = (self.tls_verify, self.dhcp_client_reboot_scenario,
2995 self.igmp_verify, self.traffic_verify),
2996 port_list = self.generate_port_list(num_subscribers, num_channels), negative_subscriber_auth = 'all')
2997 assert_equal(test_status, True)
2998 self.igmp_proxy_teardown()
2999 except:
3000 log_test.info('got some error')
3001 self.igmp_proxy_teardown()
3002 raise
3003 df.callback(0)
3004 reactor.callLater(0, sub_auth_invalid_cert, df)
3005 return df
3006
3007 def test_four_subscribers_to_join_and_jump_five_channel_using_igmp_proxy_app(self):
3008 ###"""Test 4 subscribers jump and receive for 5 channels surfing"""
3009 num_subscribers = 4
3010 num_channels = 5
3011 self.igmpproxy_setup()
3012 try:
3013 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
3014 num_channels = num_channels,
3015 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
3016 port_list = self.generate_port_list(num_subscribers, num_channels),
3017 negative_subscriber_auth = 'all')
3018 assert_equal(test_status, True)
3019 self.igmp_proxy_teardown()
3020 except:
3021 log_test.info('got some error')
3022 self.igmp_proxy_teardown()
3023 raise
3024
3025 def test_four_subscribers_to_join_next_five_channel_using_igmp_proxy_app(self):
3026 ###"""Test 4 subscribers join next for 5 channels"""
3027 num_subscribers = 4
3028 num_channels = 5
3029 self.igmpproxy_setup()
3030 try:
3031 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
3032 num_channels = num_channels,
3033 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
3034 port_list = self.generate_port_list(num_subscribers, num_channels),
3035 negative_subscriber_auth = 'all')
3036 assert_equal(test_status, True)
3037 self.igmp_proxy_teardown()
3038 except:
3039 log_test.info('got some error')
3040 self.igmp_proxy_teardown()
3041 raise
3042
3043 @nottest
3044 def test_1000_subscribers_to_join_next_1500channels_using_igmp_proxy_app(self):
3045 ###"""Test 1k subscribers join next for 1500 channels"""
3046 num_subscribers = 1000
3047 num_channels = 1500
3048 self.igmpproxy_setup()
3049 try:
3050 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
3051 num_channels = num_channels,
3052 cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
3053 port_list = self.generate_port_list(num_subscribers, num_channels),
3054 negative_subscriber_auth = 'all')
3055 assert_equal(test_status, True)
3056 self.igmp_proxy_teardown()
3057 except:
3058 log_test.info('got some error')
3059 self.igmp_proxy_teardown()
3060 raise
3061
3062 @nottest
3063 def test_5000_subscribers_to_join_and_jump_800_channels_using_igmp_proxy_app(self):
3064 ###"""Test 5k subscribers jump and receive for 800 channels surfing"""
3065 num_subscribers = 5000
3066 num_channels = 800
3067 self.igmpproxy_setup()
3068 try:
3069 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
3070 num_channels = num_channels,
3071 cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
3072 port_list = self.generate_port_list(num_subscribers, num_channels),
3073 negative_subscriber_auth = 'all')
3074 assert_equal(test_status, True)
3075 self.igmp_proxy_teardown()
3076 except:
3077 log_test.info('got some error')
3078 self.igmp_proxy_teardown()
3079 raise
3080
3081 @nottest
3082 def test_10000_subscribers_join_1200_channels_and_recv_traffic_using_igmp_proxy_app(self):
3083 ###"""Test 10k subscribers join and receive for 1200 channels surfing"""
3084 num_subscribers = 10000
3085 num_channels = 1200
3086 self.igmpproxy_setup()
3087 try:
3088 test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
3089 num_channels = num_channels,
3090 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
3091 port_list = self.generate_port_list(num_subscribers, num_channels),
3092 negative_subscriber_auth = 'all')
3093 assert_equal(test_status, True)
3094 self.igmp_proxy_teardown()
3095 except:
3096 log_test.info('got some error')
3097 self.igmp_proxy_teardown()
3098 raise
3099
3100 @nottest
3101 def test_three_subscribers_with_voltha_tls_and_igmp_proxy(self):
3102 """Test subscriber TLS and IGMP with voltha for channel surfing with 3 subscribers browsing 3 channels each"""
3103 if self.VOLTHA_HOST is None:
3104 log_test.info('Skipping test as no voltha host')
3105 return
3106 num_subscribers = 3
3107 num_channels = 3
3108 services = ('TLS','IGMP',)
3109 cbs = ( self.tls_verify, self.voltha_igmp_next_verify,)
3110 try:
3111 self.cord_subscriber_voltha(services, cbs = cbs,
3112 num_subscribers = num_subscribers,
3113 num_channels = num_channels)
3114 self.igmp_proxy_teardown()
3115 except:
3116 log_test.info('got some error')
3117 self.igmp_proxy_teardown()
3118 raise
3119