@@ -32,4 +32,10 @@

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

 #  

 #

+try: import json

+except ImportError:

+	import simplejson as json

+	import sys

+	sys.modules['json'] = json

+

 __version__ = "$Revision: 1.2 $".split(":")[1][:-1].strip()

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

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

 #

 #

+import warnings

 from jsonrpc.utilities import public

 import jsonrpc.jsonutil

@@ -80,18 +81,20 @@ codemap = {0: RPCError}

 codemap.update( (e.code, e) for e in RPCError.__subclasses__() )

 class JsonInstantiate:

-   @classmethod

-   def from_json(cls, json):

-      data = jsonrpc.jsonutil.decode(json)

-      if isinstance(data, list):

-         result = cls.from_list(data)

-      else:

-         result = cls.from_dict(data)

-      return result

+	@classmethod

+	def from_json(cls, json):

+		data = json

+		if hasattr(json, 'upper'):

+			data = jsonrpc.jsonutil.decode(json)

+		if isinstance(data, list):

+			result = cls.from_list(data)

+		else:

+			result = cls.from_dict(data)

+		return result

-   @classmethod

-   def from_list(cls, responses):

-      return [cls.from_dict(r) for r in responses]

+	@classmethod

+	def from_list(cls, responses):

+		return [cls.from_dict(r) for r in responses]

 class Request(object, JsonInstantiate):

@@ -127,6 +130,9 @@ class Request(object, JsonInstantiate):

 	def check(self):

 		if self.version != '2.0': raise InvalidRequest

 		if not isinstance(self.method, (str, unicode)): raise InvalidRequest

+		if not isinstance(self.id, (str, unicode, int, type(None))):

+			self.id = None

+			raise InvalidRequest

 	def json_equivalent(self):

@@ -137,7 +143,7 @@ class Request(object, JsonInstantiate):

 		if self.args and self.kwargs:

 			self.kwargs['__args'] = self.args

 		if self.kwargs:

-			result['params'] = self.kwargs

