encommon 0.7.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

encommon/config/test/test_config.py

@@ -8,53 +8,33 @@ is permitted, for more information consult the project license file.
 
 
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from . import SAMPLES
-from ..config import Config
 from ..logger import Logger
 from ..params import Params
 from ... import ENPYRWS
-from ...crypts.crypts import Crypts
-from ...utils.sample import load_sample
-from ...utils.sample import prep_sample
+from ... import PROJECT
+from ...crypts import Crypts
+from ...utils import load_sample
+from ...utils import prep_sample
 
+if TYPE_CHECKING:
+    from ..config import Config
 
 
-def test_Config(  # noqa: CFQ001
-    config_path: Path,
+
+def test_Config(
+    tmp_path: Path,
+    config: 'Config',
 ) -> None:
     """
     Perform various tests associated with relevant routines.
 
-    :param config_path: Custom fixture for populating paths.
+    :param tmp_path: pytest object for temporal filesystem.
+    :param config: Primary class instance for configuration.
     """
 
-    (config_path
-        .joinpath('one.yml')
-        .write_text(
-            'enconfig:\n'
-            f'  paths: ["{config_path}"]\n'
-            'enlogger:\n'
-            '  stdo_level: info\n'))
-
-    (config_path
-        .joinpath('two.yml')
-        .write_text(
-            'encrypts:\n'
-            '  phrases:\n'
-            '    default: fernetphrase\n'
-            'enlogger:\n'
-            '  stdo_level: debug\n'
-            '  file_level: info\n'))
-
-
-    config = Config(
-        files=[
-            f'{config_path}/one.yml',
-            f'{config_path}/two.yml'],
-        cargs={
-            'enlogger': {
-                'file_level': 'warning'}})
 
     attrs = list(config.__dict__)
 
@@ -68,84 +48,70 @@ def test_Config(  # noqa: CFQ001
         '_Config__crypts']
 
 
-    assert repr(config).startswith(
-        '<encommon.config.config.Config')
-    assert isinstance(hash(config), int)
-    assert str(config).startswith(
-        '<encommon.config.config.Config')
-
+    assert repr(config)[:23] == (
+        '<encommon.config.config')
 
-    assert len(config.files.paths) == 2
-    assert len(config.paths.paths) == 1
-    assert len(config.cargs) == 1
-    assert isinstance(config.config, dict)
-    assert config.model is Params
-    assert isinstance(config.params, Params)
+    assert hash(config) > 0
 
+    assert str(config)[:23] == (
+        '<encommon.config.config')
 
-    _config1 = config.config
-    _config2 = config.config
 
-    assert _config1 is not _config2
+    assert 'ConfigFiles' in str(config.files)
 
+    assert 'ConfigPaths' in str(config.paths)
 
-    sample_path = Path(
-        f'{SAMPLES}/config.json')
+    assert len(config.cargs) == 1
 
-    sample = load_sample(
-        path=sample_path,
-        update=ENPYRWS,
-        content=_config1,
-        replace={
-            'config_path': str(config_path)})
+    assert len(config.config) == 3
 
-    expect = prep_sample(
-        content=_config2,
-        replace={
-            'config_path': str(config_path)})
+    assert config.model is Params
 
-    assert sample == expect
+    assert isinstance(config.params, Params)
 
+    assert isinstance(config.logger, Logger)
 
-    _params1 = config.params
-    _params2 = config.params
+    assert isinstance(config.crypts, Crypts)
 
-    assert _params1 is _params2
 
+    replaces = {
+        'pytemp': tmp_path,
+        'PROJECT': PROJECT}
 
-    sample_path = Path(
-        f'{SAMPLES}/params.json')
+    sample_path = (
+        f'{SAMPLES}/config.json')
 
     sample = load_sample(
         path=sample_path,
         update=ENPYRWS,
-        content=_params1.model_dump(),
-        replace={
-            'config_path': str(config_path)})
+        content=config.config,
+        replace=replaces)
 
     expect = prep_sample(
-        content=_params2.model_dump(),
-        replace={
-            'config_path': str(config_path)})
+        content=config.config,
+        replace=replaces)
 
     assert sample == expect
 
 
-    logger = config.logger
 
