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

encommon/times/test/test_parse.py

@@ -10,7 +10,6 @@ is permitted, for more information consult the project license file.
 from datetime import timedelta
 
 from pytest import mark
-from pytest import raises
 
 from ..common import utcdatetime
 from ..parse import parse_time
@@ -25,85 +24,67 @@ def test_parse_time() -> None:
     Perform various tests associated with relevant routines.
     """
 
-    utcnow = utcdatetime()
+    dtime = utcdatetime()
     delta = timedelta(seconds=1)
 
 
-    dtime = parse_time(
+    parsed = parse_time(
         '1/1/1970 6:00am')
 
-    assert dtime.year == 1970
-    assert dtime.month == 1
-    assert dtime.day == 1
-    assert dtime.hour == 6
+    assert parsed.year == 1970
+    assert parsed.month == 1
+    assert parsed.day == 1
+    assert parsed.hour == 6
 
 
-    dtime = parse_time(
+    parsed = parse_time(
         '12/31/1969 6:00pm',
         tzname='US/Central')
 
-    assert dtime.year == 1970
-    assert dtime.month == 1
-    assert dtime.day == 1
-    assert dtime.hour == 0
+    assert parsed.year == 1970
+    assert parsed.month == 1
+    assert parsed.day == 1
+    assert parsed.hour == 0
 
 
-    dtime = parse_time(0)
-    assert dtime.year == 1970
+    parsed = parse_time(0)
+    assert parsed.year == 1970
 
-    dtime = parse_time('0')
-    assert dtime.year == 1970
+    parsed = parse_time('0')
+    assert parsed.year == 1970
 
 
-    dtime = parse_time('max')
+    parsed = parse_time('max')
 
-    assert dtime.year == 9999
-    assert dtime.month == 12
-    assert dtime.day == 31
-    assert dtime.hour == 23
+    assert parsed.year == 9999
+    assert parsed.month == 12
+    assert parsed.day == 31
+    assert parsed.hour == 23
 
-    dtime = parse_time('min')
+    parsed = parse_time('min')
 
-    assert dtime.year == 1
-    assert dtime.month == 1
-    assert dtime.day == 1
-    assert dtime.hour == 0
+    assert parsed.year == 1
+    assert parsed.month == 1
+    assert parsed.day == 1
+    assert parsed.hour == 0
 
 
-    dtime = parse_time('now')
-    assert dtime - utcnow <= delta
+    parsed = parse_time('now')
+    assert parsed - dtime <= delta
 
-    dtime = parse_time(None)
-    assert dtime - utcnow <= delta
+    parsed = parse_time(None)
+    assert parsed - dtime <= delta
 
-    dtime = parse_time('None')
-    assert dtime - utcnow <= delta
+    parsed = parse_time('None')
+    assert parsed - dtime <= delta
 
 
-    dtime = parse_time('+1y')
-    assert dtime - utcnow > delta
+    parsed = parse_time('+1y')
+    assert parsed - dtime > delta
 
 
-    assert parse_time(dtime) == dtime
-
-
-
-def test_parse_time_raises() -> None:
-    """
-    Perform various tests associated with relevant routines.
-    """
-
-
-    with raises(ValueError) as reason:
-        parse_time(0, tzname='foo/bar')
-
-    assert str(reason.value) == 'tzname'
-
-
-    with raises(ValueError) as reason:
-        parse_time(parse_time)  # type: ignore
-
-    assert str(reason.value) == 'source'
+    _parsed = parse_time(parsed)
+    assert _parsed == parsed
 
 
 
@@ -145,10 +126,11 @@ def test_shift_time(
     """
 
     anchor = utcdatetime(1980, 1, 1)
+    dtime = utcdatetime(*expect)
 
     parsed = shift_time(notate, anchor)
 
-    assert parsed == utcdatetime(*expect)
+    assert parsed == dtime
 
 
 
@@ -162,26 +144,32 @@ def test_string_time() -> None:
 
     strings = [
         '1980-01-01T00:00:00Z',
+        '1980-01-01T00:00:00 +0000',
         '1980-01-01T00:00:00',
         '1980-01-01 00:00:00 +0000',
         '1980-01-01 00:00:00']
 
     for string in strings:
