def test_page_components_nested_import(self, project_session, test_utils):
"""Elements and functions from imported modules are not returned
as components of a page
"""
testdir, project = project_session.activate()
sys.path.append(testdir)
page_one = test_utils.create_random_page(project)
code = 'elem1 = ("id", "test")\n'
page.edit_page_code(project, page_one, code)
# page_two imports page_one
page_two = test_utils.create_random_page(project)
code = ('from projects.{}.pages import {}\n'
'\n'
'elem2 = ("id", "test")\n'.format(project, page_one))
page.edit_page_code(project, page_two, code)
# page_three imports page_two
page_three = test_utils.create_random_page(project)
code = ('from projects.{}.pages import {}\n'
'\n'
'elem3 = ("id", "test")\n'.format(project, page_two))
page.edit_page_code(project, page_three, code)
components = Page(project, page_three).components
assert len(components['elements']) == 1
assert components['elements'][0]['name'] == 'elem3'
# import *
code = ('from projects.{}.pages.{} import *\n'
'\n'
'elem3 = ("id", "test")\n'.format(project, page_two))
page.edit_page_code(project, page_three, code)
components = Page(project, page_three).components
assert len(components['elements']) == 1
assert components['elements'][0]['name'] == 'elem3'
def test_page_path(self, project_session, test_utils):
testdir, project = project_session.activate()
page_one = test_utils.random_string()
random_dir = test_utils.random_string()
random_name = test_utils.random_string()
page_two = '{}.{}'.format(random_dir, random_name)
test_utils.create_page(project, page_one)
test_utils.create_page(project, page_two)
path_one = os.path.join(Project(project).page_directory_path, page_one + '.py')
path_two = os.path.join(Project(project).page_directory_path,
random_dir, random_name + '.py')
assert Page(project, page_one).path == path_one
assert Page(project, page_two).path == path_two
def test_edit_page(self, project_session, test_utils):
_, project = project_session.activate()
page_name = test_utils.create_random_page(project)
elements = [
{'name': 'a', 'selector': 'id', 'value': 'b', 'display_name': 'a'},
{'name': 'c', 'selector': 'id', 'value': 'd', 'display_name': ''}
]
functions = ["def func1(a, b):\n print(a, b)\n"]
import_lines = [
'import time',
'from golem import browser'
]
page.edit_page(project, page_name, elements, functions, import_lines)
expected_contents = ('import time\n'
'from golem import browser\n'
'\n'
'\n'
'a = (\'id\', \'b\', \'a\')\n'
'\n'
'c = (\'id\', \'d\', \'c\')\n'
'\n'
'def func1(a, b):\n'
' print(a, b)\n')
with open(Page(project, page_name).path) as f:
assert f.read() == expected_contents
def test_delete_page(self, project_session, test_utils):
_, project = project_session.activate()
page_name = test_utils.create_random_page(project)
errors = page.delete_page(project, page_name)
assert errors == []
assert page_name not in Project(project).pages()
assert not os.path.isfile(Page(project, page_name).path)
def page_view(project, page_name, no_sidebar=False):
page = Page(project, page_name)
if not page.exists:
abort(404, 'The page {} does not exist'.format(page_name))
_, error = utils.import_module(page.path)
if error:
if no_sidebar:
url = url_for('webapp.page_code_view_no_sidebar',
project=project,
page_name=page_name)
else:
url = url_for('webapp.page_code_view',
project=project,
page_name=page_name)
content = ('<h4>There are errors in the page</h4>'
'<p>There are errors and the page cannot be displayed, '
'open the page code editor to solve them.</p>'
'<a class="btn btn-default" href="{}">Open Page Code</a>'.
format(url))
return render_template('common_element_error.html',
project=project,
item_name=page_name,
content=content,
no_sidebar=no_sidebar)
else:
return render_template('page_builder/page_object.html',
project=project,
page_object_data=page.components,
page_name=page_name,
no_sidebar=no_sidebar)
def page_code_view(project, page_name, no_sidebar=False):
page = Page(project, page_name)
if not page.exists:
abort(404, f'The page {page_name} does not exist')
_, error = utils.import_module(page.path)
return render_template('page_builder/page_code.html', project=project,
page_object_code=page.code, page_name=page_name,
error=error, no_sidebar=no_sidebar)
def page_code_save():
project = request.json['project']
page_name = request.json['pageName']
content = request.json['content']
_verify_permissions(Permissions.STANDARD, project)
path = Page(project, page_name).path
page_module.edit_page_code(project, page_name, content)
_, error = utils.import_module(path)
return jsonify({'error': error})
def test_edit_page_selector_value_format(self, value, expected_value,
project_session, test_utils):
_, project = project_session.activate()
page_name = test_utils.create_random_page(project)
elements = [
{'name': 'foo', 'selector': 'id', 'value': value, 'display_name': 'foo'},
]
page.edit_page(project, page_name, elements, [], [])
elements = Page(project, page_name).components['elements']
assert elements[0]['value'] == expected_value
def test_edit_page_code(self, project_session, test_utils):
_, project = project_session.activate()
page_name = test_utils.create_random_page(project)
page_code = ("elem1 = ('id', 'x')\n"
"elem2 = ('id', 'y')\n"
"def func1():\n"
" pass")
page.edit_page_code(project, page_name, page_code)
with open(Page(project, page_name).path) as f:
assert f.read() == page_code
def page_components():
project = request.args['project']
page_name = request.args['page']
_verify_permissions(Permissions.READ_ONLY, project)
result = {'error': '', 'contents': []}
page = Page(project, page_name)
if not page.exists:
result['error'] = 'page does not exist'
else:
result['components'] = page.components
return jsonify(result)
def test_page_components_imported_names(self, project_session, test_utils):
"""Elements and functions from imported modules are not returned
as components of a page
"""
testdir, project = project_session.activate()
sys.path.append(testdir)
page_one = test_utils.create_random_page(project)
code = ('elem1 = ("id", "test")\n' '\n' 'def func1():\n' ' pass\n')
page.edit_page_code(project, page_one, code)
# page_two imports page_one
page_two = test_utils.create_random_page(project)
code = (f'from projects.{project}.pages import {page_one}\n'
'\n'
'elem2 = ("id", "test")\n'
'\n'
'def func2():\n'
' pass\n')
page.edit_page_code(project, page_two, code)
components = Page(project, page_two).components
assert len(components['elements']) == 1
assert components['elements'][0]['name'] == 'elem2'
assert len(components['functions']) == 1
assert components['functions'][0]['name'] == 'func2'
# import *
code = (f'from projects.{project}.pages.{page_one} import *\n'
'\n'
'elem3 = ("id", "test")\n'
'\n'
'def func3():\n'
' pass\n')
page.edit_page_code(project, page_two, code)
components = Page(project, page_two).components
assert len(components['elements']) == 1
assert components['elements'][0]['name'] == 'elem3'
assert len(components['functions']) == 1
assert components['functions'][0]['name'] == 'func3'
def test_page_components(self, project_session, test_utils):
_, project = project_session.activate()
page_name = test_utils.create_random_page(project)
page_obj = Page(project, page_name)
with open(page_obj.path, 'w') as f:
f.write('elem1 = (\'id\', \'someId\', \'Elem1\')\n')
f.write('def func1(c, b, a):\n')
f.write(' pass\n')
components = page_obj.components
expected = {
'functions': [
{
'name': 'func1',
'full_name': '{}.func1'.format(page_name),
'partial_name': '{}.func1'.format(page_name),
'description': None,
'arguments': ['c', 'b', 'a'],
'code': 'def func1(c, b, a):\n pass\n'
}
],
'elements': [
{
'name': 'elem1',
'selector': 'id',
'value': 'someId',
'display_name': 'Elem1',
'partial_name': '{}.elem1'.format(page_name),
'full_name': '{}.elem1'.format(page_name)
}
],
'import_lines': [],
'code_lines': ["elem1 = ('id', 'someId', 'Elem1')",
'def func1(c, b, a):',
' pass',
''],
'source_code': ("elem1 = ('id', 'someId', 'Elem1')\ndef func1(c, b, a):\n"
" pass\n")
}
assert components == expected
def test_page_components_import_lines(self, project_session, test_utils):
_, project = project_session.activate()
page_name = test_utils.create_random_page(project)
code = (
'import foo\n'
'import bar\n'
'from bar import baz\n'
'from golem.browser import InvalidBrowserIdError, open_browser\n'
'from module import (func1,\n'
' func2)\n'
'\n'
'element_one = ("id", "idX", "Element One")\n'
'element_two = ("id", "idX .import", "Element Two")\n'
'element_three = ("id", "idX .from .import", "Element Three")\n')
page.edit_page_code(project, page_name, code)
components = Page(project, page_name).components
expected = [
'import foo', 'import bar', 'from bar import baz',
'from golem.browser import InvalidBrowserIdError, open_browser',
'from module import (func1,\n func2)'
]
assert sorted(components['import_lines']) == sorted(expected)
def test_module_local_functions_programatically(self, project_session, test_utils):
"""module imported from path"""
_, project = project_session.activate()
page_code = ('import sys\n'
'from os import walk\n'
'foo = 1\n'
'def bar():\n'
' pass\n'
'def _baz():\n'
' pass\n'
'class Traz:\n'
' pass')
page_name = test_utils.create_random_page(project, page_code)
module, _ = utils.import_module(Page(project, page_name).path)
functions = utils.module_local_public_functions(module)
assert len(functions) == 1
assert 'sys' not in functions
assert 'walk' not in functions
assert 'foo' not in functions
assert '_baz' not in functions
assert 'Traz' not in functions
assert 'bar' in functions
def test_get_page_code_file_not_exist(self, project_session):
_, project = project_session.activate()
assert Page(project, 'does-not-exist').code is None
def test_page_code(self, project_session, test_utils):
_, project = project_session.activate()
page_name = test_utils.create_random_page(project)
file_content = 'test=("id", "xyz")\ntest2=("id", "abc")\n'
page.edit_page_code(project, page_name, file_content)
assert Page(project, page_name).code == file_content
def test_page_exists(self, project_session, test_utils):
_, project = project_session.activate()
page_name = test_utils.create_random_page(project)
assert Page(project, page_name).exists
assert not Page(project, 'not_exists_page').exists
def project_page_exists():
project = request.args['project']
page_name = request.args['page']
_verify_permissions(Permissions.READ_ONLY, project)
return jsonify(Page(project, page_name).exists)
