dmart 1.4.17__py3-none-any.whl → 1.4.19__py3-none-any.whl

{dmart-1.4.17.dist-info → dmart-1.4.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dmart
-Version: 1.4.17
+Version: 1.4.19
 Requires-Python: >=3.11
 Requires-Dist: fastapi
 Requires-Dist: pydantic

{dmart-1.4.17.dist-info → dmart-1.4.19.dist-info}/RECORD

@@ -1,7 +1,6 @@
-alembic.ini,sha256=zs8d8VhH9TRwZrPK697EZPBCfaKvI4SqTuGuG0FAm2Y,3747
 bundler.py,sha256=MDTUTVS0WL7gb-i1rDcS4i37KTqaW88TluL4L3rwjRw,1817
 data_generator.py,sha256=CnE-VHEeX7-lAXtqCgbRqR9WHjTuOgeiZcviYrHAmho,2287
-dmart.py,sha256=M6ALx41TSjzpcEczkx39aA9qdmWZk_CS2jRpU61-aEY,23288
+dmart.py,sha256=xaWzoI7xbSizlBD5Cu27FxeERJ7O69I-HZGGBQ5ucfA,24352
 get_settings.py,sha256=Sbe2WCoiK398E7HY4SNLfDN_GmE8knR4M-YJWF31jcg,153
 info.json,sha256=hXQWl19lfMkEj_zXdehGeKjiKGNJ7emY4S7d4pIqJ1E,123
 main.py,sha256=KZGhIL6AnEm5ZAPy4IvhBDpzSTjuodilV7NafNOyhzM,19676
@@ -175,6 +174,7 @@ data_adapters/sql/json_to_db_migration.py,sha256=KaubDrRZ3MfPLc-CNGPpsEccPELKr1V
 data_adapters/sql/update_query_policies.py,sha256=LUpkyzDAkiwwVWnXxPdVAU6atehW72ECAazj3mEYHK0,3857
 dmart_migrations/README,sha256=MVlc9TYmr57RbhXET6QxgyCcwWP7w-vLkEsirENqiIQ,38
 dmart_migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dmart_migrations/alembic.ini,sha256=zs8d8VhH9TRwZrPK697EZPBCfaKvI4SqTuGuG0FAm2Y,3747
 dmart_migrations/env.py,sha256=P1gnJRIUrP2jLHZ7HDbfkzkpuZJ_LMWqw05HIqOUJHo,3110
 dmart_migrations/notes.txt,sha256=X7LYSNmulLRiAUXvw07Z85bSGRTnx4NUpoNC9D2DfO8,395
 dmart_migrations/script.py.mako,sha256=u-ABdYW1tcIILgJFJdQZYLxoAI8Awd6wZbx30rY6fxU,680
@@ -246,16 +246,6 @@ plugins/system_notification_sender/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQe
 plugins/system_notification_sender/plugin.py,sha256=MUOujwyRJ3yQrXwZ-X4qSdx0ZNU2c-sYy0d0-U8twoA,8253
 plugins/update_access_controls/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plugins/update_access_controls/plugin.py,sha256=43UV4vg-zxBF_7Bv0AZH6gU0Bgy2ybapNK21wJTF05k,301
-pytests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytests/api_user_models_erros_test.py,sha256=6VWLIhazYjz7avXIMIDpT6doiBO5FVzGsGJ3Cv8cXyg,583
-pytests/api_user_models_requests_test.py,sha256=1AYZcMwa-AVeGrhTgwIkwqw3w7_CDPkbaJ0YDxLLKdY,3859
-pytests/archive_test.py,sha256=rk6jEZf-Ud7ReyH4_xJD-9SzNRz8p2Sg0qQX04VCw9M,2347
-pytests/base_test.py,sha256=d8prlME29tBnirW-3_HUtixcxUMPiLfJHRDiNkxOCRM,9902
-pytests/get_settings_test.py,sha256=AEqjnHsQjkVDqwVqtn2rN6mep4sAC_apDCgiZT4YQ28,281
-pytests/json_to_db_migration_test.py,sha256=JXO0knKPccXVIbKmyuD0yOi5fSBHmXm_NgVdO1_U7AE,9411
-pytests/service_test.py,sha256=92lqzKQoVMkj9XliPBjkGBxXb4zXsobb2WPfW5buQfc,807
-pytests/test_info.py,sha256=IOKtcEPM_03byhp5dSt2YbhTC5u_ORPahQLifZWBpjg,2074
-pytests/test_status.py,sha256=YFuBTsSd5hkpHp16GAbQ_I03RL_o2_yW-92ZNgKJry0,453
 utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utils/access_control.py,sha256=8cCKr-6bL-Shl8j8xtfjEykMPGy6wkbNz-NRwLCdx-Y,11757
 utils/async_request.py,sha256=Lm2xGXLeph7P1_fLhhNJDhPubKT2ncFn_Ueft4JVoeI,255
@@ -282,8 +272,8 @@ utils/ticket_sys_utils.py,sha256=9QAlW2iiy8KyxQRBDj_WmzS5kKb0aYJmGwd4qzmGVqo,700
 utils/web_notifier.py,sha256=QM87VVid2grC5lK3NdS1yzz0z1wXljr4GChJOeK86W4,843
 utils/templates/activation.html.j2,sha256=XAMKCdoqONoc4ZQucD0yV-Pg5DlHHASZrTVItNS-iBE,640
 utils/templates/reminder.html.j2,sha256=aoS8bTs56q4hjAZKsb0jV9c-PIURBELuBOpT_qPZNVU,639
-dmart-1.4.17.dist-info/METADATA,sha256=R7ts20I20WAd4vrVMBtjl3GztMJKwmUrQCDWSrbqJ7s,2149
-dmart-1.4.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dmart-1.4.17.dist-info/entry_points.txt,sha256=GjfoGh1bpxuU9HHGJzbtCFPNptHv9TryxHMN3uBSKpg,37
-dmart-1.4.17.dist-info/top_level.txt,sha256=XELQhaIfj-qupnyBrir39qFRh8ncu1RXkCHeitzqLLg,275
-dmart-1.4.17.dist-info/RECORD,,
+dmart-1.4.19.dist-info/METADATA,sha256=fvC35gtYzj_QldMMoGBbBnWYuKZo_hrY87dBTygXgzE,2149
+dmart-1.4.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dmart-1.4.19.dist-info/entry_points.txt,sha256=GjfoGh1bpxuU9HHGJzbtCFPNptHv9TryxHMN3uBSKpg,37
+dmart-1.4.19.dist-info/top_level.txt,sha256=S-gfX1pLerapNXiHZ8lvPYoV7sgwSX2_NCZ6xfzDUHM,267
+dmart-1.4.19.dist-info/RECORD,,

{dmart-1.4.17.dist-info → dmart-1.4.19.dist-info}/top_level.txt

@@ -13,7 +13,6 @@ migrate
 models
 password_gen
 plugins
-pytests
 run_notification_campaign
 scheduled_notification_handler
 schema_migration

dmart.py

@@ -19,11 +19,32 @@ from hypercorn.config import Config
 from hypercorn.run import run
 
 try:
+    import alembic
+    # Check if we are importing the local alembic directory which is likely a leftover
+    if hasattr(alembic, '__path__'):
+        local_alembic_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'alembic'))
+        for p in alembic.__path__:
+            if os.path.abspath(p) == local_alembic_path:
+                # Check if it is a namespace package (no __init__.py)
+                if not os.path.exists(os.path.join(p, '__init__.py')):
+                    # It is a leftover directory
+                    try:
+                        shutil.rmtree(p)
+                        # Force reload
+                        import sys
+                        if 'alembic' in sys.modules:
+                            del sys.modules['alembic']
+                        import alembic
+                    except Exception:
+                        pass
+
     from alembic import command as alembic_command
     from alembic.config import Config as AlembicConfig
     HAS_ALEMBIC = True
