regscale-cli 6.26.0.0__py3-none-any.whl → 6.27.0.1__py3-none-any.whl

tests/regscale/integrations/commercial/test_jira.py

@@ -31,7 +31,6 @@ from regscale.integrations.commercial.jira import (
     sync_regscale_objects_to_jira,
     sync_regscale_to_jira,
     task_and_attachments_sync,
-    update_regscale_issues,
     create_regscale_task_from_jira,
     create_and_update_regscale_tasks,
     process_tasks_for_sync,
@@ -39,7 +38,7 @@ from regscale.integrations.commercial.jira import (
     upload_files_to_regscale,
     validate_issue_type,
 )
-from regscale.models import File, Issue, SecurityPlan
+from regscale.models import File, Issue
 from regscale.models.regscale_models.task import Task
 from tests import CLITestFixture
 
@@ -184,6 +183,7 @@ class TestJira(CLITestFixture):
             parentId=self.PARENT_ID,
             parentModule=self.PARENT_MODULE,
             dueDate=get_current_datetime(),
+            identification=f"{self.title_prefix} Jira Issue Integration Test",
             status="Open",
         ).create()
         if fetch_attachments:
@@ -287,6 +287,8 @@ class TestJira(CLITestFixture):
     def test_sync_regscale_and_jira(self, mock_check_license, fetch_attachments):
         """Test the entire Jira & RegScale sync process"""
         mock_check_license.return_value.config = self.config
