add SendReplyJobException

Author: Allie Crevier

securedrop_client/api_jobs/downloads.py

@@ -57,6 +57,8 @@ def get_db_object(self, session: Session) -> Union[File, Message]:
 
     def call_api(self, api_client: API, session: Session) -> Any:
         '''
+        Override ApiJob.
+
         Download and decrypt the file associated with the database object.
         '''
         db_object = self.get_db_object(session)

securedrop_client/api_jobs/uploads.py

@@ -1,62 +1,59 @@
 import logging
 import sdclientapi
-import traceback
 
 from sdclientapi import API
 from sqlalchemy.orm.session import Session
 
 from securedrop_client.api_jobs.base import ApiJob
-from securedrop_client.crypto import GpgHelper
+from securedrop_client.crypto import GpgHelper, CryptoError
 from securedrop_client.db import Reply, Source
 
 logger = logging.getLogger(__name__)
 
 
 class SendReplyJob(ApiJob):
-    def __init__(
-        self,
-        source_uuid: str,
-        reply_uuid: str,
-        message: str,
-        gpg: GpgHelper,
-    ) -> None:
+    def __init__(self, source_uuid: str, reply_uuid: str, message: str, gpg: GpgHelper) -> None:
         super().__init__()
         self.source_uuid = source_uuid
         self.reply_uuid = reply_uuid
         self.message = message
         self.gpg = gpg
 
     def call_api(self, api_client: API, session: Session) -> str:
+        '''
+        Override ApiJob.
+
+        Encrypt the reply and send it to the server. If the call is successful, add it to the local
+        database. Otherwise raise a SendReplyJobException.
+        '''
         try:
-            encrypted_reply = self.gpg.encrypt_to_source(self.source_uuid,
-                                                         self.message)
-        except Exception:
-            tb = traceback.format_exc()
-            logger.error('Failed to encrypt to source {}:\n'.format(
-                self.source_uuid, tb))
-            # We raise the exception as it will get handled in ApiJob._do_call_api
-            # Exceptions must be raised for the failure signal to be emitted.
-            raise
-        else:
+            encrypted_reply = self.gpg.encrypt_to_source(self.source_uuid, self.message)
             sdk_reply = self._make_call(encrypted_reply, api_client)
-
-        # Now that the call was successful, add the reply to the database locally.
-        source = session.query(Source).filter_by(uuid=self.source_uuid).one()
-
-        reply_db_object = Reply(
-            uuid=self.reply_uuid,
-            source_id=source.id,
-            journalist_id=api_client.token_journalist_uuid,
-            filename=sdk_reply.filename,
-            content=self.message,
-            is_downloaded=True,
-            is_decrypted=True
-        )
-        session.add(reply_db_object)
-        session.commit()
-        return reply_db_object.uuid
+            # Now that the call was successful, add the reply to the database locally.
+            source = session.query(Source).filter_by(uuid=self.source_uuid).one()
+            reply_db_object = Reply(
+                uuid=self.reply_uuid,
+                source_id=source.id,
+                journalist_id=api_client.token_journalist_uuid,
+                filename=sdk_reply.filename,
+                content=self.message,
+                is_downloaded=True,
+                is_decrypted=True
+            )
+            session.add(reply_db_object)
+            session.commit()
+            return reply_db_object.uuid
+        except CryptoError as ce:
+            raise SendReplyJobException(str(ce), self.reply_uuid)
+        except Exception as e:
+            raise SendReplyJobException(str(e), self.reply_uuid)
 
     def _make_call(self, encrypted_reply: str, api_client: API) -> sdclientapi.Reply:
         sdk_source = sdclientapi.Source(uuid=self.source_uuid)
-        return api_client.reply_source(sdk_source, encrypted_reply,
-                                       self.reply_uuid)
+        return api_client.reply_source(sdk_source, encrypted_reply, self.reply_uuid)
+
+
+class SendReplyJobException(Exception):
+    def __init__(self, message: str, reply_uuid: str):
+        super().__init__(message)
+        self.reply_uuid = reply_uuid

securedrop_client/logic.py

