Resolve new comments

Signed-off-by: Yunxuan Shi <yunxuan@amazon.com>

Author: eerxuan

README.md

@@ -277,7 +277,7 @@ from tests.common.assertions import (
 assert_document_match(actual, expected, ignore_id=True)
 
 # Compare lists of documents
-assert_documents_match(actual_list, expected_list, ignore_order=True)
+assert_documents_match(actual_list, expected_list, ignore_doc_order=True)
 
 # Check field existence
 assert_field_exists(document, "user.name")

documentdb_tests/compatibility/tests/core/collections/capped_collections/test_capped_collections_create.py

@@ -8,13 +8,11 @@
 import pytest
 
 from documentdb_tests.framework.executor import execute_command
-from documentdb_tests.framework.assertions import assertSuccess
+from documentdb_tests.framework.assertions import assertSuccessPartial
 
 
 @pytest.mark.collection_mgmt
 def test_create_capped_collection(collection):
     """Test creating a capped collection."""
-    db = collection.database
-    result = execute_command(collection, {"create": "capped_test", "capped": True, "size": 100000})
-    assertSuccess(result, {"ok": 1.0}, "Should create capped collection", raw_res=True, transform=lambda r: {"ok": r["ok"]})
-    db.drop_collection("capped_test")
+    result = execute_command(collection, {"create": collection.name + "_capped", "capped": True, "size": 100000})
+    assertSuccessPartial(result, {"ok": 1.0}, "Should create capped collection")

documentdb_tests/compatibility/tests/core/operator/stages/group/test_group_stage.py

@@ -20,13 +20,14 @@ def test_group_with_count(collection):
         {"a": "B", "b": 80},
         {"a": "B", "b": 75},
     ])
-    result = execute_command(collection, {"aggregate": collection.name, "pipeline": [{"$group": {"_id": "$a", "count": {"$sum": 1}}}], "cursor": {}})
-    
+    pipeline = [{"$group": {"_id": "$a", "count": {"$sum": 1}}}]
+    result = execute_command(collection, {"aggregate": collection.name, "pipeline": pipeline, "cursor": {}})
+
     expected = [
         {"_id": "A", "count": 2},
         {"_id": "B", "count": 2}
     ]
-    assertSuccess(result, expected, "Should group and count by department", ignore_order=True)
+    assertSuccess(result, expected, "Should group and count by a", ignore_doc_order=True)
 
 
 @pytest.mark.aggregate
@@ -37,30 +38,32 @@ def test_group_with_sum(collection):
         {"a": "A", "b": 90},
         {"a": "B", "b": 80},
     ])
-    result = execute_command(collection, {"aggregate": collection.name, "pipeline": [{"$group": {"_id": "$a", "total": {"$sum": "$b"}}}], "cursor": {}})
-    
+    pipeline = [{"$group": {"_id": "$a", "total": {"$sum": "$b"}}}]
+    result = execute_command(collection, {"aggregate": collection.name, "pipeline": pipeline, "cursor": {}})
+
     expected = [
         {"_id": "A", "total": 190},
         {"_id": "B", "total": 80}
     ]
-    assertSuccess(result, expected, "Should sum by group", ignore_order=True)
+    assertSuccess(result, expected, "Should sum by group", ignore_doc_order=True)
 
 
 @pytest.mark.aggregate
 def test_group_with_avg(collection):
     """Test $group stage with average aggregation."""
     collection.insert_many([
-        {"a": "A", "b": 100},
+        {"a": "B", "b": 100},
         {"a": "A", "b": 90},
         {"a": "B", "b": 80},
     ])
-    result = execute_command(collection, {"aggregate": collection.name, "pipeline": [{"$group": {"_id": "$a", "avg": {"$avg": "$b"}}}], "cursor": {}})
-    
+    pipeline = [{"$group": {"_id": "$a", "avg": {"$avg": "$b"}}}]
+    result = execute_command(collection, {"aggregate": collection.name, "pipeline": pipeline, "cursor": {}})
+
     expected = [
         {"_id": "A", "avg": 95.0},
         {"_id": "B", "avg": 80.0}
     ]
-    assertSuccess(result, expected, "Should calculate average by group", ignore_order=True)
+    assertSuccess(result, expected, "Should calculate average by group", ignore_doc_order=True)
 
 
 @pytest.mark.aggregate
@@ -71,13 +74,14 @@ def test_group_with_min_max(collection):
         {"a": "A", "b": 90},
         {"a": "B", "b": 80},
     ])
