Merge branch 'master' of https://github.com/OpenBazaar/OpenBazaar-Server into brian-stats-collection

Author: cpacia

market/listeners.py

@@ -3,19 +3,20 @@
 import json
 import time
 import random
+from log import Logger
 from api.utils import sanitize_html
 from interfaces import MessageListener, BroadcastListener, NotificationListener
 from zope.interface import implements
 from protos.objects import PlaintextMessage, Following
 from dht.utils import digest
 
-
 class MessageListenerImpl(object):
     implements(MessageListener)
 
     def __init__(self, web_socket_factory, database):
         self.ws = web_socket_factory
         self.db = database
+        self.log = Logger(system=self)
 
     def notify(self, plaintext, signature):
         try:
@@ -45,9 +46,8 @@ def notify(self, plaintext, signature):
                 if plaintext.handle:
                     message_json["message"]["handle"] = plaintext.handle
                 self.ws.push(json.dumps(sanitize_html(message_json), indent=4))
-        except Exception:
-            pass
-
+        except Exception as e:
+            self.log.error('Market.Listener.notify Exception: %s' % e)
 
 class BroadcastListenerImpl(object):
     implements(BroadcastListener)
@@ -60,6 +60,8 @@ def notify(self, guid, message):
         # pull the metadata for this node from the db
         f = Following()
         ser = self.db.follow.get_following()
+        handle = ""
+        avatar_hash = ""
         if ser is not None:
             f.ParseFromString(ser)
             for user in f.users:
@@ -107,7 +109,7 @@ def notify(self, guid, handle, notif_type, order_id, title, image_hash):
                 "image_hash": image_hash.encode("hex")
             }
         }
-        self.ws.push(json.dumps(sanitize_html(notification_json), indent=4))
+        self.push_ws(notification_json)
 
     def push_ws(self, json_obj):
         self.ws.push(json.dumps(sanitize_html(json_obj), indent=4))

market/smtpnotification.py

@@ -14,14 +14,7 @@ class SMTPNotification(object):
 
     def __init__(self, db):
         self.db = db
-        self.server = 'localhost:25'
-        self.sender = 'OpenBazaar'
-        self.recipient = ''
-        self.username = None
-        self.password = None
-
         self.log = Logger(system=self)
-
         self.get_smtp_settings()
 
     def get_smtp_settings(self):
@@ -56,8 +49,8 @@ def send(self, subject, body):
                     server.login(self.username, self.password)
 
                 server.sendmail(self.sender, self.recipient, msg.as_string())
+                server.quit()
             except SMTPAuthenticationError as e:
+                self.log.error('Authentication Error: %s' % e)
+            except Exception as e:
                 self.log.error(e)
-                print e
-
-            server.quit()

market/tests/test_listeners.py

@@ -1,8 +1,9 @@
 from twisted.trial import unittest
 from twisted.python import log
 from mock import MagicMock
+import mock
 
-from market.listeners import MessageListenerImpl
+from market.listeners import MessageListenerImpl, BroadcastListenerImpl, NotificationListenerImpl
 from protos.objects import PlaintextMessage
 
 class MarketListenersTest(unittest.TestCase):
@@ -47,6 +48,7 @@ def _create_valid_message_json(handle):
         return message
 
     def test_MarketListeners_notify_without_handle_success(self):
+        '''MessageListenerImpl correctly notify without handle.'''
         p = self._create_valid_plaintext_message('')
         signature = 'test_signature'
         l = MessageListenerImpl(self.ws, self.db)
@@ -61,6 +63,7 @@ def test_MarketListeners_notify_without_handle_success(self):
         self.ws.push.assert_called_with(self._create_valid_message_json(''))
 
     def test_MarketListeners_notify_with_handle_success(self):
+        '''MessageListenerImpl correctly notify with handle.'''
         p = self._create_valid_plaintext_message('test_handle')
         signature = 'test_signature'
         l = MessageListenerImpl(self.ws, self.db)
@@ -74,3 +77,40 @@ def test_MarketListeners_notify_with_handle_success(self):
                                                          'test_avatar_hash',
                                                          signature, False)
         self.ws.push.assert_called_with(self._create_valid_message_json('test_handle'))
