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

pytests/api_user_models_erros_test.py

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,72 @@
+# 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

@@ -0,0 +1,300 @@
+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

@@ -0,0 +1,14 @@
+# 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