Improve loader tests to handle various scenarios

Author: garlontas

tests/_loaders/test_csv_loader.py

@@ -1,6 +1,5 @@
 # pylint: disable=not-context-manager
 from unittest import TestCase
-
 from _loaders.file_test import LoaderTestBase
 from pystreamapi.loaders import csv
 
@@ -16,13 +15,19 @@ def setUp(self):
 
     def _assert_typed_rows(self, data):
         """Assert that the two expected rows are present with correct types and values."""
-        first = next(data)
+        try:
+            first = next(data)
+        except StopIteration:
+            self.fail("Expected first row but iterator was empty")
         self.assertEqual(first.attr1, 1)
         self.assertIsInstance(first.attr1, int)
         self.assertEqual(first.attr2, 2.0)
         self.assertIsInstance(first.attr2, float)
 
-        second = next(data)
+        try:
+            second = next(data)
+        except StopIteration:
+            self.fail("Expected second row but iterator was exhausted after first row")
         self.assertEqual(second.attr1, 'a')
         self.assertIsInstance(second.attr1, str)
         self.assertEqual(second.attr2, 'b')
@@ -38,7 +43,10 @@ def test_csv_loader_basic_functionality(self):
     def test_csv_loader_without_type_casting(self):
         """Test CSV loading with type casting disabled."""
         with self.mock_file(self.file_content):
-            first = next(csv(self.file_path, cast_types=False))
+            try:
+                first = next(csv(self.file_path, cast_types=False))
+            except StopIteration:
+                self.fail("Expected first row but iterator was empty")
             self.assertEqual(first.attr1, '1')
             self.assertIsInstance(first.attr1, str)
             self.assertEqual(first.attr2, '2.0')
@@ -53,7 +61,10 @@ def test_csv_loader_custom_delimiter(self):
         """Test CSV loading with a custom delimiter."""
         content_with_semicolon = self.file_content.replace(",", ";")
         with self.mock_file(content_with_semicolon):
-            first = next(csv(self.file_path, delimiter=';'))
+            try:
+                first = next(csv(self.file_path, delimiter=';'))
+            except StopIteration:
+                self.fail("Expected first row but iterator was empty")
             self.assertEqual(first.attr1, 1)
             self.assertEqual(first.attr2, 2.0)
 

tests/_loaders/test_json_loader.py

