Gherkin Step Reference

Every step definition shipped with pytest-bdd-ewx, 532 in total, generated from the plugin source. Use the filter to find a step by any word in its text or description, or browse by domain and entity below. Parameters appear as {name}; in a feature file you replace them with a quoted value.

Writing your own steps

If no built-in step fits, see Extending the plugin. The wording in your feature file must match the step text exactly, see Using the plugin.

All domainsData modelIngestionProcessing and business logicAdministrationTest utilities

532 steps. Type to filter, or browse by domain below.

Data model

Datasources

Type	Step	What it does
Given	datasource "{datasource_id}" has at least one channel	Checks if a datasource has at least one channel.
Given	I add the channels from "{file_name}" to that datasource "{datasource_id}"	Adds channels from a file to a datasource.
Given	I count the channels of datasource "{datasource_id}"	Counts and saves the amount of channels in a datasource.
GivenWhen	I create all datasources from "{file_name}"	Creates datasources from a given file.
GivenWhen	I create all datasources from "{file_name}" if they do not exist	Creates datasources from a given file.
GivenThen	I do not expect a channel classifier "{classifier_name}" to be present for datasource "{datasource_id}"	Checks that channel classifier is absent with the given name for the datasource with the given ID.
GivenThen	I expect "{increment:d}" new flows with channel classifier "{channel_classifier}" on datasource "{datasource_id}"	Checks if amount of new flows with channel classifier is as expected.
GivenThen	I expect "{increment:d}" new flows with channel classifier "{channel_classifier}" within "{min_timeout:d}" minutes on datasource "{datasource_id}" with a poll frequency of "{freq:d}" seconds	Checks if amount of new flows with channel classifier is as expected.
GivenThen	I expect a new flow with config name "{flow_name}" and status "{flow_status}" with channel classifier "{channel_classifier}" on datasource "{datasource_id}"	Checks if amount of new successful or failed flows with channel classifier is as expected.
GivenThen	I expect a new flow with config name "{flow_name}" and status "{flow_status}" with channel classifier "{channel_classifier}" on datasource "{datasource_id}" within "{timeout:d}" minutes with a poll frequency of "{freq:d}" seconds	Checks if amount of new successful or failed flows with channel classifier is as expected.
GivenThen	I expect no channels for the datasource with id "{datasource_id}"	Checks that a datasource has no channels.
Given	I expect no new flows with channel classifier "{channel_classifier}" on datasource "{datasource_id}"	Verify that no new flows with channel classifier are created within the default polling time.
GivenThen	if there was ingestion I expect "{increment:d}" new flows with channel classifier "{channel_classifier}" on datasource "{datasource_id}" within "{min_timeout:d}" minutes with a poll frequency of "{freq:d}" seconds	Conditionally waits for new flows only if ingestion was performed (init_time is set).
Given	the datasource with ID "{datasource_id}" is not available in datasources	Confirm that a datasource with the given ID is not available in the datasources list.
GivenWhenThen	there is a datasource with id "{datasource_id}"	Check if a datasource with the given ID is created withing the default amount of time.
When	I add the channels from "{file_name}" to datasource "{datasource_id}"	Adds channels from a file to a datasource.
WhenThen	I expect "{increment:d}" new flows on datasource "{datasource_id}"	Check if a given amount of new flows are created within the default amount of time on a given datasource.
WhenThen	I expect "{increment:d}" new flows within "{min_timeout:d}" minutes on datasource "{datasource_id}" with a poll frequency of "{freq:d}" seconds	Check if a given amount of new flows are created within a given amount of time on a given datasource.
WhenThen	I expect a new flow with config name "{flow_name}" and status "{flow_status}" on datasource "{datasource_id}"	Check if a new flow using a specific flow config was created and has a specific status within the default amount of time on a given datasource.
WhenThen	I expect a new flow with config name "{flow_name}" and status "{flow_status}" on datasource "{datasource_id}" to have property "{property_key}" with value "{property_value}"	Check that a new flow has the expected value for a specific metadata property.
When	I expect a new flow with config name "{flow_name}" and status "{flow_status}" on datasource "{datasource_id}" with a poll frequency of "{freq:d}" seconds	Check if a new flow using a specific flow config was created and has a specific status within the default amount of time on a given datasource.
When	I update all datasources from "{file_name}"	Creates datasources from a given file.
Then	I do not expect response to contain "{unexpected_ds_ids}" when I search for datasources with no query and filter by the datasource classifier "{ds_classifier_name}"	Verifies that datasources from the list are not returned by search by datasource classifier filter.
Then	I do not expect response to contain "{unexpected_ds_ids}" when I search for datasources with query "{search_filter}"	Verifies that datasources from the list are not returned by search with query.
Then	I do not expect response to contain "{unexpected_ds_ids}" when I search for datasources with query "{search_filter}" and filter by the datasource classifier "{ds_classifier_name}"	Verifies that datasources from the list are not returned by search with query and datasource classifier.
Then	I expect a channel classifier "{classifier_name}" to be present for datasource "{datasource_id}"	Checks that channel classifier is present with the given name for the datasource with the given ID.
Then	I expect a new flow with config name "{flow_name}" and status "{flow_status}" on datasource "{datasource_id}"with a poll frequency of "{freq:d}" seconds	Check if a new flow using a specific flow config was created and has a specific status within the default amount of time on a given datasource.
Then	I expect for datasource with id "{datasource_id}" a channel with channel classifier "{classifier_name}" which is "{source_or_not}"	Checks if a channel classifier with the given name was created on a datasource with the given ID.
Then	I expect for datasource with id "{datasource_id}" in channel "{channel_classifier}" property tag "{tag_key}" with value "{tag_value}" and "{amount_versions}"	Checks the property tags of a given channel.
Then	I expect for datasource with id "{datasource_id}" in channel "{channel_classifier}" property tag "{tag_key}", "{tag_value}", valid from "{valid_from}", version "{version}" and removed "{removed}"	Checks the property tags of a given channel.
Then	I expect in "{channel_classifier}" property tag "{tag_key}" with value "{tag_value}" and "{amount_versions}"	Checks the property tags of a given channel.
Then	I expect in "{channel_classifier}" property tag "{tag_key}", "{tag_value}", valid from "{valid_from}", version "{version}" and removed "{removed}"	Checks the property tags of a given channel.
Then	I expect latest flow with channel classifier "{channel_classifier}" on datasource "{datasource_id}" with rule "{rule_in_sequence}" to have the parameter "{rule_parameter}" with value "{rule_parameter_value}"	Checks if a datasource contains a given flow run rule parameter.
Then	I expect no new flows with channel classifier "{channel_classifier}" within "{min_timeout:d}" minutes on datasource "{datasource_id}" with a poll frequency of "{freq:d}" seconds	Verify that no new flows with channel classifier are created within a given amount of time.
Then	I expect response containing "{ds_ids}" when I search for datasources with no filters	Search for datasources without filters, verifies the required IDs are returned.
Then	I expect response containing "{ds_ids}" when I search for datasources with no query and filter by the datasource classifier "{ds_classifier_name}"	Search for datasources, filter by the datasource classifier. Verifies the required IDs are returned.
Then	I expect response containing "{ds_ids}" when I search for datasources with query "{search_filter}"	Queries datasources, verifies the required IDs are returned.
Then	I expect response containing "{ds_ids}" when I search for datasources with query "{search_filter}" and filter by the datasource classifier "{ds_classifier_name}"	Queries datasources and filters by the datasource classifier. Verifies the required IDs are returned.
Then	I expect response to contain only datasources with id "{expected_ds_ids}" when I search for datasources with query "{query}"	Verifies that only expected datasources are returned by search with query.
Then	I expect response to contain only datasources with id "{expected_ds_ids}" when I search for datasources with query "{query}" and filter by the datasource classifier "{ds_classifier_name}"	Verifies that only expected datasources are returned by search with query and filter by datasource classifier.
Then	I expect the attribute "{attribute}" contains the value "{value}" for datasource "{datasource_id}"	Checks if a datasource has attribute as expected.
Then	I expect the channel "{classifier_name}" of datasource "{datasource_id}" to have the name "{channel_name}"	Checks the display name of the channel with the given classifier on the datasource with the given ID.
Then	I expect the following channels on datasource with id "{datasource_id}":	Checks multiple channel classifiers and their is_source property on a datasource in a single request.
Then	the datasource with id "{datasource_id}" includes the channels from "{file_name}"	Checks if a datasource has all the channels from a file.
Then	the number of channels of datasource "{datasource_id}" has changed by "{expected_diff:d}"	Checks if the amount of channels in a datasource has changed by the expected value.
Then	there is a datasource with id "{datasource_id}" within "{timeout:d}" minutes with a poll frequency of "{polling_frequency_in_seconds:d}" seconds	Check if a datasource with the given ID is created withing a given amount of time using a given check interval.

Datasource classifiers

Type	Step	What it does
Given	I check the number of datasource classifiers in my namespace	Checks and saves the datasource classifiers currently available in the namespace.
GivenWhen	I create all datasource classifiers from "{file_name}"	Creates datasource classifiers from a given file.
GivenWhen	I create all datasource classifiers from "{file_name}" if they don't exist	Creates datasource classifiers from a file if they don't already exist.
Given	I upload all datasource classifiers matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all datasource classifiers matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all datasource classifiers whose names match the given regex pattern using a specified resource manager.
Given	I upload all datasource classifiers using the default resource manager	No description yet
Given	I upload all datasource classifiers using the resource manager with name "{manager_name}"	Uploads all datasource classifiers using a specified resource manager.
Given	I upload the datasource classifier with name "{name}" using the default resource manager	No description yet
Given	I upload the datasource classifier with name "{name}" using the resource manager with name "{manager_name}"	Uploads a datasource classifier with given name using a specified resource manager.
When	I change the "{attribute_key}" of the datasource classifier "{ds_classifier_name}" to "{attribute_value}"	Changes the value of a key in a datasource classifier.
Then	I expect the "{attribute_key}" of the datasource classifier "{ds_classifier_name}" to be equal to "{attribute_value}"	Checks if the attribute of a datasource classifier equals to the expected value.
Then	the number of datasource classifiers has increased by "{expected_increase:d}"	Check for the increase in the amount of datasource classifiers since the last time.