-    assert isinstance(logger, Logger)
+def test_Config_cover(
+    config: 'Config',
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
 
-    _logger1 = config.logger
-    _logger2 = config.logger
+    :param config: Primary class instance for configuration.
+    """
 
-    assert _logger1 is _logger2
 
+    logger1 = config.logger
+    logger2 = config.logger
 
-    crypts = config.crypts
+    assert logger1 is logger2
 
-    assert isinstance(crypts, Crypts)
 
-    _crypts1 = config.crypts
-    _crypts2 = config.crypts
+    crypts1 = config.crypts
+    crypts2 = config.crypts
 
-    assert _crypts1 is _crypts2
+    assert crypts1 is crypts2

encommon/config/test/test_files.py

@@ -9,12 +9,28 @@ is permitted, for more information consult the project license file.
 
 from pathlib import Path
 
+from pytest import fixture
+
 from . import SAMPLES
 from ..files import ConfigFile
 from ..files import ConfigFiles
-from ... import ENPYRWS
-from ...utils.sample import load_sample
-from ...utils.sample import prep_sample
+
+
+
+@fixture
+def files(
+    config_path: Path,
+) -> ConfigFiles:
+    """
+    Construct the instance for use in the downstream tests.
+
+    :param config_path: Custom fixture for populating paths.
+    :returns: Newly constructed instance of related class.
+    """
+
+    return ConfigFiles([
+        f'{SAMPLES}/wayne/bwayne.yml',
+        f'{SAMPLES}/stark/tstark.yml'])
 
 
 
@@ -28,78 +44,77 @@ def test_ConfigFile(
     """
 
     file = ConfigFile(
-        f'{config_path}/wayne/bwayne.yml')
+        f'{config_path}/config.yml')
+
 
     attrs = list(file.__dict__)
 
-    assert attrs == ['path', 'config']
+    assert attrs == [
+        'path',
+        'config']
+
 
+    assert repr(file)[:22] == (
+        '<encommon.config.files')
 
-    assert repr(file).startswith(
-        '<encommon.config.files.ConfigFile')
-    assert isinstance(hash(file), int)
-    assert str(file).startswith(
-        '<encommon.config.files.ConfigFile')
+    assert hash(file) > 0
 
+    assert str(file)[:22] == (
+        '<encommon.config.files')
 
-    assert file.path.name == 'bwayne.yml'
-    assert list(file.config) == ['name']
+
+    assert file.path.name == 'config.yml'
+
+    assert len(file.config) == 3
 
 
 
 def test_ConfigFiles(
-    config_path: Path,
+    files: ConfigFiles,
 ) -> None:
     """
     Perform various tests associated with relevant routines.
 
-    :param config_path: Custom fixture for populating paths.
+    :param files: Custom fixture for the configuration files.
     """
 
-    files = ConfigFiles([
-        f'{config_path}/wayne/bwayne.yml',
-        f'{config_path}/stark/tstark.yml'])
 
     attrs = list(files.__dict__)
 
     assert attrs == [
-        'paths', 'config',
+        'paths',
+        'config',
         '_ConfigFiles__merged']
 
 
-    assert repr(files).startswith(
-        '<encommon.config.files.ConfigFiles')
-    assert isinstance(hash(files), int)
-    assert str(files).startswith(
-        '<encommon.config.files.ConfigFiles')
+    assert repr(files)[:22] == (
+        '<encommon.config.files')
 
+    assert hash(files) > 0
 
-    assert len(files.paths) == 2
-    assert len(files.config) == 2
+    assert str(files)[:22] == (
+        '<encommon.config.files')
 
 
-    files = ConfigFiles(
-        f'{config_path}/wayne/bwayne.yml')
+    assert len(files.paths) == 2
 
+    assert len(files.config) == 2
+
+    assert files.merged == {
+        'name': 'Bruce Wayne'}
 
-    _merged1 = files.merged
-    _merged2 = files.merged
 
-    assert _merged1 is not _merged2
 
