def test_does_not_set_extension_logger_level_if_none(self):
logger = Mock()
config = ConfigManager()
config.set(LOG_LEVEL, 'warning')
config.set(LOG_FORMAT, None)
config.set(LOG_DIR, '.')
config.set(APPLICATION_NAME, 'k2')
config.set(ENABLED_EXTENSIONS, ['extensionname'])
config.set(EXTENSION_LOG_LEVEL, None, entity='extensionname')
with patch('logging.getLogger', return_value=logger) as get_logger, \
patch('zaf.builtin.logging.logging.Filter', return_value=filter) as get_filter:
with ExtensionTestHarness(RootLogger, config=config):
get_logger.assert_any_call(get_logger_name('zaf', 'extensionname'))
get_logger.assert_any_call(get_logger_name('k2', 'extensionname'))
logger.setLevel.assert_called_with(logging.DEBUG)
get_filter.assert_called_with({'': 30})
def __init__(self, config, instances):
log_level = map_level(config.get(LOG_LEVEL))
log_format = config.get(LOG_FORMAT)
application_name = config.get(APPLICATION_NAME)
root_logger = logging.getLogger()
root_logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(log_format)
exclude_dict = {}
if log_level:
exclude_dict[''] = log_level
else:
exclude_dict[''] = LOG_LEVEL_OFF
for extension in config.get(ENABLED_EXTENSIONS, []):
extension_log_level = config.get(EXTENSION_LOG_LEVEL,
entity=extension)
for name in {'zaf', application_name}:
extension_logger = logging.getLogger(
get_logger_name(name, extension))
extension_logger.setLevel(logging.DEBUG)
if extension_log_level:
exclude_dict[get_logger_name(
name, extension)] = map_level(extension_log_level)
for logger_name in config.get(LOG_ERROR):
exclude_dict[logger_name] = logging.ERROR
for logger_name in config.get(LOG_WARNING):
exclude_dict[logger_name] = logging.WARNING
for logger_name in config.get(LOG_INFO):
exclude_dict[logger_name] = logging.INFO
for logger_name in config.get(LOG_DEBUG):
exclude_dict[logger_name] = logging.DEBUG
ch = logging.StreamHandler(sys.stderr)
ch.setFormatter(formatter)
ch.addFilter(Filter(exclude_dict))
root_logger.addHandler(ch)
def test_sets_extension_logger_level(self):
logger = Mock()
filter = Mock()
config = ConfigManager()
config.set(APPLICATION_NAME, 'k2')
config.set(ENABLED_EXTENSIONS, ['extensionname'])
config.set(EXTENSION_LOG_LEVEL, 'error', entity='extensionname')
with patch('logging.getLogger', return_value=logger) as get_logger, \
patch('zaf.builtin.logging.logging.Filter', return_value=filter) as get_filter:
with ExtensionTestHarness(RootLogger, config=config):
get_logger.assert_any_call(get_logger_name('zaf', 'extensionname'))
get_logger.assert_any_call(get_logger_name('k2', 'extensionname'))
logger.setLevel.assert_called_with(logging.DEBUG)
get_filter.assert_called_with(
{
'': 20,
'k2.extension.extensionname': 40,
'zaf.extension.extensionname': 40
})
def _log_file_config(self,
config,
file_id,
file_path,
extension_configs,
logger_name=None,
level='debug',
format=None,
additional_logger_levels={},
filetype='text'):
if logger_name is None:
logger_name = get_logger_name('k2', file_id)
log_file_config_name = '.'.join([LOG_FILES.namespace, LOG_FILES.name])
log_file_path_config_name = self._get_config_name(
file_id, LOG_FILE_PATH)
log_file_loggers_config_name = self._get_config_name(
file_id, LOG_FILE_LOGGERS)
log_file_level_config_name = self._get_config_name(
file_id, LOG_FILE_LEVEL)
log_file_format_config_name = self._get_config_name(
file_id, LOG_FILE_FORMAT)
log_file_debug_config_name = self._get_config_name(
file_id, LOG_FILE_DEBUG)
log_file_info_config_name = self._get_config_name(
file_id, LOG_FILE_INFO)
log_file_warning_config_name = self._get_config_name(
file_id, LOG_FILE_WARNING)
log_file_type_config_name = self._get_config_name(
file_id, LOG_FILE_TYPE)
extension_configs[log_file_config_name].append(file_id)
extension_configs[log_file_path_config_name] = os.path.join(
config.get(LOG_DIR), file_path)
extension_configs[log_file_loggers_config_name].append(logger_name)
extension_configs[log_file_level_config_name] = level
extension_configs[log_file_debug_config_name].extend(
additional_logger_levels.get('debug', []))
extension_configs[log_file_info_config_name].extend(
additional_logger_levels.get('info', []))
extension_configs[log_file_warning_config_name].extend(
additional_logger_levels.get('warning', []))
extension_configs[log_file_type_config_name] = filetype
if format is not None:
extension_configs[log_file_format_config_name] = format
def __init__(self,
ip,
port=23,
timeout=DEFAULT_TIMEOUT,
endmark=DEFAULT_END_MARK,
context_name=''):
self.ip = ip
self.port = port
self.telnet = None
self.timeout = timeout
self.endmark = re.compile(endmark) if endmark is not None else None
if context_name:
context_name = '.' + context_name
self.logger = logging.getLogger(
get_logger_name('k2', 'telnet') + context_name)
self.logger.addHandler(logging.NullHandler())
self.rawlogger = logging.getLogger('rawtelnet' + context_name)
self.rawlogger.addHandler(logging.NullHandler())
self.rawlogger_file = None
import logging
import re
from collections import Counter, defaultdict
from time import time
from zaf.component.decorator import component, requires
from zaf.config.options import ConfigOption, ConfigOptionId
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.decorator import callback_dispatcher
from k2.cmd.run import RUN_COMMAND
from k2.sut import SUT, SUT_RESET_DONE
from monitor import MONITOR_ENDPOINT, PERFORM_MEASUREMENT
logger = logging.getLogger(get_logger_name('k2', 'monitor', 'process'))
logger.addHandler(logging.NullHandler())
class SystemNetworkMonitorError(Exception):
pass
@component
@requires(exec='Exec', can=['telnet'])
class SystemNetworkStatisticsCollector(object):
"""Figure out the network RX and TX statistics by reading /proc/net/dev."""
def __init__(self, exec):
self._exec = exec
self._matcher = re.compile((r'\s+?'
r'(?P<interface>\S+):\s+'
r'(?P<rx_bytes>\S+)\s+'
import logging
from zaf.component.decorator import requires
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.decorator import callback_dispatcher
from healthcheck import HealthCheckError
from k2.cmd.run import RUN_COMMAND
from k2.runner import TEST_CASE_FINISHED
from k2.runner.testcase import Verdict
from k2.sut import SUT, SUT_RECOVERY_PERFORM
from . import HEALTH_CHECK_ENDPOINT, PERFORM_HEALTH_CHECK
logger = logging.getLogger(get_logger_name('k2', 'healthcheck'))
logger.addHandler(logging.NullHandler())
@CommandExtension(
name='healthcheck',
extends=[RUN_COMMAND],
config_options=[
ConfigOption(SUT, required=False, instantiate_on=True),
],
endpoints_and_messages={HEALTH_CHECK_ENDPOINT: [PERFORM_HEALTH_CHECK]})
class HealthMonitor(AbstractExtension):
"""Monitor SUT health."""
def __init__(self, config, instances):
self._entity = instances.get(SUT)
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.decorator import callback_dispatcher
from k2.finder.testfinder import RUN_COMMAND
from k2.results.results import TestCaseFinished, TestCaseStarted
from k2.runner import TEST_CASE_FINISHED, TEST_CASE_STARTED
from k2.runner.testcase import Verdict
from multirunner import MULTI_RUNNER_ENABLED, MULTI_RUNNER_ENDPOINT, TEST_SUBRUN
from . import CONSOLE_BINARY_ERROR_PATTERN, CONSOLE_BINARY_FAILED_PATTERN, \
CONSOLE_BINARY_IGNORED_PATTERN, CONSOLE_BINARY_PASSED_PATTERN, CONSOLE_BINARY_PATH, \
CONSOLE_BINARY_PENDING_PATTERN, CONSOLE_BINARY_SKIPPED_PATTERN, CONSOLE_BINARY_TIMEOUT, \
CONSOLE_binaryid
logger = logging.getLogger(get_logger_name('k2', 'consolerunner'))
logger.addHandler(logging.NullHandler())
@CommandExtension(
name='consolerunner',
extends=[RUN_COMMAND],
config_options=[
ConfigOption(CONSOLE_binaryid, required=False, instantiate_on=True),
ConfigOption(CONSOLE_BINARY_PATH, required=True),
ConfigOption(CONSOLE_BINARY_TIMEOUT, required=True),
ConfigOption(CONSOLE_BINARY_PASSED_PATTERN, required=False),
ConfigOption(CONSOLE_BINARY_FAILED_PATTERN, required=False),
ConfigOption(CONSOLE_BINARY_ERROR_PATTERN, required=False),
ConfigOption(CONSOLE_BINARY_PENDING_PATTERN, required=False),
ConfigOption(CONSOLE_BINARY_SKIPPED_PATTERN, required=False),
from zaf.component.util import add_cans
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, ExtensionConfig, \
FrameworkExtension, get_logger_name
from zaf.messages.dispatchers import SequentialDispatcher
from k2.cmd.run import RUN_COMMAND
from k2.sut import SUT
from powermeter import AVAILABLE_POWER_METERS, K2_POWER_METER_COMPONENT, POWER_METER, \
POWER_METER_POWER
from powermeter.powermeter import PowerMeter
from powermeter.powermetercommand import POWER_METER_COMMAND
from . import DUMMY_POWER_METER_ENDPOINT, DUMMY_POWER_METER_VALUE
logger = logging.getLogger(get_logger_name('k2', 'dummypowermeter'))
logger.addHandler(logging.NullHandler())
@CommandExtension(
name='dummypowermeter',
extends=[RUN_COMMAND, POWER_METER_COMMAND],
config_options=[
ConfigOption(SUT, required=True, instantiate_on=True),
ConfigOption(POWER_METER, required=False),
ConfigOption(DUMMY_POWER_METER_VALUE, required=False)
],
endpoints_and_messages={DUMMY_POWER_METER_ENDPOINT: [POWER_METER_POWER]},
groups=['powermeter'],
)
class DummyPowerMeter(AbstractExtension):
import logging
import re
from zaf.component.decorator import component, requires
from zaf.extensions.extension import get_logger_name
from .common import wait_for
logger = logging.getLogger(get_logger_name('k2', 'waitfor', 'file'))
logger.addHandler(logging.NullHandler())
@component()
@requires(exec='Exec')
class WaitForFile:
def __init__(self, exec):
self._exec = exec
def wait_for_match(self, file, regex, timeout=60, poll_interval=1.0):
"""
Wait for a match in the file and return Match object.
:param file: The file to look in
:param regex: The regex pattern to use
:param timeout: the timeout in seconds
:param poll_interval: the interval in seconds to use when polling the file
:return: Match object
:raises: TimeoutError if match is not found before timeout
"""
compiled_regex = re.compile(regex)
"""Provides the *noop* (no operation) command."""
import logging
from zaf.application import ApplicationContext
from zaf.commands.command import CommandId
from zaf.extensions.extension import AbstractExtension, FrameworkExtension, get_logger_name
logger = logging.getLogger(get_logger_name('zaf', 'noop'))
logger.addHandler(logging.NullHandler())
def noop(core):
"""Noop (no operation) command. Does nothing. Takes no arguments."""
return 0
NOOP_COMMAND = CommandId('noop',
noop.__doc__,
noop, [],
hidden=True,
application_contexts=ApplicationContext.EXTENDABLE)
@FrameworkExtension(name='noop', commands=[NOOP_COMMAND])
class NoopExtension(AbstractExtension):
"""Provides the noop (no operation) command."""
def __init__(self, config, instances):
pass
import logging
import time
from zaf.component.decorator import component, requires
from zaf.extensions.extension import get_logger_name
from powerswitch import POWER_SWITCH_POWER_STATE, POWER_SWITCH_POWEROFF, POWER_SWITCH_POWERON, \
POWER_SWITCH_TIMEOUT
logger = logging.getLogger(get_logger_name('k2', 'powerswitch'))
POWER_CYCLE_TIME = 30
class NoPowerSwitch(Exception):
pass
class MultiplePowerSwitches(Exception):
pass
class PowerSwitch(object):
def __init__(self, messagebus, entity, receiver_endpoint_id):
self.messagebus = messagebus
self.entity = entity
self.receiver_endpoint_id = receiver_endpoint_id
def _return_or_raise(self, futures, message):
if len(futures) == 0:
msg = 'Trying to use powerswitch failed due to no powerswitch available for sut {entity}'.format(
import logging
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.decorator import callback_dispatcher
from connectioncheck import CONNECTIONCHECK_RUN_CHECK
from connectioncheck.connectioncheck import ConnectionCheckResult
from k2.cmd.run import RUN_COMMAND
from k2.sut import SUT, SUT_IP
from . import TELNET_CONNECTION_CHECK_ENABLED, TELNET_CONNECTION_CHECK_ENDPOINT, \
TELNET_CONNECTION_CHECK_REQUIRED, TELNET_ENABLED, TELNET_PORT
from .client import TelnetClient
logger = logging.getLogger(get_logger_name('k2', 'telnetcc'))
@CommandExtension(
name='telnetcc',
extends=[RUN_COMMAND],
config_options=[
ConfigOption(SUT, required=True, instantiate_on=True),
ConfigOption(SUT_IP, required=True),
ConfigOption(TELNET_ENABLED, required=True),
ConfigOption(TELNET_CONNECTION_CHECK_ENABLED, required=True),
ConfigOption(TELNET_CONNECTION_CHECK_REQUIRED, required=True),
ConfigOption(TELNET_PORT, required=True),
],
endpoints_and_messages={
TELNET_CONNECTION_CHECK_ENDPOINT: [
import threading
from zaf.component.decorator import requires
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.decorator import callback_dispatcher
from k2 import ABORT, CRITICAL_ABORT
from k2.cmd.run import RUN_COMMAND, TEST_RUN
from k2.runner import ABORT_TEST_CASE_REQUEST, EXTENSION_NAME, RUNNER_PARALLEL_WORKERS, messages
from k2.runner.runner import TestRunner
from k2.sut import SUT_RESET_DONE, SUT_RESET_STARTED
from . import RUNNER_SUITE_NAME
logger = logging.getLogger(get_logger_name('k2', EXTENSION_NAME, 'manager'))
logger.addHandler(logging.NullHandler())
class AbortedBeforeStartException(Exception):
pass
@CommandExtension(
name=EXTENSION_NAME,
config_options=[
ConfigOption(RUNNER_SUITE_NAME, required=True),
ConfigOption(RUNNER_PARALLEL_WORKERS, required=True),
],
extends=[RUN_COMMAND],
endpoints_and_messages=messages.runner_endpoint_with_messages())
import logging
import tempfile
from unittest.mock import patch
from k2.cmd.run import RUN_COMMAND
from zaf.component.decorator import component
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
logger = logging.getLogger(get_logger_name('k2', 'workspacecomponent'))
logger.addHandler(logging.NullHandler())
@CommandExtension('workspacecomponent', extends=[RUN_COMMAND])
class WorkspaceExtension(AbstractExtension):
def __init__(self, config, instances):
@component()
class Workspace(object):
def __init__(self):
self.temp_dir = None
self.path = None
self.env = None
def __enter__(self):
self.temp_dir = tempfile.TemporaryDirectory(prefix='pycred-')
self.path = self.temp_dir.__enter__()
self.env = patch.dict('os.environ',
{'PYCRED_STORE_PATH': self.path})
self.env.__enter__()
logger.info("Creating workspace {d}".format(d=self.path))
return self
import logging
from zaf.component.decorator import requires
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.decorator import callback_dispatcher
from k2.cmd.run import RUN_COMMAND
from k2.runner.messages import TEST_RUN_FINISHED
from metrics import GENERATE_METRICS_AGGREGATE, GENERATE_METRICS_REPORT, METRICS_ENDPOINT
logger = logging.getLogger(get_logger_name('k2', 'metrics', 'triggers'))
logger.addHandler(logging.NullHandler())
@CommandExtension(
name='metrics',
extends=[RUN_COMMAND],
groups=['metrics'],
)
class TriggerMetricsReportGenerationOnTestRunFinished(AbstractExtension):
"""Triggers metrics reports generation when a test run is finished."""
@callback_dispatcher([TEST_RUN_FINISHED], priority=-1)
@requires(messagebus='MessageBus')
def trigger_report_generation(self, message, messagebus):
logger.info('Test run finished, triggering metrics report generation')
messagebus.trigger_event(GENERATE_METRICS_REPORT,
METRICS_ENDPOINT,
data=None)
@CommandExtension(
"""Provides the run command that is used to run K2 tests."""
import logging
from collections import namedtuple
from zaf.commands.command import CommandId
from zaf.config.options import ConfigOption, ConfigOptionId
from zaf.extensions.extension import FrameworkExtension, get_logger_name
from zaf.messages.message import EndpointId, MessageId
from k2.sut import SUT
logger = logging.getLogger(get_logger_name('k2', 'runcommand'))
logger.addHandler(logging.NullHandler())
EXIT_CODE_FROM_VERDICT = ConfigOptionId(
'exitcode.from.verdict',
'Give the verdict of the test run as exit code',
option_type=bool,
default=False)
RUN_COMMAND_ENDPOINT = EndpointId('runcommand', """
The K2 run command
""")
PRE_INITIALIZE_SUT = MessageId(
'PRE_INITIALIZE_SUT', """
Triggered before the initialize the SUT.
This message is sent once for each sut entity.
data: None
import logging
import os
from zaf.config.options import ConfigOption, ConfigOptionId
from zaf.extensions.extension import FrameworkExtension, get_logger_name
from k2.utils.writers import JsonWriter
from ..messages import collect_metrics
from .reporter import AbstractMetricsReportExtension
logger = logging.getLogger(get_logger_name('k2', 'metrics.json'))
logger.addHandler(logging.NullHandler())
JSON_REPORTER_ID = ConfigOptionId(
name='ids',
description='Names a JSON metrics reporter instance',
multiple=True,
entity=True,
namespace='metrics.json',
)
JSON_DIRECTORY = ConfigOptionId(
name='dir',
description='Directory to write the JSON reports to',
default='${output.dir}/metrics/json',
at=JSON_REPORTER_ID,
)
JSON_FILENAME = ConfigOptionId(
name='filename',
"""
import logging
from zaf.component.decorator import requires
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.decorator import callback_dispatcher
from k2.cmd.run import RUN_COMMAND
from k2.reports.z2 import Z2_INTERNAL_PUBLISH_REPORT_REQUEST, Z2_REPORTS, Z2_REPORTS_BUILD_NUMBER, \
Z2_REPORTS_ENDPOINT, Z2_REPORTS_FILE, Z2_REPORTS_JOB_NAME, Z2_REPORTS_URL
from k2.reports.z2.writer import generate_report, upload_report, write_report
from k2.results import RESULTS_ENDPOINT, TEST_RESULTS_COLLECTED
logger = logging.getLogger(get_logger_name('k2', 'z2report'))
logger.addHandler(logging.NullHandler())
@CommandExtension(
name='z2report',
extends=[RUN_COMMAND],
config_options=[
ConfigOption(Z2_REPORTS, required=True),
ConfigOption(Z2_REPORTS_JOB_NAME, required=False),
ConfigOption(Z2_REPORTS_BUILD_NUMBER, required=False),
],
endpoints_and_messages={
Z2_REPORTS_ENDPOINT: [Z2_INTERNAL_PUBLISH_REPORT_REQUEST],
},
groups=['test-results'],
from zaf.component.decorator import requires
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.dispatchers import CallbackDispatcher
from k2.finder.testfinder import RUN_COMMAND
from k2.results.results import TestCaseFinished, TestCaseStarted
from k2.runner import TEST_CASE_FINISHED, TEST_CASE_STARTED
from k2.runner.testcase import Verdict
from multirunner import MULTI_RUNNER_ENABLED, MULTI_RUNNER_ENDPOINT, TEST_SUBRUN
from . import GTEST_BINARY_PATH, GTEST_FILTER, GTEST_SERIAL_ENDMARK, GTEST_TIMEOUT, \
GTEST_USE_SERIAL, GTEST_XML_REPORT_PATH, GTEST_binaryid
logger = logging.getLogger(get_logger_name('k2', 'gtesbinarytrunner'))
logger.addHandler(logging.NullHandler())
@CommandExtension(
name='gtestbinaryrunner',
extends=[RUN_COMMAND],
config_options=[
ConfigOption(GTEST_binaryid, required=False, instantiate_on=True),
ConfigOption(GTEST_BINARY_PATH, required=True),
ConfigOption(GTEST_TIMEOUT, required=True),
ConfigOption(GTEST_XML_REPORT_PATH, required=False),
ConfigOption(GTEST_FILTER, required=False),
ConfigOption(GTEST_USE_SERIAL, required=False),
ConfigOption(GTEST_SERIAL_ENDMARK, required=False),
ConfigOption(MULTI_RUNNER_ENABLED, required=False),
from zaf.component.util import add_cans
from zaf.config import MissingConditionalConfigOption
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.dispatchers import SequentialDispatcher
from k2.cmd.run import RUN_COMMAND
from k2.sut import SUT
from powerswitch import K2_POWER_COMPONENT, POWER_SWITCH, POWER_SWITCH_POWER_STATE, \
POWER_SWITCH_POWEROFF, POWER_SWITCH_POWERON
from powerswitch.powercommand import POWER_COMMAND
from powerswitch.powerswitch import PowerSwitch
from . import GUDE_IP, GUDE_PORT, GUDE_POWER_SWITCH_ENDPOINT, GudePowerState
logger = logging.getLogger(get_logger_name('k2', 'gude'))
@CommandExtension(
name='gude',
extends=[RUN_COMMAND, POWER_COMMAND],
config_options=[
ConfigOption(SUT, required=True, instantiate_on=True),
ConfigOption(POWER_SWITCH, required=False),
ConfigOption(GUDE_IP, required=False),
ConfigOption(GUDE_PORT, required=False),
],
endpoints_and_messages={
GUDE_POWER_SWITCH_ENDPOINT:
[POWER_SWITCH_POWERON, POWER_SWITCH_POWEROFF, POWER_SWITCH_POWER_STATE]
},
from sutevents import LOG_LINE_RECEIVED
from zserial import SERIAL_RAW_LINE, SERIAL_RECONNECT
from . import SERIAL_BAUDRATE, SERIAL_CONNECTED, SERIAL_CONNECTION_LOST, SERIAL_DEVICE, \
SERIAL_ENABLED, SERIAL_ENDPOINT, SERIAL_FILTERS, SERIAL_LOG_ENABLED, SERIAL_PORT_IDS, \
SERIAL_PROMPT, SERIAL_RESUME, SERIAL_SEND_COMMAND, SERIAL_SUSPEND, SERIAL_TIMEOUT, \
SUT_SERIAL_PORTS
from .client import SerialClient
from .connection import find_serial_port, start_serial_connection
from .log import serial_log_line_entity
from .messages import SendSerialCommandData
from .sut import SUT_SERIAL_BAUDRATE, SUT_SERIAL_DEVICE, SUT_SERIAL_ENABLED, SUT_SERIAL_FILTERS, \
SUT_SERIAL_LOG_ENABLED, SUT_SERIAL_PROMPT, SUT_SERIAL_TIMEOUT, \
add_sut_options_to_extension_config
logger = logging.getLogger(get_logger_name('k2', 'zserial'))
NUMBER_OF_RECONNECTION_TRIES = 30
TIMEOUT_BETWEEN_CONNECTIONS = 1
class SerialException(Exception):
pass
@requires(port='SerialPort')
@requires(messagebus='MessageBus')
@component(name='Exec', can=['serial'], provided_by_extension='zserial', priority=-1)
def serial_exec(port, messagebus):
"""Exec component using serial."""
return SerialClient(messagebus, port.entity, port.serial.timeout, port.serial.prompt)
A wrapper around the GitPython module.
Provides a component that holds a GitPython Repo instance and provides some helper methods for interacting with it
"""
import datetime
import logging
import os
from contextlib import contextmanager
from tempfile import TemporaryDirectory
from zaf.component.decorator import component
from zaf.extensions.extension import AbstractExtension, FrameworkExtension, get_logger_name
logger = logging.getLogger(get_logger_name('k2', 'gitrepo'))
logger.addHandler(logging.NullHandler())
@component(provided_by_extension='gitrepo')
class GitRepo(object):
"""A helper/wrapper component around the GitPython module."""
def __init__(self, repodir, remote_name=None):
from git import Repo
self.path = repodir
self.remote_name = remote_name
self.repo = Repo.init(repodir)
self.user = None
"""
import logging
import os
import threading
import re
from http.server import BaseHTTPRequestHandler, HTTPServer
from socketserver import ThreadingMixIn
from urllib.parse import parse_qs, urlparse
from zaf.commands.command import CommandId
from zaf.component.decorator import component, requires
from zaf.config.options import ConfigOption, ConfigOptionId
from zaf.extensions.extension import AbstractExtension, FrameworkExtension, get_logger_name
logger = logging.getLogger(get_logger_name('k2', 'httpfileserver'))
logger.addHandler(logging.NullHandler())
HTTP_CODE_200 = 200 # OK
HTTP_CODE_302 = 302 # Redirection
HTTP_CODE_404 = 404 # Not found error
HTTP_CODE_500 = 500 # Server error
class ServerContent(object):
"""
POD class for keeping track of served content.
Only path and queries are used for equality and hash.
"""
def __init__(self, path, queries, status_code):
import logging
import subprocess
from zaf.extensions.extension import get_logger_name
logger = logging.getLogger(get_logger_name('k2', 'hostshellexec'))
logger.addHandler(logging.NullHandler())
class HostShellExecutorError(Exception):
pass
class HostShellExecutor(object):
def __init__(self, timeout=60, encoding='utf-8'):
self._timeout = timeout
self._encoding = encoding
def send_line(self,
line,
timeout=None,
expected_exit_code=None,
extended_process_information=False):
timeout = timeout if timeout is not None else self._timeout
try:
logger.debug('Sending line: {line}'.format(line=line))
process = self._send_line_nowait(line)
stdout, stderr = process.communicate(timeout=timeout)
stdout = stdout.decode(self._encoding)
stderr = stderr.decode(self._encoding)
import enum
import inspect
import logging
import threading
import uuid
from textwrap import dedent
from zaf.extensions.extension import get_logger_name
from k2.runner import EXTENSION_NAME
from k2.runner.exceptions import DisabledException, SkipException
from k2.runner.timeout import get_timeout
from k2.utils.string import make_valid_filename
logger = logging.getLogger(get_logger_name('k2', EXTENSION_NAME, 'testcase'))
logger.addHandler(logging.NullHandler())
@enum.unique
class Verdict(enum.IntEnum):
# Starting at zero to be able to map to exit code
PASSED = 0
FAILED = 1 # An AssertionError exception was raised
ERROR = 2 # Any non-AssertionError exception was raised
PENDING = 3 # Test case has not yet run
SKIPPED = 4 # Not run due to missing but not failing precondition
IGNORED = 5 # Not run due to configuration
def combine(self, other):
if self == Verdict.ERROR or other == Verdict.ERROR:
import logging
import re
import sys
import click
from zaf.application import APPLICATION_CONTEXT, APPLICATION_VERSION, ENTRYPOINT_NAME
from zaf.builtin.click.check_duplicates import check_for_ambiguous_duplicates
from zaf.commands import COMMAND
from zaf.config.options import ConfigOption
from zaf.config.types import Choice, ConfigChoice, Count, Entity, Flag, GlobPattern, Path
from zaf.extensions.extension import AbstractExtension, ExtensionConfig, FrameworkExtension, \
get_logger_name
from zaf.utils.bashcompletion import is_bash_completion
logger = logging.getLogger(get_logger_name('zaf', 'click'))
logger.addHandler(logging.NullHandler())
CLICK_CONFIG_PRIORITY = 100
IS_BASH_COMPLETION = is_bash_completion()
HELP_OPTIONS = ['-h', '--help', '--full-help']
FULL_HELP_OPTIONS = ['--full-help']
VERSION_OPTIONS = ['--version']
@FrameworkExtension(
name='click',
load_order=1,
config_options=[ConfigOption(ENTRYPOINT_NAME, required=True)])
class ClickInitPluginPath(AbstractExtension):
import logging
import os
from zaf.component.decorator import component, requires
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from k2.cmd.run import RUN_COMMAND
from zk2component import LOG_DIR_TESTS
logger = logging.getLogger(get_logger_name('k2', 'zk2component'))
logger.addHandler(logging.NullHandler())
@CommandExtension('zk2component',
extends=[RUN_COMMAND],
config_options=[ConfigOption(LOG_DIR_TESTS, required=True)])
class Zk2Component(AbstractExtension):
def __init__(self, config, instances):
@component
@requires(zk2='PyProc', args=['zk2'])
@requires(context='ComponentContext')
class Zk2(object):
logdir_tests = config.get(LOG_DIR_TESTS)
def __init__(self, zk2, config, context):
self.zk2 = zk2
self.config = config
self.context = context
import logging
from zaf.component.decorator import requires
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.decorator import callback_dispatcher
from k2 import CRITICAL_ABORT
from k2.cmd.run import RUN_COMMAND
from k2.sut import SUT_RESET_STARTED
from . import ABORT_ON_UNEXPECTED_SUT_RESET, ABORT_ON_UNEXPECTED_SUT_RESET_ENDPOINT
logger = logging.getLogger(get_logger_name('k2', 'aborttestrun'))
logger.addHandler(logging.NullHandler())
@CommandExtension(name='aborttestrun',
extends=[RUN_COMMAND],
config_options=[
ConfigOption(ABORT_ON_UNEXPECTED_SUT_RESET,
required=True)
],
endpoints_and_messages={
ABORT_ON_UNEXPECTED_SUT_RESET_ENDPOINT: [CRITICAL_ABORT]
},
activate_on=[ABORT_ON_UNEXPECTED_SUT_RESET])
class AbortOnUnexpectedSutReset(AbstractExtension):
"""
Aborts test run on unexpected sut reset.
import logging
from k2.cmd.run import INITIALIZE_SUT, RUN_COMMAND
from k2.sut import SUT
from zaf.component.decorator import requires
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from zaf.messages.decorator import callback_dispatcher
logger = logging.getLogger(get_logger_name('k2', 'initializejenkins'))
logger.addHandler(logging.NullHandler())
@CommandExtension(
name='initializejenkins',
extends=[RUN_COMMAND],
config_options=[ConfigOption(SUT, required=True, instantiate_on=True)])
class InitializeJenkins(AbstractExtension):
def __init__(self, config, instances):
logger.info('Intializing Jenkins')
@callback_dispatcher([INITIALIZE_SUT], entity_option_id=SUT)
@requires(jenkins='Jenkins')
def initialize_jenkins(self, message, jenkins):
logger.info('Jenkins initialization complete')
import logging
import subprocess
from k2.cmd.run import RUN_COMMAND
from zaf.component.decorator import component
from zaf.config.options import ConfigOption
from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name
from . import COVERAGE_CONFIG_FILE, COVERAGE_ENABLED
logger = logging.getLogger(get_logger_name('k2', 'pycredcomponent'))
logger.addHandler(logging.NullHandler())
@CommandExtension(
'pycredcomponent',
extends=[RUN_COMMAND],
config_options=[
ConfigOption(COVERAGE_CONFIG_FILE, required=False),
ConfigOption(COVERAGE_ENABLED, required=False),
])
class PyCredExtension(AbstractExtension):
def __init__(self, config, instances):
@component()
class PyCred(object):
coverage_enabled = config.get(COVERAGE_ENABLED, False)
coverage_config_file = config.get(COVERAGE_CONFIG_FILE)
