def test_check_output(self): self.patch_object(generic_utils, 'logging', name='mock_logging') async def mock_communicate(): return (b"output log", b"error log") mock_proc = mock.Mock(communicate=mock_communicate, returncode=0) async def mock_create_subprocess_exec(*args, **kwargs): return mock_proc self.patch_object(generic_utils.asyncio, 'create_subprocess_exec', side_effect=mock_create_subprocess_exec) check_call = zaza.sync_wrapper(generic_utils.check_output) expected = { 'Code': str(mock_proc.returncode), 'Stderr': "error log", 'Stdout': "output log", } self.assertEqual(check_call(['a', 'command']), expected) # check for raising an error mock_proc.returncode = 5 expected = { 'Code': str(mock_proc.returncode), 'Stderr': "error log", 'Stdout': "output log", } self.subprocess.CalledProcessError = subprocess.CalledProcessError try: check_call(['a', 'command']) except subprocess.CalledProcessError: pass
def test_get_machine_interfaces(self): async def af(): async for machine, interface in maas.async_get_machine_interfaces( self.maas_client): if machine == self.machine1: self.assertIn(interface, (self.m1_interface1, self.m1_interface2)) elif machine == self.machine2: self.assertIn(interface, (self.m2_interface1, self.m2_interface2)) else: self.assertIn(machine, (self.machine1, self.machine2)) f = zaza.sync_wrapper(af) f()
def test_check_call(self): async def async_check_output(*args, **kwargs): return "hello" self.patch_object(generic_utils, 'check_output', side_effect=async_check_output) check_call = zaza.sync_wrapper(generic_utils.check_call) check_call("a command") self.check_output.assert_called_once_with('a command', log_stdout=True, log_stderr=True) self.check_output.reset_mock() check_call("b command", log_stdout=False) self.check_output.assert_called_once_with('b command', log_stdout=False, log_stderr=True) self.check_output.reset_mock() check_call("c command", log_stderr=False) self.check_output.assert_called_once_with('c command', log_stdout=True, log_stderr=False)
"""Add a model to the current controller. :param model_name: Name to give the new model. :type model_name: str :param config: Model configuration. :type config: dict """ controller = Controller() await controller.connect() logging.debug("Adding model {}".format(model_name)) model = await controller.add_model(model_name, config=config) await model.disconnect() await controller.disconnect() add_model = sync_wrapper(async_add_model) async def async_destroy_model(model_name): """Remove a model from the current controller. :param model_name: Name of model to remove :type model_name: str """ controller = Controller() await controller.connect() logging.debug("Destroying model {}".format(model_name)) await controller.destroy_model(model_name) await controller.disconnect()
async def async_get_maas_client(maas_url, apikey): """Get a connected MAAS client. :param maas_url: URL to MAAS API. :type maas_url: str :param apikey: MAAS API Key for authentication. :type apikey: str :returns: Connected MAAS client. :rtpye: maas.client.facade.Client object. """ return await maas.client.connect(maas_url, apikey=apikey) get_maas_client = zaza.sync_wrapper(async_get_maas_client) @async_generator async def async_get_machine_interfaces(maas_client, machine_id=None, link_mode=None, cidr=None): """Get machine and interface objects, optionally apply filters. :param maas_client: MAAS Client object. :type maas_client: maas.client.facade.Client :param machine_id: ID of a specific machine to get information on. :type machine_id: Optional[str] :param link_mode: Only return interfaces with this link_mode. :type link_mode: Optional[LinkMode]
async def deployed(): """List deployed applications.""" # Create a Model instance. We need to connect our Model to a Juju api # server before we can use it. model = Model() # Connect to the currently active Juju model await model.connect_current() try: # list currently deploeyd services return list(model.applications.keys()) finally: # Disconnect from the api server and cleanup. await model.disconnect() sync_deployed = sync_wrapper(deployed) def get_unit_from_name(unit_name, model=None, model_name=None): """Return the units that corresponds to the name in the given model. :param unit_name: Name of unit to match :type unit_name: str :param model: Model to perform lookup in :type model: model.Model() :param model_name: Name of the model to perform lookup in :type model_name: string :returns: Unit matching given name :rtype: juju.unit.Unit or None :raises: UnitNotFound """
:param units: List of unit names. :type units: [] :param model_name: Name of model to query. :type model_name: str :rtype: juju.action.Action :raises: zaza.model.ActionFailed """ logging.info("Pausing {}".format(', '.join(units))) await zaza.model.async_run_action_on_units(units, 'pause', model_name=model_name, raise_on_failure=True) pause_units = sync_wrapper(async_pause_units) async def async_resume_units(units, model_name=None): """Resume all units in unit list. Resume all units in unit list. Wait for resume action to complete. :param units: List of unit names. :type units: [] :param model_name: Name of model to query. :type model_name: str :rtype: juju.action.Action :raises: zaza.model.ActionFailed """