@@ -14,7 +14,7 @@
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
+along with this program.  If not, see <fhttp://www.gnu.org/licenses/>.
 """
 import arrow
 import inspect
@@ -33,7 +33,7 @@
 from securedrop_client import db
 from securedrop_client.api_jobs.downloads import FileDownloadJob, MessageDownloadJob, \
     ReplyDownloadJob
-from securedrop_client.api_jobs.uploads import SendReplyJob
+from securedrop_client.api_jobs.uploads import SendReplyJob, SendReplyJobException
 from securedrop_client.crypto import GpgHelper, CryptoError
 from securedrop_client.queue import ApiJobQueue
 from securedrop_client.utils import check_dir_permissions
@@ -619,13 +619,12 @@ def send_reply(self, source_uuid: str, reply_uuid: str, message: str) -> None:
         self.api_job_queue.enqueue(job)
 
     def on_reply_success(self, reply_uuid: str) -> None:
-        logger.debug('Reply send success: {}'.format(reply_uuid))
+        logger.debug('{} sent successfully'.format(reply_uuid))
         self.reply_succeeded.emit(reply_uuid)
 
-    def on_reply_failure(self, reply_uuid: str) -> None:
-        self.set_status(_('Reply failed to send'))
-        logger.debug('Reply send failure: {}'.format(reply_uuid))
-        self.reply_failed.emit(reply_uuid)
+    def on_reply_failure(self, exception: SendReplyJobException) -> None:
+        logger.debug('{} failed to send'.format(exception.reply_uuid))
+        self.reply_failed.emit(exception.reply_uuid)
 
     def get_file(self, file_uuid: str) -> db.File:
         file = storage.get_file(self.session, file_uuid)

tests/api_jobs/test_downloads.py

@@ -224,7 +224,6 @@ def test_MessageDownloadJob_with_base_error(mocker, homedir, session, session_ma
     gpg = GpgHelper(homedir, session_maker, is_qubes=False)
     job = MessageDownloadJob(message.uuid, homedir, gpg)
     api_client = mocker.MagicMock()
-    api_client = mocker.MagicMock()
     mocker.patch.object(api_client, 'download_submission', side_effect=BaseError)
     decrypt_fn = mocker.patch.object(job.gpg, 'decrypt_submission_or_reply')
 
@@ -460,8 +459,7 @@ def test_FileDownloadJob_decryption_error(mocker, homedir, session, session_make
     session.commit()
 
     gpg = GpgHelper(homedir, session_maker, is_qubes=False)
-    mock_decrypt = mocker.patch.object(gpg, 'decrypt_submission_or_reply',
-                                       side_effect=CryptoError)
+    mock_decrypt = mocker.patch.object(gpg, 'decrypt_submission_or_reply', side_effect=CryptoError)
 
     def fake_download(sdk_obj: SdkSubmission) -> Tuple[str, str]:
         '''

tests/api_jobs/test_uploads.py

@@ -2,7 +2,7 @@
 import sdclientapi
 
 from securedrop_client import db
-from securedrop_client.api_jobs.uploads import SendReplyJob
+from securedrop_client.api_jobs.uploads import SendReplyJob, SendReplyJobException
 from securedrop_client.crypto import GpgHelper, CryptoError
 from tests import factory
 
@@ -54,7 +54,9 @@ def test_send_reply_success(homedir, mocker, session, session_maker):
 
 def test_send_reply_failure_gpg_error(homedir, mocker, session, session_maker):
     '''
-    Check that if gpg fails when sending a message, we do not call the API.
+    Check that if gpg fails when sending a message, we do not call the API, and ensure that
+    SendReplyJobException is raised when there is a CryptoError so we can handle it in
+    ApiJob._do_call_api.
     '''
     source = factory.Source()
     session.add(source)
@@ -84,8 +86,7 @@ def test_send_reply_failure_gpg_error(homedir, mocker, session, session_maker):
         gpg,
     )
 
-    # Ensure that the CryptoError is raised so we can handle it in ApiJob._do_call_api
-    with pytest.raises(CryptoError):
+    with pytest.raises(SendReplyJobException):
         job.call_api(api_client, session)
 
     # Ensure we attempted to encrypt the message
@@ -95,3 +96,25 @@ def test_send_reply_failure_gpg_error(homedir, mocker, session, session_maker):
     # Ensure reply did not get added to db
     replies = session.query(db.Reply).filter_by(uuid=msg_uuid).all()
     assert len(replies) == 0
+
+
+def test_send_reply_failure_unknown_error(homedir, mocker, session, session_maker):
+    '''
+    Check that if the reply_source api call fails when sending a message that SendReplyJobException
+    is raised and the reply is not added to the local database.
+    '''
+    source = factory.Source()
+    session.add(source)
+    session.commit()
+    api_client = mocker.MagicMock()
+    mocker.patch.object(api_client, 'reply_source', side_effect=Exception)
+    gpg = GpgHelper(homedir, session_maker, is_qubes=False)
+    encrypt_fn = mocker.patch.object(gpg, 'encrypt_to_source')
+    job = SendReplyJob(source.uuid, 'mock_reply_uuid', 'mock_message', gpg)
+
+    with pytest.raises(Exception):
+        job.call_api(api_client, session)
+
+    encrypt_fn.assert_called_once_with(source.uuid, 'mock_message')
+    replies = session.query(db.Reply).filter_by(uuid='mock_reply_uuid').all()
+    assert len(replies) == 0

tests/test_logic.py

@@ -5,7 +5,6 @@
 import arrow
 import os
 import pytest
-import sdclientapi
 
 from PyQt5.QtCore import Qt
 from sdclientapi import RequestTimeoutError
@@ -14,6 +13,7 @@
 from securedrop_client import storage, db
 from securedrop_client.crypto import CryptoError
 from securedrop_client.logic import APICallRunner, Controller
+from securedrop_client.api_jobs.uploads import SendReplyJobException
 
 with open(os.path.join(os.path.dirname(__file__), 'files', 'test-key.gpg.pub.asc')) as f:
     PUB_KEY = f.read()
@@ -1152,39 +1152,34 @@ def test_Controller_on_reply_success(homedir, mocker, session_maker, session):
     '''
     Check that when the method is called, the client emits the correct signal.
     '''
-
-    mock_gui = mocker.MagicMock()
-
-    co = Controller('http://localhost', mock_gui, session_maker, homedir)
-    co.api = mocker.Mock()
-
-    reply = sdclientapi.Reply(uuid='wat', filename='1-lol')
-
-    mock_reply_succeeded = mocker.patch.object(co, 'reply_succeeded')
-    mock_reply_failed = mocker.patch.object(co, 'reply_failed')
+    co = Controller('http://localhost', mocker.MagicMock(), session_maker, homedir)
+    reply_succeeded = mocker.patch.object(co, 'reply_succeeded')
+    reply_failed = mocker.patch.object(co, 'reply_failed')
+    reply = factory.Reply(source=factory.Source())
+    debug_logger = mocker.patch('securedrop_client.logic.logger.debug')
 
     co.on_reply_success(reply.uuid)
-    mock_reply_succeeded.emit.assert_called_once_with(reply.uuid)
-    assert not mock_reply_failed.emit.called
+
+    debug_logger.assert_called_once_with('{} sent successfully'.format(reply.uuid))
+    reply_succeeded.emit.assert_called_once_with(reply.uuid)
+    reply_failed.emit.assert_not_called()
 
 
 def test_Controller_on_reply_failure(homedir, mocker, session_maker):
     '''
     Check that when the method is called, the client emits the correct signal.
     '''
-    mock_gui = mocker.MagicMock()
-
-    co = Controller('http://localhost', mock_gui, session_maker, homedir)
-    co.api = mocker.Mock()
-
-    reply = sdclientapi.Reply(uuid='wat', filename='1-lol')
+    co = Controller('http://localhost', mocker.MagicMock(), session_maker, homedir)
+    reply_succeeded = mocker.patch.object(co, 'reply_succeeded')
+    reply_failed = mocker.patch.object(co, 'reply_failed')
+    debug_logger = mocker.patch('securedrop_client.logic.logger.debug')
 
-    mock_reply_succeeded = mocker.patch.object(co, 'reply_succeeded')
-    mock_reply_failed = mocker.patch.object(co, 'reply_failed')
+    exception = SendReplyJobException('mock_error_message', 'mock_reply_uuid')
+    co.on_reply_failure(exception)
 
-    co.on_reply_failure(reply.uuid)
-    mock_reply_failed.emit.assert_called_once_with(reply.uuid)
-    assert not mock_reply_succeeded.emit.called
+    debug_logger.assert_called_once_with('{} failed to send'.format('mock_reply_uuid'))
+    reply_failed.emit.assert_called_once_with('mock_reply_uuid')
+    reply_succeeded.emit.assert_not_called()
 
 
 def test_Controller_is_authenticated_property(homedir, mocker, session_maker):