@@ -20,25 +20,30 @@
   }
 ]
 """
+
+single_object_content = """
+{
+  "attr1": 1,
+  "attr2": 2.0
+}
+"""
+
 file_path = 'path/to/data.json'
 
 
 class TestJsonLoader(LoaderTestBase, TestCase):
 
     def test_json_loader_from_file(self):
         with self.mock_file(file_content):
-            data = json(file_path)
-            self._check_extracted_data(data)
+            self._check_extracted_data(json(file_path))
 
     def test_json_loader_is_iterable(self):
         with self.mock_file(file_content):
-            data = json(file_path)
-            self.assertEqual(len(list(iter(data))), 2)
+            self.assertEqual(len(list(iter(json(file_path)))), 2)
 
     def test_json_loader_with_empty_file(self):
         with self.mock_file(""):
-            data = json(file_path)
-            self.assertRaises(StopIteration, next, data)
+            self.assertRaises(StopIteration, next, json(file_path))
 
     def test_json_loader_with_invalid_path(self):
         with self.assertRaises(FileNotFoundError):
@@ -49,30 +54,49 @@ def test_json_loader_with_no_file(self):
             json('../')
 
     def test_json_loader_from_string(self):
-        data = json(file_content, read_from_src=True)
-        self._check_extracted_data(data)
+        self._check_extracted_data(json(file_content, read_from_src=True))
 
     def test_json_loader_from_empty_string(self):
         self.assertRaises(StopIteration, next, json("", read_from_src=True))
 
+    def test_json_loader_single_object_from_file(self):
+        """Test that a single JSON object (not array) is yielded as one namedtuple."""
+        with self.mock_file(single_object_content):
+            data = json(file_path)
+            try:
+                first = next(data)
+            except StopIteration:
+                self.fail("Expected one row but iterator was empty")
+            self.assertEqual(first.attr1, 1)
+            self.assertEqual(first.attr2, 2.0)
+            self.assertRaises(StopIteration, next, data)
+
+    def test_json_loader_single_object_from_string(self):
+        """Test that a single JSON object string is yielded as one namedtuple."""
+        data = json(single_object_content, read_from_src=True)
+        try:
+            first = next(data)
+        except StopIteration:
+            self.fail("Expected one row but iterator was empty")
+        self.assertEqual(first.attr1, 1)
+        self.assertEqual(first.attr2, 2.0)
+        self.assertRaises(StopIteration, next, data)
+
     def _check_extracted_data(self, data):
-        # Test first row
         try:
             first = next(data)
         except StopIteration:
-            return
+            self.fail("Expected first row but iterator was empty")
         self.assertEqual(first.attr1, 1)
         self.assertIsInstance(first.attr1, int)
         self.assertEqual(first.attr2, 2.0)
         self.assertIsInstance(first.attr2, float)
 
-        # Test second row
         try:
             second = next(data)
         except StopIteration:
-            return
+            self.fail("Expected second row but iterator was exhausted after first row")
         self.assertEqual(second.attr1[0].attr1, 'a')
         self.assertIsInstance(second.attr1, list)
 
-        # Verify end of file
         self.assertRaises(StopIteration, next, data)

tests/_loaders/test_yaml_loader.py

@@ -22,18 +22,15 @@ class TestYamlLoader(LoaderTestBase, TestCase):
 
     def test_yaml_loader_from_file(self):
         with self.mock_file(file_content):
-            data = yaml(file_path)
-            self._check_extracted_data(data)
+            self._check_extracted_data(yaml(file_path))
 
     def test_yaml_loader_is_iterable(self):
         with self.mock_file(file_content):
-            data = yaml(file_path)
-            self.assertEqual(len(list(iter(data))), 2)
+            self.assertEqual(len(list(iter(yaml(file_path)))), 2)
 
     def test_yaml_loader_with_empty_file(self):
         with self.mock_file(""):
-            data = yaml(file_path)
-            self.assertEqual(len(list(data)), 0)
+            self.assertEqual(len(list(yaml(file_path))), 0)
 
     def test_yaml_loader_with_invalid_path(self):
         with self.assertRaises(FileNotFoundError):
@@ -44,35 +41,47 @@ def test_yaml_loader_with_no_file(self):
             yaml('../')
 
     def test_yaml_loader_from_string(self):
-        data = yaml(file_content, read_from_src=True)
-        self._check_extracted_data(data)
+        self._check_extracted_data(yaml(file_content, read_from_src=True))
 
     def test_yaml_loader_from_empty_string(self):
         self.assertEqual(list(yaml('', read_from_src=True)), [])
 
     def test_yaml_loader_is_lazy(self):
         with self.mock_file(file_content):
-            data = yaml(file_path)
-            self.assertIsInstance(data, GeneratorType)
+            self.assertIsInstance(yaml(file_path), GeneratorType)
 
     def test_yaml_loader_with_malformed_yaml(self):
-        malformed_yaml = "key: : invalid"
         with self.assertRaises(yaml_lib.YAMLError):
-            list(yaml(malformed_yaml, read_from_src=True))
+            list(yaml("key: : invalid", read_from_src=True))
+
+    def test_yaml_loader_skips_null_document(self):
+        """Test that a null/~ document (falsy) is silently skipped."""
+        with self.mock_file("~"):
+            self.assertEqual(list(yaml(file_path)), [])
+        self.assertEqual(list(yaml("~", read_from_src=True)), [])
+
+    def test_yaml_loader_skips_empty_document_in_stream(self):
+        """Test that an empty document in a multi-document stream is silently skipped."""
+        content = "---\n- attr1: 1\n---\n"  # second document is empty
+        with self.mock_file(content):
+            self.assertEqual(len(list(yaml(file_path))), 1)
+        self.assertEqual(len(list(yaml(content, read_from_src=True))), 1)
 
     def _check_extracted_data(self, data):
         try:
             first = next(data)
         except StopIteration:
-            return
+            self.fail("Expected first row but iterator was empty")
         self.assertEqual(first.attr1, 1)
         self.assertIsInstance(first.attr1, int)
         self.assertEqual(first.attr2, 2.0)
         self.assertIsInstance(first.attr2, float)
+
         try:
             second = next(data)
         except StopIteration:
-            return
+            self.fail("Expected second row but iterator was exhausted after first row")
         self.assertIsInstance(second.attr1, list)
         self.assertEqual(second.attr1[0].attr1, 'a')
+
         self.assertRaises(StopIteration, next, data)