rule-engine-core 0.0.2__tar.gz → 0.0.4__tar.gz

{rule_engine_core-0.0.2 → rule_engine_core-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rule-engine-core
-Version: 0.0.2
+Version: 0.0.4
 Summary: A rule engine core library for Python.
 Home-page: https://github.com/temp-noob/rule-engine
 Author: Mohit Tripathi

rule_engine_core-0.0.4/rule_engine_core/db_pool.py

@@ -0,0 +1,102 @@
+"""
+Thread-safe psycopg2 connection pool, shared by every service in the monorepo.
+
+psycopg2 connections are not thread-safe: sharing one connection across the
+FastAPI request threadpool (or a background worker thread) races —
+`cursor already closed`, mid-transaction commits from unrelated handlers, etc.
+The blessed pattern is one connection per unit of work, checked out of this pool.
+
+Usage from a request handler (FastAPI dependency):
+
+    def get_db_connection():
+        with pool.acquire() as conn:
+            yield conn
+
+    @app.get(...)
+    def handler(conn = Depends(get_db_connection)):
+        SomeDao(conn).do_read()
+
+Usage from anywhere else (background thread, startup hook):
+
+    with pool.acquire() as conn:
+        ...
+
+`acquire()` commits the connection on clean exit and rolls back on exception, so
+each scope is its own transaction. Connections are created from the standard
+POSTGRES_* environment variables unless explicit `conn_kwargs` are supplied.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import threading
+from contextlib import contextmanager
+from typing import Generator, Optional
+
+from psycopg2.extensions import connection as PgConnection
+from psycopg2.pool import ThreadedConnectionPool
+
+_logger = logging.getLogger(__name__)
+
+
+def _default_conn_kwargs() -> dict:
+    """psycopg2.connect kwargs read from the standard POSTGRES_* env vars.
+
+    Single source of truth for env-based connection settings — `create_connection`
+    (rule_engine_core.entity_dao) builds one-off connections from the same kwargs.
+    """
+    return {
+        "dbname": os.getenv("POSTGRES_DB"),
+        "user": os.getenv("POSTGRES_USER"),
+        "password": os.getenv("POSTGRES_PASSWORD"),
+        "host": os.getenv("POSTGRES_HOST", "localhost"),
+    }
+
+
+class DbPool:
+    def __init__(
+        self,
+        min_conn: int = 2,
+        max_conn: int = 10,
+        conn_kwargs: Optional[dict] = None,
+    ):
+        kwargs = conn_kwargs or _default_conn_kwargs()
+        self._pool = ThreadedConnectionPool(min_conn, max_conn, **kwargs)
+        # psycopg2's ThreadedConnectionPool raises PoolError on exhaustion instead
+        # of blocking. For an HTTP server "503 on burst" is worse than "wait briefly",
+        # so we gate acquire() through a semaphore that blocks until a slot frees up.
+        self._semaphore = threading.BoundedSemaphore(max_conn)
+        _logger.info("DbPool created: min=%d max=%d", min_conn, max_conn)
+
+    @contextmanager
+    def acquire(self) -> Generator[PgConnection, None, None]:
+        """
+        Check out a connection, commit on clean exit, roll back on exception,
+        always return to the pool. Blocks if all connections are checked out.
+        """
+        self._semaphore.acquire()
+        try:
+            conn = self._pool.getconn()
+            try:
+                yield conn
+            except Exception:
+                try:
+                    conn.rollback()
+                except Exception:
+                    # If rollback itself fails the conn is probably broken; the pool
+                    # will eventually replace it. Don't mask the original exception.
+                    _logger.exception("rollback failed during DbPool.acquire teardown")
+                raise
+            else:
+                try:
+                    conn.commit()
+                except Exception:
+                    _logger.exception("commit failed during DbPool.acquire teardown")
+                    raise
+            finally:
+                self._pool.putconn(conn)
+        finally:
+            self._semaphore.release()
+
+    def close_all(self) -> None:
+        self._pool.closeall()

{rule_engine_core-0.0.2 → rule_engine_core-0.0.4}/rule_engine_core/entity_dao.py

@@ -3,14 +3,14 @@ This module defines the EntityDao class.
 This is responsible for storing and managing filter and rule entities.
 We will store these in a postgres database.
 """
-import json
+import threading
 from psycopg2.extensions import connection as PgConnection
 import psycopg2
 from rule_engine_core.parser import Node
-import os, logging
-from typing import Optional
+import logging
 import pickle
 import sys
+from rule_engine_core.db_pool import _default_conn_kwargs
 from rule_engine_core.entity_types import EntityEnum, EntityNode
 
 # Add an alias for backwards compatibility with pickled data
@@ -22,46 +22,41 @@ from rule_engine_core.entity_base import EntityBase
 
 _logger = logging.getLogger(__name__)
 
-def create_connection(config: Optional[dict] = None) -> PgConnection:
-    if config is None:
-        # Load the config from the environment variables
-        # and assume db is on the same host as the application
-        # using the default port: 5432
-        config = {
-            "database": os.getenv("POSTGRES_DB"),
-            "user": os.getenv("POSTGRES_USER"),
-            "password": os.getenv("POSTGRES_PASSWORD"),
-            "host": os.getenv("POSTGRES_HOST", "localhost"),
-            # "port": os.getenv("POSTGRES_PORT", 5432),
-        }
-    connection = psycopg2.connect(
-        dbname=config["database"],
-        user=config["user"],
-        password=config["password"],
-        host=config["host"],
-    )
-    # check and log if the connection is successful
-    if connection.closed == 0:
-        _logger.info("Connection to the database was successful")
-        return connection
-    else:
+def create_connection() -> PgConnection:
+    """Open a single new psycopg2 connection from the standard POSTGRES_* env vars.
+
+    The caller owns the returned connection's lifecycle (must close it, or hand it
+    to a component that does). Use this for dedicated, long-lived connections owned
+    by a single thread (e.g. a background worker) or for one-off scripts/tests.
+
+    For request-path or otherwise concurrent access, use rule_engine_core.db_pool.DbPool
+    instead: it pools connections and scopes one per unit of work, which is what makes
+    the access thread-safe.
+    """
+    connection = psycopg2.connect(**_default_conn_kwargs())
+    if connection.closed != 0:
         _logger.error("Connection to the database failed")
-        return None
+        raise RuntimeError("Failed to create a connection to the database")
+    _logger.info("Connection to the database was successful")
+    return connection
 
 class EntityDao:
     """
     This class is a dao for the postgres database which stores the filters and rules.
     """    
-    def __init__(self, config_file_path: Optional[str] = None):
+    def __init__(self, connection: PgConnection):
         """
-        Initializes the MetadataStore object with an empty dictionary to store metadata.
+        Wrap a caller-supplied psycopg2 connection.
+
+        The connection is borrowed, not owned: this DAO never closes it. Hand it a
+        pooled connection (one per request, via DbPool) on the request path, or a
+        dedicated connection (via create_connection) for a single-threaded background
+        worker. `_lock` serialises this instance's DB access so a single EntityDao is
+        safe to share across threads even on one connection — psycopg2 connections are
+        not thread-safe on their own.
         """
-        if config_file_path is not None:
-            with open(config_file_path, 'r') as f:
-                config = json.load(f)
-        self._connection = create_connection(config if config_file_path is not None else None)
-        if self._connection is None:
-            raise RuntimeError("Failed to create a connection to the database")
+        self._connection = connection
+        self._lock = threading.Lock()
     
     def get_all_entities(self, entity_type: EntityEnum) -> dict[str, EntityBase]:
         """
@@ -76,7 +71,7 @@ class EntityDao:
             query = "SELECT * FROM rules"
         else:
             raise ValueError(f"Invalid entity type: {entity_type}")
-        with self._connection.cursor() as cursor:
+        with self._lock, self._connection.cursor() as cursor:
             cursor.execute(query)
             rows = cursor.fetchall()
             entities = {}
@@ -111,7 +106,7 @@ class EntityDao:
         else:
             raise ValueError(f"Invalid entity type: {entity_enum}")
         
-        with self._connection.cursor() as cursor:
+        with self._lock, self._connection.cursor() as cursor:
             try:
                 # there shouldnt be a need to store the expression tree in the database
                 # todo: change it later
@@ -137,7 +132,7 @@ class EntityDao:
             query = "SELECT * FROM rules WHERE rule_name = %s"
         else:
             raise ValueError(f"Invalid entity type: {entity_enum}")
-        with self._connection.cursor() as cursor:
+        with self._lock, self._connection.cursor() as cursor:
             cursor.execute(query, (entity_id,))
             rows = cursor.fetchall()
             if len(rows) > 0:
@@ -160,7 +155,7 @@ class EntityDao:
         else:
             raise ValueError(f"Invalid entity type: {entity_enum}")
         
-        with self._connection.cursor() as cursor:
+        with self._lock, self._connection.cursor() as cursor:
             try:
                 cursor.execute(query, (entity_id,))
                 self._connection.commit()
@@ -169,11 +164,3 @@ class EntityDao:
                 _logger.error(f"Failed to delete entity: {e}")
                 self._connection.rollback()
                 return False
-
-    # create destructor for EntityDao class to close the connection
-    def __del__(self):
-        if self._connection is not None:
-            self._connection.close()
-            _logger.info("Connection to the database closed")
-        else:  
-            _logger.error("Connection to the database was not established")

rule_engine_core-0.0.4/rule_engine_core/metadata_dao.py

@@ -0,0 +1,80 @@
+"""
+DAO and sync helpers for metadata persisted in PostgreSQL.
+"""
+
+import json
+import os
+import logging
+import threading
+import psycopg2
+from typing import Optional
+from psycopg2.extensions import connection as PgConnection
+from psycopg2.extras import Json
+
+_logger = logging.getLogger(__name__)
+
+
+class MetadataDao:
+    def __init__(self, connection: PgConnection):
+        # Borrowed, not owned: never closed here. Pooled per-request on the request
+        # path (via DbPool), or a dedicated connection off the request path. `_lock`
+        # serialises DB access so one instance is safe to share across threads.
+        self._connection = connection
+        self._lock = threading.Lock()
+
+    def get_all_metadata(self) -> dict[str, dict]:
+        with self._lock, self._connection.cursor() as cursor:
+            cursor.execute("SELECT column_name, metadata_json FROM metadata")
+            rows = cursor.fetchall()
+            return {row[0]: row[1] for row in rows}
+
+    def get_metadata(self, column_name: str) -> Optional[dict]:
+        with self._lock, self._connection.cursor() as cursor:
+            cursor.execute(
+                "SELECT metadata_json FROM metadata WHERE column_name = %s",
+                (column_name,),
+            )
+            row = cursor.fetchone()
+            return row[0] if row is not None else None
+
+    def upsert_metadata(self, column_name: str, metadata_json: dict) -> bool:
+        with self._lock, self._connection.cursor() as cursor:
+            try:
+                cursor.execute(
+                    """
+                    INSERT INTO metadata (column_name, metadata_json)
+                    VALUES (%s, %s)
+                    ON CONFLICT (column_name)
+                    DO UPDATE SET metadata_json = EXCLUDED.metadata_json
+                    """,
+                    (column_name, Json(metadata_json)),
+                )
+                self._connection.commit()
+                return True
+            except psycopg2.Error:
+                _logger.exception("Failed to upsert metadata for column: %s", column_name)
+                self._connection.rollback()
+                return False
+
+    def delete_metadata(self, column_name: str) -> bool:
+        with self._lock, self._connection.cursor() as cursor:
+            try:
+                cursor.execute("DELETE FROM metadata WHERE column_name = %s", (column_name,))
+                self._connection.commit()
+                return True
+            except psycopg2.Error:
+                _logger.exception("Failed to delete metadata for column: %s", column_name)
+                self._connection.rollback()
+                return False
+
+    def dump_metadata_to_file(self, metadata_store_file_path: str) -> dict[str, dict]:
+        metadata = self.get_all_metadata()
+        parent_dir = os.path.dirname(metadata_store_file_path)
+        if parent_dir:
+            os.makedirs(parent_dir, exist_ok=True)
+        with open(metadata_store_file_path, "w", encoding="utf-8") as metadata_file:
+            json.dump(metadata, metadata_file, indent=4)
+        return metadata
+
+def sync_metadata_store_file(connection: PgConnection, metadata_store_file_path: str) -> dict[str, dict]:
+    return MetadataDao(connection).dump_metadata_to_file(metadata_store_file_path)

{rule_engine_core-0.0.2 → rule_engine_core-0.0.4}/rule_engine_core/metadata_store.py

@@ -9,6 +9,17 @@ The MetadataStore class has the following methods:
 """
 
 import json
+import logging
+import os
+from urllib import error, request
+
+DEFAULT_METADATA_SERVICE_URL = "http://localhost:8000"
+DEFAULT_METADATA_SERVICE_TIMEOUT_SECONDS = 3
+
+
+def _is_truthy_env(var_name: str, default: str = "false") -> bool:
+    return os.getenv(var_name, default).lower() in ("1", "true", "yes")
+
 
 class MetadataStore:
     def __init__(self, metadata_file_path: str):
@@ -23,6 +34,31 @@ class MetadataStore:
         """
         Populates the attributes from the metadata store.
         """
+        if _is_truthy_env("FETCH_METADATA_FROM_API"):
+            metadata_service_base_url = os.getenv("METADATA_SERVICE_URL", DEFAULT_METADATA_SERVICE_URL).rstrip("/")
+            metadata_service_timeout_seconds = int(
+                os.getenv("METADATA_SERVICE_TIMEOUT_SECONDS", str(DEFAULT_METADATA_SERVICE_TIMEOUT_SECONDS))
+            )
+            get_all_metadata_url = f"{metadata_service_base_url}/metadata"
+            try:
+                with request.urlopen(get_all_metadata_url, timeout=metadata_service_timeout_seconds) as response:
+                    if response.status != 200:
+                        raise RuntimeError(
+                            f"Failed to fetch metadata from service: {get_all_metadata_url} returned status {response.status}"
+                        )
+                    response_json = json.loads(response.read().decode("utf-8"))
+                    if not isinstance(response_json, dict):
+                        raise RuntimeError(
+                            f"Failed to fetch metadata from service: {get_all_metadata_url} returned non-object payload"
+                        )
+                    self._metadata_store.update(response_json)
+            except (error.URLError, error.HTTPError, json.JSONDecodeError) as exc:
+                logging.getLogger(__name__).exception(
+                    "Failed to fetch metadata from service in FETCH_METADATA_FROM_API mode",
+                )
+                raise RuntimeError(
+                    f"Failed to fetch metadata from service in FETCH_METADATA_FROM_API mode: {get_all_metadata_url}"
+                ) from exc
         attributes_set = set()
         for _, entity_data in self._metadata_store.items():
             for field in entity_data:
@@ -46,4 +82,4 @@ class MetadataStore:
         """
         Checks if field exists in the store and if the attribute exists for the field.
         """
-        return field in self._metadata_store and attribute in self._metadata_store[field] and self._metadata_store[field][attribute] is not None
+        return field in self._metadata_store and attribute in self._metadata_store[field] and self._metadata_store[field][attribute] is not None

{rule_engine_core-0.0.2 → rule_engine_core-0.0.4}/rule_engine_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rule-engine-core
-Version: 0.0.2
+Version: 0.0.4
 Summary: A rule engine core library for Python.
 Home-page: https://github.com/temp-noob/rule-engine
 Author: Mohit Tripathi

{rule_engine_core-0.0.2 → rule_engine_core-0.0.4}/rule_engine_core.egg-info/SOURCES.txt

@@ -2,10 +2,12 @@ README.md
 pyproject.toml
 setup.py
 rule_engine_core/__init__.py
+rule_engine_core/db_pool.py
 rule_engine_core/entity_base.py
 rule_engine_core/entity_dao.py
 rule_engine_core/entity_types.py
 rule_engine_core/filter.py
+rule_engine_core/metadata_dao.py
 rule_engine_core/metadata_store.py
 rule_engine_core/parser.py
 rule_engine_core/rule.py
@@ -14,5 +16,7 @@ rule_engine_core.egg-info/SOURCES.txt
 rule_engine_core.egg-info/dependency_links.txt
 rule_engine_core.egg-info/requires.txt
 rule_engine_core.egg-info/top_level.txt
+tests/test_metadata_dao.py
+tests/test_metadata_store_api_fetch.py
 tests/test_rule_creation_storage.py
 tests/test_rule_evaluation.py

{rule_engine_core-0.0.2 → rule_engine_core-0.0.4}/setup.py

@@ -14,7 +14,7 @@ def parse_requirements(filename):
 path = os.path.join(os.getenv('BUILD_PATH'), "requirements.txt")
 setup(
     name="rule-engine-core",  
-    version="0.0.2",          
+    version="0.0.4",          
     author="Mohit Tripathi",     
     author_email="tripathimohit051@gmail.com",
     description="A rule engine core library for Python.",

rule_engine_core-0.0.4/tests/test_metadata_dao.py

@@ -0,0 +1,79 @@
+from rule_engine_core.metadata_dao import MetadataDao, sync_metadata_store_file
+
+
+class StubCursor:
+    def __init__(self, connection):
+        self._connection = connection
+        self._rows = []
+        self._single_row = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return False
+
+    def execute(self, query, params=None):
+        if "SELECT column_name, metadata_json FROM metadata" in query:
+            self._rows = [(k, v) for k, v in self._connection.store.items()]
+        elif "SELECT metadata_json FROM metadata WHERE column_name = %s" in query:
+            value = self._connection.store.get(params[0])
+            self._single_row = (value,) if value is not None else None
+        elif "INSERT INTO metadata" in query:
+            self._connection.store[params[0]] = getattr(params[1], "adapted", params[1])
+        elif "DELETE FROM metadata WHERE column_name = %s" in query:
+            self._connection.store.pop(params[0], None)
+
+    def fetchall(self):
+        return self._rows
+
+    def fetchone(self):
+        return self._single_row
+
+
+class StubConnection:
+    def __init__(self):
+        self.store = {"price": {"type": "float"}}
+        self.closed = 0
+
+    def cursor(self):
+        return StubCursor(self)
+
+    def commit(self):
+        return None
+
+    def rollback(self):
+        return None
+
+    def close(self):
+        self.closed = 1
+
+
+def test_metadata_dao_crud_and_dump(tmp_path):
+    stub_connection = StubConnection()
+    metadata_dao = MetadataDao(stub_connection)
+
+    assert metadata_dao.get_all_metadata() == {"price": {"type": "float"}}
+    assert metadata_dao.get_metadata("price") == {"type": "float"}
+    assert metadata_dao.get_metadata("missing") is None
+
+    assert metadata_dao.upsert_metadata("country", {"type": "string"})
+    assert metadata_dao.get_metadata("country") == {"type": "string"}
+
+    assert metadata_dao.delete_metadata("country")
+    assert metadata_dao.get_metadata("country") is None
+
+    metadata_file_path = tmp_path / "metadata.json"
+    metadata = metadata_dao.dump_metadata_to_file(str(metadata_file_path))
+    assert metadata == {"price": {"type": "float"}}
+    assert metadata_file_path.exists()
+
+
+def test_sync_metadata_store_file_writes_given_path(tmp_path):
+    stub_connection = StubConnection()
+    metadata_file_path = tmp_path / "metadata.json"
+
+    metadata = sync_metadata_store_file(stub_connection, str(metadata_file_path))
+
+    assert metadata == {"price": {"type": "float"}}
+    assert metadata_file_path.exists()

rule_engine_core-0.0.4/tests/test_metadata_store_api_fetch.py

@@ -0,0 +1,137 @@
+import json
+from urllib.error import HTTPError, URLError
+import pytest
+from rule_engine_core.metadata_store import MetadataStore
+from rule_engine_core import metadata_store as metadata_store_module
+
+
+class MockResponse:
+    def __init__(self, status: int, payload: dict):
+        self.status = status
+        self._payload = payload
+
+    def read(self):
+        return json.dumps(self._payload).encode("utf-8")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return False
+
+
+def test_populate_attributes_fetches_from_api_when_enabled(monkeypatch, tmp_path):
+    metadata_file = tmp_path / "metadata.json"
+    metadata_file.write_text(json.dumps({"local_col": {"source": "file"}}), encoding="utf-8")
+
+    monkeypatch.setenv("FETCH_METADATA_FROM_API", "true")
+    monkeypatch.setenv("METADATA_SERVICE_URL", "http://metadata-service:8000")
+    monkeypatch.setattr(
+        "rule_engine_core.metadata_store.request.urlopen",
+        lambda url, timeout=3: MockResponse(200, {"api_col": {"source": "database", "type": "string"}}),
+    )
+
+    metadata_store = MetadataStore(str(metadata_file))
+
+    assert metadata_store.get_all_metadata() == {
+        "local_col": {"source": "file"},
+        "api_col": {"source": "database", "type": "string"},
+    }
+    assert metadata_store.does_field_exist("api_col")
+    assert metadata_store.attribute_exist_for_field("api_col", "source")
+
+
+def test_is_truthy_env_helper(monkeypatch):
+    monkeypatch.delenv("FETCH_METADATA_FROM_API", raising=False)
+    assert metadata_store_module._is_truthy_env("FETCH_METADATA_FROM_API") is False
+
+    monkeypatch.setenv("FETCH_METADATA_FROM_API", "1")
+    assert metadata_store_module._is_truthy_env("FETCH_METADATA_FROM_API") is True
+
+    monkeypatch.setenv("FETCH_METADATA_FROM_API", "true")
+    assert metadata_store_module._is_truthy_env("FETCH_METADATA_FROM_API") is True
+
+    monkeypatch.setenv("FETCH_METADATA_FROM_API", "yes")
+    assert metadata_store_module._is_truthy_env("FETCH_METADATA_FROM_API") is True
+
+    monkeypatch.setenv("FETCH_METADATA_FROM_API", "0")
+    assert metadata_store_module._is_truthy_env("FETCH_METADATA_FROM_API") is False
+
+
+def test_populate_attributes_raises_when_api_fails(monkeypatch, tmp_path):
+    metadata_file = tmp_path / "metadata.json"
+    metadata_file.write_text(json.dumps({"local_col": {"source": "file"}}), encoding="utf-8")
+
+    monkeypatch.setenv("FETCH_METADATA_FROM_API", "true")
+    def raise_url_error(url, timeout=3):
+        raise URLError("service unavailable")
+
+    monkeypatch.setattr(
+        "rule_engine_core.metadata_store.request.urlopen",
+        raise_url_error,
+    )
+
+    with pytest.raises(RuntimeError, match="FETCH_METADATA_FROM_API mode"):
+        MetadataStore(str(metadata_file))
+
+
+def test_populate_attributes_raises_on_http_error(monkeypatch, tmp_path):
+    metadata_file = tmp_path / "metadata.json"
+    metadata_file.write_text(json.dumps({"local_col": {"source": "file"}}), encoding="utf-8")
+
+    monkeypatch.setenv("FETCH_METADATA_FROM_API", "true")
+
+    def raise_http_error(url, timeout=3):
+        raise HTTPError(url, 500, "internal error", hdrs=None, fp=None)
+
+    monkeypatch.setattr("rule_engine_core.metadata_store.request.urlopen", raise_http_error)
+
+    with pytest.raises(RuntimeError, match="FETCH_METADATA_FROM_API mode"):
+        MetadataStore(str(metadata_file))
+
+
+def test_populate_attributes_raises_on_non_dict_api_payload(monkeypatch, tmp_path):
+    metadata_file = tmp_path / "metadata.json"
+    metadata_file.write_text(json.dumps({"local_col": {"source": "file"}}), encoding="utf-8")
+
+    monkeypatch.setenv("FETCH_METADATA_FROM_API", "true")
+    monkeypatch.setattr(
+        "rule_engine_core.metadata_store.request.urlopen",
+        lambda url, timeout=3: MockResponse(200, ["not", "a", "dict"]),
+    )
+
+    with pytest.raises(RuntimeError, match="non-object payload"):
+        MetadataStore(str(metadata_file))
+
+
+def test_populate_attributes_merges_api_and_file_metadata(monkeypatch, tmp_path):
+    metadata_file = tmp_path / "metadata.json"
+    metadata_file.write_text(
+        json.dumps(
+            {
+                "file_col": {"source": "file", "is_sec_column": False},
+                "shared_col": {"source": "file", "type": "int"},
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    monkeypatch.setenv("FETCH_METADATA_FROM_API", "true")
+    monkeypatch.setattr(
+        "rule_engine_core.metadata_store.request.urlopen",
+        lambda url, timeout=3: MockResponse(
+            200,
+            {
+                "api_col": {"source": "database", "type": "string"},
+                "shared_col": {"source": "database", "type": "float"},
+            },
+        ),
+    )
+
+    metadata_store = MetadataStore(str(metadata_file))
+
+    assert metadata_store.get_all_metadata() == {
+        "file_col": {"source": "file", "is_sec_column": False},
+        "shared_col": {"source": "database", "type": "float"},
+        "api_col": {"source": "database", "type": "string"},
+    }

{rule_engine_core-0.0.2 → rule_engine_core-0.0.4}/tests/test_rule_creation_storage.py

@@ -1,7 +1,7 @@
 # Tests the rule creation and storage functionality
 # These are integration tests that check if the rule engine can create and store rules correctly.
 from rule_engine_core.rule import Rule
-from rule_engine_core.entity_dao import EntityDao
+from rule_engine_core.entity_dao import EntityDao, create_connection
 from rule_engine_core.entity_types import EntityEnum, EntityNode
 from rule_engine_core.filter import Filter
 from rule_engine_core.parser import Node
@@ -10,7 +10,7 @@ import uuid
 
 def test_filter_creation_validation_storage_retrieval():
     metadata_store = MetadataStore("tests/test_metadatastore.json")
-    entity_dao = EntityDao()
+    entity_dao = EntityDao(create_connection())
     # Create a filter
     filter_name = str(uuid.uuid4())
     expression = "col2 > 10"