Improve test coverage for import/export flows

* Improve test coverage for import flows

- Add test_run_import_fail_mode_no_records: Test fail mode when fail
file has no records - Add test_run_import_sort_strategy_already_sorted:
Test sort strategy with already sorted file - Add
test_run_import_invalid_json_type_context: Test handling of non-dict
JSON context - Add test_run_import_with_relational_strategy: Test
relational import strategies in Pass 2 - Add
test_run_import_fails_without_creating_fail_file: Test failure path
without fail file creation

These new tests improve coverage for edge cases and error handling in
the import flows.

* Fixup failling tests

* Fix typeguard issues in import tests and improve type safety
- Fix typeguard error in test_run_import_invalid_json_type_context by using proper typing
- Improve type safety in run_import function by separating json.loads() result from typed variable\n- Ensure all 385 tests pass with typeguard enabled
- Maintain all existing functionality while improving code quality

* Improve coverage export_threaded


---------

Co-authored-by: bosd <5e2fd43-d292-4c90-9d1f-74ff3436329a@anonaddy.me>

Author: bosd

src/odoo_data_flow/importer.py

@@ -113,9 +113,10 @@ def run_import(  # noqa: C901
     parsed_context: dict[str, Any]
     if isinstance(context, str):
         try:
-            parsed_context = json.loads(context)
-            if not isinstance(parsed_context, dict):
+            loaded_context = json.loads(context)
+            if not isinstance(loaded_context, dict):
                 raise TypeError
+            parsed_context = loaded_context
         except (json.JSONDecodeError, TypeError):
             _show_error_panel(
                 "Invalid Context",

tests/test_export_threaded.py

@@ -161,7 +161,9 @@ def test_execute_batch_handles_json_decode_error(self) -> None:
         )
 
         # 2. Action
-        with patch("odoo_data_flow.export_threaded.log.error") as mock_log_error:
+        with patch(
+            "odoo_data_flow.export_threaded.log.error"
+        ) as mock_log_error:
             result = thread._execute_batch([1], 1)
 
             # 3. Assert
@@ -454,7 +456,9 @@ def test_export_handles_memory_error_fallback(
 
         # Verify the final file has all data from the successful retries
         on_disk_df = pl.read_csv(output_file, separator=";")
-        expected_df = pl.DataFrame({"id": [1, 2, 3, 4], "name": ["A", "B", "C", "D"]})
+        expected_df = pl.DataFrame(
+            {"id": [1, 2, 3, 4], "name": ["A", "B", "C", "D"]}
+        )
         assert_frame_equal(on_disk_df.sort("id"), expected_df.sort("id"))
 
     def test_export_handles_empty_batch_result(
@@ -524,7 +528,9 @@ def test_export_handles_permanent_worker_failure(
         on_disk_df = pl.read_csv(output_file, separator=";")
         assert len(on_disk_df) == 1
 
-    def test_initialize_export_connection_error(self, mock_conf_lib: MagicMock) -> None:
+    def test_initialize_export_connection_error(
+        self, mock_conf_lib: MagicMock
+    ) -> None:
         """Tests that the function handles connection errors gracefully."""
         mock_conf_lib.side_effect = Exception("Connection Refused")
 
@@ -614,7 +620,9 @@ def test_process_export_batches_empty_result(
         if result is not None:
             assert result.is_empty()
 
-    def test_process_export_batches_no_dfs_with_output(self, tmp_path: Path) -> None:
+    def test_process_export_batches_no_dfs_with_output(
+        self, tmp_path: Path
+    ) -> None:
         """Test _process_export_batches with no dataframes and an output file."""
         mock_rpc_thread = MagicMock()
         mock_rpc_thread.futures = []
@@ -640,7 +648,9 @@ def test_process_export_batches_no_dfs_with_output(self, tmp_path: Path) -> None
         assert result.is_empty()
         mock_write_csv.assert_called_once()
 
-    def test_export_relational_raw_id_success(self, mock_conf_lib: MagicMock) -> None:
+    def test_export_relational_raw_id_success(
+        self, mock_conf_lib: MagicMock
+    ) -> None:
         """Test Relational Raw id.
 
         Tests that requesting a relational field with '/.id' triggers read mode
@@ -708,7 +718,9 @@ def test_export_hybrid_mode_success(self, mock_conf_lib: MagicMock) -> None:
         }
 
         # 2. Mock the primary read() call
-        mock_model.read.return_value = [{"id": 10, "parent_id": (5, "Parent Category")}]
+        mock_model.read.return_value = [
+            {"id": 10, "parent_id": (5, "Parent Category")}
+        ]
 
         # 3. Mock the secondary XML ID lookup on 'ir.model.data'
         mock_ir_model_data = MagicMock()
@@ -737,7 +749,9 @@ def test_export_hybrid_mode_success(self, mock_conf_lib: MagicMock) -> None:
         )
         assert_frame_equal(result_df, expected_df)
 
-    def test_export_id_in_export_data_mode(self, mock_conf_lib: MagicMock) -> None:
+    def test_export_id_in_export_data_mode(
+        self, mock_conf_lib: MagicMock
+    ) -> None:
         """Test export id in export data.
 
         Tests that in export_data mode, the 'id' field correctly resolves
@@ -824,7 +838,9 @@ def test_export_auto_enables_read_mode_for_selection_field(
 
         # --- Assert ---
         _init_args, init_kwargs = mock_rpc_thread_class.call_args
-        assert init_kwargs.get("technical_names") is True, "Read mode was not triggered"
+        assert init_kwargs.get("technical_names") is True, (
+            "Read mode was not triggered"
+        )
 
         assert result_df is not None
         expected_df = pl.DataFrame({"name": ["Test Record"], "state": ["done"]})
@@ -874,10 +890,14 @@ def test_export_auto_enables_read_mode_for_binary_field(
 
         # --- Assert ---
         _init_args, init_kwargs = mock_rpc_thread_class.call_args
-        assert init_kwargs.get("technical_names") is True, "Read mode was not triggered"
+        assert init_kwargs.get("technical_names") is True, (
+            "Read mode was not triggered"
+        )
 
         assert result_df is not None
-        expected_df = pl.DataFrame({"name": ["test.zip"], "datas": ["UEsDBAoAAAAA..."]})
+        expected_df = pl.DataFrame(
+            {"name": ["test.zip"], "datas": ["UEsDBAoAAAAA..."]}
+        )
         assert_frame_equal(result_df, expected_df)
 
     @patch("odoo_data_flow.export_threaded.concurrent.futures.as_completed")
@@ -1006,3 +1026,175 @@ def test_export_main_record_xml_id_enrichment(
 
         # Sort by name to ensure consistent order for comparison
         assert_frame_equal(result_df.sort("name"), expected_df.sort("name"))
+
+    def test_execute_batch_single_record_failure(self) -> None:
+        """Test _execute_batch_with_retry handling when single record fails."""
+        mock_model = MagicMock()
+        mock_connection = MagicMock()
+        fields_info = {"id": {"type": "integer"}}
+        thread = RPCThreadExport(
+            1,
+            mock_connection,
+            mock_model,
+            ["id"],
+            fields_info,
+            technical_names=True,
+        )
+
+        # Test the else branch: when there"s only 1 ID and it fails permanently
+        # This should set has_failures = True and return empty lists
+        with patch.object(thread, "_execute_batch") as mock_execute_batch:
+            # Configure to raise an exception that will cause permanent failure
+            error = httpx.ReadTimeout("Network timeout", request=None)
+            mock_execute_batch.side_effect = error
+
+            result_data, processed_ids = thread._execute_batch_with_retry(
+                [42], "single_batch", error
+            )
+
+            # Should return empty lists
+            assert result_data == []
+            assert processed_ids == []
+            # has_failures should be set to True
+            assert thread.has_failures is True
+
+    def test_resume_existing_session_missing_all_ids(
+        self, tmp_path: Path
+    ) -> None:
+        """Test _resume_existing_session when all_ids.json is missing."""
+        from odoo_data_flow.export_threaded import _resume_existing_session
+
+        # Create session directory without all_ids.json
+        session_dir = tmp_path / "session_dir"
+        session_dir.mkdir()
+
+        # Don"t create all_ids.json file
+
+        session_id = "test_session"
+
+        ids_to_export, total_count = _resume_existing_session(
+            session_dir, session_id
+        )
+
+        # Should return empty list since all_ids.json is missing
+        assert ids_to_export == []
+        assert total_count == 0
+
+    def test_resume_existing_session_with_completed_ids(
+        self, tmp_path: Path
+    ) -> None:
+        """Test _resume_existing_session with existing completed IDs."""
+        import json
+
+        from odoo_data_flow.export_threaded import _resume_existing_session
+
+        # Create session directory with both files
+        session_dir = tmp_path / "session_dir"
+        session_dir.mkdir()
+
+        # Create all_ids.json with all record IDs
+        all_ids = [1, 2, 3, 4, 5]
+        all_ids_file = session_dir / "all_ids.json"
+        with open(all_ids_file, "w") as f:
+            json.dump(all_ids, f)
+
+        # Create completed_ids.txt with some completed records
+        completed_ids_file = session_dir / "completed_ids.txt"
+        with open(completed_ids_file, "w") as f:
+            f.write("1\n")
+            f.write("3\n")
+            f.write("5\n")
+
+        session_id = "test_session"
+
+        ids_to_export, total_count = _resume_existing_session(
+            session_dir, session_id
+        )
+
+        # Should return only uncompleted IDs (2, 4)
+        assert sorted(ids_to_export) == [2, 4]
+        assert total_count == 5  # Total was 5
+
+    def test_execute_batch_successful_split_retry(self) -> None:
+        """Test _execute_batch_with_retry with successful batch split and retry."""
+        import httpx
+
+        from odoo_data_flow.export_threaded import RPCThreadExport
+
+        mock_model = MagicMock()
+        mock_connection = MagicMock()
+        fields_info = {"id": {"type": "integer"}}
+        thread = RPCThreadExport(
+            1,
+            mock_connection,
+            mock_model,
+            ["id"],
+            fields_info,
+            technical_names=True,
+        )
+
+        # Mock _execute_batch to simulate successful batch split processing
+        # When called with [1, 2, 3, 4], it returns two successful halves
+        with patch.object(thread, "_execute_batch") as mock_execute_batch:
+            # First call for first half [1, 2] returns success
+            # Second call for second half [3, 4] returns success
+            mock_execute_batch.side_effect = [
+                ([{"id": 1}, {"id": 2}], [1, 2]),  # First half results
+                ([{"id": 3}, {"id": 4}], [3, 4]),  # Second half results
+            ]
+
+            # Call _execute_batch_with_retry with a batch that will be split
+            result_data, processed_ids = thread._execute_batch_with_retry(
+                [1, 2, 3, 4],
+                "test_batch",
+                httpx.ReadTimeout("Network timeout", request=None),
+            )
+
+            # Should have been called twice (once for each half)
+            assert mock_execute_batch.call_count == 2
+
+            # Check the calls
+            calls = mock_execute_batch.call_args_list
+            first_call_args = calls[0][0]  # First call args
+            second_call_args = calls[1][0]  # Second call args
+
+            # Should split [1,2,3,4] into [1,2] and [3,4]
+            assert first_call_args[0] == [1, 2]  # First half
+            assert (
+                first_call_args[1] == "test_batch-a"
+            )  # First half batch number
+            assert second_call_args[0] == [3, 4]  # Second half
+            assert (
+                second_call_args[1] == "test_batch-b"
+            )  # Second half batch number
+
+            # Results should be combined
+            expected_data = [{"id": 1}, {"id": 2}, {"id": 3}, {"id": 4}]
+            expected_ids = [1, 2, 3, 4]
+
+            assert result_data == expected_data
+            assert processed_ids == expected_ids
+
+    def test_enrich_main_df_with_xml_ids_missing_id_column(self) -> None:
+        """Test _enrich_main_df_with_xml_ids when ".id" column is missing."""
+        import polars as pl
+
+        from odoo_data_flow.export_threaded import _enrich_main_df_with_xml_ids
+
+        # Create DataFrame without ".id" column
+        df_without_id = pl.DataFrame(
+            {
+                "name": ["Test", "Another"],
+                "value": [100, 200],
+            }
+        )
+
+        mock_connection = MagicMock()
+        model_name = "res.partner"
+
+        result_df = _enrich_main_df_with_xml_ids(
+            df_without_id, mock_connection, model_name
+        )
+
+        # DataFrame should remain unchanged if ".id" column is missing
+        assert result_df.equals(df_without_id)