-    sample_path = Path(
-        f'{SAMPLES}/files.json')
+def test_ConfigFiles_cover(
+    files: ConfigFiles,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
 
-    sample = load_sample(
-        path=sample_path,
-        update=ENPYRWS,
-        content=_merged1,
-        replace={
-            'config_path': str(config_path)})
+    :param files: Custom fixture for the configuration files.
+    """
 
-    expect = prep_sample(
-        content=_merged2,
-        replace={
-            'config_path': str(config_path)})
+    merged1 = files.merged
+    merged2 = files.merged
 
-    assert sample == expect
+    assert merged1 is not merged2

encommon/config/test/test_logger.py

@@ -7,15 +7,42 @@ is permitted, for more information consult the project license file.
 
 
 
-from logging import Logger as _Logger
 from pathlib import Path
 
 from _pytest.logging import LogCaptureFixture
 
+from pytest import fixture
+
 from ..logger import Logger
 from ..logger import Message
+from ..params import LoggerParams
 from ...times.common import UNIXMPOCH
-from ...utils.stdout import strip_ansi
+from ...times.common import UNIXSPOCH
+from ...utils import strip_ansi
+
+
+
+_CAPLOG = list[tuple[str, int, str]]
+
+
+
+@fixture
+def logger(
+    tmp_path: Path,
+) -> Logger:
+    """
+    Construct the instance for use in the downstream tests.
+
+    :param tmp_path: pytest object for temporal filesystem.
+    :returns: Newly constructed instance of related class.
+    """
+
+    params = LoggerParams(
+        stdo_level='info',
+        file_level='info',
+        file_path=f'{tmp_path}/test.log')
+
+    return Logger(params=params)
 
 
 
@@ -24,18 +51,21 @@ def test_Message() -> None:
     Perform various tests associated with relevant routines.
     """
 
-
     message = Message(
         time=UNIXMPOCH,
         level='info',
-        dict={'foo': 'bar'},
-        empty=[],
-        float=1.0,
-        int=1,
-        list=[1, '2', 3],
+        string='foobar',
         none=None,
-        string='foo',
-        elapsed=0.69420)
+        list=['1', 2],
+        tuple=('1', 2),
+        set={'1', 2},
+        dict={'1': 2},
+        empty_list=[],
+        empty_dict={},
+        int=1,
+        float=2.0,
+        elapsed=3.69420)
+
 
     attrs = list(message.__dict__)
 
@@ -45,81 +75,66 @@ def test_Message() -> None:
         '_Message__fields']
 
 
-    assert repr(message).startswith(
-        'Message(level="info", time="1970')
-    assert isinstance(hash(message), int)
-    assert str(message).startswith(
-        'Message(level="info", time="1970')
-
+    assert repr(message)[:20] == (
+        'Message(level="info"')
 
-    assert repr(message) == (
-        'Message('
-        'level="info", '
-        f'time="{UNIXMPOCH}", '
-        'dict="{\'foo\': \'bar\'}", '
-        'float="1.0", '
-        'int="1", '
-        'list="[1, \'2\', 3]", '
-        'string="foo", '
-        'elapsed="0.69")')
+    assert hash(message) > 0
 
-    assert str(message) == repr(message)
+    assert str(message)[:20] == (
+        'Message(level="info"')
 
 
     assert message.level == 'info'
-    assert message.time == '1970-01-01'
 
-    assert message.fields == {
-        'dict': "{'foo': 'bar'}",
-        'float': '1.0',
-        'int': '1',
-        'list': "[1, '2', 3]",
-        'string': 'foo',
-        'elapsed': '0.69'}
+    assert message.time == 0
+
+    assert len(message.fields) == 8
 
 
-    output = strip_ansi(message.stdo_output)
+    output = strip_ansi(
+        message.stdo_output)
 
     assert output == (
         'level="info"'
-        ' time="1970-01-01T00:00:00Z"'
-        ' dict="{\'foo\': \'bar\'}"'
-        ' float="1.0"'
+        f' time="{UNIXSPOCH}"'
+        ' string="foobar"'
+        ' list="1,2"'
+        ' tuple="1,2"'
+        ' set="1,2"'
+        ' dict="{\'1\': 2}"'
         ' int="1"'
-        ' list="[1, \'2\', 3]"'
-        ' string="foo"'
-        ' elapsed="0.69"')
+        ' float="2.0"'
+        ' elapsed="3.69"')
 
 
-    assert message.file_output == (
+    output = message.file_output
+
+    assert output == (
         '{"level": "info",'
         f' "time": "{UNIXMPOCH}",'
-        ' "dict": "{\'foo\': \'bar\'}",'
-        ' "float": "1.0",'
+        ' "string": "foobar",'
+        ' "list": "1,2",'
+        ' "tuple": "1,2",'
+        ' "set": "1,2",'
+        ' "dict": "{\'1\': 2}",'
         ' "int": "1",'
-        ' "list": "[1, \'2\', 3]",'
-        ' "string": "foo",'
-        ' "elapsed": "0.69"}')
+        ' "float": "2.0",'
+        ' "elapsed": "3.69"}')
 
 
 
 def test_Logger(
-    tmp_path: Path,
+    logger: Logger,
     caplog: LogCaptureFixture,
 ) -> None:
     """
     Perform various tests associated with relevant routines.
 
-    :param tmp_path: pytest object for temporal filesystem.
+    :param logger: Custom fixture for the logger instance.
     :param caplog: pytest object for capturing log message.
     """
 
 