Channel classifiers and channel families

Type	Step	What it does
GivenWhen	I add a datapoint attribute if it does not exist with the name "{dpa_name}" of type "{dpa_type}" and editable flag set to "{is_editable}" to the channel "{channel_name}"	Adds new DPAs to the channel classifier.
GivenWhen	I add an enum datapoint attribute if it does not exist with the name "{dpa_name}" and enum values "{enum_values}" and editable flag set to "{is_editable}" to the channel "{channel_name}"	Adds a new enum DPA with its enum values to the channel classifier.
GivenWhen	I add datapoint attributes if they do not exist to the channel "{channel_name}" with the following name-type-editable flag:	Adds new DPAs to the channel classifier.
Given	I create all channel classifiers from "{file_name}" if they don't exist	Creates all channel classifiers from a file if they don't exist.
Given	I create all channel families from "{file_name}" if they don't exist	Creates all channel families from a file if they don't exist.
Given	I upload all channel classifiers matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all channel classifiers matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all channel classifiers whose names match the given regex pattern using a specified resource manager.
Given	I upload all channel classifiers using the default resource manager	No description yet
Given	I upload all channel classifiers using the resource manager with name "{manager_name}"	Uploads all channel classifiers using a specified resource manager.
Given	I upload the channel classifier with name "{name}" using the default resource manager	No description yet
Given	I upload the channel classifier with name "{name}" using the resource manager with name "{manager_name}"	Uploads a channel classifier with given name using a specified resource manager.
GivenThen	On channel classifier with name "{name}" I expect the attribute "{attribute}" with value "{value}"	Asserts the value of an attribute from a channel classifier.
When	I view the list of channel classifiers, I expect the channel "{channel_name}" the datapoint attribute "{dpa_name}" to include enum values "{enum_values}"	Checks that the channel classifier has the expected list of enums in the DPA.
When	I view the list of channel classifiers, I expect the channel "{channel_name}" to have the attribute "{attr_name}" with the value "{attr_value}"	Checks that the channel classifier has the expected attribute when browsing the list of channels.
When	I view the list of channel classifiers, I expect the channel "{channel_name}" to have the datapoint attribute "{dpa_name}" of type "{dpa_type}"	Checks that the channel classifier has the expected DPA when browsing the list of channels.
When	On channel classifier with name "{name}" I update the attribute "{attribute}" to "{value}"	Updates the value of a specific attribute of a channel classifier.
When	On channel classifier with name "{name}" I update the datapoint attribute "{datapoint_attribute_name}" with enum values "{enum_values}" if they do not exist	Updates the datapoint attribute of a channel classifier with individual enum values.
Then	adding a datapoint attribute with the name "{dpa_name}" of type "{dpa_type}" and editable flag set to "{is_editable}" to the channel "{channel_name}" is rejected	Checks that adding a DPA to the channel classifier is rejected as a bad request.
Then	I check the channel "{channel_name}" has a datapoint attribute with the name "{dpa_name}" of type "{dpa_type}"	Checks that the channel classifier has the expected datapoint attributes configured with type.
Then	I check the channel "{channel_name}" has the following datapoint attributes configured with type:	Checks that the channel classifier has the expected datapoint attributes configured with type.
Then	I expect this channel classifier "{classifier_name}" to be of data point type "{data_point_type}?"	Checks if the data point type of channel classifier is as expected.
Then	I expect this channel classifier "{classifier_name}" to be of unit type "{unit_type}?"	Checks if the data unit type of channel classifier is as expected.
Then	On channel classifier with name "{name}" I expect the datapoint attribute "{datapoint_attribute_name}" to include enum values "{enum_values}"	Validates that the datapoint attribute of a channel classifier contains the expected list of enum values.
Then	the attribute "{attribute}" cannot be updated with blank value for channel classifier "{name}"	Attempts to update channel classifier value with blank value.

Tags

Type	Step	What it does
GivenWhen	I create tags from file "{file_name}"	Creates tags from a file on the specified datasource.
GivenWhenThen	I expect in tag "{tag_key}" the property "{property_key}" for datasource "{datasource_id}"	Periodically checks the presence of a tag with a specific property on a datasource.
GivenWhenThen	I expect in tag "{tag_key}" the property "{property_key}" with value "{property_value}" for datasource "{datasource_id}"	Periodically checks the presence of a tag with a specific property value on a datasource.
GivenThen	I expect no tags for datasource "{datasource_id}"	Verifies no tags for the given datasource id.
GivenWhenThen	I expect the following tag properties for datasource "{datasource_id}":	Periodically checks multiple tag key/property key/property value triples on a datasource in a single request.
GivenWhen	I update or create tags from file "{file_name}" for datasource "{datasource_id}"	Creates or updates tags from a file on the specified datasource.
When	I create a tag with the name "{tag_name}" with a property "{property_name}" and a value "{property_value}" for datasource "{datasource_id}"	Creates a tag on the specified datasource. Valid from and version are set to 2000-01-01T00:00:00Z.
When	I create a tag with the name "{tag_name}" with a property "{property_name}" and a value "{property_value}", valid from "{valid_from}" and a version "{version}" for datasource "{datasource_id}"	Creates a tag on the specified datasource with specific version and valid from values.
When	I create a tag with the name "{tag_name}" with a property "{property_name}" with a value "{property_value}" and a version "{version}" for datasource "{datasource_id}"	Creates a tag on the specified datasource with specific version. Valid from is set to 2000-01-01T00:00:00Z.
WhenThen	I expect in tag "{tag_key}" the property "{property_key}" with value "{property_value}" for datasource "{datasource_id}" within "{time_limit_in_minutes:d}" minutes with a poll frequency of "{polling_frequency_in_seconds:d}" seconds	Periodically checks the presence of a tag with a specific property value on a datasource with a custom polling frequency.
When	I update tags from file "{file_name}" for datasource "{datasource_id}"	Updates tags from a file on the specified datasource.
Then	I expect for datasource with id "{datasource_id}" for the tag "{tag_key}" to have "{n_versions:d}" versions	Periodically checks the presence of a tag with a specific number of versions on a datasource.
Then	I expect for datasource with id "{datasource_id}" for the tag "{tag_key}" to have "{n_versions:d}" versions after "{wait_duration:d}" seconds	Waits for a specified duration, then verifies the tag has the expected number of versions.
Then	I expect for datasource with id "{datasource_id}" the tag "{tag_key}" with property "{property_key}" and the value "{property_value}" to be valid from "{tag_valid_from}"	Periodically checks the presence of a tag with a specific valid_from and a specific property on a datasource.
Then	I expect for datasource with id "{datasource_id}" the version "{tag_version}" of the tag "{tag_key}" with property "{property_key}" and the value "{property_value}" to be valid from "{tag_valid_from}" and removed "{removed}"	Periodically checks the presence of a tag with a specific version and a specific property value, valid from and removed attributes on a datasource.

Datapoints

Type	Step	What it does
When	I batch edit on datasource "{datasource_id}" the annotation "{annotation_key}" on the channel "{annotation_channel}" to the value "{value}" between "{start}" and "{end}" with edit reason "{edit_reason}"	Sets an annotation property on every annotation of a series between two timestamps with the batch endpoint.
When	I batch multiply on datasource "{datasource_id}" the channel "{channel_classifier}" by "{factor}" between "{start}" and "{end}" with edit reason "{edit_reason}"	Multiplies every datapoint of a channel between two timestamps with the batch endpoint.
When	I edit complex annotation on datasource "{datasource_id}" for channel "{annotation_channel}" at "{timestamp}" with edit reason "{edit_reason}":	Edits a complex annotation with multiple key-value pairs for a specified timestamp.
When	I edit on datasource "{datasource_id}" for channel "{annotation_channel}" at "{timestamp}" the annotation with the name "{annotation_key}" to the value "{value}" with edit reason "{edit_reason}"	Edits a single annotation value for a specified timestamp.
When	I edit on datasource "{datasource_id}" for channel "{channel_classifier}" at "{timestamp}" the datapoint attribute with the name "{dpa_name}" to the value "{value}" with edit reason "{edit_reason}"	Edits a single datapoint value for a specified timestamp.
When	I edit on datasource "{datasource_id}" for channel "{channel_classifier}" at "{timestamp}" the value to "{value}" with edit reason "{edit_reason}"	Edits a single datapoint value for a specified timestamp.
When	I edit on datasource "{datasource_id}" the following annotations with edit reason "{edit_reason}":	Edits multiple annotations for a specified datasource using a datatable.
When	I edit on datasource "{datasource_id}" the following datapoint attributes with edit reason "{edit_reason}":	Edits multiple datapoint attributes for a specified datasource using a datatable.
When	I edit on datasource "{datasource_id}" the following datapoint values with edit reason "{edit_reason}":	Edits multiple datapoint values for a specified datasource using a datatable.
When	I update the datapoints from the file "{file_name}"	Updates datapoints from a file, dispatching to V1 or V2 implementation based on the active API version.

Timeseries

