Module kalash.test_case
Expand source code
from typing import List, Optional
import unittest
import logging
from .config import CliConfig, Meta, Trigger
from .log import get, close
class TestCase(unittest.TestCase):
"""
Lightweight `unittest.TestCase` wrapper.
When declaring your own tests you're supposed to
inherit from this class and treat it pretty much
the same as a good old-fashioned `unittest.TestCase`.
For example:
```python
\"\"\"
META_START
id: test_something_12345
META_END
\"\"\"
from kalash.run import main, TestCase, MetaLoader
class TestSomething(TestCase):
test_something(self):
self.assertTrue(True)
if __name__ == '__main__'
main(testLoader=MetaLoader())
```
Args:
methodName (str): test method
id (str): test ID from the metadata tag
trigger (Trigger): `Trigger` instance
"""
def __init__(
self,
methodName: str,
id: str,
meta: Meta,
trigger: Optional[Trigger]
) -> None:
super().__init__(methodName=methodName)
cli_config = trigger.cli_config if trigger else CliConfig()
self._id = id
self.log_base_path = cli_config.log_dir if cli_config else None
self.groupby = cli_config.group_by if cli_config else None
self.no_log_echo = cli_config.no_log_echo if cli_config else None
self.meta = meta
self.trigger = trigger
# inject logger:
if cli_config:
if not cli_config.no_log:
self.logger = get(
id,
self.__class__.__name__,
self.meta,
cli_config
)
else:
# create dummy non-functional logger on the spot when
# running with `log=False`
self.logger = logging.getLogger(self.__class__.__name__)
# close and clear all handlers that sb could have opened
# by accident
for h in self.logger.handlers:
h.close()
self.logger.handlers = []
def allow_when(self, allowed_parameters_config_property: str, parameter_on_test_case: str):
"""When running with a custom configuration class, you can use this
method to tell your test case to not be skipped on some runtime filter.
This is useful mostly when using Kalash with `parameterized`.
Consider the following example:
```python
class TestAdvancedFiltering1(TestCase):
@parameterized.expand(['lincombo', 'cancombo'])
def test_1(self, name):
self.allow_when('run_only_with', name)
print(f"Running for {name}")
```
If at runtime the config object contains a `run_only_with=['cancombo']`
value, the test will only be triggered for `cancombo`.
Args:
allowed_parameters_config_property (str): property name on the
`config` section of the `Trigger` instance containing the
skip/allow (must be a `List`).
parameter_on_test_case (str): parameter value to find in the
allowed list, coming from the test case
"""
if self.trigger:
run_with: Optional[List[str]] = self.trigger.config.get(
allowed_parameters_config_property)
if run_with:
if parameter_on_test_case in run_with:
return
else:
import inspect
caller = inspect.stack()[1].function
self.skipTest(f"{parameter_on_test_case} made test function {caller} skip")
def __del__(self):
if hasattr(self, 'logger'):
close(self.logger)
Classes
class TestCase (methodName: str, id: str, meta: Meta, trigger: Optional[Trigger])
-
Lightweight
unittest.TestCase
wrapper.When declaring your own tests you're supposed to inherit from this class and treat it pretty much the same as a good old-fashioned
unittest.TestCase
.For example:
""" META_START id: test_something_12345 META_END """ from kalash.run import main, TestCase, MetaLoader class TestSomething(TestCase): test_something(self): self.assertTrue(True) if __name__ == '__main__' main(testLoader=MetaLoader())
Args
methodName
:str
- test method
id
:str
- test ID from the metadata tag
trigger
:Trigger
Trigger
instance
Create an instance of the class that will use the named test method when executed. Raises a ValueError if the instance does not have a method with the specified name.
Expand source code
class TestCase(unittest.TestCase): """ Lightweight `unittest.TestCase` wrapper. When declaring your own tests you're supposed to inherit from this class and treat it pretty much the same as a good old-fashioned `unittest.TestCase`. For example: ```python \"\"\" META_START id: test_something_12345 META_END \"\"\" from kalash.run import main, TestCase, MetaLoader class TestSomething(TestCase): test_something(self): self.assertTrue(True) if __name__ == '__main__' main(testLoader=MetaLoader()) ``` Args: methodName (str): test method id (str): test ID from the metadata tag trigger (Trigger): `Trigger` instance """ def __init__( self, methodName: str, id: str, meta: Meta, trigger: Optional[Trigger] ) -> None: super().__init__(methodName=methodName) cli_config = trigger.cli_config if trigger else CliConfig() self._id = id self.log_base_path = cli_config.log_dir if cli_config else None self.groupby = cli_config.group_by if cli_config else None self.no_log_echo = cli_config.no_log_echo if cli_config else None self.meta = meta self.trigger = trigger # inject logger: if cli_config: if not cli_config.no_log: self.logger = get( id, self.__class__.__name__, self.meta, cli_config ) else: # create dummy non-functional logger on the spot when # running with `log=False` self.logger = logging.getLogger(self.__class__.__name__) # close and clear all handlers that sb could have opened # by accident for h in self.logger.handlers: h.close() self.logger.handlers = [] def allow_when(self, allowed_parameters_config_property: str, parameter_on_test_case: str): """When running with a custom configuration class, you can use this method to tell your test case to not be skipped on some runtime filter. This is useful mostly when using Kalash with `parameterized`. Consider the following example: ```python class TestAdvancedFiltering1(TestCase): @parameterized.expand(['lincombo', 'cancombo']) def test_1(self, name): self.allow_when('run_only_with', name) print(f"Running for {name}") ``` If at runtime the config object contains a `run_only_with=['cancombo']` value, the test will only be triggered for `cancombo`. Args: allowed_parameters_config_property (str): property name on the `config` section of the `Trigger` instance containing the skip/allow (must be a `List`). parameter_on_test_case (str): parameter value to find in the allowed list, coming from the test case """ if self.trigger: run_with: Optional[List[str]] = self.trigger.config.get( allowed_parameters_config_property) if run_with: if parameter_on_test_case in run_with: return else: import inspect caller = inspect.stack()[1].function self.skipTest(f"{parameter_on_test_case} made test function {caller} skip") def __del__(self): if hasattr(self, 'logger'): close(self.logger)
Ancestors
- unittest.case.TestCase
Methods
def allow_when(self, allowed_parameters_config_property: str, parameter_on_test_case: str)
-
When running with a custom configuration class, you can use this method to tell your test case to not be skipped on some runtime filter. This is useful mostly when using Kalash with
parameterized
.Consider the following example:
class TestAdvancedFiltering1(TestCase): @parameterized.expand(['lincombo', 'cancombo']) def test_1(self, name): self.allow_when('run_only_with', name) print(f"Running for {name}")
If at runtime the config object contains a
run_only_with=['cancombo']
value, the test will only be triggered forcancombo
.Args
allowed_parameters_config_property
:str
- property name on the
config
section of theTrigger
instance containing the skip/allow (must be aList
). parameter_on_test_case
:str
- parameter value to find in the allowed list, coming from the test case
Expand source code
def allow_when(self, allowed_parameters_config_property: str, parameter_on_test_case: str): """When running with a custom configuration class, you can use this method to tell your test case to not be skipped on some runtime filter. This is useful mostly when using Kalash with `parameterized`. Consider the following example: ```python class TestAdvancedFiltering1(TestCase): @parameterized.expand(['lincombo', 'cancombo']) def test_1(self, name): self.allow_when('run_only_with', name) print(f"Running for {name}") ``` If at runtime the config object contains a `run_only_with=['cancombo']` value, the test will only be triggered for `cancombo`. Args: allowed_parameters_config_property (str): property name on the `config` section of the `Trigger` instance containing the skip/allow (must be a `List`). parameter_on_test_case (str): parameter value to find in the allowed list, coming from the test case """ if self.trigger: run_with: Optional[List[str]] = self.trigger.config.get( allowed_parameters_config_property) if run_with: if parameter_on_test_case in run_with: return else: import inspect caller = inspect.stack()[1].function self.skipTest(f"{parameter_on_test_case} made test function {caller} skip")