-except ImportError:
+    ALEMBIC_ERROR = None
+except ImportError as e:
     HAS_ALEMBIC = False
+    ALEMBIC_ERROR = e
 
 from data_adapters.file.archive import archive
 from data_adapters.file.create_index import main as create_index
@@ -549,7 +570,7 @@ def main():
                 # Fallback to alembic for backward compatibility
                 alembic_dir = pkg_dir / "alembic"
             
-            original_ini_path = pkg_dir / "alembic.ini"
+            original_ini_path = pkg_dir / "dmart_migrations" / "alembic.ini"
             if not original_ini_path.exists():
                 original_ini_path = alembic_dir / "alembic.ini"
             
@@ -561,6 +582,8 @@ def main():
                 # Check if alembic library is installed
                 if not HAS_ALEMBIC:
                     print("Error: 'alembic' library not found. Please install it with 'pip install alembic'.")
+                    if ALEMBIC_ERROR:
+                        print(f"Details: {ALEMBIC_ERROR}")
                     sys.exit(1)
 
                 alembic_cfg = AlembicConfig(str(original_ini_path))

pytests/api_user_models_erros_test.py

@@ -1,16 +0,0 @@
-import pytest
-from models.api import Error
-from utils.internal_error_code import InternalErrorCode
-from api.user.model.errors import INVALID_OTP, EXPIRED_OTP
-
-def test_invalid_otp():
-    assert isinstance(INVALID_OTP, Error)
-    assert INVALID_OTP.type == "OTP"
-    assert INVALID_OTP.code == InternalErrorCode.OTP_INVALID
-    assert INVALID_OTP.message == "Invalid OTP"
-
-def test_expired_otp():
-    assert isinstance(EXPIRED_OTP, Error)
-    assert EXPIRED_OTP.type == "OTP"
-    assert EXPIRED_OTP.code == InternalErrorCode.OTP_EXPIRED
-    assert EXPIRED_OTP.message == "Expired OTP"