+
+    def test_MarketListeners_save_message_exception(self):
+        p = self._create_valid_plaintext_message('test_handle')
+        signature = 'test_signature'
+        l = MessageListenerImpl(self.ws, self.db)
+        self.db.messages.save_message.side_effect = Exception("test_exception")
+        l.notify(p, signature)
+        self.assertEqual('[ERROR] Market.Listener.notify Exception: test_exception', self.catcher[0]['message'][0])
+
+    def test_MarketListeners_broadcast_notify_success(self):
+        '''BroadcastListenerImpl correctly notifies.'''
+        b = BroadcastListenerImpl(self.ws, self.db)
+        b.notify('123', 'test_message')
+        self.db.broadcasts.save_broadcast.assert_called_once_with(mock.ANY,
+                                                                  '313233', '',
+                                                                  'test_message',
+                                                                  mock.ANY, '')
+        self.ws.push.assert_called_once_with(mock.ANY)
+
+    def test_MarketListeners_notifiation_notify_success(self):
+        n = NotificationListenerImpl(self.ws, self.db)
+        n.notify('1231', 'test_handle', 'test_notify_type', 'test_order_id',
+                 'test_title', 'test_image_hash')
+        self.db.notifications.save_notification.assert_called_once_with(mock.ANY, '31323331', 'test_handle',
+                                                                        'test_notify_type', 'test_order_id',
+                                                                        'test_title', mock.ANY, 'test_image_hash')
+        self.ws.push.assert_called_once_with(mock.ANY)
+
+    def test_MarketListeners_notifiation_push_success(self):
+        notification_json = {
+            "notification": {
+                "guid": "guid"
+            }
+        }
+        n = NotificationListenerImpl(self.ws, self.db)
+        n.push_ws(notification_json)
+        self.ws.push.assert_called_once_with('{\n    "notification": {\n        "guid": "guid"\n    }\n}')

market/tests/test_smtpnotification.py

@@ -0,0 +1,77 @@
+from twisted.trial import unittest
+from twisted.python import log
+from mock import patch, MagicMock
+import mock
+from smtplib import SMTPAuthenticationError
+
+from market.smtpnotification import SMTPNotification
+
+class MarketSMTPTest(unittest.TestCase):
+
+    def setUp(self):
+        self.catcher = []
+        observer = self.catcher.append
+        log.addObserver(observer)
+        self.addCleanup(log.removeObserver, observer)
+        self.db = MagicMock()
+        self.db.settings.get.return_value = ['0', '1', '2', '3', '4', '5', '6',
+                                             '7', '8', '9', '10', '11', '12',
+                                             '13', 1, 'test_server',
+                                             'test_sender', 'test_recipient',
+                                             'test_username', 'test_password']
+
+    def test_MarketSmtp_settings_success(self):
+        '''SMTP Notification settings correctly set.'''
+        s = SMTPNotification(self.db)
+        self.assertEqual('test_server', s.server)
+        self.assertEqual('test_sender', s.sender)
+        self.assertEqual('test_recipient', s.recipient)
+        self.assertEqual('test_username', s.username)
+        self.assertEqual('test_password', s.password)
+
+    @patch("smtplib.SMTP")
+    def test_MarketSmtp_send_enabled_success(self, mock_smtp):
+        '''Email sent when enabled'''
+        instance = mock_smtp.return_value
+        s = SMTPNotification(self.db)
+        s.send('test_subject', 'test_body')
+        mock_smtp.assert_called_once_with('test_server')
+        instance.login.assert_called_once_with('test_username', 'test_password')
+        instance.sendmail.assert_called_once_with('test_sender', 'test_recipient', mock.ANY)
+
+    @patch("smtplib.SMTP")
+    def test_MarketSmtp_send_disabled_not_sent(self, mock_smtp):
+        '''Email not sent when disabled'''
+        instance = mock_smtp.return_value
+        self.db.settings.get.return_value = ['0', '1', '2', '3', '4', '5', '6',
+                                             '7', '8', '9', '10', '11', '12',
+                                             '13', 0, 'test_server',
+                                             'test_sender', 'test_recipient',
+                                             'test_username', 'test_password']
+        s = SMTPNotification(self.db)
+        s.send('test_subject', 'test_body')
+        assert mock_smtp.call_count == 0
+        assert instance.login.call_count == 0
+        assert instance.sendmail.call_count == 0
+
+    @patch("smtplib.SMTP")
+    def test_MarketSmtp_send_throw_smtpexception(self, mock_smtp):
+        '''Email sent when enabled'''
+        catcher = self.catcher
+        mock_smtp.side_effect = SMTPAuthenticationError(50, 'Test error thrown')
+        s = SMTPNotification(self.db)
+        s.send('test_subject', 'test_body')
+        mock_smtp.assert_called_once_with('test_server')
+        catch_exception = catcher.pop()
+        self.assertEquals(catch_exception["message"][0], "[ERROR] Authentication Error: (50, 'Test error thrown')")
+
+    @patch("smtplib.SMTP")
+    def test_MarketSmtp_send_throw_exception(self, mock_smtp):
+        '''Email sent when enabled'''
+        catcher = self.catcher
+        mock_smtp.side_effect = Exception('Test exception thrown')
+        s = SMTPNotification(self.db)
+        s.send('test_subject', 'test_body')
+        mock_smtp.assert_called_once_with('test_server')
+        catch_exception = catcher.pop()
+        self.assertEquals(catch_exception["message"][0], "[ERROR] Test exception thrown")