def test_addon_theme(tmpdir, capsys, config):
answers_init_path = os.path.join(tmpdir.strpath, "answers.ini")
package_dir = os.path.abspath(tmpdir.strpath)
template = """[variables]
package.description = Dummy package
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
subtemplate_warning=False
package.git.init = True
plone.version = {version}
""".format(version=config.version)
generate_answers_ini(package_dir, template)
# generate template addon:
config.template = "addon"
config.package_name = "plonetheme.task"
result = subprocess.call(
[
"mrbob",
"-O",
config.package_name,
"bobtemplates.plone:" + config.template,
"--config",
answers_init_path,
"--non-interactive",
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name))
# generate subtemplate content_type:
template = """[variables]
theme.name = Plone theme Blacksea
subtemplate_warning=False
"""
generate_answers_ini(package_dir, template)
config.template = "theme_barceloneta"
result = subprocess.call(
[
"mrbob",
"bobtemplates.plone:" + config.template,
"--config",
answers_init_path,
"--non-interactive",
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, "/src/plonetheme/task/theme/manifest.cfg")
with capsys.disabled():
run_skeleton_tox_env(wd, config)
def test_addon_theme(tmpdir, capsys, config):
answers_init_path = os.path.join(tmpdir.strpath, 'answers.ini')
package_dir = os.path.abspath(tmpdir.strpath, )
template = """[variables]
package.description = Dummy package
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
subtemplate_warning=False
package.git.init = True
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(package_dir, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'plonetheme.task'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
answers_init_path,
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
# generate subtemplate content_type:
template = """[variables]
theme.name = Plone theme Blacksea
subtemplate_warning=False
"""
generate_answers_ini(package_dir, template)
config.template = 'theme'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
answers_init_path,
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/plonetheme/task/theme/manifest.cfg')
with capsys.disabled():
run_skeleton_tox_env(wd, config)
def test_theme_package(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
theme.name = Black Sea theme
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
subtemplate_warning=False
package.git.init = True
plone.version = {version}
""".format(version=config.version, )
base.generate_answers_ini(tmpdir.strpath, template)
config.template = 'theme_package'
config.package_name = 'plonetheme.blacksea'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
generated_files = glob.glob(
tmpdir.strpath + '/' + config.package_name + '/*', )
length = len(tmpdir.strpath + '/' + config.package_name + '/')
generated_files = [f[length:] for f in generated_files]
required_files = base_files + addon_files
assert required_files <= generated_files
base_path = tmpdir.strpath + '/' + config.package_name
assert base.file_exists(
base_path,
'/src/plonetheme/blacksea/theme/manifest.cfg',
)
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
with capsys.disabled():
try:
test_result = subprocess.check_output(
['tox'],
cwd=wd,
)
print('\n{0}\n'.format(test_result.decode('utf-8')))
except subprocess.CalledProcessError as execinfo:
tox_msg = b''.join(
execinfo.output.partition(b'__ summary __')[1:], ).decode()
assert execinfo.returncode == 0, '\n{0}'.format(tox_msg)
def test_theme_package(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
theme.name = Black Sea theme
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
subtemplate_warning=False
package.git.init = True
plone.version = {version}
""".format(version=config.version, )
base.generate_answers_ini(tmpdir.strpath, template)
config.template = 'theme_package'
config.package_name = 'plonetheme.blacksea'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
generated_files = glob.glob(
tmpdir.strpath + '/' + config.package_name + '/*', )
length = len(tmpdir.strpath + '/' + config.package_name + '/')
generated_files = [f[length:] for f in generated_files]
required_files = base_files + addon_files
assert required_files <= generated_files
base_path = tmpdir.strpath + '/' + config.package_name
assert base.file_exists(
base_path,
'/src/plonetheme/blacksea/theme/manifest.cfg',
)
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
with capsys.disabled():
returncode = run_skeleton_tox_env(wd, config)
assert returncode == 0, u"The tests inside the generated package are failing, please check the output above!"
def test_addon(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(tmpdir.strpath, template)
config.template = 'addon'
config.package_name = 'collective.task'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
generated_files = glob.glob(
tmpdir.strpath + '/' + config.package_name + '/*', )
length = len(tmpdir.strpath + '/' + config.package_name + '/')
generated_files = [f[length:] for f in generated_files]
required_files = base_files + addon_files
assert required_files <= generated_files
base_path = tmpdir.strpath + '/' + config.package_name
assert file_exists(base_path, '/src/collective/task/configure.zcml')
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
with capsys.disabled():
run_skeleton_tox_env(wd, config)
def test_cs_plone_buildout(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
package.plone.version = 5.1.2
package.buildout_zope_port_number = 8080
author.name = CodeSyntax
author.email = [email protected]
author.github.user = codesyntax
plone.version = {version}
""".format(version=config.version)
generate_answers_ini(tmpdir.strpath, template)
config.template = 'cs_plone_buildout'
config.package_name = 'project1'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.cs:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
generated_files = glob.glob(tmpdir.strpath + '/' + config.package_name +
'/*')
length = len(tmpdir.strpath + '/' + config.package_name + '/')
generated_files = [f[length:] for f in generated_files]
required_files = base_files
assert required_files <= generated_files
def test_vocabulary(tmpdir, capsys, config):
answers_init_path = os.path.join(tmpdir.strpath, 'answers.ini')
package_dir = os.path.abspath(tmpdir.strpath, )
template = """[variables]
package.description = Dummy package
package.example = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
package.git.init = True
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(package_dir, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'collective.task'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
answers_init_path,
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
# generate subtemplate content_type:
template = """[variables]
vocabulary_name = AvailableTasks
subtemplate_warning = Yes
"""
generate_answers_ini(package_dir, template)
config.template = 'vocabulary'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
answers_init_path,
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/collective/task/vocabularies/configure.zcml')
assert file_exists(
wd,
'/src/collective/task/tests/test_vocab_available_tasks.py',
)
assert file_exists(
wd,
'/src/collective/task/vocabularies/available_tasks.py',
)
with capsys.disabled():
run_skeleton_tox_env(wd, config)
def test_addon(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(tmpdir.strpath, template)
config.template = 'addon'
config.package_name = 'collective.task'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
generated_files = glob.glob(
tmpdir.strpath + '/' + config.package_name + '/*', )
length = len(tmpdir.strpath + '/' + config.package_name + '/')
generated_files = [f[length:] for f in generated_files]
required_files = base_files + addon_files
assert required_files <= generated_files
base_path = tmpdir.strpath + '/' + config.package_name
assert file_exists(base_path, '/src/collective/task/configure.zcml')
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
with capsys.disabled() if config.verbose else dummy_contextmanager():
setup_virtualenv_result = subprocess.call(
[
'virtualenv',
'.',
],
cwd=wd,
)
assert setup_virtualenv_result == 0
install_buildout_result = subprocess.call(
[
'./bin/pip',
'install',
'-U',
'-r',
'requirements.txt',
],
cwd=wd,
)
assert install_buildout_result == 0
annotate_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
'annotate',
],
cwd=wd,
)
assert annotate_result == 0
buildout_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
],
cwd=wd,
)
assert buildout_result == 0
try:
test_result = subprocess.check_output(
['bin/test', '-v'],
cwd=wd,
)
print(test_result)
except subprocess.CalledProcessError as execinfo:
print(execinfo.output)
assert 'failed' in execinfo
test__code_convention_result = subprocess.call(
['bin/code-analysis'],
cwd=wd,
)
assert test__code_convention_result == 0
def test_theme_package(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
theme.name = Black Sea theme
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(tmpdir.strpath, template)
config.template = 'theme_package'
config.package_name = 'plonetheme.blacksea'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
generated_files = glob.glob(
tmpdir.strpath + '/' + config.package_name + '/*', )
length = len(tmpdir.strpath + '/' + config.package_name + '/')
generated_files = [f[length:] for f in generated_files]
required_files = base_files + addon_files
assert required_files <= generated_files
base_path = tmpdir.strpath + '/' + config.package_name
assert file_exists(
base_path,
'/src/plonetheme/blacksea/theme/manifest.cfg',
)
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
with capsys.disabled() if config.verbose else dummy_contextmanager():
setup_virtualenv_result = subprocess.call(
[
'virtualenv',
'.',
],
cwd=wd,
)
assert setup_virtualenv_result == 0
install_buildout_result = subprocess.call(
[
'./bin/pip',
'install',
'-U',
'-r',
'requirements.txt',
],
cwd=wd,
)
assert install_buildout_result == 0
annotate_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
'annotate',
],
cwd=wd,
)
assert annotate_result == 0
buildout_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
],
cwd=wd,
)
assert buildout_result == 0
test_result = subprocess.call(
['bin/test'],
cwd=wd,
)
assert test_result == 0
test__code_convention_result = subprocess.call(
['bin/code-analysis'],
cwd=wd,
)
assert test__code_convention_result == 0
def test_indexer(tmpdir, capsys, config):
answers_init_path = os.path.join(tmpdir.strpath, "answers.ini")
package_dir = os.path.abspath(tmpdir.strpath)
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(version=config.version)
generate_answers_ini(package_dir, template)
# generate template addon:
config.template = "addon"
config.package_name = "collective.svelteapps"
result = subprocess.call(
[
"mrbob",
"-O",
config.package_name,
"bobtemplates.plone:" + config.template,
"--config",
answers_init_path,
"--non-interactive",
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name))
# generate subtemplate content_type:
template = """[variables]
svelte_app_name = my_custom_svelte_element
svelte_app_custom_element = Yes
subtemplate_warning = Yes
"""
generate_answers_ini(package_dir, template)
config.template = "svelte_app"
result = subprocess.call(
[
"mrbob",
"bobtemplates.plone:" + config.template,
"--config",
answers_init_path,
"--non-interactive",
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, "/svelte_src/my_custom_svelte_element/README.md")
assert file_exists(wd, "/src/collective/svelteapps/svelta_apps/README.md")
with capsys.disabled():
returncode = run_skeleton_tox_env(wd, config)
assert returncode == 0, u"The tests inside the generated package are failing, please check the output above!"
def test_addon_viewlet(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
package.git.autocommit = True
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(tmpdir.strpath, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'collective.sample'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
# generate subtemplate viewlet:
template = """[variables]
subtemplate_warning=True
viewlet_name=first_viewlet
viewlet_python_class_name=MyView
viewlet_template=True
viewlet_template_name=pt_viewlet
"""
generate_answers_ini(wd, template)
config.template = 'viewlet'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate subtemplate viewlet:
template = """[variables]
subtemplate_warning=True
viewlet_name=second_viewlet
viewlet_python_class_name=DemoView
viewlet_template=False
"""
generate_answers_ini(wd, template)
config.template = 'viewlet'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/collective/sample/configure.zcml')
with capsys.disabled() if config.verbose else dummy_contextmanager():
setup_virtualenv_result = subprocess.call(
[
'virtualenv',
'.',
],
cwd=wd,
)
assert setup_virtualenv_result == 0
install_buildout_result = subprocess.call(
[
'./bin/pip',
'install',
'-U',
'-r',
'requirements.txt',
],
cwd=wd,
)
assert install_buildout_result == 0
annotate_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
'annotate',
],
cwd=wd,
)
assert annotate_result == 0
buildout_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
],
cwd=wd,
)
assert buildout_result == 0
test_result = subprocess.call(
['bin/test'],
cwd=wd,
)
assert test_result == 0
test__code_convention_result = subprocess.call(
['bin/code-analysis'],
cwd=wd,
)
assert test__code_convention_result == 0
def test_addon_viewlet(tmpdir, capsys, config):
answers_init_path = os.path.join(tmpdir.strpath, 'answers.ini')
package_dir = os.path.abspath(
tmpdir.strpath,
)
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
package.git.autocommit = True
plone.version = {version}
""".format(
version=config.version,
)
generate_answers_ini(package_dir, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'collective.task'
result = subprocess.call(
[
'mrbob',
'-O', config.package_name,
'bobtemplates.plone:' + config.template,
'--config', answers_init_path,
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(
os.path.join(tmpdir.strpath, config.package_name),
)
# generate subtemplate viewlet:
template = """[variables]
subtemplate_warning=True
viewlet_name=first_viewlet
viewlet_python_class_name=MyView
viewlet_template=True
viewlet_template_name=pt_viewlet
"""
generate_answers_ini(package_dir, template)
config.template = 'viewlet'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config', answers_init_path,
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate subtemplate viewlet:
template = """[variables]
subtemplate_warning=True
viewlet_name=second_viewlet
viewlet_python_class_name=DemoView
viewlet_template=False
"""
generate_answers_ini(wd, template)
config.template = 'viewlet'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config', answers_init_path,
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/collective/task/configure.zcml')
with capsys.disabled():
returncode = run_skeleton_tox_env(wd, config)
assert returncode == 0, u"The tests inside the generated package are failing, please check the output above!"
def test_addon_content_type(tmpdir, capsys, config):
answers_init_path = os.path.join(tmpdir.strpath, 'answers.ini')
package_dir = os.path.abspath(tmpdir.strpath, )
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(package_dir, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'collective.task'
try:
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
answers_init_path,
'--non-interactive',
],
cwd=tmpdir.strpath,
)
except Exception as e:
print(e)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
# generate subtemplate content_type:
template = """[variables]
dexterity_type_name=Tasks Container
dexterity_type_base_class=Container
dexterity_type_create_class=True
dexterity_type_global_allow=True
dexterity_type_filter_content_types=True
dexterity_type_desc=A tasks container for Plone
dexterity_type_supermodel=True
"""
generate_answers_ini(package_dir, template)
config.template = 'content_type'
try:
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
answers_init_path,
'--non-interactive',
],
cwd=wd,
)
except Exception as e:
print(e)
assert result == 0
# generate 2. subtemplate content_type with Item instead of Container:
template = """[variables]
dexterity_type_name=Task Item
dexterity_type_desc=A task Task content type for Plone
dexterity_type_supermodel=True
dexterity_type_base_class=Item
dexterity_type_create_class=True
dexterity_type_global_allow=False
dexterity_parent_container_type_name=Tasks Container
dexterity_type_activate_default_behaviors=False
"""
generate_answers_ini(package_dir, template)
config.template = 'content_type'
try:
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
answers_init_path,
'--non-interactive',
],
cwd=wd,
)
except Exception as e:
print(e)
assert result == 0
assert file_exists(wd, '/src/collective/task/configure.zcml')
with capsys.disabled():
returncode = run_skeleton_tox_env(wd, config)
assert returncode == 0, u"The tests inside the generated package are failing, please check the output above!"
def test_addon_content_type(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
package.example = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(tmpdir.strpath, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'collective.todo'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
# generate subtemplate content_type:
template = """[variables]
dexterity_type_name = Todos
dexterity_type_base_class = Container
dexterity_type_create_class = True
subtemplate_warning = Yes
dexterity_type_desc = A Todos container for Plone
dexterity_type_supermodel = True
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate 2. subtemplate content_type with Item instead of Container:
template = """[variables]
dexterity_type_name = Todo Task
dexterity_type_base_class = Item
dexterity_type_create_class = True
subtemplate_warning = Yes
dexterity_type_desc = A ToDo Task content type for Plone
dexterity_type_supermodel = True
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/collective/todo/configure.zcml')
with capsys.disabled() if config.verbose else dummy_contextmanager():
setup_virtualenv_result = subprocess.call(
[
'virtualenv',
'.',
],
cwd=wd,
)
assert setup_virtualenv_result == 0
install_buildout_result = subprocess.call(
[
'./bin/pip',
'install',
'-U',
'-r',
'requirements.txt',
],
cwd=wd,
)
assert install_buildout_result == 0
annotate_result = subprocess.call(
[
'bin/buildout',
'annotate',
],
cwd=wd,
)
assert annotate_result == 0
buildout_result = subprocess.call(
[
'bin/buildout',
],
cwd=wd,
)
assert buildout_result == 0
test_result = subprocess.call(
[
'bin/test',
],
cwd=wd,
)
assert test_result == 0
test__code_convention_result = subprocess.call(
[
'bin/code-analysis',
],
cwd=wd,
)
assert test__code_convention_result == 0
def test_addon_view(tmpdir, capsys, config):
answers_init_path = os.path.join(tmpdir.strpath, 'answers.ini')
package_dir = os.path.abspath(tmpdir.strpath, )
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
package.git.autocommit = True
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(package_dir, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'collective.task'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
answers_init_path,
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
# generate subtemplate view:
template = """[variables]
view_python_class=True
view_python_class_name=MyView
view_name=my_view
view_template=True
view_template_name=pt_view
"""
generate_answers_ini(package_dir, template)
config.template = 'view'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
answers_init_path,
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/collective/task/configure.zcml')
with capsys.disabled():
run_skeleton_tox_env(wd, config)
def test_upgrade_step(tmpdir, capsys, config):
answers_init_path = os.path.join(tmpdir.strpath, "answers.ini")
package_dir = os.path.abspath(tmpdir.strpath)
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(
version=config.version
)
generate_answers_ini(package_dir, template)
# generate template addon:
config.template = "addon"
config.package_name = "collective.task"
result = subprocess.call(
[
"mrbob",
"-O",
config.package_name,
"bobtemplates.plone:" + config.template,
"--config",
answers_init_path,
"--non-interactive",
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name))
# generate subtemplate content_type:
template = """[variables]
upgrade_step_title = reindex the thing
upgrade_step_description = Upgrade the thing
subtemplate_warning = Yes
"""
generate_answers_ini(package_dir, template)
config.template = "upgrade_step"
result = subprocess.call(
[
"mrbob",
"bobtemplates.plone:" + config.template,
"--config",
answers_init_path,
"--non-interactive",
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, "/src/collective/task/upgrades/configure.zcml")
assert file_exists(wd, "/src/collective/task/upgrades/1001.zcml")
assert file_exists(wd, "/src/collective/task/upgrades/v1001.py")
with capsys.disabled():
returncode = run_skeleton_tox_env(wd, config)
assert returncode == 0, u"The tests inside the generated package are failing, please check the output above!"
def test_addon_theme(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(
version=config.version,
)
generate_answers_ini(tmpdir.strpath, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'plonetheme.blacksea'
result = subprocess.call(
[
'mrbob',
'-O', config.package_name,
'bobtemplates.plone:' + config.template,
'--config', 'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(
os.path.join(tmpdir.strpath, config.package_name),
)
# generate subtemplate content_type:
template = """[variables]
subtemplate_warning = Yes
theme.name = Plone theme Blacksea
"""
generate_answers_ini(wd, template)
config.template = 'theme'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config', 'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/plonetheme/blacksea/theme/manifest.cfg')
with capsys.disabled() if config.verbose else dummy_contextmanager():
setup_virtualenv_result = subprocess.call(
[
'virtualenv',
'.',
],
cwd=wd,
)
assert setup_virtualenv_result == 0
install_buildout_result = subprocess.call(
[
'./bin/pip',
'install',
'-U',
'-r',
'requirements.txt',
],
cwd=wd,
)
assert install_buildout_result == 0
annotate_result = subprocess.call(
['bin/buildout', 'annotate', ],
cwd=wd,
)
assert annotate_result == 0
buildout_result = subprocess.call(
['bin/buildout', ],
cwd=wd,
)
assert buildout_result == 0
test_result = subprocess.call(
['bin/test', ],
cwd=wd,
)
assert test_result == 0
test__code_convention_result = subprocess.call(
['bin/code-analysis', ],
cwd=wd,
)
assert test__code_convention_result == 0
def test_addon_content_type(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(tmpdir.strpath, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'collective.task'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
# generate subtemplate content_type:
template = """[variables]
dexterity_type_name=Tasks Container
dexterity_type_base_class=Container
dexterity_type_create_class=True
dexterity_type_global_allow=True
dexterity_type_filter_content_types=True
subtemplate_warning=False
dexterity_type_desc=A tasks container for Plone
dexterity_type_supermodel=True
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate 2. subtemplate content_type with Item instead of Container:
template = """[variables]
dexterity_type_name=Task Item
dexterity_type_base_class=Item
dexterity_type_create_class=True
dexterity_type_global_allow=True
subtemplate_warning=True
dexterity_type_desc=A task Task content type for Plone
dexterity_type_supermodel=True
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate subtemplate content_type with generic class:
template = """[variables]
dexterity_type_name=Generic Tasks Container
dexterity_type_base_class=Container
dexterity_type_create_class=False
dexterity_type_global_allow=True
dexterity_type_filter_content_types=False
subtemplate_warning=True
dexterity_type_desc=A tasks container for Plone
dexterity_type_supermodel=True
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate subtemplate content_type with generic class:
template = """[variables]
dexterity_type_name=Task Item Python Schema
dexterity_type_base_class=Item
dexterity_type_create_class=True
dexterity_type_global_allow=True
dexterity_type_filter_content_types=False
subtemplate_warning=True
dexterity_type_desc=A tasks container for Plone
dexterity_type_supermodel=False
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate subtemplate content_type with parent container:
template = """[variables]
dexterity_type_name=Parent
dexterity_type_base_class=Container
dexterity_type_create_class=True
dexterity_type_global_allow=True
dexterity_type_filter_content_types=True
subtemplate_warning=True
dexterity_type_desc=A parent container for Plone
dexterity_type_supermodel=True
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate subtemplate content_type with child container:
template = """[variables]
dexterity_type_name=Child
dexterity_type_base_class=Item
dexterity_type_create_class=True
dexterity_type_global_allow=False
dexterity_parent_container_type_name=Parent
dexterity_type_filter_content_types=False
subtemplate_warning=True
dexterity_type_desc=A child container for Plone
dexterity_type_supermodel=True
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate subtemplate content_type:
template = """[variables]
dexterity_type_name=News Container
dexterity_type_base_class=Container
dexterity_type_create_class=True
dexterity_type_global_allow=y
dexterity_type_filter_content_types=n
subtemplate_warning=False
dexterity_type_desc=A tasks container for Plone
dexterity_type_supermodel=True
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
# generate subtemplate content_type:
template = """[variables]
dexterity_type_name=Another Container
dexterity_type_base_class=Container
dexterity_type_create_class=True
dexterity_type_global_allow=1
dexterity_type_filter_content_types=y
subtemplate_warning=False
dexterity_type_desc=A tasks container for Plone
dexterity_type_supermodel=True
"""
generate_answers_ini(wd, template)
config.template = 'content_type'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/collective/task/configure.zcml')
with capsys.disabled() if config.verbose else dummy_contextmanager():
setup_virtualenv_result = subprocess.call(
[
'virtualenv',
'.',
],
cwd=wd,
)
assert setup_virtualenv_result == 0
install_buildout_result = subprocess.call(
[
'./bin/pip',
'install',
'-U',
'-r',
'requirements.txt',
],
cwd=wd,
)
assert install_buildout_result == 0
annotate_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
'annotate',
],
cwd=wd,
)
assert annotate_result == 0
buildout_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
],
cwd=wd,
)
assert buildout_result == 0
test_result = subprocess.call(
['bin/test'],
cwd=wd,
)
assert test_result == 0
test__code_convention_result = subprocess.call(
['bin/code-analysis'],
cwd=wd,
)
assert test__code_convention_result == 0
def test_behavior(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
package.example = True
package.git.init = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(version=config.version)
generate_answers_ini(tmpdir.strpath, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'collective.task'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name))
# generate subtemplate content_type:
# template = """[variables]
# """
# generate_answers_ini(wd, template)
config.template = 'cs_migration'
result = subprocess.call(
[
'mrbob',
'bobtemplates.cs:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/collective/task/blueprints/configure.zcml')
assert file_exists(wd, '/src/collective/task/blueprints/pytz_fixer.py')
assert file_exists(wd,
'/src/collective/task/blueprints/reference_fields.py')
assert file_exists(wd, '/src/collective/task/pipelines/configure.zcml')
assert file_exists(wd, '/src/collective/task/pipelines/migration1.cfg')
with capsys.disabled() if config.verbose else dummy_contextmanager():
setup_virtualenv_result = subprocess.call(['virtualenv', '.'], cwd=wd)
assert setup_virtualenv_result == 0
install_buildout_result = subprocess.call(
['./bin/pip', 'install', '-U', '-r', 'requirements.txt'], cwd=wd)
assert install_buildout_result == 0
annotate_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
'annotate',
],
cwd=wd,
)
assert annotate_result == 0
buildout_result = subprocess.call(
['bin/buildout', 'code-analysis:return-status-codes=True'], cwd=wd)
assert buildout_result == 0
test_result = subprocess.call(['bin/test'], cwd=wd)
assert test_result == 0
test__code_convention_result = subprocess.call(['bin/code-analysis'],
cwd=wd)
assert test__code_convention_result == 0
def test_vocabulary(tmpdir, capsys, config):
template = """[variables]
package.description = Dummy package
package.example = True
author.name = The Plone Collective
author.email = [email protected]
author.github.user = collective
plone.version = {version}
""".format(version=config.version, )
generate_answers_ini(tmpdir.strpath, template)
# generate template addon:
config.template = 'addon'
config.package_name = 'collective.task'
result = subprocess.call(
[
'mrbob',
'-O',
config.package_name,
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=tmpdir.strpath,
)
assert result == 0
wd = os.path.abspath(os.path.join(tmpdir.strpath, config.package_name), )
# generate subtemplate content_type:
template = """[variables]
vocabulary_name = AvailableTasks
subtemplate_warning = Yes
"""
generate_answers_ini(wd, template)
config.template = 'vocabulary'
result = subprocess.call(
[
'mrbob',
'bobtemplates.plone:' + config.template,
'--config',
'answers.ini',
'--non-interactive',
],
cwd=wd,
)
assert result == 0
assert file_exists(wd, '/src/collective/task/vocabularies/configure.zcml')
assert file_exists(
wd,
'/src/collective/task/tests/test_vocab_available_tasks.py',
)
assert file_exists(
wd,
'/src/collective/task/vocabularies/available_tasks.py',
)
with capsys.disabled() if config.verbose else dummy_contextmanager():
setup_virtualenv_result = subprocess.call(
[
'virtualenv',
'.',
],
cwd=wd,
)
assert setup_virtualenv_result == 0
install_buildout_result = subprocess.call(
[
'./bin/pip',
'install',
'-U',
'-r',
'requirements.txt',
],
cwd=wd,
)
assert install_buildout_result == 0
annotate_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
'annotate',
],
cwd=wd,
)
assert annotate_result == 0
buildout_result = subprocess.call(
[
'bin/buildout',
'code-analysis:return-status-codes=True',
],
cwd=wd,
)
assert buildout_result == 0
test_result = subprocess.call(
['bin/test'],
cwd=wd,
)
assert test_result == 0
test__code_convention_result = subprocess.call(
['bin/code-analysis'],
cwd=wd,
)
assert test__code_convention_result == 0
