def __init__(self, name, test_definition):
self.name = name
test_definition = deep_merge(default_config, test_definition)
# quick shortcuts
self.test_env = test_definition['environment']
self.test_meta = test_definition['meta']
self.test_commands = test_definition.get('test_commands', [])
# take care of commands ...
self.test_commands = _build_exec_array(self.test_commands)
self.test_meta['test_before'] = \
_build_exec_array(self.test_meta.get('test_before', None))
self.test_meta['test_after'] = \
_build_exec_array(self.test_meta.get('test_after', None))
# okay.
# let's keep all file references relative to the configuration
# file. easy to remember.
configfilepath = realpath(dirname(self.test_meta.get('_configfile',
'./dummy')))
# self.TEMPLATE / .TEMPLATE_NAME
tmp = self.test_meta['docker_compose_template']
if not isabs(tmp):
tmp = realpath(join(configfilepath, tmp))
self.template = tmp
self.template_name = basename(self.template)
# self.BASEDIR
tmp = self.test_meta.get('test_basedir', configfilepath)
if not isabs(tmp):
tmp = realpath(join(configfilepath, tmp))
self.base_dir = tmp
# self.SANITIZED_NAME, .TEST_DIR
self.sanitized_name = resub("[^a-zA-Z0-9_]", "-", self.name)
self.test_dir = dbg_tr_get_testdir(self.base_dir, self.sanitized_name)
# extend SELF.TEST_ENV with TEST_DIR
self.test_env['test_dir'] = self.test_dir
# create SELF.COMMANDLINE
self.commandline = copy.copy(default_commandline_start)
for param in self.test_meta['docker_compose_params']:
self.commandline.append(param)
for key, val in self.test_env.items():
self.commandline.append("-e")
self.commandline.append("%s=%s" % (key, val))
self.commandline.append("--rm")
self.commandline.extend(copy.copy(default_commandline_end))
self.commandline.append(self.test_meta['test_service'])
# create .STATE, .RESULT, .EXCEPTION, .REASON
self.state = self.NOTRUN
self.results = []
self.exception = None
self.reason = None
# log setup
# NO LOGGING BEFORE HERE
log_filename = join(self.base_dir, basename(self.test_dir)) + ".log"
self.log = get_logger("t-%s" % self.name, filename=log_filename)
# some debug output
self.log.info("base commandline '%s'" % " ".join(self.commandline))
self.log.debug("test directory '%s'" % self.test_dir)
self.log.debug("template path '%s'" % self.template)
for key, val in self.test_env.items():
self.log.debug("env %s=%s" % (key, val))
def __init__(self,
name,
compose_file,
**kwargs):
self.name = "{}".format(name if name else basename(compose_file))
self.sanitized_name = "intmaniac{}".format(
resub("[^a-z0-9]", "",
self.name.lower() + basename(compose_file).lower())
)
self.template = compose_file
self.compose_wrapper = Compose(compose_file, self.sanitized_name,
run_kwargs={'throw': True})
# extract "top level" parameters
self.test_env = kwargs.pop('environment', {})
self.test_image = kwargs.pop('image')
self.test_linked_services = kwargs.pop('links')
self.test_commands = _build_exec_array(kwargs.pop('commands', []))
# save the rest
self.meta = kwargs
# state information
self.test_state = self.NOTRUN
self.test_results = []
self.exception = None
self.reason = None
# run information - this can only be set after the env is running
self.cleanup_test_containers = []
self.run_containers = None
# log setup
self.log = get_logger("t-%s" % self.name)
# some debug output
self.log.debug("using template '%s'" % self.template)
for key, val in self.test_env.items():
self.log.debug("env %s=%s" % (key, val))
def _prepare_environment(arguments):
global config, logger, derived_basedir
parser = ArgumentParser()
parser.add_argument("-c", "--config-file",
help="specify configuration file",
default="./intmaniac.yaml")
parser.add_argument("-e", "--env",
help="dynamically add a value to the environment",
default=[],
action="append")
parser.add_argument("-v", "--verbose",
help="increase verbosity level, use multiple times",
default=0,
action="count")
parser.add_argument("-t", "--temp-output-dir",
help="test dir location, default: $pwd/intmaniac")
config = parser.parse_args(arguments)
tools.init_logging(config)
derived_basedir = tools.setup_up_test_directory(config)
logger = tools.get_logger(__name__,
filename=join(derived_basedir, "root.log"))
def __init__(self,
name,
compose_file,
**kwargs):
self.name = "{}".format(name if name else basename(compose_file))
self.sanitized_name = "intmaniac{}".format(
resub("[^a-z0-9]", "",
self.name.lower() + basename(compose_file).lower())
)
self.template = compose_file
self.compose_wrapper = Compose(compose_file, self.sanitized_name,
run_kwargs={'throw': True})
# extract "top level" parameters
self.test_env = kwargs.pop('environment', {})
self.test_image = kwargs.pop('image')
self.test_linked_services = kwargs.pop('links')
self.test_commands = _build_exec_array(kwargs.pop('commands', []))
# meta_information
self.pull = kwargs.pop('pull', True)
self.pre = kwargs.pop('pre', None)
self.post = kwargs.pop('post', None)
self.allow_failure = kwargs.pop('allow_failure', False)
self.volumes = self.format_volume_mapping(kwargs.pop('volumes', []))
# save the rest (run-arguments for docker.container.create())
self.meta = kwargs
# state information
self.test_state = self.NOTRUN
self.test_results = []
self.exception = None
self.reason = None
# run information - this can only be set after the env is running
self.cleanup_test_containers = []
self.run_containers = None
# log setup
self.log = get_logger("t-%s" % self.name)
# some debug output
self.log.debug("using template '%s'" % self.template)
for key, val in self.test_env.items():
self.log.debug("env %s=%s" % (key, val))
def create_container(image, command=None, environment={}, **kwargs):
"""
Creates a new test container instance with the command given. Must be
called for each command, because we can't change the command once
it's set.
:param image: The docker image to use
:param command: The command to execute with the container, can be <None>
:param environment: The environment to use in the container
:param kwargs: keyword-arguments passed to docker.client.containers.create()
:return: a container-object
"""
logger = tools.get_logger(__name__ + ".create_container")
dc = get_client()
container = dc.containers.create(image,
command=command,
environment=environment,
**kwargs)
container_id = container.id
logger.debug(
"Container id {} created (image: {}, command: {}, env: {})".format(
container_id[:8], image,
command if isinstance(command, str) else str(command),
str(environment)))
return container
def create_container(image, command=None, environment={}):
"""
Creates a new test container instance with the command given. Must be
called for each command, because we can't change the command once
it's set.
:param image: The docker image to use
:param command: The command to execute with the container, can be <None>
:param environment: The environment to use in the container
:return: The container id string
"""
logger = tools.get_logger(__name__+".create_container")
dc = get_client()
tmp = dc.create_container(image,
command=command,
environment=environment)
container_id = tmp['Id']
logger.debug("Container id {} created (image: {}, command: {}, env: {})"
.format(
container_id[:8], image,
command if isinstance(command, str) else str(command),
str(environment)
)
)
return container_id
def _init_logging(config):
global logger
tools.init_logging(config)
logger = tools.get_logger(__name__)
from intmaniac import output
from intmaniac.testrun import Testrun
from intmaniac.tools import fail, deep_merge, get_logger
import yaml
from yaml.parser import ParserError
from yaml.scanner import ScannerError
import tempfile
from functools import partial
from re import search as research
from os import write as fdwrite, close as fdclose
from os.path import dirname, join, isabs, isfile
logger = get_logger(__name__)
def parse(argconfig):
"""
Opens the configuration file, de-serializes the contents, checks the
version number, and gives the configuration to the actual parser function.
Will return whatever the parser function returns, which should be a list
of Testrun objects.
:param path_to_file: The path to the configuration file
:return: A list of Testrun objects (hopefully :)
"""
fileconfig = _load_config_file(argconfig)
if 'version' not in fileconfig:
fail("Need 'config' key in configuration file, must be '2'.")
else:
from intmaniac import output
from intmaniac.testrun import Testrun
from intmaniac.tools import fail, deep_merge, get_logger
import yaml
from yaml.parser import ParserError
from yaml.scanner import ScannerError
import tempfile
from functools import partial
from re import search as research
from os import write as fdwrite, close as fdclose
from os.path import dirname, join, isabs, isfile
logger = get_logger(__name__)
def parse(argconfig):
"""
Opens the configuration file, de-serializes the contents, checks the
version number, and gives the configuration to the actual parser function.
Will return whatever the parser function returns, which should be a list
of Testrun objects.
:param path_to_file: The path to the configuration file
:return: A list of Testrun objects (hopefully :)
"""
fileconfig = _load_config_file(argconfig)
if 'version' not in fileconfig:
fail("Need 'config' key in configuration file, must be '2'.")
else:
conf_version = str(fileconfig['version'])
