def pytest_sessionstart(session):
actor_path = os.environ.get('LEAPP_TESTED_ACTOR', None)
library_path = os.environ.get('LEAPP_TESTED_LIBRARY', None)
if actor_path:
repo = find_and_scan_repositories(find_repository_basedir(actor_path),
include_locals=True)
repo.load()
actor = None
# find which actor is being tested
for a in repo.actors:
if a.full_path == actor_path.rstrip('/'):
actor = a
break
if not actor:
return
# load actor context so libraries can be imported on module level
session.leapp_repository = repo
session.actor_context = actor.injected_context()
session.actor_context.__enter__()
elif library_path:
repo = find_and_scan_repositories(
find_repository_basedir(library_path), include_locals=True)
repo.load()
os.chdir(library_path)
def test_find_and_scan_repositories_no_user_repos_config(empty_repository_dir):
repo_path = empty_repository_dir.dirpath().strpath
with mock.patch('leapp.repository.manager.RepositoryManager.get_missing_repo_links', return_value={'42'}):
with mock.patch('leapp.utils.repository.get_global_repositories_data', return_value={}):
with mock.patch('leapp.utils.repository.get_user_config_repos', return_value='/no/such/file.json'):
with pytest.raises(RepositoryConfigurationError) as err:
find_and_scan_repositories(repo_path, include_locals=True)
assert 'No repos configured' in err.value.message
def impl(context=None):
configure_logger()
repository = find_and_scan_repositories(find_repository_basedir('.'),
include_locals=True)
try:
repository.load()
except LeappError as exc:
sys.stderr.write(exc.message)
sys.stderr.write('\n')
sys.exit(1)
wf = repository.lookup_workflow(params.name)
if not wf:
raise CommandError('Could not find any workflow named "{}"'.format(
params.name))
instance = wf()
for actor_name in params.whitelist_experimental or ():
actor = repository.lookup_actor(actor_name)
if actor:
instance.whitelist_experimental_actor(actor)
with beautify_actor_exception():
instance.run(context=context,
until_phase=params.until_phase,
until_actor=params.until_actor)
report_errors(instance.errors)
def cli(args):
base_dir = find_repository_basedir('.')
repository = find_and_scan_repositories(base_dir, include_locals=True)
try:
repository.load()
except LeappError as exc:
sys.stderr.write(exc.message)
sys.exit(1)
actors = [actor for actor in repository.actors]
topics = [
topic for topic in get_topics()
if _is_local(repository, topic, base_dir, all_repos=args.all)
]
models = [
model for model in get_models()
if _is_local(repository, model, base_dir, all_repos=args.all)
]
tags = [
tag for tag in get_tags()
if _is_local(repository, tag, base_dir, all_repos=args.all)
]
workflows = [
workflow for workflow in get_workflows()
if _is_local(repository, workflow, base_dir, all_repos=args.all)
]
if not args.json:
sys.stdout.write(
'Repository:\n Name: {repository}\n Path: {base_dir}\n\n'.format(
repository=get_repository_name(base_dir), base_dir=base_dir))
_print_group('Actors',
actors,
name_resolver=lambda x: x.class_name,
path_resolver=_get_actor_path)
_print_group('Models', models)
_print_group('Tags', tags)
_print_group('Topics', topics)
_print_group('Workflows', workflows)
else:
output = {
'repository':
get_repository_name(base_dir),
'base_dir':
base_dir,
'topics':
dict((topic.__name__, _get_topic_details(topic))
for topic in topics),
'models':
dict((model.__name__, _get_model_details(model))
for model in models),
'actors':
dict((actor.class_name, _get_actor_details(actor))
for actor in actors),
'tags':
dict((tag.name, _get_tag_details(tag)) for tag in tags),
'workflows':
dict((workflow.__name__, _get_workflow_details(workflow))
for workflow in workflows)
}
json_mod.dump(output, sys.stdout, indent=2)
def cli(args):
log = configure_logger()
basedir = find_repository_basedir('.')
repository = find_and_scan_repositories(basedir, include_locals=True)
try:
repository.load()
except LeappError as exc:
sys.stderr.write(exc.message)
sys.stderr.write('\n')
sys.exit(1)
actor_logger = log.getChild('actors')
actor = repository.lookup_actor(args.actor_name)
if not actor:
raise CommandError('Actor "{}" not found!'.format(args.actor_name))
messaging = InProcessMessaging(stored=args.save_output)
messaging.load(actor.consumes)
failure = False
with beautify_actor_exception():
try:
actor(messaging=messaging, logger=actor_logger).run()
except BaseException:
failure = True
raise
report_errors(messaging.errors())
if failure or messaging.errors():
sys.exit(1)
if args.print_output:
json.dump(messaging.messages(), sys.stdout, indent=2)
sys.stdout.write('\n')
def pytest_collectstart(collector):
if collector.nodeid:
current_repo_basedir = find_repository_basedir(collector.nodeid)
# loading the current repo
if (
not hasattr(collector.session, "leapp_repository")
or current_repo_basedir != collector.session.repo_base_dir
):
repo = find_and_scan_repositories(
find_repository_basedir(collector.nodeid), include_locals=True
)
repo.load(skip_actors_discovery=True)
collector.session.leapp_repository = repo
collector.session.repo_base_dir = current_repo_basedir
# we're forcing the actor context switch only when traversing new
# actor
if "/actors/" in str(collector.fspath) and (
not hasattr(collector.session, "current_actor_path")
or collector.session.current_actor_path + os.sep
not in str(collector.fspath)
):
actor = None
for a in collector.session.leapp_repository.actors:
if a.full_path == collector.fspath.dirpath().dirname:
actor = a
break
if not actor:
logger.info("No actor found, exiting collection...")
return
# we need to tear down the context from the previous
# actor
try:
collector.session.current_actor_context.__exit__(
None, None, None
)
except AttributeError:
pass
else:
logger.info(
"Actor %r context teardown complete",
collector.session.current_actor.name,
)
logger.info("Injecting actor context for %r", actor.name)
collector.session.current_actor = actor
collector.session.current_actor_context = actor.injected_context()
collector.session.current_actor_context.__enter__()
collector.session.current_actor_path = (
collector.session.current_actor.full_path
)
logger.info("Actor %r context injected", actor.name)
def load_repo(path):
"""
Load repository on demand.
Do not require paths initialized if no environment is set.
Allows some parts to be tested without working leapp installation.
"""
from leapp.utils.repository import find_repository_basedir
from leapp.repository.scan import find_and_scan_repositories
repo = find_and_scan_repositories(find_repository_basedir(path),
include_locals=True)
repo.load()
return repo
def cli(params):
configure_logger()
repository = find_and_scan_repositories(find_repository_basedir('.'), include_locals=True)
try:
repository.load()
except LeappError as exc:
sys.stderr.write(exc.message)
sys.exit(1)
wf = repository.lookup_workflow(params.name)
if not wf:
raise CommandError('Could not find any workflow named "{}"'.format(params.name))
instance = wf()
instance.run(until_phase=params.until_phase, until_actor=params.until_actor)
report_errors(instance.errors)
def main():
logging.basicConfig(level=logging.INFO, filename='/dev/null')
logger = logging.getLogger('run_pytest.py')
BASE_REPO = 'repos'
repos = find_and_scan_repositories(BASE_REPO, include_locals=True)
repos.load()
if len(sys.argv) > 1:
actors = repos._lookup_actors(sys.argv[1])
if not actors:
sys.stderr.write('ERROR: No actor found for search "{}"\n'.format(sys.argv[1]))
err_exit()
print(' '.join([actor.full_path for actor in actors]))
else:
sys.stderr.write('ERROR: Missing commandline argument\n')
err_exit()
def _load_and_add_repo(manager, repo_path):
repo = find_and_scan_repositories(repo_path, include_locals=True)
unloaded = set()
loaded = {r.repo_id for r in manager.repos}
if hasattr(repo, 'repos'):
for repo in repo.repos:
if not manager.repo_by_id(repo.repo_id):
manager.add_repo(repo)
unloaded.add(repo.repo_id)
else:
manager.add_repo(repo)
if not loaded:
manager.load(skip_actors_discovery=True)
else:
for repo_id in unloaded:
manager.repo_by_id(repo_id).load(skip_actors_discovery=True)
def cli(args):
log = configure_logger()
basedir = find_repository_basedir('.')
repository = find_and_scan_repositories(basedir, include_locals=True)
try:
repository.load()
except LeappError as exc:
sys.stderr.write(exc.message)
sys.exit(1)
actor_logger = log.getChild('actors')
actor = repository.lookup_actor(args.actor_name)
messaging = InProcessMessaging(stored=args.save_output)
messaging.load(actor.consumes)
actor(messaging=messaging, logger=actor_logger).run()
report_errors(messaging.errors())
if args.print_output:
json.dump(messaging.messages(), sys.stdout, indent=2)
sys.stdout.write('\n')
def pytest_sessionstart(session):
actor_path = os.environ.get('LEAPP_TESTED_ACTOR', None)
if not actor_path:
return
repo = find_and_scan_repositories(('/'.join(actor_path.split('/')[:-2])), include_locals=True)
repo.load()
actor = None
# find which actor is being tested
for a in repo.actors:
if a.full_path == actor_path:
actor = a
break
if not actor:
return
# load actor context so libraries can be imported on module level
session.leapp_repository = repo
session.actor_context = actor.injected_context()
session.actor_context.__enter__()
def cli(args):
start = datetime.datetime.utcnow()
log = configure_logger()
basedir = find_repository_basedir('.')
repository = find_and_scan_repositories(basedir, include_locals=True)
try:
repository.load()
except LeappError as exc:
sys.stderr.write(exc.message)
sys.stderr.write('\n')
sys.exit(1)
actor_logger = log.getChild('actors')
actor = repository.lookup_actor(args.actor_name)
if not actor:
raise CommandError('Actor "{}" not found!'.format(args.actor_name))
config_model = getattr(import_module('leapp.models'),
args.actor_config) if args.actor_config else None
messaging = InProcessMessaging(stored=args.save_output,
config_model=config_model)
messaging.load(actor.consumes)
failure = False
with beautify_actor_exception():
try:
actor(messaging=messaging,
logger=actor_logger,
config_model=config_model).run()
except BaseException:
failure = True
raise
report_errors(messaging.errors())
report_deprecations(os.getenv('LEAPP_EXECUTION_ID'), start=start)
if failure or messaging.errors():
sys.exit(1)
if args.print_output:
json.dump(messaging.messages(), sys.stdout, indent=2)
sys.stdout.write('\n')
def cli(params):
configure_logger()
repository = find_and_scan_repositories(find_repository_basedir('.'),
include_locals=True)
try:
repository.load()
except LeappError as exc:
sys.stderr.write(exc.message)
sys.stderr.write('\n')
sys.exit(1)
wf = repository.lookup_workflow(params.name)
if not wf:
raise CommandError('Could not find any workflow named "{}"'.format(
params.name))
instance = wf()
produced_late = set(instance.initial).intersection(set(instance.produces))
if produced_late:
print_fail(
_DESCRIPTION.format(' '.join([m.__name__ for m in produced_late])))
sys.exit(1)
def loaded_leapp_repository(request):
"""
This fixture will ensure that the repository for the current test run is loaded with all its links etc.
This enables running actors and using models, tags, topics, workflows etc.
Additionally loaded_leapp_repository gives you access to a :py:class:`leapp.repository.manager.RepositoryManager`
instance.
:Example:
.. code-block:: python
from leapp.snactor.fixture import loaded_leapp_repository
from leapp.models import ExampleModel, ProcessedExampleModel
def my_repository_library_test(loaded_leapp_repository):
from leapp.libraries.common import global
e = ExampleModel(value='Some string')
result = global.process_function(e)
assert type(result) is ProcessedExampleModel
"""
repository_path = find_repository_basedir(request.module.__file__)
os.environ['LEAPP_CONFIG'] = os.path.join(repository_path, '.leapp',
'leapp.conf')
os.environ['LEAPP_HOSTNAME'] = socket.getfqdn()
context = str(uuid.uuid4())
with get_connection(None):
Execution(context=context, kind='snactor-test-run',
configuration='').store()
os.environ["LEAPP_EXECUTION_ID"] = context
manager = getattr(request.session, 'leapp_repository', None)
if not manager:
manager = find_and_scan_repositories(repository_path,
include_locals=True)
manager.load(resolve=True)
yield manager
def _run_test(repo_path):
with repo_path.as_cwd():
repository = find_and_scan_repositories(repo_path.dirpath().strpath)
assert repository
repository.load(resolve=True)
assert getattr(leapp.tags, 'TestTag')
assert repository.lookup_actor('TestActor')
assert repository.lookup_workflow('TestWorkflow')
assert not repository.lookup_workflow('MissingWorkflow')
assert not repository.lookup_actor('MissingActor')
assert repository.repos
assert len(repository.dump()) >= 1
assert repository.actors
assert not repository.topics
assert not repository.models
assert repository.tags
assert repository.workflows
assert repository.tools
assert repository.libraries
assert repository.files
with pytest.raises(LeappRuntimeError):
repository.lookup_actor('TestActor')().run()
def load_repositories_from(name, repo_path, manager=None):
if get_config().has_option('repositories', name):
repo_path = get_config().get('repositories', name)
return find_and_scan_repositories(repo_path, manager=manager)
if "tests" in root and "tests/" not in root:
for item in files:
if item.endswith(".py"):
old_item = os.path.join(root, item)
new_item = old_item.replace(".", "_" + str(actor_id) + ".")
shutil.move(old_item, new_item)
actor_id += 1
# Register repos. This may take a while.
snactor_register(TMP_BASE_REPO)
# Find and collect leapp repositories.
repos = {}
for root, dirs, files in os.walk(BASE_REPO):
if ".leapp" in dirs:
repository = find_and_scan_repositories(root, include_locals=True)
try:
repository.load()
except LeappError as exc:
sys.stderr.write(exc.message)
sys.exit(2)
repos[repository] = root
# Scan repositories for tests and print status.
logger.info(" = Scanning Leapp repositories for tests")
for repo, repo_path in repos.items():
for actor in repo.actors:
if not actor.tests:
status = " Tests MISSING: {ACTOR} | class={CLASS}"
status = status.format(ACTOR=actor.name,
CLASS=actor.class_name)
def cli(args):
logging.basicConfig(level=logging.WARNING, stream=sys.stderr)
base_dir = find_repository_basedir('.')
if args.safe and args.json:
sys.stderr.write(
'The options --safe and --json are currently mutually exclusive\n')
sys.exit(1)
if args.safe:
sys.stdout.write(
'Repository:\n Name: {repository}\n Path: {base_dir}\n\n'.format(
repository=get_repository_name(base_dir), base_dir=base_dir))
safe_discover(base_dir)
sys.exit(0)
repository = find_and_scan_repositories(base_dir, include_locals=True)
try:
repository.load()
except LeappError as exc:
sys.stderr.write(exc.message)
sys.stderr.write('\n')
sys.exit(1)
actors = repository.actors
topics = [
topic for topic in get_topics()
if _is_local(repository, topic, base_dir, all_repos=args.all)
]
models = [
model for model in get_models()
if _is_local(repository, model, base_dir, all_repos=args.all)
]
tags = [
tag for tag in get_tags()
if _is_local(repository, tag, base_dir, all_repos=args.all)
]
workflows = [
workflow for workflow in get_workflows()
if _is_local(repository, workflow, base_dir, all_repos=args.all)
]
if not args.json:
sys.stdout.write(
'Repository:\n Name: {repository}\n Path: {base_dir}\n\n'.format(
repository=get_repository_name(base_dir), base_dir=base_dir))
_print_group('Actors',
actors,
name_resolver=lambda x: x.class_name,
path_resolver=_get_actor_path)
_print_group('Models', models)
_print_group('Tags', tags)
_print_group('Topics', topics)
_print_group('Workflows', workflows)
else:
output = {
'repository':
get_repository_name(base_dir),
'base_dir':
base_dir,
'topics':
dict((topic.__name__, _get_topic_details(topic))
for topic in topics),
'models':
dict((model.__name__, _get_model_details(model))
for model in models),
'actors':
dict((actor.class_name, _get_actor_details(actor))
for actor in actors),
'tags':
dict((tag.name, _get_tag_details(tag)) for tag in tags),
'workflows':
dict((workflow.__name__, _get_workflow_details(workflow))
for workflow in workflows)
}
json.dump(output, sys.stdout, indent=2)
sys.stdout.write('\n')
import logging
import sys
from leapp.repository.scan import find_and_scan_repositories
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO, filename='/dev/null')
logger = logging.getLogger('run_pytest.py')
BASE_REPO = 'repos'
repos = find_and_scan_repositories(BASE_REPO, include_locals=True)
repos.load()
print(','.join(repos.libraries))
help='path to a dot file that should be generated')
parser.add_argument('-x',
'--regex',
help='A regex that actors name should match')
clusters_help = (
'cluster actors by tags\n'
'WARNING: the edges are too close to each other, so it is usually hard to say which label '
'belongs to which edge')
parser.add_argument('-c',
'--clusters',
default=False,
action='store_true',
help=clusters_help)
args = parser.parse_args()
repository = find_and_scan_repositories(args.repo, include_locals=True)
if not repository:
print('Could not find repository in specified path: {path}'.format(
path=args.repo),
file=sys.stderr)
sys.exit(1)
try:
repository.load()
except Exception as e:
print(
'Could not load repository:\n{message}'.format(message=e.message),
file=sys.stderr)
sys.exit(1)
serializable_tags()
from __future__ import print_function
import json
from leapp.utils.repository import find_repository_basedir
from leapp.repository.scan import find_and_scan_repositories
base_dir = find_repository_basedir('.')
repository = find_and_scan_repositories(base_dir, include_locals=True)
repository.load()
if not hasattr(repository, 'repos'):
repository.repos = [repository]
print(json.dumps([repo.serialize() for repo in repository.repos]))