def test_can_set_module_log_level_to_critical_via_environment(self):
module_name = "alt.barney.big.purple.dino_saur"
self.context.set_env(**{
"%s_LOG_LEVEL" % module_name.replace(".", "_").upper():
"CRITICAL"
})
logger = logger_for_module(module_name)
expect(logger.level).to(equal(logging.CRITICAL))
def on_report_created(self, report_filename, report_content, run_id,
**kwargs):
log = logger_for_module(__name__)
log.debug(f"Saving report {report_filename}")
self.save(artifact=report_content,
path=run_id,
filename=report_filename,
content_type=None)
def call_if_alive(ref, **kwargs):
log = logger_for_module(__name__)
func = ref()
if func:
log.debug(f"Executing {func}")
try:
func(**kwargs)
log.debug(f"{func} exited cleanly")
except Exception as e:
log.error(format_exception(e))
def defaults_for_module(module):
log = logger_for_module(__name__)
filename = module_filename(module, YML_FILENAME)
defaults = yaml.load(contents_of_file(filename), Loader=yaml.Loader) or {}
log.debug("Configuration from %s: %s" % (filename, defaults))
validate_defaults(defaults, filename=filename)
parent = parent_module(module)
if parent:
defaults = inherit_missing_defaults(defaults=defaults,
parent_module=parent)
return defaults
def __init__(self):
subscribe_event_handlers(self)
config = config_for_module(__name__)
log = logger_for_module(__name__)
self._proxies = {}
if config.http_proxy:
proxy = config.http_proxy
self._proxies["http"] = proxy
log.debug(f"Using HTTP proxy {proxy}")
if config.https_proxy:
proxy = config.https_proxy
self._proxies["https"] = proxy
log.debug(f"(Using HTTPS proxy {proxy}")
self._exception_callbacks = {}
self._logger = logger_for_module(__name__)
self._session = None
self._persistent_headers = {}
self._transcript = Transcript()
self._verify_certs = config.https_verify_certs
log.debug(f"Socket timeout: {self._socket_timeout()}")
def publish(cls, *, event, event_time=None, **kwargs):
conf = config_for_module(__name__)
log = logger_for_module(__name__)
run_id = conf.test_run_id
if event_time is None:
event_time = current_time()
log.debug(event)
if event in cls._subscribers.keys():
for subscriber in cls._subscribers[event]:
call_if_alive(subscriber,
event=event,
event_time=event_time,
run_id=run_id,
**kwargs)
def save(self, *, artifact, path, filename, content_type):
log = logger_for_module(__name__)
bucket = config_for_module(__name__).s3_bucket_for_artifacts
if not bucket:
raise InvalidConfiguration("$S3_BUCKET_FOR_ARTIFACTS is not set")
client = dependency(boto3).client("s3")
kwargs = {
"Bucket": bucket,
"Key": _assemble_file_save_path(path, filename),
"Body": artifact
}
if content_type:
kwargs["ContentType"] = content_type
log.debug(f"PUT {bucket}:{path}/{filename}")
client.put_object(**kwargs)
def on_artifact_created(
self,
run_id,
artifact,
artifact_group=None,
artifact_type=None,
artifact_mime_type=None,
suite_name=None,
test_name=None,
**kwargs,
):
log = logger_for_module(__name__)
path = self.path_for_artifact(suite_name, test_name, run_id)
filename = self.filename_for_artifact(artifact_group=artifact_group,
artifact_type=artifact_type,
mime_type=artifact_mime_type)
log.debug(f"Saving artifact {filename}")
self.save(artifact=artifact,
path=path,
filename=filename,
content_type=artifact_mime_type)
def test_logger_formatter_includes_log_level(self):
logger = logger_for_module("something")
logger.warning("SPAM ho!")
expect(self.last_message().lower()).to(contain("warning"))
def attempt():
logger_for_module(module_name)
from datetime import datetime, timedelta
import os
from time import sleep
from twin_sister import dependency
from questions_three.logging import logger_for_module
from questions_three.module_cfg import config_for_module
from .pool import Pool
log = logger_for_module(__name__)
def discover(top_dir):
walk = dependency(os).walk
scripts = []
for path, _, files in walk(top_dir):
scripts += [
dependency(os).path.join(path, fn) for fn in files
if not fn.startswith("_") and fn.endswith(".py")
]
return scripts
def _float_or_none(name, value):
if value in (None, ""):
return None
try:
return float(value)
except ValueError as e:
def test_can_set_module_log_level_to_error_via_environment(self):
module_name = "bubba"
self.context.set_env(**{"%s_LOG_LEVEL" % module_name.upper(): "ERROR"})
logger = logger_for_module(module_name)
expect(logger.level).to(equal(logging.ERROR))
def test_can_set_module_log_level_to_warning_via_environment(self):
module_name = "jerry"
self.context.set_env(
**{"%s_LOG_LEVEL" % module_name.upper(): "WARNING"})
logger = logger_for_module(module_name)
expect(logger.level).to(equal(logging.WARNING))
def test_can_set_module_log_level_to_debug_via_environment(self):
module_name = "harvey"
self.context.set_env(**{"%s_LOG_LEVEL" % module_name.upper(): "DEBUG"})
logger = logger_for_module(module_name)
expect(logger.level).to(equal(logging.DEBUG))
def test_default_log_level_is_info(self):
logger = logger_for_module("something")
expect(logger.level).to(equal(logging.INFO))
def test_logger_formatter_ends_with_message(self):
msg = "Hello! My name is '); DROP TABLE Users; --"
logger = logger_for_module("something")
logger.error(msg)
expect(self.last_message()).to(end_with(msg))
def test_logger_formatter_includes_module_name(self):
name = "names.ish_m_el"
logger = logger_for_module(name)
logger.info("Call me")
expect(self.last_message()).to(contain(name))
def test_logger_formatter_includes_timestamp(self):
logger = logger_for_module("something")
logger.warning("SPAM ho!")
expect(self.last_message()).to(start_with("%d-" % datetime.now().year))
def test_returns_a_logger(self):
logger = logger_for_module(module_name="jimmy")
expect(logger).to(be_a(Logger))
def test_environment_level_setting_does_not_affect_other_module(self):
self.context.set_env(ORANGES_LOG_LEVEL="CRITICAL")
logger = logger_for_module(module_name="apples")
expect(logger.level).to(equal(logging.INFO))
def test_child_setting_overrides_parent_setting(self):
self.context.set_env(SPAM_EGGS_LOG_LEVEL="DEBUG",
SPAM_EGGS_SAUSAGE_SPAM_LOG_LEVEL="WARNING")
logger = logger_for_module(module_name="spam.eggs.sausage.spam")
expect(logger.level).to(equal(logging.WARNING))
def test_environment_level_setting_affects_child_module(self):
self.context.set_env(SPAM_EGGS_LOG_LEVEL="DEBUG")
logger = logger_for_module(module_name="spam.eggs.sausage.spam")
expect(logger.level).to(equal(logging.DEBUG))