Merge pull request #1 from moevm/dev

merge dev into main

Author: gevoup

.gitignore

@@ -0,0 +1,5 @@
+.env
+.idea
+.github
+.venv
+__pycache__

docker-compose.yml

@@ -0,0 +1,16 @@
+version: '3.8'
+
+services:
+  arangodb:
+    image: arangodb:latest
+    environment:
+      - ARANGO_ROOT_PASSWORD=${ARANGO_PASS}
+    ports:
+      - "${ARANGO_PORT}:8529"
+    volumes:
+      - arango_data:/var/lib/arangodb3
+      - arango_apps:/var/lib/arangodb3-apps
+
+volumes:
+  arango_data:
+  arango_apps:

hello_world/arangodb_client.py

@@ -0,0 +1,164 @@
+import os
+import sys
+
+from dotenv import load_dotenv
+
+from aioarango import ArangoClient
+import aioarango.exceptions
+from aioarango.database import StandardDatabase
+
+from typing import Optional, Any
+from aioarango.typings import Json, Jsons
+
+
+dotenv_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '.env')
+if os.path.exists(dotenv_path):
+    load_dotenv(dotenv_path)
+
+ARANGO_HOST = os.getenv("ARANGO_HOST")
+ARANGO_PORT = os.getenv("ARANGO_PORT")
+ARANGO_DB = os.getenv("ARANGO_DB")
+ARANGO_USER = os.getenv("ARANGO_USER")
+ARANGO_PASS = os.getenv("ARANGO_PASS")
+
+class ArangoDatabaseClient:
+    def __init__(self):
+        self.client = ArangoClient(hosts=f"http://{ARANGO_HOST}:{ARANGO_PORT}")
+        self.db: StandardDatabase = None
+
+    async def connect(self) -> None:
+        try:
+            system_db = await self.client.db("_system", username=ARANGO_USER, password=ARANGO_PASS)
+        except aioarango.exceptions.ServerConnectionError as e:
+            sys.exit(1)
+
+        # Создаем базу, если её нет
+        if not await system_db.has_database(ARANGO_DB):
+            await system_db.create_database(ARANGO_DB)
+            print(f"База '{ARANGO_DB}' успешно создана.")
+        else:
+            print(f"База '{ARANGO_DB}' уже существует.")
+
+        # Подключаемся к базе
+        try:
+            self.db = await self.client.db(ARANGO_DB, username=ARANGO_USER, password=ARANGO_PASS, verify=True)
+        except aioarango.exceptions.ServerConnectionError as e:
+            sys.exit(1)
+
+        print(f"Подключение к базе '{ARANGO_DB}' прошло успешно.")
+
+    async def close(self):
+        await self.client.close()
+        print("Подключение к базе данных закрыто.")
+
+    async def has_collection(self, collection_name: str) -> bool:
+        return await self.db.has_collection(collection_name)
+
+    async def create_collection(self, collection_name: str) -> bool:
+        if await self.db.has_collection(collection_name):
+            print(f"Коллекция '{collection_name}' уже существует.")
+            return False
+
+        await self.db.create_collection(collection_name)
+        print(f"Коллекция '{collection_name}' успешна создана.")
+        return True
+
+    async def delete_collection(self, collection_name: str) -> bool:
+        if not await self.db.has_collection(collection_name):
+            print(f"Коллекции '{collection_name}' не существует.")
+            return False
+
+        await self.db.delete_collection(collection_name)
+        print(f"Коллекция '{collection_name}' успешна удалена.")
+        return True
+
+    async def get_all_documents_from_collection(self, collection_name: str) -> Optional[Jsons]:
+        if not await self.has_collection(collection_name):
+            print(f"Коллекции {collection_name} не существует.")
+            return None
+
+        collection = self.db.collection(collection_name)
+
+        cursor = await collection.all()
+
+        documents = [document async for document in cursor]
+
+        return documents
+
+    async def insert_documents_to_collection(self, collection_name: str, documents: Jsons) -> bool:
+        if not await self.has_collection(collection_name):
+            print(f"Коллекции {collection_name} не существует.")
+            return False
+
+        collection = self.db.collection(collection_name)
+
+        try:
+            await collection.insert_many(documents, overwrite=True, silent=True)
+        except aioarango.exceptions.DocumentInsertError as e:
+            print(f"Не удалось провести вставку в коллекцию {collection_name}:\n{e}")
+            return False
+
+        print(f"Запись в {collection_name} прошла успешно.")
+        return True
+
+    async def get_document_by_key(self, collection_name: str, document_key: str) -> Optional[Json]:
+        if not await self.has_collection(collection_name):
+            print(f"Коллекции {collection_name} не существует.")
+            return None
+
+        collection = self.db.collection(collection_name)
+
+        return await collection.get(document_key)
+
+    async def update_document_by_key(self, collection_name: str, document_key: str, new_document: Json) -> bool:
+        if not await self.has_collection(collection_name):
+            print(f"Коллекции {collection_name} не существует.")
+            return False
+
+        collection = self.db.collection(collection_name)
+
+        new_document.update({"_key": document_key})
+
+        try:
+            await collection.update(new_document, silent=True)
+        except aioarango.exceptions.DocumentUpdateError as e:
+            print(f"Не удалось провести обновление документа {document_key} в коллекции {collection_name}:\n{e}")
+            return False
+
+        print(f"Обновление документа {document_key} в {collection_name} прошло успешно.")
+        return True
+
+    async def delete_document_by_key(self, collection_name: str, document_key: str) -> bool:
+        if not await self.has_collection(collection_name):
+            print(f"Коллекции {collection_name} не существует.")
+            return False
+
+        collection = self.db.collection(collection_name)
+
+        try:
+            await collection.delete(document_key, silent=True)
+        except aioarango.exceptions.DocumentDeleteError as e:
+            print(f"Не удалось провести удаление документа {document_key} из коллекции {collection_name}:\n{e}")
+            return False
+
+        print(f"Удаление документа {document_key} из {collection_name} прошло успешно.")
+        return True
+
+    async def find_documents_by_fields(self, collection_name: str, filter: dict[str, Any]) -> Optional[Jsons]:
+        if not await self.has_collection(collection_name):
+            print(f"Коллекции {collection_name} не существует.")
+            return None
+
+        collection = self.db.collection(collection_name)
+
+        cursor = await collection.find(filter)
+
+        return [document async for document in cursor]
+
+    async def find_documents_keys_by_fields(self, collection_name: str, filter: dict) -> Optional[list[str]]:
+        documents = await self.find_documents_by_fields(collection_name, filter)
+
+        if documents is None:
+            return None
+
+        return [document["_key"] for document in documents]