+			params = self.kwargs

 		return dict(

 			jsonrpc = self.version,

@@ -82,7 +82,7 @@ class ProxyEvents(object):

 		self.IDGen = self.IDGen()

 		self.proxy = proxy

-	def get_postdata(self, args, kwargs):

+	def get_params(self, args, kwargs):

 		'''allow a subclass to modify the method's arguments

 		e.g. if an authentication token is necessary, the subclass can automatically insert it into every call'''

@@ -108,14 +108,15 @@ class JSONRPCProxy(object):

 	_eventhandler = ProxyEvents

 	def customize(self, eventhandler):

 		self._eventhandler = eventhandler(self)

+		return self

 	def _transformURL(self, serviceURL, path):

-		if serviceURL[-1] == '/':

+		if serviceURL.endswith('/'):

 			serviceURL = serviceURL[:-1]

-		if path[0] != '/':

-			path = '/%s'%path

-		if path[-1] != '/' and '?' not in path:

-			path = '%s/'%path

+		if path.endswith('/'):

+			path = path[:-1]

+		if path.startswith('/'):

+			path = path[1:]

 		return serviceURL, path

@@ -131,7 +132,7 @@ class JSONRPCProxy(object):

 		return cls(url, path, serviceName, ctxid)

-	def __init__(self, host, path='/jsonrpc', serviceName=None, *args, **kwargs):

+	def __init__(self, host, path='jsonrpc', serviceName=None, *args, **kwargs):

 		self.serviceURL = host

 		self._serviceName = serviceName

 		self._path = path

@@ -143,19 +144,25 @@ class JSONRPCProxy(object):

 	def __getattr__(self, name):

 		if self._serviceName != None:

 			name = "%s.%s" % (self._serviceName, name)

-		return self.__class__(self.serviceURL, path=self._path, serviceName=name)

+		return self.__class__(self.serviceURL, path=self._path, serviceName=name).customize(type(self._eventhandler))

 	def _get_postdata(self, args=None, kwargs=None):

-		args,kwargs = self._eventhandler.get_postdata(args, kwargs)

+		_args, _kwargs = self._eventhandler.get_params(args, kwargs)

 		id = self._eventhandler.IDGen

-		result = Request(id, self._serviceName, args, kwargs)

+		result = Request(id, self._serviceName, _args, _kwargs)

 		return jsonrpc.jsonutil.encode(result)

+	def _get_url(self):

+		result = [self.serviceURL]

+		if self._path:

+			result.append(self._path)

+		result.append('')

+		return '/'.join(result)

 	def __call__(self, *args, **kwargs):

-		url = '%(host)s%(path)s' % dict(host = self.serviceURL, path = self._path)

+		url = self._get_url()

 		postdata = self._get_postdata(args, kwargs)

 		respdata = urllib.urlopen(url, postdata).read()

 		resp = Response.from_dict(jsonrpc.jsonutil.decode(respdata))

@@ -184,7 +191,7 @@ class JSONRPCProxy(object):

 		if hasattr(methods, 'items'): methods = methods.items()

 		data = [ getattr(self, k)._get_postdata(*v) for k, v in methods ]

 		postdata = '[%s]' % ','.join(data)

-		respdata = urllib.urlopen(self.serviceURL, postdata).read()

+		respdata = urllib.urlopen(self._get_url(), postdata).read()

 		resp = Response.from_json(respdata)

 		try:

 			result = resp.get_result()

@@ -107,10 +107,7 @@ class JSON_RPC(Resource):

 			content = self.eventhandler.processcontent(content, request)

-			if isinstance(content, list):

-				content = jsonrpc.common.Request.from_list(content)

-			else:

-				content = jsonrpc.common.Request.from_dict(content)

+			content = jsonrpc.common.Request.from_json(content)

 			try:

 				if hasattr(content, 'check'):

@@ -179,6 +176,7 @@ class JSON_RPC(Resource):

 			except BaseException, e:

 				err = e

 		else: err = result

+

 		err = self.render_error(err, id)

 		self.eventhandler.log(err, request)

@@ -31,7 +31,7 @@

 #  

 #

 import json

-import unittest

+from twisted.trial import unittest

 import collections

 from jsonrpc import jsonutil

new file mode 100644

@@ -0,0 +1,95 @@

+import jsonrpc.common

+import jsonrpc.proxy

+from twisted.trial import unittest

+import mock

+import urllib

+import StringIO

+

+# Run example server before tests

+

+class TestJSONRPCProxy(unittest.TestCase):

+

+	def setUp(self):

+		self.proxy = jsonrpc.proxy.JSONRPCProxy('http://localhost:8007', path='aaa')

+

+	def test_eventhandler(self):

+		eventhandler = mock.MagicMock(spec=jsonrpc.proxy.ProxyEvents)

+		args = (1,2)

+		kwargs = {'a':1, 'b':2}

+

+		def get_params(self, args, kwargs):

+			print args, kwargs

+			return args, kwargs

+		eventhandler.get_params.side_effect = get_params

+

+		eventhandler.proc_response.side_effect = lambda _, data: data

+

+		self.proxy = jsonrpc.proxy.JSONRPCProxy.from_url('http://localhost:8007')

+		self.proxy.customize(lambda *a: eventhandler)

+		self.assertEqual(self.proxy._get_url(), 'http://localhost:8007/')

+

+		self.proxy.add(*args)

+		self.assertTrue(eventhandler.get_params.called)

+		eventhandler.get_params.assert_called_once_with( args, {} )

+		self.assertTrue(eventhandler.procresponse.called)

+

+		eventhandler.reset_mock()

+

+		self.proxy.add(**kwargs)

+		self.assertTrue(eventhandler.get_params.called)

+		eventhandler.get_params.assert_called_once_with( (), kwargs )

+		self.assertTrue(eventhandler.procresponse.called)

+

+

+	def test_url(self):

+		self.proxy = jsonrpc.proxy.JSONRPCProxy.from_url('http://localhost:8007')

+		self.assertEqual(self.proxy._get_url(), 'http://localhost:8007/')

+

+		self.proxy = jsonrpc.proxy.JSONRPCProxy.from_url('http://localhost:8007/aaa/')

+		self.assertEqual(self.proxy._get_url(), 'http://localhost:8007/aaa/')

+

+		self.proxy = jsonrpc.proxy.JSONRPCProxy.from_url('http://localhost:8007/aaa')

+		self.assertEqual(self.proxy._get_url(), 'http://localhost:8007/aaa/')

+

+		self.proxy = jsonrpc.proxy.JSONRPCProxy('http://localhost:8007')

+		self.assertEqual(self.proxy._get_url(), 'http://localhost:8007/jsonrpc/')

+

+		self.proxy = jsonrpc.proxy.JSONRPCProxy('http://localhost:8007', path='aaa')

+		self.assertEqual(self.proxy._get_url(), 'http://localhost:8007/aaa/')

+

+	def test_call(self):

+		self.assertEqual(self.proxy.add(1,2), 3)

+		self.assertEqual(self.proxy.subtract(2,1), 1)

+

+	def test_exceptions(self):

+		self.assertRaises(jsonrpc.common.RPCError, self.proxy.add, 1,'2')

+		self.assertRaises(jsonrpc.common.MethodNotFound, self.proxy.missingmethod)

+

+	def test_batchcall(self):

+		batch =[

+			('add',      [ (1,2), {} ]),

+			('subtract', [ (2,1), {} ]),

+			('add',      [ (1,3), {} ])

+		]

+		self.assertEqual(self.proxy.batch_call(batch), [(3, None), (1, None), (4, None)])

+

+		batch =[

+			('add',			[ (),    dict(a=1,b=2) ]),

+			('subtract',	[ (2,1), dict() ]),

+			('add',			[ (1,3), dict() ])

+		]

+		self.assertEqual(self.proxy.batch_call(batch), [(3, None), (1, None), (4, None)])

+

+		batch =[

+			('add', 			[ (), dict(a=1,b=2) ]),

+			('subtract', 	[ (), dict(a=2,b=1) ]),

+			('add', 			[ (), dict(a=1,b=3) ])

+		]

+		self.assertEqual(self.proxy.batch_call(batch), [(3, None), (1, None), (4, None)])

+

+

+	#def test_<testname here>(self):

+	#	pass

+

+if __name__ == '__main__':

+	unittest.main()

@@ -39,7 +39,7 @@ import jsonrpc.server

 import jsonrpc.jsonutil

 from twisted.web.test.test_web import DummyRequest

-from twisted.internet.defer import succeed

+from twisted.internet.defer import succeed, DeferredList

 from twisted.web.static import server

 def _render(resource, request):

@@ -99,6 +99,62 @@ class TestJSONRPCServer(unittest.TestCase):

 		return d

+	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])

+

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

+

+

+		request1 = DummyRequest([''])

+		request1.getCookie = mock.Mock()

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

+

+		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"], 1)

+

+

+		request3 = DummyRequest([''])

+		request3.getCookie = mock.Mock()

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

+

+		d3 = _render(resource, request3)

+		@d3.addCallback

+		def rendered(ignored):

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

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

+

+			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]))

+

+		d4 = _render(resource, request4)

+		@d4.addCallback

+		def rendered(ignored):

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

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

+

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

+

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

+

 	def test_invalid_data(self):

 		resource = jsonrpc.server.JSON_RPC()