Type	Step	What it does
Then	I do not expect the flag with the name "{flag_name}" on datasource with id "{datasource_id}" on the channel "{channel_name}" and the datapoint "{timestamp}"	Checks that a specific flag is NOT present on a datapoint in a channel.
Then	I expect a datapoint on timestamp "{timestamp}" to have a new version for continuous flow channel "{channel_name}" on datasource with id "{datasource_id}" after datapoint editing	Checks that the datapoint version is updated after editing for continuous flow channel.
Then	I expect a datapoint on timestamp "{timestamp}" to have the same version for scenario flow channel "{channel_name}" on datasource with id "{datasource_id}" after datapoint editing	Checks that the datapoint version is not updated after editing for a scenario flow channel.
Then	I expect channels with the names "{channel_list}" to have timeseries data between "{start_date}" and "{end_date}" for channel family "{channel_family}" on the datasource with id "{datasource_id}"	Verify that each channel from a given list contains timeseries data within a specified date range and channel family filter for the given datasource id.
Then	I expect channels with the names "{channel_list}" to have timeseries data between "{start_date}" and "{end_date}" for channel family "{channel_family}" on the datasource with id "{datasource_id}" when using "{view}" view	Verify that each channel from a given list contains timeseries data within a specified date range and channel family filter for the given datasource id with the requested view.
Then	I expect channels with the names "{channel_list}" to have timeseries data between "{start_date}" and "{end_date}" on the datasource with id "{datasource_id}"	Verify that each channel from a given list contains timeseries data within a specified date range for the given datasource id.
Then	I expect channels with the names "{channel_list}" to have timeseries data between "{start_date}" and "{end_date}" on the datasource with id "{datasource_id}" when using "{view}" view	Verify that each channel from a given list contains timeseries data within a specified date range for the given datasource id with the requested view.
Then	I expect in channel "{channel_classifier}" an annotation on index "{timestamp}" for property "{annotation_key}" with value "{annotation_value}" for datasource with ID "{datasource_id}"	Checks that an annotation is present at the expected time after processing a datasource.
Then	I expect in datasource with id "{datasource_id}" channel "{channel_classifier}" to have "{amount:d}" values from "{start_date}" for "{years}" years	Validates a timeseries data point is present in a channel classifier.
Then	I expect in datasource with id "{datasource_id}" for the last flow on the destination channel "{destination_classifier}" in channel "{channel_classifier}" data point "{timestamp}", "{value}"	Validates a timeseries data point is present in a channel classifier for the last flow run.
Then	I expect in datasource with id "{datasource_id}" in channel "{channel_classifier}" data point "{timestamp}", "{value}"	Validates a timeseries data point is present in a channel classifier.
Then	I expect no annotation for property "{annotation_key}" with value "{annotation_value}" in channel "{channel_classifier}" for the last flow on the destination channel "{destination_classifier}" on index "{timestamp}" for datasource with ID "{datasource_id}"	Checks that an annotation is NOT present at the expected timestamp after processing a datasource.
Then	I expect no timeseries data for the datasource with id "{datasource_id}"	Checks the datasource has no timeseries data.
Then	I expect on datasource with id "{datasource_id}" channel "{channel_classifier}" to have exactly "{amount:d}" annotations with the name "{annotation_name}" and the property "{annotation_prop_name}" between "{start_date}" and "{end_date}"	Validates if exact amount of annotations is present in a channel classifier.
Then	I expect on datasource with id "{datasource_id}" channel "{channel_classifier}" to have exactly "{amount:d}" annotations with the name "{annotation_name}" and the property "{annotation_prop_name}" between "{start_date}" and "{end_date}" when using "{view}" view for version depth "{version_depth:d}"	Validates if exact amount of annotations is present in a channel classifier with the requested view and specific version depth.
Then	I expect on datasource with id "{datasource_id}" channel "{channel_classifier}" to have exactly "{amount:d}" datapoint attribute values with the name "{dpa_name}" between "{start_date}" and "{end_date}"	Validates if exact amount of specified datapoint attribute is present in a channel classifier.
Then	I expect on datasource with id "{datasource_id}" channel "{channel_classifier}" to have exactly "{amount:d}" datapoint attribute values with the name "{dpa_name}" between "{start_date}" and "{end_date}" when using "{view}" view for version depth "{version_depth:d}"	Validates if exact amount of specified datapoint attribute is present in a channel classifier with the requested view and specific version depth.
Then	I expect on datasource with id "{datasource_id}" channel "{channel_classifier}" to have exactly "{amount:d}" flags with the name "{flag_name}" between "{start_date}" and "{end_date}" when using "{view}" view for version depth "{version_depth:d}"	Validates if exact amount of specified flag is present in a channel classifier with the requested view and specific version depth.
Then	I expect on datasource with id "{datasource_id}" channel "{channel_classifier}" to have exactly "{amount:d}" values between "{start_date}" and "{end_date}"	Validates if exact amount of timeseries data point is present in a channel classifier.
Then	I expect on datasource with id "{datasource_id}" channel "{channel_classifier}" to have exactly "{amount:d}" values between "{start_date}" and "{end_date}" when using "{view}" view for version depth "{version_depth:d}"	Validates if exact amount of timeseries data point is present in a channel classifier with the requested view and specific version depth.
Then	I expect on datasource with id "{datasource_id}" for the last flow on the destination channel "{destination_classifier}" in channel "{channel_classifier}" to have exactly "{amount:d}" values between "{start_date}" and "{end_date}"	Validates if exact amount of timeseries data point is present in a channel classifier for the last flow run.
Then	I expect on datasource with id "{datasource_id}" to have exactly "{amount:d}" datapoints when using filter "{filter_expression}"	Validates the exact amount of datapoints returned by a raw filter query on the timeseries API v2.
Then	I expect on datasource with id "{datasource_id}" to have exactly "{amount:d}" datapoints when using filter "{filter_expression}" with "{view}" view for version depth "{version_depth:d}"	Validates the exact amount of datapoints returned by a raw filter query with view and version depth.
Then	I expect the annotation "{annotation_name}" previous value to be equal to "{value}" for the timestamp "{timestamp}" on the channel "{annotation_channel}" in the edits history for the datasource with id "{datasource_id}"[ with edit reason "{edit_reason}" and user email "{user_email}"]	Checks that the previous value of an annotation is as expected in the edits history. Optionally, edit reason and user email can be verified in the edits history.
Then	I expect the datapoint attribute "{dpa_name}" previous value to be equal to "{value}" for the timestamp "{timestamp}" on the channel "{channel_name}" in the edits history for the datasource with id "{datasource_id}"[ with edit reason "{edit_reason}" and user email "{user_email}"]	Checks that the previous value of a datapoint attribute is as expected in the edits history. Optionally, edit reason and user email can be verified in the edits history.
Then	I expect the datapoint attribute-value pairs "{dpa_name}" and "{dpa_value}" in datasource with id "{datasource_id}" in channel "{channel_classifier}" on timestamp "{timestamp}"	Validates data point attribute values in a channel classifier.
Then	I expect the datapoint previous value to be equal to "{value}" for the timestamp "{timestamp}" on the channel "{channel_name}" in the edits history for the datasource with id "{datasource_id}"[ with edit reason "{edit_reason}" and user email "{user_email}"]	Checks that the previous value of a datapoint is as expected in the edits history. Optionally, edit reason and user email can be verified in the edits history.
Then	I expect the flag with the name "{flag_name}" on datasource with id "{datasource_id}" on the channel "{channel_name}" and the datapoint "{timestamp}"	Checks that a specific flag is present on a datapoint in a channel.
Then	I expect the following annotations for datasource with ID "{datasource_id}" between "{start}" and "{end}":	Checks multiple annotations in a single polling loop.
Then	I expect the following datapoint attribute-value pairs in datasource with id "{datasource_id}" in channel "{channel_classifier}" on timestamp "{timestamp}":	Validates data point attribute values in a channel classifier.
Then	I expect the following datapoint values on datasource "{datasource_id}" between "{start}" and "{end}":	Validates multiple datapoint values across channels in a single API call.
Then	I expect the following datapoint values on datasource "{datasource_id}" for the last flow on the destination channel "{destination_classifier}" between "{start}" and "{end}":	Validates multiple datapoint values across channels for the last flow in a single API call.
Then	I expect the latest value on datasource "{datasource_id}" for channel "{channel_classifier}" to match:	Validates the latest value for a datasource and channel using the getLatestValue API v2 endpoint.
Then	I verify the timeseries datapoint version of channel "{channel_classifier}" in ds id "{datasource_id}" with timestamp "{timestamp}" got updated with new datapoint version value after ingestion	Verify DP version value got updated after ingestion.

Virtual datasources

Type	Step	What it does
Given	I clear the flow reference from virtual datasource "{virtual_datasource_name}"	Clears the flowReferenceId on a virtual datasource by sending an empty string.
Given	I create a virtual datasource with name "{virtual_datasource_name}" using the filter "{virtual_datasource_filter}"	Creates a virtual datasource.
Given	I create a virtual datasource with name "{virtual_datasource_name}" using the filter "{virtual_datasource_filter}" and channel classifier "{virtual_datasource_classifier}"	Creates a virtual datasource.
Given	I create a virtual datasource with name "{virtual_datasource_name}" using the filter "{virtual_datasource_filter}" with channels "{channel_classifiers_str}" and flow reference "{flow_reference_name}" and triggerNow	Creates a virtual datasource with a flow reference ID and triggerNow=True.
GivenWhen	I create all virtual datasources from "{virtual_datasource_file_name}"	Creates virtual datasources from json file.
Given	I trigger the virtual datasource "{virtual_datasource_name}"	Triggers a virtual datasource without chained flow but with start and end date range.
Given	I trigger the virtual datasource "{virtual_datasource_name}" with the chained flow design "{flow_design_name}" between "{trigger_start_date}" and "{trigger_end_date}"	Triggers a virtual datasource with a flow design.
Given	I trigger the virtual datasource "{virtual_datasource_name}"$between "{trigger_start_date}" and "{trigger_end_date}"	Triggers a virtual datasource without chained flow but with start and end date range.
Given	I update the virtual datasource "{virtual_datasource_name}" attribute "{attr_name}" to "{attr_value}"	Updates a virtual datasource .
Given	I update the virtual datasource "{virtual_datasource_name}" with flow reference "{flow_reference_name}"	Updates a virtual datasource's flowReferenceId, resolving the flow name to an ID.

