def test_broadcast_incoming_value_changes(self):
# params
pars = Params()
pars.string('name')
pars.int('age')
# server
s = Server(pars)
# remote r1
r1 = Remote()
s.connect(r1)
# remote r2
r2_value_log = []
def onval(path, val):
print('--- on val {}'.format(path))
r2_value_log.append((path, val))
r2 = Remote()
r2.outgoing.sendValueEvent += onval
s.connect(r2)
self.assertEqual(r2_value_log, [])
# remote r1 send value change to server
r1.incoming.valueEvent('/age', 41)
# verify the change was broadcasted to r2
self.assertEqual(r2_value_log, [('/age', 41)])
def test_propagates_params_changes(self):
p = Params()
self.assertEqual(len(p), 0)
p2 = Params()
p.group('P2', p2)
self.assertEqual(p.changeEvent._fireCount, 1)
p2.int('foo')
self.assertEqual(p.changeEvent._fireCount, 2)
def test_schema_list_with_restrictions(self):
pars = Params()
pars.int('count', min=3, max=10).set(1)
pars.float('price', min=0.0, max=1.0).set(9.99)
self.assertEqual(schema_list(pars), [
{'path': '/count', 'type':'i', 'value':3, 'opts': {'min':3, 'max':10}},
{'path': '/price', 'type':'f', 'value':1.0, 'opts': {'min':0.0, 'max':1.0}},
])
def test_set_values(self):
pars = Params()
pars.int('count').set(1)
pars.float('price').set(9.99)
subpars = Params()
subpars.bool('flag').set(True)
pars.group('subgroup', subpars)
set_values(pars, {'count': 5, 'price': 0.5, 'subgroup': {'flag': False}})
self.assertEqual(pars.get('count').val(), 5)
self.assertEqual(pars.get('price').val(), 0.5)
self.assertEqual(pars.get('subgroup').get('flag').val(), False)
def test_get_values(self):
pars = Params()
pars.int('count').set(1)
pars.float('price').set(9.99)
vals = get_values(pars)
self.assertEqual(vals['count'], 1)
self.assertEqual(vals['price'], 9.99)
self.assertEqual(json.loads(json.dumps(vals))['count'], 1)
self.assertEqual(json.loads(json.dumps(vals))['price'], 9.99)
pars.get('count').set(100)
self.assertEqual(get_values(pars)['count'], 100)
def test_int(self):
params = Params()
param = params.int('age')
self.assertEqual(param.type, 'i')
self.assertTrue(isinstance(param, Param))
param.set('4')
self.assertEqual(param.val(), 4)
param.set('zzz')
self.assertEqual(param.val(), 4)
def test_schema_list_with_values(self):
pars = Params()
pars.string('name').set('Moby Dick')
pars.int('count').set(100)
pars.float('price').set(9.99)
pars.bool('soldout').set(False)
details = Params()
details.int('page_count').set(345)
details.string('author').set('Herman Melville')
pars.group('details', details)
self.assertEqual(schema_list(pars), [
{'path': '/name', 'type':'s', 'value':'Moby Dick'},
{'path': '/count', 'type':'i', 'value':100},
{'path': '/price', 'type':'f', 'value':9.99},
{'path': '/soldout', 'type':'b', 'value':False},
{'path': '/details/page_count', 'type':'i','value':345},
{'path': '/details/author', 'type':'s','value':'Herman Melville'}
])
def test_schema_list(self):
pars = Params()
pars.string('name')
pars.int('count')
pars.float('price')
pars.bool('soldout')
details = Params()
details.int('page_count')
details.string('author')
pars.group('details', details)
self.assertEqual(schema_list(pars), [
{'path': '/name', 'type':'s'},
{'path': '/count', 'type':'i'},
{'path': '/price', 'type':'f'},
{'path': '/soldout', 'type':'b'},
{'path': '/details/page_count', 'type':'i'},
{'path': '/details/author', 'type':'s'}
])
def test_create_sync_params(self):
# params
pars = Params()
pars.string('name')
# server
s = Server(pars)
# remote
r1 = Remote()
s.connect(r1)
p1 = create_sync_params(r1)
# before
self.assertEqual(len(p1), 1)
self.assertIsNone(p1.get('ranking'))
# mutation; a new parameter is added to pars
pars.int('ranking')
# after; verify the mutation is applied to r1's synced params
self.assertEqual(len(p1), 2)
self.assertIsNotNone(p1.get('ranking'))
default='info')
opts, args = parser.parse_args()
lvl = {
'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'critical': logging.CRITICAL
}['debug' if opts.verbose else str(opts.verbosity).lower()]
logging.basicConfig(level=lvl)
return opts, args
opts, args = parse_args()
params = Params()
params.string('name')
params.float('score')
params.int('level')
params.bool('highest-score')
http_server = HttpServer(Server(params))
try:
while True:
time.sleep(0.5)
except KeyboardInterrupt:
print("Received Ctrl+C... initiating exit")
http_server.stop()
def test_osc_server_choreography(self):
#
# setup
#
# param
params = Params()
params.string("name")
# server
server = Server(params)
# intercept all outgoing osc messages into send_log
send_log = []
def capture(host, port, addr, args):
send_log.append((host, port, addr, args))
# create osc server
osc_server = OscServer(server, capture_sends=capture, listen=False)
#
# Client connects
#
# create fake incoming connect message
osc_server.receive('/params/connect', ['127.0.0.1:8081'])
# verify a connect confirmation was sent
self.assertEqual(send_log,
[('127.0.0.1', 8081, '/params/connect/confirm',
(json.dumps(schema_list(params))))])
#
# Client sends new value
#
self.assertIsNone(params.get('name').val())
send_log.clear()
osc_server.receive('/params/value', ['/name', 'Fab'])
# verify value got applied into our local params
self.assertEqual(params.get('name').val(), 'Fab')
# verify the value was broadcasted back to client
self.assertEqual(send_log, [('127.0.0.1', 8081, '/params/value',
('/name', 'Fab'))])
#
# Client sends invalid new value
#
send_log.clear()
osc_server.receive('/params/value', ['/foo', 'bar'])
# verify nothing sent out to client(s)
self.assertEqual(len(send_log), 0)
#
# Schema change broadcasted to client
#
send_log.clear()
params.int('age')
self.assertEqual(send_log, [('127.0.0.1', 8081, '/params/schema',
(json.dumps(schema_list(params))))])
#
# Client requests schema
#
send_log.clear()
osc_server.receive('/params/schema', ['192.168.1.2:8080'])
# verify response
self.assertEqual(send_log, [('192.168.1.2', 8080, '/params/schema',
(json.dumps(schema_list(params))))])
#
# Client disconnected by server
#
send_log.clear()
# osc_server.receive('/params/disconnect', ('127.0.0.1:8081'))
for r in server.connected_remotes:
r.outgoing.send_disconnect()
# server.disconnect(r)
self.assertEqual(send_log,
[('127.0.0.1', 8081, '/params/disconnect', ())])