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

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