Ingestion

Files and ingestion

Type	Step	What it does
Given	I check the number of files in my namespace	Checks the number of files in the namespace.
Given	I delete the file "{file_name}" if exists	Deletes file if exists.
GivenWhenThen	I expect the file "{file_name}" in file manager	Verifies that a file is in storage within default time limit.
GivenThen	I expect the file "{file_name}" to have an attribute "{attr_key}" with value "{attr_value}"	Validates the file's attribute value by file name.
GivenWhenThen	I expect the file with the name "{file_name}" in file manager with content matching the file "{test_data_file_name}"	No description yet
GivenWhenThen	I expect the file with the name containing "{file_name_part}" in file manager within "{time_limit_in_minutes:d}" minutes with a poll frequency of "{polling_freq_in_seconds:d}" seconds	Verifies that a file is in storage within a given time limit, by partial file name search.
GivenWhenThen	I expect the file with the name containing "{file_name_part}" to be absent from file manager within "{time_limit_in_minutes:d}" minutes with a poll frequency of "{polling_freq_in_seconds:d}" seconds	Verifies a file never appears in file manager within a time limit (partial name match).
GivenWhenThen	I expect the file with the name containing "{file_name}" in file manager	Verifies that a file is in storage by partial name search within default time limit.
GivenThen	I expect the file with the name containing "{file_name}" to have an attribute "{attr_key}" with value "{attr_value}"	Validates the file's attribute value using partial file name search.
GivenWhen	I ingest the file "{file_name}"	Ingests a file without specifying a market adapter.
GivenWhen	I ingest the file "{file_name}" with market adapter "{adapter_name}"	Ingests a file using a given market adapter to do so.
Given	I upload the file "{file_name}" with market adapter "{adapter_name}" assigned and tags "{tag_names}" added	Uploads a file to file management with assigned market adapter, and adds the given tags to it.
GivenWhen	I upload the file "{file_path}"	Uploads files to file management.
Given	I upload the file "{file_path}" as "{new_file_name}" where the value for "{key}" is "{value}"	Uploads a file to the file management with the specified name, and saves the specified value with the key in the context to share among steps.
Given	I upload the file "{file_path}" where the value for "{key}" is "{value}"	Uploads a file to the file management and saves the specified value with the key in the context to share among steps.
Given	I upload the file "{file_path}" with market adapter "{adapter_name}" assigned	Uploads a file to file management with assigned market adapter.
Given	there is no datasource with id "{datasource_id}" I upload and ingest the file "{file_path}" with market adapter "{market_adapter_name}"	Conditional ingestion if a given datasource does not exist. This is helpful for scenarios where the setup might be expensive. For example when the test depends on the existence of a datasource with particularly big sizes.
When	I add the tags "{tags}" to the file "{file_name}"	Adds tags to the specified file.
When	I add the tags "{tags}" to the file with the name "{partial_file_name}"	Adds tags to the specified file.
When	I add the tags "{tags}" to the file with the name containing "{partial_file_name}"	Adds tags to the file by partial file name (allowing prefix).
When	I assign market adapter with the name "{adapter_name}" to the file "{file_name}"	Assigns a market adapter to the specified file.
When	I delete tag "{tag_name}" from the file "{file_name}"	Deletes the given tag from the specified file.
When	I delete the file "{file_name}"	Deletes the specified file.
Then	I expect "{file_name}" in file manager within "{time_limit_in_minutes:d}" minutes with a poll frequency of "{polling_freq_in_seconds:d}" seconds	Verifies that a file is in storage within a given time limit.
Then	I expect the file with the name "{file_name}" in file manager with content matching the file "{test_data_file_name}" after processed by script in "{script_path}"	No description yet
Then	I expect the file with the partial name "{file_name}" in file manager with content matching the file "{test_data_file_name}" after processed by script in "{script_path}"	No description yet
Then	I should see the details of the file "{file_name}"	Checks the details of the specified file.
Then	I should see the tags "{tags}" in the file "{file_name}"	Validates if the given tags are present in the specified file.
Then	I should see the tags "{tags}" in the file with the name "{file_name}"	Validates if the given tags are present in the specified file.
Then	I should see the tags "{tags}" in the file with the name containing "{partial_file_name}"	Validates if the given tags are present in the file searched by partial name (allowing prefix).
Then	the file "{file_name}" should be linked to market adapter with the name "{adapter_name}"	Validates the specified file is linked to the given market adapter.
Then	the file "{file_name}" should be linked to the market adapter with the name "{ma_name}"	Validates if the file is linked to the given market adapter by file name.
Then	the file with the name containing "{file_name}" should be linked to the market adapter with the name "{ma_name}"	Validates if the file is linked to the given market adapter by partial file name search.
Then	the number of files has decreased by "{expected_decrease:d}"	Validates the number of files has decreased to an expected value within a given time limit.
Then	the number of files has decreased by "{expected_decrease:d}" within "{time_limit_in_minutes:d}" minutes with a poll frequency of "{polling_freq_in_seconds:d}" seconds	Checks if the number of files has decreased by a certain amount within a given time limit.
Then	the number of files has increased by "{expected_increase:d}"	Validates the number of files has increased to an expected value within a given time limit.
Then	the number of files has increased by "{expected_increase:d}" within "{time_limit_in_minutes:d}" minutes with a poll frequency of "{polling_freq_in_seconds:d}" seconds	Checks if the number of files has increased by a certain amount within a given time limit.
Then	The tag "{tag_name}" is not present in the file "{file_name}"	Validates that the given tag is not present in the specified file.
Then	there is/are "{expected_amount:d}" file(s) created after ingestion	Verifies that the number of files created after ingestion is as expected.

Market adapters

Type	Step	What it does
Given	I check the number of market adapters in my namespace	Checks the number of market adapters in the namespace.
Given	I create a configured market adapter from "{file_name}"	Creates a market adapter from a file and replaces its Transformation Configuration names with IDs.
Given	I create a market adapter from "{file_name}" with configuration "{conf_name}"	Creates a market adapter from a file and a given transformation configuration.
Given	I create a market adapter from "{file_name}" with transformation configuration "{conf_name}"	Creates a market adapter from a file and a given transformation configuration.
GivenWhen	I create all market adapters from "{file_name}"	Creates market adapters from a given file.
Given	I upload all market adapters matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all market adapters matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all market adapters whose names match the given regex pattern using a specified resource manager.
Given	I upload all market adapters using the default resource manager	No description yet
Given	I upload all market adapters using the resource manager with name "{manager_name}"	Uploads all market adapters using a specified resource manager.
Given	I upload the market adapter with name "{name}" using the default resource manager	No description yet
Given	I upload the market adapter with name "{name}" using the resource manager with name "{manager_name}"	Uploads a market adapter with given name using a specified resource manager.
Then	I have no market adapters anymore	Checks that there are no more market adapters.
Then	I should be able to see the names of all market adapters	Validates whether all marker adapters in the active namespace have names.
Then	I should see the versions of the market adapter with the name "{name}"	Validates that the versions of the market adapter with the given name can be retrieved.
Then	the "{key}" of the market adapter with the name "{name}" should be "{value}"	Validates the value of a specific field of the market adapter with the given name.
Then	the number of market adapters has decreased by "{expected_decrease:d}"	Validates that the number of market adapters has decreased by the expected amount.
Then	the number of market adapters has increased by "{expected_increase:d}"	Validates that the number of market adapters has increased by the expected amount.

Market adapter implementations

Type	Step	What it does
Given	I create a market adapter implementation from "{file_name}"	Creates a market adapter implementation from a JSON file in the test-data directory.
When	I create a market adapter from "{file_name}" linked to implementation with technical name "{impl_tech_name}"	Creates a market adapter from a JSON file and links it to an existing implementation.
When	I delete the market adapter implementation with technical name "{name}"	Deletes the market adapter implementation with the given technical name.
When	I update the market adapter implementation with technical name "{name}" from "{file_name}"	Updates a market adapter implementation by technical name using data from a JSON file.
Then	the market adapter implementation with technical name "{name}" does not exist	Checks that a market adapter implementation with the given technical name does not exist.
Then	the market adapter implementation with technical name "{name}" exists	Checks that a market adapter implementation with the given technical name exists.
Then	the market adapter implementation with technical name "{name}" has the attribute "{attr_name}" with value "{attr_value}"	Checks that a market adapter implementation has the expected value for a given attribute.
Then	the market adapter with the name "{ma_name}" has an implementation with technical name "{impl_tech_name}"	Checks that a market adapter is linked to the expected implementation.

Transformation configurations

