@@ -30,6 +30,7 @@

 #  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #

 #

+import traceback

 import jsonrpc.jsonutil

 from jsonrpc.utilities import public

 import jsonrpc.common

@@ -40,6 +41,7 @@ from twisted.internet import threads

 from twisted.internet import defer

 from twisted.web.resource import Resource

+import abc

 import copy

 import UserDict, collections

@@ -49,6 +51,11 @@ collections.Mapping.register(UserDict.DictMixin)

 class ServerEvents(object):

 	'''Subclass this and pass to :py:meth:`JSON_RPC.customize` to customize the JSON-RPC server'''

+	DEBUG = False

+

+	#: an object defining a 'get' method which contains the methods

+	methods = None

+

 	def __init__(self, server):

 		#: A link to the JSON-RPC server instance

 		self.server = server

@@ -57,17 +64,35 @@ class ServerEvents(object):

 		'''Find the method and call it with the specified args

 		:returns: the result of the method'''

-		method = self.findmethod(rpcrequest.method)

-		if method is None: raise jsonrpc.common.MethodNotFound

+

 		extra.update(rpcrequest.kwargs)

-		return method(*rpcrequest.args, **extra)

+		method, postprocess_result = self.findmethod(rpcrequest.method, rpcrequest.args, extra), False

+		if hasattr('method', '__iter__'):

+			method, postprocess_result = method

+

+		if self.DEBUG:

+			# Debugging: raise AssertionError if type of method is invalid

+			assert method is None or callable(method), 'the returned method is not callable'

+

+		if not callable(method): raise jsonrpc.common.MethodNotFound

+

+		result = method(*rpcrequest.args, **extra)

+

+		#if the result needs to be adjusted/validated, do it

+		if postprocess_result:

+			result = self.methods.postprocess(rpcrequest.method, result, rpcrequest.args, extra)

+

+		return result

-	def findmethod(self, method_name):

+	def findmethod(self, method_name, args=None, kwargs=None):

 		'''Return the callable associated with the method name

-		:returns: a callable'''

-		raise NotImplementedError

+		:returns: a callable or None if the method is not found'''

+		if self.methods is not None:

+			return self.methods.get_method(method_name)

+		else:

+			raise NotImplementedError

 	def processrequest(self, result, args, **kw):

 		'''Override to implement custom handling of the method result and request'''

@@ -91,11 +116,11 @@ class ServerEvents(object):

 		for example

 			def getresponsecode(self, result):

-		  		code = 200

-		  		if not isinstance(result, list):

-		  			if result is not None and result.error is not None:

-		  				code = result.error.code or 500

-		  		return code

+				code = 200

+				if not isinstance(result, list):

+					if result is not None and result.error is not None:

+						code = result.error.code or 500

+				return code

 		:returns: :py:class:`int`'''