-    logger = Logger(
-        stdo_level='info',
-        file_level='info',
-        file_path=f'{tmp_path}/test.log')
-
     attrs = list(logger.__dict__)
 
     assert attrs == [
@@ -127,47 +142,78 @@ def test_Logger(
         '_Logger__file_level',
         '_Logger__file_path',
         '_Logger__started',
-        '_Logger__logger_stdo',
-        '_Logger__logger_file']
+        '_Logger__logr_stdo',
+        '_Logger__logr_file']
+
+
+    assert repr(logger)[:23] == (
+        '<encommon.config.logger')
 
+    assert hash(logger) > 0
 
-    assert repr(logger).startswith(
-        '<encommon.config.logger.Logger')
-    assert isinstance(hash(logger), int)
-    assert str(logger).startswith(
-        '<encommon.config.logger.Logger')
+    assert str(logger)[:23] == (
+        '<encommon.config.logger')
 
 
     assert logger.stdo_level == 'info'
+
     assert logger.file_level == 'info'
+
     assert logger.file_path is not None
-    assert logger.file_path.name == 'test.log'
+
     assert logger.started is False
-    assert isinstance(logger.logger_stdo, _Logger)
-    assert isinstance(logger.logger_file, _Logger)
+
+    assert logger.logger_stdo is not None
+
+    assert logger.logger_file is not None
+
+
+    logger.log_d(msg='pytest')
+    logger.log_c(msg='pytest')
+    logger.log_e(msg='pytest')
+    logger.log_i(msg='pytest')
+    logger.log_w(msg='pytest')
+
+
+
+def test_Logger_cover(
+    logger: Logger,
+    caplog: LogCaptureFixture,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param logger: Custom fixture for the logger instance.
+    :param caplog: pytest object for capturing log message.
+    """
 
 
     def _logger_logs() -> None:
-        logger.log_d(message='pytest')
-        logger.log_c(message='pytest')
-        logger.log_e(message='pytest')
-        logger.log_i(message='pytest')
-        logger.log_w(message='pytest')
+        logger.log_d(msg='pytest')
+        logger.log_c(msg='pytest')
+        logger.log_e(msg='pytest')
+        logger.log_i(msg='pytest')
+        logger.log_w(msg='pytest')
 
 
-    _caplog = list[tuple[str, int, str]]
+    def _logger_stdo() -> _CAPLOG:
 
+        output = caplog.record_tuples
+        key = 'encommon.logger.stdo'
 
-    def _logger_stdo() -> _caplog:
         return [
-            x for x in caplog.record_tuples
-            if x[0] == 'encommon.logger.stdo']
+            x for x in output
+            if x[0] == key]
+
+
+    def _logger_file() -> _CAPLOG:
 
+        output = caplog.record_tuples
+        key = 'encommon.logger.file'
 
-    def _logger_file() -> _caplog:
         return [
-            x for x in caplog.record_tuples
-            if x[0] == 'encommon.logger.file']
+            x for x in output
+            if x[0] == key]
 
 
     logger.start()
@@ -189,16 +235,17 @@ def test_Logger(
     logger.start()
 
     message = 'unknown exception'
+    raises = Exception('pytest')
 
     logger.log_e(
         message=message,
-        exc_info=Exception('pytest'))
+        exc_info=raises)
 
-    stdo_text = _logger_stdo()[-1][2]
-    file_text = _logger_file()[-1][2]
+    stdo = _logger_stdo()[-1][2]
+    file = _logger_file()[-1][2]
 
-    assert message in str(stdo_text)
-    assert message in str(file_text)
+    assert message in str(stdo)
+    assert message in str(file)
 
     assert len(_logger_stdo()) == 6
     assert len(_logger_file()) == 6