Fix: improve test structure and add test runner to handle PyO3 import issues

Author: star7js

run_tests.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""
+Simple test runner to avoid PyO3 import issues.
+"""
+
+import subprocess
+import sys
+import os
+
+def run_tests():
+    """Run tests using subprocess to avoid PyO3 issues."""
+    print("Running tests to avoid PyO3 import issues...")
+    
+    # Run basic functionality test first
+    print("\n1. Running basic functionality test...")
+    result1 = subprocess.run([sys.executable, "test_basic_functionality.py"], 
+                           capture_output=True, text=True)
+    
+    if result1.returncode == 0:
+        print("✅ Basic functionality test passed")
+        print(result1.stdout)
+    else:
+        print("❌ Basic functionality test failed")
+        print(result1.stderr)
+    
+    # Run improved modules tests
+    print("\n2. Running improved modules tests...")
+    result2 = subprocess.run([sys.executable, "-m", "pytest", 
+                            "tests/test_improved_modules.py", "-v"], 
+                           capture_output=True, text=True)
+    
+    if result2.returncode == 0:
+        print("✅ Improved modules tests passed")
+        print(result2.stdout)
+    else:
+        print("❌ Improved modules tests failed")
+        print(result2.stderr)
+    
+    # Run multi-issue tests
+    print("\n3. Running multi-issue tests...")
+    result3 = subprocess.run([sys.executable, "-m", "pytest", 
+                            "tests/test_multi_issue_upload_with_subtasks.py", "-v"], 
+                           capture_output=True, text=True)
+    
+    if result3.returncode == 0:
+        print("✅ Multi-issue tests passed")
+        print(result3.stdout)
+    else:
+        print("❌ Multi-issue tests failed")
+        print(result3.stderr)
+    
+    # Summary
+    print("\n" + "="*50)
+    print("TEST SUMMARY")
+    print("="*50)
+    print(f"Basic functionality: {'✅ PASS' if result1.returncode == 0 else '❌ FAIL'}")
+    print(f"Improved modules: {'✅ PASS' if result2.returncode == 0 else '❌ FAIL'}")
+    print(f"Multi-issue: {'✅ PASS' if result3.returncode == 0 else '❌ FAIL'}")
+    
+    total_failures = sum(1 for r in [result1, result2, result3] if r.returncode != 0)
+    if total_failures == 0:
+        print("\n🎉 All tests passed!")
+        return 0
+    else:
+        print(f"\n⚠️  {total_failures} test suite(s) failed")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(run_tests()) 

tests/test_improved_modules.py

@@ -6,6 +6,7 @@
 from unittest.mock import Mock, patch
 import tempfile
 import os
+import sys
 from atlassian.errors import ApiError
 
 # Mock the atlassian import to avoid real network calls
@@ -16,6 +17,7 @@
         "atlassian.errors": Mock(),
     },
 ):
+    # Import modules after mocking
     from src.config import JiraConfig, AppConfig  # noqa
     from src.models import JiraIssueData, JiraSubtaskData, CSVRow
     from src.csv_processor import CSVProcessor
@@ -214,10 +216,9 @@ class TestJiraClient(unittest.TestCase):
 
     def setUp(self):
         """Set up test fixtures."""
-        self.jira_patcher = patch("src.jira_client.Jira")
-        self.mock_jira_class = self.jira_patcher.start()
-        self.mock_jira_instance = self.mock_jira_class.return_value
-
+        # Don't patch during setup to avoid PyO3 issues
+        # We'll patch in individual test methods instead
+        
         with patch.dict(
             os.environ,
             {
@@ -226,81 +227,93 @@ def setUp(self):
                 "JIRA_API_TOKEN": "test-token",
             },
         ):
+            # Import JiraClient here to avoid PyO3 issues
+            from src.jira_client import JiraClient
             self.client = JiraClient()
-            self.client.jira = self.mock_jira_instance
-
-    def tearDown(self):
-        """Tear down test fixtures."""
-        self.jira_patcher.stop()
 
     def test_test_connection_success(self):
         """Test successful connection test."""
-        self.mock_jira_instance.server_info.return_value = {
-            "serverTitle": "Test Server"
-        }
-        self.assertTrue(self.client.test_connection())
+        with patch("src.jira_client.Jira") as mock_jira_class:
+            mock_jira_instance = mock_jira_class.return_value
+            mock_jira_instance.server_info.return_value = {
+                "serverTitle": "Test Server"
+            }
+            self.client.jira = mock_jira_instance
+            self.assertTrue(self.client.test_connection())
 
     def test_test_connection_failure(self):
         """Test failed connection test."""
-        self.mock_jira_instance.server_info.side_effect = Exception(
-            "Connection failed"
-        )
-        self.assertFalse(self.client.test_connection())
+        with patch("src.jira_client.Jira") as mock_jira_class:
+            mock_jira_instance = mock_jira_class.return_value
+            mock_jira_instance.server_info.side_effect = Exception(
+                "Connection failed"
+            )
+            self.client.jira = mock_jira_instance
+            self.assertFalse(self.client.test_connection())
 
     def test_create_issue_success(self):
         """Test successful issue creation."""
-        self.mock_jira_instance.issue_create.return_value = {
-            "key": "TEST-123",
-            "id": "12345",
-        }
-
-        issue_data = JiraIssueData(
-            project_key="TEST",
-            summary="Test Issue",
-            description="Test Description",
-            issue_type="Task",
-        )
-        created_issue = self.client.create_issue(issue_data.model_dump())
+        with patch("src.jira_client.Jira") as mock_jira_class:
+            mock_jira_instance = mock_jira_class.return_value
+            mock_jira_instance.issue_create.return_value = {
+                "key": "TEST-123",
+                "id": "12345",
+            }
+            self.client.jira = mock_jira_instance
+
+            issue_data = JiraIssueData(
+                project_key="TEST",
+                summary="Test Issue",
+                description="Test Description",
+                issue_type="Task",
+            )
+            created_issue = self.client.create_issue(issue_data.model_dump())
 
-        self.assertIsNotNone(created_issue)
-        self.assertEqual(created_issue["key"], "TEST-123")
-        self.mock_jira_instance.issue_create.assert_called_once()
+            self.assertIsNotNone(created_issue)
+            self.assertEqual(created_issue["key"], "TEST-123")
+            mock_jira_instance.issue_create.assert_called_once()
 
     def test_create_issue_failure(self):
         """Test failed issue creation."""
-        # Create a mock ApiError that inherits from Exception
-        mock_api_error = Exception("Server Error")
-        mock_api_error.status_code = 500
-        self.mock_jira_instance.issue_create.side_effect = mock_api_error
-
-        issue_data = JiraIssueData(
-            project_key="TEST",
-            summary="Test Issue",
-            description="Test Description",
-            issue_type="Task",
-        )
-        with self.assertRaises(Exception):
-            self.client.create_issue(issue_data.model_dump())
+        with patch("src.jira_client.Jira") as mock_jira_class:
+            mock_jira_instance = mock_jira_class.return_value
+            # Create a mock exception with status_code
+            mock_exception = Exception("Server Error")
+            mock_exception.status_code = 500
+            mock_jira_instance.issue_create.side_effect = mock_exception
+            self.client.jira = mock_jira_instance
+
+            issue_data = JiraIssueData(
+                project_key="TEST",
+                summary="Test Issue",
+                description="Test Description",
+                issue_type="Task",
+            )
+            with self.assertRaises(Exception):
+                self.client.create_issue(issue_data.model_dump())
 
     def test_create_subtask_success(self):
         """Test successful subtask creation."""
-        self.mock_jira_instance.issue_create.return_value = {
-            "key": "TEST-124",
-            "id": "12346",
-        }
-
-        subtask_data = JiraSubtaskData(
-            project_key="TEST",
-            summary="Test Subtask",
-            description="Test Subtask Description",
-            issue_type="Sub-task",
-            parent_id="TEST-123",
-        )
-        created_subtask = self.client.create_subtask(subtask_data.model_dump())
+        with patch("src.jira_client.Jira") as mock_jira_class:
+            mock_jira_instance = mock_jira_class.return_value
+            mock_jira_instance.issue_create.return_value = {
+                "key": "TEST-124",
+                "id": "12346",
+            }
+            self.client.jira = mock_jira_instance
+
+            subtask_data = JiraSubtaskData(
+                project_key="TEST",
+                summary="Test Subtask",
+                description="Test Subtask Description",
+                issue_type="Sub-task",
+                parent_id="TEST-123",
+            )
+            created_subtask = self.client.create_subtask(subtask_data.model_dump())
 
-        self.assertIsNotNone(created_subtask)
-        self.assertEqual(created_subtask["key"], "TEST-124")
-        self.mock_jira_instance.issue_create.assert_called_once()
+            self.assertIsNotNone(created_subtask)
+            self.assertEqual(created_subtask["key"], "TEST-124")
+            mock_jira_instance.issue_create.assert_called_once()
 
 
 if __name__ == "__main__":

tests/test_multi_issue_upload_with_subtasks.py

@@ -1,6 +1,19 @@
 import unittest
-from unittest.mock import mock_open, patch
-from src import multi_issue_upload_with_subtasks
+from unittest.mock import mock_open, patch, Mock
+import sys
+import os
+
+# Add src to path without importing pydantic modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+# Mock pydantic before importing
+with patch.dict('sys.modules', {
+    'pydantic': Mock(),
+    'pydantic.BaseModel': Mock(),
+    'pydantic.Field': Mock(),
+    'pydantic.field_validator': Mock(),
+}):
+    from multi_issue_upload_with_subtasks import read_csv, create_jira_issue, create_jira_subtask
 
 
 class TestJiraScript(unittest.TestCase):
@@ -12,45 +25,41 @@ class TestJiraScript(unittest.TestCase):
         read_data="Project Key,Summary,Description,Issue Type\nTest,Ticket 1,Description 1,Task",
     )
     def test_read_csv(self, mock_open_instance):
-        rows = multi_issue_upload_with_subtasks.read_csv("dummy.csv")
+        rows = read_csv("dummy.csv")
         self.assertEqual(len(rows), 1)
         self.assertEqual(rows[0]["Project Key"], "Test")
         # ... more assertions based on your CSV structure
 
     # Test for create_jira_issue function
-    @patch.object(
-        multi_issue_upload_with_subtasks.jira,
-        "issue_create",
-        return_value={"key": "TEST-123", "id": "001"},
-    )
-    def test_create_jira_issue(self, mock_issue_create):
+    @patch('multi_issue_upload_with_subtasks.jira')
+    def test_create_jira_issue(self, mock_jira):
+        mock_jira.issue_create.return_value = {"key": "TEST-123", "id": "001"}
+        
         issue_data = {
             "project": {"key": "Test"},
             "summary": "Ticket 1",
             "description": "Description 1",
             "issuetype": {"name": "Task"},
         }
-        response = multi_issue_upload_with_subtasks.create_jira_issue(issue_data)
-        mock_issue_create.assert_called_once_with(fields=issue_data)
+        response = create_jira_issue(issue_data)
+        mock_jira.issue_create.assert_called_once_with(fields=issue_data)
         self.assertEqual(response["key"], "TEST-123")
         # ... more assertions if needed
 
     # Test for create_jira_subtask function (similar to the one above)
-    @patch.object(
-        multi_issue_upload_with_subtasks.jira,
-        "issue_create",
-        return_value={"key": "TEST-124", "id": "002"},
-    )
-    def test_create_jira_subtask(self, mock_issue_create):
+    @patch('multi_issue_upload_with_subtasks.jira')
+    def test_create_jira_subtask(self, mock_jira):
+        mock_jira.issue_create.return_value = {"key": "TEST-124", "id": "002"}
+        
         subtask_data = {
             "project": {"key": "Test"},
             "summary": "Subtask 1",
             "description": "Subtask Description 1",
             "issuetype": {"name": "Sub-task"},
             "parent": {"id": "001"},
         }
-        response = multi_issue_upload_with_subtasks.create_jira_subtask(subtask_data)
-        mock_issue_create.assert_called_once_with(fields=subtask_data)
+        response = create_jira_subtask(subtask_data)
+        mock_jira.issue_create.assert_called_once_with(fields=subtask_data)
         self.assertEqual(response["key"], "TEST-124")
         # ... more assertions if needed