fdc-shared-kernel 0.0.3__py3-none-any.whl

shared_kernel/messaging/nats_databus.py

@@ -0,0 +1,171 @@
+import json
+import logging
+from nats.aio.client import Client as NATS
+from nats.js.api import ConsumerConfig, DeliverPolicy, StreamConfig
+from typing import Callable, Any, List, Union
+
+
+class NATSDataBus:
+    """
+    A NATS Interface class to handle both standard NATS and JetStream operations.
+    """
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(NATSDataBus, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, servers: str = None):
+        """
+        Initialize the NATSInterface.
+
+        Args:
+            servers (str): A string containing the NATS server URLs.
+        """
+        if not hasattr(self, "initialized"):  # to prevent reinitialization
+            super().__init__()
+            self.nc = NATS()
+            self.servers = servers
+            self.connected = False
+            self.js = None  # JetStream context
+            self.initialized = True
+
+    async def make_connection(self):
+        """
+        Connect to the NATS server.
+        """
+        if not self.connected:
+            await self.nc.connect(servers=self.servers)
+            self.js = self.nc.jetstream(timeout=10)
+            self.connected = True
+
+    async def close_connection(self):
+        """
+        Close the connection to the NATS server.
+        """
+        try:
+            if self.connected:
+                await self.nc.close()
+                self.connected = False
+        except Exception as e:
+            raise e
+
+    async def create_stream(self, topics: List[Any]):
+        """
+        Create a stream for topics to persist the messages
+
+        Args:
+            topics (List): The messages in this topic with be persisted.
+        """
+        try:
+            stream_name = "sample-stream-1"
+            stream_config = StreamConfig(
+                name=stream_name,
+                subjects=topics,
+                max_age=600,  # retain messages for 10 mins
+            )
+            await self.js.add_stream(stream_config)
+        except Exception as e:
+            raise e
+
+    async def publish_event(
+        self, topic: str, event_payload: dict
+    ) -> Union[bool, Exception]:
+        """
+        Publish a message to a JetStream subject.
+
+        Args:
+            topic (str): The topic to publish the message to.
+            event_payload (dict): The message to be published.
+
+        Returns:
+            bool: True if the event was published successfully.
+        """
+        try:
+
+            ack = await self.js.publish(
+                topic, json.dumps(event_payload).encode("utf-8")
+            )
+            logging.info(
+                f"Published event '{event_payload.get('event_name')}' to topic '{topic}', ack: {ack}"
+            )
+            return True
+        except Exception as e:
+            logging.error(
+                f"Failed to publish event '{event_payload.get('event_name')}': {str(e)}",
+                exc_info=True,
+            )
+            raise e
+
+    async def request_event(
+        self, topic: str, event_payload: str, timeout: float = 10.0
+    ) -> Union[dict, Exception]:
+        """
+        Send a request and wait for a response.
+
+        Args:
+            topic (str): The topic to publish the message to.
+            event_payload (dict): The message to be published.
+            timeout (float): The timeout for the request.
+
+        Returns:
+            dict: The response message.
+        """
+        try:
+            response = await self.nc.request(
+                topic, json.dumps(event_payload).encode("utf-8"), timeout=timeout
+            )
+            return json.loads(response.data.decode("utf-8"))
+        except Exception as e:
+            logging.error(f"Failed to request topic '{topic}': {e}", exc_info=True)
+            raise e
+
+    async def subscribe_async_event(
+        self, topic: str, callback: Callable[[Any], None], durable_name: str
+    ):
+        """
+        Subscribe to a JetStream subject with a durable consumer and process messages asynchronously.
+
+        Args:
+            topic: The topic to subscribe to.
+            callback: A callback function to handle received messages.
+            durable_name: The durable name for the subscription/consumer. (give a unique name for each consumer)
+        """
+        try:
+            await self.create_stream(topics=[topic])
+            consumer_config = ConsumerConfig(
+                name=durable_name,
+                deliver_policy=DeliverPolicy.ALL,
+                durable_name=durable_name,
+            )
+
+            await self.js.subscribe(topic, cb=callback, config=consumer_config)
+            logging.info(f"Subscribed to async event on topic '{topic}'")
+
+        except Exception as e:
+            logging.error(
+                f"Failed to subscribe to async event on topic '{topic}': {e}",
+                exc_info=True,
+            )
+            raise e
+
+    async def subscribe_sync_event(self, topic: str, callback: Callable[[Any], None]):
+        """
+        Subscribe to a NATS subject and return a response after processing the message.
+
+        Args:
+            topic: The topic to subscribe to.
+            callback: A callback function to handle received messages.
+        """
+        try:
+            await self.nc.subscribe(topic, cb=callback)
+            logging.info(f"Subscribed to sync event on topic '{topic}'")
+
+        except Exception as e:
+            logging.error(
+                f"Failed to subscribe to sync event on topic '{topic}': {e}",
+                exc_info=True,
+            )
+            raise e

