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 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 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 )
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()
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()
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')