-    result = execute_command(collection, {"aggregate": collection.name, "pipeline": [{"$group": {"_id": "$a", "min": {"$min": "$b"}, "max": {"$max": "$b"}}}], "cursor": {}})
-    
+    pipeline = [{"$group": {"_id": "$a", "min": {"$min": "$b"}, "max": {"$max": "$b"}}}]
+    result = execute_command(collection, {"aggregate": collection.name, "pipeline": pipeline, "cursor": {}})
+
     expected = [
         {"_id": "A", "min": 90, "max": 100},
         {"_id": "B", "min": 80, "max": 80}
     ]
-    assertSuccess(result, expected, "Should find min and max by group", ignore_order=True)
+    assertSuccess(result, expected, "Should find min and max by group", ignore_doc_order=True)
 
 
 @pytest.mark.aggregate
@@ -88,7 +92,8 @@ def test_group_all_documents(collection):
         {"a": "B", "b": 10},
         {"a": "A", "b": 3},
     ])
-    result = execute_command(collection, {"aggregate": collection.name, "pipeline": [{"$group": {"_id": None, "total": {"$sum": "$b"}}}], "cursor": {}})
-    
+    pipeline = [{"$group": {"_id": None, "total": {"$sum": "$b"}}}]
+    result = execute_command(collection, {"aggregate": collection.name, "pipeline": pipeline, "cursor": {}})
+
     expected = [{"_id": None, "total": 18}]
     assertSuccess(result, expected, "Should sum across all documents")

documentdb_tests/compatibility/tests/core/operator/stages/match/test_match_stage.py

@@ -51,13 +51,12 @@ def test_match_multiple_conditions(collection):
     collection.insert_many([
         {"_id": 0, "a": "A", "b": 30, "c": "NYC"},
         {"_id": 1, "a": "B", "b": 25, "c": "SF"},
-        {"_id": 2, "a": "C", "b": 35, "c": "NYC"},
+        {"_id": 2, "a": "C", "b": 35, "c": "SF"},
     ])
     result = execute_command(collection, {"aggregate": collection.name, "pipeline": [{"$match": {"c": "NYC", "b": {"$gte": 30}}}], "cursor": {}})
 
     expected = [
-        {"_id": 0, "a": "A", "b": 30, "c": "NYC"},
-        {"_id": 2, "a": "C", "b": 35, "c": "NYC"}
+        {"_id": 0, "a": "A", "b": 30, "c": "NYC"}
     ]
     assertSuccess(result, expected, "Should match multiple conditions")
 

documentdb_tests/framework/assertions.py

@@ -22,7 +22,7 @@ def _format_exception_error(result: Exception) -> str:
     return f"[UNEXPECTED_ERROR] Expected success but got exception:\n{pprint.pformat({'code': code, 'msg': msg}, width=100)}\n"
 
 
-def assertSuccess(result: Union[Any, Exception], expected: Any, msg: str = None, raw_res: bool = False, transform: Optional[Callable] = None, ignore_order: bool = False):
+def assertSuccess(result: Union[Any, Exception], expected: Any, msg: str = None, raw_res: bool = False, transform: Optional[Callable] = None, ignore_doc_order: bool = False):
     """
     Assert command succeeded and optionally check result.
 
@@ -32,7 +32,7 @@ def assertSuccess(result: Union[Any, Exception], expected: Any, msg: str = None,
         msg: Custom assertion message (optional)
         raw_res: If asserting raw result. False by default, only compare content of ["cursor"]["firstBatch"]
         transform: Optional callback to transform result before comparison
-        ignore_order: If True, compare lists as sets (order-independent)
+        ignore_doc_order: If True, compare lists as sets (order-independent)
     """
     if isinstance(result, Exception):
         if isinstance(result, _INFRA_TYPES):
@@ -51,7 +51,7 @@ def assertSuccess(result: Union[Any, Exception], expected: Any, msg: str = None,
     error_text += f"\n\nExpected:\n{pprint.pformat(expected, width=100)}"
     error_text += f"\n\nActual:\n{pprint.pformat(result, width=100)}\n"
 
-    if ignore_order and isinstance(result, list) and isinstance(expected, list):
+    if ignore_doc_order and isinstance(result, list) and isinstance(expected, list):
         assert sorted(result, key=lambda x: str(x)) == sorted(expected, key=lambda x: str(x)), error_text
     else:
         assert result == expected, error_text