def test_check_ifd(self):
dh = MagicMock()
# state is 'on'
dh.cli.return_value = Response(status=True, response='xe-0/0/0 up up')
self.assertEqual(_check_ifd(dh, 'xe-0/0/0', action='on'), 'on')
# state is 'off'
dh.cli.return_value = Response(status=True,
response='xe-0/0/0 up down')
self.assertEqual(_check_ifd(dh, 'xe-0/0/0', action='off'), 'off')
# state is 'not found default to off'
dh.cli.return_value = Response(
status=True, response='error: device xe-0/0/46 not found')
self.assertEqual(_check_ifd(dh, 'xe-0/0/46', action='off'), 'off')
# state is 'admin_down'
dh.cli.return_value = Response(status=True,
response='xe-0/0/0 down down')
self.assertEqual(_check_ifd(dh, 'xe-0/0/0', action='up'), True)
# state is None
dh.cli.return_value = Response(status=True,
response='xe-0/0/0 down up')
self.assertIsNone(_check_ifd(dh, 'xe-0/0/0', action=None))
def test_idp_remove_attack_in_sig_xml(self):
self.mocked_obj.shell = MagicMock()
try:
idp_remove_attack_in_sig_xml()
except Exception as err:
self.assertEqual(err.args[0],
"Device handle is mandatory argument")
try:
idp_remove_attack_in_sig_xml(device=self.mocked_obj)
except Exception as err:
self.assertEqual(err.args[0],
"Missing mandatory argument attackname")
device_response = ""
self.mocked_obj.shell = MagicMock(
return_value=Response(device_response))
try:
idp_remove_attack_in_sig_xml(device=self.mocked_obj,
attackname="FTP:USER:ROOT")
except Exception as err:
self.assertEqual(
err.args[0],
"grep command output is not as expected: , hence not "
"able to remove the attack : FTP:USER:ROOT")
device_response = "139088- <Entry>\n" + "139090: <Name>FTP:USER:ROOT</Name>\n" + "139150- </Entry>"
self.mocked_obj.shell = MagicMock(
return_value=Response(device_response))
self.assertEqual(
idp_remove_attack_in_sig_xml(device=self.mocked_obj,
attackname="FTP:USER:ROOT"), True)
def test_get_if_snmp_index(self):
logging.info("-----------Test get_if_snmp_index: -----------")
######################################################################
from jnpr.toby.system.snmp.snmpkeywords import get_if_snmp_index
dev_object = MagicMock()
######################################################################
logging.info("Test case 1: Get interface snmp index successfully")
response = """
Logical interface xe-0/0/0.1 (Index 3833) (SNMP ifIndex 3445) (Generation 3642)
Flags: Up SNMP-Traps 0x4000 VLAN-Tag [ 0x8100.1 ] Encapsulation: ENET2
"""
dev_object.cli = MagicMock(return_value=Response(response=response))
result = get_if_snmp_index(dev=dev_object, interface='xe-0/0/0.1')
self.assertEqual(result, '3445', 'Should not be False')
######################################################################
logging.info("Test case 2: Get interface snmp index unsuccessfully"
" with response of cli command is empty")
response = ""
dev_object.cli = MagicMock(return_value=Response(response=response))
result = get_if_snmp_index(dev=dev_object, interface='xe-0/0/0.1')
self.assertEqual(result, False, 'Should be False')
######################################################################
logging.info("Test case 3: Get interface snmp index unsuccessfully"
" with snmp index not found")
response = "Logical interface xe-0/0/0.1 (Index 3833)"
dev_object.cli = MagicMock(return_value=Response(response=response))
result = get_if_snmp_index(dev=dev_object, interface='xe-0/0/0.1')
self.assertEqual(result, False, 'Should be False')
def test_config_engine_rpc(self):
'''
rpc function of config engine
'''
dh = MagicMock()
#dh.commit = MagicMock()
dh.commit.return_value = Response(status=True, response='test')
cfg._get_dev_handle.return_value = dh
kwargs = {'rpc':'test', 'commit_timeout':60}
cfg._process_cv.return_value=kwargs
rpc_cmd = '<edit-config><target><candidate/></target><config><configuration><system><host-name>tobybbb</host-name></system></configuration></config></edit-config>'
# load rpc without device_list
cfg._load_rpc = MagicMock()
try:
config.config_engine(cfg, rpc=rpc_cmd)
except Exception as err:
self.assertEqual(str(err), "missing device_list for rpc")
# run rpc:
self.assertTrue(config.config_engine(cfg, rpc=rpc_cmd, device_list='r0', commit=True, commit_timeout=60))
dh.commit.return_value = Response(status=False, response='test')
#self.assertRaises(Exception, config.config_engine(cfg, rpc=rpc_cmd, device_list='r0', commit=True, commit_timeout=60))
cfg._process_cv.return_value = {'rpc':'test', 'timeout':60}
try:
config.config_engine(cfg, rpc=rpc_cmd, device_list='r0', commit=True, commit_timeout=60)
except Exception as err:
self.assertRaises(Exception)
def test_kill_process(self):
device = MagicMock(spec=Cisco)
device.log = MagicMock()
###################################################################
logging.info(
"Test case 1: pid is not specified, kill process unsuccessfully")
with self.assertRaises(Exception) as context:
self.assertRaises(Exception, IOS.kill_process(device))
logging.info("\tPassed")
###################################################################
logging.info("Test case 2: kill process unsuccessfully")
device.cli = MagicMock(return_value=Response(response=''))
expected_result = False
result = IOS.kill_process(device, pid=1, signal=9)
self.assertEqual(result, expected_result,
"Result should be %s" % expected_result)
logging.info("\tPassed")
###################################################################
logging.info("Test case 3: kill process successfully")
device.cli = MagicMock(return_value=Response(response='abc'))
expected_result = 'abc'
result = IOS.kill_process(device, pid=1)
self.assertEqual(result, expected_result,
"Result should be %s" % expected_result)
logging.info("\tPassed")
def test_save_config(self):
device = MagicMock(spec=Cisco)
device.log = MagicMock()
###################################################################
logging.info("Test case 1: save config successfully")
device.cli = MagicMock(return_value=Response(response=''))
device.execute = MagicMock(
side_effect=['want to overwrite?', '[confirm]', '[OK]'])
result = IOS.save_config(device, file='start')
self.assertTrue(result, "Result should be True")
logging.info("\tPassed")
###################################################################
logging.info("Test case 2: Invalid file. save config unsuccessfully")
device.cli = MagicMock(return_value=Response(response=''))
device.execute = MagicMock(
side_effect=['want to overwrite?', '[confirm]', '[OK]'])
with self.assertRaises(Exception) as context:
self.assertRaises(Exception, IOS.save_config(device))
logging.info("\tPassed")
###################################################################
logging.info("Test case 3: save config successfully")
device.cli = MagicMock(return_value=Response(response=''))
device.execute = MagicMock(side_effect=['', '', ''])
result = IOS.save_config(device, file='start')
self.assertFalse(result, "Result should be False")
logging.info("\tPassed")
def test_reboot(self, sleep_patch):
device = MagicMock(spec=Cisco)
device.log = MagicMock()
sleep_patch = MagicMock()
device.save_config = MagicMock()
###################################################################
logging.info("Test case 1: Cannot save config. Reboot unsuccessfully")
device.cli = MagicMock(return_value=Response(response='yes/no'))
device.execute = MagicMock()
result = IOS.reboot(device)
self.assertFalse(result, "Result should be False")
logging.info("\tPassed")
###################################################################
logging.info("Test case 2: Reboot successfully")
device.cli = MagicMock(return_value=Response(response='confirm'))
device.execute = MagicMock()
device.reconnect = MagicMock(return_value=True)
result = IOS.reboot(device)
self.assertTrue(result, "Result should be True")
logging.info("\tPassed")
###################################################################
logging.info("Test case 2: Reboot unsuccessfully")
device.cli = MagicMock(return_value=Response(response='confirm'))
device.execute = MagicMock()
device.reconnect = MagicMock(return_value=False)
result = IOS.reboot(device)
self.assertFalse(result, "Result should be False")
logging.info("\tPassed")
def test_get_image(self):
device = MagicMock(spec=Cisco)
device.log = MagicMock()
###################################################################
logging.info("Test case 1: get_image successfully")
device.cli = MagicMock(
return_value=Response(response=""""ROM: ROMMON Emulation Microcode
ROM: 3700 Software (C3745-ADVENTERPRISEK9_SNA-M), Version 12.4(25d), RELEASE SOFTWARE (fc1)
R1 uptime is 3 hours, 53 minutes
System returned to ROM by unknown reload cause - suspect boot_data[BOOT_COUNT] 0x0, BOOT_COUNT 0, BOOTDATA 19
System image file is "tftp://255.255.255.255/unknown"
This product contains cryptographic features and is subject to United"""
))
expected_result = 'tftp://255.255.255.255/unknown'
result = get_image(device)
self.assertEqual(result, expected_result,
"Result should be %s" % expected_result)
logging.info("\tPassed")
###################################################################
logging.info("Test case 2: get_image unsuccessfully")
device.cli = MagicMock(
return_value=Response(response=""""ROM: ROMMON Emulation Microcode
ROM: 3700 Software (C3745-ADVENTERPRISEK9_SNA-M),
R1 uptime is 3 hours, 53 minutes
System returned to ROM by unknown reload cause - suspect boot_data[BOOT_COUNT] 0x0, BOOT_COUNT 0, BOOTDATA 19
System image file is ""
This product contains cryptographic features and is subject to United"""
))
expected_result = ''
result = get_image(device)
self.assertEqual(result, expected_result,
"Result should be %s" % expected_result)
logging.info("\tPassed")
def test_check_ifd_shell_up_down(self):
dh = MagicMock()
dh.shell.return_value = Response(status=True, response='DOWN')
self.assertTrue(_check_ifd_shell_up_down(dh, 'xe-0/0/0', action=None))
dh.shell.return_value = Response(status=True, response='test')
self.assertTrue(_check_ifd_shell_up_down(dh, 'xe-0/0/0', action='on'))
dh.shell.return_value = Response(status=False, response='inactive')
self.assertFalse(_check_ifd_shell_up_down(dh, 'xe-0/0/0',
action='off'))
def test_connect(self):
from jnpr.toby.hldcl.cisco.cisco import Cisco, IOS
device = MagicMock(spec=Cisco)
device.host = 'test'
device._connect = MagicMock(return_value=True)
device.enable = MagicMock(return_value=True)
device.cli = MagicMock()
device.log = MagicMock()
device.cli = MagicMock(return_value=Response(response=''))
IOS.connect(device)
device.cli = MagicMock(return_value=Response(response='error'))
IOS.connect(device)
def test_check_pic_on_off(self):
dh = MagicMock()
# state is 'online'
dh.cli.return_value = Response(status=True,
response=' State Online')
self.assertEqual(_check_pic_on_off(dh, 'xe-0/0/0', action='on'), False)
# state is 'offline'
dh.cli.return_value = Response(status=True,
response=' State Offline')
self.assertEqual(_check_pic_on_off(dh, 'xe-0/0/0', action='off'),
False)
def test_check_ifd_cfg_enable_disable(self):
dh = MagicMock()
dh.config.return_value = Response(status=True, response='disable')
self.assertTrue(
_check_ifd_cfg_enable_disable(dh, 'xe-0/0/0', action=None))
dh.config.return_value = Response(status=True, response='test')
self.assertTrue(
_check_ifd_cfg_enable_disable(dh, 'xe-0/0/0', action='enable'))
dh.config.return_value = Response(status=False, response='inactive')
self.assertFalse(
_check_ifd_cfg_enable_disable(dh, 'xe-0/0/0', action='off'))
def test_check_10ge_xfp_laser(self, mockshf):
dh = MagicMock()
# state is 'on'
dh.vty.return_value = Response(status=True,
response=' Tx not ready: 1 Clear')
self.assertEqual(_check_10ge_xfp_laser(dh, 'ge-0/0/0', action=None),
'on')
# state is 'off'
dh.vty.return_value = Response(status=True,
response=' Tx not ready: 1 Set')
self.assertEqual(_check_10ge_xfp_laser(dh, 'ge-0/0/0', action=None),
'off')
def test_restart_process(self, check_daemon_mock, check_master_re_mock, func_name_mock):
dh = MagicMock()
# process is None
#self.assertFalse(restart_process(dh, process=None))
# no process
#self.assertFalse(restart_process(dh, process='wrong'))
#check_daemon_mock.side_effect =[1, 2, 111, 222, 44, 44, 11, 5, 9, 88, 45, 46]
check_master_re_mock.return_value = True
dh.get_current_controller_name.return_value = 're0'
dh.set_current_controller.return_value = False
self.assertTrue(triggers.restart_process(dh, process='kernel-replication'))
dh.get_current_controller_name.return_value = 're1'
dh.cli.return_value = Response(status= False, response='syntax error')
self.assertTrue(triggers.restart_process(dh, process='kernel-replication', option='soft'))
check_master_re_mock.return_value = False
self.assertTrue(triggers.restart_process(dh, process='kernel-replication'))
# no pid
check_master_re_mock.return_value = True
dh.cli.return_value = Response(status= True, response='123')
self.assertTrue(triggers.restart_process(dh, process='interface-control'))
self.assertTrue(triggers.restart_process(dh, process='chassis-control'))
# syntax error in method name
dh.cli.return_value = Response(status=True, response='syntax error')
#self.assertFalse(triggers.restart_process(dh, process='snmp'))
self.assertFalse(triggers.restart_process(dh, process='snmp',force_restart_process=True))
#dual_re= True
dh.cli.return_value = Response(status= True, response='123')
check_master_re_mock.return_value = False
dh.get_current_controller_name.return_value = 're0'
dh.set_current_controller.return_value = True
self.assertTrue(triggers.restart_process(dh, process='kernel-replication'))
dh.get_current_controller_name.return_value = 're1'
self.assertTrue(triggers.restart_process(dh, process='kernel-replication'))
# handle exception from hldcl
dh.cli.side_effect = Exception
self.assertFalse(triggers.restart_process(dh, process='snmp'))
def test_check_isis_neighbor(self, sleep_time):
from jnpr.toby.hldcl.cisco.utils import check_isis_neighbor
device = MagicMock()
device.log = MagicMock()
###################################################################
logging.info("Test case 1: Run with valid response and return True")
res = '''
System Id Type Interface IP Address State Holdtime Circuit Id
0000.0000.0002 L1 Et0/0 192.168.128.2 UP 21 R5.02
0000.0000.0003 L2 Et0/0 192.168.128.3 UP 28 R5.03
0000.0000.0004 L3 Et0/0 192.168.128.4 Down 28 R5.04
'''
device.cli = MagicMock(side_effect=[
Response(response="no response"),
Response(response=res)
])
result = check_isis_neighbor(
device,
system_id=['0000.0000.0002', '0000.0000.0003'],
router_type=['L1', 'L2'],
interface=['Et0/0', 'Et0/0'],
ip_address=['192.168.128.2', '192.168.128.3'],
state='Up',
circuit_id=['R5.02', 'R5.03'],
num=2,
timeout=90,
interval=10,
options="detail")
self.assertTrue(result, "Result should be True")
logging.info("\tPassed")
###################################################################
logging.info("Test case 2: Run with not match state")
device.cli = MagicMock(return_value=Response(response=res))
result = check_isis_neighbor(device,
system_id='0000.0000.0004',
router_type='L3',
interface='Et0/0',
ip_address='192.168.128.4',
state='Up',
circuit_id='R5.04',
num=None,
timeout=90,
interval=10,
options=None)
self.assertFalse(result, "Result should be False")
logging.info("\tPassed")
def test_on_config(self):
dh = MagicMock()
# config returned successfully
dh.config.return_value = Response(status=True, response='test')
self.assertTrue(triggers.on_config(dh, 'set this'))
# config returned syntax error
dh.config.return_value = Response(status=True, response='syntax error')
self.assertFalse(triggers.on_config(dh, 'set this'))
# config returned status False
dh.config.return_value = Response(status=False, response='anything')
self.assertFalse(triggers.on_config(dh, 'set this'))
dh.config.side_effect = Exception
self.assertFalse(triggers.on_config(dh, 'set this'))
def test_on_cli(self):
dh = MagicMock()
# cli returned successfully
dh.cli.return_value = Response(status=True, response='test')
self.assertTrue(triggers.on_cli(dh, 'show chassis alarm'))
# cli returned syntax error
dh.cli.return_value = Response(status=True, response='syntax error')
self.assertFalse(triggers.on_cli(dh, 'show chassis alarm'))
# cli returned status False
dh.cli.return_value = Response(status=False, response='anything')
self.assertFalse(triggers.on_cli(dh, 'show chassis alarm'))
dh.cli.side_effect = Exception
self.assertFalse(triggers.on_cli(dh, 'show chassis alarm'))
def test_kill_trapd(self):
logging.info("-----------Test __kill_trapd: -----------")
dev_object = MagicMock()
######################################################################
logging.info("Test case 1: __kill_trapd successfully")
response = "regress 40865 0.0 0.0 22680 2144 1 "\
"S+ 11:58PM 0:00.00 grep snmptrapd"
dev_object.shell = MagicMock(return_value=Response(response=response))
result = kill_trapd(dev_object)
self.assertEqual(result, True, 'Should be True')
######################################################################
logging.info("Test case 2: __kill_trapd unsuccessfully")
response = ""
dev_object.shell = MagicMock(return_value=Response(response=response))
result = kill_trapd(dev_object, port=40865)
self.assertEqual(result, False, 'Should be False')
def test_check_trap(self, patch_kill_trapd, patch_controller,
patch_snmp_channel, patch_get_trap_result,
patch_sleep):
logging.info("-----------Test check_trap: -----------")
######################################################################
from jnpr.toby.system.snmp.snmpkeywords import check_trap
dev_object = MagicMock()
patch_controller.return_value.log = MagicMock()
patch_controller.return_value.host = MagicMock()
patch_snmp_channel.return_value.snmpchannel = MagicMock()
patch_kill_trapd.return_value = True
def test_trap():
pass
######################################################################
logging.info("Test case 1: SNMP check_trap successfully")
patch_snmp_channel.return_value.get_trap_result = MagicMock(
return_value='.1.3.6.1.2.1.14.16.2.0.2')
result = check_trap(dev_object, test_trap, port=162,
config_trap=False, pattern='1.3.6.1.2',
time_end_trap=1)
self.assertEqual(result, True, 'Should be True')
######################################################################
logging.info("Test case 2: SNMP check_trap unsuccessfully")
patch_snmp_channel.return_value.get_trap_result = MagicMock(
return_value='.1.3.6.1.2.1.14.16.2.0.2')
dev_object.config = MagicMock(return_value=Response(response=''))
result = check_trap(dev_object, test_trap, port=162,
config_trap=True, trap_group='abc',
pattern=['abc', '123'], time_end_trap=1)
self.assertEqual(result, False, 'Should be False')
def cli(self, command='', mode='privileged', pattern=None, timeout=60, kw_call=False):
"""
Executes operational commands for user or privileged mode on IOS
device_object.cli(command = 'show version')
:param command:
**REQUIRED** CLI command to execute
:param mode:
**OPTIONAL** 'user' or 'privileged' mode. Default: privileged
:param timeout:
*OPTIONAL* Time by which response should be received. Default is
60 seconds
:param pattern: Expected pattern
:return: Object with the following methods
'response()': Response from the CLI command(text)
"""
if command is None:
raise TobyException("Mandatory argument 'command' is missing!", host_obj=self)
self._switch_mode(mode=mode)
if not pattern:
pattern = self.prompt
# Only one command can be executed
if not isinstance(command, str):
raise TobyException("'command' should be a string", host_obj=self)
self.log('command: ' + command)
response = self.execute(command=command, pattern=pattern,
timeout=timeout)
return_value = Response(response=response, status=True)
return return_value
def shell(self, *args, **kvargs):
"""
Method called by user to send a string command to device and save its
response.
:param command:
**REQUIRED** string command to be sent to the device
:param pattern:
*OPTIONAL* Output will be collected till this pattern is found.
:param timeout:
*OPTIONAL* Time by which output is expected. Default is
set based on os/platform/model of the box
:return: response from device. exception if timeout seen
"""
if 'command' not in kvargs:
raise TobyException('Command for device not specified',
host_obj=self)
try:
kvargs['timeout'] = kvargs.get('timeout', self.shell_timeout)
patt_match = self.execute(*args, **kvargs)
if patt_match == -1:
raise TobyException('Timeout seen while retrieving output',
host_obj=self)
else:
return_value = Response(response=self.response)
return return_value
except:
raise TobyException("Timeout seen while retrieving output",
host_obj=self)
def test__check_interface_status(self, sleep_patch):
from jnpr.toby.hldcl.juniper.routing.crpd import Crpd
from jnpr.toby.utils.response import Response
import builtins
cobject = MagicMock(spec=Crpd)
builtins.t = cobject
cobject.cli = MagicMock(return_value=Response(response="lsi Up MPLS enabled"))
self.assertTrue(Crpd._check_interface_status(cobject, interfaces=["lsi"]))
cobject = MagicMock(spec=Crpd)
cobject.cli = MagicMock(return_value=Response(response="lsi down MPLS enabled"))
self.assertFalse(Crpd._check_interface_status(cobject, interfaces=["(interface 2)"]))
cobject.cli = MagicMock(return_value=Response(response="""(interface 1) int1 up (interface 2) int2 down"""))
self.assertFalse(Crpd._check_interface_status(cobject, interfaces=["Some other pattern"]))
cobject.cli = MagicMock(return_value=Response(response="""(interface 1) """))
self.assertFalse(Crpd._check_interface_status(cobject, interfaces=["(interface"]))
def test__check_daemon(self,check_vmhost_mock):
dh = MagicMock()
check_vmhost_mock.return_value = False
dh.cli.return_value = Response(status=True, \
response=' 4598 root 3 20 0 860M 55640K kqread 3:05 0.00% rpd')
self.assertTrue(triggers._check_daemon(dh, daemon='rpd', mode='cli'))
self.assertFalse(triggers._check_daemon(dh, daemon='wrong', mode='cli'))
def test_check_ospf_neighbor(self, sleep_time):
from jnpr.toby.hldcl.cisco.utils import check_ospf_neighbor
device = MagicMock()
device.log = MagicMock()
###################################################################
logging.info("Test case 1: Run with valid response and return True")
res = '''
Neighbor ID Pri State Dead Time Address Interface
10.199.199.137 1 FULL/DR 0:00:31 192.168.80.37 Ethernet0
172.16.48.1 1 FULL/DROTHER 0:00:33 172.16.48.1 Fddi0
172.16.48.200 1 WAIT/DROTHER 0:00:33 172.16.48.200 Fddi0
10.199.199.137 5 FULL/DR 0:00:33 172.16.48.189 Fddi0
'''
device.cli = MagicMock(side_effect=[
Response(response="no response"),
Response(response=res)
])
result = check_ospf_neighbor(
device,
ospfv3=False,
address=['192.168.80.37', '172.16.48.1'],
interface=['Ethernet0', 'Fddi0'],
router_id=['10.199.199.137', '172.16.48.1'],
state='Full',
num=None,
timeout=90,
interval=10,
options=" area 1")
self.assertTrue(result, "Result should be True")
logging.info("\tPassed")
###################################################################
logging.info("Test case 2: Run with ospfv3 and not match state")
device.cli = MagicMock(return_value=Response(response=res))
result = check_ospf_neighbor(device,
ospfv3=True,
address='172.16.48.200',
interface='Fddi0',
router_id='172.16.48.200',
state='Full',
num=1,
timeout=90,
interval=10,
options=None)
self.assertFalse(result, "Result should be False")
logging.info("\tPassed")
def test_check_fpc_restart(self, mockshf):
dh = MagicMock()
# state is 'online'
dh.cli.return_value = Response(status=True, response='online')
self.assertEqual(
_check_fpc_restart(dh,
'xe-0/0/0',
action='online',
wait_to_check=0), None)
def test_check_fpc_on_off(self, mockshf):
dh = MagicMock()
# state is 'online'
dh.cli.return_value = Response(status=True, response='Offline')
self.assertEqual(
_check_fpc_on_off(dh,
'xe-0/0/0',
action='offline',
wait_to_check=0), False)
dh.cli.return_value = Response(
status=True,
response=
' 0 Online 51 15 0 15 15 14 3584 6 25'
)
self.assertEqual(
_check_fpc_on_off(dh, 'xe-0/0/0', action='online',
wait_to_check=0), True)
def test_check_mtip_gpcs_laser(self, mockshf):
dh = MagicMock()
# state is 'on'
dh.vty.return_value = Response(status=True,
response=' control : 0x00001140')
self.assertEqual(_check_mtip_gpcs_laser(dh, 'ge-0/0/0', action=None),
'on')
# state is 'off'
dh.vty.return_value = Response(status=True,
response=' control : 0x00001d40')
self.assertEqual(_check_mtip_gpcs_laser(dh, 'ge-0/0/0', action=None),
'off')
dh.vty.return_value = Response(status=True,
response=' control : 0x00001d')
self.assertEqual(_check_mtip_gpcs_laser(dh, 'ge-0/0/0', action=None),
None)
def test_check_agent_smith_laser(self, mockshf):
dh = MagicMock()
# state is 'on'
dh.vty.return_value = Response(status=True,
response='7 0/0/0 2 ON')
self.assertEqual(_check_agent_smith_laser(dh, 'xe-0/0/0', action=None),
'on')
# state is 'off'
dh.vty.return_value = Response(status=True,
response='7 0/0/0 2 OFF')
self.assertEqual(_check_agent_smith_laser(dh, 'xe-0/0/0', action=None),
'off')
dh.vty.return_value = Response(status=True,
response='7 0/0/0 2 BOOG')
self.assertEqual(_check_agent_smith_laser(dh, 'xe-0/0/0', action=None),
None)
def test_pop3_fetch_mail_success(self):
lst = [Response("FETCHED MAIL")]
self.mocked_obj.shell = MagicMock(side_effect=lst)
self.assertEqual(
email_traffic.pop3_fetch_mail(
device=self.mocked_obj,
server="5.0.0.1",
user_name="test",
password="******",
starttls="yes"),
True)
def test_execute_interactive_commands_success_running(self):
lst = [Response("250")]
self.mocked_obj.shell = MagicMock(side_effect=lst)
command = ["MAIL FROM: <*****@*****.**>"]
pattern = ["250"]
self.assertEqual(
email_traffic.execute_interactive_commands(
device=self.mocked_obj,
command=command,
pattern=pattern),
True)