-        assert string_time(string) == expect
+
+        parsed = string_time(string)
+
+        assert parsed == expect
 
 
     parsed = string_time(
         '1980_01_01',
-        formats=['%Y', '%Y_%m_%d'])
+        formats=['%Y_%m_%d'])
 
     assert parsed == expect
 
+
     parsed = string_time(
         '1980_01_01',
         formats='%Y_%m_%d')
 
     assert parsed == expect
 
+
     parsed = string_time(
         '1979-12-31 18:00:00',
         tzname='US/Central')
@@ -196,13 +184,15 @@ def test_since_time() -> None:
     """
 
 
-    dtime = shift_time('-1s')
+    parsed = shift_time('-1s')
+    since = since_time(parsed)
 
-    assert since_time(dtime) >= 1
-    assert since_time(dtime) < 2
+    assert since >= 1
+    assert since < 2
 
 
-    dtime = shift_time('+1s')
+    parsed = shift_time('+1s')
+    since = since_time(parsed)
 
-    assert since_time(dtime) > 0
-    assert since_time(dtime) < 2
+    assert since > 0
+    assert since < 2

encommon/times/test/test_timers.py

@@ -10,110 +10,164 @@ is permitted, for more information consult the project license file.
 from pathlib import Path
 from time import sleep
 
+from pytest import fixture
 from pytest import raises
 
 from ..timers import Timers
 
 
 
-def test_Timers() -> None:
+@fixture
+def timers(
+    tmp_path: Path,
+) -> Timers:
+    """
+    Construct the instance for use in the downstream tests.
+
+    :param tmp_path: pytest object for temporal filesystem.
+    :returns: Newly constructed instance of related class.
+    """
+
+    return Timers(
+        timers={'one': 1},
+        file=f'{tmp_path}/cache.db')
+
+
+
+def test_Timers(
+    timers: Timers,
+) -> None:
     """
     Perform various tests associated with relevant routines.
+
+    :param timers: Primary class instance for timers object.
     """
 
-    timers = Timers({'one': 1})
 
     attrs = list(timers.__dict__)
 
     assert attrs == [
-        '_Timers__timers',
-        '_Timers__cache_file',
-        '_Timers__cache_name',
-        '_Timers__cache_dict']
+        '_Timers__config',
+        '_Timers__sqlite',
+        '_Timers__file',
+        '_Timers__table',
+        '_Timers__cache']
+
+
+    assert repr(timers)[:22] == (
+        '<encommon.times.timers')
 
+    assert hash(timers) > 0
 
-    assert repr(timers).startswith(
-        '<encommon.times.timers.Timers')
-    assert isinstance(hash(timers), int)
-    assert str(timers).startswith(
-        '<encommon.times.timers.Timers')
+    assert str(timers)[:22] == (
+        '<encommon.times.timers')
 
 
     assert timers.timers == {'one': 1}
-    assert timers.cache_file is not None
-    assert len(timers.cache_dict) == 1
-    assert timers.cache_name is not None
+
+    assert timers.sqlite is not None
+
+    assert timers.file[-8:] == 'cache.db'
+
+    assert timers.table == 'timers'
+
+    assert list(timers.cache) == ['one']
+
+
+
+def test_Timers_cover(
+    timers: Timers,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param timers: Primary class instance for timers object.
+    """
 
 
     assert not timers.ready('one')
+
     sleep(1.1)
+
     assert timers.ready('one')
 
 
     timers.create('two', 2, 0)
 
     assert timers.ready('two')
+
     assert not timers.ready('two')
 
 
 
 def test_Timers_cache(
-    tmp_path: Path,
+    timers: Timers,
 ) -> None:
     """
     Perform various tests associated with relevant routines.
 
-    :param tmp_path: pytest object for temporal filesystem.
+    :param timers: Primary class instance for timers object.
     """
 
-    cache_file = (
-        f'{tmp_path}/timers.db')
-
     timers1 = Timers(
-        timers={'one': 1},
-        cache_file=cache_file)
+        timers={'uno': 1},
+        file=timers.file)
 
-    assert not timers1.ready('one')
+    assert not timers1.ready('uno')
 
     sleep(0.75)
 
     timers2 = Timers(
-        timers={'one': 1},
-        cache_file=cache_file)
+        timers={'uno': 1},
+        file=timers.file)
 