hello_world/requirements.txt

@@ -0,0 +1,172 @@
+import os
+from dotenv import load_dotenv
+
+import pytest_asyncio
+import pytest
+
+dotenv_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '.env')
+if os.path.exists(dotenv_path):
+    load_dotenv(dotenv_path)
+
+from arangodb_client import ArangoDatabaseClient
+
+@pytest_asyncio.fixture(scope="function")
+async def db_client():
+    client = ArangoDatabaseClient()
+    await client.connect()
+    yield client
+    await client.close()
+
+collection_name = "test_collection"
+
+@pytest.mark.asyncio
+async def test_create_non_existing_collection(db_client):
+    if await db_client.has_collection(collection_name):
+        await db_client.delete_collection(collection_name)
+
+    assert await db_client.has_collection(collection_name) is False
+
+    creation_result = await db_client.create_collection(collection_name)
+    assert creation_result is True
+
+    assert await db_client.has_collection(collection_name) is True
+
+@pytest.mark.asyncio
+async def test_create_existing_collection(db_client):
+    if not await db_client.has_collection(collection_name):
+        await db_client.create_collection(collection_name)
+
+    assert await db_client.has_collection(collection_name) is True
+
+    creation_result = await db_client.create_collection(collection_name)
+    assert creation_result is False
+
+@pytest.mark.asyncio
+async def test_insert_documents_to_existing_collection(db_client):
+    if not await db_client.has_collection(collection_name):
+        await db_client.create_collection(collection_name)
+
+    assert await db_client.has_collection(collection_name) is True
+
+    documents = [{"_key": "1", "name": "Andrew", "age": 30},
+                 {"_key": "2", "name": "Anton", "age": 20},
+                 {"_key": "3", "name": "Egor", "age": 21}]
+
+    insertion_result = await db_client.insert_documents_to_collection(collection_name, documents)
+    assert insertion_result is True
+
+    result_documents = await db_client.get_all_documents_from_collection(collection_name)
+    for i, result_document in enumerate(result_documents):
+        assert (result_document["_key"] == documents[i]["_key"]
+                and result_document["name"] == documents[i]["name"]
+                and result_document["age"] == documents[i]["age"])
+
+@pytest.mark.asyncio
+async def test_insert_documents_to_non_existing_collection(db_client):
+    non_existing_collection_name = "non_existing_collection"
+
+    if await db_client.has_collection(non_existing_collection_name):
+        await db_client.delete_collection(non_existing_collection_name)
+
+    assert await db_client.has_collection(non_existing_collection_name) is False
+
+    documents = [{"_key": "7", "name": "Gleb", "age": 15},
+                 {"_key": "8", "name": "Max", "age": 44},
+                 {"_key": "9", "name": "Ilya", "age": 19}]
+
+    insertion_result = await db_client.insert_documents_to_collection(non_existing_collection_name, documents)
+    assert insertion_result is False
+
+    result_documents = await db_client.get_all_documents_from_collection(non_existing_collection_name)
+    assert result_documents is None
+
+@pytest.mark.asyncio
+async def test_update_document_with_known_key(db_client):
+    if not await db_client.has_collection(collection_name):
+        await db_client.create_collection(collection_name)
+
+    assert await db_client.has_collection(collection_name) is True
+
+    document = {"_key": "123", "name": "Aleksandr", "age": 20}
+
+    updated_data = {"name": "Kirill"}
+
+    insertion_result = await db_client.insert_documents_to_collection(collection_name, [document])
+    assert insertion_result is True
+
+    update_result = await db_client.update_document_by_key(collection_name, "123", updated_data)
+    assert update_result is True
+
+    result_document = await db_client.get_document_by_key(collection_name, "123")
+    assert result_document["name"] == "Kirill"
+
+@pytest.mark.asyncio
+async def test_delete_existing_document(db_client):
+    if not await db_client.has_collection(collection_name):
+        await db_client.create_collection(collection_name)
+
+    assert await db_client.has_collection(collection_name) is True
+
+    document = {"_key": "123", "name": "Aleksandr", "age": 20}
+
+    insertion_result = await db_client.insert_documents_to_collection(collection_name, [document])
+    assert insertion_result is True
+
+    assert await db_client.get_document_by_key(collection_name, "123") is not None
+
+    deletion_result = await db_client.delete_document_by_key(collection_name, "123")
+    assert deletion_result is True
+
+    result_document = await db_client.get_document_by_key(collection_name, "123")
+    assert result_document is None
+
+@pytest.mark.asyncio
+async def test_delete_non_existing_document(db_client):
+    if not await db_client.has_collection(collection_name):
+        await db_client.create_collection(collection_name)
+
+    assert await db_client.has_collection(collection_name) is True
+
+    if await db_client.get_document_by_key(collection_name, "doc_key") is not None:
+        await db_client.delete_document_by_key(collection_name, "doc_key")
+
+    assert await db_client.get_document_by_key(collection_name, "doc_key") is None
+
+    deletion_result = await db_client.delete_document_by_key(collection_name, "doc_key")
+    assert deletion_result is False
+
+@pytest.mark.asyncio
+async def test_find_existing_document(db_client):
+    if not await db_client.has_collection(collection_name):
+        await db_client.create_collection(collection_name)
+
+    assert await db_client.has_collection(collection_name) is True
+
+    document = {"_key": "111", "name": "Andrew", "age": 30}
+    document_key = "111"
+
+    if await db_client.get_document_by_key(collection_name, document_key) is None:
+        await db_client.insert_documents_to_collection(collection_name, [document])
+
+    assert await db_client.get_document_by_key(collection_name, document_key) is not None
+
+    search_result = await db_client.find_documents_by_fields(collection_name, {"name": "Andrew", "age": 30})
+    assert search_result is not None and len(search_result) > 0
+
+@pytest.mark.asyncio
+async def test_find_non_existing_document(db_client):
+    if not await db_client.has_collection(collection_name):
+        await db_client.create_collection(collection_name)
+
+    assert await db_client.has_collection(collection_name) is True
+
+    document = { "_key": "cghgvjb", "name": "Aleksey", "age": 30 }
+    document_key = "cghgvjb"
+
+    if await db_client.get_document_by_key(collection_name, document_key) is not None:
+        await db_client.delete_document_by_key(collection_name, document_key)
+
+    assert await db_client.get_document_by_key(collection_name, document_key) is None
+
+    search_result = await db_client.find_documents_by_fields(collection_name, {"name": "Aleksey", "age": 30})
+    assert search_result is not None and len(search_result) == 0

hello_world/test_arangodb_client.py

@@ -0,0 +1,2 @@
+[pytest]
+async_mode = auto