pytests/api_user_models_requests_test.py

@@ -1,98 +0,0 @@
-import pytest
-from pydantic import ValidationError
-
-from api.user.model.requests import (
-    OTPType,
-    SendOTPRequest,
-    PasswordResetRequest,
-    ConfirmOTPRequest,
-    UserLoginRequest,
-    Exception,
-    Error,
-    InternalErrorCode
-)
-import utils.regex as rgx
-
-
-def test_send_otp_request_valid_msisdn():
-    request = SendOTPRequest(msisdn="7777778110")
-    result = request.check_fields()
-    assert result == {"msisdn": "7777778110"}
-
-def test_send_otp_request_valid_email():
-    request = SendOTPRequest(email="test@example.com")
-    result = request.check_fields()
-    assert result == {"email": "test@example.com"}
-
-def test_send_otp_request_missing_fields():
-    # Ensure both fields are explicitly None
-    with pytest.raises(Exception) as excinfo:
-        SendOTPRequest(msisdn=None, email=None).check_fields()
-    assert excinfo.value.status_code == 422
-    assert excinfo.value.error.code == InternalErrorCode.EMAIL_OR_MSISDN_REQUIRED
-
-def test_send_otp_request_too_many_fields():
-    with pytest.raises(Exception) as excinfo:
-        SendOTPRequest(msisdn="7777778110", email="test@example.com").check_fields()
-    assert excinfo.value.status_code == 422
-    assert excinfo.value.error.code == InternalErrorCode.INVALID_STANDALONE_DATA
-
-def test_password_reset_request_valid_msisdn():
-    request = PasswordResetRequest(msisdn="7777778110")
-    result = request.check_fields()
-    assert result == {"msisdn": "7777778110"}
-
-def test_password_reset_request_valid_email():
-    request = PasswordResetRequest(email="test@example.com")
-    result = request.check_fields()
-    assert result == {"email": "test@example.com"}
-
-def test_password_reset_request_missing_fields():
-    with pytest.raises(Exception) as excinfo:
-        PasswordResetRequest().check_fields()
-    assert excinfo.value.status_code == 422
-    assert excinfo.value.error.code == InternalErrorCode.EMAIL_OR_MSISDN_REQUIRED
-
-def test_password_reset_request_too_many_fields():
-    with pytest.raises(Exception) as excinfo:
-        PasswordResetRequest(msisdn="7777778110", email="test@example.com").check_fields()
-    assert excinfo.value.status_code == 422
-    assert excinfo.value.error.code == InternalErrorCode.INVALID_STANDALONE_DATA
-
-def test_confirm_otp_request_valid():
-    request = ConfirmOTPRequest(msisdn="7777778110", code="123456")
-    assert request.msisdn == "7777778110"
-    assert request.code == "123456"
-
-def test_confirm_otp_request_invalid_code():
-    with pytest.raises(ValidationError):
-        ConfirmOTPRequest(msisdn="7777778110", code="invalid")
-
-def test_user_login_request_valid_shortname():
-    request = UserLoginRequest(shortname="john_doo", password="my_secure_password_@_93301")
-    result = request.check_fields()
-    assert result == {"shortname": "john_doo"}
-
-def test_user_login_request_valid_email():
-    request = UserLoginRequest(email="test@example.com", password="my_secure_password_@_93301")
-    result = request.check_fields()
-    assert result == {"email": "test@example.com"}
-
-def test_user_login_request_valid_msisdn():
-    request = UserLoginRequest(msisdn="7777778110", password="my_secure_password_@_93301")
-    result = request.check_fields()
-    assert result == {"msisdn": "7777778110"}
-
-def test_user_login_request_missing_fields():
-    request = UserLoginRequest(password="my_secure_password_@_93301")
-    result = request.check_fields()
-    assert result == {}
-
-def test_user_login_request_too_many_fields():
-    with pytest.raises(ValueError, match="Too many input has been passed"):
-        UserLoginRequest(shortname="john_doo", email="test@example.com", msisdn="7777778110", password="my_secure_password_@_93301").check_fields()
-
-def test_user_login_request_missing_password():
-    request = UserLoginRequest(shortname="john_doo")
-    result = request.check_fields()
-    assert result == {"shortname": "john_doo"}

pytests/archive_test.py

