Merge pull request #66 from lbryio/add-tests-blob-handler

add tests for BlobRequestHandler and run on travis

lbrynet/core/server/BlobRequestHandler.py

@@ -140,6 +140,7 @@ class BlobRequestHandler(object):
         def set_expected_payment():
             log.info("Setting expected payment")
             if self.blob_bytes_uploaded != 0 and self.blob_data_payment_rate is not None:
+                # TODO: explain why 2**20
                 self.wallet.add_expected_payment(self.peer,
                                                  self.currently_uploading.length * 1.0 *
                                                  self.blob_data_payment_rate / 2**20)
@@ -156,4 +157,4 @@ class BlobRequestHandler(object):
             if reason is not None and isinstance(reason, Failure):
                 log.info("Upload has failed. Reason: %s", reason.getErrorMessage())
 
-        return _send_file()
+        return _send_file()

packaging/travis/install_dependencies_and_run_tests.sh

@@ -38,8 +38,8 @@ rm get-pip.py
 
 pip install -r requirements.txt
 
-pip install nose coverage coveralls pylint
+pip install mock pylint
-nosetests --with-coverage --cover-package=lbrynet -v -I functional_tests.py tests/
+trial tests
 # TODO: submit coverage report to coveralls
 
 # TODO: as code quality improves, make pylint be more strict

tests/lbrynet/core/server/test_BlobRequestHandler.py

@@ -0,0 +1,127 @@
+import StringIO
+
+import mock
+from twisted.internet import defer, protocol
+from twisted.test import proto_helpers
+from twisted.trial import unittest
+
+from lbrynet.core import Peer
+from lbrynet.core.server import BlobRequestHandler
+
+
+class TestBlobRequestHandlerQueries(unittest.TestCase):
+    def setUp(self):
+        self.blob_manager = mock.Mock()
+        self.payment_rate_manager = mock.Mock()
+        self.handler = BlobRequestHandler.BlobRequestHandler(
+            self.blob_manager, None, self.payment_rate_manager)
+
+    def test_empty_response_when_empty_query(self):
+        self.assertEqual(
+            {}, self.successResultOf(self.handler.handle_queries({})))
+
+    def test_error_set_when_rate_is_missing(self):
+        query = {'requested_blob': 'blob'}
+        deferred = self.handler.handle_queries(query)
+        response = {'incoming_blob': {'error': 'RATE_UNSET'}}
+        self.assertEqual(response, self.successResultOf(deferred))
+
+    def test_error_set_when_rate_too_low(self):
+        self.payment_rate_manager.accept_rate_blob_data.return_value = False
+        query = {
+            'blob_data_payment_rate': 'way_too_low',
+            'requested_blob': 'blob'
+        }
+        deferred = self.handler.handle_queries(query)
+        response = {
+            'blob_data_payment_rate': 'RATE_TOO_LOW',
+            'incoming_blob': {'error': 'RATE_UNSET'}
+        }
+        self.assertEqual(response, self.successResultOf(deferred))
+
+    def test_response_when_rate_too_low(self):
+        self.payment_rate_manager.accept_rate_blob_data.return_value = False
+        query = {
+            'blob_data_payment_rate': 'way_too_low',
+        }
+        deferred = self.handler.handle_queries(query)
+        response = {
+            'blob_data_payment_rate': 'RATE_TOO_LOW',
+        }
+        self.assertEqual(response, self.successResultOf(deferred))
+
+    def test_blob_unavailable_when_blob_not_validated(self):
+        self.payment_rate_manager.accept_rate_blob_data.return_value = True
+        blob = mock.Mock()
+        blob.is_validated.return_value = False
+        self.blob_manager.get_blob.return_value = defer.succeed(blob)
+        query = {
+            'blob_data_payment_rate': 'rate',
+            'requested_blob': 'blob'
+        }
+        deferred = self.handler.handle_queries(query)
+        response = {
+            'blob_data_payment_rate': 'RATE_ACCEPTED',
+            'incoming_blob': {'error': 'BLOB_UNAVAILABLE'}
+        }
+        self.assertEqual(response, self.successResultOf(deferred))
+
+    def test_blob_unavailable_when_blob_cannot_be_opened(self):
+        self.payment_rate_manager.accept_rate_blob_data.return_value = True
+        blob = mock.Mock()
+        blob.is_validated.return_value = True
+        blob.open_for_reading.return_value = None
+        self.blob_manager.get_blob.return_value = defer.succeed(blob)
+        query = {
+            'blob_data_payment_rate': 'rate',
+            'requested_blob': 'blob'
+        }
+        deferred = self.handler.handle_queries(query)
+        response = {
+            'blob_data_payment_rate': 'RATE_ACCEPTED',
+            'incoming_blob': {'error': 'BLOB_UNAVAILABLE'}
+        }
+        self.assertEqual(response, self.successResultOf(deferred))
+
+    def test_blob_details_are_set_when_all_conditions_are_met(self):
+        self.payment_rate_manager.accept_rate_blob_data.return_value = True
+        blob = mock.Mock()
+        blob.is_validated.return_value = True
+        blob.open_for_reading.return_value = True
+        blob.blob_hash = 'DEADBEEF'
+        blob.length = 42
+        self.blob_manager.get_blob.return_value = defer.succeed(blob)
+        query = {
+            'blob_data_payment_rate': 'rate',
+            'requested_blob': 'blob'
+        }
+        deferred = self.handler.handle_queries(query)
+        response = {
+            'blob_data_payment_rate': 'RATE_ACCEPTED',
+            'incoming_blob': {
+                'blob_hash': 'DEADBEEF',
+                'length': 42
+            }
+        }
+        self.assertEqual(response, self.successResultOf(deferred))
+
+
+class TestBlobRequestHandlerSender(unittest.TestCase):
+    def test_nothing_happens_if_not_currently_uploading(self):
+        handler = BlobRequestHandler.BlobRequestHandler(None, None, None)
+        handler.currently_uploading = None
+        deferred = handler.send_blob_if_requested(None)
+        self.assertEqual(True, self.successResultOf(deferred))
+
+    def test_file_is_sent_to_consumer(self):
+        # TODO: also check that the expected payment values are set
+        consumer = proto_helpers.StringTransport()
+        test_file = StringIO.StringIO('test')
+        handler = BlobRequestHandler.BlobRequestHandler(None, None, None)
+        handler.peer = mock.create_autospec(Peer.Peer)
+        handler.currently_uploading = mock.Mock()
+        handler.read_handle = test_file
+        handler.send_blob_if_requested(consumer)
+        while consumer.producer:
+            consumer.producer.resumeProducing()
+        self.assertEqual(consumer.value(), 'test')