class JsonRpcBuilderTest(unittest.TestCase):
    def setUp(self):
        self.builder = JsonRpcBuilder()

    def testRequest(self):
        expected = {
            'jsonrpc': '2.0',
            'method': 'testMethod',
            'params': ['testParam'],
            'id': 'test_id'
        }
        request = self.builder.request('testMethod', ['testParam'], "test_id")
        self.assertEqual(ujson.dumps(request), ujson.dumps(expected))

    def testResponse(self):
        expected = {'jsonrpc': '2.0', 'result': 12.43, 'id': 'test_response'}
        response = self.builder.response(12.43, 'test_response')
        self.assertEqual(ujson.dumps(response), ujson.dumps(expected))

    def testResponseWithError(self):
        expected = {
            'jsonrpc': '2.0',
            'error': 'Test Error',
            'id': 'test_error'
        }
        response = self.builder.error_response('Test Error', 'test_error')
        self.assertEqual(ujson.dumps(response), ujson.dumps(expected))

    def testParseResponse(self):
        response = '{"jsonrpc":"2.0","result":12.43,"id":"test_parse"}'
        expected = 12.43
        result = self.builder.parseResponse(response)
        self.assertEqual(expected, result)
예제 #2
0
class RIPMatlabTest(unittest.TestCase):
    def setUp(self):
        self.builder = JsonRpcBuilder()
        self.matlab = RIPMatlab()

    def tearDown(self):
        pass

    def testName(self):
        request = self.builder.request('connect', params=None, request_id='1')
        result = self.matlab.parse(ujson.dumps(request))
        request = self.builder.request('connect', params=[], request_id='1')
        result = self.matlab.parse(ujson.dumps(request))
        print(result)
        request = self.builder.request('get',
                                       params=[['x', 'y']],
                                       request_id='2')
        result = self.matlab.parse(ujson.dumps(request))
        print(result)
        request = self.builder.request('set', params=[['x', 'y'], [12, 7]])
        result = self.matlab.parse(ujson.dumps(request))
        print(result)
        request = self.builder.request('eval', params=['y=2*x;'])
        result = self.matlab.parse(ujson.dumps(request))
        print(result)
        request = self.builder.request('get',
                                       params=[['x', 'y']],
                                       request_id='2')
        result = self.matlab.parse(ujson.dumps(request))
        print(result)
예제 #3
0
 def setUp(self):
     self.builder = JsonRpcBuilder()
     self.matlab = RIPMatlab()
예제 #4
0
 def setUp(self):
     self.builder = JsonRpcBuilder()
     self.server = JsonRpcServer()
     self.server.on('add', {'x', 'y'}, self.add)