+        # Add thread_manager to the mock Application
+        mock_check_license.return_value.thread_manager = MagicMock()
         try:
             sync_regscale_and_jira(
                 parent_id=self.PARENT_ID,
@@ -302,6 +304,8 @@ class TestJira(CLITestFixture):
     def test_sync_regscale_and_jira_tasks(self, mock_check_license, fetch_attachments):
         """Test the entire Jira & RegScale task sync process"""
         mock_check_license.return_value.config = self.config
+        # Add thread_manager to the mock Application
+        mock_check_license.return_value.thread_manager = MagicMock()
         try:
             sync_regscale_and_jira(
                 parent_id=self.PARENT_ID,
@@ -358,7 +362,7 @@ class TestJira(CLITestFixture):
         mock_fetch_jira_objects.assert_called_once_with(
             jira_client=mock_jira_client,
             jira_project=self.JIRA_PROJECT,
-            jql_str="project = SNES",
+            jql_str="project = 'SNES'",
             jira_issue_type="Bug",
             sync_tasks_only=False,
         )
@@ -390,6 +394,11 @@ class TestJira(CLITestFixture):
         mock_jira_client = MagicMock()
         mock_create_jira_client.return_value = mock_jira_client
 
+        # Setup mock config with jiraCustomFields returning empty dict
+        mock_config = MagicMock()
+        mock_config.get.return_value = {}
+        mock_check_license.return_value.config = mock_config
+
         # mock these so that we can control what objects were returned to check later
         mock_fetch_jira_objects.return_value = MagicMock()
         mock_get_regscale_data_and_attachments.return_value = (MagicMock(), MagicMock())
@@ -415,7 +424,7 @@ class TestJira(CLITestFixture):
         mock_fetch_jira_objects.assert_called_once_with(
             jira_client=mock_jira_client,
             jira_project=self.JIRA_PROJECT,
-            jql_str="project = SNES",
+            jql_str="project = 'SNES'",
             jira_issue_type="Bug",
             sync_tasks_only=False,
         )
@@ -429,6 +438,7 @@ class TestJira(CLITestFixture):
             api=mock_api.return_value,
             sync_attachments=fetch_attachments,
             attachments=mock_get_regscale_data_and_attachments.return_value[1],
+            custom_fields={},
         )
         mock_sync_regscale_objects_to_jira.assert_called_once_with(
             mock_fetch_jira_objects.return_value,
@@ -438,6 +448,7 @@ class TestJira(CLITestFixture):
             self.PARENT_ID,
             self.PARENT_MODULE,
             False,
+            False,
         )
 
     @patch(f"{PATH}.sync_regscale_objects_to_jira")
@@ -606,14 +617,12 @@ class TestJira(CLITestFixture):
         mock_create_and_update_regscale_issues.assert_not_called()
 
     @patch(f"{PATH}.create_jira_client")
-    @patch(f"{PATH}.create_threads")
     @patch(f"{PATH}.create_and_update_regscale_tasks")
     @patch(f"{PATH}.check_license", return_value=MagicMock(spec=Application))
     def test_sync_regscale_objects_to_jira_all(
         self,
         mock_check_license,
         mock_create_and_update_regscale_tasks,
-        mock_create_threads,
         mock_create_jira_client,
         fetch_attachments,
     ):
@@ -622,18 +631,29 @@ class TestJira(CLITestFixture):
         mock_jira_client = MagicMock()
         mock_create_jira_client.return_value = mock_jira_client
 
+        # Create mock application with ThreadManager
+        mock_app = MagicMock(spec=Application)
+        mock_app.config = self.config
+        mock_thread_manager = MagicMock()
+        mock_app.thread_manager = mock_thread_manager
+
+        # Mock Jira issues
+        mock_jira_issues = [MagicMock(), MagicMock()]
+
         sync_regscale_objects_to_jira(
-            MagicMock(),
+            mock_jira_issues,
             MagicMock(),
             fetch_attachments,
-            MagicMock(spec=Application),
+            mock_app,
             self.PARENT_ID,
             self.PARENT_MODULE,
             False,
         )
 
         mock_create_and_update_regscale_tasks.assert_not_called()
-        mock_create_threads.assert_called_once()
+        # Verify ThreadManager methods were called
+        mock_thread_manager.submit_tasks_from_list.assert_called_once()
+        mock_thread_manager.execute_and_verify.assert_called_once()
 
     @patch(f"{PATH}.JIRA")
     def test_create_jira_client_basic(self, mock_jira):
@@ -1159,14 +1179,14 @@ class TestJira(CLITestFixture):
         mock_compare_files_for_dupes_and_upload.assert_called_once()
 
     @patch(f"{PATH}.compare_files_for_dupes_and_upload")
-    @patch(f"{PATH}.Issue.insert_issue")
-    @patch(f"{PATH}.Issue.update_issue")
+    @patch(f"{PATH}.map_jira_to_regscale_issue")
+    @patch(f"{PATH}.Issue.save")
     @patch(f"{PATH}.job_progress", return_value=MagicMock(spec=Progress))
     def test_create_and_update_regscale_issues(
         self,
         mock_job_progress_object,
         mock_update_issue,
-        mock_insert_issue,
+        mock_map_jira_to_regscale_issue,
         mock_compare_files_for_dupes_and_upload,
         fetch_attachments,
     ):
@@ -1190,60 +1210,58 @@ class TestJira(CLITestFixture):
         lowest_priority.name = "lowest"
 
         # Create mock Jira issues
-        jira_issues = [
-            MagicMock(  # should be skipped (up to date - nothing happens) - counts as updated
-                key="JIRA-1",
-                fields=MagicMock(
-                    summary="Skipped issue",
-                    description="Skipped issue description",
-                    status=open_status,
-                    duedate=None,
-                    priority=highest_priority,
-                    statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
-                    attachment=MagicMock(),
-                ),
+        jira_issue_1 = MagicMock(  # should be updated (existing issue)
+            key="JIRA-1",
+            fields=MagicMock(
+                summary="Skipped issue",
+                description="Skipped issue description",
+                status=open_status,
+                duedate=None,
+                priority=highest_priority,
+                statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
+                attachment=[MagicMock()],  # Has attachments
             ),
-            MagicMock(  # should be inserted (issue in jira but not regscale)
-                key="JIRA-2",
-                fields=MagicMock(
-                    summary="New issue",
-                    description="New issue description",
-                    status=open_status,
-                    duedate=None,
-                    priority=medium_priority,
-                    statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
-                    attachment=None,
-                ),
+        )
+        jira_issue_2 = MagicMock(  # should be inserted (issue in jira but not regscale)
+            key="JIRA-2",
+            fields=MagicMock(
+                summary="New issue",
+                description="New issue description",
+                status=open_status,
+                duedate=None,
+                priority=medium_priority,
+                statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
+                attachment=None,
             ),
-            MagicMock(  # should be updated (issue in both but out of sync)
-                key="JIRA-3",
-                fields=MagicMock(
-                    summary="Existing issue",
-                    description="Existing issue description",
-                    status=in_progress_status,
-                    duedate=None,
-                    priority=low_priority,
-                    statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
-                    attachment=None,  # No attachments
-                ),
+        )
+        jira_issue_3 = MagicMock(  # should be updated (issue in both but out of sync)
+            key="JIRA-3",
+            fields=MagicMock(
+                summary="Existing issue",
+                description="Existing issue description",
+                status=in_progress_status,
+                duedate=None,
+                priority=low_priority,
+                statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
+                attachment=None,  # No attachments
             ),
-            MagicMock(  # should be closed - counts as updated
-                key="JIRA-4",
-                fields=MagicMock(
-                    summary="Existing issue",
-                    description="Existing issue description",
-                    status=closed_status,
-                    duedate=None,
-                    priority=lowest_priority,
-                    statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
-                    attachment=None,  # No attachments
-                ),
+        )
+        jira_issue_4 = MagicMock(  # should be closed - counts as updated
+            key="JIRA-4",
+            fields=MagicMock(
+                summary="Existing issue",
+                description="Existing issue description",
+                status=closed_status,
+                duedate=None,
+                priority=lowest_priority,
+                statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
+                attachment=None,  # No attachments
             ),
-        ]
+        )
 
         # Create RegScale issues
         regscale_issues = [
-            Issue(  # matches JIRA-1 (should be skipped - up to date)
+            Issue(  # matches JIRA-1 (should be updated)
                 id=1,
                 title="Skipped issue",
                 status="Open",
@@ -1252,6 +1270,7 @@ class TestJira(CLITestFixture):
                 parentId=self.PARENT_ID,
                 parentModule=self.PARENT_MODULE,
                 dueDate=get_current_datetime(),
+                identification=f"{self.title_prefix} Jira Issue Integration Test",
             ),
             Issue(  # matches JIRA-3 (should be updated - issue in both but out of sync)
                 id=3,
@@ -1262,6 +1281,7 @@ class TestJira(CLITestFixture):
                 parentId=self.PARENT_ID,
                 parentModule=self.PARENT_MODULE,
                 dueDate=get_current_datetime(),
+                identification=f"{self.title_prefix} Jira Issue Integration Test",
             ),
             Issue(  # matches JIRA-4 (should be closed - jira closed but regscale open)
                 id=4,
@@ -1272,32 +1292,41 @@ class TestJira(CLITestFixture):
                 parentId=self.PARENT_ID,
                 parentModule=self.PARENT_MODULE,
                 dueDate=get_current_datetime(),
+                identification=f"{self.title_prefix} Jira Issue Integration Test",
             ),
         ]
 
         # Create mock config with priority mappings from init.yaml
         config = {
             "issues": {"jira": {"highest": 7, "high": 30, "medium": 90, "low": 180, "lowest": 365, "status": "Open"}},
-            "maxThreads": 4,  # Set to match number of issues to process
-            "userId": "123e4567-e89b-12d3-a456-426614174000",  # Add a fake UUID for userId for issue owner
+            "maxThreads": 4,
+            "userId": "123e4567-e89b-12d3-a456-426614174000",
         }
         app = MagicMock()
         app.config = config
 
         # Setup mock return values
         mock_update_issue.return_value = MagicMock()
-        mock_insert_issue.return_value = MagicMock()
+
+        # Mock the creation of a new issue
+        created_issue_mock = MagicMock()
+        created_issue_mock.id = 2
+        created_issue_mock.create.return_value = created_issue_mock
+        mock_map_jira_to_regscale_issue.return_value = created_issue_mock
 
         with mock_job_progress_object as job_progress:
             test_task = job_progress.add_task(
                 description="Processing issues",
-                total=len(jira_issues),
+                total=4,
                 visible=False,
             )
 
-            args = (
-                jira_issues,  # Pass all issues at once
+            # Test the function with each Jira issue individually (as ThreadManager would call it)
+            # JIRA-1: existing issue with matching jiraId and attachments
+            create_and_update_regscale_issues(
+                jira_issue_1,
                 regscale_issues,
+                False,
                 fetch_attachments,
                 MagicMock(),
                 app,
@@ -1307,17 +1336,56 @@ class TestJira(CLITestFixture):
                 job_progress,
             )
 
-            # Test each thread
-            for thread in range(4):
-                create_and_update_regscale_issues(
-                    args=args,
-                    thread=thread,
-                )
+            # JIRA-2: new issue (not in regscale_issues)
+            create_and_update_regscale_issues(
+                jira_issue_2,
+                regscale_issues,
+                False,
+                fetch_attachments,
+                MagicMock(),
+                app,
+                self.PARENT_ID,
+                self.PARENT_MODULE,
+                test_task,
+                job_progress,
+            )
 
-            assert mock_update_issue.call_count == 3  # JIRA-3, JIRA-4, and JIRA-1
-            assert mock_insert_issue.call_count == 1  # JIRA-2
+            # JIRA-3: existing issue to be updated
+            create_and_update_regscale_issues(
+                jira_issue_3,
+                regscale_issues,
+                False,
+                fetch_attachments,
+                MagicMock(),
+                app,
+                self.PARENT_ID,
+                self.PARENT_MODULE,
+                test_task,
+                job_progress,
+            )
+
+            # JIRA-4: existing issue to be closed
+            create_and_update_regscale_issues(
+                jira_issue_4,
+                regscale_issues,
+                False,
+                fetch_attachments,
+                MagicMock(),
+                app,
+                self.PARENT_ID,
+                self.PARENT_MODULE,
+                test_task,
+                job_progress,
+            )
+
+            # Verify update_issue was called 3 times (JIRA-1, JIRA-3, JIRA-4)
+            assert mock_update_issue.call_count == 3
+            # Verify map_jira_to_regscale_issue was called once for JIRA-2 (new issue)
+            assert mock_map_jira_to_regscale_issue.call_count == 1
+            # Verify attachment handling
             if fetch_attachments:
-                assert mock_compare_files_for_dupes_and_upload.call_count == 1  # JIRA-2
+                # Only JIRA-1 has attachments in fields.attachment
+                assert mock_compare_files_for_dupes_and_upload.call_count == 1
             else:
                 assert mock_compare_files_for_dupes_and_upload.call_count == 0
 
@@ -1335,6 +1403,7 @@ class TestJira(CLITestFixture):
                 dueDate=get_current_datetime(),
                 parentId=self.PARENT_ID,
                 parentModule=self.PARENT_MODULE,
+                identification=f"{self.title_prefix} Jira Issue Integration Test",
             ),
             Issue(
                 id=3,
@@ -1345,6 +1414,7 @@ class TestJira(CLITestFixture):
                 parentId=self.PARENT_ID,
                 parentModule=self.PARENT_MODULE,
                 jiraId="JIRA-3",
+                identification=f"{self.title_prefix} Jira Issue Integration Test",
             ),
         ]
 
@@ -1459,6 +1529,7 @@ class TestJira(CLITestFixture):
             jiraId="JIRA-123",
             severityLevel="High",
             dueDate="2023-12-31",
+            identification=f"{self.title_prefix} Jira Issue Integration Test",
         )
 
         comment = _generate_jira_comment(issue)
@@ -1493,6 +1564,7 @@ class TestJira(CLITestFixture):
             otherIdentifier="JIRA-123",
             percentComplete=50,
             dueDate="2023-12-31",
+            identification=f"{self.title_prefix} Jira Issue Integration Test",
         )
 
         comment = _generate_jira_comment(task)
@@ -1596,6 +1668,7 @@ class TestJira(CLITestFixture):
             description="Test Description",
             parentId=self.PARENT_ID,
             parentModule=self.PARENT_MODULE,
+            identification=f"{self.title_prefix} Jira Issue Integration Test",
         )
 
         # setup file hashes for upload
@@ -1671,6 +1744,7 @@ class TestJira(CLITestFixture):
             parentModule=self.PARENT_MODULE,
             dueDate=get_current_datetime(),
             status="Open",
+            identification=f"{self.title_prefix} Jira Issue Integration Test",
         )
         reg_issue = tmp.create()
 
@@ -1782,29 +1856,345 @@ class TestJira(CLITestFixture):
             )
             assert os.path.exists(tmpdir) is True
 
