move validate method to private

Author: lvrfrc87

netcompare/check_types.py

@@ -129,7 +129,7 @@ def evaluate(self, *args, **kwargs) -> Tuple[Dict, bool]:
 
     @staticmethod
     @abstractmethod
-    def validate(**kwargs) -> None:
+    def _validate(**kwargs) -> None:
         """Method to validate arguments that raises proper exceptions."""
 
     @staticmethod
@@ -142,13 +142,13 @@ class ExactMatchType(CheckType):
     """Exact Match class docstring."""
 
     @staticmethod
-    def validate(**kwargs) -> None:
+    def _validate(**kwargs) -> None:
         """Method to validate arguments."""
         # reference_data = getattr(kwargs, "reference_data")
 
     def evaluate(self, value_to_compare: Any, reference_data: Any) -> Tuple[Dict, bool]:
         """Returns the difference between values and the boolean."""
-        self.validate(reference_data=reference_data)
+        self._validate(reference_data=reference_data)
         evaluation_result = diff_generator(reference_data, value_to_compare)
         return self.result(evaluation_result)
 
@@ -157,7 +157,7 @@ class ToleranceType(CheckType):
     """Tolerance class docstring."""
 
     @staticmethod
-    def validate(**kwargs) -> None:
+    def _validate(**kwargs) -> None:
         """Method to validate arguments."""
         # reference_data = getattr(kwargs, "reference_data")
         tolerance = kwargs.get("tolerance")
@@ -170,7 +170,7 @@ def validate(**kwargs) -> None:
 
     def evaluate(self, value_to_compare: Any, reference_data: Any, tolerance: int) -> Tuple[Dict, bool]:
         """Returns the difference between values and the boolean. Overwrites method in base class."""
-        self.validate(reference_data=reference_data, tolerance=tolerance)
+        self._validate(reference_data=reference_data, tolerance=tolerance)
         evaluation_result = diff_generator(reference_data, value_to_compare)
         self._remove_within_tolerance(evaluation_result, tolerance)
         return self.result(evaluation_result)
@@ -206,7 +206,7 @@ class ParameterMatchType(CheckType):
     """Parameter Match class implementation."""
 
     @staticmethod
-    def validate(**kwargs) -> None:
+    def _validate(**kwargs) -> None:
         """Method to validate arguments."""
         mode_options = ["match", "no-match"]
         params = kwargs.get("params")
@@ -225,7 +225,7 @@ def validate(**kwargs) -> None:
 
     def evaluate(self, value_to_compare: Mapping, params: Dict, mode: str) -> Tuple[Dict, bool]:
         """Parameter Match evaluator implementation."""
-        self.validate(params=params, mode=mode)
+        self._validate(params=params, mode=mode)
         # TODO: we don't use the mode?
         evaluation_result = parameter_evaluator(value_to_compare, params, mode)
         return self.result(evaluation_result)
@@ -235,7 +235,7 @@ class RegexType(CheckType):
     """Regex Match class implementation."""
 
     @staticmethod
-    def validate(**kwargs) -> None:
+    def _validate(**kwargs) -> None:
         """Method to validate arguments."""
         mode_options = ["match", "no-match"]
         regex = kwargs.get("regex")
@@ -252,7 +252,7 @@ def validate(**kwargs) -> None:
 
     def evaluate(self, value_to_compare: Mapping, regex: str, mode: str) -> Tuple[Mapping, bool]:
         """Regex Match evaluator implementation."""
-        self.validate(regex=regex, mode=mode)
+        self._validate(regex=regex, mode=mode)
         evaluation_result = regex_evaluator(value_to_compare, regex, mode)
         return self.result(evaluation_result)
 
@@ -261,7 +261,7 @@ class OperatorType(CheckType):
     """Operator class implementation."""
 
     @staticmethod
-    def validate(**kwargs) -> None:
+    def _validate(**kwargs) -> None:
         """Validate operator parameters."""
         in_operators = ("is-in", "not-in", "in-range", "not-range")
         bool_operators = ("all-same",)
@@ -334,7 +334,7 @@ def validate(**kwargs) -> None:
 
     def evaluate(self, value_to_compare: Any, params: Any) -> Tuple[Dict, bool]:
         """Operator evaluator implementation."""
-        self.validate(**params)
+        self._validate(**params)
         # For name consistency.
         reference_data = params
         evaluation_result = operator_evaluator(reference_data["params"], value_to_compare)

pyproject.toml

@@ -71,10 +71,12 @@ no-docstring-rgx="^(_|test_|Meta$)"
 # Line length is enforced by Black, so pylint doesn't need to check it.
 # Pylint and Black disagree about how to format multi-line arrays; Black wins.
 # too-many-branches disabled to supported nested logic in Operator.
+# protected-access disabled as we want test the method
 disable = """,
     line-too-long,
     bad-continuation,
-    too-many-branches     
+    too-many-branches,
+    protected-access
     """
 
 [tool.pylint.miscellaneous]

tests/test_type_checks.py

@@ -15,7 +15,7 @@ class CheckTypeChild(CheckType):
 
     assert (
         "Can't instantiate abstract class CheckTypeChild"
-        " with abstract methods evaluate, validate" in error.value.__str__()
+        " with abstract methods _validate, evaluate" in error.value.__str__()
     )
 
 
@@ -26,14 +26,14 @@ class CheckTypeChild(CheckType):
         """Test Class."""
 
         @staticmethod
-        def validate(**kwargs):
+        def _validate(**kwargs):
             return None
 
         def evaluate(self, *args, **kwargs):
             return {}, True
 
     check = CheckTypeChild()
-    assert isinstance(check, CheckTypeChild) and check.validate() is None and check.evaluate() == ({}, True)
+    assert isinstance(check, CheckTypeChild) and check._validate() is None and check.evaluate() == ({}, True)
 
 
 @pytest.mark.parametrize(

tests/test_validates.py

@@ -127,6 +127,6 @@ def test_tolerance_key_name(check_type_str, evaluate_args, expected_results):
     check = CheckType.init(check_type_str)
 
     with pytest.raises(ValueError) as exc_info:
-        check.validate(**evaluate_args)
+        check._validate(**evaluate_args)
 
     assert exc_info.type is ValueError and exc_info.value.args[0] == expected_results