add scripts, CONTRIBUTING, increase tests cov

CONTRIBUTING.md

@@ -0,0 +1,77 @@
+## Developing
+
+If you already cloned the repository and you know that you need to deep dive in the code, here are some guidelines to set up your environment.
+
+### Virtual environment with `venv`
+
+You can create a virtual environment in a directory using Python's `venv` module:
+
+```bash
+$ python -m venv venv
+```
+
+That will create a directory `./venv/` with the Python binaries and then you will be able to install packages for that isolated environment.
+
+### Activate the environment
+
+Activate the new environment with:
+
+```bash
+$ source ./venv/bin/activate
+```
+
+Make sure you have the latest pip version on your virtual environment to 
+```bash
+$ python -m pip install --upgrade pip
+```
+
+### pip
+
+After activating the environment as described above:
+
+```bash
+$ pip install -e ."[dev]"
+```
+
+It will install all the dependencies and your local Propan in your local environment.
+
+#### Using your local Propan
+
+If you create a Python file that imports and uses Propan, and run it with the Python from your local environment, it will use your local Propan source code.
+
+And if you update that local Propan source code, as it is installed with `-e`, when you run that Python file again, it will use the fresh version of Propan you just edited.
+
+That way, you don't have to "install" your local version to be able to test every change.
+
+To use your local Propan cli type:
+```bash
+$ python -m propan ...
+```
+
+### Tests
+
+To run tests with your current Propan application and Python environment use:
+```bash
+$ bash ./scripts/test-cov.sh
+```
+
+To run all tests based on RabbitMQ, NATS or another dependencies you should run first following *docker-compose.yml*
+
+```yaml
+version: "3"
+
+services:
+  rabbit:
+    image: rabbitmq
+    ports:
+      - 5672:5672
+
+  nats:
+    image: nats
+    ports:
+      - 4222:4222
+```
+
+```bash
+$ docker compose up -d
+```

propan/__about__.py

@@ -1,3 +1,3 @@
 """Simple and fast framework to create message brokers based microservices"""
 
-__version__ = "0.0.8.3"
+__version__ = "0.0.8.4"

propan/brokers/model/broker_usecase.py

@@ -1,4 +1,4 @@
-from abc import ABC
+from abc import ABC, abstractmethod
 import logging
 from time import perf_counter
 from functools import wraps
@@ -20,14 +20,10 @@ def __init__(self,
                  apply_types: bool = True,
                  logger: Optional[logging.Logger] = access_logger,
                  log_level: int = logging.INFO,
-                 log_fmt: Optional[str] = None,
                  **kwargs):
         self.logger = logger
         self.log_level = log_level
 
-        if log_fmt:
-            self._fmt = log_fmt
-
         self._is_apply_types = apply_types
         self._connection_args = args
         self._connection_kwargs = kwargs
@@ -39,35 +35,33 @@ async def connect(self, *args, **kwargs):
         if self._connection is None:
             _args = args or self._connection_args
             _kwargs = kwargs or self._connection_kwargs
-
-            try:
-                self._connection = await self._connect(*_args, **_kwargs)
-            except Exception as e:
-                if self.logger:
-                    self.logger.error(e)
-                exit()
-
+            self._connection = await self._connect(*_args, **_kwargs)
             return self._connection
 
+    @abstractmethod
     async def _connect(self, *args, **kwargs) -> Any:
         raise NotImplementedError()
 
-    async def start(self) -> None:
-        self._init_logger()
-        await self.connect()
-
+    @abstractmethod
     def publish_message(self, queue_name: str, message: str) -> None:
         raise NotImplementedError()
 
+    @abstractmethod
     def close(self) -> None:
         raise NotImplementedError()
 
+    @abstractmethod
     def _decode_message(self) -> Union[str, dict]:
         raise NotImplementedError()
 
+    @abstractmethod
     def _process_message(self, func: Callable, watcher: Optional[BaseWatcher]) -> Callable:
         raise NotImplementedError()
 
+    async def start(self) -> None:
+        self._init_logger()
+        await self.connect()
+
     def _get_log_context(self, *kwargs) -> dict[str, Any]:
         return {}
 
@@ -82,12 +76,12 @@ def _init_logger(self):
         for handler in self.logger.handlers:
             handler.setFormatter(type(handler.formatter)(self.fmt))
 
-    def __enter__(self) -> 'BrokerUsecase':
-        self.connect()
+    async def __aenter__(self) -> 'BrokerUsecase':
+        await self.connect()
         return self
 
