from calendar import timegm from datetime import datetime, timedelta, date, tzinfo as TZInfo from typing import Callable, Self, Tuple, TypeVar, Generic, Mapping T = TypeVar('T', bound=datetime | date) class Queue(list[T]): delta: float delta_delta: float delta_type: str def __init__(self, delta: float | None, delta_delta: float, delta_type: str) -> None: super().__init__() if delta is None: self.delta = 0 self.delta_delta = delta_delta else: self.delta = delta self.delta_delta = 0 self.delta_type = delta_type def advance_next(self, delta: timedelta) -> None: self[-1] += delta # type: ignore[assignment] def next(self) -> T: instance = self.pop(0) if not self: self.delta += self.delta_delta n = instance + timedelta(**{self.delta_type: self.delta}) self.append(n) # type: ignore[arg-type] return instance class MockedCurrent(Generic[T]): _mock_queue: Queue[T] _mock_base_class: type _mock_class: type _mock_tzinfo: TZInfo | None _mock_date_type: type[date] _correct_mock_type: Callable[[T], Self] | None = None def __init_subclass__( cls, concrete: bool = False, queue: Queue[T] | None = None, strict: bool | None = None, tzinfo: TZInfo | None = None, date_type: type[date] = date, ) -> None: if concrete: assert not queue is None, 'queue must be passed if concrete=True' cls._mock_queue = queue cls._mock_base_class = cls.__bases__[0].__bases__[1] cls._mock_class = cls if strict else cls._mock_base_class cls._mock_tzinfo = tzinfo cls._mock_date_type = date_type @classmethod def add(cls, *args: int | T, **kw: int | TZInfo | None) -> None: if 'tzinfo' in kw or len(args) > 7: raise TypeError('Cannot add using tzinfo on %s' % cls.__name__) if args and isinstance(args[0], cls._mock_base_class): instance = args[0] instance_tzinfo = getattr(instance, 'tzinfo', None) if instance_tzinfo: if instance_tzinfo != cls._mock_tzinfo: raise ValueError( 'Cannot add %s with tzinfo of %s as configured to use %s' % ( instance.__class__.__name__, instance_tzinfo, cls._mock_tzinfo )) instance = instance.replace(tzinfo=None) # type: ignore[attr-defined] if cls._correct_mock_type: instance = cls._correct_mock_type(instance) else: instance = cls(*args, **kw) # type: ignore[arg-type] cls._mock_queue.append(instance) @classmethod def set(cls, *args: int | T, **kw: int | TZInfo | None) -> None: cls._mock_queue.clear() cls.add(*args, **kw) @classmethod def tick(cls, *args: timedelta, **kw: float) -> None: if kw: delta = timedelta(**kw) else: delta, = args cls._mock_queue.advance_next(delta) def __add__(self, other: timedelta) -> Self: instance = super().__add__(other) # type: ignore[misc] if self._correct_mock_type: instance = self._correct_mock_type(instance) return instance def __new__(cls, *args: int, **kw: int | TZInfo | None) -> Self: if cls is cls._mock_class: return super().__new__(cls, *args, **kw) else: return cls._mock_class(*args, **kw) def mock_factory( type_name: str, mock_class: type[MockedCurrent[T]], default: Tuple[int, ...], args: tuple[int | T | None | TZInfo, ...], kw: Mapping[str, int | TZInfo | None], delta: float | None, delta_type: str, delta_delta: float = 1, date_type: type[date] | None = None, tzinfo: TZInfo | None = None, strict: bool = False ) -> type[MockedCurrent[T]]: cls = type( type_name, (mock_class,), {}, concrete=True, queue=Queue(delta, delta_delta, delta_type), strict=strict, tzinfo=tzinfo, date_type=date_type, ) if args != (None,): if not (args or kw): args = default cls.add(*args, **kw) # type: ignore[attr-defined] return cls class MockDateTime(MockedCurrent[datetime], datetime): @classmethod def add(cls, *args: int | datetime, **kw: int | TZInfo | None) -> None: """ This will add the :class:`datetime.datetime` created from the supplied parameters to the queue of datetimes to be returned by :meth:`~MockDateTime.now` or :meth:`~MockDateTime.utcnow`. An instance of :class:`~datetime.datetime` may also be passed as a single positional argument. """ return super().add(*args, **kw) @classmethod def set(cls, *args: int | datetime, **kw: int | TZInfo | None) -> None: """ This will set the :class:`datetime.datetime` created from the supplied parameters as the next datetime to be returned by :meth:`~MockDateTime.now` or :meth:`~MockDateTime.utcnow`, clearing out any datetimes in the queue. An instance of :class:`~datetime.datetime` may also be passed as a single positional argument. """ return super().set(*args, **kw) @classmethod def tick(cls, *args: timedelta, **kw: float) -> None: """ This method should be called either with a :class:`~datetime.timedelta` as a positional argument, or with keyword parameters that will be used to construct a :class:`~datetime.timedelta`. The :class:`~datetime.timedelta` will be used to advance the next datetime to be returned by :meth:`~MockDateTime.now` or :meth:`~MockDateTime.utcnow`. """ return super().tick(*args, **kw) @classmethod def _correct_mock_type(cls, instance: datetime) -> Self: return cls._mock_class( instance.year, instance.month, instance.day, instance.hour, instance.minute, instance.second, instance.microsecond, instance.tzinfo, ) @classmethod def _adjust_instance_using_tzinfo(cls, instance: datetime) -> Self: if cls._mock_tzinfo: offset = cls._mock_tzinfo.utcoffset(instance) if offset is None: raise TypeError('tzinfo with .utcoffset() returning None is not supported') instance = instance - offset return instance # type: ignore[return-value] @classmethod def now(cls, tz: TZInfo | None = None) -> Self: """ :param tz: An optional timezone to apply to the returned time. If supplied, it must be an instance of a :class:`~datetime.tzinfo` subclass. This will return the next supplied or calculated datetime from the internal queue, rather than the actual current datetime. If `tz` is supplied, see :ref:`timezones`. """ instance = cls._mock_queue.next() if tz is not None: instance = tz.fromutc(cls._adjust_instance_using_tzinfo(instance).replace(tzinfo=tz)) return cls._correct_mock_type(instance) @classmethod def utcnow(cls) -> Self: """ This will return the next supplied or calculated datetime from the internal queue, rather than the actual current UTC datetime. If you care about timezones, see :ref:`timezones`. """ instance = cls._mock_queue.next() return cls._adjust_instance_using_tzinfo(instance) def date(self) -> date: """ This will return the date component of the current mock instance, but using the date type supplied when the mock class was created. """ return self._mock_date_type( self.year, self.month, self.day ) def mock_datetime( *args: int | datetime | None | TZInfo, tzinfo: TZInfo | None = None, delta: float | None = None, delta_type: str = 'seconds', date_type: type[date] = date, strict: bool = False, **kw: int | TZInfo | None, ) -> type[MockDateTime]: """ .. currentmodule:: testfixtures.datetime A function that returns a mock object that can be used in place of the :class:`datetime.datetime` class but where the return value of :meth:`~MockDateTime.now` can be controlled. If a single positional argument of ``None`` is passed, then the queue of datetimes to be returned will be empty and you will need to call :meth:`~MockDateTime.set` or :meth:`~MockDateTime.add` before calling :meth:`~MockDateTime.now` or :meth:`~MockDateTime.utcnow`. If an instance of :class:`~datetime.datetime` is passed as a single positional argument, that will be used as the first date returned by :meth:`~MockDateTime.now` :param year: An optional year used to create the first datetime returned by :meth:`~MockDateTime.now`. :param month: An optional month used to create the first datetime returned by :meth:`~MockDateTime.now`. :param day: An optional day used to create the first datetime returned by :meth:`~MockDateTime.now`. :param hour: An optional hour used to create the first datetime returned by :meth:`~MockDateTime.now`. :param minute: An optional minute used to create the first datetime returned by :meth:`~MockDateTime.now`. :param second: An optional second used to create the first datetime returned by :meth:`~MockDateTime.now`. :param microsecond: An optional microsecond used to create the first datetime returned by :meth:`~MockDateTime.now`. :param tzinfo: An optional :class:`datetime.tzinfo`, see :ref:`timezones`. :param delta: The size of the delta to use between values returned from mocked class methods. If not specified, it will increase by 1 with each call to :meth:`~MockDateTime.now`. :param delta_type: The type of the delta to use between values returned from mocked class methods. This can be any keyword parameter accepted by the :class:`~datetime.timedelta` constructor. :param date_type: The type to use for the return value of the mocked class methods. This can help with gotchas that occur when type checking is performed on values returned by the :meth:`~testfixtures.datetime.MockDateTime.date` method. :param strict: If ``True``, calling the mock class and any of its methods will result in an instance of the mock being returned. If ``False``, the default, an instance of :class:`~datetime.datetime` will be returned instead. The mock returned will behave exactly as the :class:`datetime.datetime` class as well as being a subclass of :class:`~testfixtures.datetime.MockDateTime`. """ if len(args) > 7: tzinfo = args[7] # type: ignore[assignment] args = args[:7] else: tzinfo = tzinfo or (getattr(args[0], 'tzinfo', None) if args else None) return mock_factory( 'MockDateTime', MockDateTime, (2001, 1, 1, 0, 0, 0), args, kw, tzinfo=tzinfo, delta=delta, delta_delta=10, delta_type=delta_type, date_type=date_type, strict=strict, ) # type: ignore[return-value] class MockDate(MockedCurrent[date], date): @classmethod def _correct_mock_type(cls, instance: date) -> Self: return cls._mock_class( instance.year, instance.month, instance.day, ) @classmethod def add(cls, *args: int | date, **kw: int | TZInfo | None) -> None: """ This will add the :class:`datetime.date` created from the supplied parameters to the queue of dates to be returned by :meth:`~MockDate.today`. An instance of :class:`~datetime.date` may also be passed as a single positional argument. """ return super().add(*args, **kw) @classmethod def set(cls, *args: int | date, **kw: int | TZInfo | None) -> None: """ This will set the :class:`datetime.date` created from the supplied parameters as the next date to be returned by :meth:`~MockDate.today`, regardless of any dates in the queue. An instance of :class:`~datetime.date` may also be passed as a single positional argument. """ return super().set(*args, **kw) @classmethod def tick(cls, *args: timedelta, **kw: float) -> None: """ This method should be called either with a :class:`~datetime.timedelta` as a positional argument, or with keyword parameters that will be used to construct a :class:`~datetime.timedelta`. The :class:`~datetime.timedelta` will be used to advance the next date to be returned by :meth:`~MockDate.today`. """ return super().tick(*args, **kw) @classmethod def today(cls) -> Self: """ This will return the next supplied or calculated date from the internal queue, rather than the actual current date. """ return cls._mock_queue.next() # type: ignore[return-value] def mock_date( *args: int | date | None, delta: float | None = None, delta_type: str = 'days', strict: bool = False, **kw: int ) -> type[MockDate]: """ .. currentmodule:: testfixtures.datetime A function that returns a mock object that can be used in place of the :class:`datetime.date` class but where the return value of :meth:`~datetime.date.today` can be controlled. If a single positional argument of ``None`` is passed, then the queue of dates to be returned will be empty and you will need to call :meth:`~MockDate.set` or :meth:`~MockDate.add` before calling :meth:`~MockDate.today`. If an instance of :class:`~datetime.date` is passed as a single positional argument, that will be used as the first date returned by :meth:`~datetime.date.today` :param year: An optional year used to create the first date returned by :meth:`~datetime.date.today`. :param month: An optional month used to create the first date returned by :meth:`~datetime.date.today`. :param day: An optional day used to create the first date returned by :meth:`~datetime.date.today`. :param delta: The size of the delta to use between values returned from :meth:`~datetime.date.today`. If not specified, it will increase by 1 with each call to :meth:`~datetime.date.today`. :param delta_type: The type of the delta to use between values returned from :meth:`~datetime.date.today`. This can be any keyword parameter accepted by the :class:`~datetime.timedelta` constructor. :param strict: If ``True``, calling the mock class and any of its methods will result in an instance of the mock being returned. If ``False``, the default, an instance of :class:`~datetime.date` will be returned instead. The mock returned will behave exactly as the :class:`datetime.date` class as well as being a subclass of :class:`~testfixtures.datetime.MockDate`. """ return mock_factory( 'MockDate', MockDate, (2001, 1, 1), args, kw, delta=delta, delta_type=delta_type, strict=strict, ) # type: ignore[return-value] ms = 10**6 class MockTimeFactory(MockedCurrent[datetime], datetime): pass class MockTime: def __init__(self, factory: type[MockedCurrent[datetime]]): self.factory = factory def add(self, *args: int | datetime, **kw: int | TZInfo | None) -> None: """ This will add the time specified by the supplied parameters to the queue of times to be returned by calls to the mock. The parameters are the same as the :class:`datetime.datetime` constructor. An instance of :class:`~datetime.datetime` may also be passed as a single positional argument. """ self.factory.add(*args, **kw) def set(self, *args: int | datetime, **kw: int | TZInfo | None) -> None: """ This will set the time specified by the supplied parameters as the next time to be returned by a call to the mock, regardless of any times in the queue. The parameters are the same as the :class:`datetime.datetime` constructor. An instance of :class:`~datetime.datetime` may also be passed as a single positional argument. """ self.factory.set(*args, **kw) def tick(self, *args: timedelta, **kw: float) -> None: """ This method should be called either with a :class:`~datetime.timedelta` as a positional argument, or with keyword parameters that will be used to construct a :class:`~datetime.timedelta`. The :class:`~datetime.timedelta` will be used to advance the next time to be returned by a call to the mock. """ self.factory.tick(*args, **kw) def __call__(self) -> float: instance = self.factory._mock_queue.next() time: float = timegm(instance.utctimetuple()) time += (float(instance.microsecond) / ms) return time def mock_time( *args: int | datetime | None, delta: float | None = None, delta_type: str = 'seconds', **kw: int, ) -> MockTime: """ .. currentmodule:: testfixtures.datetime A function that returns a :class:`mock object ` that can be used in place of the :func:`time.time` function but where the return value can be controlled. If a single positional argument of ``None`` is passed, then the queue of times to be returned will be empty and you will need to call :meth:`~MockTime.set` or :meth:`~MockTime.add` before calling the mock. If an instance of :class:`~datetime.datetime` is passed as a single positional argument, that will be used to create the first time returned. :param year: An optional year used to create the first time returned. :param month: An optional month used to create the first time. :param day: An optional day used to create the first time. :param hour: An optional hour used to create the first time. :param minute: An optional minute used to create the first time. :param second: An optional second used to create the first time. :param microsecond: An optional microsecond used to create the first time. :param delta: The size of the delta to use between values returned. If not specified, it will increase by 1 with each call to the mock. :param delta_type: The type of the delta to use between values returned. This can be any keyword parameter accepted by the :class:`~datetime.timedelta` constructor. The :meth:`~testfixtures.datetime.MockTime.add`, :meth:`~testfixtures.datetime.MockTime.set` and :meth:`~testfixtures.datetime.MockTime.tick` methods on the mock can be used to control the return values. """ if 'tzinfo' in kw or len(args) > 7 or (args and getattr(args[0], 'tzinfo', None)): raise TypeError("You don't want to use tzinfo with test_time") factory = mock_factory( 'MockTime', MockTimeFactory, (2001, 1, 1, 0, 0, 0), args, kw, delta=delta, delta_type=delta_type, ) return MockTime(factory)