Fix bug with validationerror not being raised

Added tests to check that all requests returns an error
when the data is incorrect

Author: Insoleet

_ucoinpy_test/api/bma/test_blockchain.py

@@ -1,10 +1,11 @@
 import unittest
 import jsonschema
+from _ucoinpy_test.api.webserver import WebFunctionalSetupMixin, web, asyncio
 from ucoinpy.api.bma.blockchain import Parameters, Block, Current, Hardship, Membership, Newcomers, \
     Certifications, Joiners, Actives, Leavers, UD, TX
 
 
-class Test_BMA_Blockchain(unittest.TestCase):
+class Test_BMA_Blockchain(WebFunctionalSetupMixin, unittest.TestCase):
     def test_parameters(self):
         json_sample = {
           "currency": "meta_brouzouf",
@@ -25,6 +26,22 @@ def test_parameters(self):
         }
         jsonschema.validate(json_sample, Parameters.schema)
 
+    def test_parameters_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            params = Parameters(None)
+            params.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from params.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_block_0(self):
         json_sample = {
   "version": 1,
@@ -79,6 +96,38 @@ def test_schema_block_0(self):
         jsonschema.validate(json_sample, Block.schema)
         jsonschema.validate(json_sample, Current.schema)
 
+    def test_block_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/100', handler)
+            block = Block(None, 100)
+            block.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from block.get()
+
+        self.loop.run_until_complete(go())
+
+    def test_current_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            current = Current(None)
+            current.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from current.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_block(self):
         json_sample = {
             "version": 1,
@@ -125,6 +174,22 @@ def test_schema_hardship(self):
         }
         jsonschema.validate(json_sample, Hardship.schema)
 
+    def test_hardship_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/fingerprint', handler)
+            hardship = Hardship(None, "fingerprint")
+            hardship.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from hardship.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_membership(self):
         json_sample = {
             "pubkey": "8Fi1VSTbjkXguwThF4v2ZxC5whK7pwG2vcGTkPUPjPGU",
@@ -149,6 +214,22 @@ def test_schema_membership(self):
         }
         jsonschema.validate(json_sample, Membership.schema)
 
+    def test_membership_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/pubkey', handler)
+            membership = Membership(None, "pubkey")
+            membership.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from membership.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_newcomers(self):
         json_sample = {
             "result": {
@@ -157,6 +238,22 @@ def test_schema_newcomers(self):
         }
         jsonschema.validate(json_sample, Newcomers.schema)
 
+    def test_newcomers_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            newcomers = Newcomers(None)
+            newcomers.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from newcomers.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_certifications(self):
         json_sample = {
             "result": {
@@ -165,6 +262,22 @@ def test_schema_certifications(self):
         }
         jsonschema.validate(json_sample, Certifications.schema)
 
+    def test_certifications_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            certs = Certifications(None)
+            certs.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from certs.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_joiners(self):
         json_sample = {
             "result": {
@@ -173,6 +286,22 @@ def test_schema_joiners(self):
         }
         jsonschema.validate(json_sample, Joiners.schema)
 
+    def test_joiners_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            joiners = Joiners(None)
+            joiners.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from joiners.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_actives(self):
         json_sample = {
             "result": {
@@ -181,6 +310,22 @@ def test_schema_actives(self):
         }
         jsonschema.validate(json_sample, Actives.schema)
 
+    def test_actives_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            actives = Actives(None)
+            actives.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from actives.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_leavers(self):
         json_sample = {
             "result": {
@@ -189,6 +334,22 @@ def test_schema_leavers(self):
         }
         jsonschema.validate(json_sample, Leavers.schema)
 
+    def test_leavers_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            leavers = Leavers(None)
+            leavers.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from leavers.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_ud(self):
         json_sample = {
             "result": {
@@ -197,10 +358,42 @@ def test_schema_ud(self):
         }
         jsonschema.validate(json_sample, UD.schema)
 
+    def test_ud_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            ud = UD(None)
+            ud.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from ud.get()
+
+        self.loop.run_until_complete(go())
+
     def test_schema_tx(self):
         json_sample = {
             "result": {
                 "blocks": [223, 813]
             }
         }
         jsonschema.validate(json_sample, TX.schema)
+
+    def test_tx_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            tx = TX(None)
+            tx.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from tx.get()
+
+        self.loop.run_until_complete(go())

_ucoinpy_test/api/bma/test_network.py

@@ -1,11 +1,12 @@
 import unittest
 import jsonschema
 from ucoinpy.api.bma.network import Peering
-from ucoinpy.api.bma.network.peering import Peers, Status
+from _ucoinpy_test.api.webserver import WebFunctionalSetupMixin, web, asyncio
+from ucoinpy.api.bma.network.peering import Peers
 
 
-class Test_BMA_Network(unittest.TestCase):
-    
+class Test_BMA_Network(WebFunctionalSetupMixin, unittest.TestCase):
+
     def test_peering(self):
         json_sample = {
           "version": "1",
@@ -20,6 +21,21 @@ def test_peering(self):
         }
         jsonschema.validate(json_sample, Peering.schema)
 
+    def test_peering_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            peering = Peering(None)
+            peering.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from peering.get()
+
+        self.loop.run_until_complete(go())
 
     def test_peers_root(self):
         json_sample = {
@@ -45,4 +61,20 @@ def test_peers_leaf(self):
             "signature": "42yQm4hGTJYWkPg39hQAUgP6S6EQ4vTfXdJuxKEHL1ih6YHiDL2hcwrFgBHjXLRgxRhj2VNVqqc6b4JayKqTE14r"
           }
         }
-        jsonschema.validate(json_sample, Peers.schema)
+        jsonschema.validate(json_sample, Peers.schema)
+
+    def test_peers_bad(self):
+        @asyncio.coroutine
+        def handler(request):
+            yield from request.read()
+            return web.Response(body=b'{}', content_type='application/json')
+
+        @asyncio.coroutine
+        def go():
+            _, srv, url = yield from self.create_server('GET', '/', handler)
+            peers = Peers(None)
+            peers.reverse_url = lambda path: url
+            with self.assertRaises(jsonschema.exceptions.ValidationError):
+                yield from peers.get()
+
+        self.loop.run_until_complete(go())