@@ -1,72 +0,0 @@
-# import pytest
-# from unittest.mock import patch
-# from time import time
-# import argparse
-# import asyncio
-# from archive import redis_doc_to_meta, archive
-#
-#
-# def test_redis_doc_to_meta():
-#     mock_record = {
-#         "resource_type": "record",
-#         "created_at": time(),
-#         "updated_at": time(),
-#     }
-#     expected_keys = ["resource_type", "created_at", "updated_at"]
-#     with patch("models.core.Record") as MockRecord:
-#         MockRecord.model_fields.keys.return_value = expected_keys
-#         MockRecord.model_validate.return_value = mock_record
-#         meta = redis_doc_to_meta(mock_record)
-#         assert meta == mock_record
-#         assert MockRecord.model_fields.keys.call_count == 3
-#         MockRecord.model_validate.assert_called_once()
-#
-# def main():
-#     parser = argparse.ArgumentParser(
-#         description="Script for archiving records from different spaces and subpaths."
-#     )
-#     parser.add_argument("space", type=str, help="The name of the space")
-#     parser.add_argument("subpath", type=str, help="The subpath within the space")
-#     parser.add_argument(
-#         "schema",
-#         type=str,
-#         help="The subpath within the space. Optional, if not provided move everything",
-#         nargs="?",
-#     )
-#     parser.add_argument(
-#         "olderthan",
-#         type=int,
-#         help="The number of day, older than which, the entries will be archived (based on updated_at)",
-#     )
-#
-#     args = parser.parse_args()
-#     space = args.space
-#     subpath = args.subpath
-#     olderthan = args.olderthan
-#     schema = args.schema or "meta"
-#
-#     asyncio.run(archive(space, subpath, schema, olderthan))
-#     print("Done.")
-#
-#
-# @pytest.mark.asyncio
-# @patch("argparse.ArgumentParser.parse_args")
-# @patch("archive.archive")
-# async def test_main(mock_archive, mock_parse_args):
-#     mock_args = argparse.Namespace(
-#         space="space",
-#         subpath="subpath",
-#         schema="schema",
-#         olderthan=1
-#     )
-#     mock_parse_args.return_value = mock_args
-#
-#     with patch("asyncio.run") as mock_asyncio_run:
-#         mock_asyncio_run.side_effect = lambda x: asyncio.ensure_future(x)
-#         main()
-#
-#     mock_parse_args.assert_called_once()
-#     mock_asyncio_run.assert_called_once()
-#
-# if __name__ == "__main__":
-#     pytest.main()

pytests/base_test.py

@@ -1,300 +0,0 @@
-import json
-from utils.settings import settings
-from fastapi import status
-from models.api import Query
-from models.enums import QueryType, ResourceType, RequestType
-
-superman = {}
-alibaba = {}
-
-with open("./login_creds.sh", "r") as file:
-    for line in file.readlines():
-        if line.strip().startswith("export SUPERMAN"):
-            superman = json.loads(str(line.strip().split("'")[1]))
-        if line.strip().startswith("export ALIBABA"):
-            alibaba = json.loads(str(line.strip().split("'")[1]))
-
-MANAGEMENT_SPACE: str = f"{settings.management_space}"
-USERS_SUBPATH: str = "users"
-DEMO_SPACE: str = "test"
-DEMO_SUBPATH: str = "content"
-
-
-async def get_superman_cookie(client) -> str:
-    response = await client.post(
-        "/user/login",
-        json={"shortname": superman["shortname"], "password": superman["password"]},
-    )
-    print(f"\n {response.json() = } \n creds: {superman = } \n")
-    assert response.status_code == status.HTTP_200_OK
-    # client.cookies.set("auth_token", response.cookies["auth_token"])
-    return str(response.cookies["auth_token"])
-
-async def set_superman_cookie(client):
-    response = await client.post(
-        "/user/login",
-        json={"shortname": superman["shortname"], "password": superman["password"]},
-    )
-    print(f"\n {response.json() = } \n creds: {superman = } \n")
-    assert response.status_code == status.HTTP_200_OK
-    client.cookies.set("auth_token", response.cookies["auth_token"])
-
-
-async def set_alibaba_cookie(client):
-    response = await client.post(
-        "/user/login",
-        json={"shortname": alibaba["shortname"], "password": alibaba["password"]},
-    )
-    print(f"\n {response.json() = } \n creds: {alibaba = } \n")
-    assert response.status_code == status.HTTP_200_OK
-    client.cookies.set("auth_token", response.cookies["auth_token"])
-
-
-async def init_test_db(client) -> None:
-    # Create the space
-    await client.post(
-        "managed/request",
-        json={
-            "space_name": DEMO_SPACE,
-            "request_type": RequestType.create,
-            "records": [
-                {
-                    "resource_type": ResourceType.space,
-                    "subpath": "/",
-                    "shortname": DEMO_SPACE,
-                    "attributes": {},
-                }
-            ],
-        },
-    )
-
-    # Create the folder
-    await client.post(
-        "/managed/request",
-        json={
-            "space_name": DEMO_SPACE,
-            "request_type": RequestType.create,
-            "records": [
-                {
-                    "resource_type": ResourceType.folder,
-                    "subpath": "/",
-                    "shortname": DEMO_SUBPATH,
-                    "attributes": {},
-                }
-            ],
-        },
-    )
-
-
-async def delete_space(client) -> None:
-    headers = {"Content-Type": "application/json"}
-    endpoint = "/managed/request"
-    request_data = {
-        "space_name": DEMO_SPACE,
-        "request_type": RequestType.delete,
-        "records": [
-            {
-                "resource_type": ResourceType.space,
-                "subpath": "/",
-                "shortname": DEMO_SPACE,
-                "attributes": {},
-            }
-        ],
-    }
-
-    assert_code_and_status_success(
-        await client.post(endpoint, json=request_data, headers=headers)
-    )
-    check_not_found(
-        await client.get(f"/managed/entry/space/{DEMO_SPACE}/__root__/{DEMO_SPACE}")
-    )
-
-
-def check_repeated_shortname(response):
-    json_response = response.json()
-    assert response.status_code == status.HTTP_400_BAD_REQUEST
-    assert "failed" == json_response.get("status")
-    assert "request" == json_response.get("error", {}).get("type")
-
-
-def check_not_found(response):
-    json_response = response.json()
-    assert response.status_code == status.HTTP_404_NOT_FOUND
-    assert "failed" == json_response.get("status")
-    assert "db" == json_response.get("error").get("type")
-
-
-def check_unauthorized(response):
-    json_response = response.json()
-    assert response.status_code == status.HTTP_401_UNAUTHORIZED
-    assert "failed" == json_response.get("status")
-    assert "auth" == json_response.get("error", {}).get("type")
-
-
-def assert_code_and_status_success(response):
-    if response.status_code != status.HTTP_200_OK:
-        print(
-            "\n\n\n\n\n========================= ERROR RESPONSE: =========================n:",
-            response.json(),
-            "\n\n\n\n\n",
-        )
-    json_response = response.json()
-    print(f"{json_response=}")
-    assert response.status_code == status.HTTP_200_OK
-    assert json_response.get("status") == "success"
-    
-
-def assert_bad_request(response):
-    assert response.status_code == status.HTTP_400_BAD_REQUEST
-    assert response.json()["status"] == "failed"
-
-
-async def assert_resource_created(
-    client,
-    query: Query,
-    res_shortname: str,
-    res_subpath: str,
-    res_attributes: dict | None = None,
-    res_attachments: dict[str, int] | None = None,
-):
-    if not query.search:
-        query.search = ""
-    response = await client.post(
-        "/managed/query",
-        json=query.model_dump(exclude_none=True),
-    )
-    assert_code_and_status_success(response)
-    json_response = response.json()
-    assert json_response["status"] == "success"
-    assert json_response["attributes"]["returned"] == query.limit
-    assert json_response["records"][0]["shortname"] == res_shortname
-    assert json_response["records"][0]["subpath"] in [res_subpath, f"/{res_subpath}"]
-    if res_attributes:
-        if "is_active" not in res_attributes:
-            res_attributes["is_active"] = False
-        if "tags" not in res_attributes:
-            res_attributes["tags"] = []
-        res_attributes["owner_shortname"] = "dmart"
-
-        json_response["records"][0]["attributes"].pop("created_at", None)
-        json_response["records"][0]["attributes"].pop("updated_at", None)
-        assert (
-            json_response["records"][0]["attributes"]["payload"]["body"]
-            == res_attributes["payload"]["body"]
-        )
-
-    # Assert correct attachments number for each attachment type returned
-    if res_attachments:
-        for attachment_key, attachments in json_response["records"][0][
-            "attachments"
-        ].items():
-            if attachment_key in res_attachments:
-                assert len(attachments) == res_attachments[attachment_key]
-
-
-async def assert_resource_deleted(client, space: str, subpath: str, shortname: str):
-    query = Query(
-        type=QueryType.search,
-        space_name=space,
-        subpath=subpath,
-        search="",
-        filter_shortnames=[shortname],
-        retrieve_json_payload=True,
-        limit=1,
-    )
-    response = await client.post("/managed/query", json=query.model_dump(exclude_none=True))
-    assert_code_and_status_success(response)
-    assert response.json()["status"] == "success"
-    assert response.json()["attributes"]["returned"] == 0
-
-
-async def upload_resource_with_payload(
-    client,
-    space_name,
-    record_path: str,
-    payload_path: str,
-    payload_type,
-    attachment=False,
-    is_fail=False,
-):
-    with open(record_path, "rb") as request_file, open(
-        payload_path, "rb"
-    ) as media_file:
-        files = {
-            "request_record": ("record.json", request_file, "application/json"),
-            "payload_file": (media_file.name.split("/")[-1], media_file, payload_type),
-        }
-        response = await client.post(
-            "managed/resource_with_payload",
-            headers={},
-            data={"space_name": space_name},
-            files=files,
-        )
-
-    if is_fail:
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-    else:
-        assert_code_and_status_success(response)
-
-    if attachment:
-        with open(record_path, 'r') as record_file:
-            record_data = json.loads(record_file.read())
-            subpath_parts = record_data["subpath"].split('/')
-            attach_parent_subpath, attach_parent_shortname = "/".join(subpath_parts[:-1]), subpath_parts[-1]
-        await assert_resource_created(
-            client,
-            query=Query(
-                type=QueryType.search,
-                space_name=space_name,
-                subpath=attach_parent_subpath,
-                filter_shortnames=[attach_parent_shortname],
-                retrieve_json_payload=True,
-                retrieve_attachments=True,
-                limit=1,
-            ),
-            res_shortname=attach_parent_shortname,
-            res_subpath=attach_parent_subpath,
-            res_attachments={"media": 1},
-        )
-
-
-async def delete_resource(client, resource_type: str, del_subpath: str, del_shortname: str):
-    headers = {"Content-Type": "application/json"}
-    endpoint = "/managed/request"
-    request_data = {
-        "space_name": DEMO_SPACE,
-        "request_type": RequestType.delete,
-        "records": [
-            {
-                "resource_type": resource_type,
-                "subpath": del_subpath,
-                "shortname": del_shortname,
-                "attributes": {},
-            }
-        ],
-    }
-
-    response = await client.post(endpoint, json=request_data, headers=headers)
-    assert_code_and_status_success(response)
-
-
-async def retrieve_content_folder(client):
-    response = await client.get(f"managed/entry/folder/{DEMO_SPACE}/{settings.root_subpath_mw}/{DEMO_SUBPATH}")
-    
-    assert response.status_code == status.HTTP_200_OK
-     
-    await assert_resource_created(
-        client,
-        query=Query(
-            type=QueryType.search,
-            space_name=DEMO_SPACE,
-            subpath="/",
-            filter_shortnames=[DEMO_SUBPATH],
-            filter_types=[ResourceType.folder],
-            retrieve_json_payload=True,
-            limit=1,
-        ),
-        res_shortname=DEMO_SUBPATH,
-        res_subpath="/",
-        res_attributes={},
-    )

pytests/get_settings_test.py

@@ -1,14 +0,0 @@
-# test_script.py
-import subprocess
-import pytest
-
-
-@pytest.mark.run(order=4)
-def test_script_execution():
-    result = subprocess.run(
-        ['python3', 'get_settings.py'],
-        capture_output=True,
-        text=True,
-        check=True
-    )
-    assert result.returncode == 0

pytests/json_to_db_migration_test.py

@@ -1,237 +0,0 @@
-import time
-from uuid import uuid4
-import pytest
-import os
-import json
-from pathlib import Path
-from sqlmodel import Session, create_engine, text, SQLModel
-from data_adapters.sql.create_tables import Attachments, Entries, Spaces, Histories
-from sqlalchemy.exc import OperationalError
-from utils.settings import settings
-
-
-def subpath_checker(subpath: str):
-    if subpath.endswith("/"):
-        subpath = subpath[:-1]
-    if not subpath.startswith("/"):
-        subpath = '/' + subpath
-    return subpath
-
-
-def connect_with_retry(engine, retries=5, delay=2):
-    """
-    Try to connect to the database with retries.
-    """
-    for attempt in range(retries):
-        try:
-            with engine.connect() as _:
-                print(f"Connected to the database on attempt {attempt + 1}")
-                return
-        except OperationalError as e:
-            print(f"Connection attempt {attempt + 1} failed: {e}")
-            time.sleep(delay)
-    raise Exception("Could not connect to the database after multiple attempts")
-
-
-@pytest.fixture(scope="module")
-def setup_database():
-    if settings.active_data_db == "file":
-        pytest.skip("Skipping test for file-based database")
-        return
-
-    # Use the settings to connect with the main `postgres` user
-    postgresql_url = f"{settings.database_driver.replace('+asyncpg','+psycopg')}://{settings.database_username}:{settings.database_password}@{settings.database_host}:{settings.database_port}"
-    engine = create_engine(f"{postgresql_url}/postgres", echo=False, isolation_level="AUTOCOMMIT")
-
-    # Create the database
-    with Session(engine) as session:
-        try:
-            session.exec(text(f"DROP DATABASE IF EXISTS {settings.database_name}"))
-            session.commit()
-            session.exec(text(f"CREATE DATABASE {settings.database_name}"))
-            session.commit()  # Ensure the transaction is fully committed
-            print(f"Database {settings.database_name} created successfully")
-        except Exception as e:
-            print(f"Database creation failed: {e}")
-
-    # Add a small delay to ensure the database is fully ready
-    time.sleep(2)
-
-    yield
-
-    # Drop the database after tests
-    with Session(engine) as session:
-        try:
-            session.exec(text(f"DROP DATABASE IF EXISTS {settings.database_name}"))
-            session.commit()
-            print(f"Database {settings.database_name} dropped successfully")
-        except Exception as e:
-            print(f"Database deletion failed: {e}")
-
-    engine.dispose()
-
-
-@pytest.fixture(scope="module")
-def setup_environment(setup_database):
-    if settings.active_data_db == "file":
-        pytest.skip("Skipping test for file-based database")
-        return
-
-    # Set the database name from settings
-    driver = settings.database_driver.replace('+asyncpg', '+psycopg')
-    postgresql_url = f"{driver}://{settings.database_username}:{settings.database_password}@{settings.database_host}:{settings.database_port}"
-    engine = create_engine(f"{postgresql_url}/{settings.database_name}", echo=False)
-
-    # Retry connecting to the newly created database
-    connect_with_retry(engine)
-
-    # Generate tables after ensuring connection
-    postgresql_url = f"{driver}://{settings.database_username}:{settings.database_password}@{settings.database_host}:{settings.database_port}/{settings.database_name}"
-    engine = create_engine(postgresql_url, echo=False)
-    SQLModel.metadata.create_all(engine)
-
-    yield engine
-
-    engine.dispose()
-
-
-def test_json_to_db_migration(setup_environment):
-    if settings.active_data_db == "file":
-        pytest.skip("Skipping test for file-based database")
-        return
-
-    engine = setup_environment
-
-    # Create a complex mock directory structure and files for different entry types
-    os.makedirs('/tmp/test_space/.dm', exist_ok=True)
-    with open('/tmp/test_space/.dm/meta.space.json', 'w') as f:
-        json.dump({"key": "value"}, f)
-
-    # Create more directories and files for the migration
-    os.makedirs('/tmp/test_space/dir1', exist_ok=True)
-    with open('/tmp/test_space/dir1/history.jsonl', 'w') as f:
-        f.write(json.dumps({"key": "history"}) + '\n')
-
-    # Create attachments folder and files
-    os.makedirs('/tmp/test_space/dir1/attachments', exist_ok=True)
-    with open('/tmp/test_space/dir1/attachments/meta.attachments.json', 'w') as f:
-        json.dump({
-            "uuid": str(uuid4()),
-            "space_name": "test_space",
-            "subpath": "/dir1",
-            "acl": [],
-            "relationships": [],
-            "payload": {"body": "attachment content"}
-        }, f)
-
-    # Create ticket-related file
-    with open('/tmp/test_space/dir1/meta.ticket.json', 'w') as f:
-        json.dump({
-            "state": "open",
-            "is_open": True,
-            "reporter": "user1",
-            "subpath": "/dir1/ticket"
-        }, f)
-
-    # Create user meta file
-    with open('/tmp/test_space/.dm/meta.user.json', 'w') as f:
-        json.dump({
-            "resource_type": "user",
-            "firebase_token": "firebase_token",
-            "language": "en"
-        }, f)
-
-    # Create role meta file
-    with open('/tmp/test_space/.dm/meta.role.json', 'w') as f:
-        json.dump({
-            "resource_type": "role",
-            "permissions": ["read", "write"]
-        }, f)
-
-    # Create permission meta file
-    with open('/tmp/test_space/.dm/meta.permission.json', 'w') as f:
-        json.dump({
-            "resource_type": "permission",
-            "subpaths": {"read": "/read", "write": "/write"},
-            "resource_types": ["user", "role"]
-        }, f)
-
-    # Run the migration script
-    try:
-        with Session(engine) as session:
-            for root, dirs, _ in os.walk('/tmp/test_space'):
-                tmp = root.replace('/tmp/test_space', '')
-                if tmp == '':
-                    continue
-                if tmp[0] == '/':
-                    tmp = tmp[1:]
-                space_name = tmp.split('/')[0]
-                subpath = '/'.join(tmp.split('/')[1:])
-                if space_name == '..':
-                    continue
-
-                if space_name.startswith('.git'):
-                    continue
-
-                if subpath == '' or subpath == '/':
-                    subpath = '/'
-                    p = os.path.join(root, '.dm', 'meta.space.json')
-                    entry = {}
-                    if Path(p).is_file():
-                        entry = json.load(open(p))
-                        entry['space_name'] = space_name
-                        entry['subpath'] = '/'
-                        session.add(Spaces.model_validate(entry))
-                    continue
-
-                subpath = subpath.replace('.dm', '')
-                if subpath != '/' and subpath.endswith('/'):
-                    subpath = subpath[:-1]
-
-                if subpath == '':
-                    subpath = '/'
-
-                for dir in dirs:
-                    for file in os.listdir(os.path.join(root, dir)):
-                        if not file.startswith('meta'):
-                            if file == 'history.jsonl':
-                                lines = open(os.path.join(root, dir, file), 'r').readlines()
-                                for line in lines:
-                                    history = json.loads(line)
-                                    history['shortname'] = dir
-                                    history['space_name'] = space_name
-                                    history['subpath'] = subpath_checker(subpath)
-                                    session.add(Histories.model_validate(history))
-                            continue
-
-                        p = os.path.join(root, dir, file)
-                        if Path(p).is_file():
-                            if 'attachments' in p:
-                                _attachment = json.load(open(os.path.join(root, dir, file)))
-                                _attachment['space_name'] = space_name
-                                _attachment['uuid'] = _attachment.get('uuid', uuid4())
-                                _attachment['subpath'] = subpath_checker(_attachment['subpath'])
-                                session.add(Attachments.model_validate(_attachment))
-                            elif file.endswith('.json'):
-                                entry = json.load(open(p))
-                                entry['space_name'] = space_name
-                                entry['subpath'] = subpath_checker(subpath)
-                                session.add(Entries.model_validate(entry))
-            session.commit()
-        assert True  # Assert that the migration completes without error
-    except Exception as e:
-        print(f"Migration failed: {e}")
-        assert False  # Fail the test if there is any exception
-
-    # Clean up the mock directory structure
-    os.remove('/tmp/test_space/.dm/meta.space.json')
-    os.remove('/tmp/test_space/dir1/history.jsonl')
-    os.remove('/tmp/test_space/dir1/attachments/meta.attachments.json')
-    os.remove('/tmp/test_space/dir1/meta.ticket.json')
-    os.remove('/tmp/test_space/.dm/meta.user.json')
-    os.remove('/tmp/test_space/.dm/meta.role.json')
-    os.remove('/tmp/test_space/.dm/meta.permission.json')
-    os.rmdir('/tmp/test_space/dir1/attachments')
-    os.rmdir('/tmp/test_space/.dm')
-    os.rmdir('/tmp/test_space/dir1')
-    os.rmdir('/tmp/test_space')

pytests/service_test.py

@@ -1,26 +0,0 @@
-from api.user.service import gen_alphanumeric
-import pytest
-
-@pytest.mark.run(order=9)
-def test_gen_alphanumeric_length():
-    # Test default length
-    result = gen_alphanumeric()
-    assert len(result) == 16, "Default length should be 16"
-
-    # Test custom length
-    length = 32
-    result = gen_alphanumeric(length)
-    assert len(result) == length, f"Length should be {length}"
-
-
-@pytest.mark.run(order=9)
-def test_gen_alphanumeric_characters():
-    result = gen_alphanumeric()
-    assert all(c.isalnum() for c in result), "Result should only contain alphanumeric characters"
-
-
-@pytest.mark.run(order=9)
-def test_gen_alphanumeric_unique():
-    num_samples = 100
-    samples = {gen_alphanumeric() for _ in range(num_samples)}
-    assert len(samples) == num_samples, "Generated strings should be unique"

pytests/test_info.py

@@ -1,55 +0,0 @@
-from httpx import AsyncClient
-from pytests.base_test import get_superman_cookie
-from fastapi import status
-import pytest
-from utils.internal_error_code import InternalErrorCode
-from utils.jwt import sign_jwt
-from utils.settings import settings
-
-
-
-@pytest.mark.run(order=6)
-@pytest.mark.anyio
-async def test_info_me(client: AsyncClient) -> None:
-
-    client.cookies.set("auth_token", await get_superman_cookie(client))
-    response = await client.get("/info/me")
-    assert response.status_code == status.HTTP_200_OK
-    json_response = response.json()
-    assert json_response["status"] == "success"
-
-@pytest.mark.run(order=6)
-@pytest.mark.anyio
-async def test_info_manifest(client: AsyncClient) -> None:
-
-        client.cookies.set("auth_token", await get_superman_cookie(client))
-        response = await client.get("/info/manifest")
-        assert response.status_code == status.HTTP_200_OK
-        json_response = response.json()
-        assert json_response["status"] == "success"
-
-
-@pytest.mark.run(order=6)
-@pytest.mark.anyio
-async def test_get_settings_should_pass(client: AsyncClient) -> None:
-    client.cookies.set("auth_token", await get_superman_cookie(client))
-    response = await client.get("/info/settings")
-    assert response.status_code == status.HTTP_200_OK
-
-
-# @pytest.mark.run(order=6)
-# @pytest.mark.anyio
-# async def test_in_loop_tasks(client: AsyncClient) -> None:
-#     client.cookies.set("auth_token", await get_superman_cookie(client))
-#     response = await client.get("/info/in-loop-tasks")
-#     assert response.status_code == status.HTTP_200_OK
-#     json_response = response.json()
-#     assert json_response["status"] == "success"
-#     assert "tasks_count" in json_response["attributes"]
-#     assert isinstance(json_response["attributes"]["tasks_count"], int)
-#     assert "tasks" in json_response["attributes"]
-#     assert isinstance(json_response["attributes"]["tasks"], list)
-#     for task in json_response["attributes"]["tasks"]:
-#         assert "name" in task
-#         assert "coroutine" in task
-#         assert "stack" in task

pytests/test_status.py

@@ -1,15 +0,0 @@
-
-# from pytests.base_test import  client
-from fastapi import status
-from httpx import AsyncClient
-import pytest
-
-# @pytest.mark.asyncio(scope="session")
-@pytest.mark.anyio
-async def test_sanity(client: AsyncClient) -> None:
-#    async with my_client as client:
-        response = await client.get("/")
-        assert response.status_code == status.HTTP_200_OK
-        json_response = response.json()
-        assert json_response["status"] == "success"
-