Test data

The data for each test can be stored inside the test or in a separate CSV file. To select which location Golem should use, set the test_data setting to ‘csv’ or ‘infile’.

CSV Data

When “test_data” setting is set to “csv” the data will be saved in a separate csv file in the same folder as the test.

Note: All csv values are considered strings. If you need different value types use the ‘infile’ setting.

Infile Data

When using “test_data”: “infile” in settings different Python variable types can be used. Strings must be defined in quotes in the Web Module data table.

data table infile

The test code looks like this:

test_with_infile_data.py

description = 'Hey! this test has infile data!'

data = [
    {
        'numbers': 12,
        'boolean': False,
        'none': None,
        'list': [1,2,3],
        'dict': {'key': 'string'},
        'tuple': (1, '2', 3.0),
        'str_single': 'test',
        'str_double': "test",
    },
    {
        'numbers': 12,
        'boolean': True,
        'none': None,
        'list': ['a', 'b', 'c'],
        'dict': {"key": 12},
        'tuple': ('a', 'a"b"c', "a'b'c"),
        'str_single': 'a "b" c',
        'str_double': "a 'b' c",
    },
]

def test(data):
    navigate('some_url')
    send_keys(('id', 'searchInput'), data.str_single)
    

Infile data is stored as a list of dictionaries. Each dictionary is a different test set.

Adding Values to Data at Runtime

Values can be added to the data object using the store action

def test(data):
    store('title', 'My Title')
    assert_title(data.title)

Accesing data during the test

Data object is present in the execution module during the test.

from golem import execution

print(execution.data.my_value)

Data object is shared among all the functions of a test file::

def setup(data):
    store('title', 'My Title')
    data.username = 'my-username'  # direct assignment also works

def test_one(data):
    assert_title(data.title)
    assert_username(data.username)
   
def test_two(data):
    assert_title_is_not(data.title)
    assert_username_is_not(data.username)

The get_data action can be used to retrieve the data object:

page1.py

from golem import actions

def function():
    print(actions.get_data().title)

Environments

Environments are defined in the environments.json file inside a project. This file can be used to store environment specific data, such as the URL and the user credentials.

For example:

environments.json

{
    "testing": {
        "url": "http://testing.app",
        "users": {
            "user01": {
                "username": "john"
            },
            "user02": {
                "username": "mark"
            }
        }
    },
    "staging": {
        "url": "http://stage.app",
        "users": {
            "user01": {
                "username": "john"
            },
            "user02": {
                "username": "mark"
            }
        }
    }
}

During the execution of the test, the environment data is stored in data.env:

test1.py

def test(data):
    navigate(data.env.url)
    login(data.env.users.user01.username)

Select the Environments For the Test

There are two ways to define the environment (or environments) for a test or suite:

1. from the command line:

   golem run project_name test_name -e testing
   golem run project_name suite_name -e testing staging
   

2. from the definition of a suite:

   suite1.py

   environments = ['testing']
   

Secrets

Secrets are defined in the secrets.json file inside a project. Secrets can be used to store specific data which you do not want to expose in golem test reports / logging such as passwords, hostnames of database systems and temporary test data needed for text execution

Please note: When using secrets in conjunction with default Golem actions, their values can be exposed in the test reports and logs. Exposure is caused by the fact that most default golem actions log their actions.

secrets.json

{
  "database": {
    "host": "db-server.local",
    "user": "db_consumer",
    "password": "abc",
    "port": 5432,
    "schema": "public"
  },
  "secret_user_1": "Joe"
}

During text execution secrets can be stored and retrieved, see examples below.

1. storing and retrieving a secret from a test

def test(data):
    store_secret('password', 'my_password')
    print(get_secrets().password)

1. storing and retrieving a secret from a page

from golem import actions
def some_function():
    actions.store_secret('password', 'my_password')
    print(actions.get_secrets().password)