Use queue for source deletion

Add api_jobs/sources.py containing DeleteSourceJob, add its priority
to queue.JOB_PRIORITIES, and use it in logic.delete_source. Add tests.

securedrop_client/api_jobs/sources.py

@@ -0,0 +1,44 @@
+import logging
+import sdclientapi
+
+from sdclientapi import API
+from sqlalchemy.orm.session import Session
+
+from securedrop_client.api_jobs.base import ApiJob
+
+logger = logging.getLogger(__name__)
+
+
+class DeleteSourceJob(ApiJob):
+    def __init__(self, source_uuid: str) -> None:
+        super().__init__()
+        self.source_uuid = source_uuid
+
+    def call_api(self, api_client: API, session: Session) -> str:
+        '''
+        Override ApiJob.
+
+        Delete a source on the server
+        '''
+        try:
+            source_sdk_object = sdclientapi.Source(uuid=self.source_uuid)
+
+            # TODO: After
+            # https://github.com/freedomofpress/securedrop-client/issues/648
+            # is merged, we will want to pass the default request
+            # timeout instead of setting it on the api object
+            # directly.
+            api_client.default_request_timeout = 5
+            api_client.delete_source(source_sdk_object)
+
+            return self.source_uuid
+        except Exception as e:
+            error_message = "Failed to delete source {uuid} due to {exception}".format(
+                uuid=self.source_uuid, exception=repr(e))
+            raise DeleteSourceJobException(error_message, self.source_uuid)
+
+
+class DeleteSourceJobException(Exception):
+    def __init__(self, message: str, source_uuid: str):
+        super().__init__(message)
+        self.source_uuid = source_uuid

securedrop_client/logic.py

@@ -34,6 +34,7 @@
 from securedrop_client import db
 from securedrop_client.api_jobs.downloads import FileDownloadJob, MessageDownloadJob, \
     ReplyDownloadJob, DownloadChecksumMismatchException, MetadataSyncJob
+from securedrop_client.api_jobs.sources import DeleteSourceJob
 from securedrop_client.api_jobs.uploads import SendReplyJob, SendReplyJobError, \
     SendReplyJobTimeoutError
 from securedrop_client.api_jobs.updatestar import UpdateStarJob, UpdateStarJobException
@@ -757,20 +758,24 @@ def on_delete_source_failure(self, result: Exception) -> None:
         error = _('Failed to delete source at server')
         self.gui.update_error_status(error)
 
-    def delete_source(self, source):
-        """Performs a delete operation on source record.
+    def delete_source(self, source: db.Source):
+        """
+        Performs a delete operation on source record.
 
-        This method will first request server to delete the source record. If
-        the process of deleting record at server is successful, it will sync
-        the server records with the local state. On failure, it will display an
-        error.
+        This method will submit a job to delete the source record on
+        the server. If the job succeeds, the success handler will
+        synchronize the server records with the local state. If not,
+        the failure handler will display an error.
         """
-        self.call_api(
-            self.api.delete_source,
-            self.on_delete_source_success,
-            self.on_delete_source_failure,
-            source
-        )
+        if not self.api:  # Then we should tell the user they need to login.
+            self.on_action_requiring_login()
+            return
+
+        job = DeleteSourceJob(source.uuid)
+        job.success_signal.connect(self.on_delete_source_success, type=Qt.QueuedConnection)
+        job.failure_signal.connect(self.on_delete_source_failure, type=Qt.QueuedConnection)
+
+        self.api_job_queue.enqueue(job)
 
     def send_reply(self, source_uuid: str, reply_uuid: str, message: str) -> None:
         """

securedrop_client/queue.py

@@ -11,6 +11,7 @@
     PauseQueueJob
 from securedrop_client.api_jobs.downloads import (FileDownloadJob, MessageDownloadJob,
                                                   ReplyDownloadJob, MetadataSyncJob)
+from securedrop_client.api_jobs.sources import DeleteSourceJob
 from securedrop_client.api_jobs.uploads import SendReplyJob
 from securedrop_client.api_jobs.updatestar import UpdateStarJob
 
@@ -45,7 +46,7 @@ class RunnableQueue(QObject):
         FileDownloadJob: 13,  # File downloads processed in separate queue
         MessageDownloadJob: 13,
         ReplyDownloadJob: 13,