Type	Step	What it does
Given	I check the number of transformation configurations in my namespace	Fetches the transformation configurations in the namespace and places them in the tests context dictionary.
Given	I create a transformation configuration from "{file_name}" with flow design "{flow_design_name}"	Creates a transformation configuration with a flow design from a file.
Given	I create all transformation configurations from "{file_name}"	Creates a transformation configuration from a file.
Given	I expect in transformation configuration with name "{tc_name}" the flow properties to contain the key "{prop_key}" with the value "{prop_value}"	Validates the flow property key-value of the given transformation configuration.
Given	I upload all transformation configurations matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all transformation configurations matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all transformation configurations whose names match the given regex pattern using a specified resource manager.
Given	I upload all transformation configurations using the default resource manager	No description yet
Given	I upload all transformation configurations using the resource manager with name "{manager_name}"	Uploads all transformation configurations using a specified resource manager.
Given	I upload the transformation configuration with name "{name}" using the default resource manager	No description yet
Given	I upload the transformation configuration with name "{name}" using the resource manager with name "{manager_name}"	Uploads a transformation configuration with given name using a specified resource manager.
Then	I have no transformation configurations anymore	Checks that there are no transformation configurations.
Then	I should be able to see the names of all transformation configurations	Validates whether all transformation configurations in the active namespace have a name.
Then	I should see the versions of the transformation configuration with the name "{name}"	Validates whether the versions of the transformation configuration with the given name can be fetched.
Then	the number of transformation configurations has decreased by "{expected_decrease:d}"	Validates that the number of transformation configurations has decreased by an expected amount.
Then	the number of transformation configurations has increased by "{expected_increase:d}"	Validates that the number of transformation configurations has increased by an expected amount.

SOAP endpoints

Type	Step	What it does
GivenThen	I consume the soap endpoint with name "{soap_endpoint_name}" with the file "{file_name}"	Consumes a SOAP endpoint using a given file.
Given	I create all soap endpoints from "{soap_endpoints_file_name}"	Creates SOAP endpoints from a file.
GivenWhen	I delete the soap endpoint with name "{soap_endpoint_name}"	Delete SOAP endpoint.
Given	I expect to receive an error "{error_text}" on consuming SOAP endpoint with name "{soap_endpoint_name}" from template file "{file_name}"	Consumes a SOAP endpoint using a given file and verify the error for incorrect XML content.
Given	I update the attribute "{attribute}" with value "{value}" for soap endpoint name "{soap_endpoint_name}"	Updates a SOAP endpoint attributes.
Given	I upload all SOAP endpoints matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all SOAP endpoints matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all SOAP endpoints whose names match the given regex pattern using a specified resource manager.
Given	I upload all SOAP endpoints using the default resource manager	No description yet
Given	I upload all SOAP endpoints using the resource manager with name "{manager_name}"	Uploads all SOAP endpoints using a specified resource manager.
Given	I upload the SOAP endpoint with name "{name}" using the default resource manager	No description yet
Given	I upload the SOAP endpoint with name "{name}" using the resource manager with name "{manager_name}"	Uploads a SOAP endpoint with given name using a specified resource manager.
GivenThen	there is/are "{expected_count:d}" SOAP endpoint(s) created	Retrieves all SOAP endpoints.
Then	I expect "{expected_count:d}" SOAP response file(s) with operation "{soap_operation_name}"	Find the SOAP message response file.
Then	I expect the attribute "{attribute}" contains the value "{expected_value}" for soap endpoint name "{soap_endpoint_name}"	Retrieves a SOAP details based on the name and check the attributes.

Inbound REST integration service

Type	Step	What it does
When	I send the EREX aggregated measurement series message "{file_name}" to the inrest service	Sends an EREX aggregated measurement series payload to the inrest service.
Then	the accepted EREX message is stored in the file manager within "{timeout:d}" seconds	Polls the file manager for the file the inrest service creates for an accepted message.
Then	the inrest service accepts the message	Asserts the inrest response is a 200 referencing the sent message id.

Integrations stub (external systems)

Type	Step	What it does
Given	the integrations stub has no recorded messages	Clears the stub's queued and sent message state.
Given	the integrations stub is reachable	Asserts the deployed integrations stub answers its health endpoint.
When	I queue an inbound "{message_type}" message with content type "{content_type}" on the integrations stub	Queues an inbound message on the stub for the soap-hub scheduler's next poll.
When	the integrations stub http-pull document is updated	Publishes a new revision of the stubbed http_pull document.
Then	the integrations stub receives a sent message containing "{text}" within "{timeout:d}" seconds	Polls the stub until a message whose SOAP XML contains the given text was sent to it.
Then	the integrations stub receives an acknowledgement for the queued message within "{timeout:d}" seconds	Polls the stub for an acknowledgement referencing the queued message.
Then	the stubbed document source receives a conditional http-pull request within "{timeout:d}" seconds	Polls the stub's document source until a conditional GET was recorded.
Then	the stubbed SEL meter is polled within "{timeout:d}" seconds	Polls the stub's SEL meter counters until the modbus service has connected and read registers.
Then	the stubbed target API receives a request for path "{path}" within "{timeout:d}" seconds	Polls the stub's ribs target facade until a request for the given path was recorded.

Pub/Sub

Type	Step	What it does
Given	I create the pubsub subscriber to subscription "{name}"	Creates a pubsub subscription.
Then	I pull 1 message from the pubsub subscription "{name}" and compare it with the content in file "{file_path}"	Pulls 1 message from pubsub subscription and compares the content with the payload of a given file.
Then	I pull 1 message from the pubsub subscription "{name}" and compare it with the content in file "{file_path}" after processed by script in "{script_path}"	Pulls 1 message from pubsub subscription and compares the content with the payload of a given file. The content of the file and the output of pubsub is processed by a script before comparison.
Then	I pull 1 message from the pubsub subscription "{name}" and compare it with the content in file "{file_path}" and correlation_id "{correlation_id}"	Pulls 1 message from a pubsub subscription and compares both its data payload and its ``correlationId`` attribute with the expected values.

Processing and business logic

Flow designs

Type	Step	What it does
Given	I check the number of flow designs in my namespace	Fetches the flow designs from the active namespace and stores them on the context.
Given	I create all flow designs from "{flow_designs_file_name}"	Creates flow designs from a file.
Given	I create all flow designs from "{flow_designs_file_name}" and decision trees from "{decision_trees_file_name}"	Creates flow designs and decision trees from a file.
GivenWhenThen	I create the delta variable "{variable_name}" with a timeout of "{timeout_in_seconds:d}" seconds from now	No description yet
GivenWhen	I trigger the flow design "{flow_design_name}" for the datasource "{datasource_id}" with the channel classifier "{channel_classifier}" between "{start_date}" and "{end_date}"	Triggers a flow for a Datasource.
GivenWhenThen	I update in the flow design "{flow_to_update}" the sequence name "{seq_to_update}" the rule function "{rule_function_name}" with parameter key "{param_key_to_update}" the new value "{value_to_update}"	Update flow - seq - rule parameter.
Given	I upload all flows matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all flows matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all flows whose names match the given regex pattern using a specified resource manager.
Given	I upload all flows using the default resource manager	No description yet
Given	I upload all flows using the resource manager with name "{manager_name}"	Uploads all flows using a specified resource manager.
Given	I upload the flow with name "{name}" using the default resource manager	No description yet
Given	I upload the flow with name "{name}" using the resource manager with name "{manager_name}"	Uploads a flow with given name using a specified resource manager.
When	I trigger the datasource flow design "{flow_design_name}" for the datasource "{datasource_id}"	Triggers a flow for a Datasource.
When	I trigger the datasource flow design "{flow_design_name}" for the datasource "{datasource_id}" between "{start_date}" and "{end_date}"	Triggers a flow for a Datasource.
Then	I have no flow designs anymore	Validates that there are no flow designs.
Then	I should be able to see the names of all flow designs	Validates that all flow designs in the active namespace have names.
Then	I should see the versions of the flow design with the name "{flow_name}"	Validates that the versions of the flow design with the given name can be retrieved.
Then	the number of flow designs has decreased by "{expected_decrease:d}"	Validates that the number of flow designs has decreased by the expected amount.
Then	the number of flow designs has increased by "{expected_increase:d}"	Validates that the number of flow designs has increased by the expected amount.

Rules

Type	Step	What it does
Given	I check the number of rules of rule type "{rule_type_name}" in my namespace	Fetches the rules of a specific type from the namespace and stores them in the tests context dictionary.
Given	I create all rules from "{file_name}"	Creates all rules present in a given file.
Given	I upload all rules matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all rules matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all rules whose names match the given regex pattern using a specified resource manager.
Given	I upload all rules using the default resource manager	No description yet
Given	I upload all rules using the resource manager with name "{manager_name}"	Uploads all rules using a specified resource manager.
Given	I upload all transform rules matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all transform rules matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all transform rules whose names match the given regex pattern using a specified resource manager.
Given	I upload all transform rules using the default resource manager	No description yet
Given	I upload all transform rules using the resource manager with name "{manager_name}"	Uploads all transform rules using a specified resource manager.
Given	I upload the rule with name "{name}" using the default resource manager	No description yet
Given	I upload the rule with name "{name}" using the resource manager with name "{manager_name}"	Uploads a rule with given name using a specified resource manager.
Given	I upload the transform rule with name "{name}" using the default resource manager	No description yet
Given	I upload the transform rule with name "{name}" using the resource manager with name "{manager_name}"	Uploads a transform rule with given name using a specified resource manager.
When	I change the "{key}" of the rule with the name "{name}" to "{value}"	Updates the value of a given key of the rule with the given name.
When	I create a rule from "{file_name}"	Creates a rule from a given file.
When	I delete the rule with the name "{name}"	Deletes the rule with the given name.
Then	I should be able to see the content of the rule types	Validates that all the rule types in the namespace have contents.
Then	I should be able to see the names of all rules of type "{rule_type_name}"	Validates that all the rules in the namespace have a name.
Then	I should see the versions of the rule with the name "{name}"	Validates that the versions of the rule with the given name can be fetched.
Then	the "{key}" of the rule with the name "{name}" should be "{value}"	Validates the value of a specific field of the rule with the given name.
Then	the number of rules is "{amount:d}"	Checks the number of rules created.
Then	the number of rules of rule type "{rule_type_name}" has decreased by "{expected_decrease:d}"	Validates that the number of rules of a given type has decreased by an expected amount.
Then	the number of rules of rule type "{rule_type_name}" has increased by "{expected_increase:d}"	Validates that the number of rules of a given type has increased by an expected amount.
Then	the rule with the name "{name}" exists	Validates that a rule with the given name exists in the namespace.