예제 #5
0
class JsonRpcServerTest(unittest.TestCase):
    def setUp(self):
        self.builder = JsonRpcBuilder()
        self.server = JsonRpcServer()
        self.server.on('add', {'x', 'y'}, self.add)

    def add(self, x, y):
        return x + y

    def testRpcCallWithPositionalParameters(self):
        expected = {
            'jsonrpc': '2.0',
            'result': 65,
            'id': 1,
        }
        response = self.call('add', [42, 23], 1)
        self.assertEqual(ujson.dumps(expected), ujson.dumps(response))

    def call(self, method, params, request_id):
        request = self.builder.request(method, params, request_id)
        response = self.server.parse(ujson.dumps(request))
        return response

    def testRpcCallWithNamedParameters(self):
        expected = {
            'jsonrpc': '2.0',
            'result': 65,
            'id': 1,
        }
        response = self.call('add', {
            'x': 23,
            'y': 42
        }, 1)
        self.assertEqual(ujson.dumps(expected), ujson.dumps(response))

    def testRpcCallNonExistentMethod(self):
        expected = {
            'jsonrpc': '2.0',
            'error': self.server.METHOD_NOT_FOUND,
            'id': 1,
        }
        response = self.call('foobar', [], 1)
        self.assertEqual(ujson.dumps(expected), ujson.dumps(response))

    def testRpcCallNotification(self):
        expected = None
        response = self.call('add', [42, 23], None)
        self.assertEqual(expected, response)

    def testRpcCallInvalidJson(self):
        expected = {
            'jsonrpc': '2.0',
            'error': self.server.PARSE_ERROR,
            'id': None,
        }
        request = '{"jsonrpc": "2.0", "method": "foobar, "params": "bar", "baz]'
        response = self.server.parse(request)
        self.assertEqual(ujson.dumps(expected), ujson.dumps(response))

    def testRpcCallWithInvalidRequestObject(self):
        expected = {
            'jsonrpc': '2.0',
            'error': self.server.INVALID_REQUEST,
            'id': None,
        }
        request = '{"jsonrpc": "2.0"}'
        response = self.server.parse(request)
        self.assertEqual(ujson.dumps(expected), ujson.dumps(response))

    def testRpcCallBatchWithInvalidJSON(self):
        expected = {
            'jsonrpc': '2.0',
            'error': self.server.PARSE_ERROR,
            'id': None,
        }
        request = '[{"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"}, {"jsonrpc": "2.0", "method"]'
        response = self.server.parse(request)
        self.assertEqual(ujson.dumps(response), ujson.dumps(expected))

    def testRpcCallBatchEmptyArray(self):
        expected = {
            'jsonrpc': '2.0',
            'error': self.server.INVALID_REQUEST,
            'id': None,
        }
        request = '[]'
        response = self.server.parse(request)
        self.assertEqual(ujson.dumps(response), ujson.dumps(expected))

    def testRpcCallInvalidBatchOne(self):
        expected = [{
            'jsonrpc': '2.0',
            'error': self.server.INVALID_REQUEST,
            'id': None,
        }]
        request = '[1]'
        response = self.server.parse(request)
        self.assertEqual(ujson.dumps(response), ujson.dumps(expected))

    def testRpcCallInvalidBatchThree(self):
        expected = [
            {
                'jsonrpc': '2.0',
                'error': self.server.INVALID_REQUEST,
                'id': None,
            },
            {
                'jsonrpc': '2.0',
                'error': self.server.INVALID_REQUEST,
                'id': None,
            },
            {
                'jsonrpc': '2.0',
                'error': self.server.INVALID_REQUEST,
                'id': None,
            },
        ]
        request = '[1, 2, 3]'
        response = self.server.parse(request)
        self.assertEqual(ujson.dumps(response), ujson.dumps(expected))

    def testRpcCallBatch(self):
        expected = [
            {
                'jsonrpc': '2.0',
                'result': 35,
                'id': 1
            },
            {
                'jsonrpc': '2.0',
                'error': self.server.INVALID_REQUEST,
                'id': None
            },
            {
                'jsonrpc': '2.0',
                'error': self.server.METHOD_NOT_FOUND,
                'id': 5
            },
        ]
        request = [
            self.builder.request('add', [23, 12], 1),
            {
                'jsonrpc': '2.0'
            },
            self.builder.request('foo.get', [23], 5),
        ]
        response = self.server.parse(ujson.dumps(request))
        self.assertEqual(ujson.dumps(response), ujson.dumps(expected))
예제 #6
0
'''
@author: jcsombria
'''
from jsonrpc.JsonRpcServer import JsonRpcServer
from jsonrpc.JsonRpcBuilder import JsonRpcBuilder
from rip.core.RIPMeta import *
import samplers

builder = JsonRpcBuilder()


class RIPGeneric(JsonRpcServer):
    '''
  RIP Server - Reference Implementation
  '''
    def __init__(self, info={}):
        '''
    Constructor
    '''
        metadata = self._parse_info(info)
        super().__init__(metadata['name'], metadata['description'])
        self.metadata = metadata
        self.ssePeriod = 0.5
        self.sseRunning = False
        self._running = False
        self.addMethods({
            'get': {
                'description': 'To read server variables',
                'params': {
                    'expId': 'string',
                    'variables': '[string]'
 def setUp(self):
     self.builder = JsonRpcBuilder()