@@ -108,6 +133,19 @@ class ServerEvents(object):

 		:returns: :py:class:`twisted.internet.defer.Deferred`'''

 		return threads.deferToThread(method, *a, **kw)

+	def defer_with_rpcrequest(self, method, rpcrequest, *a, **kw):

+		d = threads.deferToThread(method, rpcrequest, *a, **kw)

+

+		@d.addCallback

+		def _inner(result):

+			return result, rpcrequest

+		@d.addErrback

+		def _inner(result):

+			result.rpcrequest = rpcrequest

+			return result

+

+		return d

+

 ## Base class providing a JSON-RPC 2.0 implementation with 2 customizable hooks

@@ -173,7 +211,7 @@ class JSON_RPC(Resource):

 		if contents == []: raise jsonrpc.common.InvalidRequest

-		def callmethod(request, rpcrequest, add, **kwargs):

+		def callmethod(rpcrequest, request, add, **kwargs):

 			add.update(kwargs)

 			result = self.eventhandler.callmethod(request, rpcrequest, **add)

 			return result

@@ -183,25 +221,31 @@ class JSON_RPC(Resource):

 			res = None

 			add = copy.deepcopy(rpcrequest.extra)

 			add.update(kw)

-			deferreds.append(self.eventhandler.defer(callmethod, request, rpcrequest, add))

+			deferreds.append(self.eventhandler.defer_with_rpcrequest(callmethod, rpcrequest, request, add))

 		deferreds = defer.DeferredList(deferreds, consumeErrors=True)

 		@deferreds.addCallback

 		def helper(deferredresults):

 			result = []

-			for success, methodresult in deferredresults:

-				res = None

-				if success:

-					res = jsonrpc.common.Response(id=rpcrequest.id, result=methodresult)

-					res = self.eventhandler.processrequest(res, request.args, **kw)

-				else:

-					try:

-						methodresult.raiseException()

-					except Exception, e:

-						res = self.render_error(e, rpcrequest.id)

-

-				if res.id is not None:

-					result.append(res)

+			try:

+				for success, methodresult in deferredresults:

+					res = None

+					if success:

+						methodresult, rpcrequest = methodresult

+						res = jsonrpc.common.Response(id=rpcrequest.id, result=methodresult)

+						res = self.eventhandler.processrequest(res, request.args, **kw)

+					else:

+						rpcrequest = methodresult.rpcrequest

+						try:

+							methodresult.raiseException()

+						except Exception, e:

+							res = self.render_error(e, rpcrequest.id)

+

+					if res.id is not None:

+						result.append(res)

+			except Exception, e:

+				traceback.print_exc()

+				raise

 			if result != []:

 				if not islist: result = result[0]

@@ -30,6 +30,7 @@

 #  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #

 #

+import functools

 from twisted.trial import unittest

 import StringIO

@@ -46,7 +47,7 @@ def _render(resource, request):

     result = resource.render(request)

     if isinstance(result, str):

         request.write(result)

-        request.finish()

+        equest.finish()

         return succeed(None)

     elif result is server.NOT_DONE_YET:

         if request.finished:

@@ -59,7 +60,7 @@ def _render(resource, request):

 class SimpleEventHandler(jsonrpc.server.ServerEvents):

 	def log(self, result, request, error=False): pass

-	def findmethod(self, method):

+	def findmethod(self, method, *_, **__):

 		if method in set(['echo', 'add']):

 			return getattr(self, method)

@@ -68,307 +69,269 @@ class SimpleEventHandler(jsonrpc.server.ServerEvents):

 	def echo(self, v): return v

+def TestResource(setup):

+	def _inner1(tests):

+		@functools.wraps(setup)

+		def _inner2(self):

+			resource = jsonrpc.server.JSON_RPC()

+			resource.customize(SimpleEventHandler)

-class TestJSONRPCServer(unittest.TestCase):

-

-	def setUp(self):

-		self.id_ = 'an_id'

-		self.param = "some data"

-

-	def test_eventhandler(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.eventhandler = mock.Mock(jsonrpc.server.ServerEvents)

-		resource.eventhandler.findmethod.return_value = lambda *a, **b: 'test data'

-

-		rv = {"jsonrpc": "2.0", "params": [self.param], "method": "echo", "id": self.id_}

-		resource.eventhandler.processcontent.return_value = rv

-		resource.eventhandler.processrequest.return_value = rv

-

-		request = DummyRequest([''])

-		request.getCookie = mock.Mock()

-		request.content = StringIO.StringIO(jsonrpc.jsonutil.encode(rv))

-

-		d = _render(resource, request)

+			request = DummyRequest([''])

+			request.getCookie = mock.Mock()

-		@d.addCallback

-		def rendered(ignored):

-			self.assertTrue(resource.eventhandler.processcontent.called)

-			self.assertTrue(resource.eventhandler.callmethod.called)

-			self.assertTrue(resource.eventhandler.processrequest.called)

-			self.assertTrue(resource.eventhandler.log.called)

+			result = setup(self, request, resource)

+			if result is not None:

+				request, resource = result

-		return d

+			d = _render(resource, request).addCallback(tests, self, request, resource)

+			return d

+		return _inner2

+	return _inner1

-	def test_requestid(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

-		request0 = DummyRequest([''])

-		request0.getCookie = mock.Mock()

-		request0.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": "%s"}' % (jsonrpc.jsonutil.encode([self.param]), self.id_))

-

-		d0 = _render(resource, request0)

-		@d0.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request0.written), 1)

-			data = jsonrpc.jsonutil.decode(request0.written[0])

+class TestJSONRPCServer(unittest.TestCase):

-			self.assertEqual(data["id"], self.id_)

+	def setUp(self):

+		self.id_ = 'an_id'

+		self.param = "some data"

+	@TestResource

+	def test_eventhandler(self, request, resource):

+		resource.eventhandler = mock.Mock(wraps=resource.eventhandler)

+		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": "%s"}' % (jsonrpc.jsonutil.encode([self.param]), self.id_))

+		return request, resource

+

+	@test_eventhandler

+	def test_eventhandler(ignored, self, request, resource):

+		self.assertTrue( resource.eventhandler.processcontent.called )

+		self.assertTrue( resource.eventhandler.defer_with_rpcrequest.called )

+		self.assertTrue( resource.eventhandler.callmethod.called )

+		self.assertTrue( resource.eventhandler.defer.called )

+		self.assertTrue( resource.eventhandler.getresponsecode.called )

+		self.assertTrue( resource.eventhandler.log.called )

+

+	@TestResource

+	def test_requestid0(self, request, resource):

+		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": "%s"}' % (jsonrpc.jsonutil.encode([self.param]), self.id_))

+		return request, resource

-		request1 = DummyRequest([''])

-		request1.getCookie = mock.Mock()

-		request1.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": 1}' % jsonrpc.jsonutil.encode([self.param]))

+	@test_requestid0

+	def test_requestid0(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

-		d1 = _render(resource, request1)

-		@d1.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request1.written), 1)

-			data = jsonrpc.jsonutil.decode(request1.written[0])

+		self.assertEqual(data["id"], self.id_)

-			self.assertEqual(data["id"], 1)

+	@TestResource

+	def test_requestid1(self, request, resource):

+		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": 1}' % jsonrpc.jsonutil.encode([self.param]))

+		return request, resource

-		request3 = DummyRequest([''])

-		request3.getCookie = mock.Mock()

-		request3.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": []}' % jsonrpc.jsonutil.encode([self.param]))

+	@test_requestid1

+	def test_requestid1(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

-		d3 = _render(resource, request3)

-		@d3.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request3.written), 1)

-			data = jsonrpc.jsonutil.decode(request3.written[0])

+		self.assertEqual(data["id"], 1)

-			self.assertNotEqual(data["id"], [])

-		request4 = DummyRequest([''])

-		request4.getCookie = mock.Mock()

-		request4.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": {}}' % jsonrpc.jsonutil.encode([self.param]))

+	@TestResource

+	def test_requestid2(self, request, resource):

+		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": []}' % jsonrpc.jsonutil.encode([self.param]))

+		return request, resource

-		d4 = _render(resource, request4)

-		@d4.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request4.written), 1)

-			data = jsonrpc.jsonutil.decode(request4.written[0])

+	@test_requestid2

+	def test_requestid2(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

-			self.assertNotEqual(data["id"], {})

+		self.assertNotEqual(data["id"], [])

-		return DeferredList([d0,d1,d3,d4])

+	@TestResource

+	def test_requestid3(self, request, resource):

+		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": {}}' % jsonrpc.jsonutil.encode([self.param]))

+		return request, resource

+	@test_requestid3

+	def test_requestid3(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

-	def test_invalid_data(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

+		self.assertNotEqual(data["id"], {})

-		request = DummyRequest([''])

-		request.getCookie = mock.Mock()

+	@TestResource

+	def test_invalid_data(self, request, resource):

 		request.content = StringIO.StringIO(' {"v": %s}, "method": "echo"}' % (jsonrpc.jsonutil.encode(self.param)))

+		return request, resource

-		d = _render(resource, request)

-

-		@d.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request.written), 1)

-			data = jsonrpc.jsonutil.decode(request.written[0])

-

-			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error."}, "id": None})

+	@test_invalid_data

+	def test_invalid_data(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

-		return d

+		self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error."}, "id": None})

-	def test_wrongversion(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

-		request = DummyRequest([''])

-		request.getCookie = mock.Mock()

+	@TestResource

+	def test_wrongversion(self, request, resource):

 		request.content = StringIO.StringIO('{"jsonrpc": "2.1", "params": %s, "method": "echo", "id": "%s"}' % (jsonrpc.jsonutil.encode([self.param]), self.id_))

-		d = _render(resource, request)

-		@d.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request.written), 1)

-			data = jsonrpc.jsonutil.decode(request.written[0])

-			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": self.id_})

-		return d

+	@test_wrongversion

+	def rendered(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": self.id_})

-	def test_invalidmethodname(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

-

-		request = DummyRequest([''])

-		request.getCookie = mock.Mock()

+	@TestResource

+	def test_invalidmethodname(self, request, resource):

 		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": 0, "id": "%s"}' % (jsonrpc.jsonutil.encode([self.param]), self.id_))

-		d = _render(resource, request)

-

-		@d.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request.written), 1)

-			data = jsonrpc.jsonutil.decode(request.written[0])

-			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": self.id_})

-		return d

-	def test_missingmethod(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

+	@test_invalidmethodname

+	def rendered(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": self.id_})

-		request = DummyRequest([''])

-		request.getCookie = mock.Mock()

+	@TestResource

+	def test_missingmethod(self, request, resource):

 		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "non_existent", "id": "%s"}' % (jsonrpc.jsonutil.encode([self.param]), self.id_))

-		d = _render(resource, request)

-		@d.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request.written), 1)

-			data = jsonrpc.jsonutil.decode(request.written[0])

-			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Procedure not found."}, "id": self.id_})

-		return d

+	@test_missingmethod

+	def rendered(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Procedure not found."}, "id": self.id_})

+	@TestResource

 	def test_simplecall(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

-

-		request = DummyRequest([''])

-		request.getCookie = mock.Mock()

 		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": %s, "method": "echo", "id": "%s"}' % (jsonrpc.jsonutil.encode([self.param]), self.id_))

-		d = _render(resource, request)

-

-		@d.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request.written), 1)

-			data = jsonrpc.jsonutil.decode(request.written[0])

-

-			self.assertEqual(data['id'], self.id_)

-			self.assertEqual(data['result'], self.param)

-		return d

+	@test_simplecall

+	def rendered(ignored):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

-	def test_notify(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

+		self.assertEqual(data['id'], self.id_)

+		self.assertEqual(data['result'], self.param)

-		request = DummyRequest([''])

-		request.getCookie = mock.Mock()

+	@TestResource

+	def test_notify(self, request, resource):

 		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": {"v": %s}, "method": "echo"}' % (jsonrpc.jsonutil.encode(self.param)))

-		d = _render(resource, request)

+	@test_notify

+	def test_notify(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 0)

-		@d.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request.written), 0)

-		return d

-

-

-	def test_kwcall(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

-

-		request = DummyRequest([''])

-		request.getCookie = mock.Mock()

+	@TestResource

+	def _test_kwcall(self, request, resource):

 		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": {"v": %s}, "method": "echo", "id": "%s"}' % (jsonrpc.jsonutil.encode(self.param), self.id_))

-		d = _render(resource, request)

-

-		@d.addCallback

-		def rendered(ignored):

-			self.assertEqual(len(request.written), 1)

-			data = jsonrpc.jsonutil.decode(request.written[0])

+	@_test_kwcall

+	def test_kwcall_id(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

-			self.assertEqual(data['id'], self.id_)

-			self.assertEqual(data['result'], self.param)

+		self.assertEqual(data['id'], self.id_)

-		return d

+	@_test_kwcall

+	def test_kwcall_result(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(data['result'], self.param)

-	def test_err(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

-

-		request = DummyRequest([''])

-		request.getCookie = mock.Mock()

+	@TestResource

+	def test_err(self, request, resource):

 		request.content = StringIO.StringIO('{"jsonrpc": "2.0", "params": [1, "sss"], "method": "add", "id": "%s"}' % self.id_)

+		return request, resource

-		d = _render(resource, request)

-

-		@d.addCallback

-		def rendered(ignored, *a):

-			self.assertEqual(len(request.written), 1)

-			data = jsonrpc.jsonutil.decode(request.written[0])

-

-			self.assertEqual(data['id'], self.id_)

-			self.assertTrue(data.get('error', False))

-		return rendered

+	@test_err

+	def test_err(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+		data = jsonrpc.jsonutil.decode(request.written[0])

-	def test_batchcall(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

+		self.assertEqual(data['id'], self.id_)

+		self.assertTrue(data.get('error', False))

-		request = DummyRequest([''])

+	@TestResource

+	def _test_batchcall(self, request, resource):

 		request.content = StringIO.StringIO(

 			'[{"jsonrpc": "2.0", "params": [1, 2], "method": "add", "id": "1"},'

 				'{"jsonrpc": "2.0", "params": {"a": 3, "b": 2}, "method": "add", "id": "2"}]'

 		)

-		request.getCookie = mock.Mock()

-

-		d = _render(resource, request)

-

-		@d.addCallback

-		def rendered(ignored, *a):

-			self.assertEqual(len(request.written), 1)

-			data = jsonrpc.jsonutil.decode(request.written[0])

-			self.assertEqual(len(data), 2)

-			self.assertEqual(set(x['id'] for x in data), set("12"))

-			self.assertEqual(set(x['result'] for x in data), set([3,5]))

-

-			self.assertFalse(any(x.get('error', False) for x in data))

-		return rendered

-

-	def test_batchcall_1err(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

-

-		request = DummyRequest([''])

+		return request, resource

+

+	@_test_batchcall

+	def test_batchcall1(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

+

+	@_test_batchcall

+	def test_batchcall2(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(len(data), 2)

+

+	@_test_batchcall

+	def test_batchcall3(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(set(x['result'] for x in data), set([3,5]))

+

+	@_test_batchcall

+	def test_batchcall4(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(set(x['id'] for x in data), set("12"))

+

+	@_test_batchcall

+	def test_batchcall5(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertFalse(any(x.get('error', False) for x in data))

+

+	@TestResource

+	def _test_batchcall_1err(self, request, resource):

 		request.content = StringIO.StringIO(

 			'[{"jsonrpc": "2.0", "params": [1, 2], "method": "add", "id": "1"},'

 				'{"jsonrpc": "2.0", "params": {"a": "3", "b": 2}, "method": "add", "id": "2"}]'

 		)

-		request.getCookie = mock.Mock()

+		return request, resource

-		d = _render(resource, request)

+	@_test_batchcall_1err

+	def test_batchcall_1err_1(ignored, self, request, resource):

+		self.assertEqual(len(request.written), 1)

-		@d.addCallback

-		def rendered(ignored, *a):

-			self.assertEqual(len(request.written), 1)

-			data = jsonrpc.jsonutil.decode(request.written[0])

-			self.assertEqual(len(data), 2)

-			self.assertEqual(set(x['id'] for x in data), set("12"))

-			self.assertEqual(set(x.get('result', False) for x in data), set([3,False]))

+	@_test_batchcall_1err

+	def test_batchcall_1err_2(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(len(data), 2)

-			self.assertEqual(len(filter(None, [x.get('error') for x in data])), 1)

-		return rendered

+	@_test_batchcall_1err

+	def test_batchcall_1err_3(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(set(x['id'] for x in data), set("12"))

+	@_test_batchcall_1err

+	def test_batchcall_1err_4(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(set(x.get('result', False) for x in data), set([3,False]))

-	def test_batchcall_emptylist(self):

-		resource = jsonrpc.server.JSON_RPC()

-		resource.customize(SimpleEventHandler)

+	@_test_batchcall_1err

+	def test_batchcall_1err_5(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(len(filter(None, [x.get('error') for x in data])), 1)

-		request = DummyRequest([''])

+	@TestResource

+	def _test_batchcall_emptylist(self, request, resource):

 		request.content = StringIO.StringIO('[]')

-		request.getCookie = mock.Mock()

-

-		d = _render(resource, request)

-		@d.addCallback

-		def rendered(ignored, *a):

-			data = jsonrpc.jsonutil.decode(request.written[0])

-			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": None})

-		return rendered

+	@_test_batchcall_emptylist

+	def test_batchcall_emptylist(ignored, self, request, resource):

+		data = jsonrpc.jsonutil.decode(request.written[0])

+		self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": None})