-    assert not timers1.ready('one')
-    assert not timers2.ready('one')
+    assert not timers1.ready('uno')
+    assert not timers2.ready('uno')
 
     sleep(0.25)
 
     timers2.load_cache()
 
-    assert timers1.ready('one')
-    assert timers2.ready('one')
+    assert timers1.ready('uno')
+    assert timers2.ready('uno')
 
 
 
-def test_Timers_raises() -> None:
+def test_Timers_raises(
+    timers: Timers,
+) -> None:
     """
     Perform various tests associated with relevant routines.
+
+    :param timers: Primary class instance for timers object.
     """
 
-    timers = Timers({'one': 1})
 
+    _raises = raises(ValueError)
 
-    with raises(ValueError) as reason:
+    with _raises as reason:
         timers.ready('dne')
 
-    assert str(reason.value) == 'unique'
+    _reason = str(reason.value)
 
+    assert _reason == 'unique'
 
-    with raises(ValueError) as reason:
+
+    _raises = raises(ValueError)
+
+    with _raises as reason:
         timers.update('dne')
 
-    assert str(reason.value) == 'unique'
+    _reason = str(reason.value)
+
+    assert _reason == 'unique'
 
 
-    with raises(ValueError) as reason:
+    _raises = raises(ValueError)
+
+    with _raises as reason:
         timers.create('one', 1)
 
-    assert str(reason.value) == 'unique'
+    _reason = str(reason.value)
+
+    assert _reason == 'unique'

encommon/times/test/test_times.py

@@ -7,8 +7,6 @@ is permitted, for more information consult the project license file.
 
 
 
-from pytest import raises
-
 from ..common import STAMP_SIMPLE
 from ..common import UNIXEPOCH
 from ..common import UNIXHPOCH
@@ -22,21 +20,25 @@ def test_Times() -> None:
     Perform various tests associated with relevant routines.
     """
 
-    times = Times(0, format=STAMP_SIMPLE)
+    times = Times(
+        UNIXEPOCH,
+        format=STAMP_SIMPLE)
+
 
     attrs = list(times.__dict__)
 
     assert attrs == [
-        '_Times__source']
+        '_Times__source',
+        '_Times__hashed']
+
 
+    assert repr(times)[:23] == (
+        "Times('1970-01-01T00:00")
 
-    assert repr(times) == (
-        "Times('1970-01-01T"
-        "00:00:00.000000+0000')")
-    assert isinstance(hash(times), int)
-    assert str(times) == (
-        '1970-01-01T00:00:00'
-        '.000000+0000')
+    assert hash(times) > 0
+
+    assert str(times)[:23] == (
+        '1970-01-01T00:00:00.000')
 
 
     assert int(times) == 0
@@ -58,37 +60,26 @@ def test_Times() -> None:
     assert times.source.year == 1970
 
     assert times.epoch == 0.0
+
     assert times.mpoch == 0.0
+
     assert times.simple == UNIXEPOCH
+
     assert times.subsec == UNIXMPOCH
+
     assert times.human == UNIXHPOCH
+
     assert times.elapsed >= 1672531200
+
     assert times.since >= 1672531200
 
     assert times.before == (
         '1969-12-31T23:59:59.999999Z')
+
     assert times.after == (
         '1970-01-01T00:00:00.000001Z')
 
-    stamp = times.stamp(
-        tzname='US/Central')
-
-    assert stamp[:4] == '1969'
-    assert stamp[11:][:2] == '18'
-
+    assert times.stamp() == UNIXMPOCH
 
     times = times.shift('+1y')
-
     assert times == '1971-01-01'
-
-
-
-def test_Times_raises() -> None:
-    """
-    Perform various tests associated with relevant routines.
-    """
-
-    with raises(ValueError) as reason:
-        Times(0).stamp(tzname='foo')
-
-    assert str(reason.value) == 'tzname'

encommon/times/test/test_window.py

@@ -7,21 +7,43 @@ is permitted, for more information consult the project license file.
 
 
 
+from typing import TYPE_CHECKING
+
+from pytest import fixture
 from pytest import mark
 
-from ..common import PARSABLE
 from ..window import Window
 from ..window import window_croniter
 from ..window import window_interval
 
+if TYPE_CHECKING:
+    from ..common import PARSABLE
+
+
+
+@fixture
+def window() -> Window:
+    """
+    Construct the instance for use in the downstream tests.
+
+    :returns: Newly constructed instance of related class.
+    """
+
+    return Window(
+        schedule='* * * * *',
+        start=330, stop=630)
 
 
-def test_Window() -> None:
+
+def test_Window(
+    window: Window,
+) -> None:
     """
     Perform various tests associated with relevant routines.
