test: added tests cases for decorator

Author: mahimairaja

tests/resources/test_answer.py

@@ -76,12 +76,12 @@ def test_generate_answer_with_prompts(client, mocker, mock_response):
 @pytest.mark.parametrize(
     "ns, q, tk, model, temp, history, msg",
     [
-        ("", "q", 5, "m", 0.5, [], "'namespace' must be a non-empty string"),
-        (None, "q", 5, "m", 0.5, [], "'namespace' must be a non-empty string"),
-        ("ns", "", 5, "m", 0.5, [], "'query' must be a non-empty string"),
+        ("", "q", 5, "m", 0.5, [], "Argument 'namespace' cannot be empty."),
+        (None, "q", 5, "m", 0.5, [], "Argument 'namespace' cannot be None."),
+        ("ns", "", 5, "m", 0.5, [], "Argument 'query' cannot be empty."),
         ("ns", "q", 0, "m", 0.5, [], "'top_k' must be a positive integer"),
         ("ns", "q", -1, "m", 0.5, [], "'top_k' must be a positive integer"),
-        ("ns", "q", 5, "", 0.5, [], "'ai_model' must be a non-empty string"),
+        ("ns", "q", 5, "", 0.5, [], "Argument 'ai_model' cannot be empty."),
         (
             "ns",
             "q",

tests/resources/test_namespaces.py

@@ -84,8 +84,8 @@ def test_create_namespace_conflict(client, mocker, mock_response):
 @pytest.mark.parametrize(
     "name, ns_type, dim, expected_error_msg",
     [
-        ("", "text", None, "'namespace_name' must be a non-empty string"),
-        (None, "text", None, "'namespace_name' must be a non-empty string"),
+        ("", "text", None, "Argument 'namespace_name' cannot be empty."),
+        (None, "text", None, "Argument 'namespace_name' cannot be None."),
         ("test", "invalid_type", None, "Namespace type must be 'text' or 'vector'"),
         (
             "test",
@@ -250,11 +250,20 @@ def test_delete_namespace_not_found(client, mocker, mock_response):
     client._mock_httpx_instance.request.assert_called_once()
 
 
-@pytest.mark.parametrize("invalid_name", ["", None, 123])
-def test_delete_namespace_invalid_name_client_side(client, invalid_name):
+@pytest.mark.parametrize(
+    "invalid_name, expected_error",
+    [
+        ("", "Argument 'namespace_name' cannot be empty."),
+        (None, "Argument 'namespace_name' cannot be None."),
+        (123, "Argument 'namespace_name' must be of type <class 'str'>."),
+    ],
+)
+def test_delete_namespace_invalid_name_client_side(
+    client, invalid_name, expected_error
+):
     """Test client-side validation for delete_namespace name."""
-    with pytest.raises(
-        InvalidInputError, match="'namespace_name' must be a non-empty string"
-    ):
+    import re
+
+    with pytest.raises(InvalidInputError, match=re.escape(expected_error)):
         client.namespaces.delete(invalid_name)
     client._mock_httpx_instance.request.assert_not_called()

tests/utils/test_decorators.py

@@ -0,0 +1,84 @@
+import pytest
+
+from moorcheh_sdk.exceptions import InvalidInputError
+from moorcheh_sdk.utils.decorators import required_args
+
+
+class TestClass:
+    @required_args(["a", "b"], types={"a": int, "b": str})
+    def method(self, a, b, c=None):
+        return a, b, c
+
+
+def test_required_args_success():
+    """Test that the decorator allows valid arguments."""
+    obj = TestClass()
+    assert obj.method(1, "test") == (1, "test", None)
+    assert obj.method(a=1, b="test", c="optional") == (1, "test", "optional")
+
+
+def test_required_args_missing_arg():
+    """Test that missing required arguments raise TypeError (caught and re-raised as InvalidInputError)."""
+    obj = TestClass()
+    # If an argument is missing from the call, python's bind will raise TypeError
+    with pytest.raises(InvalidInputError):
+        obj.method(a=1)
+
+
+def test_required_args_none_value():
+    """Test that None values for required arguments raise InvalidInputError."""
+    obj = TestClass()
+    with pytest.raises(InvalidInputError, match="Argument 'a' cannot be None."):
+        obj.method(a=None, b="test")
+
+    with pytest.raises(InvalidInputError, match="Argument 'b' cannot be None."):
+        obj.method(a=1, b=None)
+
+
+def test_required_args_empty_value():
+    """Test that empty values for string/list arguments raise InvalidInputError."""
+    obj = TestClass()
+    with pytest.raises(InvalidInputError, match="Argument 'b' cannot be empty."):
+        obj.method(a=1, b="")
+
+
+def test_required_args_wrong_type():
+    """Test that arguments with wrong types raise InvalidInputError."""
+    obj = TestClass()
+    with pytest.raises(
+        InvalidInputError, match="Argument 'a' must be of type <class 'int'>."
+    ):
+        obj.method(a="not an int", b="test")
+
+    with pytest.raises(
+        InvalidInputError, match="Argument 'b' must be of type <class 'str'>."
+    ):
+        obj.method(a=1, b=123)
+
+
+def test_required_args_allow_zero_false():
+    """Test that 0 and False are not considered empty."""
+
+    @required_args(["num", "flag"], types={"num": int, "flag": bool})
+    def func(num, flag):
+        return num, flag
+
+    assert func(0, False) == (0, False)
+
+
+def test_required_args_list_validation():
+    """Test validation for list types."""
+
+    @required_args(["items"], types={"items": list})
+    def func(items):
+        return items
+
+    assert func([1, 2]) == [1, 2]
+
+    with pytest.raises(InvalidInputError, match="Argument 'items' cannot be empty."):
+        func([])
+
+    with pytest.raises(
+        InvalidInputError, match="Argument 'items' must be of type <class 'list'>."
+    ):
+        func("not a list")