def test_remove_interfaces_from_vm_with_filter(self):
# arrange
device1 = Mock(spec=vim.vm.device.VirtualEthernetCard)
device2 = Mock(spec=vim.vm.device.VirtualEthernetCard)
device3 = Mock(spec=vim.vm.device.VirtualSoundCard)
device1.name = 'this is the one'
device2.name = 'very close'
device3.name = 'not it'
vm = Mock()
vm.config = Mock()
vm.config.hardware()
vm.config.hardware.device = [device3, device2, device1]
connector = VirtualSwitchToMachineDisconnectCommand(
Mock(), Mock(), 'anetwork')
#connector.remove_devices = Mock(return_value=True)
# act
condition = lambda device: device.name == device1.name
res = connector.remove_interfaces_from_vm_task(vm, condition)
# assert
self.assertTrue(res)
def integrationtest_remove_interface(self):
default_network = None
connector = VirtualSwitchToMachineDisconnectCommand(self.py_vmomi_service,
self.resource_connection_details_retriever,
self.configurer,
default_network)
vm = self.get_vm(self.py_vmomi_service, self.virtual_machine_name)
print "Remove vNIC. Machine: '{}' UUID: [{}]".format(self.virtual_machine_name, self.vm_uuid)
task = connector.remove_interfaces_from_vm_task(vm)
self.synchronous_task_waiter.wait_for_task(task, Mock())
def integrationtest_all_disconnect(self):
default_network = None
connector = VirtualSwitchToMachineDisconnectCommand(self.py_vmomi_service,
self.resource_connection_details_retriever,
self.configurer,
default_network)
self.vm_uuid = self.vm_uuid or self.get_vm_uuid(self.py_vmomi_service, self.virtual_machine_name)
print "DISCONNECT ALL. Machine: '{}' UUID: [{}]".format(self.virtual_machine_name, self.vm_uuid)
result = connector.disconnect_all(self.vcenter_name, self.vm_uuid)
print result
def test_integrationtest_disconnect(self):
default_network = None
connector = VirtualSwitchToMachineDisconnectCommand(self.py_vmomi_service,
self.configurer,
default_network)
self.vm_uuid = self.vm_uuid or self.get_vm_uuid(self.py_vmomi_service, self.virtual_machine_name)
print "DISCONNECT. Machine: '{}' UUID: [{}]".format(self.virtual_machine_name, self.vm_uuid)
#result = connector.disconnect(self.vcenter_name, self.vm_uuid, self.dv_port_group_name)
result = connector.disconnect(self.vcenter_name, self.vm_uuid, self.standard_network_name)
print result
def test_remove_interfaces_from_vm_no_nic_found(self):
# arrange
vm = Mock()
vm.config = Mock()
vm.config.hardware()
vm.config.hardware.device = []
virtual_switch_to_machine_connector = VirtualSwitchToMachineDisconnectCommand(Mock(), Mock(), 'anetwork')
# act
res = virtual_switch_to_machine_connector.remove_interfaces_from_vm_task(vm)
# assert
self.assertIsNone(res)
def test_remove_interfaces_from_vm_no_nic_found(self):
# arrange
vm = Mock()
vm.config = Mock()
vm.config.hardware()
vm.config.hardware.device = []
virtual_switch_to_machine_connector = VirtualSwitchToMachineDisconnectCommand(
Mock(), Mock(), 'anetwork')
# act
res = virtual_switch_to_machine_connector.remove_interfaces_from_vm_task(
vm)
# assert
self.assertIsNone(res)
def test_remove_interfaces_from_vm_no_filter(self):
# arrange
device1 = Mock(spec=vim.vm.device.VirtualEthernetCard)
device2 = Mock(spec=vim.vm.device.VirtualSoundCard)
vm = Mock()
vm.config = Mock()
vm.config.hardware()
vm.config.hardware.device = [device2, device1]
virtual_switch_to_machine_connector = VirtualSwitchToMachineDisconnectCommand(Mock(), Mock(), 'anetwork')
# act
res = virtual_switch_to_machine_connector.remove_interfaces_from_vm_task(vm)
# assert
self.assertTrue(res)
def test_remove_interfaces_from_vm_no_filter(self):
# arrange
device1 = Mock(spec=vim.vm.device.VirtualEthernetCard)
device2 = Mock(spec=vim.vm.device.VirtualSoundCard)
vm = Mock()
vm.config = Mock()
vm.config.hardware()
vm.config.hardware.device = [device2, device1]
virtual_switch_to_machine_connector = VirtualSwitchToMachineDisconnectCommand(
Mock(), Mock(), 'anetwork')
# act
res = virtual_switch_to_machine_connector.remove_interfaces_from_vm_task(
vm)
# assert
self.assertTrue(res)
def test_delete(self):
# arrange
uuid = 'uuid'
network_name = 'network_name'
network = Mock()
network.name = network_name
si = Mock()
vm = Mock()
vm.network = [network]
connection_detail = Mock()
connection_detail.host = Mock()
connection_detail.username = Mock()
connection_detail.password = Mock()
connection_detail.port = Mock()
pv_service = Mock()
pv_service.connect = Mock(return_value=si)
pv_service.find_by_uuid = Mock(return_value=vm)
connector = VirtualSwitchToMachineDisconnectCommand(
pv_service, Mock(), 'anetwork')
vcenter_data_model = VMwarevCenterResourceModel()
# act
res = connector.disconnect(si=si,
logger=Mock(),
vcenter_data_model=vcenter_data_model,
vm_uuid=uuid,
network_name=network_name)
# assert
self.assertTrue(
pv_service.connect.called_with(connection_detail.host,
connection_detail.username,
connection_detail.password,
connection_detail.port))
self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid))
self.assertTrue(res)
def test_delete_all(self):
# arrange
uuid = 'uuid'
si = Mock()
vm = Mock()
connection_detail = Mock()
connection_detail.host = Mock()
connection_detail.username = Mock()
connection_detail.password = Mock()
connection_detail.port = Mock()
pv_service = Mock()
pv_service.connect = Mock(return_value=si)
pv_service.find_by_uuid = Mock(return_value=vm)
connector = VirtualSwitchToMachineDisconnectCommand(
pv_service, Mock(), 'anetwork')
# virtual_switch_to_machine_connector.remove_interfaces_from_vm = Mock(return_value=True)
connector.get_network_by_name = lambda x, y: Mock()
vcenter_data_model = VMwarevCenterResourceModel()
# act
res = connector.disconnect(si=si,
logger=Mock(),
vcenter_data_model=vcenter_data_model,
vm_uuid=uuid,
network_name=None,
vm=None)
# assert
self.assertTrue(
pv_service.connect.called_with(connection_detail.host,
connection_detail.username,
connection_detail.password,
connection_detail.port))
self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid))
# self.assertTrue(virtual_switch_to_machine_connector.remove_interfaces_from_vm.called_with(vm))
self.assertTrue(res)
def test_delete(self):
# arrange
uuid = 'uuid'
network_name = 'network_name'
network = Mock()
network.name = network_name
si = Mock()
vm = Mock()
vm.network = [network]
connection_detail = Mock()
connection_detail.host = Mock()
connection_detail.username = Mock()
connection_detail.password = Mock()
connection_detail.port = Mock()
pv_service = Mock()
pv_service.connect = Mock(return_value=si)
pv_service.find_by_uuid = Mock(return_value=vm)
connector = VirtualSwitchToMachineDisconnectCommand(pv_service, Mock(), 'anetwork')
vcenter_data_model = VMwarevCenterResourceModel()
# act
res = connector.disconnect(si=si,
logger=Mock(),
vcenter_data_model=vcenter_data_model,
vm_uuid= uuid,
network_name=network_name)
# assert
self.assertTrue(pv_service.connect.called_with(connection_detail.host,
connection_detail.username,
connection_detail.password,
connection_detail.port))
self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid))
self.assertTrue(res)
def test_is_device_match_network_not_found(self):
# arrange
device = Mock()
device.backing = Mock(spec=[])
virtual_switch_to_machine_connector = VirtualSwitchToMachineDisconnectCommand(
Mock(), Mock(), 'anetwork')
# act
# res = virtual_switch_to_machine_connector.is_device_match_network(device, 'Fake name')
res = VNicService.device_is_attached_to_network(device, 'Fake name')
# assert
self.assertFalse(res)
def test_delete_all(self):
# arrange
uuid = 'uuid'
si = Mock()
vm = Mock()
connection_detail = Mock()
connection_detail.host = Mock()
connection_detail.username = Mock()
connection_detail.password = Mock()
connection_detail.port = Mock()
pv_service = Mock()
pv_service.connect = Mock(return_value=si)
pv_service.find_by_uuid = Mock(return_value=vm)
connector = VirtualSwitchToMachineDisconnectCommand(pv_service, Mock(), 'anetwork')
# virtual_switch_to_machine_connector.remove_interfaces_from_vm = Mock(return_value=True)
connector.get_network_by_name = lambda x, y: Mock()
vcenter_data_model = VMwarevCenterResourceModel()
# act
res = connector.disconnect(si=si,
logger=Mock(),
vcenter_data_model=vcenter_data_model,
vm_uuid=uuid,
network_name=None,
vm=None)
# assert
self.assertTrue(pv_service.connect.called_with(connection_detail.host,
connection_detail.username,
connection_detail.password,
connection_detail.port))
self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid))
# self.assertTrue(virtual_switch_to_machine_connector.remove_interfaces_from_vm.called_with(vm))
self.assertTrue(res)
def test_remove_interfaces_from_vm_with_filter(self):
# arrange
device1 = Mock(spec=vim.vm.device.VirtualEthernetCard)
device2 = Mock(spec=vim.vm.device.VirtualEthernetCard)
device3 = Mock(spec=vim.vm.device.VirtualSoundCard)
device1.name = 'this is the one'
device2.name = 'very close'
device3.name = 'not it'
vm = Mock()
vm.config = Mock()
vm.config.hardware()
vm.config.hardware.device = [device3, device2, device1]
connector = VirtualSwitchToMachineDisconnectCommand(Mock(), Mock(), 'anetwork')
#connector.remove_devices = Mock(return_value=True)
# act
condition = lambda device: device.name == device1.name
res = connector.remove_interfaces_from_vm_task(vm, condition)
# assert
self.assertTrue(res)
def __init__(self):
"""
Initialize the driver session, this function is called everytime a new instance of the driver is created
in here the driver is going to be bootstrapped
:param context: models.QualiDriverModels.InitCommandContext
"""
self.cs_helper = CloudshellDriverHelper()
synchronous_task_waiter = SynchronousTaskWaiter()
pv_service = pyVmomiService(connect=SmartConnect,
disconnect=Disconnect,
task_waiter=synchronous_task_waiter)
self.resource_model_parser = ResourceModelParser()
port_group_name_generator = DvPortGroupNameGenerator()
vnic_to_network_mapper = VnicToNetworkMapper(
quali_name_generator=port_group_name_generator)
resource_remover = CloudshellResourceRemover()
ovf_service = OvfImageDeployerService(self.resource_model_parser)
self.vm_loader = VMLoader(pv_service)
vm_deployer = VirtualMachineDeployer(
pv_service=pv_service,
name_generator=generate_unique_name,
ovf_service=ovf_service,
cs_helper=self.cs_helper,
resource_model_parser=ResourceModelParser())
dv_port_group_creator = DvPortGroupCreator(
pyvmomi_service=pv_service,
synchronous_task_waiter=synchronous_task_waiter)
virtual_machine_port_group_configurer = \
VirtualMachinePortGroupConfigurer(pyvmomi_service=pv_service,
synchronous_task_waiter=synchronous_task_waiter,
vnic_to_network_mapper=vnic_to_network_mapper,
vnic_service=VNicService(),
name_gen=port_group_name_generator)
virtual_switch_to_machine_connector = VirtualSwitchToMachineConnector(
dv_port_group_creator, virtual_machine_port_group_configurer)
# Command Wrapper
self.command_wrapper = CommandWrapper(
pv_service=pv_service,
cloud_shell_helper=self.cs_helper,
resource_model_parser=self.resource_model_parser,
context_based_logger_factory=ContextBasedLoggerFactory())
# Deploy Command
self.deploy_command = DeployCommand(deployer=vm_deployer)
# Virtual Switch Revoke
self.virtual_switch_disconnect_command = \
VirtualSwitchToMachineDisconnectCommand(
pyvmomi_service=pv_service,
port_group_configurer=virtual_machine_port_group_configurer,
resource_model_parser=self.resource_model_parser)
# Virtual Switch Connect
virtual_switch_connect_command = \
VirtualSwitchConnectCommand(
pv_service=pv_service,
virtual_switch_to_machine_connector=virtual_switch_to_machine_connector,
dv_port_group_name_generator=DvPortGroupNameGenerator(),
vlan_spec_factory=VlanSpecFactory(),
vlan_id_range_parser=VLanIdRangeParser())
self.connection_orchestrator = ConnectionCommandOrchestrator(
connector=virtual_switch_connect_command,
disconnector=self.virtual_switch_disconnect_command,
resource_model_parser=self.resource_model_parser)
# Destroy VM Command
self.destroy_virtual_machine_command = \
DestroyVirtualMachineCommand(pv_service=pv_service,
resource_remover=resource_remover,
disconnector=self.virtual_switch_disconnect_command)
# Power Command
self.vm_power_management_command = \
VirtualMachinePowerManagementCommand(pyvmomi_service=pv_service,
synchronous_task_waiter=synchronous_task_waiter)
ip_manager = VMIPManager()
# Refresh IP command
self.refresh_ip_command = RefreshIpCommand(
pyvmomi_service=pv_service,
resource_model_parser=ResourceModelParser(),
ip_manager=ip_manager)
# Save Snapshot
self.snapshot_saver = SaveSnapshotCommand(
pyvmomi_service=pv_service, task_waiter=synchronous_task_waiter)
# Snapshot Restorer
self.snapshot_restorer = SnapshotRestoreCommand(
pyvmomi_service=pv_service, task_waiter=synchronous_task_waiter)
self.snapshots_retriever = RetrieveSnapshotsCommand(
pyvmomi_service=pv_service)
