desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Mock set_port method'
| def set_port(self, sg_name):
| self.sg_name = sg_name
return MockNSServiceGroupServerBinding()
|
'Mock add method'
| @staticmethod
def add(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSServiceGroupServerBinding()
|
'Mock delete method'
| @staticmethod
def delete(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSServiceGroupServerBinding()
|
'Mock set_name method'
| def set_name(self, sg_name):
| self.sg_name = sg_name
return MockNSService()
|
'Mock get method'
| @staticmethod
def get(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSService()
|
'Mock enable method'
| @staticmethod
def enable(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSService()
|
'Mock disable method'
| @staticmethod
def disable(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSService()
|
'Mock get_svrstate method'
| @staticmethod
def get_svrstate():
| return 'UP'
|
'Mock set_name method'
| def set_name(self, sg_name):
| self.sg_name = sg_name
return MockNSServer()
|
'Mock get method'
| @staticmethod
def get(obj, servicegroup):
| return MockNSServer()
|
'Mock add method'
| @staticmethod
def add(obj, servicegroup):
| return MockNSServer()
|
'Mock delete method'
| @staticmethod
def delete(obj, servicegroup):
| return MockNSServer()
|
'Mock update method'
| @staticmethod
def update(obj, servicegroup):
| return MockNSServer()
|
'Mock enable method'
| @staticmethod
def enable(obj, servicegroup):
| return MockNSServer()
|
'Mock disable method'
| @staticmethod
def disable(obj, servicegroup):
| return MockNSServer()
|
'Mock get_ipaddress method'
| @staticmethod
def get_ipaddress():
| return ''
|
'Mock set_ipaddress method'
| @staticmethod
def set_ipaddress(s_ip):
| return s_ip
|
'Mock get_state method'
| def get_state(self):
| if (self.flag == 1):
return ''
elif (self.flag == 2):
return 'DISABLED'
return 'ENABLED'
|
'Mock set_name method'
| def set_name(self, sg_name):
| self.sg_name = sg_name
return MockNSLBVServer()
|
'Mock get method'
| @staticmethod
def get(obj, servicegroup):
| return MockNSLBVServer()
|
'Mock set_ipv46 method'
| @staticmethod
def set_ipv46(v_ip):
| return v_ip
|
'Mock set_port method'
| @staticmethod
def set_port(v_port):
| return v_port
|
'Mock set_servicetype method'
| @staticmethod
def set_servicetype(v_type):
| return v_type
|
'Mock get_ipv46 method'
| @staticmethod
def get_ipv46():
| return ''
|
'Mock get_port method'
| @staticmethod
def get_port():
| return ''
|
'Mock get_servicetype method'
| @staticmethod
def get_servicetype():
| return ''
|
'Mock add method'
| @staticmethod
def add(obj, servicegroup):
| return MockNSLBVServer()
|
'Mock delete method'
| @staticmethod
def delete(obj, servicegroup):
| return MockNSLBVServer()
|
'Mock set_name method'
| def set_name(self, sg_name):
| self.sg_name = sg_name
return MockNSLBVServerServiceGroupBinding()
|
'Mock get method'
| @staticmethod
def get(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return [MockNSLBVServerServiceGroupBinding()]
|
'Mock get_servicegroupname method'
| @staticmethod
def get_servicegroupname():
| return 'serviceGroupName'
|
'Mock set_servicegroupname method'
| def set_servicegroupname(self, sg_name):
| self.sg_name = sg_name
if self.flag:
return None
return MockNSLBVServerServiceGroupBinding()
|
'Mock add method'
| @staticmethod
def add(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSLBVServerServiceGroupBinding()
|
'Mock delete method'
| @staticmethod
def delete(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSLBVServerServiceGroupBinding()
|
'Mock set_vservername method'
| def set_vservername(self, sg_name):
| self.sg_name = sg_name
return MockNSSSLVServerSSLCertKeyBinding()
|
'Mock get method'
| @staticmethod
def get(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return [MockNSSSLVServerSSLCertKeyBinding()]
|
'Mock get_certkeyname method'
| @staticmethod
def get_certkeyname():
| return 'serviceGroupName'
|
'Mock set_certkeyname method'
| def set_certkeyname(self, sg_name):
| self.sg_name = sg_name
return MockNSSSLVServerSSLCertKeyBinding()
|
'Mock add method'
| @staticmethod
def add(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSSSLVServerSSLCertKeyBinding()
|
'Mock delete method'
| @staticmethod
def delete(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSSSLVServerSSLCertKeyBinding()
|
'Tests if it checks if a service group exists'
| def test_servicegroup_exists(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
MockNSNitro.flag = None
self.assertTrue(netscaler.servicegroup_exists('serviceGrpName'))
self.assertFalse(netscaler.servicegroup_exists('serviceGrpName', sg_type='HTTP'))
MockNSNitro.flag = True
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.servicegroup_exists('serGrpNme'))
|
'Tests if it add a new service group'
| def test_servicegroup_add(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertFalse(netscaler.servicegroup_add('serviceGroupName'))
MockNSNitro.flag = True
self.assertFalse(netscaler.servicegroup_add('serviceGroupName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.servicegroup_add('serveGrpName'))
|
'Tests if it delete a new service group'
| def test_servicegroup_delete(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
MockNSNitro.flag = None
self.assertTrue(netscaler.servicegroup_delete('serviceGrpName'))
mock = MagicMock(side_effect=[None, MockNSServiceGroup()])
with patch.object(netscaler, '_servicegroup_get', mock):
MockNSNitro.flag = True
self.assertFalse(netscaler.servicegroup_delete('srGrpName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.servicegroup_delete('sGNam'))
|
'Tests if it check if a server:port combination
is a member of a servicegroup'
| def test_servicegroup_server_exists(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertFalse(netscaler.servicegroup_server_exists('serviceGrpName', 'serverName', 'serverPort'))
|
'Tests if it check if a server:port combination
is a member of a servicegroup'
| def test_servicegroup_server_up(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertFalse(netscaler.servicegroup_server_up('serviceGrpName', 'serverName', 'serverPort'))
|
'Tests if it enable a server:port member of a servicegroup'
| def test_servicegroup_server_enable(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertFalse(netscaler.servicegroup_server_enable('serviceGrpName', 'serverName', 'serverPort'))
with patch.object(netscaler, '_servicegroup_get_server', MagicMock(return_value=MockNSServiceGroup())):
MockNSNitro.flag = None
self.assertTrue(netscaler.servicegroup_server_enable('servGrpName', 'serverName', 'serPort'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.servicegroup_server_enable('serGrpName', 'serverName', 'sPort'))
|
'Tests if it disable a server:port member of a servicegroup'
| def test_sergrp_server_disable(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertFalse(netscaler.servicegroup_server_disable('serviceGrpName', 'serverName', 'serverPort'))
with patch.object(netscaler, '_servicegroup_get_server', MagicMock(return_value=MockNSServiceGroup())):
MockNSNitro.flag = None
self.assertTrue(netscaler.servicegroup_server_disable('serveGrpName', 'serverName', 'serPort'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.servicegroup_server_disable('servGrpName', 'serverName', 'sPort'))
|
'Tests if it add a server:port member to a servicegroup'
| def test_servicegroup_server_add(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.servicegroup_server_add('serGrpName', 'serverName', 'sPort'))
MockNSNitro.flag = None
self.assertTrue(netscaler.servicegroup_server_add('serGrpName', 'serverName', 'serverPort'))
mock = MagicMock(return_value=MockNSServiceGroupServerBinding())
with patch.object(netscaler, '_servicegroup_get_server', mock):
MockNSNitro.flag = True
self.assertFalse(netscaler.servicegroup_server_add('serviceGroupName', 'serverName', 'serPort'))
|
'Tests if it remove a server:port member to a servicegroup'
| def test_servicegroup_server_delete(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.servicegroup_server_delete('servGrpName', 'serverName', 'sPort'))
self.assertFalse(netscaler.servicegroup_server_delete('serviceGroupName', 'serverName', 'serverPort'))
mock = MagicMock(return_value=MockNSServiceGroupServerBinding())
with patch.object(netscaler, '_servicegroup_get_server', mock):
MockNSNitro.flag = None
self.assertTrue(netscaler.servicegroup_server_delete('serviceGroupName', 'serverName', 'serPort'))
|
'Tests if it checks if a service is UP'
| def test_service_up(self):
| mock = MagicMock(return_value=MockNSService())
with patch.object(netscaler, '_service_get', mock):
self.assertTrue(netscaler.service_up('serviceGrpName'))
|
'Tests if it checks if a service is UP'
| def test_service_exists(self):
| mock = MagicMock(return_value=MockNSService())
with patch.object(netscaler, '_service_get', mock):
self.assertTrue(netscaler.service_exists('serviceGrpName'))
|
'Tests if it enable a service'
| def test_service_enable(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.service_enable('serviceGrpName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.service_enable('serviceGrpName'))
mock = MagicMock(return_value=MockNSService())
with patch.object(netscaler, '_service_get', mock):
self.assertFalse(netscaler.service_enable('serGrpName'))
|
'Tests if it disable a service'
| def test_service_disable(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.service_disable('serviceGrpName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.service_disable('serceGrpName'))
mock = MagicMock(return_value=MockNSService())
with patch.object(netscaler, '_service_get', mock):
self.assertFalse(netscaler.service_disable('seGrpName'))
|
'Tests if it checks if a server exists'
| def test_server_exists(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.server_exists('serviceGrpName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.server_exists('serviceGrpName'))
self.assertFalse(netscaler.server_exists('serviceGrpName', ip='1.0.0.1'))
self.assertFalse(netscaler.server_exists('serviceGrpName', s_state='serverName'))
|
'Tests if it add a server'
| def test_server_add(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertFalse(netscaler.server_add('servGrpName', '1.0.0.1'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.server_add('serviceGrpName', '1.0.0.1'))
mock = MagicMock(return_value=False)
with patch.object(netscaler, 'server_exists', mock):
self.assertTrue(netscaler.server_add('serviceGrpName', '1.0.0.1'))
|
'Tests if it delete a server'
| def test_server_delete(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.server_delete('serviceGrpName'))
mock = MagicMock(side_effect=[MockNSServer(), None])
with patch.object(netscaler, '_server_get', mock):
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.server_delete('serGrpName'))
self.assertFalse(netscaler.server_delete('serviceGrpName'))
|
'Tests if it update a server\'s attributes'
| def test_server_update(self):
| mock = MagicMock(side_effect=[None, MockNSServer(), MockNSServer(), MockNSServer()])
with patch.object(netscaler, '_server_get', mock):
self.assertFalse(netscaler.server_update('seGrName', '1.0.0.1'))
self.assertFalse(netscaler.server_update('serGrpName', ''))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.server_update('serGrpName', '1.0.0.1'))
mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.server_update('serGrpName', '1.0.0.1'))
|
'Tests if it check if a server is enabled globally'
| def test_server_enabled(self):
| mock = MagicMock(return_value=MockNSServer())
with patch.object(netscaler, '_server_get', mock):
MockNSServer.flag = None
self.assertTrue(netscaler.server_enabled('serGrpName'))
|
'Tests if it enables a server globally'
| def test_server_enable(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.server_enable('serGrpName'))
MockNSServer.flag = 1
self.assertTrue(netscaler.server_enable('serGrpName'))
mock = MagicMock(side_effect=[MockNSServer(), None])
with patch.object(netscaler, '_server_get', mock):
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.server_enable('serGrpName'))
self.assertFalse(netscaler.server_enable('serGrpName'))
|
'Tests if it disable a server globally'
| def test_server_disable(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.server_disable('serGrpName'))
MockNSServer.flag = 2
self.assertTrue(netscaler.server_disable('serGrpName'))
MockNSServer.flag = None
mock = MagicMock(side_effect=[None, MockNSServer()])
with patch.object(netscaler, '_server_get', mock):
self.assertFalse(netscaler.server_disable('serGrpName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.server_disable('serGrpName'))
|
'Tests if it checks if a vserver exists'
| def test_vserver_exists(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.vserver_exists('vserverName'))
self.assertFalse(netscaler.vserver_exists('vserverName', v_ip='1.0.0.1'))
self.assertFalse(netscaler.vserver_exists('vserrName', v_ip='', v_port='vserverPort'))
self.assertFalse(netscaler.vserver_exists('vserrName', v_ip='', v_port='', v_type='vserverType'))
mock = MagicMock(return_value=None)
with patch.object(netscaler, '_vserver_get', mock):
self.assertFalse(netscaler.vserver_exists('vserverName'))
|
'Tests if it add a new lb vserver'
| def test_vserver_add(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertFalse(netscaler.vserver_add('alex.patate.chaude.443', '1.2.3.4', '443', 'SSL'))
mock = MagicMock(return_value=False)
with patch.object(netscaler, 'vserver_exists', mock):
self.assertTrue(netscaler.vserver_add('alex.pae.chaude.443', '1.2.3.4', '443', 'SSL'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.vserver_add('alex.chde.443', '1.2.3.4', '443', 'SSL'))
|
'Tests if it delete a new lb vserver'
| def test_vserver_delete(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.vserver_delete('alex.pe.chaude.443'))
mock = MagicMock(side_effect=[None, MockNSLBVServer()])
with patch.object(netscaler, '_vserver_get', mock):
self.assertFalse(netscaler.vserver_delete('alex.chade.443'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.vserver_delete('al.cha.443'))
|
'Tests if it checks if a servicegroup is tied to a vserver'
| def test_vser_sergrp_exists(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.vserver_servicegroup_exists('vserverName', 'serviceGroupName'))
|
'Tests if it bind a servicegroup to a vserver'
| def test_vserver_servicegroup_add(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
MockNSNitro.flag = None
self.assertTrue(netscaler.vserver_servicegroup_add('vserverName', 'serGroupName'))
mock = MagicMock(side_effect=[MockNSLBVServerServiceGroupBinding(), None])
with patch.object(netscaler, 'vserver_servicegroup_exists', mock):
self.assertFalse(netscaler.vserver_servicegroup_add('vserName', 'serGroupName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.vserver_servicegroup_add('vName', 'serGroupName'))
|
'Tests if it unbind a servicegroup from a vserver'
| def test_vser_sergrp_delete(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertFalse(netscaler.vserver_servicegroup_delete('vservName', 'serGroupName'))
mock = MagicMock(return_value=MockNSLBVServerServiceGroupBinding())
with patch.object(netscaler, 'vserver_servicegroup_exists', mock):
MockNSNitro.flag = None
self.assertTrue(netscaler.vserver_servicegroup_delete('vName', 'serGroupName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.vserver_servicegroup_delete('vserverName', 'serGroupName'))
|
'Tests if it checks if a SSL certificate is tied to a vserver'
| def test_vserver_sslcert_exists(self):
| mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
self.assertTrue(netscaler.vserver_sslcert_exists('vserverName', 'serviceGroupName'))
|
'Tests if it binds a SSL certificate to a vserver'
| def test_vserver_sslcert_add(self):
| mock = MagicMock(side_effect=[MockNSSSLVServerSSLCertKeyBinding(), None, None])
with patch.object(netscaler, 'vserver_sslcert_exists', mock):
self.assertFalse(netscaler.vserver_sslcert_add('vserName', 'serGroupName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.vserver_sslcert_add('vName', 'serGrName'))
mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
MockNSNitro.flag = None
self.assertTrue(netscaler.vserver_sslcert_add('vserverName', 'serGroupName'))
|
'Tests if it unbinds a SSL certificate from a vserver'
| def test_vserver_sslcert_delete(self):
| mock = MagicMock(side_effect=[None, MockNSSSLVServerSSLCertKeyBinding(), MockNSSSLVServerSSLCertKeyBinding()])
with patch.object(netscaler, 'vserver_sslcert_exists', mock):
self.assertFalse(netscaler.vserver_sslcert_delete('vName', 'serGrpName'))
mock = MagicMock(return_value='')
with patch.dict(netscaler.__salt__, {'config.option': mock}):
MockNSNitro.flag = None
self.assertTrue(netscaler.vserver_sslcert_delete('vservName', 'serGroupName'))
with patch.object(netscaler, '_connect', MagicMock(return_value=None)):
self.assertFalse(netscaler.vserver_sslcert_delete('vserverName', 'serGroupName'))
|
'Test installing a capability with DISM'
| def test_add_capability(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
with patch.dict(dism.__grains__, {'osversion': 10}):
dism.add_capability('test')
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Add-Capability', '/CapabilityName:test', '/NoRestart'])
|
'Test installing a capability with DISM'
| def test_add_capability_with_extras(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
with patch.dict(dism.__grains__, {'osversion': 10}):
dism.add_capability('test', 'life', True)
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Add-Capability', '/CapabilityName:test', '/Source:life', '/LimitAccess', '/NoRestart'])
|
'Test uninstalling a capability with DISM'
| def test_remove_capability(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
with patch.dict(dism.__grains__, {'osversion': 10}):
dism.remove_capability('test')
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Remove-Capability', '/CapabilityName:test', '/NoRestart'])
|
'Test getting all the capabilities'
| def test_get_capabilities(self):
| capabilties = 'Capability Identity : Capa1\r\n State : Installed\r\nCapability Identity : Capa2\r\n State : Disabled\r\n'
mock = MagicMock(return_value=capabilties)
with patch.dict(dism.__salt__, {'cmd.run': mock}):
with patch.dict(dism.__grains__, {'osversion': 10}):
out = dism.get_capabilities()
mock.assert_called_once_with(['DISM', '/English', '/Online', '/Get-Capabilities'])
self.assertEqual(out, ['Capa1', 'Capa2'])
|
'Test getting all the installed capabilities'
| def test_installed_capabilities(self):
| capabilties = 'Capability Identity : Capa1\r\n State : Installed\r\nCapability Identity : Capa2\r\n State : Disabled\r\n'
mock = MagicMock(return_value=capabilties)
with patch.dict(dism.__salt__, {'cmd.run': mock}):
with patch.dict(dism.__grains__, {'osversion': 10}):
out = dism.installed_capabilities()
mock.assert_called_once_with(['DISM', '/English', '/Online', '/Get-Capabilities'])
self.assertEqual(out, ['Capa1'])
|
'Test getting all the available capabilities'
| def test_available_capabilities(self):
| capabilties = 'Capability Identity : Capa1\r\n State : Installed\r\nCapability Identity : Capa2\r\n State : Not Present\r\n'
mock = MagicMock(return_value=capabilties)
with patch.dict(dism.__salt__, {'cmd.run': mock}):
with patch.dict(dism.__grains__, {'osversion': 10}):
out = dism.available_capabilities()
mock.assert_called_once_with(['DISM', '/English', '/Online', '/Get-Capabilities'])
self.assertEqual(out, ['Capa2'])
|
'Test installing a feature with DISM'
| def test_add_feature(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
dism.add_feature('test')
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Enable-Feature', '/FeatureName:test', '/NoRestart'])
|
'Test installing a feature with DISM'
| def test_add_feature_with_extras(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
dism.add_feature('sponge', 'bob', 'C:\\temp', True, True)
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Enable-Feature', '/FeatureName:sponge', '/PackageName:bob', '/Source:C:\\temp', '/LimitAccess', '/All', '/NoRestart'])
|
'Test uninstalling a capability with DISM'
| def test_remove_feature(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
dism.remove_feature('test')
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Disable-Feature', '/FeatureName:test', '/NoRestart'])
|
'Test uninstalling a capability with DISM'
| def test_remove_feature_with_extras(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
dism.remove_feature('sponge', True)
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Disable-Feature', '/FeatureName:sponge', '/Remove', '/NoRestart'])
|
'Test getting all the features'
| def test_get_features(self):
| features = 'Feature Name : Capa1\r\n State : Enabled\r\nFeature Name : Capa2\r\n State : Disabled\r\n'
mock = MagicMock(return_value=features)
with patch.dict(dism.__salt__, {'cmd.run': mock}):
out = dism.get_features()
mock.assert_called_once_with(['DISM', '/English', '/Online', '/Get-Features'])
self.assertEqual(out, ['Capa1', 'Capa2'])
|
'Test getting all the installed features'
| def test_installed_features(self):
| features = 'Feature Name : Capa1\r\n State : Enabled\r\nFeature Name : Capa2\r\n State : Disabled\r\n'
mock = MagicMock(return_value=features)
with patch.dict(dism.__salt__, {'cmd.run': mock}):
out = dism.installed_features()
mock.assert_called_once_with(['DISM', '/English', '/Online', '/Get-Features'])
self.assertEqual(out, ['Capa1'])
|
'Test getting all the available features'
| def test_available_features(self):
| features = 'Feature Name : Capa1\r\n State : Enabled\r\nFeature Name : Capa2\r\n State : Disabled\r\n'
mock = MagicMock(return_value=features)
with patch.dict(dism.__salt__, {'cmd.run': mock}):
out = dism.available_features()
mock.assert_called_once_with(['DISM', '/English', '/Online', '/Get-Features'])
self.assertEqual(out, ['Capa2'])
|
'Test installing a package with DISM'
| def test_add_package(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
dism.add_package('test')
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Add-Package', '/PackagePath:test', '/NoRestart'])
|
'Test installing a package with DISM'
| def test_add_package_with_extras(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
dism.add_package('sponge', True, True)
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Add-Package', '/PackagePath:sponge', '/IgnoreCheck', '/PreventPending', '/NoRestart'])
|
'Test uninstalling a package with DISM'
| def test_remove_package(self):
| mock = MagicMock()
with patch.dict(dism.__salt__, {'cmd.run_all': mock}):
dism.remove_package('test')
mock.assert_called_once_with(['DISM', '/Quiet', '/Online', '/Remove-Package', '/NoRestart', '/PackagePath:test'])
|
'Test getting all the installed features'
| def test_installed_packages(self):
| features = 'Package Identity : Capa1\r\n State : Installed\r\nPackage Identity : Capa2\r\n State : Installed\r\n'
mock = MagicMock(return_value=features)
with patch.dict(dism.__salt__, {'cmd.run': mock}):
out = dism.installed_packages()
mock.assert_called_once_with(['DISM', '/English', '/Online', '/Get-Packages'])
self.assertEqual(out, ['Capa1', 'Capa2'])
|
'Test for Returns bridges interfaces
along with enslaved physical interfaces'
| def test_show(self):
| mock = MagicMock(return_value=True)
with patch.object(bridge, '_os_dispatch', mock):
self.assertTrue(bridge.show('br'))
|
'Test for Returns the machine\'s bridges list'
| def test_list_(self):
| mock = MagicMock(return_value=None)
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.list_(), None)
mock = MagicMock(return_value=['A', 'B'])
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.list_(), ['A', 'B'])
|
'Test for Returns interfaces attached to a bridge'
| def test_interfaces(self):
| self.assertEqual(bridge.interfaces(), None)
mock = MagicMock(return_value={'interfaces': 'A'})
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.interfaces('br'), 'A')
|
'Test for Returns the bridge to which the interfaces are bond to'
| def test_find_interfaces(self):
| mock = MagicMock(return_value=None)
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.find_interfaces(), None)
mock = MagicMock(return_value={'interfaces': 'A'})
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.find_interfaces(), {})
|
'Test for Creates a bridge'
| def test_add(self):
| mock = MagicMock(return_value='A')
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.add(), 'A')
|
'Test for Deletes a bridge'
| def test_delete(self):
| mock = MagicMock(return_value='A')
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.delete(), 'A')
|
'Test for Adds an interface to a bridge'
| def test_addif(self):
| mock = MagicMock(return_value='A')
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.addif(), 'A')
|
'Test for Removes an interface from a bridge'
| def test_delif(self):
| mock = MagicMock(return_value='A')
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.delif(), 'A')
|
'Test for Sets Spanning Tree Protocol state for a bridge'
| def test_stp(self):
| with patch.dict(bridge.__grains__, {'kernel': 'Linux'}):
mock = MagicMock(return_value='Linux')
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.stp(), 'Linux')
with patch.dict(bridge.__grains__, {'kernel': 'FreeBSD'}):
mock = MagicMock(return_value='FreeBSD')
with patch.object(bridge, '_os_dispatch', mock):
self.assertEqual(bridge.stp(), 'FreeBSD')
with patch.dict(bridge.__grains__, {'kernel': None}):
self.assertFalse(bridge.stp())
|
'Mock load method'
| @staticmethod
def loads(data, object_hook):
| if MockJson.flag:
return (data, object_hook)
else:
raise ValueError
|
'Test if create the named vm'
| def test_create(self):
| MockJson.flag = True
mock = MagicMock(return_value=True)
with patch.dict(saltcloudmod.__salt__, {'cmd.run_stdout': mock}):
self.assertTrue(saltcloudmod.create('webserver', 'rackspace_centos_512'))
MockJson.flag = False
self.assertDictEqual(saltcloudmod.create('webserver', 'rackspace_centos_512'), {})
|
'Tests to return System information'
| def test_system_info(self):
| mock = MagicMock(return_value={'retcode': 0, 'stdout': None})
with patch.dict(drac.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value='ABC')
with patch.object(drac, '__parse_drac', mock):
self.assertEqual(drac.system_info(), 'ABC')
|
'Tests to return Network Configuration'
| def test_network_info(self):
| mock = MagicMock(return_value={'retcode': 0, 'stdout': None})
with patch.dict(drac.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value='ABC')
with patch.object(drac, '__parse_drac', mock):
self.assertEqual(drac.network_info(), 'ABC')
|
'tests for configure the nameservers on the DRAC'
| def test_nameservers(self):
| self.assertFalse(drac.nameservers('a', 'b', 'c'))
mock = MagicMock(return_value=False)
with patch.object(drac, '__execute_cmd', mock):
self.assertFalse(drac.nameservers('a'))
mock = MagicMock(return_value=True)
with patch.object(drac, '__execute_cmd', mock):
self.assertTrue(drac.nameservers('a'))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.