V0.13.0 tests fix (#37)

* fix some syntax errors in comprehensive tests

* fix rest of comprehensive tests

* fix api contract tests

---------

Co-authored-by: Kevin Kopczynski <kkopczynski@cyborg.co>

Author: ahellegit

tests/comprehensive_test.py

@@ -172,7 +172,7 @@ def test_ivf_index_creation_and_operations(self):
         results = self.index.query(query_vectors=[query_vector], top_k=5)
 
         self.assertGreater(len(results[0]), 0)
-        self.assertTrue("id" in results[0][0])
+        self.assertTrue("id" in results[0])
 
     def test_ivfpq_index_creation_and_operations(self):
         """Test IVFPQ index creation with PQ parameters"""
@@ -205,8 +205,10 @@ def test_ivfpq_index_creation_and_operations(self):
         query_vector = self.test_vectors[0]
         results = self.index.query(query_vectors=[query_vector], top_k=5)
 
+        
+
         self.assertGreater(len(results[0]), 0)
-        self.assertTrue("id" in results[0][0])
+        self.assertTrue("id" in results[0])
 
     def test_ivfpq_parameter_validation(self):
         """Test IVFPQ parameter validation"""
@@ -360,10 +362,10 @@ def tearDown(self):
     def test_empty_query_results(self):
         """Test handling of empty query results"""
         query_vector = np.random.rand(128).astype(np.float32)
-        results = self.index.query(query_vectors=[query_vector], top_k=10)
+        results = self.index.query(query_vectors=query_vector, top_k=10)
 
         # Should return empty results for empty index
-        self.assertEqual(len(results[0]), 0)
+        self.assertEqual(len(results), 0)
 
     def test_mismatched_parameter_lengths(self):
         """Test validation of mismatched parameter lengths"""
@@ -391,9 +393,8 @@ def test_mismatched_parameter_lengths(self):
             self.index.upsert(items_missing_vector)
 
         # Test with empty items list
-        result = self.index.upsert([])
-        # Empty upsert should succeed but insert nothing
-        self.assertIsNotNone(result)
+        with self.assertRaises(Exception):
+            result = self.index.upsert([])
 
     def test_content_preservation_through_operations(self):
         """Test that content is preserved through various operations"""
@@ -469,6 +470,26 @@ async def concurrent_upsert():
 class TestBackendCompatibility(unittest.TestCase):
     """Test backend compatibility (Lite vs Full)"""
 
+    def setUp(self):
+        self.client = create_client()
+        self.index_name = generate_unique_name()
+        self.index_key = self.client.generate_key()
+        self.index_config = cyborgdb.IndexIVFFlat(dimension=128)
+        self.index = self.client.create_index(
+            self.index_name,
+            self.index_key,
+            self.index_config,
+            metric="euclidean",
+        )
+
+    def tearDown(self):
+        """Clean up created indexes"""
+        try:
+            if self.index:
+                self.index.delete_index()
+        except Exception:
+            pass
+
     def test_lite_backend_compatibility(self):
         """Test operations with lite backend"""
         client = create_client()

tests/test_api_contract.py

@@ -703,19 +703,17 @@ def test_15_encrypted_index_query(self):
         query_vector = self.test_vectors[0]
 
         # Test query with default include (should be ["distance", "metadata"])
+        # Single query now returns results directly (not wrapped in a list)
         results = self.index.query(query_vectors=[query_vector])
 
         self.assertIsInstance(results, list)
-        self.assertEqual(len(results), 1, "Should have 1 result for 1 query")
-
-        query_results = results[0]
-        self.assertIsInstance(query_results, list)
+        # Single query returns flat list of results
         self.assertGreater(
-            len(query_results), 0, "Query should return at least one result"
+            len(results), 0, "Query should return at least one result"
         )
 
         # Check exact structure with default include - id is always included, plus distance and metadata by default
-        for result in query_results:
+        for result in results:
             self.assertIsInstance(result, dict)
             validate_exact_keys(
                 result,
@@ -755,7 +753,7 @@ def test_15_encrypted_index_query(self):
             query_vectors=[query_vector], top_k=5, include=["metadata"]
         )
 
-        for result in results[0]:
+        for result in results:
             validate_exact_keys(
                 result,
                 {"id", "distance", "metadata"},
@@ -775,7 +773,7 @@ def test_15_encrypted_index_query(self):
         # Test with empty include (should only have id and distance)
         results = self.index.query(query_vectors=[query_vector], include=["distance"])
 
-        for result in results[0]:
+        for result in results:
             validate_exact_keys(
                 result, {"id", "distance"}, "query() result with include=[]"
             )
@@ -786,7 +784,7 @@ def test_15_encrypted_index_query(self):
         )
 
         # Results should have id, distance, and metadata (default include)
-        for result in results[0]:
+        for result in results:
             validate_exact_keys(
                 result,
                 {"id", "distance", "metadata"},
@@ -817,20 +815,17 @@ def test_16_encrypted_index_query_patterns(self):
             self.assertIn("id", results[0])
             self.assertIn("distance", results[0])
 
-        # Test Pattern 2: Single vector in nested list -> nested list return
+        # Test Pattern 2: Single vector in nested list -> flat list return (API update)
         single_vector_nested = [self.test_vectors[1].tolist()]
         results = self.index.query(query_vectors=single_vector_nested, top_k=3)
 
-        # Should return list of lists (batch format)
+        # Single query now returns flat list of results directly
         self.assertIsInstance(results, list)
-        self.assertEqual(len(results), 1, "Should have 1 result list for 1 query")
-        self.assertIsInstance(
-            results[0], list, "Batch query should return nested lists"
-        )
-        if len(results[0]) > 0:
-            self.assertIsInstance(results[0][0], dict, "Each result should be a dict")
-            self.assertIn("id", results[0][0])
-            self.assertIn("distance", results[0][0])
+        self.assertGreater(len(results), 0, "Should have results for single query")
+        if len(results) > 0:
+            self.assertIsInstance(results[0], dict, "Single query should return flat list of dicts")
+            self.assertIn("id", results[0])
+            self.assertIn("distance", results[0])
 
         # Test Pattern 3: Multiple vectors -> multiple result lists
         multiple_vectors = [
@@ -903,7 +898,7 @@ def test_16_encrypted_index_query_patterns(self):
             )
 
         # Test Pattern 6: Text-based query with query_contents
-        # Single text query
+        # Single text query (returns flat list directly)
         text_query = "test content for similarity search"
         results = self.index.query(query_contents=text_query, top_k=3)