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)
# -*- coding: utf-8 -*-
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)