+    @patch(f"{PATH}.sync_regscale_objects_to_jira")
+    @patch(f"{PATH}.sync_regscale_to_jira", return_value=[])
+    @patch(f"{PATH}.create_jira_client")
+    @patch(f"{PATH}.fetch_jira_objects")
+    @patch(f"{PATH}.get_regscale_data_and_attachments")
+    @patch(f"{PATH}.Api", return_value=MagicMock(spec=Api))
+    @patch(f"{PATH}.check_license", return_value=MagicMock(spec=Application))
+    def test_sync_regscale_and_jira_with_poams_true(
+        self,
+        mock_check_license,
+        mock_api,
+        mock_get_regscale_data_and_attachments,
+        mock_fetch_jira_objects,
+        mock_create_jira_client,
+        mock_sync_regscale_to_jira,
+        mock_sync_regscale_objects_to_jira,
+        fetch_attachments,
+    ):
+        """Test sync_regscale_and_jira with use_poams=True"""
+        # Setup mocks
+        mock_jira_client = MagicMock()
+        mock_create_jira_client.return_value = mock_jira_client
+        mock_fetch_jira_objects.return_value = [MagicMock()]
+        mock_get_regscale_data_and_attachments.return_value = ([MagicMock()], MagicMock())
+
+        # Call function with use_poams=True
+        sync_regscale_and_jira(
+            parent_id=self.PARENT_ID,
+            parent_module=self.PARENT_MODULE,
+            jira_project=self.JIRA_PROJECT,
+            jira_issue_type="Bug",
+            sync_attachments=fetch_attachments,
+            use_poams=True,
+        )
+
+        # Verify sync_regscale_objects_to_jira was called with use_poams=True
+        mock_sync_regscale_objects_to_jira.assert_called_once()
+        call_args = mock_sync_regscale_objects_to_jira.call_args
+        assert call_args[0][7] is True  # use_poams is the 8th positional argument
+
+    @patch(f"{PATH}.sync_regscale_objects_to_jira")
+    @patch(f"{PATH}.sync_regscale_to_jira", return_value=[])
+    @patch(f"{PATH}.create_jira_client")
+    @patch(f"{PATH}.fetch_jira_objects")
+    @patch(f"{PATH}.get_regscale_data_and_attachments")
+    @patch(f"{PATH}.Api", return_value=MagicMock(spec=Api))
+    @patch(f"{PATH}.check_license", return_value=MagicMock(spec=Application))
+    def test_sync_regscale_and_jira_with_poams_false(
+        self,
+        mock_check_license,
+        mock_api,
+        mock_get_regscale_data_and_attachments,
+        mock_fetch_jira_objects,
+        mock_create_jira_client,
+        mock_sync_regscale_to_jira,
+        mock_sync_regscale_objects_to_jira,
+        fetch_attachments,
+    ):
+        """Test sync_regscale_and_jira with use_poams=False (default)"""
+        # Setup mocks
+        mock_jira_client = MagicMock()
+        mock_create_jira_client.return_value = mock_jira_client
+        mock_fetch_jira_objects.return_value = [MagicMock()]
+        mock_get_regscale_data_and_attachments.return_value = ([MagicMock()], MagicMock())
+
+        # Call function with use_poams=False (default)
+        sync_regscale_and_jira(
+            parent_id=self.PARENT_ID,
+            parent_module=self.PARENT_MODULE,
+            jira_project=self.JIRA_PROJECT,
+            jira_issue_type="Bug",
+            sync_attachments=fetch_attachments,
+            use_poams=False,
+        )
+
+        # Verify sync_regscale_objects_to_jira was called with use_poams=False
+        mock_sync_regscale_objects_to_jira.assert_called_once()
+        call_args = mock_sync_regscale_objects_to_jira.call_args
+        assert call_args[0][7] is False  # use_poams is the 8th positional argument
+
+    @patch(f"{PATH}.create_jira_client")
+    @patch(f"{PATH}.create_and_update_regscale_issues")
+    @patch(f"{PATH}.check_license", return_value=MagicMock(spec=Application))
+    def test_sync_regscale_objects_to_jira_with_poams(
+        self,
+        mock_check_license,
+        mock_create_and_update_regscale_issues,
+        mock_create_jira_client,
+        fetch_attachments,
+    ):
+        """Test sync_regscale_objects_to_jira passes use_poams to create_and_update_regscale_issues"""
+        mock_check_license.return_value.config = self.config
+        mock_jira_client = MagicMock()
+        mock_create_jira_client.return_value = mock_jira_client
+
+        # Create mock application with ThreadManager
+        mock_app = MagicMock(spec=Application)
+        mock_app.config = self.config
+        mock_thread_manager = MagicMock()
+        mock_app.thread_manager = mock_thread_manager
+
+        # Mock Jira issues
+        mock_jira_issues = [MagicMock(), MagicMock()]
+        mock_regscale_objects = [MagicMock()]
+
+        # Test with use_poams=True
+        sync_regscale_objects_to_jira(
+            mock_jira_issues,
+            mock_regscale_objects,
+            fetch_attachments,
+            mock_app,
+            self.PARENT_ID,
+            self.PARENT_MODULE,
+            False,  # sync_tasks_only
+            True,  # use_poams
+        )
+
+        # Verify ThreadManager was called with correct parameters
+        mock_thread_manager.submit_tasks_from_list.assert_called_once()
+        call_args = mock_thread_manager.submit_tasks_from_list.call_args[0]
+        # use_poams is the 4th argument (index 3) after function, jira_issues, and regscale_objects
+        assert call_args[3] is True
+
+    @patch(f"{PATH}.map_jira_to_regscale_issue")
+    def test_map_jira_to_regscale_issue_with_poam_true(self, mock_map_jira_to_regscale_issue):
+        """Test map_jira_to_regscale_issue sets isPoam=True when is_poam=True"""
+        # Create mock Jira issue
+        mock_issue = MagicMock()
+        mock_issue.fields.summary = "Test Issue"
+        mock_issue.fields.description = "Test Description"
+        mock_issue.fields.status.name = "Open"
+        mock_issue.fields.priority.name = "High"
+        mock_issue.fields.duedate = None
+        mock_issue.key = "TEST-123"
+
+        # Create mock config
+        mock_config = {
+            "userId": "1",
+            "issues": {"jira": {"status": "Open", "high": 7, "medium": 14, "low": 30}},
+        }
+
+        # Call the actual function with is_poam=True
+        result = map_jira_to_regscale_issue(
+            jira_issue=mock_issue,
+            config=mock_config,
+            parent_id=self.PARENT_ID,
+            parent_module=self.PARENT_MODULE,
+            is_poam=True,
+        )
+
+        # Verify the Issue object was created with isPoam=True
+        assert isinstance(result, Issue)
+        assert result.isPoam is True
+        assert result.title == "Test Issue"
+        assert result.jiraId == "TEST-123"
+
+    @patch(f"{PATH}.map_jira_to_regscale_issue")
+    def test_map_jira_to_regscale_issue_with_poam_false(self, mock_map_jira_to_regscale_issue):
+        """Test map_jira_to_regscale_issue sets isPoam=False when is_poam=False"""
+        # Create mock Jira issue
+        mock_issue = MagicMock()
+        mock_issue.fields.summary = "Test Issue"
+        mock_issue.fields.description = "Test Description"
+        mock_issue.fields.status.name = "Open"
+        mock_issue.fields.priority.name = "High"
+        mock_issue.fields.duedate = None
+        mock_issue.key = "TEST-123"
+
+        # Create mock config
+        mock_config = {
+            "userId": "1",
+            "issues": {"jira": {"status": "Open", "high": 7, "medium": 14, "low": 30}},
+        }
+
+        # Call the actual function with is_poam=False
+        result = map_jira_to_regscale_issue(
+            jira_issue=mock_issue,
+            config=mock_config,
+            parent_id=self.PARENT_ID,
+            parent_module=self.PARENT_MODULE,
+            is_poam=False,
+        )
+
+        # Verify the Issue object was created with isPoam=False
+        assert isinstance(result, Issue)
+        assert result.isPoam is False
+        assert result.title == "Test Issue"
+        assert result.jiraId == "TEST-123"
+
+    @patch(f"{PATH}.compare_files_for_dupes_and_upload")
+    @patch(f"{PATH}.map_jira_to_regscale_issue")
+    @patch(f"{PATH}.Issue.update_issue")
+    @patch(f"{PATH}.job_progress", return_value=MagicMock(spec=Progress))
+    def test_create_and_update_regscale_issues_sets_ispoam_on_new_issue(
+        self,
+        mock_job_progress_object,
+        mock_update_issue,
+        mock_map_jira_to_regscale_issue,
+        mock_compare_files_for_dupes_and_upload,
+    ):
+        """Test that create_and_update_regscale_issues sets isPoam on newly created issues"""
+        # Create mock Jira issue
+        open_status = MagicMock()
+        open_status.name = "open"
+        high_priority = MagicMock()
+        high_priority.name = "high"
+
+        jira_issue = MagicMock(
+            key="JIRA-NEW",
+            fields=MagicMock(
+                summary="New Issue",
+                description="New issue description",
+                status=open_status,
+                duedate=None,
+                priority=high_priority,
+                statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
+                attachment=None,
+            ),
+        )
+
+        # Create empty RegScale issues list (no existing issues)
+        regscale_issues = []
+
+        # Create mock config
+        config = {
+            "issues": {"jira": {"highest": 7, "high": 30, "medium": 90, "low": 180, "lowest": 365, "status": "Open"}},
+            "maxThreads": 4,
+            "userId": "123e4567-e89b-12d3-a456-426614174000",
+        }
+        app = MagicMock()
+        app.config = config
+
+        # Mock the creation of a new issue
+        created_issue_mock = MagicMock()
+        created_issue_mock.id = 999
+        created_issue_mock.create.return_value = created_issue_mock
+        mock_map_jira_to_regscale_issue.return_value = created_issue_mock
+
+        with mock_job_progress_object as job_progress:
+            test_task = job_progress.add_task(
+                description="Processing issues",
+                total=1,
+                visible=False,
+            )
+
+            # Call with use_poams=True
+            create_and_update_regscale_issues(
+                jira_issue,
+                regscale_issues,
+                True,  # use_poams
+                False,  # add_attachments
+                MagicMock(),
+                app,
+                self.PARENT_ID,
+                self.PARENT_MODULE,
+                test_task,
+                job_progress,
+            )
+
+            # Verify map_jira_to_regscale_issue was called with is_poam=True
+            mock_map_jira_to_regscale_issue.assert_called_once()
+            call_kwargs = mock_map_jira_to_regscale_issue.call_args[1]
+            assert call_kwargs["is_poam"] is True
+
+    @patch(f"{PATH}.compare_files_for_dupes_and_upload")
+    @patch(f"{PATH}.map_jira_to_regscale_issue")
+    @patch(f"{PATH}.Issue.save")
     @patch(f"{PATH}.job_progress", return_value=MagicMock(spec=Progress))
