Test improvements

Author: apetenchea

arangoasync/collection.py

@@ -265,6 +265,10 @@ async def insert(
                 document operations. Only applicable if **overwrite** is set to true
                 or **overwriteMode** is set to "update" or "replace".
 
+        Returns:
+            bool | dict: Document metadata (e.g. document id, key, revision) or `True`
+                if **silent** is set to `True`.
+
         References:
             - `create-a-document <https://docs.arangodb.com/stable/develop/http-api/documents/#create-a-document>`__
         """  # noqa: E501

arangoasync/database.py

@@ -391,7 +391,7 @@ async def create_collection(
                 This will be used only for document operations.
             doc_deserializer (Deserializer): Custom document deserializer.
                 This will be used only for document operations.
-            col_type (CollectionType | None): Collection type.
+            col_type (CollectionType | int | str | None): Collection type.
             write_concern (int | None): Determines how many copies of each shard are
                 required to be in sync on the different DB-Servers.
             wait_for_sync (bool | None): If `True`, the data is synchronised to disk
@@ -449,6 +449,12 @@ async def create_collection(
         """  # noqa: E501
         data: Json = {"name": name}
         if col_type is not None:
+            if isinstance(col_type, int):
+                col_type = CollectionType.from_int(col_type)
+            elif isinstance(col_type, str):
+                col_type = CollectionType.from_str(col_type)
+            elif not isinstance(col_type, CollectionType):
+                raise ValueError("Invalid collection type")
             data["type"] = col_type.value
         if write_concern is not None:
             data["writeConcern"] = write_concern
@@ -644,7 +650,7 @@ async def create_user(
         """Create a new user.
 
         Args:
-            user (UserInfo): User information.
+            user (UserInfo | dict): User information.
 
         Returns:
             UserInfo: New user details.
@@ -657,10 +663,13 @@ async def create_user(
             .. code-block:: python
 
                 await db.create_user(UserInfo(user="john", password="secret"))
+                await db.create_user({user="john", password="secret"})
 
         References:
             - `create-a-user <https://docs.arangodb.com/stable/develop/http-api/users/#create-a-user>`__
         """  # noqa: E501
+        if isinstance(user, dict):
+            user = UserInfo(**user)
         if not user.user:
             raise ValueError("Username is required.")
 

arangoasync/typings.py

@@ -62,6 +62,24 @@ def from_int(value: int) -> "CollectionType":
         else:
             raise ValueError(f"Invalid collection type value: {value}")
 
+    @staticmethod
+    def from_str(value: str) -> "CollectionType":
+        """Return a collection type from its string value.
+
+        Args:
+            value (str): Collection type string value.
+
+        Returns:
+            CollectionType: Collection type.
+        """
+        value = value.lower()
+        if value == "document":
+            return CollectionType.DOCUMENT
+        elif value == "edge":
+            return CollectionType.EDGE
+        else:
+            raise ValueError(f"Invalid collection type value: {value}")
+
     def __str__(self) -> str:
         return self.name.lower()
 

tests/conftest.py

@@ -85,7 +85,7 @@ def basic_auth_root(root, password):
 
 
 @pytest.fixture
-def clusetr():
+def cluster():
     return global_data.cluster
 
 
@@ -109,6 +109,18 @@ def sys_db_name():
     return global_data.sys_db_name
 
 
+@pytest.fixture
+def docs():
+    return [
+        {"_key": "1", "val": 1, "text": "foo", "loc": [1, 1]},
+        {"_key": "2", "val": 2, "text": "foo", "loc": [2, 2]},
+        {"_key": "3", "val": 3, "text": "foo", "loc": [3, 3]},
+        {"_key": "4", "val": 4, "text": "bar", "loc": [4, 4]},
+        {"_key": "5", "val": 5, "text": "bar", "loc": [5, 5]},
+        {"_key": "6", "val": 6, "text": "bar", "loc": [5, 5]},
+    ]
+
+
 @pytest.fixture(scope="session")
 def event_loop():
     loop = asyncio.new_event_loop()
@@ -146,14 +158,22 @@ async def sys_db(arango_client, sys_db_name, basic_auth_root):
 
 
 @pytest_asyncio.fixture
-async def test_db(arango_client, sys_db, username, password):
+async def db(arango_client, sys_db, username, password, cluster):
     tst_db_name = generate_db_name()
     tst_user = UserInfo(
         user=username,
         password=password,
         active=True,
     )
-    await sys_db.create_database(tst_db_name, users=[tst_user])
+    tst_db_kwargs = dict(name=tst_db_name, users=[tst_user])
+    if cluster:
+        tst_db_kwargs.update(
+            dict(
+                replication_factor=3,
+                write_concern=2,
+            )
+        )
+    await sys_db.create_database(**tst_db_kwargs)
     yield await arango_client.db(
         tst_db_name,
         auth_method="basic",
@@ -174,10 +194,10 @@ async def bad_db(arango_client):
 
 
 @pytest_asyncio.fixture
-async def test_doc_col(test_db):
+async def doc_col(db):
     col_name = generate_col_name()
-    yield await test_db.create_collection(col_name)
-    await test_db.delete_collection(col_name)
+    yield await db.create_collection(col_name)
+    await db.delete_collection(col_name)
 
 
 @pytest_asyncio.fixture(scope="session", autouse=True)

tests/test_database.py

@@ -1,7 +1,16 @@
 import pytest
 
 from arangoasync.collection import StandardCollection
-from tests.helpers import generate_col_name, generate_db_name
+from arangoasync.exceptions import (
+    CollectionCreateError,
+    CollectionDeleteError,
+    CollectionListError,
+    DatabaseCreateError,
+    DatabaseDeleteError,
+    DatabaseListError,
+)
+from arangoasync.typings import CollectionType, KeyOptions, UserInfo
+from tests.helpers import generate_col_name, generate_db_name, generate_username
 
 
 @pytest.mark.asyncio
@@ -11,29 +20,56 @@ async def test_database_misc_methods(sys_db):
 
 
 @pytest.mark.asyncio
-async def test_create_drop_database(arango_client, sys_db, basic_auth_root):
-    # TODO also handle exceptions
-    # TODO use more options (cluster must be enabled for that)
-
+async def test_create_drop_database(
+    arango_client,
+    sys_db,
+    db,
+    basic_auth_root,
+    password,
+    cluster,
+):
     # Create a new database
     db_name = generate_db_name()
-    assert await sys_db.create_database(db_name) is True
-    new_db = await arango_client.db(
+    db_kwargs = dict(
+        name=db_name,
+        users=[
+            dict(username=generate_username(), password=password, active=True),
+            UserInfo(user=generate_username(), password=password, active=True),
+        ],
+    )
+    if cluster:
+        db_kwargs["replication_factor"] = 3
+        db_kwargs["write_concern"] = 2
+        db_kwargs["sharding"] = "flexible"
+
+    assert await sys_db.create_database(**db_kwargs) is True
+    await arango_client.db(
         db_name, auth_method="basic", auth=basic_auth_root, verify=True
     )
     assert await sys_db.has_database(db_name) is True
 
+    # Try to create a database without permissions
+    with pytest.raises(DatabaseCreateError):
+        await db.create_database(generate_db_name())
+
+    # Try to create a database that already exists
+    with pytest.raises(DatabaseCreateError):
+        await sys_db.create_database(db_name)
+
     # List available databases
     dbs = await sys_db.databases()
     assert db_name in dbs
     assert "_system" in dbs
 
-    # TODO move this to a separate test for documents
-    col_name = generate_col_name()
-    col = await new_db.create_collection(col_name)
-    await col.insert({"_key": "1", "a": 1})
-    doc = await col.get("1")
-    assert doc["_key"] == "1"
+    # Cannot list databases without permission
+    with pytest.raises(DatabaseListError):
+        await db.databases()
+    with pytest.raises(DatabaseListError):
+        await db.has_database(db_name)
+
+    # Databases can only be dropped from the system database
+    with pytest.raises(DatabaseDeleteError):
+        await db.delete_database(db_name)
 
     # Drop the newly created database
     assert await sys_db.delete_database(db_name) is True
@@ -43,22 +79,87 @@ async def test_create_drop_database(arango_client, sys_db, basic_auth_root):
 
 
 @pytest.mark.asyncio
-async def test_create_drop_collection(test_db):
-    # TODO also handle exceptions
-
+async def test_create_drop_collection(db, bad_db, cluster):
     # Create a new collection
     col_name = generate_col_name()
-    col = await test_db.create_collection(col_name)
+    col = await db.create_collection(col_name)
     assert isinstance(col, StandardCollection)
-    assert await test_db.has_collection(col_name)
-    cols = await test_db.collections()
+    assert await db.has_collection(col_name)
+    cols = await db.collections()
     assert any(c.name == col_name for c in cols)
 
+    # Try to create a collection that already exists
+    with pytest.raises(CollectionCreateError):
+        await db.create_collection(col_name)
+
+    # Try collection methods from a non-existent db
+    with pytest.raises(CollectionCreateError):
+        await bad_db.create_collection(generate_col_name())
+    with pytest.raises(CollectionListError):
+        await bad_db.collections()
+    with pytest.raises(CollectionListError):
+        await bad_db.has_collection(col_name)
+
+    # Try to create a collection with invalid args
+    with pytest.raises(ValueError):
+        await db.create_collection(generate_col_name(), col_type="invalid")
+    with pytest.raises(ValueError):
+        await db.create_collection(generate_col_name(), col_type=db)
+    with pytest.raises(ValueError):
+        await db.create_collection(generate_col_name(), key_options={})
+
     # Drop the newly created collection
-    assert await test_db.delete_collection(col_name) is True
-    assert not await test_db.has_collection(col_name)
+    assert await db.delete_collection(col_name) is True
+    assert not await db.has_collection(col_name)
     non_existent_col = generate_col_name()
-    assert await test_db.has_collection(non_existent_col) is False
-    assert (
-        await test_db.delete_collection(non_existent_col, ignore_missing=True) is False
-    )
+    assert await db.has_collection(non_existent_col) is False
+    assert await db.delete_collection(non_existent_col, ignore_missing=True) is False
+
+    # Do not ignore missing collection
+    with pytest.raises(CollectionDeleteError):
+        await db.delete_collection(non_existent_col)
+
+    # Multiple arguments in a cluster setup
+    if cluster:
+        schema = {
+            "rule": {
+                "type": "object",
+                "properties": {
+                    "test_attr:": {"type": "string"},
+                },
+                "required": ["test_attr"],
+            },
+            "level": "moderate",
+            "message": "Schema Validation Failed.",
+            "type": "json",
+        }
+
+        computed_values = [
+            {
+                "name": "foo",
+                "expression": "RETURN 1",
+                "computeOn": ["insert", "update", "replace"],
+                "overwrite": True,
+                "failOnWarning": False,
+                "keepNull": True,
+            }
+        ]
+
+        col = await db.create_collection(
+            col_name,
+            col_type=CollectionType.DOCUMENT,
+            write_concern=2,
+            wait_for_sync=True,
+            number_of_shards=1,
+            is_system=False,
+            computed_values=computed_values,
+            schema=schema,
+            key_options=KeyOptions(
+                allow_user_keys=True,
+                generator_type="autoincrement",
+                increment=5,
+                offset=10,
+            ),
+        )
+        assert col.name == col_name
+        assert await db.delete_collection(col_name) is True

tests/test_document.py

@@ -0,0 +1,31 @@
+import pytest
+
+from arangoasync.exceptions import DocumentParseError
+from tests.helpers import generate_col_name
+
+
+@pytest.mark.asyncio
+async def test_document_insert(doc_col, docs):
+    # Test insert document with no key
+    result = await doc_col.insert({})
+    assert await doc_col.get(result["_key"]) is not None
+
+    # Test insert document with ID
+    doc_id = f"{doc_col.name}/foo"
+    result = await doc_col.insert({"_id": doc_id})
+    assert doc_id == result["_id"]
+    assert result["_key"] == "foo"
+    assert await doc_col.get("foo") is not None
+    assert await doc_col.get(doc_id) is not None
+
+    with pytest.raises(DocumentParseError) as err:
+        await doc_col.insert({"_id": f"{generate_col_name()}/foo"})
+    assert "Bad collection name" in err.value.message
+
+    # Test insert with default options
+    for doc in docs:
+        result = await doc_col.insert(doc)
+        assert result["_id"] == f"{doc_col.name}/{doc['_key']}"
+        assert result["_key"] == doc["_key"]
+        assert isinstance(result["_rev"], str)
+        assert (await doc_col.get(doc["_key"]))["val"] == doc["val"]