class GarlicoinWrapper:
def __init__(self, rpcUrl, rpcUser, rpcPass):
self.srv = Server(rpcUrl, auth=(rpcUser, rpcPass))
def get_user_address(self, userId):
addresses = self.srv.getaddressesbyaccount(str(userId))
if not addresses:
return self.generate_address(str(userId))
else:
return addresses[0]
def generate_address(self, userId):
return self.srv.getnewaddress(str(userId))
def get_balance(self, userId):
return self.srv.getbalance(str(userId))
def transfer(self, userIdSrc, grlcDest, amount):
return self.srv.sendfrom(str(userIdSrc), grlcDest, amount)
def move_between_accounts(self, userIdSrc, userIdDest, amount):
try:
return self.srv.move(str(userIdSrc), str(userIdDest),
round(amount, 8))
except jsonrpc.TransportError as e:
err = json.loads(e.server_response.content)['error']['message']
msg = f"{ctx.author.mention} ERROR: {err}: {e.request.body['params']}"
return msg
def main(port, force=False):
server = Server(f'http://127.0.0.1:{port}')
last_block = None
while True:
try:
info = server.getblockchaininfo()
trace(info)
if info['block'] != last_block:
needs_solve = (last_block is not None) or force
trace('needs_solve?', needs_solve)
if needs_solve:
block = server.getblockinfo(info['block'])
sol = solve(block)
trace('sol:', sol)
if sol:
trace('submit')
r = server.submit(sol['block'], sol['task_sol_fn'],
sol['puzzle_sol_fn'])
trace(r)
last_block = info['block']
except:
trace(traceback.format_exc())
pass
trace('idle')
time.sleep(random.randint(15, 25))
def get_session_key(self):
self.server = Server(self.limesurvey_rpc)
try:
self.session_key = self.server.get_session_key(
settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
self.session_key = None if isinstance(self.session_key,
dict) else self.session_key
except TransportError:
self.session_key = None
def setUp(self):
self.server = Server(
'http://survey.numec.prp.usp.br/index.php/admin/remotecontrol')
self.session_key = self.server.get_session_key(
settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
# Checks if connected in the LimeSurvey with the settings.py credentials
self.assertNotIsInstance(self.session_key, dict)
def test_forbid_private_methods(self):
"""Test that we can't call private class methods (those starting with '_')"""
s = Server('http://host-doesnt-exist')
with self.assertRaises(AttributeError):
s._foo()
# nested private method call
with self.assertRaises(AttributeError):
s.foo.bar._baz()
def test_forbid_private_methods(self):
"""Test that we can't call private class methods (those starting with '_')"""
s = Server('http://host-doesnt-exist')
with self.assertRaises(AttributeError):
s._foo()
# nested private method call
with self.assertRaises(AttributeError):
s.foo.bar._baz()
def main():
# bionet nodes have a json_rpc endpoint at /rpc
bionet = Server('http://localhost:8000/rpc')
try:
res = bionet.searchVirtuals('t')
print "foo() said: %s" % res
except ProtocolError as err:
print("while calling .searchVirtuals(): %s" % err.message)
def main():
api = Server("http://127.0.0.1:9996/api")
with codecs.open("web/src/defaultSentence.txt", encoding="utf-8") as f:
sentence = f.read().strip()
with codecs.open("web/src/defaultTree.txt", "w", encoding="utf-8") as f:
f.write(api.phrase_parse(sentence))
with codecs.open("web/src/defaultEDS.txt", "w", encoding="utf-8") as f:
f.write(api.hrg_parse(sentence))
def get_session_key(self):
self.server = Server(settings.LIMESURVEY['URL_API'] +
'/index.php/admin/remotecontrol')
try:
self.session_key = self.server.get_session_key(
settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
self.session_key = None if isinstance(self.session_key, dict) \
else self.session_key
except TransportError:
self.session_key = None
def remote_play(path):
"""
This function remotes play a file to a kodi xbmc server.
:param path:
:return:
"""
smb_path = path.format(destination_dir='smb://MIINAS/MoviesSeries')
url = "http://192.168.0.149:8080/jsonrpc"
http_client = Server(
url,
auth=(settings.JSON_RPC_USERNAME, settings.JSON_RPC_PASSWORD),
)
http_client.send_request('Player.Open', False, {'item': {'file': smb_path}})
def test_headers_passthrough(self):
"""Test that we correctly send RFC-defined headers and merge them with user defined ones"""
def callback(request):
expected_headers = {
'Content-Type': 'application/json',
'Accept': 'application/json-rpc',
'X-TestCustomHeader': '1'
}
self.assertTrue(set(expected_headers.items()).issubset(set(request.headers.items())))
return 200, {}, u'{"jsonrpc": "2.0", "result": true, "id": 1}'
responses.add_callback(
responses.POST, 'http://mock/xmlrpc', content_type='application/json', callback=callback,
)
s = Server('http://mock/xmlrpc', headers={'X-TestCustomHeader': '1'})
s.foo()
def main():
parser = argparse.ArgumentParser(description='DefiChain Exporter')
parser.add_argument('--username', help='rpc username')
parser.add_argument('--password', help='rpc password')
parser.add_argument('--port', help='exporter port (default 8000)', default=8000)
parser.add_argument('--masternode', help='masternode host (default http://localhost:8554)', default='http://localhost:8554')
args = parser.parse_args()
start_http_server(args.port)
server = Server(args.masternode, auth=(args.username, args.password))
masternode_minting_functions = {
"currentblockweight": { "type": "gauge", "obj" : Gauge('masternode__minting_current_blockweight', 'Current Blockweight')},
"currentblocktx": { "type": "gauge", "obj" : Gauge('masternode_minting_current_blocktx', 'Current Blocktx')},
"difficulty": { "type": "gauge", "obj" : Gauge('masternode_minting_difficulty', 'Difficulty')},
'isoperator': { "type": "enum", "obj" : Enum('masternode_minting_isoperator', 'Is Operator', states = ["True", "False"])},
'masternodestate': { "type": "enum", "obj" : Enum('masternode_minting_masternodestate', 'Masternode state', states = ["ENABLED", "PRE_ENABLED", "PRE_RESIGNED", "RESIGNED", "PRE_BANNED", "BANNED"])},
"mintedblocks": { "type": "gauge", "obj" : Gauge('masternode_minting_mintedblocks', 'Minted blocks')}
}
while True:
process_masternode_minting(server, masternode_minting_functions)
time.sleep(random.random())
def __init__(self, rpcuser=None, rpcpassword=None, host=None, port=None):
"""Connects to node using credentials given
Parameters
----------
rpcuser : str
as defined in bitcoin.conf
rpcpassword : str
as defined in bitcoin.conf
host : str, optional
host where the Bitcoin node resides; defaults to 127.0.0.1
port : int, optional
port to connect to; uses default ports according to network
Raises
------
ValueError
if rpcuser and/or rpcpassword are not specified
"""
if not rpcuser or not rpcpassword:
raise ValueError('rpcuser or rpcpassword is missing')
if not host:
host = '127.0.0.1'
if not port:
port = NETWORK_DEFAULT_PORTS[get_network()]
self.proxy = Server("http://{}:{}".format(host, port),
auth=(rpcuser, rpcpassword))
def parse_response(response):
"""We override to use Extended Json here."""
def custom_json_decoder():
return load_from_json_str(response.text)
response.json = custom_json_decoder
return ServerBase.parse_response(response)
def setUp(self):
self.server = Server('http://survey.numec.prp.usp.br/index.php/admin/remotecontrol')
self.session_key = self.server.get_session_key(settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
# Checks if connected in the LimeSurvey with the settings.py credentials
self.assertNotIsInstance(self.session_key, dict)
def test_headers_passthrough(self):
"""Test that we correctly send RFC-defined headers and merge them with user defined ones"""
def callback(request):
expected_headers = {
'Content-Type': 'application/json',
'Accept': 'application/json-rpc',
'X-TestCustomHeader': '1'
}
self.assertTrue(set(expected_headers.items()).issubset(set(request.headers.items())))
return 200, {}, u'{"jsonrpc": "2.0", "result": true, "id": 1}'
responses.add_callback(
responses.POST, 'http://mock/xmlrpc', content_type='application/json', callback=callback,
)
s = Server('http://mock/xmlrpc', headers={'X-TestCustomHeader': '1'})
s.foo()
def main(port):
server = Server(f'http://127.0.0.1:{port}')
last_block = None
while True:
info = server.getblockchaininfo()
trace(info)
if info['block'] != last_block:
last_block = info['block']
notify_user('New block ' + str(last_block),
title='ICFPC',
sound='Basso')
time.sleep(random.randint(15, 25))
def setUp(self):
self.server = Server(settings.LIMESURVEY['URL_API'] + '/index.php/admin/remotecontrol')
try:
self.session_key = self.server.get_session_key(settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
self.session_key = None if isinstance(self.session_key, dict) else self.session_key
except TransportError:
self.session_key = None
class Xcoind(object):
_rpc = None
_cache = None
def __init__(self, host, port, user, password, cache=None):
self._rpc_server = Server('http://%s:%s' % (host, port),
auth=(user, password))
self._cache = cache if cache else LocalCache()
def rpc(self, method, *params):
cachekey = 'rpc__%s_%s' % (method, str(params))
resp = self._cache.get(cachekey)
if resp:
return resp
resp = self._rpc_server.send_request(method, False, params)
self._cache.set(cachekey, resp)
return resp
def getbestblockhash(self):
return self.rpc('getbestblockhash')
def getblock(self, hash):
block = self.rpc('getblock', hash, True)
block['version_hex'] = hex(block['version'])
block['version_bin'] = bin(block['version'])
return block
def getlastnblocks(self, limit):
lastblockhash = self.getbestblockhash()
cachekey = 'getlastnblocks__%s__%s' % (lastblockhash, limit)
blocks = self._cache.get(cachekey)
if blocks:
return blocks
last = self.getblock(lastblockhash)
blocks = [last]
for i in range(limit):
if not 'previousblockhash' in last:
break
last = self.getblock(last['previousblockhash'])
blocks.append(last)
self._cache.set(cachekey, blocks)
return blocks
def gettx(self, tx_hash):
try:
raw = self.rpc('getrawtransaction', tx_hash)
except (TransportError, ProtocolError), e:
raise ProtocolError('getrawtransaction ' + tx_hash + '\n' +
'Error ' + json.JSONEncoder().encode(e.args))
return self.rpc('decoderawtransaction', raw)
def parse_response(self, response):
"""We override to use Extended Json here."""
def custom_json_decoder():
return load_from_json_str(response.text)
response.json = custom_json_decoder
try:
return ServerBase.parse_response(response)
except ProtocolError as exc:
if self._response_error_handler:
return self._response_error_handler(exc)
raise
def main():
bionet = Server('http://localhost:3000/rpc')
res = bionet.foo('foo')
print "no stream: %s" % res
res = bionet.bar()
print "return stream: %s" % res
res = bionet.baz('a')
print "callback stream: %s" % res
try:
res = bionet.fail()
except ProtocolError as err:
print("got error: %s" % err.message)
print("just the error message: %s" %
err.server_data['error']['message'])
try:
res = bionet.secret()
except ProtocolError as err:
print("while calling .secret(): %s" % err.message)
res = bionet.login('foo', 'bar')
# note: your probably won't ever need to use this token manually
print "logged in and got token: %s" % res
res = bionet.secret()
print "secret: %s" % res
try:
res = bionet.admin_secret()
except ProtocolError as err:
print("while calling .admin_secret(): %s" % err.message)
class XPdClient(object):
def __init__(self, rpc_url, rpc_user, rpc_password):
headers = {'Authorization': self.authenticate_str(rpc_user, rpc_password)}
self.connection = Server(rpc_url, headers=headers)
info = self.connection.getinfo()
logger.debug('Connected to XPd (version: {0}) successfully'.format(info['version']))
def __getattr__(self, name):
if is_xpd_command(name):
return getattr(self.connection, name)
else:
raise AttributeError(
'\'{0}\' object has no attribute \'{1}\''.format(self, name))
@classmethod
def authenticate_str(cls, user, password):
_auth_seed = ':'.join([user, password])
_auth_b64 = base64.b64encode(_auth_seed.encode('utf-8')).decode('ascii')
return 'Basic ' + _auth_b64
class Xcoind(object):
_rpc = None
_cache = None
def __init__(self, host, port, user, password, cache=None):
self._rpc_server = Server('http://%s:%s' % (host, port),
auth=(user, password))
self._cache = cache if cache else LocalCache()
def rpc(self, method, *params):
cachekey = 'rpc__%s_%s' % (method, str(params))
resp = self._cache.get(cachekey)
if resp:
return resp
resp = self._rpc_server.send_request(method, False, params)
self._cache.set(cachekey, resp)
return resp
def getbestblockhash(self):
return self.rpc('getbestblockhash')
def getblock(self, hash):
block = self.rpc('getblock', hash, True)
block['version_hex'] = hex(block['version'])
block['version_bin'] = bin(block['version'])
return block
def getlastnblocks(self, limit):
lastblockhash = self.getbestblockhash()
cachekey = 'getlastnblocks__%s__%s' % (lastblockhash, limit)
blocks = self._cache.get(cachekey)
if blocks:
return blocks
last = self.getblock(lastblockhash)
blocks = [last]
for i in range(limit):
if not 'previousblockhash' in last:
break
last = self.getblock(last['previousblockhash'])
blocks.append(last)
self._cache.set(cachekey, blocks)
return blocks
def gettx(self, tx_hash):
raw = self.rpc('getrawtransaction', tx_hash)
return self.rpc('decoderawtransaction', raw)
def gettxs(self, tx_hashes):
cachekey = 'gettxs__%s' % str(tx_hashes)
txs = self._cache.get(cachekey)
if txs:
return txs
txs = []
for tx_hash in tx_hashes:
tx = self.gettx(tx_hash)
txs.append(tx)
self._cache.set(cachekey, txs)
return txs
def getsimpletx(self, txid):
tx = self.gettx(txid)
vins = []
if 'coinbase' in tx['vin'][0]:
coinbase = tx['vin'][0]['coinbase']
coinbase_text = ''.join([
i if ord(i) < 128 else '.'
for i in binascii.unhexlify(coinbase)
])
else:
coinbase = None
coinbase_text = None
for vin in tx['vin']:
in_tx = self.gettx(vin['txid'])
for in_vout in in_tx['vout']:
if vin['vout'] == in_vout['n']:
vins.append({
'address':
in_vout['scriptPubKey']['addresses'][0] if
'addresses' in in_vout['scriptPubKey'] else None,
'value':
in_vout['value'],
})
vouts = []
for vout in tx['vout']:
vouts.append({
'address':
vout['scriptPubKey']['addresses'][0]
if 'addresses' in vout['scriptPubKey'] else None,
'value':
vout['value'],
})
return {
'txid': txid,
'is_coinbase': bool(coinbase),
'coinbase': coinbase,
'coinbase_text': coinbase_text,
'vin': vins,
'vout': vouts,
'tx': tx,
}
#!/usr/bin/python
from jsonrpc_requests import Server
rpc = Server('http://localhost:5555')
print(rpc.object.slot())
print(rpc.object.slotWithParams("one", False, 10))
print(rpc.object.slotWithParamsAndReturnValue("kostya"))
def test_exception_passthrough(self):
with self.assertRaises(TransportError) as transport_error:
s = Server('http://host-doesnt-exist')
s.foo()
self.assertEqual(transport_error.exception.args[0], "Error calling method 'foo'")
self.assertIsInstance(transport_error.exception.args[1], requests.exceptions.RequestException)
parser_s = subparsers.add_parser('submit')
parser_s.add_argument('block', default=None, help="block to submit for")
parser_s.add_argument('task_sol_path',
default=None,
help=".sol file for block task")
parser_s.add_argument('puzzle_sol_path',
default=None,
help=".desc file for block puzzle")
args = parser.parse_args()
try:
args.port = int(args.port)
except ValueError:
parser.error('Port must be an integer.')
server = Server(f'http://{args.bind}:{args.port}')
# Handle getblockinfo
if args.subcmd == 'getblockinfo':
bi = None
if args.block is None:
bi = server.getblockinfo()
else:
# Allow commands like `./lambda-cli.py getblockinfo block`
# i.e. with block taken as item rather than item
if not args.block.isdecimal():
args.subitem = args.item
args.item = args.block
args.block = None
bi = server.getblockinfo(
) if args.block is None else server.getblockinfo(args.block)
class ZcashdMiner(object):
def __init__(self, zcashd_url):
self.solver = Solver()
self.server = Server(zcashd_url)
def get_cb_tx(self, template, mining_address=None):
orig = hex_to_bin(template['coinbasetxn']['data'])
if not mining_address:
return orig
orig_decoded = self.server.decoderawtransaction(
template['coinbasetxn']['data'])
founder_tax_address = orig_decoded['vout'][1]['scriptPubKey'][
'addresses'][0]
founder_tax_amount = orig_decoded['vout'][1]['value']
reward = orig_decoded['vout'][0]['value']
new_out_tx = hex_to_bin(
self.server.createrawtransaction(
[], {
mining_address: reward,
founder_tax_address: founder_tax_amount
}))
return replace_output(orig, new_out_tx)
@staticmethod
def get_header_from_templete(t, cb_tx, nonce):
version = t['version']
previous_block_hash = hex_to_bin(t['previousblockhash'])
cb_hash = double_sha256_digest(cb_tx) #[::-1]
# cb_hash = hex_to_bin(t['coinbasetxn']['hash'])[::-1]
hashes = [
cb_hash,
] + txs_hashes(get_txs_from_template(t))
hash_merkle_root = MerkleTree(hashes).tree_digest()
time = t['curtime']
bits = t['bits']
return ''.join((
struct.pack("<i", version),
previous_block_hash[::-1],
hash_merkle_root,
'\x00' * 32,
struct.pack("<I", time),
hex_to_bin(bits)[::-1],
nonce,
))
def submit_block(self, template, cb_tx, header_with_solution_bin):
txs = get_txs_from_template(template)
block_bin = ''.join((
header_with_solution_bin,
pack_varint(len(txs) + 1),
# hex_to_bin(template['coinbasetxn']['data']),
cb_tx,
''.join(txs),
))
block_hex = bin_to_hex(block_bin)
result = self.server.submitblock(block_hex)
return bin_to_hex(
double_sha256_digest(header_with_solution_bin)[::-1]), result
def mine_block(self, mining_address=None):
template = self.server.getblocktemplate()
target = long(template['target'], 16)
nonce_counter = 0
while True:
nonce_counter += 1
nonce_bin = '%32x' % nonce_counter
cb_tx = self.get_cb_tx(template, mining_address)
header_bin = self.get_header_from_templete(template, cb_tx,
nonce_bin)
sol_num = self.solver.find_solutions(header_bin)
for i in range(sol_num):
solution_bin = self.solver.get_solution(i)
header_with_solution_bin = header_bin + '\xfd\x40\x05' + solution_bin
hash_bin = double_sha256_digest(header_with_solution_bin)
hash_int = sha256_digest_to_int(hash_bin)
if hash_int < target:
return self.submit_block(template, cb_tx,
header_with_solution_bin)
def mine_n_blocks(self, n, mining_address=None):
for _ in range(n):
yield self.mine_block(mining_address)
time.sleep(2)
class ABCSearchEngine(ABC):
QUESTION_PROPERTIES = [
'gid', 'question', 'question_order', 'subquestions', 'answeroptions',
'title', 'type', 'attributes_lang', 'attributes', 'other'
]
session_key = None
server = None
def __init__(self):
self.get_session_key()
def get_session_key(self):
self.server = Server(
settings.LIMESURVEY['URL_API'] + '/index.php/admin/remotecontrol')
try:
self.session_key = self.server.get_session_key(
settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD']
)
self.session_key = None if isinstance(self.session_key, dict) \
else self.session_key
except TransportError:
self.session_key = None
def release_session_key(self):
if self.session_key:
self.server.release_session_key(self.session_key)
@abstractmethod
def find_all_questionnaires(self):
"""
:return: all stored surveys
"""
list_survey = self.server.list_surveys(self.session_key, None)
return list_survey
@abstractmethod
def find_all_active_questionnaires(self):
"""
:return: all active surveys
"""
list_survey = self.server.list_surveys(self.session_key, None)
list_active_survey = []
if isinstance(list_survey, list):
for survey in list_survey:
if survey['active'] == "Y" and self.survey_has_token_table(survey['sid']):
list_active_survey.append(survey)
else:
list_active_survey = None
return list_active_survey
@abstractmethod
def find_questionnaire_by_id(self, sid):
"""
:param sid: survey ID
:return: survey
"""
list_survey = self.server.list_surveys(self.session_key, None)
try:
survey = next((survey for survey in list_survey if survey['sid'] == sid))
except StopIteration:
survey = None
return survey
@abstractmethod
def add_participant(self, sid):
"""
:param sid: Survey ID
:return: dictionary with token and token_id; None if error.
"""
participant_data = {'email': '', 'firstname': '', 'lastname': ''}
result = self.server.add_participants(
self.session_key, sid, [participant_data], True
)
if result \
and isinstance(result, list) \
and isinstance(result[0], dict) \
and 'error' not in result[0]:
return {'token': result[0]['token'],
'tid': result[0]['tid']}
else:
return None
@abstractmethod
def delete_participant(self, survey_id, tokens_ids):
""" Delete survey participant
:param survey_id: survey ID
:param tokens_ids: token_id to put in a list
:return: on success, an array of deletion status for each participant; on failure, status array.
"""
result = self.server.delete_participants(
self.session_key,
survey_id,
[tokens_ids]
)
return result
@abstractmethod
def get_survey_title(self, sid, language):
"""
:param sid: survey ID
:param language: language
:return: title of the survey
"""
if self.session_key:
survey_title = self.server.get_language_properties(self.session_key, sid, {'method': 'surveyls_title'},
language)
if 'surveyls_title' in survey_title:
survey_title = survey_title.get('surveyls_title')
else:
survey_title = str(sid)
else:
survey_title = str(sid)
return survey_title
@abstractmethod
def get_survey_properties(self, sid, prop):
"""
:param sid: survey ID
:param prop: the name of the propriety of the survey
:return: value of the property
"""
result = self.server.get_survey_properties(self.session_key, sid, {'method': prop})
return result.get(prop)
@abstractmethod
def get_survey_languages(self, sid):
"""
:param sid: survey ID
:return: the base and the additional idioms
"""
result = self.server.get_survey_properties(self.session_key, sid, ['additional_languages', 'language'])
return result
@abstractmethod
def activate_survey(self, sid):
""" Activates a survey
:param sid: survey ID
:return: status of the survey
"""
result = self.server.activate_survey(self.session_key, sid)
return result['status']
@abstractmethod
def activate_tokens(self, sid):
""" Activates tokens for a determined survey
:param sid: survey ID
:return: status of the survey
"""
result = self.server.activate_tokens(self.session_key, sid)
return result['status']
@abstractmethod
def get_participant_properties(self, survey_id, token_id, prop):
"""
:param survey_id: survey ID
:param token_id: token ID
:param prop: property name
:return: value of a determined property from a participant/token
"""
if self.session_key:
result = self.server.get_participant_properties(
self.session_key, survey_id, token_id, {'method': prop}
)
result = result.get(prop)
else:
result = ''
return result
@abstractmethod
def survey_has_token_table(self, sid):
"""
:param sid: survey ID
:return: True if the survey has token table; False, if not.
"""
result = self.server.get_summary(self.session_key, sid, "token_completed")
return isinstance(result, int)
@abstractmethod
def add_survey(self, sid, title, language, survey_format):
""" Adds a survey to the LimeSurvey
:param sid: survey ID
:param title: title of the survey
:param language: language of the survey
:param survey_format: format of the survey
:return: survey ID generated
"""
survey_id_generated = self.server.add_survey(
self.session_key, sid, title, language, survey_format
)
return survey_id_generated
@abstractmethod
def delete_survey(self, sid):
""" remove a survey from the LimeSurvey
:param sid: survey ID
:return: status of the operation
"""
status = self.server.delete_survey(self.session_key, sid)
return status['status']
@abstractmethod
def get_responses_by_token(self, sid, token, language, fields=[]):
""" obtains responses from a determined token
:param sid: survey ID
:param token: token
:param language: language
:param fields: fields array, using SGQA identifier
:return: responses in the txt format
"""
if fields:
responses = self.server.export_responses_by_token(
self.session_key, sid, 'csv', token, language, 'complete', 'code', 'short', fields)
else:
responses = self.server.export_responses_by_token(
self.session_key, sid, 'csv', token, language, 'complete')
if isinstance(responses, str):
responses_txt = b64decode(responses)
else:
responses_txt = responses
return responses_txt
@abstractmethod
def get_responses(self, sid, language, response_type, fields, heading_type):
""" Obtains responses from a determined survey
:param sid: survey ID
:param language: language
:param response_type: (optional)'short' or 'long'
Optional defaults to 'short'
:param fields: filter fields that must be returned
:param heading_type: (optional) 'code','full' or 'abbreviated'
Optional defaults to 'code'
:return: responses in txt format
"""
responses = self.server.export_responses(
self.session_key, sid, 'csv', language, 'complete', heading_type,
response_type
)
if isinstance(responses, str):
responses_txt = b64decode(responses)
else:
responses_txt = responses
return responses_txt
def get_header_response(self, sid, language, token, heading_type):
""" Obtain header responses
:param sid: survey ID
:param language: language
:param heading_type: heading type (can be 'code' or 'full')
:return: responses in the txt format
"""
responses = self.server.export_responses_by_token(
self.session_key, sid, 'csv', token, language,
'complete', heading_type, 'short'
)
if not isinstance(responses, str):
responses = self.server.export_responses(
self.session_key, sid, 'csv', language,
'complete', heading_type, 'short'
)
if isinstance(responses, str):
responses_txt = b64decode(responses)
else:
responses_txt = responses
return responses_txt
@abstractmethod
def get_summary(self, sid, stat_name):
"""
:param sid: survey ID
:param stat_name: name of the summary option - valid values are 'token_count', 'token_invalid', 'token_sent',
'token_opted_out', 'token_completed', 'completed_responses', 'incomplete_responses', 'full_responses' or 'all'
:return: summary information
"""
summary_responses = self.server.get_summary(self.session_key, sid, stat_name)
return summary_responses
@abstractmethod
def insert_questions(self, sid, questions_data, format_import_file):
""" Imports a group of questions from a file
:param sid: survey ID
:param questions_data: question data
:param format_import_file: lsg file
:return:
"""
questions_data_b64 = b64encode(questions_data.encode('utf-8'))
result = self.server.import_group(
self.session_key, sid, questions_data_b64.decode('utf-8'),
format_import_file
)
if isinstance(result, dict):
if 'status' in result:
return None
else:
return result
@abstractmethod
def get_question_properties(self, question_id, language):
"""
:param question_id: question ID
:param language: language of the answer
:return: properties of a question of a survey
"""
properties = self.server.get_question_properties(
self.session_key, question_id, self.QUESTION_PROPERTIES, language
)
return properties
def set_question_properties(self, sid, data):
return self.server.set_question_properties(self.session_key, sid, data)
@abstractmethod
def list_groups(self, sid):
"""
:param sid: survey ID
:return: ids and info of groups belonging to survey
"""
groups = self.server.list_groups(self.session_key, sid)
return groups
@abstractmethod
def get_group_properties(self, gid):
"""
:param gid: group ID
:param lang: group language to return correct group, as Remote
Control API does not do that
:return: list of group properties
"""
return self.server.get_group_properties(self.session_key, gid)
def set_group_properties(self, sid, data):
return self.server.set_group_properties(
self.session_key, sid, data
)
@abstractmethod
def list_questions(self, sid, gid):
"""
:param sid: survey ID
:param gid: group ID
:return: ids and info of (sub-)questions of a survey/group
"""
question_list = []
questions = self.server.list_questions(self.session_key, sid, gid)
for question in questions:
question_list.append(question['id']['qid'])
return question_list
@abstractmethod
def find_tokens_by_questionnaire(self, sid):
"""
:param sid:
:return: tokens for specific id
"""
tokens = self.server.list_participants(
self.session_key, sid, 0, 99999999
)
return tokens
def add_group(self, sid, title, description):
return self.server.add_group(self.session_key, sid, title)
def add_response(self, sid, response_data):
return self.server.add_response(self.session_key, sid, response_data)
def set_participant_properties(self, sid, tid, properties_dict):
return self.server.set_participant_properties(
self.session_key, sid, tid, properties_dict
)
def test_exception_passthrough(self):
with self.assertRaises(TransportError) as transport_error:
s = Server('http://host-doesnt-exist')
s.foo()
self.assertEqual(transport_error.exception.args[0], "Error calling method 'foo'")
self.assertIsInstance(transport_error.exception.args[1], requests.exceptions.RequestException)
class Xcoind(object):
_rpc = None
_cache = None
def __init__(self, host, port, user, password, cache=None):
self._rpc_server = Server('http://%s:%s' % (host, port), auth=(user, password))
self._cache = cache if cache else LocalCache()
def rpc(self, method, *params):
cachekey = 'rpc__%s_%s' % (method, str(params))
resp = self._cache.get(cachekey)
if resp:
return resp
resp = self._rpc_server.send_request(method, False, params)
self._cache.set(cachekey, resp)
return resp
def getbestblockhash(self):
return self.rpc('getbestblockhash')
def getblock(self, hash):
block = self.rpc('getblock', hash, True)
block['version_hex'] = hex(block['version'])
block['version_bin'] = bin(block['version'])
return block
def getlastnblocks(self, limit):
lastblockhash = self.getbestblockhash()
cachekey = 'getlastnblocks__%s__%s' % (lastblockhash, limit)
blocks = self._cache.get(cachekey)
if blocks:
return blocks
last = self.getblock(lastblockhash)
blocks = [last]
for i in range(limit):
if not 'previousblockhash' in last:
break
last = self.getblock(last['previousblockhash'])
blocks.append(last)
self._cache.set(cachekey, blocks)
return blocks
def gettx(self, tx_hash):
raw = self.rpc('getrawtransaction', tx_hash)
return self.rpc('decoderawtransaction', raw)
def gettxs(self, tx_hashes):
cachekey = 'gettxs__%s' % str(tx_hashes)
txs = self._cache.get(cachekey)
if txs:
return txs
txs = []
for tx_hash in tx_hashes:
tx = self.gettx(tx_hash)
txs.append(tx)
self._cache.set(cachekey, txs)
return txs
def getsimpletx(self, txid):
tx = self.gettx(txid)
vins = []
if 'coinbase' in tx['vin'][0]:
coinbase = tx['vin'][0]['coinbase']
coinbase_text = ''.join([i if ord(i) < 128 else '.' for i in binascii.unhexlify(coinbase)])
else:
coinbase = None
coinbase_text = None
for vin in tx['vin']:
in_tx = self.gettx(vin['txid'])
for in_vout in in_tx['vout']:
if vin['vout'] == in_vout['n']:
vins.append({
'address': in_vout['scriptPubKey']['addresses'][0] if 'addresses' in in_vout['scriptPubKey'] else None,
'value': in_vout['value'],
})
vouts = []
for vout in tx['vout']:
vouts.append({
'address': vout['scriptPubKey']['addresses'][0] if 'addresses' in vout['scriptPubKey'] else None,
'value': vout['value'],
})
return {
'txid': txid,
'is_coinbase': bool(coinbase),
'coinbase': coinbase,
'coinbase_text': coinbase_text,
'vin': vins,
'vout': vouts,
'tx': tx,
}
def __init__(self, host, port, user, password, cache=None):
self._rpc_server = Server('http://%s:%s' % (host, port), auth=(user, password))
self._cache = cache if cache else LocalCache()
def __init__(self, host, port, user, password, cache=None):
self._rpc_server = Server('http://%s:%s' % (host, port),
auth=(user, password))
self._cache = cache if cache else LocalCache()
from pprint import pprint
from jsonrpc_requests import Server
server = Server('http://localhost:37128')
server.getstatus()
server.createwallet("test1", "samkorn")
# Throws "Response without a result field"
server.selectwallet("test1")
server.getwalletinfo("test1")
server.listunspentcoins()
server.getnewaddress("test receive")
server.send()
{
"payments": [{
"sendto": "tb1qgvnht40a08gumw32kp05hs8mny954hp2snhxcz",
"amount": 15000,
"label": "David"
}, {
"sendto": "tb1qpyhfrpys6skr2mmnc35p3dp7zlv9ew4k0gn7qm",
"amount": 86200,
"label": "Michael"
}],
"coins": [{
"transactionid":
"ab83d9d0b2a9873b8ab0dc48b618098f3e7fbd807e27a10f789e9bc330ca89f7",
class ABCSearchEngineTest(TestCase):
session_key = None
server = None
def setUp(self):
self.server = Server('http://survey.numec.prp.usp.br/index.php/admin/remotecontrol')
self.session_key = self.server.get_session_key(settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
# Checks if connected in the LimeSurvey with the settings.py credentials
self.assertNotIsInstance(self.session_key, dict)
def test_complete_survey(self):
lime_survey = Questionnaires()
sid = None
try:
# Cria uma nova survey no lime survey
title_survey = 'Questionario de teste'
sid = lime_survey.add_survey(9999, title_survey, 'en', 'G')
# Obtenho o titulo da survey
survey_title = lime_survey.get_survey_title(sid)
self.assertEqual(survey_title, title_survey)
# Verifica se esta ativa
survey_active = lime_survey.get_survey_properties(sid, 'active')
self.assertEqual(survey_active, 'N')
# Obtem uma propriedade - Administrador da Survey
survey_admin = lime_survey.get_survey_properties(sid, 'admin')
self.assertEqual(survey_admin, None)
# Importar grupo de questoes
handle_file_import = open('quiz/static/quiz/tests/limesurvey_groups.lsg', 'r')
questions_data = handle_file_import.read()
questions_id = lime_survey.insert_questions(sid, questions_data, 'lsg')
self.assertGreaterEqual(questions_id, 1)
# Inicia tabela de tokens
self.assertEqual(lime_survey.activate_tokens(sid), 'OK')
# Ativar survey
self.assertEqual(lime_survey.activate_survey(sid), 'OK')
# Verifica se esta ativa
survey_active = lime_survey.get_survey_properties(sid, 'active')
self.assertEqual(survey_active, 'Y')
# Adiciona participante e obtem o token
result_token = lime_survey.add_participant(sid)
# Verifica se o token
token = lime_survey.get_participant_properties(sid, result_token, "token")
self.assertEqual(token, result_token['token'])
finally:
# Deleta a survey gerada no Lime Survey
self.assertEqual(lime_survey.delete_survey(sid), 'OK')
def test_find_all_questionnaires_method_returns_correct_result(self):
questionnaires = Questionnaires()
list_survey = self.server.list_surveys(self.session_key, None)
self.server.release_session_key(self.session_key)
self.assertEqual(questionnaires.find_all_questionnaires(), list_survey)
questionnaires.release_session_key()
def test_find_questionnaire_by_id_method_found_survey(self):
questionnaires = Questionnaires()
list_survey = self.server.list_surveys(self.session_key, None)
self.server.release_session_key(self.session_key)
self.assertEqual(questionnaires.find_questionnaire_by_id(list_survey[3]['sid']), list_survey[3])
questionnaires.release_session_key()
def test_find_questionnaire_by_id_method_not_found_survey_by_string(self):
questionnaires = Questionnaires()
self.assertEqual(None, questionnaires.find_questionnaire_by_id('three'))
questionnaires.release_session_key()
def test_find_questionnaire_by_id_method_not_found_survey_by_out_of_range(self):
questionnaires = Questionnaires()
self.assertEqual(None, questionnaires.find_questionnaire_by_id(10000000))
questionnaires.release_session_key()
def test_list_active_questionnaires(self):
questionnaires = Questionnaires()
list_survey = self.server.list_surveys(self.session_key, None)
self.server.release_session_key(self.session_key)
list_active_survey = []
for survey in list_survey:
survey_has_token = questionnaires.survey_has_token_table(survey['sid'])
if survey['active'] == "Y" and survey_has_token is True:
list_active_survey.append(survey)
self.assertEqual(questionnaires.find_all_active_questionnaires(), list_active_survey)
questionnaires.release_session_key()
def test_add_participant_to_a_survey(self):
"""testa a insercao de participante em um questionario """
surveys = Questionnaires()
list_active_surveys = surveys.find_all_active_questionnaires()
self.assertNotEqual(list_active_surveys, None)
survey = list_active_surveys[0]
sid = int(survey['sid'])
# list_participants = self.server.list_participants(self.session_key, sid)
# participant_data = {'email': '*****@*****.**', 'lastname': 'junqueira', 'firstname': 'juca'}
participant_data_result = surveys.add_participant(sid)
# verificar se info retornada eh a mesma
# self.assertEqual(participant_data_result[0]['email'], participant_data['email'])
# self.assertEqual(participant_data_result[0]['lastname'], participant_data['lastname'])
# self.assertEqual(participant_data_result[0]['firsStname'], participant_data['firstname'])
self.assertNotEqual(participant_data_result, None)
# list_participants_new = self.server.list_participants(self.session_key, sid)
# self.assertEqual(len(list_participants_new), len(list_participants) + 1)
# token_id = participant_data_result[0]['tid']
token_id = participant_data_result['token_id']
# tokens_to_delete = [token_id]
# remover participante do questionario
result = self.server.delete_participants(self.session_key, sid, [token_id])
self.assertEqual(result[str(token_id)], 'Deleted')
surveys.release_session_key()
def test_add_and_delete_survey(self):
"""
TDD - Criar uma survey de teste e apos devera ser excluida
"""
survey_id_generated = self.server.add_survey(self.session_key, 9999, 'Questionario de Teste', 'en', 'G')
self.assertGreaterEqual(survey_id_generated, 0)
status = self.server.delete_survey(self.session_key, survey_id_generated)
self.assertEqual(status['status'], 'OK')
self.server.release_session_key(self.session_key)
def test_add_and_delete_survey_methods(self):
questionnaires = Questionnaires()
sid = questionnaires.add_survey('9999', 'Questionario de Teste', 'en', 'G')
self.assertGreaterEqual(sid, 0)
status = questionnaires.delete_survey(sid)
self.assertEqual(status, 'OK')
# def test_get_survey_property_usetokens(self):
# """testa a obtencao das propriedades de um questionario"""
#
# surveys = Questionnaires()
# result = surveys.get_survey_properties(641729, "usetokens")
# surveys.release_session_key()
#
# pass
# def test_get_participant_property_usetokens(self):
# """testa a obtencao das propriedades de um participant/token"""
#
# surveys = Questionnaires()
#
# # completo
# result1 = surveys.get_participant_properties(426494, 2, "completed")
#
# # nao completo
# result2 = surveys.get_participant_properties(426494, 230, "completed")
# result3 = surveys.get_participant_properties(426494, 230, "token")
# surveys.release_session_key()
#
# pass
# def test_survey_has_token_table(self):
# """testa se determinado questionario tem tabela de tokens criada"""
#
# surveys = Questionnaires()
#
# # exemplo de "true"
# result = surveys.survey_has_token_table(426494)
#
# # exemplo de "false"
# result2 = surveys.survey_has_token_table(642916)
# surveys.release_session_key()
#
# pass
def test_delete_participant_to_a_survey(self):
"""
Remove survey participant test
testa a insercao de participante em um questionario
"""
surveys = Questionnaires()
list_active_surveys = surveys.find_all_active_questionnaires()
self.assertNotEqual(list_active_surveys, None)
survey = list_active_surveys[0]
sid = int(survey['sid'])
# list_participants = self.server.list_participants(self.session_key, sid)
# participant_data = {'email': '*****@*****.**', 'lastname': 'junqueira', 'firstname': 'juca'}
participant_data_result = surveys.add_participant(sid)
# verificar se info retornada eh a mesma
# self.assertEqual(participant_data_result[0]['email'], participant_data['email'])
# self.assertEqual(participant_data_result[0]['lastname'], participant_data['lastname'])
# self.assertEqual(participant_data_result[0]['firstname'], participant_data['firstname'])
self.assertNotEqual(participant_data_result, None)
# list_participants_new = self.server.list_participants(self.session_key, sid)
# self.assertEqual(len(list_participants_new), len(list_participants) + 1)
# token_id = participant_data_result[0]['tid']
token_id = participant_data_result['token_id']
# tokens_to_delete = [token_id]
# remover participante do questionario
result = surveys.delete_participant(sid, token_id)
self.assertEqual(result[str(token_id)], 'Deleted')
surveys.release_session_key()
def __init__(self, zcashd_url):
self.solver = Solver()
self.server = Server(zcashd_url)
class TestJSONRPCClient(TestCase):
def setUp(self):
random.randint = Mock(return_value=1)
self.server = Server('http://mock/xmlrpc')
def test_length(self):
"""Verify that this library is really smaller than 100 lines, as stated in README.rst"""
with open(inspect.getfile(Server)) as library_file:
self.assertLessEqual(len([l for l in library_file.readlines()
if l.strip()]), 100)
def test_pep8_conformance(self):
"""Test that we conform to PEP8."""
source_files = []
project_dir = os.path.dirname(os.path.abspath(__file__))
package_dir = os.path.join(project_dir, 'jsonrpc_requests')
for root, directories, filenames in os.walk(package_dir):
source_files.extend([os.path.join(root, f) for f in filenames if f.endswith('.py')])
pep8style = pep8.StyleGuide(quiet=False, max_line_length=120)
result = pep8style.check_files(source_files)
self.assertEqual(result.total_errors, 0, "Found code style errors (and warnings).")
def test_dumps(self):
# test keyword args
self.assertSameJSON(
'''{"params": {"foo": "bar"}, "jsonrpc": "2.0", "method": "my_method_name", "id": 1}''',
self.server.serialize('my_method_name', params={'foo': 'bar'}, is_notification=False)
)
# test positional args
self.assertSameJSON(
'''{"params": ["foo", "bar"], "jsonrpc": "2.0", "method": "my_method_name", "id": 1}''',
self.server.serialize('my_method_name', params=('foo', 'bar'), is_notification=False)
)
# test notification
self.assertSameJSON(
'''{"params": ["foo", "bar"], "jsonrpc": "2.0", "method": "my_method_name"}''',
self.server.serialize('my_method_name', params=('foo', 'bar'), is_notification=True)
)
def test_parse_result(self):
with self.assertRaisesRegex(ProtocolError, 'Response is not a dictionary'):
self.server.parse_result([])
with self.assertRaisesRegex(ProtocolError, 'Response without a result field'):
self.server.parse_result({})
with self.assertRaises(ProtocolError) as protoerror:
body = {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": "1"}
self.server.parse_result(body)
self.assertEqual(protoerror.exception.args[0], -32601)
self.assertEqual(protoerror.exception.args[1], 'Method not found')
@responses.activate
def test_send_request(self):
# catch non-json responses
with self.assertRaises(TransportError) as transport_error:
responses.add(responses.POST, 'http://mock/xmlrpc', body='not json', content_type='application/json')
self.server.send_request('my_method', is_notification=False, params=None)
self.assertEqual(transport_error.exception.args[0], 'Cannot deserialize response body')
self.assertIsInstance(transport_error.exception.args[1], ValueError)
responses.reset()
# catch non-200 responses
with self.assertRaisesRegex(TransportError, '404'):
responses.add(responses.POST, 'http://mock/xmlrpc', body='{}', content_type='application/json', status=404)
self.server.send_request('my_method', is_notification=False, params=None)
responses.reset()
# catch requests own exception
with self.assertRaisesRegex(TransportError, 'Requests exception'):
def callback(request):
raise requests.RequestException('Requests exception')
responses.add_callback(
responses.POST, 'http://mock/xmlrpc', content_type='application/json', callback=callback,
)
self.server.send_request('my_method', is_notification=False, params=None)
responses.reset()
# a notification
responses.add(responses.POST, 'http://mock/xmlrpc', body='we dont care about this',
content_type='application/json')
self.server.send_request('my_notification', is_notification=True, params=None)
responses.reset()
def test_exception_passthrough(self):
with self.assertRaises(TransportError) as transport_error:
s = Server('http://host-doesnt-exist')
s.foo()
self.assertEqual(transport_error.exception.args[0], "Error calling method 'foo'")
self.assertIsInstance(transport_error.exception.args[1], requests.exceptions.RequestException)
def test_forbid_private_methods(self):
"""Test that we can't call private class methods (those starting with '_')"""
s = Server('http://host-doesnt-exist')
with self.assertRaises(AttributeError):
s._foo()
# nested private method call
with self.assertRaises(AttributeError):
s.foo.bar._baz()
@responses.activate
def test_headers_passthrough(self):
"""Test that we correctly send RFC-defined headers and merge them with user defined ones"""
def callback(request):
expected_headers = {
'Content-Type': 'application/json',
'Accept': 'application/json-rpc',
'X-TestCustomHeader': '1'
}
self.assertTrue(set(expected_headers.items()).issubset(set(request.headers.items())))
return 200, {}, u'{"jsonrpc": "2.0", "result": true, "id": 1}'
responses.add_callback(
responses.POST, 'http://mock/xmlrpc', content_type='application/json', callback=callback,
)
s = Server('http://mock/xmlrpc', headers={'X-TestCustomHeader': '1'})
s.foo()
def test_method_call(self):
"""mixing *args and **kwargs is forbidden by the spec"""
with self.assertRaisesRegex(ProtocolError, 'JSON-RPC spec forbids mixing arguments and keyword arguments'):
self.server.testmethod(1, 2, a=1, b=2)
@responses.activate
def test_method_nesting(self):
"""Test that we correctly nest namespaces"""
def callback(request):
request_message = json.loads(request.body)
if (request_message["params"][0] == request_message["method"]):
return (200, {}, u'{"jsonrpc": "2.0", "result": true, "id": 1}')
else:
return (200, {}, u'{"jsonrpc": "2.0", "result": false, "id": 1}')
responses.add_callback(
responses.POST, 'http://mock/xmlrpc', content_type='application/json', callback=callback,
)
self.assertEqual(self.server.nest.testmethod("nest.testmethod"), True)
self.assertEqual(self.server.nest.testmethod.some.other.method("nest.testmethod.some.other.method"), True)
@responses.activate
def test_calls(self):
# rpc call with positional parameters:
def callback1(request):
request_message = json.loads(request.body)
self.assertEqual(request_message["params"], [42, 23])
return (200, {}, u'{"jsonrpc": "2.0", "result": 19, "id": 1}')
responses.add_callback(
responses.POST, 'http://mock/xmlrpc',
content_type='application/json',
callback=callback1,
)
self.assertEqual(self.server.subtract(42, 23), 19)
responses.reset()
# rpc call with named parameters
def callback2(request):
request_message = json.loads(request.body)
self.assertEqual(request_message["params"], {'y': 23, 'x': 42})
return (200, {}, u'{"jsonrpc": "2.0", "result": 19, "id": 1}')
responses.add_callback(
responses.POST, 'http://mock/xmlrpc',
content_type='application/json',
callback=callback2,
)
self.assertEqual(self.server.subtract(x=42, y=23), 19)
responses.reset()
# rpc call with a mapping type
def callback3(request):
request_message = json.loads(request.body)
self.assertEqual(request_message["params"], {'foo': 'bar'})
return (200, {}, u'{"jsonrpc": "2.0", "result": null}')
responses.add_callback(
responses.POST, 'http://mock/xmlrpc',
content_type='application/json',
callback=callback3,
)
self.server.foobar({'foo': 'bar'})
responses.reset()
@responses.activate
def test_notification(self):
# Verify that we ignore the server response
responses.add(responses.POST, 'http://mock/xmlrpc',
body='{"jsonrpc": "2.0", "result": 19, "id": 3}',
content_type='application/json')
self.assertIsNone(self.server.subtract(42, 23, _notification=True))
responses.reset()
class ABCSearchEngineTest(TestCase):
session_key = None
server = None
def setUp(self):
self.server = Server(settings.LIMESURVEY['URL_API'] +
'/index.php/admin/remotecontrol')
try:
self.session_key = self.server.get_session_key(
settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
self.session_key = None if isinstance(self.session_key,
dict) else self.session_key
except TransportError:
self.session_key = None
def test_complete_survey(self):
lime_survey = Questionnaires()
sid = None
try:
# Cria uma nova survey no lime survey
title_survey = 'Questionario de teste'
sid = lime_survey.add_survey(9999, title_survey, 'en', 'G')
# Obtenho o titulo da survey
survey_title = lime_survey.get_survey_title(sid)
self.assertEqual(survey_title, title_survey)
# Verifica se esta ativa
survey_active = lime_survey.get_survey_properties(sid, 'active')
self.assertEqual(survey_active, 'N')
# Obtem uma propriedade - Administrador da Survey
survey_admin = lime_survey.get_survey_properties(sid, 'admin')
self.assertEqual(survey_admin, None)
# Importar grupo de questoes
handle_file_import = \
open('quiz/static/quiz/tests/limesurvey_groups.lsg', 'r')
questions_data = handle_file_import.read()
questions_id = \
lime_survey.insert_questions(sid, questions_data, 'lsg')
self.assertGreaterEqual(questions_id, 1)
# Inicia tabela de tokens
self.assertEqual(lime_survey.activate_tokens(sid), 'OK')
# Ativar survey
self.assertEqual(lime_survey.activate_survey(sid), 'OK')
# Verifica se esta ativa
survey_active = lime_survey.get_survey_properties(sid, 'active')
self.assertEqual(survey_active, 'Y')
# Adiciona participante e obtem o token
result_token = lime_survey.add_participant(sid)
# Verifica se o token está presente na tabela de participantes
token = lime_survey.get_participant_properties(
sid, result_token, "token")
self.assertEqual(token, result_token['token'])
finally:
# Deleta a survey gerada no Lime Survey
self.assertEqual(lime_survey.delete_survey(sid), 'OK')
def test_find_all_questionnaires_method_returns_correct_result(self):
questionnaires = Questionnaires()
list_survey = self.server.list_surveys(self.session_key, None)
self.server.release_session_key(self.session_key)
self.assertEqual(questionnaires.find_all_questionnaires(), list_survey)
questionnaires.release_session_key()
def test_find_questionnaire_by_id_method_found_survey(self):
questionnaires = Questionnaires()
list_survey = self.server.list_surveys(self.session_key, None)
self.server.release_session_key(self.session_key)
self.assertEqual(
questionnaires.find_questionnaire_by_id(list_survey[3]['sid']),
list_survey[3])
questionnaires.release_session_key()
def test_find_questionnaire_by_id_method_not_found_survey_by_string(self):
questionnaires = Questionnaires()
self.assertEqual(None,
questionnaires.find_questionnaire_by_id('three'))
questionnaires.release_session_key()
def test_find_questionnaire_by_id_method_not_found_survey_by_out_of_range(
self):
questionnaires = Questionnaires()
self.assertEqual(None,
questionnaires.find_questionnaire_by_id(10000000))
questionnaires.release_session_key()
def test_list_active_questionnaires(self):
questionnaires = Questionnaires()
list_survey = self.server.list_surveys(self.session_key, None)
self.server.release_session_key(self.session_key)
list_active_survey = []
for survey in list_survey:
survey_has_token = questionnaires.survey_has_token_table(
survey['sid'])
if survey['active'] == "Y" and survey_has_token is True:
list_active_survey.append(survey)
self.assertEqual(questionnaires.find_all_active_questionnaires(),
list_active_survey)
questionnaires.release_session_key()
def test_add_participant_to_a_survey(self):
"""testa a insercao de participante em um questionario """
surveys = Questionnaires()
list_active_surveys = surveys.find_all_active_questionnaires()
self.assertNotEqual(list_active_surveys, None)
survey = list_active_surveys[0]
sid = int(survey['sid'])
# list_participants = self.server.list_participants(self.session_key, sid)
# participant_data = {'email': '*****@*****.**', 'lastname': 'junqueira', 'firstname': 'juca'}
participant_data_result = surveys.add_participant(sid)
# verificar se info retornada eh a mesma
# self.assertEqual(participant_data_result[0]['email'], participant_data['email'])
# self.assertEqual(participant_data_result[0]['lastname'], participant_data['lastname'])
# self.assertEqual(participant_data_result[0]['firsStname'], participant_data['firstname'])
self.assertNotEqual(participant_data_result, None)
# list_participants_new = self.server.list_participants(self.session_key, sid)
# self.assertEqual(len(list_participants_new), len(list_participants) + 1)
# token_id = participant_data_result[0]['tid']
token_id = participant_data_result['tid']
# tokens_to_delete = [token_id]
# remover participante do questionario
result = self.server.delete_participants(self.session_key, sid,
[token_id])
self.assertEqual(result[str(token_id)], 'Deleted')
surveys.release_session_key()
def test_add_and_delete_survey(self):
"""
TDD - Criar uma survey de teste e apos devera ser excluida
"""
survey_id_generated = self.server.add_survey(self.session_key, 9999,
'Questionario de Teste',
'en', 'G')
self.assertGreaterEqual(survey_id_generated, 0)
status = self.server.delete_survey(self.session_key,
survey_id_generated)
self.assertEqual(status['status'], 'OK')
self.server.release_session_key(self.session_key)
def test_add_and_delete_survey_methods(self):
questionnaires = Questionnaires()
sid = questionnaires.add_survey('9999', 'Questionario de Teste', 'en',
'G')
self.assertGreaterEqual(sid, 0)
status = questionnaires.delete_survey(sid)
self.assertEqual(status, 'OK')
# def test_get_survey_property_usetokens(self):
# """testa a obtencao das propriedades de um questionario"""
#
# surveys = Questionnaires()
# result = surveys.get_survey_properties(641729, "usetokens")
# surveys.release_session_key()
#
# pass
# def test_get_participant_property_usetokens(self):
# """testa a obtencao das propriedades de um participant/token"""
#
# surveys = Questionnaires()
#
# # completo
# result1 = surveys.get_participant_properties(426494, 2, "completed")
#
# # nao completo
# result2 = surveys.get_participant_properties(426494, 230, "completed")
# result3 = surveys.get_participant_properties(426494, 230, "token")
# surveys.release_session_key()
#
# pass
# def test_survey_has_token_table(self):
# """testa se determinado questionario tem tabela de tokens criada"""
#
# surveys = Questionnaires()
#
# # exemplo de "true"
# result = surveys.survey_has_token_table(426494)
#
# # exemplo de "false"
# result2 = surveys.survey_has_token_table(642916)
# surveys.release_session_key()
#
# pass
def test_delete_participant_to_a_survey(self):
"""
Remove survey participant test
testa a insercao de participante em um questionario
"""
surveys = Questionnaires()
list_active_surveys = surveys.find_all_active_questionnaires()
self.assertNotEqual(list_active_surveys, None)
survey = list_active_surveys[0]
sid = int(survey['sid'])
# list_participants = self.server.list_participants(self.session_key, sid)
# participant_data = {'email': '*****@*****.**', 'lastname': 'junqueira', 'firstname': 'juca'}
participant_data_result = surveys.add_participant(sid)
# verificar se info retornada eh a mesma
# self.assertEqual(participant_data_result[0]['email'], participant_data['email'])
# self.assertEqual(participant_data_result[0]['lastname'], participant_data['lastname'])
# self.assertEqual(participant_data_result[0]['firstname'], participant_data['firstname'])
self.assertNotEqual(participant_data_result, None)
# list_participants_new = self.server.list_participants(self.session_key, sid)
# self.assertEqual(len(list_participants_new), len(list_participants) + 1)
# token_id = participant_data_result[0]['tid']
token_id = participant_data_result['tid']
# tokens_to_delete = [token_id]
# remover participante do questionario
result = surveys.delete_participant(sid, token_id)
self.assertEqual(result[str(token_id)], 'Deleted')
surveys.release_session_key()
def setUp(self):
random.randint = Mock(return_value=1)
self.server = Server('http://mock/xmlrpc')
class TestJSONRPCClient(TestCase):
def setUp(self):
random.randint = Mock(return_value=1)
self.server = Server('http://mock/xmlrpc')
def test_length(self):
"""Verify that this library is really smaller than 100 lines, as stated in README.rst"""
with open(inspect.getfile(Server)) as library_file:
self.assertLessEqual(len([l for l in library_file.readlines()
if l.strip()]), 100)
def test_pep8_conformance(self):
"""Test that we conform to PEP8."""
source_files = []
project_dir = os.path.dirname(os.path.abspath(__file__))
package_dir = os.path.join(project_dir, 'jsonrpc_requests')
for root, directories, filenames in os.walk(package_dir):
source_files.extend([os.path.join(root, f) for f in filenames if f.endswith('.py')])
pep8style = pep8.StyleGuide(quiet=False, max_line_length=120)
result = pep8style.check_files(source_files)
self.assertEqual(result.total_errors, 0, "Found code style errors (and warnings).")
def test_dumps(self):
# test keyword args
self.assertSameJSON(
'''{"params": {"foo": "bar"}, "jsonrpc": "2.0", "method": "my_method_name", "id": 1}''',
self.server.serialize('my_method_name', params={'foo': 'bar'}, is_notification=False)
)
# test positional args
self.assertSameJSON(
'''{"params": ["foo", "bar"], "jsonrpc": "2.0", "method": "my_method_name", "id": 1}''',
self.server.serialize('my_method_name', params=('foo', 'bar'), is_notification=False)
)
# test notification
self.assertSameJSON(
'''{"params": ["foo", "bar"], "jsonrpc": "2.0", "method": "my_method_name"}''',
self.server.serialize('my_method_name', params=('foo', 'bar'), is_notification=True)
)
def test_deserialize(self):
with self.assertRaisesRegex(ProtocolError, 'Response is not a dictionary'):
self.server.deserialize([])
with self.assertRaisesRegex(ProtocolError, 'Response without a result field'):
self.server.deserialize({})
with self.assertRaises(ProtocolError) as protoerror:
body = {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": "1"}
self.server.deserialize(body)
self.assertEqual(protoerror.exception.args[0], -32601)
self.assertEqual(protoerror.exception.args[1], 'Method not found')
@responses.activate
def test_send_request(self):
# catch non-json responses
with self.assertRaises(TransportError) as transport_error:
responses.add(responses.POST, 'http://mock/xmlrpc', body='not json', content_type='application/json')
self.server.send_request('my_method', is_notification=False, params=None)
self.assertEqual(transport_error.exception.args[0], 'Cannot deserialize response body')
self.assertIsInstance(transport_error.exception.args[1], ValueError)
responses.reset()
# catch non-200 responses
with self.assertRaisesRegex(TransportError, '404'):
responses.add(responses.POST, 'http://mock/xmlrpc', body='{}', content_type='application/json', status=404)
self.server.send_request('my_method', is_notification=False, params=None)
responses.reset()
# catch requests own exception
with self.assertRaisesRegex(TransportError, 'Requests exception'):
def callback(request):
raise requests.RequestException('Requests exception')
responses.add_callback(
responses.POST, 'http://mock/xmlrpc', content_type='application/json', callback=callback,
)
self.server.send_request('my_method', is_notification=False, params=None)
responses.reset()
# a notification
responses.add(responses.POST, 'http://mock/xmlrpc', body='we dont care about this',
content_type='application/json')
self.server.send_request('my_notification', is_notification=True, params=None)
responses.reset()
def test_exception_passthrough(self):
with self.assertRaises(TransportError) as transport_error:
s = Server('http://host-doesnt-exist')
s.foo()
self.assertEqual(transport_error.exception.args[0], "Error calling method 'foo'")
self.assertIsInstance(transport_error.exception.args[1], requests.exceptions.RequestException)
def test_forbid_private_methods(self):
"""Test that we can't call private class methods (those starting with '_')"""
s = Server('http://host-doesnt-exist')
with self.assertRaises(AttributeError):
s._foo()
# nested private method call
with self.assertRaises(AttributeError):
s.foo.bar._baz()
@responses.activate
def test_headers_passthrough(self):
"""Test that we correctly send RFC-defined headers and merge them with user defined ones"""
def callback(request):
expected_headers = {
'Content-Type': 'application/json',
'Accept': 'application/json-rpc',
'X-TestCustomHeader': '1'
}
self.assertTrue(set(expected_headers.items()).issubset(set(request.headers.items())))
return 200, {}, u'{"jsonrpc": "2.0", "result": true, "id": 1}'
responses.add_callback(
responses.POST, 'http://mock/xmlrpc', content_type='application/json', callback=callback,
)
s = Server('http://mock/xmlrpc', headers={'X-TestCustomHeader': '1'})
s.foo()
def test_method_call(self):
"""mixing *args and **kwargs is forbidden by the spec"""
with self.assertRaisesRegex(ProtocolError, 'JSON-RPC spec forbids mixing arguments and keyword arguments'):
self.server.testmethod(1, 2, a=1, b=2)
@responses.activate
def test_method_nesting(self):
"""Test that we correctly nest namespaces"""
def callback(request):
request_message = json.loads(request.body)
if (request_message["params"][0] == request_message["method"]):
return (200, {}, u'{"jsonrpc": "2.0", "result": true, "id": 1}')
else:
return (200, {}, u'{"jsonrpc": "2.0", "result": false, "id": 1}')
responses.add_callback(
responses.POST, 'http://mock/xmlrpc', content_type='application/json', callback=callback,
)
self.assertEqual(self.server.nest.testmethod("nest.testmethod"), True)
self.assertEqual(self.server.nest.testmethod.some.other.method("nest.testmethod.some.other.method"), True)
@responses.activate
def test_calls(self):
# rpc call with positional parameters:
def callback1(request):
request_message = json.loads(request.body)
self.assertEqual(request_message["params"], [42, 23])
return (200, {}, u'{"jsonrpc": "2.0", "result": 19, "id": 1}')
responses.add_callback(
responses.POST, 'http://mock/xmlrpc',
content_type='application/json',
callback=callback1,
)
self.assertEqual(self.server.subtract(42, 23), 19)
responses.reset()
# rpc call with named parameters
def callback2(request):
request_message = json.loads(request.body)
self.assertEqual(request_message["params"], {'y': 23, 'x': 42})
return (200, {}, u'{"jsonrpc": "2.0", "result": 19, "id": 1}')
responses.add_callback(
responses.POST, 'http://mock/xmlrpc',
content_type='application/json',
callback=callback2,
)
self.assertEqual(self.server.subtract(x=42, y=23), 19)
responses.reset()
@responses.activate
def test_notification(self):
# Verify that we ignore the server response
responses.add(responses.POST, 'http://mock/xmlrpc',
body='{"jsonrpc": "2.0", "result": 19, "id": 3}',
content_type='application/json')
self.assertIsNone(self.server.subtract(42, 23, _notification=True))
responses.reset()
def setUp(self):
random.randint = Mock(return_value=1)
self.server = Server('http://mock/xmlrpc')
class ABCSearchEngine(ABC):
session_key = None
server = None
def __init__(self):
self.get_session_key()
def get_session_key(self):
self.server = Server(settings.LIMESURVEY['URL_API'] +
'/index.php/admin/remotecontrol')
try:
self.session_key = self.server.get_session_key(
settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
self.session_key = None if isinstance(self.session_key, dict) \
else self.session_key
except TransportError:
self.session_key = None
def release_session_key(self):
if self.session_key:
self.server.release_session_key(self.session_key)
@abstractmethod
def find_all_questionnaires(self):
"""
:return: all stored surveys
"""
list_survey = self.server.list_surveys(self.session_key, None)
return list_survey
@abstractmethod
def find_all_active_questionnaires(self):
"""
:return: all active surveys
"""
list_survey = self.server.list_surveys(self.session_key, None)
list_active_survey = []
if isinstance(list_survey, list):
for survey in list_survey:
if survey['active'] == "Y" and self.survey_has_token_table(
survey['sid']):
list_active_survey.append(survey)
else:
list_active_survey = None
return list_active_survey
@abstractmethod
def find_questionnaire_by_id(self, sid):
"""
:param sid: survey ID
:return: survey
"""
list_survey = self.server.list_surveys(self.session_key, None)
try:
survey = next(
(survey for survey in list_survey if survey['sid'] == sid))
except StopIteration:
survey = None
return survey
@abstractmethod
def add_participant(self, sid):
"""
:param sid: Survey ID
:return: dictionary with token and token_id; None if error.
"""
participant_data = {'email': '', 'firstname': '', 'lastname': ''}
result = self.server.add_participants(self.session_key, sid,
[participant_data], True)
if result \
and isinstance(result, list) \
and isinstance(result[0], dict) \
and 'error' not in result[0]:
return {'token': result[0]['token'], 'tid': result[0]['tid']}
else:
return None
@abstractmethod
def delete_participant(self, survey_id, tokens_ids):
""" Delete survey participant
:param survey_id: survey ID
:param tokens_ids: token_id to put in a list
:return: on success, an array of deletion status for each participant; on failure, status array.
"""
result = self.server.delete_participants(self.session_key, survey_id,
[tokens_ids])
return result
@abstractmethod
def get_survey_title(self, sid, language):
"""
:param sid: survey ID
:param language: language
:return: title of the survey
"""
if self.session_key:
survey_title = self.server.get_language_properties(
self.session_key, sid, {'method': 'surveyls_title'}, language)
if 'surveyls_title' in survey_title:
survey_title = survey_title.get('surveyls_title')
else:
survey_title = str(sid)
else:
survey_title = str(sid)
return survey_title
@abstractmethod
def get_survey_properties(self, sid, prop):
"""
:param sid: survey ID
:param prop: the name of the propriety of the survey
:return: value of the property
"""
result = self.server.get_survey_properties(self.session_key, sid,
{'method': prop})
return result.get(prop)
@abstractmethod
def get_survey_languages(self, sid):
"""
:param sid: survey ID
:return: the base and the additional idioms
"""
result = self.server.get_survey_properties(
self.session_key, sid, ['additional_languages', 'language'])
return result
@abstractmethod
def activate_survey(self, sid):
""" Activates a survey
:param sid: survey ID
:return: status of the survey
"""
result = self.server.activate_survey(self.session_key, sid)
return result['status']
@abstractmethod
def activate_tokens(self, sid):
""" Activates tokens for a determined survey
:param sid: survey ID
:return: status of the survey
"""
result = self.server.activate_tokens(self.session_key, sid)
return result['status']
@abstractmethod
def get_participant_properties(self, survey_id, token_id, prop):
"""
:param survey_id: survey ID
:param token_id: token ID
:param prop: property name
:return: value of a determined property from a participant/token
"""
if self.session_key:
result = self.server.get_participant_properties(
self.session_key, survey_id, token_id, {'method': prop})
result = result.get(prop)
else:
result = ''
return result
@abstractmethod
def survey_has_token_table(self, sid):
"""
:param sid: survey ID
:return: True if the survey has token table; False, if not.
"""
result = self.server.get_summary(self.session_key, sid,
"token_completed")
return isinstance(result, int)
@abstractmethod
def add_survey(self, sid, title, language, survey_format):
""" Adds a survey to the LimeSurvey
:param sid: survey ID
:param title: title of the survey
:param language: language of the survey
:param survey_format: format of the survey
:return: survey ID generated
"""
survey_id_generated = self.server.add_survey(self.session_key, sid,
title, language,
survey_format)
return survey_id_generated
@abstractmethod
def delete_survey(self, sid):
""" remove a survey from the LimeSurvey
:param sid: survey ID
:return: status of the operation
"""
status = self.server.delete_survey(self.session_key, sid)
return status['status']
@abstractmethod
def get_responses_by_token(self, sid, token, language, fields=[]):
""" obtains responses from a determined token
:param sid: survey ID
:param token: token
:param language: language
:param fields: fields array, using SGQA identifier
:return: responses in the txt format
"""
if fields:
responses = self.server.export_responses_by_token(
self.session_key, sid, 'csv', token, language, 'complete',
'code', 'short', fields)
else:
responses = self.server.export_responses_by_token(
self.session_key, sid, 'csv', token, language, 'complete')
if isinstance(responses, str):
responses_txt = b64decode(responses)
else:
responses_txt = responses
return responses_txt
@abstractmethod
def get_responses(self, sid, language, response_type, fields,
heading_type):
""" Obtains responses from a determined survey
:param sid: survey ID
:param language: language
:param response_type: (optional)'short' or 'long'
Optional defaults to 'short'
:param fields: filter fields that must be returned
:param heading_type: (optional) 'code','full' or 'abbreviated'
Optional defaults to 'code'
:return: responses in txt format
"""
responses = self.server.export_responses(self.session_key, sid, 'csv',
language, 'complete',
heading_type, response_type)
if isinstance(responses, str):
responses_txt = b64decode(responses)
else:
responses_txt = responses
return responses_txt
def get_header_response(self, sid, language, token, heading_type):
""" Obtain header responses
:param sid: survey ID
:param language: language
:param heading_type: heading type (can be 'code' or 'full')
:return: responses in the txt format
"""
responses = self.server.export_responses_by_token(
self.session_key, sid, 'csv', token, language, 'complete',
heading_type, 'short')
if not isinstance(responses, str):
responses = self.server.export_responses(self.session_key, sid,
'csv', language,
'complete', heading_type,
'short')
if isinstance(responses, str):
responses_txt = b64decode(responses)
else:
responses_txt = responses
return responses_txt
@abstractmethod
def get_summary(self, sid, stat_name):
"""
:param sid: survey ID
:param stat_name: name of the summary option - valid values are 'token_count', 'token_invalid', 'token_sent',
'token_opted_out', 'token_completed', 'completed_responses', 'incomplete_responses', 'full_responses' or 'all'
:return: summary information
"""
summary_responses = self.server.get_summary(self.session_key, sid,
stat_name)
return summary_responses
@abstractmethod
def insert_questions(self, sid, questions_data, format_import_file):
""" Imports a group of questions from a file
:param sid: survey ID
:param questions_data: question data
:param format_import_file: lsg file
:return:
"""
questions_data_b64 = b64encode(questions_data.encode('utf-8'))
result = self.server.import_group(self.session_key, sid,
questions_data_b64.decode('utf-8'),
format_import_file)
if isinstance(result, dict):
if 'status' in result:
return None
else:
return result
@abstractmethod
def get_question_properties(self, question_id, language):
"""
:param question_id: question ID
:param language: language of the answer
:return: properties of a question of a survey
"""
properties = self.server.get_question_properties(
self.session_key, question_id, [
'gid', 'question', 'subquestions', 'answeroptions', 'title',
'type', 'attributes_lang', 'attributes', 'other'
], language)
return properties
def set_question_properties(self, sid, data):
return self.server.set_question_properties(self.session_key, sid, data)
@abstractmethod
def list_groups(self, sid):
"""
:param sid: survey ID
:return: ids and info of groups belonging to survey
"""
groups = self.server.list_groups(self.session_key, sid)
return groups
@abstractmethod
def get_group_properties(self, gid):
"""
:param gid: group ID
:param lang: group language to return correct group, as Remote
Control API does not do that
:return: list of group properties
"""
return self.server.get_group_properties(self.session_key, gid)
def set_group_properties(self, sid, data):
return self.server.set_group_properties(self.session_key, sid, data)
@abstractmethod
def list_questions(self, sid, gid):
"""
:param sid: survey ID
:param gid: group ID
:return: ids and info of (sub-)questions of a survey/group
"""
question_list = []
questions = self.server.list_questions(self.session_key, sid, gid)
for question in questions:
question_list.append(question['id']['qid'])
return question_list
@abstractmethod
def find_tokens_by_questionnaire(self, sid):
"""
:param sid:
:return: tokens for specific id
"""
tokens = self.server.list_participants(self.session_key, sid, 0,
99999999)
return tokens
def add_group(self, sid, title, description):
return self.server.add_group(self.session_key, sid, title)
def add_response(self, sid, response_data):
return self.server.add_response(self.session_key, sid, response_data)
def set_participant_properties(self, sid, tid, properties_dict):
return self.server.set_participant_properties(self.session_key, sid,
tid, properties_dict)
from jsonrpc_requests import Server
fusion = Server("http://EMEA-DCRS-FM-48X-1/jsonrpc")
fusion.login(username="******", password="******")
#print (fusion.get_hostname())
#print (fusion.get_startup_config("patch"))
#print (fusion.get_messages())
pl = fusion.get_ports("A1", "A2", "A3")
print(pl[0])
for i in pl:
for k in i.keys():
if (i[k] != ''):
if (k != 'name'):
print(" {:<16s} : {:2s} ".format(k, str(i[k])))
else:
print(i[k])
print('\n')
