def test_discover(self): executor = RequestHandler(self.plugin_path, os.path.join(os.getcwd(), 'src', 'ovirtscheduler')) ret = executor.discover() print ret assert ret == { 'balance': { 'test_plugin': ( 'This is a fake balance function that always' ' return the guid' ' 33333333-3333-3333-3333-333333333333', '')}, 'filters': { 'test_plugin': ( 'This is a simple filter that returns' ' all given host ID', ''), 'test_failing_plugin': ('This filter is expected to fail and' ' should be used only in tests.', '')}, 'scores': { 'test_plugin': ( 'This is a simple score function that' ' returns all given host ID with score' ' 50', ''), 'test_failing_plugin': ( 'This function is expected to fail and' ' should be used only in tests.', '')}} pass
def test_aggregate_filter_results_empty(self): """ Tests if the empty filterRunners array results in None. """ executor = RequestHandler(self.plugin_path, os.path.join(os.getcwd(), 'src')) filterRunners = [] assert executor.aggregate_filter_results(filterRunners, '') is None
def setUp(self): dummy_key = 12345678901234567890123456789012 headers = {'X-Auth-Token': dummy_key} TEAM_DATA = get_team_data()["teams"] TEAM_NAMES = {team["code"]: team["id"] for team in TEAM_DATA} LEAGUE_IDS = leagueids.LEAGUE_IDS self.dummy_url = "http://some_url" writer = get_writer() self.rq = RequestHandler(headers, LEAGUE_IDS, TEAM_NAMES, writer)
def test_aggregate_filter_results_singleNone(self): """ Checks that the aggregate filter will return None when all runners fail. """ executor = RequestHandler(self.plugin_path, os.path.join(os.getcwd(), 'src')) class NoneResultRunner: def __init__(self): self._script = 'test' def getResults(self): return None def getReturnCode(self): return 1 def getErrors(self): return None filterRunners = [NoneResultRunner()] assert executor.aggregate_filter_results(filterRunners, '') is None
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_socket.bind(('localhost', 8000)) server_socket.listen(5) def parse_http(http: str): request, *headers, _, body = http.split('\r\n') method, path, protocol = request.split(" ") headers = dict(line.split(":", maxsplit=1) for line in headers) return locals() def prepare_response(response): return response.encode('utf-8') def view(request): # todo return Response(status=200, content='Your Application Response').to_byte() while True: connection, address = server_socket.accept() http_request = connection.recv(1024).decode('utf-8') request = RequestHandler(**parse_http(http_request)) response = view(request) http_response = prepare_response(response) connection.sendall(http_response)
def application(): return WSGIApplication([ ('/', RequestHandler.with_page('handlers.default')), ('/people/add', RequestHandler.with_page('handlers.people.add')), ('/people', RequestHandler.with_page('handlers.people.search')), ('/people/proximity', RequestHandler.with_page('handlers.people.proximity')), ('/people/bounding_box', RequestHandler.with_page('handlers.people.bounding_box')), ('/people/upload', RequestHandler.with_page('handlers.people.upload')), ('/people/([^/]*)$', RequestHandler.with_page('handlers.people.detail')), ('/events/add', RequestHandler.with_page('handlers.events.add')), ('/events/proximity', RequestHandler.with_page('handlers.events.proximity')), ('/events/bounding_box', RequestHandler.with_page('handlers.events.bounding_box')), ('/events', RequestHandler.with_page('handlers.events.default')), ('/events/users', RequestHandler.with_page('handlers.events.users')), ('/events/upload', RequestHandler.with_page('handlers.events.upload')), ('/events/([^/]*)$', RequestHandler.with_page('handlers.events.detail')), ('/events/([^/]*)/attending/add$', RequestHandler.with_page('handlers.events.attending.add')), ], debug=True)
def open_routes(path): requestHandler = RequestHandler('') return requestHandler.handle_request(flask.request.path, flask.request, False)
from request_handler import RequestHandler from examples.user import User rh = RequestHandler() rh.add(User, '/user') def main(request): return rh.handle(request)
class HttpServer: __request_parser: RequestParser = RequestParser() __request_processor: RequestHandler = RequestHandler() def __init__(self, config_name="config.json"): self.__config = ServerConfig(config_name) logging.basicConfig(filename=self.__config.log_file, level=logging.DEBUG, format='%(asctime)s %(message)s') self.thread_pool = ThreadPool() def run(self): """Binds, listens, processing HTTP requests on socket""" s = socket(AF_INET, SOCK_STREAM) s.bind((self.__config.host, self.__config.port)) s.listen(self.__config.queue_size) logging.info(f'Launched at {self.__config.port}') while True: try: client_connection, _ = s.accept() except Exception as e: logging.info(e) s.close() break client_connection.settimeout(self.__config.max_req_time) self.thread_pool.add_task(self.__route_request, client_connection) def __route_request(self, client): """Routes request to handler if exists, then closes the connection""" if self.__config.proxy_pass_mode: __proxy_passer = ProxyPasser(client) __proxy_passer.run() return while True: try: raw_request = self.__read_from_socket(client) except timeout: logging.info("Caught timeout waiting for socket connection") break except ReadSocketError: bad_response = Response(code=400) client.sendall(bad_response.get_bytes()) client.close() logging.info(f'Failed to read request. Returned response' f' {bad_response.code}') return req = self.__request_parser.parse(raw_request) if req.method == "GET": response_func, response = self.__request_processor.handle_get( req) logging.info(f'Received GET {req.path}, ' f'returned response {response.code}') response_func(client=client) if "Connection" not in req.headers \ or req.headers["Connection"].lower() != "keep-alive": break client.close() def __read_from_socket(self, client): """Reads request data from socket. If request method or protocol are not supported, rejects it""" result = bytearray() req = None head_len = 0 total_len = None while not total_len or head_len < total_len: chunk = client.recv(8192) if not chunk: break result += chunk head_len += len(chunk) if not req: req = self.__request_parser.try_get_headers(result) if not req: continue if req.method not in self.__config.supported_methods or \ req.proto not in self.__config.supported_protos: logging.info(f'Received unsupported request {req}') raise ReadSocketError("Request of this type not supported") total_len = req.headers.get("Content-Length") if not total_len: break return result
raise Exception("No Bridge Detected") #cloud_variable_ep = CloudVariableEp(hub_variables) #this class can be used to poll an endpoint, I didn't find a real use for it. # ep_poller = EndpointPoller(translations, hub_variables) serial_handler = SerialHandler(selected) # while true swap between polling EPs and receiving / sending. while (True): # if the bridged micro:bit has sent us data, process if serial_handler.buffered() > 0: rPacket = RadioPacket(serial_handler.read_packet()) translationsFile = open("./translations.json") translations = json.load(translationsFile) requestHandler = RequestHandler(rPacket, translations, hub_variables, None) bytes = requestHandler.handleRequest() serial_handler.write_packet(bytes) # else: # otherwise check if our asynchronous socket io ep has packets to transmit. # bytes = cloud_variable_ep.drain() # if len(bytes) > 0: # serial_handler.write_packet(bytes) # prevent burning the processor :) sleep(0.01)
github_poller = URLPoller(hub_variables["translations_json"]["url"], hub_variables["translations_json"]["poll_time"]) packet_count = 0 try: while(True): # if the bridged micro:bit has sent us data, process if serial_handler.buffered() > 0: rPacket = RadioPacket(serial_handler.read_packet()) packet_count += 1 now = datetime.datetime.now() print "Request Time: %d:%d:%d; Packets Seen: %d" % (now.hour, now.minute, now.second, packet_count) requestHandler = RequestHandler(rPacket,translations, shared_dict, None) # spawn a new thread to handle the request p = Process(target=handleRequest, args=(requestHandler, serial_handler,)) p.start() # every few minutes we check github for new translations. if github_poller.poll(): temp_translations = github_poller.get_cached() if temp_translations["version"] <= translations["version"]: continue translations = temp_translations print "Updating translations from Github"
def main(): tree_printer('..') configFile = json.load(open('../config/soccer_data_config.json', 'r')) if not configFile: click.secho("Could not find configFile", fg="red", bold=True) exit(-1) apikey = configFile['apiToken'] print("API Token found.") print(apikey) headers = {'X-Auth-Token': apikey} print("Fetching today's date ...") today = date.today() print("Today is: {}".format(today.strftime("%Y-%m-%d"))) try: print("Instatiating request handler") #NEED TO MAKE IT A THREAD rh = RequestHandler(headers) print("Instatiating json Writer and reader") js = JSonWR('../data/updates') for competition in configFile['competitions']: print("Trying to fetch information on {}".format( competition['Name'])) league = rh.get_league(competition['ID']) if not league: click.secho("League: {} with ID: {} NOT FOUND".format( competition['Name'], competition['ID']), fg="red", bold=True) break season = league['seasons'][0] new_season = False last_season_updated = js.open_json(['league', str(league['id']) ])['seasons'][0] if season != last_season_updated: new_season = True update_matches = rh.get_league_scores( league, matchFilter=competition['matchFilter'], dateFrom=(today - timedelta(days=1)), dateTo=datetime.strptime(season['endDate'], '%Y-%m-%d')) if new_season: update_teams = rh.get_teams_in_league(league, season=season) if update_teams: print( "New Season update available, teams fetched: ".format( len(update_teams['teams']))) js.save_json(update_teams, [ 'league', str(league['id']), 'season', season['startDate'][:4], 'updated_teams' ]) if update_matches: print("New Matches fetched: {}".format( len(update_matches['matches']))) js.save_json(update_matches, [ 'league', str(league['id']), 'season', season['startDate'][:4], 'updated_matches', today.strftime("%Y_%m_%d") ]) js.save_json(league, ['league', str(league['id'])]) else: click.secho("NO new matches for this week", fg="red", bold=True) except IncorrectParametersException as e: click.secho(str(e), fg="red", bold=True)
def create_context(): global request_handler airline_management = AirlineManagement() request_handler = RequestHandler() request_handler.link_handler('/bookSeat', airline_management.book_seat) request_handler.link_handler('/canCommit', airline_management.can_commit) request_handler.link_handler('/finishTransaction', airline_management.commit) request_handler.link_handler('/rollbackTransaction', airline_management.rollback) request_handler.link_handler('/getSeats', airline_management.get_seats) request_handler.link_handler('/getAvailableSeats', airline_management.get_available_seats) request_handler.link_handler('/runningTransactions', airline_management.running_transactions)
# -*- coding: utf-8 -*- """ Отсюда вызывать RequestHandler с параметрами """ from request_handler import RequestHandler import json __author__ = 'Anton Korobkov' # загружаем параметры with open('parameters.json') as data_file: connection_data = json.load(data_file) handler = RequestHandler() for regnum in connection_data["regions"]: for okpd in connection_data["okpds"]: handler.main(regnum, okpd=okpd) handler.write_to_excel('pandas_simple.xlsx')
# -*- coding: utf-8 -*-
def __init__(self, server_address, routes): RequestHandler.add_routes(routes) self.httpd = HTTPServer(server_address, RequestHandler)
def __init__(self, channel, source_dir): self.channel = channel self.handler = RequestHandler(source_dir)
class TestRequestHandler(unittest.TestCase): VALID_LEAGUE_CODE = "BL" VALID_TEAM_CODE = "AFC" VALID_TIME = 10 def setUp(self): dummy_key = 12345678901234567890123456789012 headers = {'X-Auth-Token': dummy_key} TEAM_DATA = get_team_data()["teams"] TEAM_NAMES = {team["code"]: team["id"] for team in TEAM_DATA} LEAGUE_IDS = leagueids.LEAGUE_IDS self.dummy_url = "http://some_url" writer = get_writer() self.rq = RequestHandler(headers, LEAGUE_IDS, TEAM_NAMES, writer) def tearDown(self): pass @mock.patch('requests.get') def test_ok_code(self, mock_call): mock_call.return_value = mock.MagicMock(status_code=requests.codes.ok, response=json.dumps( {'key': 'value'})) try: self.rq._get(self.dummy_url) except APIErrorException: self.fail("Threw exception erroneously") @mock.patch('requests.get') def test_bad_code(self, mock_call): mock_call.return_value = mock.MagicMock(status_code=requests.codes.bad, response=json.dumps( {'key': 'value'})) with self.assertRaises(APIErrorException) as context: self.rq._get(self.dummy_url) self.assertTrue("Invalid request. " "Check parameters." in context.exception) @mock.patch('requests.get') def test_forbidden_code(self, mock_call): mock_call.return_value = mock.MagicMock( status_code=requests.codes.forbidden, response=json.dumps({'key': 'value'})) with self.assertRaises(APIErrorException) as context: self.rq._get(self.dummy_url) self.assertTrue('This resource is restricted' in context.exception) @mock.patch('requests.get') def test_not_found_code(self, mock_call): mock_call.return_value = mock.MagicMock( status_code=requests.codes.not_found, response=json.dumps({'key': 'value'})) with self.assertRaises(APIErrorException) as context: self.rq._get(self.dummy_url) self.assertTrue("This resource does not exist. " "Check parameters" in context.exception) @mock.patch('requests.get') def test_too_many_requests_code(self, mock_call): mock_call.return_value = mock.MagicMock( status_code=requests.codes.too_many_requests, response=json.dumps({'key': 'value'})) with self.assertRaises(APIErrorException) as context: self.rq._get(self.dummy_url) self.assertTrue("You have exceeded your allowed " "requests per minute/day" in context.exception) # @mock.patch('soccer.writers.Stdout.live_scores') # @mock.patch('requests.get') # def test_get_live_scores_ok(self, mock_request_call, mock_writer): # mock_request_call.side_effect = \ # [mocked_requests_get({'games': [1, 2]}, 200)] # mock_writer.return_value = mock.Mock() # self.rq.get_live_scores(True) # mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('soccer.writers.Stdout.live_scores') @mock.patch('requests.get') def test_get_live_scores_0_games(self, mock_request_call, mock_writer, mock_click): mock_request_call.side_effect = \ [mocked_requests_get({'games': []}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_live_scores(True) mock_click.assert_called_with("No live action " "currently", fg="red", bold=True) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('soccer.writers.Stdout.live_scores') @mock.patch('requests.get') def test_get_live_scores_error(self, mock_request_call, mock_writer, mock_click): mock_request_call.side_effect = \ [mocked_requests_get({'games': [1, 2]}, 400)] mock_writer.return_value = mock.Mock() self.rq.get_live_scores(True) mock_click.assert_called_with( "There was problem getting " "live scores", fg="red", bold=True) mock_writer.assert_called_once() # @mock.patch('soccer.writers.Stdout.team_scores') # @mock.patch('requests.get') # def test_get_team_scores_ok(self, # mock_request_call, mock_writer): # mock_request_call.side_effect = \ # [mocked_requests_get({'fixtures': [1, 2]}, 200)] # mock_writer.return_value = mock.Mock() # self.rq.get_team_scores(TestRequestHandler.VALID_TEAM_CODE, # 6, True, True) # mock_writer.assert_called_once() # @mock.patch('click.secho') # @mock.patch('soccer.writers.Stdout.team_scores') # @mock.patch('requests.get') # def test_get_team_scores_0_fixtures(self, # mock_request_call, # mock_writer, mock_click): # mock_request_call.side_effect = \ # [mocked_requests_get({'fixtures': []}, 200)] # mock_writer.return_value = mock.Mock() # self.rq.get_team_scores(TestRequestHandler.VALID_TEAM_CODE, # 6, True, True) # mock_click.assert_called_with("No action during" # " past week. Change the time " # "parameter to get " # "more fixtures.", fg="red", bold=True) # mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('soccer.writers.Stdout.team_scores') @mock.patch('requests.get') def test_get_team_scores_bad_id(self, mock_request_call, mock_writer, mock_click): mock_request_call.side_effect = \ [mocked_requests_get({'fixtures': [1, 2]}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_team_scores("AdkljdfkljkdlFC", 6, True, True) mock_click.assert_called_with("Team code is not " "correct.", fg="red", bold=True) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('requests.get') def test_get_standings_error(self, mock_request_call, mock_click): mock_request_call.side_effect = \ APIErrorException() self.rq.get_standings(TestRequestHandler.VALID_LEAGUE_CODE) mock_click.assert_called_with( "No standings availble for " "{league}.".format(league=TestRequestHandler.VALID_LEAGUE_CODE), fg="red", bold=True) @mock.patch('soccer.writers.Stdout.standings') @mock.patch('requests.get') def test_get_standings_ok(self, mock_request_call, mock_writer): mock_request_call.side_effect = \ [mocked_requests_get({'standing': []}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_standings(TestRequestHandler.VALID_LEAGUE_CODE) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('requests.get') def test_get_league_scores_error(self, mock_request_call, mock_click): mock_request_call.side_effect = \ APIErrorException() self.rq.get_league_scores(TestRequestHandler.VALID_LEAGUE_CODE, TestRequestHandler.VALID_TIME, False, False) mock_click.assert_called_with("No data " "for the given league.", fg="red", bold=True) # @mock.patch('click.secho') # @mock.patch('requests.get') # def test_get_league_scores_no_fixtures(self, # mock_request_call, # mock_click): # mock_request_call.side_effect = \ # [mocked_requests_get({'fixtures': []}, 200)] # self.rq.get_league_scores(TestRequestHandler.VALID_LEAGUE_CODE, # TestRequestHandler.VALID_TIME, False, False) # mock_click.assert_called_with("No {league} matches in " # "the past week.".format( # league=TestRequestHandler.VALID_LEAGUE_CODE), # fg="red", bold=True) # @mock.patch('soccer.writers.Stdout.league_scores') # @mock.patch('requests.get') # def test_get_league_scores_multiple_fixtures(self, # mock_request_call, # mock_writer): # mock_request_call.side_effect = \ # [mocked_requests_get({'fixtures': [1]}, 200)] # mock_writer.return_value = mock.Mock() # self.rq.get_league_scores(TestRequestHandler.VALID_LEAGUE_CODE, # TestRequestHandler.VALID_TIME, False, False) # mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('requests.get') def test_get_team_players_error(self, mock_request_call, mock_click): mock_request_call.side_effect = APIErrorException() self.rq.get_team_players(TestRequestHandler.VALID_TEAM_CODE) mock_click.assert_called_with( "No data for the team. " "Please check the team code.", bold=True, fg="red")
def search(): try: # Process request and return final list json objects return jsonify(RequestHandler.process_request(request)) except Exception as e: return jsonify({'ERROR': str(e)})
class Dnb_res_handler(object): def __init__(self, client_id, client_secret, api_key, endpoint): self.endpoint = endpoint self.aws_signing_v4 = AwsSigningV4( aws_access_key_id=client_id, aws_secret_access_key=client_secret, aws_host="developer-api-sandbox.dnb.no", aws_region="eu-west-1", aws_service="execute-api", ) self.request_handler = RequestHandler( endpoint=self.endpoint, aws_signing_v4=self.aws_signing_v4, api_key=api_key) def get_customers(self): all_customer_path = "/testCustomers" all_customer_res = self.request_handler.get_request( path=all_customer_path, params={}) all_customers = all_customer_res.json() return all_customers["customers"] def get_customer_token(self, ssn): value = "{\"type\":\"SSN\", \"value\":\"%s\"}" % ssn token_params = {"customerId": value} token_path = "/token" customer_token_res = self.request_handler.get_request( path=token_path, params=token_params) token = customer_token_res.json() return token["tokenInfo"][0] def get_accounts(self, token): all_accounts_path = "/accounts" all_accounts_res = self.request_handler.get_request( path=all_accounts_path, params={}, api_token=token) all_accounts = all_accounts_res.json() return all_accounts["accounts"] def get_transactions(self, accountNumber, token, from_date, to_date): transactions_path = "/transactions/%s" % accountNumber time_interval = {"fromDate": from_date, "toDate": to_date} # print(time_interval) all_transactions_res = self.request_handler.get_request( path=transactions_path, params=time_interval, api_token=token) # print(all_transactions_res) all_transactions = all_transactions_res.json()["transactions"] out_going = [] for trans in all_transactions: trans.pop("externalReference") trans.pop("textLines") trans.pop("details") trans.pop("bookingDate") trans.pop("valueDate") trans.pop("accountNumber") trans.pop("transactionDate") trans.pop("transactionId") for trans in all_transactions: if (trans["amount"] < 0): out_going.append(trans) return out_going
def create_context(): global request_handler hotel_management = HotelManagement() request_handler = RequestHandler() request_handler.link_handler('/bookRoom', hotel_management.book_room) request_handler.link_handler('/canCommit', hotel_management.can_commit) request_handler.link_handler('/finishTransaction', hotel_management.commit) request_handler.link_handler('/rollbackTransaction', hotel_management.rollback) request_handler.link_handler('/getRooms', hotel_management.get_rooms) request_handler.link_handler('/getAvailableRooms', hotel_management.get_available_rooms) request_handler.link_handler('/runningTransactions', hotel_management.running_transactions)
def run_scripts(): try: return jsonify(RequestHandler.process_request(request)) except Exception as e: return jsonify({'ERROR': str(e)})
def accept_wrapper(self, sock): conn, addr = sock.accept() print("accepted connection from", addr) conn.setblocking(False) message = RequestHandler(self.sel, conn, addr) self.sel.register(conn, selectors.EVENT_READ, data=message)
import logging from colorama import Fore, Style from flask import Flask, request, make_response, jsonify from databases.models import create_tables from helpers.utility import get_time from request_handler import RequestHandler log = logging.getLogger('werkzeug') log.setLevel(logging.ERROR) app = Flask(__name__) parser = RequestHandler() # default route @app.route('/') def index(): return 'Hello World!' # function for responses def results(): print("-" * 20) print( f"{Fore.CYAN}{get_time()} [SERVER] New request received.{Style.RESET_ALL}" ) # Parse JSON request into a readable object.
class TestRequestHandler(unittest.TestCase): VALID_LEAGUE_CODE = "BL" VALID_TEAM_CODE = "AFC" VALID_TIME = 10 def setUp(self): dummy_key = 12345678901234567890123456789012 headers = {'X-Auth-Token': dummy_key} TEAM_DATA = get_team_data()["teams"] TEAM_NAMES = {team["code"]: team["id"] for team in TEAM_DATA} LEAGUE_IDS = leagueids.LEAGUE_IDS self.dummy_url = "http://some_url" writer = get_writer() self.rq = RequestHandler(headers, LEAGUE_IDS, TEAM_NAMES, writer) def tearDown(self): pass @mock.patch('requests.get') def test_ok_code(self, mock_call): mock_call.return_value = mock.MagicMock( status_code=requests.codes.ok, response=json.dumps({'key': 'value'})) try: self.rq._get(self.dummy_url) except APIErrorException: self.fail("Threw exception erroneously") @mock.patch('requests.get') def test_bad_code(self, mock_call): mock_call.return_value = mock.MagicMock( status_code=requests.codes.bad, response=json.dumps({'key': 'value'})) with self.assertRaises(APIErrorException) as context: self.rq._get(self.dummy_url) self.assertTrue("Invalid request. " "Check parameters." in context.exception) @mock.patch('requests.get') def test_forbidden_code(self, mock_call): mock_call.return_value = mock.MagicMock( status_code=requests.codes.forbidden, response=json.dumps({'key': 'value'})) with self.assertRaises(APIErrorException) as context: self.rq._get(self.dummy_url) self.assertTrue('This resource is restricted' in context.exception) @mock.patch('requests.get') def test_not_found_code(self, mock_call): mock_call.return_value = mock.MagicMock( status_code=requests.codes.not_found, response=json.dumps({'key': 'value'})) with self.assertRaises(APIErrorException) as context: self.rq._get(self.dummy_url) self.assertTrue("This resource does not exist. " "Check parameters" in context.exception) @mock.patch('requests.get') def test_too_many_requests_code(self, mock_call): mock_call.return_value = mock.MagicMock( status_code=requests.codes.too_many_requests, response=json.dumps({'key': 'value'})) with self.assertRaises(APIErrorException) as context: self.rq._get(self.dummy_url) self.assertTrue("You have exceeded your allowed " "requests per minute/day" in context.exception) @mock.patch('soccer.writers.Stdout.live_scores') @mock.patch('requests.get') def test_get_live_scores_ok(self, mock_request_call, mock_writer): mock_request_call.side_effect = \ [mocked_requests_get({'games': [1, 2]}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_live_scores(True) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('soccer.writers.Stdout.live_scores') @mock.patch('requests.get') def test_get_live_scores_0_games(self, mock_request_call, mock_writer, mock_click): mock_request_call.side_effect = \ [mocked_requests_get({'games': []}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_live_scores(True) mock_click.assert_called_with("No live action " "currently", fg="red", bold=True) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('soccer.writers.Stdout.live_scores') @mock.patch('requests.get') def test_get_live_scores_error(self, mock_request_call, mock_writer, mock_click): mock_request_call.side_effect = \ [mocked_requests_get({'games': [1, 2]}, 400)] mock_writer.return_value = mock.Mock() self.rq.get_live_scores(True) mock_click.assert_called_with("There was problem getting " "live scores", fg="red", bold=True) mock_writer.assert_called_once() @mock.patch('soccer.writers.Stdout.team_scores') @mock.patch('requests.get') def test_get_team_scores_ok(self, mock_request_call, mock_writer): mock_request_call.side_effect = \ [mocked_requests_get({'fixtures': [1, 2]}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_team_scores(TestRequestHandler.VALID_TEAM_CODE, 6, True, True) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('soccer.writers.Stdout.team_scores') @mock.patch('requests.get') def test_get_team_scores_0_fixtures(self, mock_request_call, mock_writer, mock_click): mock_request_call.side_effect = \ [mocked_requests_get({'fixtures': []}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_team_scores(TestRequestHandler.VALID_TEAM_CODE, 6, True, True) mock_click.assert_called_with("No action during" " past week. Change the time " "parameter to get " "more fixtures.", fg="red", bold=True) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('soccer.writers.Stdout.team_scores') @mock.patch('requests.get') def test_get_team_scores_bad_id(self, mock_request_call, mock_writer, mock_click): mock_request_call.side_effect = \ [mocked_requests_get({'fixtures': [1, 2]}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_team_scores("AdkljdfkljkdlFC", 6, True, True) mock_click.assert_called_with("Team code is not " "correct.", fg="red", bold=True) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('requests.get') def test_get_standings_error(self, mock_request_call, mock_click): mock_request_call.side_effect = \ APIErrorException() self.rq.get_standings(TestRequestHandler.VALID_LEAGUE_CODE) mock_click.assert_called_with("No standings availble for " "{league}.".format( league=TestRequestHandler.VALID_LEAGUE_CODE), fg="red", bold=True) @mock.patch('soccer.writers.Stdout.standings') @mock.patch('requests.get') def test_get_standings_ok(self, mock_request_call, mock_writer): mock_request_call.side_effect = \ [mocked_requests_get({'standing': []}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_standings(TestRequestHandler.VALID_LEAGUE_CODE) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('requests.get') def test_get_league_scores_error(self, mock_request_call, mock_click): mock_request_call.side_effect = \ APIErrorException() self.rq.get_league_scores(TestRequestHandler.VALID_LEAGUE_CODE, TestRequestHandler.VALID_TIME, False, False) mock_click.assert_called_with("No data " "for the given league.", fg="red", bold=True) @mock.patch('click.secho') @mock.patch('requests.get') def test_get_league_scores_no_fixtures(self, mock_request_call, mock_click): mock_request_call.side_effect = \ [mocked_requests_get({'fixtures': []}, 200)] self.rq.get_league_scores(TestRequestHandler.VALID_LEAGUE_CODE, TestRequestHandler.VALID_TIME, False, False) mock_click.assert_called_with("No {league} matches in " "the past week.".format( league=TestRequestHandler.VALID_LEAGUE_CODE), fg="red", bold=True) @mock.patch('soccer.writers.Stdout.league_scores') @mock.patch('requests.get') def test_get_league_scores_multiple_fixtures(self, mock_request_call, mock_writer): mock_request_call.side_effect = \ [mocked_requests_get({'fixtures': [1]}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_league_scores(TestRequestHandler.VALID_LEAGUE_CODE, TestRequestHandler.VALID_TIME, False, False) mock_writer.assert_called_once() @mock.patch('click.secho') @mock.patch('requests.get') def test_get_team_players_error(self, mock_request_call, mock_click): mock_request_call.side_effect = APIErrorException() self.rq.get_team_players(TestRequestHandler.VALID_TEAM_CODE) mock_click.assert_called_with("No data for the team. " "Please check the team code.", bold=True, fg="red") @mock.patch('click.secho') @mock.patch('requests.get') def test_get_team_players_no_players(self, mock_request_call, mock_click): mock_request_call.side_effect = \ [mocked_requests_get({'count': "0"}, 200)] self.rq.get_team_players(TestRequestHandler.VALID_TEAM_CODE) mock_click.assert_called_with("No players found " "for this team", fg="red", bold=True) @mock.patch('soccer.writers.Stdout.team_players') @mock.patch('requests.get') def test_get_team_players_no_players(self, mock_request_call, mock_writer): mock_request_call.side_effect = \ [mocked_requests_get({'count': "1"}, 200)] mock_writer.return_value = mock.Mock() self.rq.get_team_players(TestRequestHandler.VALID_TEAM_CODE) mock_writer.assert_called_once()
def handleOne(self, database, validator=lambda *a, **k: True): s, addr = self.sock.accept() return RequestHandler(s, addr, database).do(validator)
def get_handler(self): return ( RequestHandler() .set_protocol("http") .set_server(self.ip_address) )
GOOGLE_DISCOVERY_URL = ( "https://accounts.google.com/.well-known/openid-configuration") # Flask app setup app = Flask(__name__) app.config['supports_credentials'] = True print("app config:", app.config) cors = CORS(app, resources={r"/api/*": { "origins": "*" }}, supports_credentials=True) app.secret_key = os.environ.get("SECRET_KEY") or os.urandom(24) unauthorized_resp = None current_quickstart_instance = Quickstart() current_handler_instance = RequestHandler(None) temp_user = None my_logger.debug("Going to initialize DB") # Naive database setup try: my_logger.debug("creating DB") init_db() except sqlite3.OperationalError: # Assume it's already been created my_logger.debug("DB already created") # OAuth 2 client setup client = WebApplicationClient(GOOGLE_CLIENT_ID)