def run_command(project='',
test_query='',
browsers=None,
processes=1,
environments=None,
interactive=False,
timestamp=None,
reports=None,
report_folder=None,
report_name=None,
tags=None):
execution_runner = ExecutionRunner(browsers, processes, environments,
interactive, timestamp, reports,
report_folder, report_name, tags)
if project:
if utils.project_exists(project):
execution_runner.project = project
session.settings = settings_manager.get_project_settings(project)
# add --interactive value to settings to make
# it available from inside a test
session.settings['interactive'] = interactive
if test_query:
if suite_module.suite_exists(project, test_query):
execution_runner.run_suite(test_query)
elif test_case.test_case_exists(project, test_query):
execution_runner.run_test(test_query)
else:
if test_query == '.':
test_query = ''
path = os.path.join(session.testdir, 'projects', project,
'tests', test_query)
if os.path.isdir(path):
execution_runner.run_directory(test_query)
else:
msg = ('golem run: error: the value {} does not match '
'an existing test, suite or directory'.format(
test_query))
sys.exit(msg)
else:
print(messages.RUN_USAGE_MSG)
test_cases = utils.get_test_cases(project)
print('Test Cases:')
utils.display_tree_structure_command_line(
test_cases['sub_elements'])
test_suites = utils.get_suites(project)
print('\nTest Suites:')
# TODO print suites in structure
for suite in test_suites['sub_elements']:
print(' ' + suite['name'])
else:
msg = ('golem run: error: the project {} does not exist'.format(
project))
sys.exit(msg)
elif interactive:
interactive_module.interactive(session.settings, browsers)
else:
print(messages.RUN_USAGE_MSG)
print('Projects:')
for project in utils.get_projects():
print(' {}'.format(project))
def suite_view(project, suite):
if not user.has_permissions_to_project(g.user.id, project, root_path,
'gui'):
return render_template('not_permission.html')
all_test_cases = utils.get_test_cases(root_path, project)
selected_tests = suite_module.get_suite_test_cases(root_path, project,
suite)
worker_amount = suite_module.get_suite_amount_of_workers(
root_path, project, suite)
browsers = suite_module.get_suite_browsers(root_path, project, suite)
browsers = ', '.join(browsers)
default_browser = test_execution.settings['default_browser']
environments = suite_module.get_suite_environments(root_path, project,
suite)
environments = ', '.join(environments)
return render_template('suite.html',
project=project,
all_test_cases=all_test_cases['sub_elements'],
selected_tests=selected_tests,
suite=suite,
worker_amount=worker_amount,
browsers=browsers,
default_browser=default_browser,
environments=environments)
def test_get_test_cases(self, test_directory_fixture, project_fixture):
test_case.new_test_case(test_directory_fixture['full_path'],
project_fixture['project_name'],
['subdir1', 'subdir2'],
'test3')
test_case.new_test_case(test_directory_fixture['full_path'],
project_fixture['project_name'],
['subdir1'],
'test2')
test_case.new_test_case(test_directory_fixture['full_path'],
project_fixture['project_name'],
[],
'test1')
tests = utils.get_test_cases(test_directory_fixture['full_path'],
project_fixture['project_name'])
expected_result = {
'type': 'directory',
'name': 'tests',
'dot_path': '.',
'sub_elements': [
{
'type': 'directory',
'name': 'subdir1',
'dot_path': 'subdir1',
'sub_elements': [
{
'type': 'directory',
'name': 'subdir2',
'dot_path': 'subdir1.subdir2',
'sub_elements': [
{
'type': 'file',
'name': 'test3',
'dot_path': 'subdir1.subdir2.test3',
'sub_elements': []
}
]
},
{
'type': 'file',
'name': 'test2',
'dot_path': 'subdir1.test2', 'sub_elements': []
}
]
},
{
'type': 'file',
'name': 'test1',
'dot_path': 'test1',
'sub_elements': []
}
]
}
assert tests == expected_result
def test_get_test_cases(self, testdir_fixture, project_fixture):
test_case.new_test_case(testdir_fixture['path'],
project_fixture['name'],
['subdir1', 'subdir2'],
'test3')
test_case.new_test_case(testdir_fixture['path'],
project_fixture['name'],
['subdir1'],
'test2')
test_case.new_test_case(testdir_fixture['path'],
project_fixture['name'],
[],
'test1')
tests = utils.get_test_cases(testdir_fixture['path'],
project_fixture['name'])
expected_result = {
'type': 'directory',
'name': 'tests',
'dot_path': '.',
'sub_elements': [
{
'type': 'directory',
'name': 'subdir1',
'dot_path': 'subdir1',
'sub_elements': [
{
'type': 'directory',
'name': 'subdir2',
'dot_path': 'subdir1.subdir2',
'sub_elements': [
{
'type': 'file',
'name': 'test3',
'dot_path': 'subdir1.subdir2.test3',
'sub_elements': []
}
]
},
{
'type': 'file',
'name': 'test2',
'dot_path': 'subdir1.test2', 'sub_elements': []
}
]
},
{
'type': 'file',
'name': 'test1',
'dot_path': 'test1',
'sub_elements': []
}
]
}
assert tests == expected_result
def test_get_test_cases_no_tests(self, project_function):
_, project = project_function.activate()
tests = utils.get_test_cases(project)
expected = {
'type': 'directory',
'name': 'tests',
'dot_path': '.',
'sub_elements': []
}
assert tests == expected
def test_get_test_cases(self, project_class):
testdir = project_class.testdir
project = project_class.name
test_case.new_test_case(testdir, project, ['subdir1', 'subdir2'],
'test3')
test_case.new_test_case(testdir, project, ['subdir1'], 'test2')
test_case.new_test_case(testdir, project, [], 'test1')
tests = utils.get_test_cases(testdir, project)
expected = {
'type':
'directory',
'name':
'tests',
'dot_path':
'.',
'sub_elements': [{
'type':
'directory',
'name':
'subdir1',
'dot_path':
'subdir1',
'sub_elements': [{
'type':
'directory',
'name':
'subdir2',
'dot_path':
'subdir1.subdir2',
'sub_elements': [{
'type': 'file',
'name': 'test3',
'dot_path': 'subdir1.subdir2.test3',
'sub_elements': []
}]
}, {
'type': 'file',
'name': 'test2',
'dot_path': 'subdir1.test2',
'sub_elements': []
}]
}, {
'type': 'file',
'name': 'test1',
'dot_path': 'test1',
'sub_elements': []
}]
}
assert tests == expected
def suite_view(project, suite):
if not suite_module.suite_exists(project, suite):
abort(404, 'The suite {} does not exist'.format(suite))
all_test_cases = utils.get_test_cases(project)
selected_tests = suite_module.get_suite_test_cases(project, suite)
processes = suite_module.get_suite_amount_of_processes(project, suite)
browsers = suite_module.get_suite_browsers(project, suite)
default_browser = session.settings['default_browser']
environments = suite_module.get_suite_environments(project, suite)
tags = suite_module.get_tags(project, suite)
return render_template('suite.html', project=project,
all_test_cases=all_test_cases['sub_elements'],
selected_tests=selected_tests, suite=suite,
processes=processes, browsers=browsers,
default_browser=default_browser, environments=environments,
tags=tags)
def project(project):
if not user.has_permissions_to_project(g.user.id, project, root_path):
return render_template('not_permission.html')
test_cases = utils.get_test_cases(
root_path,
project)
page_objects = utils.get_page_objects(
root_path,
project)
return render_template(
'project.html',
test_cases=test_cases,
project=project,
page_objects=page_objects)
def suite_view(project, suite):
suite_exists = suite_module.suite_exists(test_execution.root_path, project, suite)
if not suite_exists:
abort(404, 'The suite {} does not exist'.format(suite))
all_test_cases = utils.get_test_cases(root_path, project)
selected_tests = suite_module.get_suite_test_cases(root_path, project, suite)
worker_amount = suite_module.get_suite_amount_of_workers(root_path, project, suite)
browsers = suite_module.get_suite_browsers(root_path, project, suite)
browsers = ', '.join(browsers)
default_browser = test_execution.settings['default_browser']
environments = suite_module.get_suite_environments(root_path, project, suite)
environments = ', '.join(environments)
return render_template('suite.html', project=project,
all_test_cases=all_test_cases['sub_elements'],
selected_tests=selected_tests, suite=suite,
worker_amount=worker_amount, browsers=browsers,
default_browser=default_browser, environments=environments)
def suite_view(project, suite):
if not user.has_permissions_to_project(g.user.id, project, root_path, 'gui'):
return render_template('not_permission.html')
all_test_cases = utils.get_test_cases(root_path, project)
selected_tests = suite_module.get_suite_test_cases(root_path, project, suite)
worker_amount = suite_module.get_suite_amount_of_workers(root_path, project, suite)
browsers = suite_module.get_suite_browsers(root_path, project, suite)
browsers = ', '.join(browsers)
default_browser = test_execution.settings['default_browser']
environments = suite_module.get_suite_environments(root_path, project, suite)
environments = ', '.join(environments)
return render_template('suite.html',
project=project,
all_test_cases=all_test_cases['sub_elements'],
selected_tests=selected_tests,
suite=suite,
worker_amount=worker_amount,
browsers=browsers,
default_browser=default_browser,
environments=environments)
def test_get_test_cases(self, test_directory_fixture, project_fixture):
test_case.new_test_case(test_directory_fixture['full_path'],
project_fixture['project_name'],
['subdir1', 'subdir2'],
'test3')
test_case.new_test_case(test_directory_fixture['full_path'],
project_fixture['project_name'],
['subdir1'],
'test2')
test_case.new_test_case(test_directory_fixture['full_path'],
project_fixture['project_name'],
[],
'test1')
tests = utils.get_test_cases(test_directory_fixture['full_path'],
project_fixture['project_name'])
expected_result = OrderedDict([('subdir1', OrderedDict([('subdir2',
OrderedDict([(('test3',
'subdir1.subdir2.test3'), None)])),
(('test2', 'subdir1.test2'), None)])),
(('test1', 'test1'), None)])
assert tests == expected_result
def execute_from_command_line(root_path):
parser = cli.get_golem_parser()
args = parser.parse_args()
# set test_execution values
test_execution.root_path = root_path
test_execution.settings = utils.get_global_settings()
import golem.core
golem.core.temp = test_execution.settings
# main action == gui
if args.main_action == 'gui':
gui_start.run_gui()
sys.exit()
# main action == run
if args.main_action == 'run':
if not args.project:
print 'Usage:', parser.usage, '\n\n', 'Project List:'
for proj in utils.get_projects(root_path):
print '> {}'.format(proj)
sys.exit()
# check if selected project does not exist
elif not args.project in utils.get_projects(root_path):
sys.exit('Error: the project {0} does not exist'
.format(test_execution.project))
else:
test_execution.project = args.project
# check if test_or_suite value is present
if not args.test_or_suite:
print 'Usage:', parser.usage
print '\nTest Cases:'
test_cases = utils.get_test_cases(root_path,
test_execution.project)
utils.display_tree_structure_command_line(test_cases)
print '\nTest Suites:'
test_suites = utils.get_suites(root_path,
test_execution.project)
utils.display_tree_structure_command_line(test_suites)
sys.exit()
# check if test_or_suite value matches an existing test suite
elif utils.test_suite_exists(root_path,
test_execution.project,
args.test_or_suite):
test_execution.suite = args.test_or_suite
# execute test suite
test_runner.run_suite(root_path,
test_execution.project,
test_execution.suite)
# check if test_or_suite value matches an existing test case
elif utils.test_case_exists(root_path,
test_execution.project,
args.test_or_suite):
test_execution.test = args.test_or_suite
# execute test case
test_runner.run_single_test_case(root_path,
test_execution.project,
test_execution.test)
else:
# test_or_suite does not match any existing suite or test
sys.exit('Error: the value {0} does not match an existing '
'suite or test'
.format(args.test_or_suite))
# main action == startproject
if args.main_action == 'startproject':
sys.exit('To be defined')
# main action == createuser
if args.main_action == 'createuser':
sys.exit('To be defined')
def get_tests():
if request.method == 'POST':
project = request.form['project']
tests = utils.get_test_cases(root_path, project)
return json.dumps(tests)
def test_get_test_cases_no_tests(self, project_function):
testdir = project_function['testdir']
project = project_function['name']
tests = utils.get_test_cases(testdir, project)
expected = {'type': 'directory', 'name': 'tests', 'dot_path': '.', 'sub_elements': []}
assert tests == expected
def run(self, test_execution, args):
test_execution.thread_amount = args.threads
test_execution.cli_drivers = args.browsers
test_execution.cli_environments = args.environments
test_execution.timestamp = args.timestamp
test_execution.interactive = args.interactive
# test_execution.minimize = args.minimize
root_path = test_execution.root_path
if args.project and args.test_or_suite:
if not args.project in utils.get_projects(root_path):
msg = [
'Error: the project {0} does not exist'.format(
args.project), '', 'Usage:', self._parser.usage, '',
'Projects:'
]
for proj in utils.get_projects(root_path):
msg.append(' {}'.format(proj))
raise CommandException('\n'.join(msg))
else:
test_execution.project = args.project
test_execution.settings = settings_manager.get_project_settings(
args.project, test_execution.settings)
if utils.test_suite_exists(root_path, test_execution.project,
args.test_or_suite):
test_execution.suite = args.test_or_suite
# execute test suite
start_execution.run_test_or_suite(
root_path,
test_execution.project,
suite=test_execution.suite)
elif utils.test_case_exists(root_path, test_execution.project,
args.test_or_suite):
test_execution.test = args.test_or_suite
# execute test case
start_execution.run_test_or_suite(root_path,
test_execution.project,
test=test_execution.test)
else:
# test_or_suite does not match any existing suite or test
msg = [('Error: the value {0} does not match an existing '
'suite or test'.format(args.test_or_suite)), '',
'Usage:', self._parser.usage]
raise CommandException('\n'.join(msg))
elif not args.project and not args.test_or_suite and test_execution.interactive:
from golem.test_runner import interactive
interactive.interactive(test_execution.settings,
test_execution.cli_drivers)
elif not args.project:
msg = ['Usage:', self._parser.usage, '', 'Projects:']
for proj in utils.get_projects(root_path):
msg.append(' {}'.format(proj))
raise CommandException('\n'.join(msg))
elif args.project and not args.test_or_suite:
msg = ['Usage: {}'.format(self._parser.usage), '', 'Test Cases:']
print('\n'.join(msg))
test_cases = utils.get_test_cases(root_path, args.project)
utils.display_tree_structure_command_line(
test_cases['sub_elements'])
print('\nTest Suites:')
test_suites = utils.get_suites(root_path, args.project)
for suite in test_suites['sub_elements']:
print(' ' + suite['name'])
raise CommandException()
else:
# test_or_suite does not match any existing suite or test
raise CommandException(
'Error: the value {0} does not match an existing '
'suite or test'.format(args.test_or_suite))
def run_command(project='', test_or_suite='', browsers=[], threads=1,
environments=[], interactive=False, timestamp=None):
test_execution.thread_amount = threads
test_execution.cli_drivers = browsers
test_execution.cli_environments = environments
test_execution.timestamp = timestamp
test_execution.interactive = interactive
root_path = test_execution.root_path
if project:
existing_projects = utils.get_projects(root_path)
if project in existing_projects:
test_execution.project = project
settings = settings_manager.get_project_settings(root_path, project)
test_execution.settings = settings
# settings are accessible from a test
# test_execution is not accessible from a test
# the test needs to know if interactive is true
test_execution.settings['interactive'] = interactive
if test_or_suite:
if suite_module.suite_exists(root_path, test_execution.project,
test_or_suite):
test_execution.suite = test_or_suite
# execute test suite
start_execution.run_test_or_suite(root_path,
test_execution.project,
suite=test_execution.suite)
elif test_case.test_case_exists(root_path, test_execution.project,
test_or_suite):
test_execution.test = test_or_suite
# execute test case
start_execution.run_test_or_suite(root_path,
test_execution.project,
test=test_execution.test)
else:
# TODO run directory
# test_or_suite does not match any existing suite or test
msg = ('golem run: error: the value {0} does not match an existing '
'test or suite'.format(test_or_suite))
sys.exit(msg)
else:
print(messages.RUN_USAGE_MSG)
test_cases = utils.get_test_cases(root_path, project)
print('Test Cases:')
utils.display_tree_structure_command_line(test_cases['sub_elements'])
test_suites = utils.get_suites(root_path, project)
print('\nTest Suites:')
# TODO print suites in structure
for suite in test_suites['sub_elements']:
print(' ' + suite['name'])
else:
msg = ('golem run: error: the project {0} does not exist'.format(project))
sys.exit(msg)
elif test_execution.interactive:
interactive_module.interactive(test_execution.settings,
test_execution.cli_drivers)
else:
print(messages.RUN_USAGE_MSG)
print('Projects:')
for proj in utils.get_projects(root_path):
print(' {}'.format(proj))
def run(self, test_execution, args):
test_execution.thread_amount = args.threads
test_execution.cli_drivers = args.browsers
test_execution.cli_environments = args.environments
test_execution.timestamp = args.timestamp
test_execution.interactive = args.interactive
root_path = test_execution.root_path
if args.project and args.test_or_suite:
if not args.project in utils.get_projects(root_path):
msg = ['Error: the project {0} does not exist'.format(args.project),
'',
'Usage:', self._parser.usage,
'',
'Projects:']
for proj in utils.get_projects(root_path):
msg.append(' {}'.format(proj))
raise CommandException('\n'.join(msg))
else:
test_execution.project = args.project
test_execution.settings = settings_manager.get_project_settings(root_path, args.project)
if utils.test_suite_exists(root_path, test_execution.project,
args.test_or_suite):
test_execution.suite = args.test_or_suite
# execute test suite
start_execution.run_test_or_suite(root_path,
test_execution.project,
suite=test_execution.suite)
elif utils.test_case_exists(root_path, test_execution.project,
args.test_or_suite):
test_execution.test = args.test_or_suite
# execute test case
start_execution.run_test_or_suite(root_path,
test_execution.project,
test=test_execution.test)
else:
# test_or_suite does not match any existing suite or test
msg = [('Error: the value {0} does not match an existing '
'suite or test'.format(args.test_or_suite)),
'',
'Usage:', self._parser.usage]
raise CommandException('\n'.join(msg))
elif not args.project and not args.test_or_suite and test_execution.interactive:
from golem.test_runner import interactive
interactive.interactive(test_execution.settings, test_execution.cli_drivers)
elif not args.project:
msg = ['Usage:',
self._parser.usage,
'',
'Projects:']
for proj in utils.get_projects(root_path):
msg.append(' {}'.format(proj))
raise CommandException('\n'.join(msg))
elif args.project and not args.test_or_suite:
msg = ['Usage: {}'.format(self._parser.usage),
'',
'Test Cases:']
print('\n'.join(msg))
test_cases = utils.get_test_cases(root_path,
args.project)
utils.display_tree_structure_command_line(test_cases['sub_elements'])
print('\nTest Suites:')
test_suites = utils.get_suites(root_path, args.project)
for suite in test_suites['sub_elements']:
print(' ' + suite['name'])
raise CommandException()
else:
# test_or_suite does not match any existing suite or test
raise CommandException(
'Error: the value {0} does not match an existing '
'suite or test'.format(args.test_or_suite))
def get_tests():
if request.method == 'POST':
project = request.form['project']
tests = utils.get_test_cases(root_path, project)
return json.dumps(tests)