shared_kernel/tests/config/test_config.py

@@ -0,0 +1,35 @@
+# import unittest
+# import os
+# from unittest.mock import patch, mock_open
+# from shared_kernel.config import Config
+# from shared_kernel.exceptions import InvalidConfiguration, MissingConfiguration
+#
+#
+# class TestConfig(unittest.TestCase):
+#
+#     @patch('shared_kernel.config.find_dotenv', return_value='.env')
+#     def test_init_with_env_file_found(self, mock_find_dotenv):
+#         with patch('builtins.open', mock_open(read_data='KEY=value')):
+#             config=Config()
+#             self.assertEqual(config.get('KEY'), 'value')
+#
+#     @patch('shared_kernel.config.find_dotenv', return_value='')
+#     def test_init_with_env_file_not_found(self, mock_find_dotenv):
+#         with self.assertRaises(InvalidConfiguration):
+#             Config()
+#
+#     @patch('shared_kernel.config.find_dotenv', return_value='.env')
+#     def test_get_existing_variable(self, mock_find_dotenv):
+#         with patch.dict(os.environ, {'EXISTING_KEY': 'existing_value'}):
+#             config=Config()
+#             self.assertEqual(config.get('EXISTING_KEY'), 'existing_value')
+#
+#     @patch('shared_kernel.config.find_dotenv', return_value='/mocked/path/to/.env')
+#     def test_get_non_existing_variable(self, mock_find_dotenv):
+#         with self.assertRaises(MissingConfiguration):
+#             config=Config()
+#             config.get('NON_EXISTING_KEY')
+#
+#
+# if __name__ == '__main__':
+#     unittest.main()

shared_kernel/tests/logger/test_logger.py

@@ -0,0 +1,48 @@
+# import unittest
+# from unittest.mock import patch, MagicMock
+# import logging
+# from shared_kernel.logger import Logger
+#
+#
+# class TestLogger(unittest.TestCase):
+#
+#     @patch('logging.getLogger')
+#     def setUp(self, mock_get_logger):
+#         # Setup runs before each test method
+#         self.mock_logger = MagicMock(spec=logging.Logger)
+#         self.mock_logger.handlers = []  # Initialize handlers attribute
+#         self.mock_logger.level = logging.NOTSET  # Set the level attribute
+#         mock_get_logger.return_value = self.mock_logger
+#         self.test_logger = Logger(name='test_logger', log_file='test_log.log')
+#
+#     def test_init(self):
+#         # Test initialization parameters
+#         self.assertEqual(self.test_logger.name, 'test_logger')
+#         self.assertEqual(self.test_logger.log_file, 'test_log.log')
+#
+#     def test_configure_logger(self):
+#         # Test logger configuration
+#         self.test_logger.configure_logger()
+#         self.mock_logger.addHandler.assert_called()
+#
+#     def test_info_logging(self):
+#         # Test info logging
+#         message = 'Test info message'
+#         self.test_logger.info(message)
+#         self.mock_logger.info.assert_called_with(message)
+#
+#     def test_error_logging(self):
+#         # Test error logging
+#         message = 'Test error message'
+#         self.test_logger.error(message)
+#         self.mock_logger.error.assert_called_with(message)
+#
+#     def test_debug_logging(self):
+#         # Test debug logging
+#         message = 'Test debug message'
+#         self.test_logger.debug(message)
+#         self.mock_logger.debug.assert_called_with(message)
+#
+#
+# if __name__ == '__main__':
+#     unittest.main()