Triggers and trigger schedules

Type	Step	What it does
GivenThen	Available triggers technical names are: {names}	Gets a list of available triggers.
Given	I create a Big Query ingest trigger from file "{file_name}" with the market adapter "{ma_name}"	Create a trigger for the BQ ingest service.
Given	I create a flow trigger from file "{file_name}" with the flow "{flow_name}"	Create a trigger for the flow service.
GivenWhen	I create a trigger from file "{file_name}"	Create a trigger.
Given	I create a vds trigger from file "{file_name}" with "{flow_name}" chained flow	Create a trigger for the VDS service with chained flow.
GivenWhenThen	I update the trigger with the name "{trigger_name}" the attribute "{attribute}" to "{value}"	Updates an attribute of a trigger
Given	I upload all trigger schedules matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all trigger schedules matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all trigger schedules whose names match the given regex pattern using a specified resource manager.
Given	I upload all trigger schedules using the default resource manager	No description yet
Given	I upload all trigger schedules using the resource manager with name "{manager_name}"	Uploads all trigger schedules using a specified resource manager.
Given	I upload the trigger schedule with name "{name}" using the default resource manager	No description yet
Given	I upload the trigger schedule with name "{name}" using the resource manager with name "{manager_name}"	Uploads a trigger schedule with given name using a specified resource manager.
When	I execute the trigger with the name "{trigger_name}"	Execute a trigger manually.
Then	I check created time of the file "{file_name}" after the trigger is executed	Check that file's creation time is according to trigger schedule (by file name).
Then	I check created time of the file with the name containing "{file_name}" after the trigger is executed	Check that file's creation time is according to trigger schedule (using partial file name search).
Then	I check the flow timestamp on channel classifier "{channel_classifier}" on datasource "{datasource_id}" after the trigger is executed	Checks that the flow timestamp is according to trigger execution time.

Decision trees

Type	Step	What it does
Given	I create all decision trees from "{file_name}"	Creates decision trees from a given file.
Given	I set the default decision tree in the current namespace to "{decision_tree_name}"	Sets the default decision tree in the current namespace to the given name.
Given	I upload all flow decision trees matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all flow decision trees matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all flow decision trees whose names match the given regex pattern using a specified resource manager.
Given	I upload all flow decision trees using the default resource manager	No description yet
Given	I upload all flow decision trees using the resource manager with name "{manager_name}"	Uploads all flow decision trees using a specified resource manager.
Given	I upload all rule decision trees matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all rule decision trees matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all rule decision trees whose names match the given regex pattern using a specified resource manager.
Given	I upload all rule decision trees using the default resource manager	No description yet
Given	I upload all rule decision trees using the resource manager with name "{manager_name}"	Uploads all rule decision trees using a specified resource manager.
Given	I upload the flow decision tree with name "{name}" using the default resource manager	No description yet
Given	I upload the flow decision tree with name "{name}" using the resource manager with name "{manager_name}"	Uploads a flow decision tree with given name using a specified resource manager.
Given	I upload the rule decision tree with name "{name}" using the default resource manager	No description yet
Given	I upload the rule decision tree with name "{name}" using the resource manager with name "{manager_name}"	Uploads a rule decision tree with given name using a specified resource manager.

Timeslice groups

Type	Step	What it does
GivenWhen	I create all timeslice groups from "{file_name}"	Creates timeslice groups from a given file.
Given	I upload all timeslice groups matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all timeslice groups matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all timeslice groups whose names match the given regex pattern using a specified resource manager.
Given	I upload all timeslice groups using the default resource manager	No description yet
Given	I upload all timeslice groups using the resource manager with name "{manager_name}"	Uploads all timeslice groups using a specified resource manager.
Given	I upload the timeslice group with name "{name}" using the default resource manager	No description yet
Given	I upload the timeslice group with name "{name}" using the resource manager with name "{manager_name}"	Uploads a timeslice group with given name using a specified resource manager.
GivenThen	The attribute with name "{attribute}" of timeslice group "{group_name}" is set to "{value}"	Validates that the attribute of a timeslice group is present and has the expected value.
GivenThen	The number of timeslice groups is "{amount:d}"	Validates the number of timeslice groups is as expected.
GivenThen	The timeslice group with name "{group_name}" has "{amount:d}" historical versions	Validates that the number of historical versions of a timeslice group is as expected.
Given	The timeslice group with name "{group_name}" has "{amount:d}" versions	Validates that the number of versions of a timeslice group is as expected.
When	I set the "{attribute}" of the timeslice group with name "{group_name}" to "{value}"	Updates a attribute on a given timeslice group.
Then	The timeslice group with name "{group_name}" has "{amount:d}" old versions	Validates that the number of versions of a timeslice group is as expected.

ML models

Type	Step	What it does
Given	I create an ML model with name "{model_name}", runtime "{runtime}" and file "{file_name}"	Creates a new ML Model.
Given	I update an ML model with name "{model_name}", runtime "{runtime}" and file to "{file_name}"	Updates the ML Model with the model_name.
Given	There is an ML model with the name "{model_name}"	Checks if an ML Model exist.
When	I delete the ML model with the name "{model_name}"	Deletes an ML Model.
When	I deploy the ML model with the name "{model_name}"	Deploys an ML Model.
When	I disable the ML model with the name "{model_name}"	Disables an ML Model.
Then	I expect an ML model with the name "{model_name}", runtime "{runtime}", file "{file_name}" and active status "{active}"	Checks if an ML Model has all these values in its attributes.
Then	I expect there is no ML model with the name "{model_name}"	Checks if an ML Model does not exist.

Computed flags

Type	Step	What it does
Given	I create all flags from "{file_name}"	Creates all flags present in a given file.
Then	I expect the flag with the name "{name}" to have the attribute "{attr}" with the value "{value}"	Checks if the value of an attribute in the flag.

Tasks, task boards, statuses and types

Type	Step	What it does
Given	I create a task status with name "{name}"	Creates a new task status with the given name.
Given	I create a task status with name "{name}", if it doesn't exist	Creates a new task status with the given name, if it doesn't exist.
Given	I create a task type with name "{name}"	Creates a new task type with the given name, if it doesn't exist.
Given	I create all task boards from "{file_name}"	Creates task boards from a given file.
Given	I save the number of tasks on the current namespace	Save the number of tasks.
Given	I upload all task statuses matching the regex pattern '{pattern}' using the default resource manager	No description yet
Given	I upload all task statuses matching the regex pattern '{pattern}' using the resource manager with name '{manager_name}'	Uploads all task statuses whose names match the given regex pattern using a specified resource manager.
Given	I upload all task statuses using the default resource manager	No description yet
Given	I upload all task statuses using the resource manager with name '{manager_name}'	Uploads all task statuses using a specified resource manager.
Given	I upload all task types matching the regex pattern '{pattern}' using the default resource manager	No description yet
Given	I upload all task types matching the regex pattern '{pattern}' using the resource manager with name '{manager_name}'	Uploads all task types whose names match the given regex pattern using a specified resource manager.
Given	I upload all task types using the default resource manager	No description yet
Given	I upload all task types using the resource manager with name '{manager_name}'	Uploads all task types using a specified resource manager.
Given	I upload all taskboards matching the regex pattern '{pattern}' using the default resource manager	No description yet
Given	I upload all taskboards matching the regex pattern '{pattern}' using the resource manager with name '{manager_name}'	Uploads all taskboards whose names match the given regex pattern using a specified resource manager.
Given	I upload all taskboards using the default resource manager	No description yet
Given	I upload all taskboards using the resource manager with name '{manager_name}'	Uploads all taskboards using a specified resource manager.
Given	I upload the task status with name '{name}' using the default resource manager	No description yet
Given	I upload the task status with name '{name}' using the resource manager with name '{manager_name}'	Uploads a task status with given name using a specified resource manager.
Given	I upload the task type with name '{name}' using the default resource manager	No description yet
Given	I upload the task type with name '{name}' using the resource manager with name '{manager_name}'	Uploads a task type with given name using a specified resource manager.
Given	I upload the taskboard with name '{name}' using the default resource manager	No description yet
Given	I upload the taskboard with name '{name}' using the resource manager with name '{manager_name}'	Uploads a taskboard with given name using a specified resource manager.
Given	the number of tasks is "{amount:d}"	Check the number of tasks.
WhenThen	I expect "{amount:d}" task(s) with the title "{title}" within "{time_limit_in_minutes:d}" minutes with a poll frequency of "{polling_frequency_in_seconds:d}" seconds	Poll to check if the expected amount of tasks with given title exist.
WhenThen	the task with the title "{title}" exists within "{time_limit_in_minutes:d}" minutes with a poll frequency of "{polling_frequency_in_seconds:d}" seconds	Poll to check if the task with given title exists.
Then	I expect the number of tasks to be "{amount:d}"	Check the number of tasks.
Then	I expect the task with the title "{task_title}" on the task board with the name "{task_board_name}"	Check if the task is on the task board.
Then	I expect the task with the title "{task_title}" on the task board with the name "{task_board_name}" under status "{task_status}"	Check if the task is on the task board under appropriate status.
Then	I expect there to be "{amount:d}" more tasks within "{time_limit_in_minutes:d}" minutes with a poll frequency of "{polling_frequency_in_seconds:d}" seconds	Check if the number of tasks has increased by a certain amount.
Then	the task with the title "{task_title}" has the attribute "{attribute_name}" with the value "{attribute_value}"	Check some of the tasks attributes value.
Then	the task with the title "{task_title}" has the following attributes:	Verify multiple task attributes in a single API call.
Then	the task with the title "{task_title}" has the subject attribute "{attribute_name}" with the value "{attribute_value}"	Check the attribute value "subject" of the task.
Then	the task with the title "{task_title}" is linked to the task board with the name "{task_board_names}"	Check if the task is linked to the task board.

