fdc-shared-kernel 0.0.4__tar.gz → 0.0.5__tar.gz

{fdc_shared_kernel-0.0.4 → fdc_shared_kernel-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.4
+Version: 0.0.5
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3
@@ -26,6 +26,10 @@ Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: setuptools==71.0.0
 Requires-Dist: SQLAlchemy==2.0.31
 Requires-Dist: typing_extensions==4.12.2
+Requires-Dist: boto3==1.34.148
+Requires-Dist: boto3==1.34.148
+Requires-Dist: azure-keyvault-secrets==4.8.0
+Requires-Dist: azure-identity==1.17.1
 
 # FDC Shared Kernel
 

{fdc_shared_kernel-0.0.4 → fdc_shared_kernel-0.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fdc_shared_kernel"
-version = "0.0.4"
+version = "0.0.5"
 requires-python = ">=3.7"
 readme = "README_pypi.md"
 description = "Shared library for microservice"

fdc_shared_kernel-0.0.4/src/fdc_shared_kernel.egg-info/requires.txt → fdc_shared_kernel-0.0.5/requirements.txt

@@ -16,3 +16,7 @@ python-dotenv==1.0.1
 setuptools==71.0.0
 SQLAlchemy==2.0.31
 typing_extensions==4.12.2
+boto3==1.34.148
+boto3==1.34.148
+azure-keyvault-secrets==4.8.0
+azure-identity==1.17.1

{fdc_shared_kernel-0.0.4 → fdc_shared_kernel-0.0.5}/src/fdc_shared_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.4
+Version: 0.0.5
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3
@@ -26,6 +26,10 @@ Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: setuptools==71.0.0
 Requires-Dist: SQLAlchemy==2.0.31
 Requires-Dist: typing_extensions==4.12.2
+Requires-Dist: boto3==1.34.148
+Requires-Dist: boto3==1.34.148
+Requires-Dist: azure-keyvault-secrets==4.8.0
+Requires-Dist: azure-identity==1.17.1
 
 # FDC Shared Kernel
 

{fdc_shared_kernel-0.0.4 → fdc_shared_kernel-0.0.5}/src/fdc_shared_kernel.egg-info/SOURCES.txt

@@ -20,10 +20,15 @@ src/shared_kernel/exceptions/operational_exceptions.py
 src/shared_kernel/exceptions/security_exceptions.py
 src/shared_kernel/interfaces/__init__.py
 src/shared_kernel/interfaces/databus.py
+src/shared_kernel/interfaces/keyvault.py
 src/shared_kernel/logger/__init__.py
 src/shared_kernel/messaging/__init__.py
 src/shared_kernel/messaging/nats_databus.py
 src/shared_kernel/models/__init__.py
+src/shared_kernel/security/__init__.py
+src/shared_kernel/security/key_vault/__init__.py
+src/shared_kernel/security/key_vault/aws_secret_manager.py
+src/shared_kernel/security/key_vault/azure_keyvault.py
 src/shared_kernel/tests/__init__.py
 src/shared_kernel/tests/config/test_config.py
 src/shared_kernel/tests/logger/test_logger.py
@@ -31,7 +36,6 @@ src/shared_kernel/tests/messaging/test_nats_interface.py
 src/shared_kernel/tests/utils/test_data_validators.py
 src/shared_kernel/tests/utils/test_date_format_utils.py
 src/shared_kernel/tests/utils/test_string_utils.py
-src/shared_kernel/tests/utils/utils.py
 src/shared_kernel/utils/__init__.py
 src/shared_kernel/utils/data_validators_utils.py
 src/shared_kernel/utils/date_format_utils.py

fdc_shared_kernel-0.0.4/requirements.txt → fdc_shared_kernel-0.0.5/src/fdc_shared_kernel.egg-info/requires.txt

@@ -15,4 +15,8 @@ pytest-asyncio==0.23.8
 python-dotenv==1.0.1
 setuptools==71.0.0
 SQLAlchemy==2.0.31
-typing_extensions==4.12.2
+typing_extensions==4.12.2
+boto3==1.34.148
+boto3==1.34.148
+azure-keyvault-secrets==4.8.0
+azure-identity==1.17.1

{fdc_shared_kernel-0.0.4 → fdc_shared_kernel-0.0.5}/src/shared_kernel/config/__init__.py

@@ -2,9 +2,9 @@ import os
 from typing import Any
 from dotenv import load_dotenv, find_dotenv
 from shared_kernel.exceptions import MissingConfiguration, InvalidConfiguration
-import logging
+from src.shared_kernel.logger import Logger
 
-logging.basicConfig(level=logging.INFO)
+logger = Logger('SHARED_KERNEL')
 
 
 class Config:
@@ -26,12 +26,12 @@ class Config:
         if env_path is None:
             dotenv_path = find_dotenv()
             if not dotenv_path:
-                logging.error(".env file not found")
+                logger.error(".env file not found")
                 raise InvalidConfiguration(".env file not found")
         else:
             dotenv_path = env_path
 
-        logging.info(f"Loading environment variables from {dotenv_path}")
+        logger.info(f"Loading environment variables from {dotenv_path}")
         load_dotenv(dotenv_path)
 
     @staticmethod

fdc_shared_kernel-0.0.5/src/shared_kernel/interfaces/__init__.py

@@ -0,0 +1,2 @@
+from src.shared_kernel.interfaces.databus import *
+from src.shared_kernel.interfaces.keyvault import *

fdc_shared_kernel-0.0.5/src/shared_kernel/interfaces/keyvault.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+
+
+class KeyVaultInterface(ABC):
+
+    @abstractmethod
+    def __init__(self, config: dict):
+        """Initialize the key vault connection with the given configuration dictionary."""
+        pass
+
+    @abstractmethod
+    def store_secret(self, name: str, secret: str) -> None:
+        """Store a secret in the key vault."""
+        pass
+
+    @abstractmethod
+    def retrieve_secret(self, name: str) -> str:
+        """Retrieve a secret from the key vault."""
+        pass
+
+    @abstractmethod
+    def delete_secret(self, name: str) -> None:
+        """Delete a secret from the key vault."""
+        pass
+
+    @abstractmethod
+    def list_secrets(self) -> list:
+        """List all secrets in the key vault."""
+        pass

{fdc_shared_kernel-0.0.4 → fdc_shared_kernel-0.0.5}/src/shared_kernel/messaging/nats_databus.py

@@ -1,11 +1,12 @@
 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
+from src.shared_kernel.interfaces import DataBus
+from src.shared_kernel.logger import Logger
 
 
-class NATSDataBus:
+class NATSDataBus(DataBus):
     """
     A NATS Interface class to handle both standard NATS and JetStream operations.
     """
@@ -31,6 +32,7 @@ class NATSDataBus:
             self.connected = False
             self.js = None  # JetStream context
             self.initialized = True
+            self.logger = Logger('SHARED_KERNEL')
 
     async def make_connection(self):
         """
@@ -88,12 +90,12 @@ class NATSDataBus:
             ack = await self.js.publish(
                 topic, json.dumps(event_payload).encode("utf-8")
             )
-            logging.info(
+            self.logger.info(
                 f"Published event '{event_payload.get('event_name')}' to topic '{topic}', ack: {ack}"
             )
             return True
         except Exception as e:
-            logging.error(
+            self.logger.error(
                 f"Failed to publish event '{event_payload.get('event_name')}': {str(e)}",
                 exc_info=True,
             )
@@ -119,7 +121,7 @@ class NATSDataBus:
             )
             return json.loads(response.data.decode("utf-8"))
         except Exception as e:
-            logging.error(f"Failed to request topic '{topic}': {e}", exc_info=True)
+            self.logger.error(f"Failed to request topic '{topic}': {e}", exc_info=True)
             raise e
 
     async def subscribe_async_event(
@@ -142,10 +144,10 @@ class NATSDataBus:
             )
 
             await self.js.subscribe(topic, cb=callback, config=consumer_config)
-            logging.info(f"Subscribed to async event on topic '{topic}'")
+            self.logger.info(f"Subscribed to async event on topic '{topic}'")
 
         except Exception as e:
-            logging.error(
+            self.logger.error(
                 f"Failed to subscribe to async event on topic '{topic}': {e}",
                 exc_info=True,
             )
@@ -161,10 +163,10 @@ class NATSDataBus:
         """
         try:
             await self.nc.subscribe(topic, cb=callback)
-            logging.info(f"Subscribed to sync event on topic '{topic}'")
+            self.logger.info(f"Subscribed to sync event on topic '{topic}'")
 
         except Exception as e:
-            logging.error(
+            self.logger.error(
                 f"Failed to subscribe to sync event on topic '{topic}': {e}",
                 exc_info=True,
             )

fdc_shared_kernel-0.0.5/src/shared_kernel/security/__init__.py

@@ -0,0 +1 @@
+from src.shared_kernel.security.key_vault import *

fdc_shared_kernel-0.0.5/src/shared_kernel/security/key_vault/__init__.py

@@ -0,0 +1,14 @@
+from src.shared_kernel.interfaces import KeyVaultInterface
+from src.shared_kernel.security.key_vault.aws_secret_manager import AWSSecretsManager
+from src.shared_kernel.security.key_vault.azure_keyvault import AzureKeyVault
+
+
+class KeyVaultFactory:
+    @staticmethod
+    def create_key_vault(vault_type: str, config: dict) -> KeyVaultInterface:
+        if vault_type == 'AZURE':
+            return AzureKeyVault(config)
+        elif vault_type == 'AWS':
+            return AWSSecretsManager(config)
+        else:
+            raise ValueError(f"Unknown vault type: {vault_type}")

fdc_shared_kernel-0.0.5/src/shared_kernel/security/key_vault/aws_secret_manager.py

@@ -0,0 +1,98 @@
+import boto3
+from botocore.exceptions import ClientError
+from src.shared_kernel.interfaces import KeyVaultInterface
+from src.shared_kernel.logger import Logger
+
+
+class AWSSecretsManager(KeyVaultInterface):
+    def __init__(self, config: dict):
+        """
+        Initialize the AWS Secrets Manager connection with the given configuration.
+
+        Args:
+            config (dict): Configuration dictionary containing region_name, aws_access_key_id, _aws_secret_access_key
+        """
+        self._region_name = config.get('region_name')
+        self._aws_access_key_id = config.get('AWS_SERVER_PUBLIC_KEY')
+        self._aws_secret_access_key = config.get('AWS_SERVER_SECRET_KEY')
+        self._client = boto3.client('secretsmanager',
+                                    aws_access_key_id=self._aws_access_key_id,
+                                    aws_secret_access_key=self._aws_secret_access_key,
+                                    region_name=self._region_name)
+        self.logger = Logger('SHARED_KERNEL')
+        self.logger.info(f"Connected to AWS Secrets Manager in region: {self._region_name}")
+
+    def store_secret(self, name: str, secret: str) -> None:
+        """
+        Store a secret in AWS Secrets Manager.
+
+        Args:
+            name (str): The name of the secret.
+            secret (str): The value of the secret.
+
+        Raises:
+            ClientError: If storing the secret fails.
+        """
+        try:
+            self._client.create_secret(Name=name, SecretString=secret)
+            self.logger.info(f"Stored secret '{name}'")
+        except ClientError as e:
+            if e.response['Error']['Code'] == 'ResourceExistsException':
+                self._client.update_secret(SecretId=name, SecretString=secret)
+                self.logger.info(f"Updated secret '{name}'")
+            else:
+                self.logger.error(f"Failed to update secret '{name}' | Error: '{e}'")
+                raise e
+
+    def retrieve_secret(self, name: str) -> str:
+        """
+        Retrieve a secret from AWS Secrets Manager.
+
+        Args:
+            name (str): The name of the secret.
+
+        Returns:
+            str: The value of the retrieved secret, or None if retrieval fails.
+
+        Raises:
+            ClientError: If retrieving the secret fails.
+        """
+        try:
+            response = self._client.get_secret_value(SecretId=name)
+            return response['SecretString']
+        except ClientError as e:
+            self.logger.error(f"Error retrieving secret '{name}': {e}")
+            return None
+
+    def delete_secret(self, name: str) -> None:
+        """
+        Delete a secret from AWS Secrets Manager.
+
+        Args:
+            name (str): The name of the secret.
+
+        Raises:
+            ClientError: If deleting the secret fails.
+        """
+        try:
+            self._client.delete_secret(SecretId=name, ForceDeleteWithoutRecovery=True)
+            self.logger.info(f"Deleted secret '{name}'")
+        except ClientError as e:
+            self.logger.error(f"Error deleting secret '{name}': {e}")
+
+    def list_secrets(self) -> list:
+        """
+        List all secrets in AWS Secrets Manager.
+
+        Returns:
+            list: A list of secret names.
+
+        Raises:
+            ClientError: If listing the secrets fails.
+        """
+        try:
+            response = self._client.list_secrets()
+            return [secret['Name'] for secret in response['SecretList']]
+        except ClientError as e:
+            self.logger.error(f"Error listing secrets: {e}")
+            return []

fdc_shared_kernel-0.0.5/src/shared_kernel/security/key_vault/azure_keyvault.py

@@ -0,0 +1,67 @@
+from azure.identity import DefaultAzureCredential, ClientSecretCredential
+from azure.keyvault.secrets import SecretClient
+from src.shared_kernel.interfaces import KeyVaultInterface
+from src.shared_kernel.logger import Logger
+
+
+class AzureKeyVault(KeyVaultInterface):
+    def __init__(self, config: dict):
+        """
+        Initialize the Azure Key Vault connection with the given configuration.
+
+        Args:
+            config (dict): Configuration dictionary containing 'vault_url'.
+        """
+        self._vault_url = config.get('vault_url')
+        self._credential = ClientSecretCredential(
+            tenant_id=config.get('tenant_id'),
+            client_id=config.get('client_id'),
+            client_secret=config.get('client_secret')
+        )
+        self._client = SecretClient(vault_url=self._vault_url, credential=self._credential)
+        self.logger = Logger('SHARED_KERNEL')
+        self.logger.info(f"Connected to Azure Key Vault at: {self._vault_url}")
+
+    def store_secret(self, name: str, secret: str) -> None:
+        """
+        Store a secret in Azure Key Vault.
+
+        Args:
+            name (str): The name of the secret.
+            secret (str): The value of the secret.
+        """
+        self._client.set_secret(name, secret)
+        self.logger.info(f"Stored secret '{name}'")
+
+    def retrieve_secret(self, name: str) -> str:
+        """
+        Retrieve a secret from Azure Key Vault.
+
+        Args:
+            name (str): The name of the secret.
+
+        Returns:
+            str: The value of the retrieved secret.
+        """
+        retrieved_secret = self._client.get_secret(name)
+        return retrieved_secret.value
+
+    def delete_secret(self, name: str) -> None:
+        """
+        Delete a secret from Azure Key Vault.
+
+        Args:
+            name (str): The name of the secret.
+        """
+        self._client.begin_delete_secret(name)
+        self.logger.info(f"Deleted secret '{name}'")
+
+    def list_secrets(self) -> list:
+        """
+        List all secrets in Azure Key Vault.
+
+        Returns:
+            list: A list of secret names.
+        """
+        secrets = self._client.list_properties_of_secrets()
+        return [secret.name for secret in secrets]

fdc_shared_kernel-0.0.5/src/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()

fdc_shared_kernel-0.0.5/src/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()

fdc_shared_kernel-0.0.5/src/shared_kernel/tests/messaging/test_nats_interface.py

@@ -0,0 +1,40 @@
+# import pytest
+# from asynctest import CoroutineMock, patch
+# from shared_kernel.messaging import NATSInterface
+#
+# @pytest.fixture
+# async def nats_interface():
+#     nats = NATSInterface(servers=None)
+#     await nats.connect()
+#     yield nats
+#     await nats.close()
+#
+# @pytest.mark.asyncio
+# @patch('shared_kernel.messaging.NATSInterface.connect', new_callable=CoroutineMock)
+# @patch('shared_kernel.messaging.NATSInterface.close', new_callable=CoroutineMock)
+# async def test_connect_and_close(mock_connect, mock_close, nats_interface):
+#     await nats_interface.connect()
+#     mock_connect.assert_called_once()
+#
+#     await nats_interface.close()
+#     mock_close.assert_called_once()
+#
+# @pytest.mark.asyncio
+# @patch('shared_kernel.messaging.NATSInterface.publish', new_callable=CoroutineMock)
+# async def test_publish(mock_publish, nats_interface):
+#     await nats_interface.connect()
+#     await nats_interface.publish("test_subject", "Hello, NATS!")
+#     mock_publish.assert_called_once_with("test_subject", b"Hello, NATS!")
+#     await nats_interface.close()
+#
+# @pytest.mark.asyncio
+# @patch('shared_kernel.messaging.NATSInterface.subscribe', new_callable=CoroutineMock)
+# async def test_subscribe(mock_subscribe, nats_interface):
+#     await nats_interface.connect()
+#
+#     async def mock_callback(msg):
+#         return None
+#
+#     await nats_interface.subscribe("test_subject", mock_callback)
+#     mock_subscribe.assert_called_once_with("test_subject", cb=mock_callback)
+#     await nats_interface.close()

fdc_shared_kernel-0.0.4/src/shared_kernel/tests/config/test_config.py

@@ -1,35 +0,0 @@
-# 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()

fdc_shared_kernel-0.0.4/src/shared_kernel/tests/logger/test_logger.py

@@ -1,48 +0,0 @@
-# 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()

fdc_shared_kernel-0.0.4/src/shared_kernel/tests/messaging/test_nats_interface.py

@@ -1,36 +0,0 @@
-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()