def decorator(func): """The real decorator.""" if ALOE_INSTALLED: aloe_step(step_sentence)(func) if BEHAVE_INSTALLED: use_step_matcher('re') behave_step(step_sentence)(func) return func
def build_step_func(self): decorator = DECORATORS_BY_TYPES[self.type_] use_step_matcher('re') @decorator(self.sentence) def behave_step(context, *args, **kwargs): self.context = context # args not used. Your regex must use named groups "(?P<name>...)" return self.step(**kwargs) return behave_step
# along with this program. If not, see <http://www.gnu.org/licenses/>. # """ """ import os import sys from behave import use_step_matcher, given, when, then if sys.version_info < (3, 0): from urllib2 import urlopen else: from urllib.request import urlopen use_step_matcher("re") @given(u'data is available') def step_impl_data_available(context): if not os.path.exists('/tmp/SVM02_npp_d20150311_t1122204_e1123446_b17451_c20150311113206961730_cspp_dev.h5'): response = urlopen('https://zenodo.org/record/16355/files/' 'SVM02_npp_d20150311_t1122204_e1123446_b17451_c20150311113206961730_cspp_dev.h5') with open('/tmp/SVM02_npp_d20150311_t1122204_e1123446_b17451_c20150311113206961730_cspp_dev.h5', mode="w") as fp: fp.write(response.read()) if not os.path.exists('/tmp/GMTCO_npp_d20150311_t1122204_e1123446_b17451_c20150311113205873710_cspp_dev.h5'): response = urlopen('https://zenodo.org/record/16355/files/' 'GMTCO_npp_d20150311_t1122204_e1123446_b17451_c20150311113205873710_cspp_dev.h5') with open('/tmp/GMTCO_npp_d20150311_t1122204_e1123446_b17451_c20150311113205873710_cspp_dev.h5', mode="w") as fp:
dialog = get_dialog(context, dialog_title) dialog_shadow = expand_shadow_root(context, dialog) input_element = None timeout = time() + int(seconds) while time() < timeout: input_element = get_input_element_from_form(context, dialog_shadow, field_name) if input_element.is_displayed(): return True sleep(1) assert input_element, "Could not find field %s after %s seconds" % field_name assert False, "Field %s did not become visible after %s seconds" \ % (field_name, seconds) #@step(u'I click the "{button_name}" button in the "{dialog_title}" dialog') use_step_matcher("re") @step(u'I click the "(?P<button_name>[A-Za-z0-9_\. ]+)" button in the "(?P<dialog_title>[A-Za-z ]+)" dialog') def click_button_in_dialog(context, button_name, dialog_title): dialog = get_dialog(context, dialog_title) assert dialog, "Could not find dialog with title %s" % dialog_title dialog_shadow = expand_shadow_root(context, dialog) button = get_button_from_form(context, dialog_shadow, button_name, tag_name='paper-button:not([hidden]), paper-item:not([hidden])') clicketi_click(context, button) use_step_matcher("parse") @step(u'I click the toggle button with id "{btn_id}" in the "{dialog}" dialog') def click_toggle_button_in_dialog(context, btn_id, dialog): open_dialog = get_dialog(context, dialog) assert open_dialog, "Could not find dialog with title %s" % dialog dialog_shadow = expand_shadow_root(context, open_dialog)
# limitations under the License. import behave import simplejson as json import staticconf.testing from clusterman_metrics import APP_METRICS from clusterman_metrics import SYSTEM_METRICS from moto import mock_autoscaling from moto import mock_ec2 from moto import mock_sqs from clusterman.aws.client import autoscaling from clusterman.aws.client import ec2 from clusterman.config import CREDENTIALS_NAMESPACE from clusterman.monitoring_lib import yelp_meteorite behave.use_step_matcher('re') BEHAVE_DEBUG_ON_ERROR = False @behave.fixture def patch_meteorite(context): if yelp_meteorite: with yelp_meteorite.testcase(): yield else: yield @behave.fixture def setup_configurations(context): boto_config = {
before_feature(context, feature), after_feature(context, feature) These run before and after each feature file is exercised. The feature passed in is an instance of Feature. before_tag(context, tag), after_tag(context, tag) """ import json import platform import os import re import requests import uuid from behave import use_step_matcher from features.support import Config # -- SETUP: Use cfparse as default matcher use_step_matcher('cfparse') with_JIRA = False def before_all(context): global with_JIRA # Set Config File to Data variable and check if we are running locally or in Jenkins try: # We set the data for the Autoamtion using the ENV variable passed Thru jenkins. context.data = Config.Config(str(os.environ['ENV'])).save_to_var() # We turn the API on. with_JIRA = True # If this fails we set it to a hardcoded Value, that can be changed according to your needs. except KeyError: context.data = Config.Config('DEV').save_to_var() if with_JIRA:
from behave import given, when, then, use_step_matcher try: from unittest.mock import patch except ImportError: from mock import patch use_step_matcher("re") @given("a dataset is available") # noqa: F811 def step_impl(context): """ :type context: behave.runner.Context """ from satpy import Scene from xarray import DataArray scn = Scene() scn["MyDataset"] = DataArray([[1, 2], [3, 4]], dims=['y', 'x']) context.scene = scn @when("the show command is called") # noqa: F811 def step_impl(context): """ :type context: behave.runner.Context """ with patch('trollimage.xrimage.XRImage.show') as mock_show: context.scene.show("MyDataset") mock_show.assert_called_once_with()
import json import behave from behave import when, given from liveblog_helpers import liveblog_request from liveblog_fixtures import upload_fixtures # ============================================================================ behave.use_step_matcher('re') METHODS_RE = '(?P<method>GET|POST|PUT|PATCH|DELETE)' @when(METHODS_RE + ' (?P<uri>.*) with headers') def step_impl_request_with_headers(context, method, uri): headers = json.loads(context.text) liveblog_request(context, method, uri, headers=headers) @when(METHODS_RE + ' (?P<uri>.*)') def step_impl_request(context, method, uri): liveblog_request(context, method, uri) # ============================================================================ behave.use_step_matcher('parse') @given('{number:n} fixtures') def step_imp_fixtures(context, number): upload_fixtures(context, number)
from behave import step from iotqatools.helpers_utils import * from iotqatools.cb_v2_utils import CB from iotqatools.mongo_utils import Mongo from tools.properties_config import Properties # methods in properties class from tools.NGSI_v2 import NGSI # constants CONTEXT_BROKER_ENV = u'context_broker_env' MONGO_ENV = u'mongo_env' properties_class = Properties() behave.use_step_matcher("re") __logger__ = logging.getLogger("steps") # ------------------ create_entities ------------------------------------------------ @step(u'a definition of headers') def definition_of_headers(context): """ configuration of different header (service, service path, Content-Type, Accept, etc) :param context: It’s a clever place where you and behave can store information to share around. It runs at three levels, automatically managed by behave. """ __logger__.info("Reading CB properties from properties.json file...") props = properties_class.read_properties()[CONTEXT_BROKER_ENV] context.cb = CB(protocol=props["CB_PROTOCOL"], host=props["CB_HOST"],
""" SetUp environment for BDD tests """ from behave import use_step_matcher # Select default step matcher, possible variants are: ['re', 'parse', 'cfparse'] # NOTE: PyCharm understands only 're' # issue: https://youtrack.jetbrains.com/issue/PY-14532 use_step_matcher('re')
add_form = get_add_form(context, title) if form_type == 'add' else \ get_edit_form(context, title) add_form_shadow = expand_shadow_root(context, add_form) form_input = None timeout = time() + int(seconds) while time() < timeout: form_input = get_input_element_from_form(context, add_form_shadow, field_name) if form_input and form_input.is_displayed(): return True sleep(1) assert form_input, "Could not find field %s after %s seconds" % ( field_name, seconds) use_step_matcher("re") @step( u'I set the "(?P<script_input>[A-Za-z ]+)" script "(?P<script>[A-Za-z0-9 \-/,._#!<>+:=\{\}@%\*\"\n~\\\\\[\]]+)"' ) def set_script_to_field(context, script_input, script): form = get_add_form(context, 'machine') form_shadow = expand_shadow_root(context, form) form_input = get_input_element_from_form(context, form_shadow, script_input.lower()) n = 70 script.replace('\"', '"') chunks = [script[i:i + n] for i in xrange(0, len(script), n)] for chunk in chunks: if '\\n' in chunk:
def call(context, url): """Send message to microservice.""" request = { 'message': { 'query_graph': context.query_graph, 'results': getattr(context, 'results', []), }, 'options': getattr(context, 'options', {}) } if 'knowledge_graph' in context: request['message']['knowledge_graph'] = context.knowledge_graph context.response = requests.post(url, json=request) context.response_json = context.response.json() use_step_matcher('re') # This is much too generic a pattern matching template which # will override any other @given in the steps.py file which starts with the English article 'a' # so we comment it out! # #@given('a (?P<key>.*)') #def append_to_list(context, key): # """Append element to list in context. # # Create the list if it does not exist. # """ # key = key.replace(' ', '_') + 's' # value = getattr(context, key, []) # value.append(json.loads(context.text)) # setattr(context, key, value)
add_form = get_add_form(context, title) if form_type == 'add' else \ get_edit_form(context, title) add_form_shadow = expand_shadow_root(context, add_form) form_input = None timeout = time() + int(seconds) while time() < timeout: form_input = get_input_element_from_form(context, add_form_shadow, field_name) if form_input.is_displayed(): return True sleep(1) assert form_input, "Could not find field %s after %s seconds" % field_name assert False, "Field %s did not become visible after %s seconds" \ % (field_name, seconds) use_step_matcher("re") @step(u'I set the value "(?P<value>[A-Za-z0-9 \-/,._#!<>+:=\{\}@%\*\"\n~\\\\]+)" to field "(?P<name>[A-Za-z ]+)" in the "(?P<title>[A-Za-z]+)" (?P<form_type>[A-Za-z]+) form') def set_value_to_field(context, value, name, title, form_type): if context.mist_config.get(value): value = context.mist_config.get(value) elif "random" in value: value_key = value value = value.replace("random", str(randrange(1000))) context.mist_config[value_key] = value form = get_add_form(context, title) if form_type == 'add' else \ get_edit_form(context, title) form_shadow = expand_shadow_root(context, form) form_input = get_input_element_from_form(context, form_shadow, name.lower()) assert form_input, "Could not set value to field %s" % name clear_input_and_send_keys(form_input, value)
from behave import use_step_matcher, step from acceptance.page_model.change_user_page import ChangeUserPage use_step_matcher('re') @step('I click on SAVE button again') def step_impl(context): page = ChangeUserPage(context) page.save_button.click()
assert premis_event is not None # <premis:eventDetail>program=gpg (GPG); version=1.4.16; python-gnupg; # version=0.4.0</premis:eventDetail> premis_event_detail = premis_event.find( 'mets:xmlData/premis:event/premis:eventDetail', context.am_user.mets.mets_nsmap).text assert 'GPG' in premis_event_detail assert 'version=' in premis_event_detail premis_event_od_note = premis_event.find( 'mets:xmlData/premis:event/premis:eventOutcomeInformation/' 'premis:eventOutcomeDetail/premis:eventOutcomeDetailNote', context.am_user.mets.mets_nsmap).text.strip() assert 'Status="encryption ok"' in premis_event_od_note use_step_matcher('re') @then( 'the (?P<aip_description>.*)pointer file contains a mets:transformFile element' ' for the encryption event') def step_impl(context, aip_description): """Makes the following assertions about the first (and presumably only) <mets:file> element in the AIP's pointer file: 1. the xlink:href attribute's value of <mets:FLocat> is a path with extension .gpg 2. the decompression-type <mets:transformFile> has TRANSFORMORDER 2 3. there is a new <mets:transformFile> element for the decryption event needed to get at this AIP. 4. <premis:compositionLevel> incremented 5. <premis:inhibitors> added
from behave import given, then, when, use_step_matcher use_step_matcher("re") @given('we have behave "(?P<name>\w+)"') # noqa def step_impl(context, name): # noqa print(name) @when('we implement test number "(?P<numeral>\d+)"') # noqa def step_impl(context, numeral): # noqa try: numeral = int(numeral) print(numeral) except ValueError: context.failed = True @when('we implement test number "(?P<word>\w+)"') # noqa def step_impl(context, word): # noqa print(word) assert type(word) is str use_step_matcher("parse") @when('we run test number "{value:d}"') # noqa def step_impl(context, value): # noqa print(value)
import behave import logging from behave import step from iotqatools.mongo_utils import Mongo from tools.properties_config import Properties from tools.NGSI_v2 import NGSI # constants MONGO_ENV = u'mongo_env' properties_class = Properties() behave.use_step_matcher("re") __logger__ = logging.getLogger("steps") # ------------------ create subscriptions ------------------------------------------------ @step(u'properties to subscriptions') def properties_to_subscriptions(context): """ properties to subscription (previous step to create or update subcription request) :param context: It’s a clever place where you and behave can store information to share around. It runs at three levels, automatically managed by behave. """ __logger__.info("Define the properties used in the subcription request") context.cb.properties_to_subcription(context)
from behave import given, when, then, register_type, use_step_matcher from test.common.helper import create_project import parse @parse.with_pattern(r"[a-zA-Z0-9_\s]+") def parse_string(text): return text register_type(str_value=parse_string) use_step_matcher("cfparse") @then('the response field "{field}" should be "{value:str_value?}"') def step_impl(context, field, value): if value is None: value = '' assert context.response[field] == value @then('The response should have the error message: "{error_message}"') def step_impl(context, error_message): assert context.response['errorMessages'][0] == error_message @then('The response should have an error message') def step_impl(context): assert 'errorMessages' in context.response
# -*- coding: utf--8 -*- # -- SETUP: Use cfparse as default matcher from behave import use_step_matcher use_step_matcher("cfparse")