Administration

Namespaces

Type	Step	What it does
GivenWhen	I bootstrap the current namespace	Bootstraps the current namespace.
GivenWhen	I bootstrap the namespace with id "{namespace_id}"	Bootstraps the namespace which was created by the `Given I create a namespace from "generic_customer.json"` step.
Given	I set the "{property_name}" in the current namespace to "{property_value}"	Sets a property in the current namespace.
Given	I upload all namespace properties matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all namespace properties matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all namespace properties whose names match the given regex pattern using a specified resource manager.
Given	I upload all namespace properties using the default resource manager	No description yet
Given	I upload all namespace properties using the resource manager with name "{manager_name}"	Uploads all namespace properties using a specified resource manager.
Given	I upload the namespace property with name "{name}" using the default resource manager	No description yet
Given	I upload the namespace property with name "{name}" using the resource manager with name "{manager_name}"	Uploads a namespace property with given name using a specified resource manager.
Then	I expect the current namespace to be bootstrapped	Makes sure that all needed resources have been instantiated in Datastore, BigTable and BigQuery.

Billing account

Type	Step	What it does
Given	I add the property with the key "{prop_key}" with the value "{prop_value}" to the current billing account	Adds a property key-value to the current billing account.
Given	I create a namespace with the name "{namespace_name}" in the billing account with id "{billing_account_id}"	Creates a namespace to be used by the test.
GivenThen	I do not expect the current billing account to contain the property key '{prop_key}' with the value '{prop_value}'	Checks that a property key-value of the current billing account does not exist.
Given	I expect the current billing account to contain the property key "{prop_key}" with the value "{prop_value}"	Checks a property key-value of the current billing account.
GivenThen	I remove the property with the key "{prop_key}" with the value "{prop_value}" from the current billing account	Removes a property key-value from the current billing account.

Identity and test users

Type	Step	What it does
GivenWhen	I act as the environment identity	Puts the environment's own identity back in charge.
GivenWhen	I act as the test user "{email}"	Makes the provisioned user the acting identity for the rest of the scenario.
Given	I provision the test user "{email}" with the groups "{group_ids}" on the namespace "{namespace_id}"	Grants a user the given groups on a namespace and mints credentials that act as them.
Given	I provision the test user "{email}" without any grant	Mints credentials that act as a user who holds no grant anywhere.
When	I refresh the token of the test user "{email}"	Drops the cached token of a provisioned user so the next request mints a fresh one.
Then	I cannot mint credentials for the user "{email}"	Asserts that minting credentials that act as the given user is refused.

IAM grants

Type	Step	What it does
GivenWhen	I create an email domain rule for "{domain}" granting the groups "{group_ids}" on the namespace "{namespace_id}"	Creates a rule granting the given groups to everyone with an address in the domain.
GivenWhen	I delete the email domain rule for "{domain}" on the namespace "{namespace_id}"	Deletes a rule.
GivenWhen	I grant the user "{email}" the groups "{group_ids}" on the namespace "{namespace_id}"	Grants a user the given permission groups on a namespace.
GivenWhen	I make the user "{email}" an administrator	Makes a user a platform administrator.
GivenWhenThen	I revoke the access of the user "{email}" to the namespace "{namespace_id}"	Revokes a user's access to a namespace.
GivenWhen	I revoke the administrator flag of the user "{email}"	Takes the platform administrator flag away from a user.
When	I change the groups of the user "{email}" on the namespace "{namespace_id}" to "{group_ids}"	Replaces the permission groups a user holds on a namespace.
When	I remove the property "{key}" for the user "{email}" on the namespace "{namespace_id}"	Removes a property a user holds in a namespace.
When	I set the property "{key}" to "{value}" for the user "{email}" on the namespace "{namespace_id}"	Sets a property a user holds in a namespace.
Then	a grant without groups is refused for the user "{email}" on the namespace "{namespace_id}"	Asserts creating a grant that names no groups is refused.
Then	a rule without groups is refused for "{domain}" on the namespace "{namespace_id}"	Asserts creating a rule that names no groups is refused.
Then	apiv1.5 grants the acting identity the scope "{permission}" on "{resource}"	Asserts apiv1.5 reports the given scope for the acting identity.
Then	apiv1.5 reports the acting identity as an administrator	Asserts apiv1.5 agrees the acting identity is a platform administrator.
Then	apiv1.5 reports the groups "{group_ids}" for the acting identity on the namespace "{namespace_id}"	Asserts apiv1.5 reads back the same groups the gateway wrote.
Then	changing the groups of the user "{email}" on the namespace "{namespace_id}" to none is refused	Asserts emptying the groups of an existing grant is refused.
Then	I expect an IAM audit event by the acting identity about the user "{target}" containing the text "{log_substring}"	Asserts an IAM audit event was emitted naming both the actor and the user it was about.
Then	the account of the acting identity records no identity provider	Asserts an account materialised by a client-credentials mint has no provider bound.
Then	the acting identity can reach the datasources of the namespace "{namespace_id}"	Asserts the acting identity is not refused on the datasources of a namespace.
Then	the acting identity can read the grants of the namespace "{namespace_id}"	Asserts the acting identity may list the grants of a namespace.
Then	the acting identity can read their own account	Asserts the acting identity may read their own account without being an administrator.
Then	the acting identity cannot create a rule on the namespace "{namespace_id}"	Asserts the acting identity is refused when creating a rule on a namespace.
Then	the acting identity cannot grant the user "{email}" on the namespace "{namespace_id}"	Asserts the acting identity is refused when creating a grant on a namespace.
Then	the acting identity cannot make the user "{email}" an administrator	Asserts a non-administrator is refused when handing out the administrator flag.
Then	the acting identity cannot read the account of the user "{email}"	Asserts a non-administrator is refused when reading somebody else's account.
Then	the acting identity cannot read the datasources of the namespace "{namespace_id}"	Asserts the acting identity is refused on the datasources of a namespace.
Then	the acting identity cannot read the grants of the namespace "{namespace_id}"	Asserts the acting identity is refused when listing the grants of a namespace.
Then	the acting identity cannot revoke the user "{email}" from the namespace "{namespace_id}"	Asserts the acting identity is refused when revoking a grant on a namespace.
Then	the acting identity has platform access on the namespace "{namespace_id}"	Asserts apiv1.5 agrees the acting identity may reach a namespace.
Then	the acting identity is refused on the namespace "{namespace_id}"	Asserts apiv1.5 refuses the acting identity on a namespace.
Then	the email domain rule for "{domain}" is listed on the namespace "{namespace_id}"	Asserts a rule turns up in the listing of a namespace.
Then	the email domain rule for "{domain}" on the namespace "{namespace_id}" grants the groups "{group_ids}"	Asserts a rule names exactly the given groups.
Then	the grant of the user "{email}" is listed on the namespace "{namespace_id}"	Asserts the grant of a user turns up in the listing of a namespace.
Then	the grant of the user "{email}" is not listed on the namespace "{namespace_id}"	Asserts the grant of a user does not turn up in the listing of a namespace.
Then	the user "{email}" cannot revoke their own administrator flag	Asserts an administrator cannot take their own flag away.
Then	the user "{email}" holds no grant on the namespace "{namespace_id}"	Asserts a user holds no grant on a namespace.
Then	the user "{email}" holds no property "{key}" on the namespace "{namespace_id}"	Asserts a user holds no property of the given key in a namespace.
Then	the user "{email}" holds the groups "{group_ids}" on the namespace "{namespace_id}"	Asserts the grant of a user on a namespace names exactly the given groups.
Then	the user "{email}" holds the property "{key}" with value "{value}" on the namespace "{namespace_id}"	Asserts a user holds the given property in a namespace.
Then	the user "{email}" is an administrator	Asserts a user carries the platform administrator flag.
Then	the user "{email}" is not an administrator	Asserts a user does not carry the platform administrator flag.
Then	there is no email domain rule for "{domain}" on the namespace "{namespace_id}"	Asserts no rule exists for the given domain.

Permission groups

Type	Step	What it does
Given	I create the group "{group_name}" from file "{file_name}"	Create group using json payload from file.
Given	I upload all permission groups matching the regex pattern "{pattern}" using the default resource manager	No description yet
Given	I upload all permission groups matching the regex pattern "{pattern}" using the resource manager with name "{manager_name}"	Uploads all permission groups whose names match the given regex pattern using a specified resource manager.
Given	I upload all permission groups using the default resource manager	No description yet
Given	I upload all permission groups using the resource manager with name "{manager_name}"	Uploads all permission groups using a specified resource manager.
Given	I upload the permission group with name "{name}" using the default resource manager	No description yet
Given	I upload the permission group with name "{name}" using the resource manager with name "{manager_name}"	Uploads a permission group with given name using a specified resource manager.
When	I set permission scope to "{state_to_set}" for group "{group_name}"	Set scopes for group stored in tests context dictionary.
When	I update group "{group_name}" using template "{file_name}"	Update group properties using json file template.
Then	I cannot update group "{group_name}" with property "{property_name}" being blank	Verify that group without cannot be updated if name property specified incorrectly.
Then	the group "{group_name}" contains scope property "{attribute}" with value "{value}"	Verify that group have property.
Then	the group "{group_name}" contains the attribute "{attribute}" with value "{value}"	Verify that group have property.
Then	the group "{group_name}" do not have scopes	Verify that created group do not have scopes.
Then	the group "{group_name}" is created	Get group details and verify that it exists.
Then	the group "{group_name}" is deleted	Delete created group that saved in test context dictionary.
Then	the group "{group_name}" is in "{state_to_check}"	Verify that group blacklisted or whitelisted.
Then	the group with blank property "{property_name}" cannot be created	Create new group and verify that is not possible due to name object is empty.

