get test suite running

Author: blink1073

bindings/python/pymongoarrow/api.py

@@ -84,8 +84,8 @@ def find_arrow_all(collection, query, *, schema=None, **kwargs):
         against which to run the ``find`` operation.
       - `query`: A mapping containing the query to use for the find operation.
       - `schema` (optional): Instance of :class:`~pymongoarrow.schema.Schema`.
-        If the schema is not given, it will be inferred using the first
-        document in the result set.
+        If the schema is not given, it will be inferred using the data in the
+        result set.
 
     Additional keyword-arguments passed to this method will be passed
     directly to the underlying ``find`` operation.
@@ -122,8 +122,8 @@ def aggregate_arrow_all(collection, pipeline, *, schema=None, **kwargs):
         against which to run the ``aggregate`` operation.
       - `pipeline`: A list of aggregation pipeline stages.
       - `schema` (optional): Instance of :class:`~pymongoarrow.schema.Schema`.
-        If the schema is not given, it will be inferred using the first
-        document in the result set.
+        If the schema is not given, it will be inferred using the data in the
+        result set.
 
     Additional keyword-arguments passed to this method will be passed
     directly to the underlying ``aggregate`` operation.
@@ -177,8 +177,8 @@ def find_pandas_all(collection, query, *, schema=None, **kwargs):
         against which to run the ``find`` operation.
       - `query`: A mapping containing the query to use for the find operation.
       - `schema` (optional): Instance of :class:`~pymongoarrow.schema.Schema`.
-        If the schema is not given, it will be inferred using the first
-        document in the result set.
+        If the schema is not given, it will be inferred using the data in the
+        result set.
 
     Additional keyword-arguments passed to this method will be passed
     directly to the underlying ``find`` operation.
@@ -198,8 +198,8 @@ def aggregate_pandas_all(collection, pipeline, *, schema=None, **kwargs):
         against which to run the ``find`` operation.
       - `pipeline`: A list of aggregation pipeline stages.
       - `schema` (optional): Instance of :class:`~pymongoarrow.schema.Schema`.
-        If the schema is not given, it will be inferred using the first
-        document in the result set.
+        If the schema is not given, it will be inferred using the data in the
+        result set.
 
     Additional keyword-arguments passed to this method will be passed
     directly to the underlying ``aggregate`` operation.
@@ -240,8 +240,8 @@ def find_numpy_all(collection, query, *, schema=None, **kwargs):
         against which to run the ``find`` operation.
       - `query`: A mapping containing the query to use for the find operation.
       - `schema` (optional): Instance of :class:`~pymongoarrow.schema.Schema`.
-        If the schema is not given, it will be inferred using the first
-        document in the result set.
+        If the schema is not given, it will be inferred using the data in the
+        result set.
 
     Additional keyword-arguments passed to this method will be passed
     directly to the underlying ``find`` operation.
@@ -271,8 +271,8 @@ def aggregate_numpy_all(collection, pipeline, *, schema=None, **kwargs):
         against which to run the ``find`` operation.
       - `query`: A mapping containing the query to use for the find operation.
       - `schema` (optional): Instance of :class:`~pymongoarrow.schema.Schema`.
-        If the schema is not given, it will be inferred using the first
-        document in the result set.
+        If the schema is not given, it will be inferred using the data in the
+        result set.
 
     Additional keyword-arguments passed to this method will be passed
     directly to the underlying ``aggregate`` operation.
@@ -338,8 +338,8 @@ def find_polars_all(collection, query, *, schema=None, **kwargs):
         against which to run the ``find`` operation.
       - `query`: A mapping containing the query to use for the find operation.
       - `schema` (optional): Instance of :class:`~pymongoarrow.schema.Schema`.
-        If the schema is not given, it will be inferred using the first
-        document in the result set.
+        If the schema is not given, it will be inferred using the data in the
+        result set.
 
     Additional keyword-arguments passed to this method will be passed
     directly to the underlying ``find`` operation.
@@ -361,8 +361,8 @@ def aggregate_polars_all(collection, pipeline, *, schema=None, **kwargs):
         against which to run the ``find`` operation.
       - `pipeline`: A list of aggregation pipeline stages.
       - `schema` (optional): Instance of :class:`~pymongoarrow.schema.Schema`.
-        If the schema is not given, it will be inferred using the first
-        document in the result set.
+        If the schema is not given, it will be inferred using the data in the
+        result set.
 
     Additional keyword-arguments passed to this method will be passed
     directly to the underlying ``aggregate`` operation.

bindings/python/pyproject.toml

@@ -95,9 +95,8 @@ archs = "x86_64 arm64"
 [tool.pytest.ini_options]
 minversion = "7"
 addopts = ["-ra", "--strict-config", "--strict-markers", "--durations=5", "--junitxml=xunit-results/TEST-results.xml"]
-testpaths = ["test", "test/pandas_types"]
+testpaths = ["test"]
 log_cli_level = "INFO"