-    def __exit__(self, *args, **kwargs):
-        self.close()
+    async def __aexit__(self, *args, **kwargs):
+        await self.close()
 
     def _wrap_handler(self,
                       func: Callable,

propan/brokers/model/schemas.py

@@ -9,9 +9,6 @@ class NameRequired(BaseModel):
     def __init__(self, name: str, **kwargs):
         super().__init__(name=name, **kwargs)
 
-    def __hash__(self):
-        return hash(self.json())
-
     def __eq__(self, other: 'NameRequired') -> bool:
         return self.name == other.name
 

propan/brokers/nats/nats_broker.py

@@ -34,13 +34,6 @@ def __init__(
         super().__init__(*args, **kwargs)
         self._fmt = log_fmt
 
-    async def __aenter__(self) -> 'NatsBroker':
-        await self.connect()
-        return self
-
-    async def __aexit__(self, *args, **kwargs):
-        await self.close()
-
     async def _connect(self, *args, **kwargs) -> Client:
         return await nats.connect(*args, **kwargs)
 

propan/brokers/push_back_watcher.py

@@ -1,4 +1,4 @@
-from abc import ABC
+from abc import ABC, abstractmethod
 from logging import Logger
 from collections import Counter
 from typing import Optional, Type, Callable
@@ -12,12 +12,15 @@ def __init__(self, max_tries: int = None, logger: Optional[Logger] = None):
         self.logger = logger
         self.max_tries = max_tries
 
+    @abstractmethod
     def add(self, message_id: str) -> None:
         raise NotImplementedError()
 
+    @abstractmethod
     def is_max(self, message_id: str) -> bool:
         raise NotImplementedError()
 
+    @abstractmethod
     def remove(self, message_id: str):
         raise NotImplementedError()
 

propan/brokers/rabbit/rabbit_broker.py

@@ -38,9 +38,6 @@ async def __aenter__(self) -> 'RabbitBroker':
         await self.connect()
         await self.init_channel()
         return self
-
-    async def __aexit__(self, *args, **kwargs):
-        await self.close()
 
     async def _connect(self, *args, **kwargs) -> aio_pika.Connection:
         return await aio_pika.connect_robust(

pyproject.toml

@@ -64,6 +64,7 @@ propan = "propan:cli"
 
 [project.optional-dependencies]
 async_rabbit = [
+    "pika-stubs",
     "aio-pika>=9",
 ]
 
@@ -75,18 +76,15 @@ test = [
     "propan[async_rabbit]",
     "propan[async_nats]",
 
-    "distutils",
+    "ruff",
+
+    "coverage[toml]",
     "pytest",
     "pytest-asyncio",
-    "pytest-cov",
 ]
 
 dev = [
     "propan[test]",
-
-    "pika-stubs",
-
-    "loguru",
 ]
 
 [tool.hatch.metadata]
@@ -117,3 +115,27 @@ features = [
 
 [[tool.hatch.envs.test.matrix]]
 python = ["37", "38", "39", "310", "311"]
+
+[tool.coverage.run]
+parallel = true
+source = [
+    "propan",
+    "tests"
+]
+context = '${CONTEXT}'
+
+[tool.coverage.report]
+show_missing = true
+skip_empty = true
+exclude_lines = [
+    "if __name__ == .__main__.:",
+    "from .*",
+    "import .*",
+    '@(abc\.)?abstractmethod',
+    "raise NotImplementedError",
+    'raise AssertionError',
+    'if self.logger is not None:',
+    'logger\..*',
+    "pass",
+    '\.\.\.',
+]

scripts/publish.sh

@@ -0,0 +1,3 @@
+hatch clean
+hatch build
+hatch publish

scripts/test-cov.sh

@@ -0,0 +1,4 @@
+bash scripts/test.sh ${@}
+coverage combine
+coverage report --show-missing
+coverage html

scripts/test.sh

@@ -0,0 +1 @@
+coverage run -m pytest tests ${@}

tests/brokers/base/test_pushback.py

@@ -8,7 +8,7 @@
 
 
 @pytest.mark.asyncio
-async def test_push_not_push(async_mock: AsyncMock):
+async def test_push_back_correct(async_mock: AsyncMock):
     message_id = 1
 
     watcher = PushBackWatcher(3)
@@ -25,6 +25,23 @@ async def test_push_not_push(async_mock: AsyncMock):
     assert not watcher.memory.get(message_id)
 
 
+@pytest.mark.asyncio
+async def test_push_back_endless_correct(async_mock: AsyncMock):
+    message_id = 1
+
+    watcher = FakePushBackWatcher()
+
+    context = WatcherContext(watcher, message_id,
+                            on_success=async_mock.on_success,
+                            on_error=async_mock.on_error,
+                            on_max=async_mock.on_max)
+
+    async with context:
+        await async_mock()
+
+    async_mock.on_success.assert_awaited_once()
+
+
 @pytest.mark.asyncio
 async def test_push_back_watcher(async_mock: AsyncMock):
     watcher = PushBackWatcher(3)

tests/utils/context/test_alias.py

@@ -45,8 +45,11 @@ async def test_nested_context_alias(context: Context):
     context.set_context("model", model)
 
     @use_context
-    async def func(*args, m = Alias("model.field.field"), **kwargs):
-        return m is model.field.field
+    async def func(*args,
+                   m = Alias("model.field.field"),
+                   m2 = Alias("model.not_existed"),
+                   **kwargs):
+        return m is model.field.field and m2 is None
 
     assert await func(model=model)
 

tests/utils/context/test_depens.py

@@ -27,7 +27,7 @@ async def test_sync_with_async_depends():
 
     @use_context
     def func(*args, k = Depends(async_dep), **kwargs):
-        return k is key
+        pass
 
     with pytest.raises(ValueError):
         func(key=key)