+
+    :param window: Primary class instance for window object.
     """
 
-    window = Window('* * * * *', 330, 630)
 
     attrs = list(window.__dict__)
 
@@ -36,23 +58,52 @@ def test_Window() -> None:
         '_Window__walked']
 
 
-    assert repr(window).startswith(
-        '<encommon.times.window.Window')
-    assert isinstance(hash(window), int)
-    assert str(window).startswith(
-        '<encommon.times.window.Window')
+    assert repr(window)[:22] == (
+        '<encommon.times.window')
+
+    assert hash(window) > 0
+
+    assert str(window)[:22] == (
+        '<encommon.times.window')
 
 
     assert window.schedule == '* * * * *'
+
     assert window.start == '1970-01-01T00:05:30Z'
+
     assert window.stop == '1970-01-01T00:10:30Z'
+
     assert window.anchor == window.start
+
     assert window.delay == 0.0
+
     assert window.last == '1970-01-01T00:05:00Z'
+
     assert window.next == '1970-01-01T00:06:00Z'
+
     assert window.walked is False
 
 
+
+def test_Window_cover(
+    window: Window,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param window: Primary class instance for window object.
+    """
+
+
+    window = Window(
+        schedule='* * * * *',
+        start=window.start,
+        stop=window.stop)
+
+    assert window.last == '1970-01-01T00:05:00Z'
+    assert window.next == '1970-01-01T00:06:00Z'
+    assert window.walked is False
+
     for count in range(100):
         if window.walk() is False:
             break
@@ -66,15 +117,13 @@ def test_Window() -> None:
     assert window.walked is True
 
 
-    window = Window({'minutes': 1}, 300, 600)
+    window = Window(
+        schedule={'minutes': 1},
+        start=window.start,
+        stop=window.stop)
 
-    assert window.schedule == {'minutes': 1}
-    assert window.start == '1970-01-01T00:05:00Z'
-    assert window.stop == '1970-01-01T00:10:00Z'
-    assert window.anchor == window.start
-    assert window.delay == 0.0
-    assert window.last == '1970-01-01T00:04:00Z'
-    assert window.next == '1970-01-01T00:05:00Z'
+    assert window.last == '1970-01-01T00:04:30Z'
+    assert window.next == '1970-01-01T00:05:30Z'
     assert window.walked is False
 
     for count in range(100):
@@ -85,12 +134,15 @@ def test_Window() -> None:
     assert count == 5
     assert not window.walk()
 
-    assert window.last == '1970-01-01T00:10:00Z'
-    assert window.next == '1970-01-01T00:10:00Z'
+    assert window.last == '1970-01-01T00:10:30Z'
+    assert window.next == '1970-01-01T00:10:30Z'
     assert window.walked is True
 
 
-    window = Window('* * * * *', '+5m', '+10m')
+    window = Window(
+        schedule='* * * * *',
+        start='+5m', stop='+10m')
+
     assert not window.walk(False)
 
 
@@ -110,7 +162,7 @@ def test_Window() -> None:
      ('0 * * * *', 3661, False, (3600, 7200))])
 def test_window_croniter(
     schedule: str,
-    anchor: PARSABLE,
+    anchor: 'PARSABLE',
     backward: bool,
     expect: tuple[int, int],
 ) -> None:
@@ -146,7 +198,7 @@ def test_window_croniter(
      ({'hours': 1}, 3661, False, (3661, 7261))])
 def test_window_interval(
     schedule: dict[str, int],
-    anchor: PARSABLE,
+    anchor: 'PARSABLE',
     backward: bool,
     expect: tuple[int, int],
 ) -> None: