dmart 1.4.35__py3-none-any.whl → 1.4.36__py3-none-any.whl

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"
-