From ef465b34e7f9cf9d78d4dd9aa25a14af5b7050a5 Mon Sep 17 00:00:00 2001 From: Ad5001 Date: Thu, 17 Oct 2024 02:08:24 +0200 Subject: [PATCH] Finishing natural language plugin. --- .../tests/plugins/natural/__init__.py | 1 + .../plugins/natural/interfaces/assertion.py | 15 +- .../tests/plugins/natural/interfaces/base.py | 122 +++++++--- .../tests/plugins/natural/interfaces/basic.py | 54 +++-- .../tests/plugins/natural/interfaces/int.py | 208 ++++++++++++----- .../tests/plugins/natural/interfaces/spy.py | 218 ++++++++++++++++++ runtime-pyside6/tests/plugins/natural/spy.py | 213 +---------------- runtime-pyside6/tests/plugins/natural/that.py | 23 +- .../tests/plugins/tests/__init__.py | 0 .../tests/plugins/tests/test_natural.py | 217 +++++++++++++++++ 10 files changed, 751 insertions(+), 320 deletions(-) create mode 100644 runtime-pyside6/tests/plugins/natural/interfaces/spy.py create mode 100644 runtime-pyside6/tests/plugins/tests/__init__.py create mode 100644 runtime-pyside6/tests/plugins/tests/test_natural.py diff --git a/runtime-pyside6/tests/plugins/natural/__init__.py b/runtime-pyside6/tests/plugins/natural/__init__.py index 7a67869..4cfe179 100644 --- a/runtime-pyside6/tests/plugins/natural/__init__.py +++ b/runtime-pyside6/tests/plugins/natural/__init__.py @@ -18,4 +18,5 @@ from .spy import Spy from .that import that +from .interfaces.base import Assertion diff --git a/runtime-pyside6/tests/plugins/natural/interfaces/assertion.py b/runtime-pyside6/tests/plugins/natural/interfaces/assertion.py index f2504a2..e1e43c4 100644 --- a/runtime-pyside6/tests/plugins/natural/interfaces/assertion.py +++ b/runtime-pyside6/tests/plugins/natural/interfaces/assertion.py @@ -17,14 +17,23 @@ """ class Assertion(Exception): - def __init__(self, assertion: bool, message: str): + def __init__(self, assertion: bool, message: str, invert: bool): self.assertion = assertion self.message = message + self.invert = invert + + def _invert_message(self): + for verb in ('is', 'was', 'has', 'have'): + for negative in ("n't", ' not', ' never', ' no'): + self.message = self.message.replace(f"{verb}{negative}", verb.upper()) def __str__(self): return self.message def __bool__(self): - if not self.assertion: + if not self.invert and not self.assertion: raise self - return self.assertion \ No newline at end of file + if self.invert and self.assertion: + self._invert_message() + raise self + return True # Raises otherwise. \ No newline at end of file diff --git a/runtime-pyside6/tests/plugins/natural/interfaces/base.py b/runtime-pyside6/tests/plugins/natural/interfaces/base.py index 88b9e06..0786285 100644 --- a/runtime-pyside6/tests/plugins/natural/interfaces/base.py +++ b/runtime-pyside6/tests/plugins/natural/interfaces/base.py @@ -15,10 +15,10 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . """ -from typing import Self +from typing import Self, Callable, Any -from tests.plugins.natural.interfaces.assertion import Assertion -from tests.plugins.natural.interfaces.utils import repr_ +from .assertion import Assertion +from .utils import repr_ class AssertionInterface: @@ -26,15 +26,91 @@ class AssertionInterface: Most basic assertion interface. You probably want to use BaseAssertionInterface """ - def __init__(self, value): + + def __init__(self, value, parent: Self = None): self._value = value + self._parent = parent + if parent is None: + self.__not = False @property - def was(self) -> Self: + def _not(self) -> bool: + """ + Internal state of whether the expression was negated. + Use "not_" to set it. + :return: + """ + return self.__not if self._parent is None else self._parent._not + + @_not.setter + def _not(self, value: bool): + if self._not is True: + raise RuntimeError("Cannot call is_not or was_not twice in the same statement.") + if self._parent is None: + self.__not = True + else: + self._parent._not = True + + def instance_of(self, type_: type) -> Assertion: + """ + Checks if the current value is equal to the provided value + """ + value_type_name = type(self._value).__name__ + if not isinstance(type_, type): + raise RuntimeError("Provided 'type' provided is not a class.") + return Assertion( + isinstance(self._value, type_), + f"The value ({value_type_name} {repr_(self._value)}) is not a {type_.__name__}.", + self._not + ) + + def __call__(self, condition: Callable[[Any], bool]) -> Assertion: + """ + Apply condition to value that returns whether or not the value is valid. + """ + return Assertion( + condition(self._value), + f"The value ({repr_(self._value)}) did not match given conditions.", + self._not + ) + + """ + NOT Properties. + """ + + @property + def NOT(self) -> Self: + self._not = True return self @property - def be(self) -> Self: + def not_(self) -> Self: + self._not = True + return self + + @property + def never(self) -> Self: + self._not = True + return self + + """ + Chain self properties to sound natural + """ + + @property + def that(self) -> Self: + return self + + @property + def is_(self) -> Self: + return self + + @property + def does(self) -> Self: + return self + + @property + def was(self) -> Self: return self @property @@ -57,31 +133,25 @@ class AssertionInterface: def an(self) -> Self: return self - def is_a(self, type_) -> Assertion: - """ - Checks if the current value is equal to the provided value - """ - value_type_name = type(self._value).__name__ - return Assertion(isinstance(type_, type_), f"The value ({value_type_name} {repr_(self._value)}) is not a {type_.__name__}.") - - class EqualAssertionInterface(AssertionInterface): """ Interface created for when its value should be checked for equality """ - def __init__(self, value): - super().__init__(value) + + def __init__(self, value, parent: AssertionInterface = None): + super().__init__(value, parent) def __call__(self, value) -> Assertion: - return Assertion(value == self._value, f"The value ({repr_(self._value)}) is not equal to {repr(value)}.") - - def to(self, value) -> Self: - return self(value) - - def of(self, value) -> Self: - return self(value) + return Assertion( + value == self._value, + f"The value {repr_(self._value)} is different from {repr(value)}.", + self._not + ) + @property + def to(self) -> Self: + return self class BaseAssertionInterface(AssertionInterface): @@ -91,11 +161,11 @@ class BaseAssertionInterface(AssertionInterface): """ Checks if the current value is equal to the provided value """ - return EqualAssertionInterface(self._value) + return EqualAssertionInterface(self._value, self) @property - def is_equal(self) -> EqualAssertionInterface: + def equal(self) -> EqualAssertionInterface: """ Checks if the current value is equal to the provided value """ - return self.equals \ No newline at end of file + return self.equals diff --git a/runtime-pyside6/tests/plugins/natural/interfaces/basic.py b/runtime-pyside6/tests/plugins/natural/interfaces/basic.py index 1d5a878..25d45cb 100644 --- a/runtime-pyside6/tests/plugins/natural/interfaces/basic.py +++ b/runtime-pyside6/tests/plugins/natural/interfaces/basic.py @@ -15,47 +15,69 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . """ -from tests.plugins.natural.interfaces.assertion import Assertion -from tests.plugins.natural.interfaces.base import BaseAssertionInterface -from tests.plugins.natural.interfaces.int import IntInterface -from tests.plugins.natural.interfaces.utils import repr_ +from .assertion import Assertion +from .base import BaseAssertionInterface +from .int import NumberInterface +from .utils import repr_ class FixedIteratorInterface(BaseAssertionInterface): @property - def length(self) -> IntInterface: - return IntInterface(len(self._value)) + def length(self) -> NumberInterface: + return NumberInterface(len(self._value), self) def elements(self, *elements) -> Assertion: - tests = [elem for elem in elements if elem in self._value] + tests = [repr_(elem) for elem in elements if elem not in self._value] return Assertion( len(tests) == 0, - f"This value ({repr_(self._value)}) does not have elements ({repr_(tests)})" + f"This value ({repr_(self._value)}) does not have elements {', '.join(tests)}.", + self._not ) def element(self, element) -> Assertion: return Assertion( element in self._value, - f"This value ({repr_(self._value)}) does not have element ({repr_(element)})" + f"This value ({repr_(self._value)}) does not have element {repr_(element)}.", + self._not ) def contains(self, *elements) -> Assertion: - return self.elements(*elements) + """ + Check if the element(s) are contained in the iterator. + """ + if len(elements) == 1: + return self.element(elements[0]) + else: + return self.elements(*elements) + + def contain(self, *elements): + """ + Check if the element(s) are contained in the iterator. + """ + return self.contains(*elements) + class BoolInterface(BaseAssertionInterface): @property - def is_true(self): + def true(self): return Assertion( self._value == True, - f"The value ({repr_(self._value)}) is not True." + f"The value ({repr_(self._value)}) is not True.", + self._not ) @property - def is_false(self): + def false(self): return Assertion( self._value == False, - f"The value ({repr_(self._value)}) is not False." + f"The value ({repr_(self._value)}) is not False.", + self._not ) -class StringInterface(LengthInterface): - pass \ No newline at end of file + +class StringInterface(FixedIteratorInterface): + pass + + +class ListInterface(FixedIteratorInterface): + pass diff --git a/runtime-pyside6/tests/plugins/natural/interfaces/int.py b/runtime-pyside6/tests/plugins/natural/interfaces/int.py index aaf0511..7ac8871 100644 --- a/runtime-pyside6/tests/plugins/natural/interfaces/int.py +++ b/runtime-pyside6/tests/plugins/natural/interfaces/int.py @@ -15,17 +15,47 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . """ +from idlelib.configdialog import is_int +from math import log10, floor, ceil from typing import Self -from tests.plugins.natural.interfaces.assertion import Assertion -from tests.plugins.natural.interfaces.base import BaseAssertionInterface, EqualAssertionInterface, AssertionInterface -from tests.plugins.natural.interfaces.utils import repr_ +from .assertion import Assertion +from .base import AssertionInterface +from .utils import repr_ -class IntComparisonAssertionInterface(AssertionInterface): - def __init__(self, value): - super().__init__(value) - self._compare_to = None +class NumberComparisonAssertionInterface(AssertionInterface): + def __init__(self, value, parent: AssertionInterface = None): + super().__init__(value, parent) + self._compare_stack = [] + + def _generate_compare_to(self) -> int: + """ + The number generated by the comparison stack. + E.g. can parse one.hundred.million.and.thirty.three.thousand.and.twelve.hundred.and.seven + as ['one', 'hundred', 'million', 'thirty', 'three', 'thousand', 'twelve', 'hundred', 'seven'] + which results 100,034,207 + """ + minus = len(self._compare_stack) > 0 and self._compare_stack[0] == -1 + if len(self._compare_stack) < (2 if minus else 1): + raise RuntimeError("No number to compare the value to provided.") + if minus: + self._compare_stack.pop(0) + # Compute the number + add_stack = [self._compare_stack.pop(0)] + for element in self._compare_stack: + last_power = floor(log10(abs(add_stack[-1]))) + current_power = floor(log10(abs(element))) + if last_power < current_power: # E.g. one hundred + add_stack[-1] *= element + elif last_power == 1 and current_power == 0: # E.g thirty four + add_stack[-1] += element + elif last_power > current_power: # E.g a hundred and five + add_stack.append(element) + else: + raise RuntimeError(f"Cannot chain two numbers with the same power ({add_stack[-1]} => {element}.") + total = sum(add_stack) + return -total if minus else total def _compare(self) -> Assertion: raise RuntimeError(f"No comparison method defined in {type(self).__name__}.") @@ -34,23 +64,26 @@ class IntComparisonAssertionInterface(AssertionInterface): return bool(self._compare()) def __call__(self, compare_to: int) -> Self: - if self._compare_to is None: - self._compare_to = int(compare_to) - else: - self._compare_to *= int(compare_to) + if type(compare_to) not in (float, int): + raise RuntimeError(f"Cannot compare number ({self._value}) to non number ({repr_(compare_to)}).") + self._compare_stack.append(compare_to) + return self + + """ + Chain self properties + """ + + @property + def and_(self) -> Self: return self @property - def time(self) -> Self: + def AND(self) -> Self: return self - @property - def times(self) -> Self: - return self - - @property - def never(self) -> Self: - return self(0) + """ + Number shorthands + """ @property def once(self) -> Self: @@ -64,6 +97,10 @@ class IntComparisonAssertionInterface(AssertionInterface): def thrice(self) -> Self: return self(3) + @property + def minus(self) -> Self: + return self(-1) + @property def zero(self) -> Self: return self(0) @@ -108,6 +145,42 @@ class IntComparisonAssertionInterface(AssertionInterface): def ten(self) -> Self: return self(10) + @property + def eleven(self) -> Self: + return self(11) + + @property + def twelve(self) -> Self: + return self(12) + + @property + def thirteen(self) -> Self: + return self(13) + + @property + def fourteen(self) -> Self: + return self(14) + + @property + def fifteen(self) -> Self: + return self(15) + + @property + def sixteen(self) -> Self: + return self(16) + + @property + def seventeen(self) -> Self: + return self(17) + + @property + def eighteen(self) -> Self: + return self(18) + + @property + def nineteen(self) -> Self: + return self(19) + @property def twenty(self) -> Self: return self(20) @@ -134,11 +207,11 @@ class IntComparisonAssertionInterface(AssertionInterface): @property def eighty(self) -> Self: - return self(70) + return self(80) @property def ninety(self) -> Self: - return self(70) + return self(90) @property def hundred(self) -> Self: @@ -157,73 +230,92 @@ class IntComparisonAssertionInterface(AssertionInterface): return self(1_000_000_000) -class LessThanComparisonInterface(IntComparisonAssertionInterface): +class LessThanComparisonInterface(NumberComparisonAssertionInterface): def _compare(self) -> Assertion: + compare = self._generate_compare_to() return Assertion( - self._value < self._compare_to, - f"The value ({repr_(self._value)}) is not less than to {repr_(self._compare_to)}." + self._value < compare, + f"The value ({repr_(self._value)}) is not less than to {repr_(compare)}.", + self._not ) -class MoreThanComparisonInterface(IntComparisonAssertionInterface): + +class MoreThanComparisonInterface(NumberComparisonAssertionInterface): def _compare(self) -> Assertion: + compare = self._generate_compare_to() return Assertion( - self._value > self._compare_to, - f"The value ({repr_(self._value)}) is not more than to {repr_(self._compare_to)}." + self._value > compare, + f"The value ({repr_(self._value)}) is not more than to {repr_(compare)}.", + self._not ) -class AtLeastComparisonInterface(IntComparisonAssertionInterface): + +class AtLeastComparisonInterface(NumberComparisonAssertionInterface): def _compare(self) -> Assertion: + compare = self._generate_compare_to() return Assertion( - self._value >= self._compare_to, - f"The value ({repr_(self._value)}) is not at least to {repr_(self._compare_to)}." + self._value >= compare, + f"The value ({repr_(self._value)}) is not at least to {repr_(compare)}.", + self._not ) -class AtMostComparisonInterface(IntComparisonAssertionInterface): + +class AtMostComparisonInterface(NumberComparisonAssertionInterface): def _compare(self) -> Assertion: + compare = self._generate_compare_to() return Assertion( - self._value <= self._compare_to, - f"The value ({repr_(self._value)}) is not at least to {repr_(self._compare_to)}." + self._value <= compare, + f"The value ({repr_(self._value)}) is not at least to {repr_(compare)}.", + self._not ) -class EqualComparisonInterface(IntComparisonAssertionInterface): + +class EqualComparisonInterface(NumberComparisonAssertionInterface): def _compare(self) -> Assertion: + compare = self._generate_compare_to() return Assertion( - self._value == self._compare_to, - f"The value ({repr_(self._value)}) is not equal to {repr_(self._compare_to)}." + self._value == compare, + f"The value ({repr_(self._value)}) is not equal to {repr_(compare)}.", + self._not ) + @property def to(self) -> Self: return self - def of(self) -> Self: - return self - -class IntInterface(AssertionInterface): - def less_than(self) -> LessThanComparisonInterface: - return LessThanComparisonInterface(self._value) - - @property - def more_than(self) -> MoreThanComparisonInterface: - return MoreThanComparisonInterface(self._value) - - @property - def at_least(self) -> AtLeastComparisonInterface: - return AtLeastComparisonInterface(self._value) - - @property - def at_most(self) -> AtMostComparisonInterface: - return AtMostComparisonInterface(self._value) +class NumberInterface(AssertionInterface): + def __call__(self, value): + return EqualComparisonInterface(self._value, self)(value) @property def equals(self) -> EqualComparisonInterface: - return EqualComparisonInterface(self._value) + return EqualComparisonInterface(self._value, self) @property - def is_equal(self) -> EqualComparisonInterface: - return EqualComparisonInterface(self._value) + def equal(self) -> EqualComparisonInterface: + return EqualComparisonInterface(self._value, self) @property def exactly(self) -> EqualComparisonInterface: - return EqualComparisonInterface(self._value) + return EqualComparisonInterface(self._value, self) + @property + def of(self) -> EqualComparisonInterface: + return EqualComparisonInterface(self._value, self) + + @property + def less_than(self) -> LessThanComparisonInterface: + return LessThanComparisonInterface(self._value, self) + + @property + def more_than(self) -> MoreThanComparisonInterface: + return MoreThanComparisonInterface(self._value, self) + + @property + def at_least(self) -> AtLeastComparisonInterface: + return AtLeastComparisonInterface(self._value, self) + + @property + def at_most(self) -> AtMostComparisonInterface: + return AtMostComparisonInterface(self._value, self) diff --git a/runtime-pyside6/tests/plugins/natural/interfaces/spy.py b/runtime-pyside6/tests/plugins/natural/interfaces/spy.py new file mode 100644 index 0000000..59b09d3 --- /dev/null +++ b/runtime-pyside6/tests/plugins/natural/interfaces/spy.py @@ -0,0 +1,218 @@ +""" + * LogarithmPlotter - 2D plotter software to make BODE plots, sequences and distribution functions. + * Copyright (C) 2021-2024 Ad5001 + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . +""" + +from typing import Callable, Self + +from .base import Assertion, repr_, AssertionInterface +from .int import NumberComparisonAssertionInterface + +PRINT_PREFIX = (" " * 24) + + +class SpyAssertion(Assertion): + def __init__(self, assertion: bool, message: str, calls: list, invert: bool): + super().__init__(assertion, message + "\n", invert) + if len(calls) > 0: + self.message += self.render_calls(calls) + else: + self.message += f"{PRINT_PREFIX}0 registered calls." + + def render_calls(self, calls): + lines = [f"{PRINT_PREFIX}{len(calls)} registered call(s):"] + for call in calls: + repr_args = [repr_(arg) for arg in call[0]] + repr_kwargs = [f"{key}={repr_(arg)}" for key, arg in call[1].items()] + lines.append(f" - {', '.join([*repr_args, *repr_kwargs])}") + return ("\n" + PRINT_PREFIX).join(lines) + + +class Methods: + AT_LEAST_ONCE = "AT_LEAST_ONCE" + EXACTLY = "EXACTLY" + AT_LEAST = "AT_LEAST" + AT_MOST = "AT_MOST" + MORE_THAN = "MORE_THAN" + LESS_THAN = "LESS_THAN" + + +class CalledInterface(NumberComparisonAssertionInterface): + """ + Internal class generated by Spy.called. + """ + + def __init__(self, calls: list[tuple[list, dict]], parent: AssertionInterface): + super().__init__(len(calls), parent) + self.__calls = calls + self.__method = Methods.AT_LEAST_ONCE + + def __apply_method(self, calls): + required = None if self._compare_stack == [] else self._generate_compare_to() + calls_count = len(calls) + match self.__method: + case Methods.AT_LEAST_ONCE: + compare = len(calls) >= 1 + error = f"Method was not called" + case Methods.EXACTLY: + compare = len(calls) == required + error = f"Method was not called {required} times ({required} != {calls_count})" + case Methods.AT_LEAST: + compare = len(calls) >= required + error = f"Method was not called at least {required} times ({required} >= {calls_count})" + case Methods.AT_MOST: + compare = len(calls) <= required + error = f"Method was not called at most {required} times ({required} <= {calls_count})" + case Methods.MORE_THAN: + compare = len(calls) > required + error = f"Method was not called more than {required} times ({required} > {calls_count})" + case Methods.LESS_THAN: + compare = len(calls) < required + error = f"Method was not called less than {required} times ({required} < {calls_count})" + case _: + raise RuntimeError(f"Unknown method {self.__method}.") + return compare, error + + def __bool__(self) -> bool: + """ + Converts to boolean on assertion. + """ + compare, error = self.__apply_method(self.__calls) + return bool(SpyAssertion(compare, error + ".", self.__calls, self._not)) + + """ + Chaining methods + """ + + def __call__(self, compare_to: int) -> Self: + super().__call__(compare_to) + if self.__method == Methods.AT_LEAST_ONCE: + self.__method = Methods.EXACTLY + return self + + @property + def at_least(self) -> Self: + if self.__method == Methods.AT_LEAST_ONCE: + self.__method = Methods.AT_LEAST + else: + raise RuntimeError(f"Cannot redefine method from {self.__method} to {Methods.AT_MOST}") + return self + + @property + def at_most(self) -> Self: + if self.__method == Methods.AT_LEAST_ONCE: + self.__method = Methods.AT_MOST + else: + raise RuntimeError(f"Cannot redefine method from {self.__method} to {Methods.AT_MOST}") + return self + + @property + def more_than(self) -> Self: + if self.__method == Methods.AT_LEAST_ONCE: + self.__method = Methods.MORE_THAN + else: + raise RuntimeError(f"Cannot redefine method from {self.__method} to {Methods.MORE_THAN}") + return self + + @property + def less_than(self) -> Self: + if self.__method == Methods.AT_LEAST_ONCE: + self.__method = Methods.LESS_THAN + else: + raise RuntimeError(f"Cannot redefine method from {self.__method} to {Methods.LESS_THAN}") + return self + + @property + def time(self) -> Self: + return self + + @property + def times(self) -> Self: + return self + + """ + Class properties. + """ + + def __match_calls_for_condition(self, condition: Callable[[list, dict], bool]) -> tuple[bool, str]: + calls = [] + for call in self.__calls: + if condition(call[0], call[1]): + calls.append(call) + compare, error = self.__apply_method(calls) + return compare, error + + def with_arguments(self, *args, **kwargs) -> SpyAssertion: + """ + Checks if the Spy has been called the given number of times + with at least the given arguments. + """ + + def some_args_matched(a, kw): + args_matched = all(( + arg in a + for arg in args + )) + kwargs_matched = all(( + key in kw and kw[key] == arg + for key, arg in kwargs.items() + )) + return args_matched and kwargs_matched + + compare, error = self.__match_calls_for_condition(some_args_matched) + repr_args = ', '.join([repr(arg) for arg in args]) + repr_kwargs = ', '.join([f"{key}={repr(arg)}" for key, arg in kwargs.items()]) + msg = f"{error} with arguments ({repr_args}) and keyword arguments ({repr_kwargs})." + return SpyAssertion(compare, msg, self.__calls, self._not) + + def with_arguments_matching(self, test_condition: Callable[[list, dict], bool]) -> SpyAssertion: + """ + Checks if the Spy has been called the given number of times + with arguments matching the given conditions. + """ + compare, error = self.__match_calls_for_condition(test_condition) + msg = f"{error} with arguments matching given conditions." + return SpyAssertion(compare, msg, self.__calls, self._not) + + def with_exact_arguments(self, *args, **kwargs) -> SpyAssertion: + """ + Checks if the Spy has been called the given number of times + with all the given arguments. + """ + compare, error = self.__match_calls_for_condition(lambda a, kw: a == args and kw == kwargs) + repr_args = ', '.join([repr(arg) for arg in args]) + repr_kwargs = ', '.join([f"{key}={repr(arg)}" for key, arg in kwargs.items()]) + msg = f"{error} with exact arguments ({repr_args}) and keyword arguments ({repr_kwargs})." + return SpyAssertion(compare, msg, self.__calls, self._not) + + def with_no_argument(self) -> SpyAssertion: + """ + Checks if the Spy has been called the given number of times + with all the given arguments. + """ + compare, error = self.__match_calls_for_condition(lambda a, kw: len(a) == 0 and len(kw) == 0) + return SpyAssertion(compare, f"{error} with no arguments.", self.__calls, self._not) + + +class SpyAssertionInterface(AssertionInterface): + + @property + def called(self) -> CalledInterface: + """ + Returns a boolean-able interface to check conditions for a given number of + time the spy was called. + """ + return CalledInterface(self._value.calls, self) diff --git a/runtime-pyside6/tests/plugins/natural/spy.py b/runtime-pyside6/tests/plugins/natural/spy.py index 1d77629..fbd8e17 100644 --- a/runtime-pyside6/tests/plugins/natural/spy.py +++ b/runtime-pyside6/tests/plugins/natural/spy.py @@ -15,207 +15,15 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . """ -from typing import Callable, Self - -from tests.plugins.natural.interfaces.base import Assertion, repr_, AssertionInterface -from tests.plugins.natural.interfaces.int import IntComparisonAssertionInterface - -PRINT_PREFIX = (" " * 24) +from typing import Callable -class SpyAssertion(Assertion): - def __init__(self, assertion: bool, message: str, calls: list): - super().__init__(assertion, message + "\n") - if len(calls) > 0: - self.message += self.render_calls(calls) - else: - self.message += f"{PRINT_PREFIX}0 registered calls." - - - def render_calls(self, calls): - lines = [f"{PRINT_PREFIX}{len(calls)} registered call(s):"] - for call in calls: - repr_args = [repr_(arg) for arg in call[0]] - repr_kwargs = [f"{key}={repr_(arg)}" for key, arg in call[1].items()] - lines.append(f" - {', '.join([*repr_args, *repr_kwargs])}") - return ("\n" + PRINT_PREFIX).join(lines) - - -class Methods: - AT_LEAST_ONCE = "AT_LEAST_ONCE" - EXACTLY = "EXACTLY" - AT_LEAST = "AT_LEAST" - AT_MOST = "AT_MOST" - MORE_THAN = "AT_LEAST" - LESS_THAN = "AT_MOST" - - -class CalledInterface(IntComparisonAssertionInterface): - """ - Internal class generated by Spy.was_called. - """ - - def __init__(self, calls: list[tuple[list, dict]]): - super().__init__(len(calls)) - self.__calls = calls - self.__method = Methods.AT_LEAST_ONCE - - def __apply_method(self, calls): - required = self._compare_to - calls_count = len(calls) - match self.__method: - case Methods.AT_LEAST_ONCE: - compare = len(calls) >= 1 - error = "Method was not called" - case Methods.EXACTLY: - compare = len(calls) == required - error = f"Method was not called {required} times ({required} != {calls_count})" - case Methods.AT_LEAST: - compare = len(calls) >= required - error = f"Method was not called at least {required} times ({required} > {calls_count})" - case Methods.AT_MOST: - compare = len(calls) <= required - error = f"Method was not called at most {required} times ({required} < {calls_count})" - case Methods.MORE_THAN: - compare = len(calls) > required - error = f"Method was not called more than {required} times ({required} >= {calls_count})" - case Methods.LESS_THAN: - compare = len(calls) < required - error = f"Method was not called less than {required} times ({required} <= {calls_count})" - case _: - raise RuntimeError(f"Unknown method {self.__method}.") - return compare, error - - def __bool__(self) -> bool: - """ - Converts to boolean on assertion. - """ - compare, error = self.__apply_method(self.__calls) - return bool(SpyAssertion(compare, error + ".", self.__calls)) - - """ - Chaining methods - """ - - def __call__(self, *args, **kwargs) -> Self: - if len(args) != 1: - raise RuntimeError("Cannot call called interface with more than one argument.") - self._compare_to = int(args[0]) - if self.__method == Methods.AT_LEAST_ONCE: - self.__method = Methods.EXACTLY - return self - - @property - def at_least(self) -> Self: - if self.__method == Methods.AT_LEAST_ONCE: - self.__method = Methods.AT_LEAST - else: - raise RuntimeError(f"Cannot redefine method from {self.__method} to {Methods.AT_MOST}") - return self - - @property - def at_most(self) -> Self: - if self.__method == Methods.AT_LEAST_ONCE: - self.__method = Methods.AT_MOST - else: - raise RuntimeError(f"Cannot redefine method from {self.__method} to {Methods.AT_MOST}") - return self - - @property - def more_than(self) -> Self: - if self.__method == Methods.AT_LEAST_ONCE: - self.__method = Methods.MORE_THAN - else: - raise RuntimeError(f"Cannot redefine method from {self.__method} to {Methods.MORE_THAN}") - return self - - @property - def less_than(self) -> Self: - if self.__method == Methods.AT_LEAST_ONCE: - self.__method = Methods.LESS_THAN - else: - raise RuntimeError(f"Cannot redefine method from {self.__method} to {Methods.LESS_THAN}") - return self - - @property - def time(self) -> Self: - return self - - @property - def times(self) -> Self: - return self - - """ - Class properties. - """ - - def __match_calls_for_condition(self, condition: Callable[[list, dict], bool]) -> tuple[bool, str]: - calls = [] - for call in self.__calls: - if condition(call[0], call[1]): - calls.append(call) - compare, error = self.__apply_method(calls) - return compare, error - - def with_arguments(self, *args, **kwargs) -> SpyAssertion: - """ - Checks if the Spy has been called the given number of times - with at least the given arguments. - """ - - def some_args_matched(a, kw): - args_matched = all(( - arg in a - for arg in args - )) - kwargs_matched = all(( - key in kw and kw[key] == arg - for key, arg in kwargs.items() - )) - return args_matched and kwargs_matched - - compare, error = self.__match_calls_for_condition(some_args_matched) - repr_args = ', '.join([repr(arg) for arg in args]) - repr_kwargs = ', '.join([f"{key}={repr(arg)}" for key, arg in kwargs.items()]) - msg = f"{error} with arguments ({repr_args}) and keyword arguments ({repr_kwargs})." - return SpyAssertion(compare, msg, self.__calls) - - def with_arguments_matching(self, test_condition: Callable[[list, dict], bool]) -> SpyAssertion: - """ - Checks if the Spy has been called the given number of times - with arguments matching the given conditions. - """ - compare, error = self.__match_calls_for_condition(test_condition) - msg = f"{error} with arguments matching given conditions." - return SpyAssertion(compare, msg, self.__calls) - - def with_exact_arguments(self, *args, **kwargs) -> SpyAssertion: - """ - Checks if the Spy has been called the given number of times - with all the given arguments. - """ - compare, error = self.__match_calls_for_condition(lambda a, kw: a == args and kw == kwargs) - repr_args = ', '.join([repr(arg) for arg in args]) - repr_kwargs = ', '.join([f"{key}={repr(arg)}" for key, arg in kwargs.items()]) - msg = f"{error} with exact arguments ({repr_args}) and keyword arguments ({repr_kwargs})." - return SpyAssertion(compare, msg, self.__calls) - - def with_no_argument(self) -> SpyAssertion: - """ - Checks if the Spy has been called the given number of times - with all the given arguments. - """ - compare, error = self.__match_calls_for_condition(lambda a, kw: len(a) == 0 and len(kw) == 0) - return SpyAssertion(compare, f"{error} with no arguments.", self.__calls) - - -class Spy(AssertionInterface): +class Spy: """ Class to spy into method calls with natural language expressions. """ def __init__(self, function: Callable = None): - super().__init__(function) self.function = function self.calls = [] @@ -223,20 +31,3 @@ class Spy(AssertionInterface): self.calls.append((args, kwargs)) if self.function is not None: self.function(*args, **kwargs) - - @property - def called(self) -> CalledInterface: - """ - Returns a boolean-able interface to check conditions for a given number of - time the spy was called. - """ - return CalledInterface(self.calls) - - @property - def not_called(self) -> CalledInterface: - """ - Returns a boolean-able interface to check that conditions were never fulfilled - in the times the spy was called. - """ - ret = CalledInterface(self.calls) - return ret(0) diff --git a/runtime-pyside6/tests/plugins/natural/that.py b/runtime-pyside6/tests/plugins/natural/that.py index 38ee54e..05a3e31 100644 --- a/runtime-pyside6/tests/plugins/natural/that.py +++ b/runtime-pyside6/tests/plugins/natural/that.py @@ -17,17 +17,21 @@ """ from typing import overload, Generic, TypeVar -from .spy import Spy +from . import Spy from .interfaces.base import AssertionInterface, BaseAssertionInterface -from .interfaces.basic import StringInterface, BoolInterface -from .interfaces.int import IntInterface +from .interfaces.basic import StringInterface, BoolInterface, ListInterface +from .interfaces.int import NumberInterface +from .interfaces.spy import SpyAssertionInterface Interface = TypeVar("Interface", bound=AssertionInterface) MATCHES = [ (str, StringInterface), - (int, IntInterface), (bool, BoolInterface), + (int, NumberInterface), + (float, NumberInterface), + (list, ListInterface), + (Spy, SpyAssertionInterface) ] @@ -36,11 +40,18 @@ def that(value: str) -> StringInterface: ... @overload -def that(value: int) -> IntInterface: ... +def that(value: bool) -> BoolInterface: ... @overload -def that(value: bool) -> BoolInterface: ... +def that(value: int) -> NumberInterface: ... + + +@overload +def that(value: float) -> NumberInterface: ... + +@overload +def that(value: Spy) -> SpyAssertionInterface: ... @overload diff --git a/runtime-pyside6/tests/plugins/tests/__init__.py b/runtime-pyside6/tests/plugins/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/runtime-pyside6/tests/plugins/tests/test_natural.py b/runtime-pyside6/tests/plugins/tests/test_natural.py new file mode 100644 index 0000000..d7fe26c --- /dev/null +++ b/runtime-pyside6/tests/plugins/tests/test_natural.py @@ -0,0 +1,217 @@ +""" + * LogarithmPlotter - 2D plotter software to make BODE plots, sequences and distribution functions. + * Copyright (C) 2021-2024 Ad5001 + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . +""" +import pytest + +from ..natural import that, Assertion, Spy + + +def test_string(): + assert that("QWERTY").is_.an.instance_of(str) + assert that("QWERTY").is_.not_.an.instance_of(int) + assert that("QWERTY").is_.equal.to("QWERTY") + assert that("QWERTY").is_.NOT.equal.to("QWERTYUIOP") + assert that("QWERTY").is_.NOT.equal.to(3) + assert that("QWERTY").has.a.length.of(6) + assert that("QWERTY").does.NOT.have.a.length.of(7) + assert that("QWERTY").has.a.length.that.is_.NOT(5) + assert that("QWERTY").contains("WER") + assert that("QWERTY").contains("WER", "TY") + assert that("QWERTY").does.not_.contain("AZERTY") + with pytest.raises(Assertion): + assert that("QWERTY").is_.an.instance_of(int) + with pytest.raises(Assertion): + assert that("QWERTY").is_.equal.to(False) + with pytest.raises(Assertion): + assert that("QWERTY").has.a.length.of(1) + with pytest.raises(Assertion): + assert that("QWERTY").contains("AZERTY") + with pytest.raises(Assertion): + assert that("QWERTY").does.NOT.contain("QWE") + +def test_bool(): + assert that(True).is_.an.instance_of(bool) + assert that(True).is_.an.instance_of(int) + assert that(True).is_.NOT.an.instance_of(str) + assert that(True).equals(True) + assert that(True).is_.true + assert that(True).is_.NOT.false + assert that(False).is_.equal.to(False) + assert that(False).is_.false + assert that(False).is_.NOT.true + with pytest.raises(Assertion): + assert that(True).is_.false + with pytest.raises(Assertion): + assert that(True).is_.NOT.true + +def test_int(): + assert that(2).is_.an.instance_of(int) + assert that(2).is_.NOT.an.instance_of(bool) + assert that(2).is_.NOT.an.instance_of(str) + assert that(2).is_.more_than(1) + assert that(2).is_.NOT.less_than(1) + assert that(2).is_.less_than(3) + assert that(2).is_.NOT.more_than(3) + assert that(2).is_.at_least(1) + assert that(2).is_.NOT.at_most(1) + assert that(2).is_.at_most(3) + assert that(2).is_.NOT.at_least(3) + assert that(2).is_.at_most(2) + assert that(2).is_.at_least(2) + # Equality + assert that(2).is_(2) + assert that(2).was(2) + assert that(2).is_.exactly(2) + assert that(2).is_.equal.to(2) + assert that(2).equals(2) + assert that(2).is_.NOT(3) + assert that(2).does.NOT.equal(3) + +def test_int_shorthands(): + # Direct numbers + assert that(0).equals.zero + assert that(1).equals.one + assert that(2).equals.two + assert that(3).equals.three + assert that(4).equals.four + assert that(5).equals.five + assert that(6).equals.six + assert that(7).equals.seven + assert that(8).equals.eight + assert that(9).equals.nine + assert that(10).equals.ten + assert that(11).equals.eleven + assert that(12).equals.twelve + assert that(13).equals.thirteen + assert that(14).equals.fourteen + assert that(15).equals.fifteen + assert that(16).equals.sixteen + assert that(17).equals.seventeen + assert that(18).equals.eighteen + assert that(19).equals.nineteen + assert that(20).equals.twenty + assert that(30).equals.thirty + assert that(40).equals.forty + assert that(50).equals.fifty + assert that(60).equals.sixty + assert that(70).equals.seventy + assert that(80).equals.eighty + assert that(90).equals.ninety + assert that(100).equals.a.hundred + assert that(1000).equals.a.thousand + assert that(1_000_000).equals.a.million + +def test_add_natural_complex(): + # Test composed + assert that(34).equals.thirty.four + assert that(-34).equals.minus.thirty.four + assert that(100_033_207).equals.one.hundred.million.AND.thirty.three.thousand.AND.two.hundred.AND.seven + assert that(-1_200_033_207).equals.minus.one.billion.AND.two.hundred.million.AND.thirty.three.thousand.AND.two.hundred.AND.seven + assert that(7890).equals.seven.thousand.eight.hundred.and_.ninety + assert that(7890).equals.seventy.eight.hundred.and_.ninety + assert that(7890).equals(78)(100)(90) + with pytest.raises(RuntimeError): + assert that(1_000_000).equals.a.thousand.thousand + with pytest.raises(RuntimeError): + assert that(600).equals.one.twenty.thirty + with pytest.raises(RuntimeError): + assert that(2).equals + with pytest.raises(RuntimeError): + assert that(2).equals.one.minus.two + +def test_spy(): + spy = Spy() + assert that(spy).is_.an.instance_of(Spy) + assert that(spy).is_(callable) + # Check calls + assert that(spy).was.never.called + assert that(spy).was.called.zero.times + spy(30, arg="string") + assert that(spy).was.called + assert that(spy).was.called.once + assert that(spy).was.called.one.time + assert that(spy).was.NOT.called.more_than.once + assert that(spy).was.called.with_arguments(30) + assert that(spy).was.called.with_arguments_matching(lambda args, kwargs: len(args) == 1 and len(kwargs) == 1) + assert that(spy).was.NOT.called.with_arguments(50) + assert that(spy).was.NOT.called.with_exact_arguments(30) + assert that(spy).was.NOT.called.with_no_argument() + assert that(spy).was.called.with_exact_arguments(30, arg="string") + with pytest.raises(Assertion): + assert that(spy).was.called.with_arguments(50) + with pytest.raises(Assertion): + assert that(spy).was.called.with_exact_arguments(30) + with pytest.raises(Assertion): + assert that(spy).was.called.with_no_argument() + +def test_spy_seral_calls(): + spy = Spy(lambda *args, **kw: None) + obj = object() + spy() + spy(30, arg="string") + spy(obj, 30, example=obj, none=None) + assert that(spy).was.called + assert that(spy).was.called.more_than.once + assert that(spy).was.called.more_than.twice + assert that(spy).was.NOT.called.more_than.thrice + assert that(spy).was.called.at_most.thrice + assert that(spy).was.called.at_least.thrice + assert that(spy).was.called.three.times + assert that(spy).was.called.less_than(4).times + # Check arguments + assert that(spy).was.called.once.with_no_argument() + assert that(spy).was.called.at_most.once.with_no_argument() + assert that(spy).was.called.twice.with_arguments(30) + assert that(spy).was.NOT.called.less_than.twice.with_arguments(30) + assert that(spy).was.called.once.with_arguments(obj) + assert that(spy).was.called.once.with_arguments(arg="string") + assert that(spy).was.called.once.with_arguments(30, obj) + assert that(spy).was.called.once.with_arguments(none=None) + assert that(spy).was.NOT.called.with_arguments(None) + assert that(spy).was.NOT.called.with_arguments(obj, 30, arg="string") + with pytest.raises(Assertion): + assert that(spy).was.called.with_arguments(obj, 30, arg="string") + # Checking with exact arguments + assert that(spy).was.called.once.with_exact_arguments(30, arg="string") + assert that(spy).was.called.once.with_exact_arguments(obj, 30, example=obj, none=None) + assert that(spy).was.NOT.called.with_exact_arguments(obj, 30, arg="string") + with pytest.raises(Assertion): + assert that(spy).was.called.with_exact_arguments(obj, 30, arg="string") + # Check arguments matching + assert that(spy).has.NOT.been.called.with_arguments_matching(lambda a, kw: len(a) + len(kw) == 3) + assert that(spy).was.called.once.with_arguments_matching(lambda a, kw: len(a) + len(kw) == 2) + assert that(spy).was.called.once.with_arguments_matching(lambda a, kw: len(a) + len(kw) == 4) + with pytest.raises(Assertion): + assert that(spy).was.called.with_arguments_matching(lambda a, kw: len(a) + len(kw) == 3) + + +def test_wrongful_expressions(): + spy = Spy() + with pytest.raises(RuntimeError): + assert that(3).is_.less_than("str") + with pytest.raises(RuntimeError): + assert that(3).does.NOT.NOT.equal(3) + with pytest.raises(RuntimeError): + assert that(3).is_.an.instance_of("non type") + with pytest.raises(RuntimeError): + assert that(spy).was.called.more_than.at_least.once + with pytest.raises(RuntimeError): + assert that(spy).was.called.more_than.at_most.once + with pytest.raises(RuntimeError): + assert that(spy).was.called.more_than.less_than.once + with pytest.raises(RuntimeError): + assert that(spy).was.called.more_than.more_than.once \ No newline at end of file