shared_kernel/tests/messaging/test_nats_interface.py

@@ -0,0 +1,36 @@
+import asyncio
+from unittest.mock import patch
+from nats.aio.client import Client as NATS
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_nats_subscriber():
+    # Start the patch
+    mock_client = patch('nats.aio.client.Client').start()
+
+    # Get the mock instance
+    instance = mock_client.return_value
+
+    # Configure the mock to return True for is_connected and None for publish
+    instance.is_connected.return_value = True
+    instance.publish.return_value = None
+
+    try:
+        # Initialize the NATS client
+        nc = NATS()
+
+        # Connect to the mock NATS server
+        await nc.connect('nats://localhost:4222')
+
+        # Subscribe to a topic asynchronously
+        await nc.subscribe('foo', cb=lambda m: print(f'Received: {m.data}'))
+
+        # Publish a message to the subscribed topic
+        await nc.publish('foo', b'bar')
+
+        # Assert that the callback was called with the published message
+        instance.publish.assert_called_once_with('foo', b'bar')
+    finally:
+        # Stop the patch after the test
+        mock_client.stop()

shared_kernel/tests/utils/test_data_validators.py

@@ -0,0 +1,18 @@
+import unittest
+from shared_kernel.utils import DataValidators
+
+
+class TestDataValidators(unittest.TestCase):
+
+    def test_validate_email(self):
+        self.assertTrue(DataValidators.validate_email("test@example.com"))
+        self.assertFalse(DataValidators.validate_email("not_an_email"))
+
+    def test_validate_phone(self):
+        self.assertTrue(DataValidators.validate_phone("1234567890"))
+        self.assertFalse(DataValidators.validate_phone("12345"))  # Not exactly 10 digits
+        self.assertFalse(DataValidators.validate_phone("123-456-7890"))  # Contains dashes
+
+
+if __name__ == '__main__':
+    unittest.main()

shared_kernel/tests/utils/test_date_format_utils.py

@@ -0,0 +1,20 @@
+from datetime import datetime
+from shared_kernel.utils import DateFormatUtils
+import unittest
+
+
+class TestDateFormatUtils(unittest.TestCase):
+
+    def test_format_date(self):
+        now = datetime.now()
+        formatted_now = DateFormatUtils.format_date(now)
+        self.assertEqual(formatted_now, now.strftime("%Y-%m-%d"))
+
+    def test_parse_date(self):
+        date_str = "2024-07-17"
+        parsed_date = DateFormatUtils.parse_date(date_str)
+        self.assertEqual(parsed_date.strftime("%Y-%m-%d"), date_str)
+
+
+if __name__ == '__main__':
+    unittest.main()

shared_kernel/tests/utils/test_string_utils.py

@@ -0,0 +1,28 @@
+import unittest
+from shared_kernel.utils import StringUtils
+
+
+class TestStringUtils(unittest.TestCase):
+
+    def test_no_truncation_needed(self):
+        self.assertEqual(StringUtils.truncate_string("Hello, world!", 20), "Hello, world!")
+
+    def test_truncation_with_default_suffix(self):
+        self.assertEqual(StringUtils.truncate_string("Hello, world!", 8), "Hello...")
+
+    def test_truncation_with_custom_suffix(self):
+        self.assertEqual(StringUtils.truncate_string("Hello, world!", 10, suffix='***'), "Hello, ***")
+
+    def test_empty_string(self):
+        self.assertEqual(StringUtils.truncate_string("", 5), "")
+
+    def test_suffix_longer_than_max_length(self):
+        self.assertEqual(StringUtils.truncate_string("Hello", 3, suffix='***'), '***')
+
+    def test_remove_html_tags(self):
+        self.assertEqual(StringUtils.remove_html_tags("<p>Hello, <strong>world</strong>!</p>"),
+                         "Hello, world!")
+
+
+if __name__ == '__main__':
+    unittest.main()