Process monitoring (Promo)

Type	Step	What it does
GivenThen	I check the following metrics for the promo config with the name "{name_promo}":	Checks multiple metrics of a promo config in a single polling cycle using a DataTable.
GivenThen	I check the metric with the name "{metric_name}" has value "{value}" for the promo config with the name "{name_promo}"	Checks the metrics of the instance.
GivenThen	I check the number of promo configs is equal "{amount:d}"	Checks the amount of promo configurations that exist in the namespace.
Given	I create all promo configs from "{file_name}"	Creates all promo configurations present in a given file.
GivenWhen	I delete the promo config "{name}"	Delete the promo config.
Given	I try to create invalid promo config from "{file_name}" and expect status code "{status_code:d}" and message "{message}"	No description yet
Then	I assign the flow design with name "{flow_design_name}" to promo config "{name}"	Assigns a flow design to promo configuration.
Then	I assign the market adapter with name "{ma_name}" to promo config "{name}"	Assigns a market adapter to promo configuration.
Then	I check if the flow design with name "{flow_design_name}" is assigned to "{name}" config	Checks if a flow design is assigned to a promo.
Then	I check if the market adapter with name "{ma_name}" is assigned to "{name}" config	Checks if a market adapter is assigned to a promo.
Then	I expect a promo config with the name "{name}" to have the attribute "{attr}" with the value "{value}"	Checks if the value of an attribute in the promo config.
Then	I update the attribute "{attr}" with value "{value}" in promo config "{name}"	Updates the attribute with given value in the promo config.

Audit events

Type	Step	What it does
Then	I expect an audit event with severity "{severity}" and contains the text "{log_substring}"	Step that periodically searches for an audit event based on severity level, time and text.
Then	I expect an audit event with severity "{severity}" and contains the text "{log_substring}" within "{time_out_in_minutes:d}" minutes with a poll frequency of "{polling_freq_in_seconds:d}" seconds	Step that searches for an audit event based on severity level, time and text.
Then	I expect new audit events	Step to check for the existence of new audit events.

Resource manager

Type	Step	What it does
Given	I create a resource manager from the global configurations directory	No description yet
Given	I create a resource manager with name "{manager_name}" from directory "{dirpath}"	Creates a resource :class:`Manager` with `manager_name` from the provided `dirpath` to use for configuration management.
Given	I create a resource manager with name "{manager_name}" from directory "{dirpath}" with standard package rules "{rule_names_csv}"	Creates a resource manager from a suite's configs merged with rules sourced from the standard package.
Given	I upload all configurations using the default resource manager	No description yet
GivenThen	I upload all configurations using the resource manager with name "{manager_name}"	Uploads all configurations stored in the specified resource manager.
Given	I upload the standard package rules "{rule_names_csv}"	Uploads rules sourced directly from the ``standard_packages`` package (single source of truth).

Chatbot (EnerGPT)

Type	Step	What it does
Given	I expect a successful response when I send a question "{question_text}" to energychat	Send a question to the energychat endpoint and verify a successful response.
Given	I greet the chatbot	Greet the chatbot to initialize a session with a default persona.

Test utilities

Queries (EQL)

Type	Step	What it does
Then	I should be able to find datasource "{datasource_id}" with query "{query}"	Search datasource by id and filter with Query request.
Then	I use advanced search to check in tag "{tag_key}" the property "{property_key}" with value "{property_value}" for datasource "{datasource_id}"	Uses advanced search to check the value a tag property holds in its latest version.
Then	I use advanced search to check that previous version of a datapoint is saved with the value "{value}" for the timestamp "{timestamp}" for the channel "{channel_name}" on a datasource with id "{datasource_id}"	Uses advanced search to check the value of a previous datapoint version.
Then	I use advanced search to check the annotation "{annotation_name}" with the key "{annotation_key}" on the sequence id "{sequence_id}" has a value "{value}" for the timestamp "{timestamp}" for the channel "{channel_name}" on a datasource with id "{datasource_id}"	Uses advanced search to check the DPA value of a datapoint.
Then	I use advanced search to check the annotation "{annotation_name}" with the key "{annotation_key}" on the sequence id "{sequence_id}" has a value "{value}" for the timestamp "{timestamp}" for the channel "{channel_name}" on a datasource with id "{datasource_id}" after {...}	Uses advanced search to check the annotation value of a datapoint after ingestion.
Then	I use advanced search to check the datapoint attribute "{dpa_name}" value is "{value}" for the timestamp "{timestamp}" for the channel "{channel_name}" on a datasource with id "{datasource_id}"	Uses advanced search to check the DPA value of a datapoint.
Then	I use advanced search to check the datapoint attribute "{dpa_name}" value is "{value}" for the timestamp "{timestamp}" for the channel "{channel_name}" on a datasource with id "{datasource_id}" after {...}	Uses advanced search to check the DPA value of a datapoint.
Then	I use advanced search to check the datapoint value is "{value}" for the timestamp "{timestamp}" for the channel "{channel_name}" on a datasource with id "{datasource_id}"	Uses advanced search to check the value of a datapoint.
Then	I use advanced search to check the datapoint value is "{value}" for the timestamp "{timestamp}" for the channel "{channel_name}" on a datasource with id "{datasource_id}" after {...}	Uses advanced search to check the datapoint value of a datapoint after ingestion.
Then	I use advanced search to check the following annotation values with sequence id "{sequence_id}" on datasource "{datasource_id}":	Uses advanced search to check multiple annotation values in a single BQ query per poll cycle.
Then	I use advanced search to check the following datapoint values on datasource "{datasource_id}" after {...}:	Uses advanced search to check multiple datapoint values in a single BQ query per poll cycle.
Then	I use advanced search to check the following datapoint values on datasource "{datasource_id}":	Uses advanced search to check multiple datapoint values in a single BQ query per poll cycle.
Then	I use advanced search to check the following DPA values for channel "{channel_name}" at timestamp "{timestamp}" on a datasource with id "{datasource_id}":	Uses advanced search to check multiple DPA values for a single (channel, timestamp) in one BQ query.
Then	the datasources table should show "{expected_count}" versions? for datasource "{datasource_id}"	Verifies the exact number of versions stored in the datasources table for a datasource.
Then	the latest version in the datasources table for datasource "{datasource_id}" should have the following attributes:	Verifies the latest version of a datasource in the raw datasources table has expected attributes.
Then	the latest_datasources view should show datasource "{datasource_id}" and channel "{channel_name}" with the following attributes:	Verifies that the latest_datasources view contains a channel with expected attributes.
Then	the latest_datasources view should show datasource "{datasource_id}" and channel classifier "{channel_classifier}" with the following attributes:	Verifies a channel in the latest_datasources view, located by its classifier.
Then	the latest_datasources view should show datasource "{datasource_id}" with the following attributes:	Verifies that the latest_datasources view contains a datasource with expected attributes.

Polling

Type	Step	What it does
GivenWhenThen	I wait for "{amount_in_secs:d}" seconds	Pauses the tests for a given amount of seconds.
Then	I do following steps with a timeout of "{timeout}" minutes and a poll frequency of "{poll_freq}" seconds	Sets the timeout and poll frequency in the context to be used for certain requests that need to wait for results.

Generic objects

Type	Step	What it does
GivenWhen	I change the "{key}" attribute of the "{obj_type_name}" with name "{name}" to "{value}"	Updates a string attribute of a certain object with valid value.
GivenWhen	I delete all "{obj_type_name}" from the target namespace	Deletes every object of the given type from the target namespace.
GivenThen	the "{obj_type_name}" with the id "{obj_id}" does not exist	Checks if an object with a given ID exists.
GivenThen	the "{obj_type_name}" with the id "{obj_id}" exists	Checks if an object with a given ID exists.
GivenThen	the "{obj_type_name}" with the name "{obj_name}" does not exist	Checks if an object with a given name does not exist.
GivenWhenThen	the "{obj_type_name}" with the name "{obj_name}" exists	Checks if an object with a given name exists.
When	I cannot create a "{obj_type_name}" with invalid configuration file "{file_name}"	Try to create an object of the given type from invalid configuration file.
When	I cannot update nonexistent "{obj_type_name}" with configuration file "{file_name}"	Try to create an object of the given type from invalid configuration file.
WhenThen	I delete the "{obj_type_name}" with the name "{name}"	Delete an object by name.
When	I update the "{obj_type_name}" with the name "{name}" with configuration file "{file_name}"	Update an object using a file.
Then	changing the "{key}" attribute of the "{obj_type_name}" with name "{name}" to "{value}" returns a Bad Request	Updates a string attribute of a certain object with invalid value.
Then	I cannot get a "{obj_type_name}" by nonexistent id "{nonexistent_id}"	Try to get an object by nonexistent id.
Then	I cannot get deleted "{obj_type_name}" by id	Try to get deleted/nonexistent object by id.
Then	I get the "{obj_type_name}" by id and verify all updated fields	Get an object by id and verify it was updated as expected.

API clients

Type	Step	What it does
Given	I purge all data	Purges all data from the target namespace.
Given	I purge all data I have permission to delete	Purges all data from the target namespace the user has permission to list.
Given	I purge all data I have permission to delete on namespace "{namespace_name}"	Purges all data from the target namespace the user has permission to list.
GivenThen	I switch to api version "{api_version}"	Switches between API 1.5 and 2 versions.
Given	I use the namespace with the name "{nsp_name}"	This step is used to get the namespace id by name and set it for the test run.