def test__run__pass(file_with_instance, stack, test): e = file_with_instance name, path, success = stack e.instance.deployment_name = name e.instance.sut = SUT('service', 'sut', '{}_sut'.format(name)) set_test_data(e, test) e.run_test()
def test__run__network_context__pass(command_with_instance, stack, data): e = command_with_instance name, path, success = stack e.instance.deployment_name = name e.instance.sut = SUT('network', 'm2m', '{}_m2m'.format(name)) test = data.get('test') set_test_data(e, test) e.run_test()
def test__run__pass(command_with_instance, stack, data): e = command_with_instance name, path, success = stack e.instance.deployment_name = name e.instance.sut = SUT('service', 'sut', '{}_sut'.format(name)) test = data.get('test') set_test_data(e, test) e.run_test()
def __init__(self): DynamicCore.__init__(self, []) self.ROBOT_LIBRARY_LISTENER = self # inputs self.descriptor_file = None self.suite_source = None self.parsed_descriptor = None # Suite config self.deployment_name = None self.orchestrator = None # Test case config self.sut = SUT(None, None, None) self.deployment_options = { 'SKIP_UNDEPLOY': False, 'USE_DEPLOYMENT': None } self.test_volume = None self.sidecar = None self.services = [] self.containers = [] # keep state of test self.context = None self.test_cases = [] self.current_keywords = [] self.fatal_error = False self.validation_attempted = False try: self.deployment_options['USE_DEPLOYMENT'] = \ (Settings.use_deployment or BuiltIn().get_variable_value("${USE_DEPLOYMENT}") or '').strip('\'') if (self.deployment_options['USE_DEPLOYMENT'] or BuiltIn().get_variable_value("${SKIP_UNDEPLOY}") or Settings.skip_undeploy): self.deployment_options['SKIP_UNDEPLOY'] = True except RobotNotRunningError: pass
def test__run__pass(placement_with_instance, stack, data): e = placement_with_instance name, path, success = stack e.instance.deployment_name = name e.instance.sut = SUT(target_type='service', target=name + '_sut', service_id=name + '_sut') test = data.get('test') set_test_data(e, test) e.run_test()
def test__run__service_context__pass(port_with_instance, stack, volume_with_goss, test, data, mapped, out): e = port_with_instance name, path, success = stack service = name + '_sut' container = e.instance.orchestrator.controller.get_containers_for_service( service)[0] e.instance.deployment_name = name e.instance.sut = SUT(target_type='service', target=container.name, service_id=service) e.instance.test_volume = volume_with_goss set_test_data(e, test.get('test'))
def goss_sut_service(stack, containers): return SUT( target_type='service', target=containers[0].name, service_id=stack[0] )
def dummy_sut(): return SUT(target_type='service', target='', service_id='')
def sut(container): return SUT(target_type='service', target=container.name, service_id=container.name)
def test__get_container_labels__fail(dockertool): dockertool.sut = SUT('bla', 'bla', 'bla') # Test with pytest.raises(NotFoundError): dockertool.get_container_labels()
def sut(context='service'): return SUT(context, 'sut', 'bla')
class VnfValidator(DynamicCore): """ The VnfValidator is the base library that contains low-level keywords for the VNF Robot. The class implements the DynamicCore interface provided by the Robot Framework. For every test suite, one instance of the class is created. """ ROBOT_LIBRARY_SCOPE = 'TEST SUITE' ROBOT_LISTENER_API_VERSION = 2 __version__ = VERSION def __init__(self): DynamicCore.__init__(self, []) self.ROBOT_LIBRARY_LISTENER = self # inputs self.descriptor_file = None self.suite_source = None self.parsed_descriptor = None # Suite config self.deployment_name = None self.orchestrator = None # Test case config self.sut = SUT(None, None, None) self.deployment_options = { 'SKIP_UNDEPLOY': False, 'USE_DEPLOYMENT': None } self.test_volume = None self.sidecar = None self.services = [] self.containers = [] # keep state of test self.context = None self.test_cases = [] self.current_keywords = [] self.fatal_error = False self.validation_attempted = False try: self.deployment_options['USE_DEPLOYMENT'] = \ (Settings.use_deployment or BuiltIn().get_variable_value("${USE_DEPLOYMENT}") or '').strip('\'') if (self.deployment_options['USE_DEPLOYMENT'] or BuiltIn().get_variable_value("${SKIP_UNDEPLOY}") or Settings.skip_undeploy): self.deployment_options['SKIP_UNDEPLOY'] = True except RobotNotRunningError: pass # noinspection PyUnusedLocal def _start_suite(self, name, attrs): """ Listener method by the Robot Framework that is called when on suite setup. Args: name: name of the suite attrs: attributes of the suite Returns: None """ self.suite_source = attrs.get('source', None) self.descriptor_file = BuiltIn().get_variable_value( "${DESCRIPTOR}") or 'docker-compose.yml' # parse robot file self.parsed_descriptor = parser.RobotFactory(self.suite_source) self.test_cases = [t for t in self.parsed_descriptor.testcases] assert self.test_cases, "A robot file should contain test cases." # comment out check of test steps # if not self._check_test_steps(): # return try: BuiltIn().log('\nOptions: {}'.format(self.deployment_options), level='INFO', console=True) self.orchestrator = DockerOrchestrator(self) self.orchestrator.get_or_create_deployment() except SetupError as exc: BuiltIn().log('_start_suite: {}'.format(exc), level='ERROR') self.fatal_error = True def _check_test_steps(self): """ Helper method to check if for every test case in the suite, there is at least one command for setting the context and one validation statement Returns: True: if the conditions are met False: if the conditions are not met """ for test_case in self.test_cases: context_steps_count = len([ step for step in test_case.steps if len(step) > 1 and 'context' in step[1] ]) if (len(test_case.steps) - context_steps_count) < 1: BuiltIn().log( '_start_suite: Error with Test case: \n"{}"\n' 'Every test case requires at least ONE context statement and ONE validation statement' .format(test_case.name), level='ERROR') self.fatal_error = True return False return True # noinspection PyUnusedLocal def _end_suite(self, name, attrs): """ Listener method by the Robot Framework that is called when on suite setup. Args: name: name of the suite attrs: attributes of the suite Returns: None """ if self.orchestrator: self.orchestrator.remove_deployment() def update_sut(self, **kwargs): """ Update the sut object with the values provided in **kwargs. Before the update takes place, we check if the updated SUT is available. Args: **kwargs: target_type, target, service_id Returns: None """ # create a new namedtuple and use the old values if no new value is available # noinspection PyProtectedMember temp_sut = self.sut._replace( target_type=kwargs.get('target_type', self.sut.target_type), target=kwargs.get('target', self.sut.target), service_id=kwargs.get('service_id', self.sut.service_id), ) try: # set_breakpoint() self.sut = self._check_sut_availability(temp_sut) BuiltIn().log( '\nUpdating context: target_type={}, service_id={}, target={}'. format( self.sut.target_type if self.sut.target_type else 'Not set', self.sut.service_id if self.sut.service_id else 'Not set', self.sut.target if self.sut.target else 'Not set'), level='INFO', console=Settings.to_console) except NotFoundError as exc: raise NotFoundError( 'update_sut: Fatal error: {} "{}" not found in deployment "{}".' .format(temp_sut.target_type, temp_sut.target, self.deployment_name)) def _check_sut_availability(self, temp_sut): """ Helper method to determine if an SUT is available. Makes use of the Orchestrator instance. Args: temp_sut: namedtuple Returns: temp_sut: namedtuple """ try: if temp_sut.target_type == 'network': self.orchestrator.controller.get_network(temp_sut.service_id) elif temp_sut.target_type == 'service': self.orchestrator.controller.get_service(temp_sut.service_id) self.orchestrator.controller.get_containers_for_service( temp_sut.service_id) elif temp_sut.target_type == 'container': self.orchestrator.controller.get_containers( filters={'name': temp_sut.service_id}, all=True) else: raise NotFoundError( '_check_sut_availability: target_type {} is invalid'. format(temp_sut.target_type)) return temp_sut except NotFoundError as exc: raise exc def run_keyword(self, name, args, kwargs): """ Mandatory method in dynamic libraries of the Robot Framework. Gets called by the framework if a keyword was identified as belonging to that library. Returns: None """ self.context = BuiltIn().get_library_instance(all=True) # logger.info(u"\nRunning keyword '%s' with arguments %s." % (name, args), also_console=True) return self.keywords[name](*args, **kwargs) @keyword('Set ${context_type:\S+} context to ${context:\S+}') def set_context_kw(self, context_type=None, context=None): """ Keyword 'Set context' Args: context_type: str context: str Returns: None """ try: set_context(self, context_type, context) except (NotFoundError, SetupError) as exc: BuiltIn().fatal_error(exc) @keyword( 'Command ${{raw_entity:{}}}: ${{raw_prop:{}}} ${{matcher:{}}} ${{raw_val:{}}}' .format(matchers.quoted_or_unquoted_string, '|'.join(Command.properties.keys()), '|'.join(all_matchers.keys()), matchers.quoted_or_unquoted_string)) def command_kw(self, raw_entity, raw_prop, matcher, raw_val): """ 'Command' keyword. Args: raw_entity: str raw_prop: str matcher: str raw_val: str Returns: None """ try: set_breakpoint() validation_target = Command(self) validation_target.set_as_dict({ 'context': self.sut, 'entity': raw_entity, 'property': raw_prop, 'matcher': matcher, 'value': raw_val }) validation_target.run_test() except ValidationError as exc: BuiltIn().fail(exc) @keyword('File ${{raw_entity:{}}}: ${{matcher:{}}} ${{raw_val:{}}}'.format( matchers.quoted_or_unquoted_string, '|'.join(string_matchers.keys()), matchers.quoted_or_unquoted_string)) def file_kw_content(self, raw_entity, matcher, raw_val): """ 'File' keyword (no property) Args: raw_entity: str matcher: str raw_val: str Returns: None """ try: validation_target = File(self) validation_target.set_as_dict({ 'context': self.sut, 'entity': raw_entity, 'property': 'content', 'matcher': matcher, 'value': raw_val }) validation_target.run_test() except ValidationError as exc: BuiltIn().fail(exc) @keyword( 'File ${{raw_entity:{}}}: ${{raw_prop:{}}} ${{matcher:{}}} ${{raw_val:{}}}' .format(matchers.quoted_or_unquoted_string, '|'.join(File.properties.keys()), '|'.join(all_matchers.keys()), matchers.quoted_or_unquoted_string)) def file_kw(self, raw_entity, raw_prop, matcher, raw_val): """ 'File' keyword (with property) Args: raw_entity: str raw_prop: str matcher: str raw_val: str Returns: None """ try: validation_target = File(self) validation_target.set_as_dict({ 'context': self.sut, 'entity': raw_entity, 'property': raw_prop, 'matcher': matcher, 'value': raw_val }) validation_target.run_test() except ValidationError as exc: BuiltIn().fail(exc) @keyword( 'Address ${{raw_entity:\S+}}: ${{matcher:{}}} ${{raw_val:\S+}}'.format( '|'.join(string_matchers.keys()))) def address_kw(self, raw_entity, matcher, raw_val): """ 'Address' keyword Args: raw_entity: str matcher: str raw_val: str Returns: None """ try: entity = Address(self) entity.set_as_dict({ 'context': self.sut, 'entity': raw_entity, 'matcher': matcher, 'value': raw_val }) entity.run_test() except ValidationError as exc: BuiltIn().fail(exc) @keyword('DNS') def dns_kw(self): pass @keyword('Interface') def interface_kw(self): pass @keyword( 'Variable ${{raw_entity:{}}}: ${{matcher:{}}} ${{raw_val:{}}}'.format( matchers.quoted_or_unquoted_string, '|'.join(string_matchers.keys()), matchers.quoted_or_unquoted_string)) def env_variable_kw(self, raw_entity, matcher, raw_val): """ 'Variable' keyword Args: raw_entity: str matcher: str raw_val: str Returns: None """ try: validation_target = Variable(self) validation_target.set_as_dict({ 'context': self.sut, 'entity': raw_entity, 'matcher': matcher, 'value': raw_val }) validation_target.run_test() except ValidationError as exc: BuiltIn().fail(exc) @keyword( 'Port ${{raw_entity:\S+}}: ${{raw_prop:{}}} ${{matcher:{}}} ${{raw_val:\S+}}' .format('|'.join(Port.properties.keys()), '|'.join(string_matchers.keys()))) def port_kw(self, raw_entity, raw_prop, matcher, raw_val): """ 'Port' keyword Args: raw_entity: str raw_prop: str matcher: str raw_val: str Returns: None """ try: validation_target = Port(self) validation_target.set_as_dict({ 'context': self.sut, 'entity': raw_entity, 'property': raw_prop, 'matcher': matcher, 'value': raw_val }) validation_target.run_test() except ValidationError as exc: BuiltIn().fail(exc) @keyword( 'Placement: ${{raw_prop:{}}} ${{matcher:{}}} ${{raw_val:\S+}}'.format( '|'.join(Placement.properties.keys()), '|'.join(string_matchers.keys()))) def placement_kw(self, raw_prop, matcher, raw_val): """ 'Placement' keyword Args: raw_prop: str matcher: str raw_val: str Returns: None """ try: validation_target = Placement(self) validation_target.set_as_dict({ 'context': self.sut, 'entity': 'placement', 'property': raw_prop, 'matcher': matcher, 'value': raw_val }) validation_target.run_test() except ValidationError as exc: BuiltIn().fail(exc) @keyword('Remove deployment') def remove_deployment_kw(self): """ 'Remove deployment' keyword Returns: None """ self.orchestrator.remove_deployment(self)