-        # DeletionJob: 14,  # Not yet implemented
+        DeleteSourceJob: 14,
         SendReplyJob: 15,
         UpdateStarJob: 16,
         # FlagJob: 16,  # Not yet implemented

tests/api_jobs/test_sources.py

@@ -0,0 +1,45 @@
+import pytest
+
+from securedrop_client.api_jobs.sources import DeleteSourceJob, DeleteSourceJobException
+from tests import factory
+
+
+def test_delete_source_job(homedir, mocker, session, session_maker):
+    '''
+    Test DeleteSourceJob construction and operation.
+    '''
+    source = factory.Source()
+    session.add(source)
+    session.commit()
+
+    api_client = mocker.MagicMock()
+    api_client.delete_source = mocker.MagicMock()
+
+    mock_sdk_source = mocker.Mock()
+    mock_source_init = mocker.patch(
+        'securedrop_client.logic.sdclientapi.Source',
+        return_value=mock_sdk_source
+    )
+
+    job = DeleteSourceJob(source.uuid)
+    job.call_api(api_client, session)
+
+    mock_source_init.assert_called_once_with(uuid=source.uuid)
+    api_client.delete_source.assert_called_once_with(mock_sdk_source)
+
+
+def test_failure_to_delete(homedir, mocker, session, session_maker):
+    '''
+    Check failure of a DeleteSourceJob.
+    '''
+    source = factory.Source()
+    session.add(source)
+    session.commit()
+
+    api_client = mocker.MagicMock()
+    api_client.delete_source = mocker.MagicMock()
+    api_client.delete_source.side_effect = Exception
+
+    job = DeleteSourceJob(source.uuid)
+    with pytest.raises(DeleteSourceJobException):
+        job.call_api(api_client, session)

tests/test_logic.py

@@ -1283,21 +1283,53 @@ def test_Controller_on_delete_source_failure(homedir, config, mocker, session_ma
     co.gui.update_error_status.assert_called_with('Failed to delete source at server')
 
 
-def test_Controller_delete_source(homedir, config, mocker, session_maker):
+def test_Controller_delete_source_not_logged_in(homedir, config, mocker, session_maker):
+    """
+    Deleting a source when not logged in should cause an error.
+
+    Ensure that trying to delete a source when not logged in calls the
+    method that displays an error status in the left sidebar.
+    """
+    mock_gui = mocker.MagicMock()
+    co = Controller('http://localhost', mock_gui, session_maker, homedir)
+    source_db_object = mocker.MagicMock()
+    co.on_action_requiring_login = mocker.MagicMock()
+    co.api = None
+    co.delete_source(source_db_object)
+    co.on_action_requiring_login.assert_called_with()
+
+
+def test_Controller_delete_source(homedir, config, mocker, session_maker, session):
     '''
-    Using the `config` fixture to ensure the config is written to disk.
+    Check that a DeleteSourceJob is submitted when delete_source is called.
     '''
     mock_gui = mocker.MagicMock()
-    mock_source = mocker.MagicMock()
     co = Controller('http://localhost', mock_gui, session_maker, homedir)
     co.call_api = mocker.MagicMock()
     co.api = mocker.MagicMock()
-    co.delete_source(mock_source)
-    co.call_api.assert_called_with(
-        co.api.delete_source,
-        co.on_delete_source_success,
-        co.on_delete_source_failure,
-        mock_source
+
+    mock_success_signal = mocker.MagicMock()
+    mock_failure_signal = mocker.MagicMock()
+    mock_job = mocker.MagicMock(
+        success_signal=mock_success_signal, failure_signal=mock_failure_signal
+    )
+    mock_job_cls = mocker.patch(
+        "securedrop_client.logic.DeleteSourceJob", return_value=mock_job
+    )
+    mock_queue = mocker.patch.object(co, 'api_job_queue')
+
+    source = factory.Source()
+    session.add(source)
+    session.commit()
+
+    co.delete_source(source)
+    mock_job_cls.assert_called_once_with(source.uuid)
+    mock_queue.enqueue.assert_called_once_with(mock_job)
+    mock_success_signal.connect.assert_called_once_with(
+        co.on_delete_source_success, type=Qt.QueuedConnection
+    )
+    mock_failure_signal.connect.assert_called_once_with(
+        co.on_delete_source_failure, type=Qt.QueuedConnection
     )