def __init__(self,
filename,
file_contents,
load_time,
*,
validate=None,
validation_kwargs=None,
check=None,
context=None):
"""
Initialize plug-in and create provider from definition extracted
from manage.py pointed by `filename`
"""
self._load_time = load_time
# override provider_manager.setup() to capture setup's parameters
setup_kwargs = []
start_time = now()
def fake_setup(**kwargs):
setup_kwargs.append(kwargs)
from plainbox import provider_manager
provider_manager.setup = fake_setup
loader = SourceFileLoader('manage', filename)
loader.load_module()
location = os.path.dirname(os.path.abspath(filename))
if len(setup_kwargs) < 1:
# did not load any provider from given manage.py
# creating empty definition
definition = Provider1Definition()
else:
setup_kwargs = setup_kwargs.pop()
definition = Provider1Definition()
definition.location = location
definition.name = setup_kwargs.get('name', None)
definition.namespace = setup_kwargs.get('namespace', Unset)
definition.version = setup_kwargs.get('version', None)
definition.description = setup_kwargs.get('description', None)
definition.gettext_domain = setup_kwargs.get(
'gettext_domain', Unset)
self._provider = Provider1.from_definition(
definition,
secure=False,
validate=validate,
validation_kwargs=validation_kwargs,
check=check,
context=context)
self._wrap_time = now() - start_time
def test_init_validation__location_unset(self):
"""
verify that Provider1Definition allows 'location' field to be unset
"""
def_ = Provider1Definition()
def_.location = Unset
self.assertEqual(def_.location, Unset)
def test_definition_without_location(self):
"""
Smoke test to ensure we can load a typical provider definition that is
not using the location field. Those are similar to what a packaged
provider would look like.
"""
def_ = Provider1Definition()
with mock.patch('os.path.isdir') as mock_isdir:
# Mock os.path.isdir so that we can validate all of the directory
# variables.
mock_isdir.return_value = True
def_.read_string("[PlainBox Provider]\n"
"name = org.example:smoke-test\n"
"version = 1.0\n"
"description = a description\n"
"gettext_domain = domain\n"
"units_dir = /some/directory/units\n"
"jobs_dir = /some/directory/jobs\n"
"data_dir = /some/directory/data\n"
"bin_dir = /some/directory/bin\n"
"locale_dir = /some/directory/locale\n")
self.assertEqual(def_.name, "org.example:smoke-test")
self.assertEqual(def_.version, "1.0")
self.assertEqual(def_.description, "a description")
self.assertEqual(def_.gettext_domain, "domain")
self.assertEqual(def_.location, Unset)
self.assertEqual(def_.units_dir, "/some/directory/units")
self.assertEqual(def_.jobs_dir, "/some/directory/jobs")
self.assertEqual(def_.data_dir, "/some/directory/data")
self.assertEqual(def_.bin_dir, "/some/directory/bin")
self.assertEqual(def_.locale_dir, "/some/directory/locale")
def _create_definition(self, tmpdir):
os.mkdir(os.path.join(tmpdir, "jobs"))
filename = os.path.join(tmpdir, "jobs", "jobs.txt")
with open(filename, "wt", encoding='UTF-8') as stream:
print("name: dummy", file=stream)
print("plugin: shell", file=stream)
print("command: true", file=stream)
os.mkdir(os.path.join(tmpdir, "whitelists"))
filename = os.path.join(tmpdir, "whitelists", "test.whitelist")
with open(filename, "wt", encoding='UTF-8') as stream:
print("dummy", file=stream)
os.mkdir(os.path.join(tmpdir, "data"))
filename = os.path.join(tmpdir, "data", "test.dat")
with open(filename, "wt", encoding='UTF-8') as stream:
print("data", file=stream)
os.mkdir(os.path.join(tmpdir, "bin"))
filename = os.path.join(tmpdir, "bin", "test.sh")
with open(filename, "wt", encoding='UTF-8') as stream:
print("#!/bin/sh", file=stream)
print(":", file=stream)
os.chmod(filename, 0o755)
definition = Provider1Definition()
definition.location = tmpdir
definition.name = "2014.com.example:test"
definition.version = "1.0"
definition.description = "description"
definition.gettext_domain = "domain"
return definition
def test_definition_with_location(self):
"""
Smoke test to ensure we can load a typical provider definition that is
using the location field and is not using any other directory fields.
Those are similar to what a unpackaged, under development provider
would look like.
"""
def_ = Provider1Definition()
with mock.patch('os.path.isdir') as mock_isdir:
# Mock os.path.isdir so that we can validate all of the directory
# variables.
mock_isdir.return_value = True
def_.read_string("[PlainBox Provider]\n"
"name = 2013.org.example:smoke-test\n"
"version = 1.0\n"
"description = a description\n"
"gettext_domain = domain\n"
"location = /some/directory")
self.assertEqual(def_.name, "2013.org.example:smoke-test")
self.assertEqual(def_.version, "1.0")
self.assertEqual(def_.description, "a description")
self.assertEqual(def_.gettext_domain, "domain")
self.assertEqual(def_.location, "/some/directory")
self.assertEqual(def_.units_dir, Unset)
self.assertEqual(def_.jobs_dir, Unset)
self.assertEqual(def_.whitelists_dir, Unset)
self.assertEqual(def_.data_dir, Unset)
self.assertEqual(def_.bin_dir, Unset)
self.assertEqual(def_.locale_dir, Unset)
def test_init_validation__no_name(self):
"""
verify that Provider1Definition ensures that 'name' field is not unset
"""
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
def_.name = Unset
self.assertEqual(str(boom.exception), "must be set to something")
def test_init_validation__empty_name(self):
"""
verify that Provider1Definition ensures that 'name' field is not empty
"""
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
def_.name = ""
self.assertEqual(str(boom.exception), "cannot be empty")
def test_init_validation__gettext_domain_can_be_unset(self):
"""
verify that Provider1Definition allows 'gettext_domain' field to be
unset
"""
def_ = Provider1Definition()
def_.gettext_domain = Unset
self.assertEqual(def_.gettext_domain, Unset)
def test_name_without_colon(self):
"""
Verify that the property Provider1Definition.name_without_colon
is computed correctly
"""
def_ = Provider1Definition()
def_.name = "org.example:smoke-test"
self.assertEqual(def_.name, "org.example:smoke-test")
self.assertEqual(def_.name_without_colon, "org.example.smoke-test")
def test_init_validation__location_relative(self):
"""
verify that Provider1Definition ensures that 'location' is not a
relative pathname
"""
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
def_.location = 'some/place'
self.assertEqual(str(boom.exception), "cannot be relative")
def test_init_validation__typical_version(self):
"""
verify that Provider1Definition allows typical values for the 'version'
field
"""
for ver in ('0.7.1', '0.7', '0', '2014.4', '12.04.5', '2014.4+bzr46'):
def_ = Provider1Definition()
def_.version = ver
self.assertEqual(def_.version, ver)
def test_init_validation__any_description(self):
"""
verify that Provider1Definition allows any value for the 'description'
field
"""
for desc in (Unset, "", "description"):
def_ = Provider1Definition()
def_.description = desc
self.assertEqual(def_.description, desc)
def test_init_validation__location_is_empty(self):
"""
verify that Provider1Definition ensures that 'location' field is not
empty
"""
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
def_.location = ''
self.assertEqual(str(boom.exception), "cannot be empty")
def test_init_validation__non_iqn_name(self):
"""
verify that Provider1Definition ensures that 'name' field rejects names
that don't look like RFC3720 IQN
"""
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
def_.name = "name = my pretty name\n"
self.assertEqual(str(boom.exception), "must look like RFC3720 IQN")
def test_init_validation__typical_name(self):
"""
verify that Provider1Definition allows typical values for 'name' field
"""
def_ = Provider1Definition()
for name in ('2013.org.example:tests',
'2013.com.canonical.certification:usb-testing'):
def_.name = name
self.assertEqual(def_.name, name)
def test_init_validation__incorrect_looking_version(self):
"""
verify that Provider1Definition ensures that 'version' field rejects
values that don't look like a typical version
"""
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
def_.version = "FOOBAR+git4654654654"
self.assertEqual(str(boom.exception),
"must be a PEP440 compatible version")
def test_init_validation__foo_dir_unset(self):
"""
verify that Provider1Definition allows 'jobs_dir', 'whitelists_dir',
'data_dir', 'bin_dir' and 'locale_dir' fields to be unset
"""
for attr in ('units_dir', 'jobs_dir', 'whitelists_dir', 'data_dir',
'bin_dir', 'locale_dir'):
def_ = Provider1Definition()
setattr(def_, attr, Unset)
self.assertEqual(getattr(def_, attr), Unset)
def test_init_validation__typical_gettext_domain(self):
"""
verify that Provider1Definition allows 'gettext_domain' field to have
typical values
"""
for gettext_domain in ("plainbox", "checkbox",
"2014_com_canonical_provider_name",
"2014-com-canonical-provider-name"):
def_ = Provider1Definition()
def_.gettext_domain = gettext_domain
self.assertEqual(def_.gettext_domain, gettext_domain)
def test_init_validation__foo_dir_is_empty(self):
"""
verify that Provider1Definition ensures that 'jobs_dir',
'data_dir', 'bin_dir' and 'locale_dir' fields are not empty
"""
for attr in ('units_dir', 'jobs_dir', 'data_dir', 'bin_dir',
'locale_dir'):
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
setattr(def_, attr, '')
self.assertEqual(str(boom.exception), "cannot be empty")
def test_init_validation__location_doesnt_exist(self):
"""
verify that Provider1Definition ensures that 'location' field is not
pointing to an non-existing directory
"""
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
with mock.patch('os.path.isdir') as mock_isdir:
mock_isdir.return_value = False
def_.location = '/some/place'
self.assertEqual(str(boom.exception), "no such directory")
def test_init_validation__incorrect_looking_version(self):
"""
verify that Provider1Definition ensures that 'version' field rejects
values that don't look like a typical version
"""
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
def_.version = "2014.4+bzr46"
self.assertEqual(
str(boom.exception),
"must be a sequence of digits separated by dots")
def test_init_validation__foo_dir_relative(self):
"""
verify that Provider1Definition ensures that 'jobs_dir',
'whitelists_dir', 'data_dir', 'bin_dir' and 'locale_dir' fields are not
a relative pathname
"""
for attr in ('units_dir', 'jobs_dir', 'whitelists_dir', 'data_dir',
'bin_dir', 'locale_dir'):
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
setattr(def_, attr, 'some/place')
self.assertEqual(str(boom.exception), "cannot be relative")
def get_stubbox_def():
"""
Get a Provider1Definition for stubbox
"""
stubbox_def = Provider1Definition()
stubbox_def.name = "com.canonical.plainbox:stubbox"
stubbox_def.version = "1.0"
stubbox_def.description = N_("StubBox (dummy data for development)")
stubbox_def.secure = False
stubbox_def.gettext_domain = "plainbox-provider-stubbox"
stubbox_def.location = os.path.join(
get_plainbox_dir(), "impl/providers/stubbox")
return stubbox_def
def get_categories_def():
"""
Get a Provider1Definition for the provider that knows all the categories
"""
categories_def = Provider1Definition()
categories_def.name = "com.canonical.plainbox:categories"
categories_def.version = "1.0"
categories_def.description = N_("Common test category definitions")
categories_def.secure = False
categories_def.gettext_domain = "plainbox-provider-categories"
categories_def.location = os.path.join(
get_plainbox_dir(), "impl/providers/categories")
return categories_def
def get_manifest_def():
"""
Get a Provider1Definition for the provider that handles the manifest
machinery.
"""
manifest_def = Provider1Definition()
manifest_def.name = "com.canonical.plainbox:manifest"
manifest_def.version = "1.0"
manifest_def.description = N_("Hardware Manifest Provider")
manifest_def.secure = False
manifest_def.gettext_domain = "plainbox-provider-manifest"
manifest_def.location = os.path.join(
get_plainbox_dir(), "impl/providers/manifest")
return manifest_def
def get_exporters_def():
"""
Get a Provider1Definition for the provider that handles the exporters
machinery.
"""
exporters_def = Provider1Definition()
exporters_def.name = "com.canonical.plainbox:exporters"
exporters_def.version = "1.0"
exporters_def.description = N_("Exporters Provider")
exporters_def.secure = False
exporters_def.gettext_domain = "plainbox-provider-exporters"
exporters_def.location = os.path.join(
get_plainbox_dir(), "impl/providers/exporters")
return exporters_def
def test_init_validation__foo_dir_doesnt_exist(self):
"""
verify that Provider1Definition ensures that 'jobs_dir',
'whitelists_dir', 'data_dir', 'bin_dir' and 'locale_dir' fields are not
pointing to a non-existing directory
"""
for attr in ('units_dir', 'jobs_dir', 'whitelists_dir', 'data_dir',
'bin_dir', 'locale_dir'):
def_ = Provider1Definition()
with self.assertRaises(ValidationError) as boom:
with mock.patch('os.path.isdir') as mock_isdir:
mock_isdir.return_value = False
setattr(def_, attr, '/some/place')
self.assertEqual(str(boom.exception), "no such directory")
def setup(**kwargs):
"""
The setup method that is being called from generated manage.py scripts.
This setup method is similar in spirit to the setup.py's setup() call
present in most python projects. It takes any keyword arguments and tries
to make the best of it.
:param kwargs:
arbitrary keyword arguments, see below for what we currently look up
:raises:
SystemExit with the exit code of the program. This is done regardless
of normal / abnormal termination.
The following keyword parameters are supported:
name:
name of the provider (IQN compatible). Typically something like
``2013.org.example:some-name`` where the ``some-name`` is a simple
identifier and a private namespace for whoever owned
``org.example`` in ``2013``
version:
version string, required
description:
description (may be long/multi line), optional
gettext_domain:
gettext translation domain for job definition strings, optional
"""
setup_logging()
manage_py = inspect.stack()[1][0].f_globals['__file__']
location = os.path.dirname(os.path.abspath(manage_py))
definition = Provider1Definition()
try:
definition.location = location
definition.name = kwargs.get('name', None)
definition.version = kwargs.get('version', None)
definition.description = kwargs.get('description', None)
definition.gettext_domain = kwargs.get('gettext_domain', Unset)
except ConfigValidationError as exc:
raise SystemExit(
_("{}: bad value of {!r}, {}").format(manage_py, exc.variable.name,
exc.message))
else:
raise SystemExit(ProviderManagerTool(definition).main())
def _create_definition(self, tmpdir):
os.mkdir(os.path.join(tmpdir, "jobs"))
filename = os.path.join(tmpdir, "jobs", "jobs.pxu")
with open(filename, "wt", encoding='UTF-8') as stream:
print("id: dummy", file=stream)
print("plugin: shell", file=stream)
print("command: true", file=stream)
print("estimated_duration: 10", file=stream)
print("flags: preserve-locale", file=stream)
# NOTE: absence of summary is not reported? Bug?
# print("_summary: A dummy job", file=stream)
print("_description: This job is dummy", file=stream)
os.mkdir(os.path.join(tmpdir, "units"))
filename = os.path.join(tmpdir, "units", "testplans.pxu")
with open(filename, "wt", encoding='UTF-8') as stream:
print("unit: test plan", file=stream)
print("id: test", file=stream)
print("_name: Dummy Tests", file=stream)
print("_description: All dummy tests", file=stream)
print("estimated_duration: 10", file=stream)
print("include: dummy", file=stream)
os.mkdir(os.path.join(tmpdir, "data"))
filename = os.path.join(tmpdir, "data", "test.dat")
with open(filename, "wt", encoding='UTF-8') as stream:
print("data", file=stream)
os.mkdir(os.path.join(tmpdir, "bin"))
filename = os.path.join(tmpdir, "bin", "test.sh")
with open(filename, "wt", encoding='UTF-8') as stream:
print("#!/bin/sh", file=stream)
print(":", file=stream)
os.chmod(filename, 0o755)
os.mkdir(os.path.join(tmpdir, "src"))
filename = os.path.join(tmpdir, "src", "hello.c")
with open(filename, "wt", encoding='UTF-8') as stream:
print("int main() { return 0; }", file=stream)
definition = Provider1Definition()
definition.location = tmpdir
definition.name = "com.example:test"
definition.version = "1.0"
definition.description = "description"
definition.gettext_domain = "domain"
return definition