-    def test_update_regscale_issue(self, mock_job_progress_object, regscale_issue_and_attachment):
-        """Test updating an issue in RegScale"""
-        test_issue = regscale_issue_and_attachment
-        # update fields in a RegScale issue
-        test_issue.assetIdentifier = f"Updated via Test on {get_current_datetime()}"
-        test_issue.lastUpdatedById = self.config["userId"]
+    def test_create_and_update_regscale_issues_sets_ispoam_on_existing_issue(
+        self,
+        mock_job_progress_object,
+        mock_save,
+        mock_map_jira_to_regscale_issue,
+        mock_compare_files_for_dupes_and_upload,
+    ):
+        """Test that create_and_update_regscale_issues sets isPoam on existing issues"""
+        # Create mock Jira issue
+        open_status = MagicMock()
+        open_status.name = "open"
+        high_priority = MagicMock()
+        high_priority.name = "high"
+
+        jira_issue = MagicMock(
+            key="JIRA-1",
+            fields=MagicMock(
+                summary="Existing Issue",
+                description="Existing issue description",
+                status=open_status,
+                duedate=None,
+                priority=high_priority,
+                statuscategorychangedate="2025-06-12T12:46:34.755961+0000",
+                attachment=None,
+            ),
+        )
+
+        # Create existing RegScale issue (using MagicMock to avoid actual creation)
+        existing_issue = MagicMock(spec=Issue)
+        existing_issue.jiraId = "JIRA-1"
+        existing_issue.isPoam = False  # Initially not a POAM
+        existing_issue.id = 1
+        existing_issue.title = "Existing Issue"
+        regscale_issues = [existing_issue]
+
+        # Create mock config
+        config = {
+            "issues": {"jira": {"highest": 7, "high": 30, "medium": 90, "low": 180, "lowest": 365, "status": "Open"}},
+            "maxThreads": 4,
+            "userId": "123e4567-e89b-12d3-a456-426614174000",
+            "jiraCustomFields": {},
+        }
+        app = MagicMock()
+        app.config = config
+
+        # Setup mock return values
+        mock_save.return_value = MagicMock()
+
         with mock_job_progress_object as job_progress:
             test_task = job_progress.add_task(
-                description="Updating 1 issue(s) in RegScale...",
-                total=len([test_issue]),
+                description="Processing issues",
+                total=1,
                 visible=False,
             )
-            update_regscale_issues(
-                args=([test_issue], test_task),
-                thread=0,
+
+            # Call with use_poams=True
+            create_and_update_regscale_issues(
+                jira_issue,
+                regscale_issues,
+                True,  # use_poams
+                False,  # add_attachments
+                MagicMock(),
+                app,
+                self.PARENT_ID,
+                self.PARENT_MODULE,
+                test_task,
+                job_progress,
             )
-            # make sure the task was marked complete
-            assert test_task.finished
-        # make sure the issue was updated
-        updated_issue = Issue.fetch_issue_by_id(app=self.app, issue_id=test_issue.id)
-        assert updated_issue.assetIdentifier == test_issue.assetIdentifier
-        assert updated_issue.lastUpdatedById == test_issue.lastUpdatedById
+
+            # Verify the existing issue had isPoam set to True
+            assert existing_issue.isPoam is True
 
     @staticmethod
     def teardown_class(cls):