-norecursedirs = ["test/*"]
 faulthandler_timeout = 1500
 xfail_strict = true
 filterwarnings = [

bindings/python/test/test_arrow.py

@@ -74,6 +74,7 @@ def setUpClass(cls):
         cls.coll = cls.client.pymongoarrow_test.get_collection(
             "test", write_concern=WriteConcern(w="majority")
         )
+        cls.addClassCleanup(cls.client.close)
 
     def setUp(self):
         self.coll.drop()
@@ -113,6 +114,14 @@ def test_find_simple(self):
         self.assertEqual(find_cmd.command_name, "find")
         self.assertEqual(find_cmd.command["projection"], {"_id": True, "data": True})
 
+    def test_find_repeat_type(self):
+        expected = Table.from_pydict(
+            {"_id": [1, 2, 3, 4], "data": [10, 20, 30, None]},
+            ArrowSchema([("_id", int32()), ("data", int32())]),
+        )
+        table = self.run_find({}, schema=Schema({"_id": int32(), "data": int32()}))
+        self.assertEqual(table, expected)
+
     def test_find_with_projection(self):
         expected = Table.from_pydict(
             {"_id": [4, 3], "data": [None, 60]},
@@ -266,18 +275,19 @@ def test_pymongo_error(self):
             },
             ArrowSchema(schema),
         )
-
+        client = MongoClient(
+            host="somedomainthatdoesntexist.org",
+            port=123456789,
+            serverSelectionTimeoutMS=10,
+        )
         with self.assertRaises(ArrowWriteError) as exc:
             write(
-                MongoClient(
-                    host="somedomainthatdoesntexist.org",
-                    port=123456789,
-                    serverSelectionTimeoutMS=10,
-                ).pymongoarrow_test.get_collection(
+                client.pymongoarrow_test.get_collection(
                     "test", write_concern=WriteConcern(w="majority")
                 ),
                 data,
             )
+        client.close()
         self.assertEqual(
             exc.exception.details.keys(),
             {"nInserted", "writeConcernErrors", "writeErrors"},
@@ -840,6 +850,7 @@ def setUpClass(cls):
         cls.client = client_context.get_client(
             event_listeners=[cls.getmore_listener, cls.cmd_listener]
         )
+        cls.addClassCleanup(cls.client.close)
 
     def test_find_decimal128(self):
         oids = list(ObjectId() for i in range(4))

bindings/python/test/test_datetime.py

@@ -44,6 +44,9 @@ def setUp(self):
         for doc in self.coll.find({}, sort=[("_id", ASCENDING)]):
             self.expected_times.append(doc["data"])
 
+    def tearDown(self):
+        self.client.close()
+
     def test_context_creation_fails_with_unsupported_granularity(self):
         unsupported_granularities = ["s", "us", "ns"]
         for g in unsupported_granularities:

bindings/python/test/test_numpy.py

@@ -42,6 +42,10 @@ def setUpClass(cls):
         )
         cls.schema = {}
 
+    @classmethod
+    def tearDownClass(cls):
+        cls.client.close()
+
     def assert_numpy_equal(self, actual, expected):
         self.assertIsInstance(actual, dict)
         for field in expected:

bindings/python/test/test_pandas.py

@@ -47,6 +47,10 @@ def setUpClass(cls):
             event_listeners=[cls.getmore_listener, cls.cmd_listener]
         )
 
+    @classmethod
+    def tearDownClass(cls):
+        cls.client.close()
+
 
 class TestExplicitPandasApi(PandasTestBase):
     @classmethod

bindings/python/test/test_polars.py

@@ -50,6 +50,7 @@ def setUpClass(cls):
             event_listeners=[cls.getmore_listener, cls.cmd_listener],
             uuidRepresentation="standard",
         )
+        cls.addClassCleanup(cls.client.close)
 
 
 class TestExplicitPolarsApi(PolarsTestBase):
@@ -182,11 +183,11 @@ def test_polars_types(self):
             "Boolean": pl.Series([True, False, None]),
         }
 
-        df_in = pl.DataFrame._from_dict(data=data, schema=pl_schema)
+        df_in = pl.from_dict(data=data, schema=pl_schema)
         self.coll.drop()
         write(self.coll, df_in)
         df_out = find_polars_all(self.coll, {}, schema=Schema(pa_schema))
-        pl.testing.assert_frame_equal(df_in, df_out.drop("_id"))
+        pl.testing.assert_frame_equal(df_in, df_out)
 
     def test_extension_types_fail(self):
         """Confirm failure on ExtensionTypes for Polars.DataFrame.from_arrow"""
@@ -264,10 +265,9 @@ def test_exceptions_for_unsupported_polar_types(self):
         class MyObject:
             pass
 
-        with self.assertRaises(pl.PolarsPanicError) as exc:
+        with self.assertRaises(pl.exceptions.PanicException) as exc:
             df_in = pl.DataFrame(data=[MyObject()] * 2)
             write(self.coll, df_in)
-        self.assertTrue("not implemented" in exc.exception.args[0])
 
     def test_polars_binary_type(self):
         """Demonstrates that binary data is not yet supported. TODO [ARROW-214]
@@ -393,5 +393,5 @@ def test_bson_types(self):
             try:
                 dfpl = pl.from_arrow(table.drop("_id"))
                 assert dfpl["value"].dtype == data_type["ptype"]
-            except pl.ComputeError:
+            except pl.exceptions.ComputeError:
                 assert isinstance(table["value"].type, pa.ExtensionType)

bindings/python/test/test_pymongoarrow.py

@@ -26,6 +26,10 @@ def setUpClass(cls):
             raise unittest.SkipTest("cannot connect to MongoDB")
         cls.client = client_context.get_client()
 
+    @classmethod
+    def tearDownClass(cls):
+        cls.client.close()
+
     def test_version(self):
         self.assertIsNotNone(__version__)
         self.assertIsInstance(__version__, str)