async def test_simple_streaming_with_chunk_timeout(self):
app = Vibora(server_limits=ServerLimits(write_buffer=1))
async def stream():
for _ in range(0, 5):
await asyncio.sleep(0)
yield b'1' * 1024 * 1024 * 100
@app.route('/')
async def home():
return StreamingResponse(stream,
chunk_timeout=3,
complete_timeout=999)
with app.test_client() as client:
response = await client.get('/', stream=True)
try:
first = True
chunk_size = 1 * 1024 * 1024
async for chunk in response.stream(chunk_size=chunk_size):
if first:
await asyncio.sleep(5)
first = False
self.assertTrue(len(chunk) <= chunk_size)
self.fail(
'Vibora should have closed the connection because of a chunk timeout.'
)
except asyncio.IncompleteReadError:
pass
async def test_files_upload_expects_correctly_parsed(self):
app = Vibora()
@app.route("/", methods=["POST"])
async def home(request: Request):
form = await request.form()
return JsonResponse(
{
"a": (await form["a"].read()).decode(),
"b": (await form["b"].read()).decode(),
"c": (await form["c"].read()).decode(),
"d": form["d"],
}
)
async with app.test_client() as client:
response = await client.post(
"/",
form={
"a": FileUpload(content=b"a"),
"b": FileUpload(content=b"b"),
"c": FileUpload(content=b"c"),
"d": 1,
},
)
self.assertEqual(response.status_code, 200)
self.assertDictEqual(response.json(), {"a": "a", "b": "b", "c": "c", "d": "1"})
async def test_files_upload_expects_correctly_parsed(self):
app = Vibora()
@app.route('/', methods=['POST'])
async def home(request: Request):
form = await request.form()
return JsonResponse({
'a': await form['a'].read(),
'b': await form['b'].read(),
'c': await form['c'].read(),
'd': form['d'],
})
with app.test_client() as client:
response = await client.post(
'/',
form={
'a': FileUpload(content=b'a'),
'b': FileUpload(content=b'b'),
'c': FileUpload(content=b'c'),
'd': 1,
},
)
self.assertEqual(response.status_code, 200)
self.assertDictEqual(response.json(), {
'a': 'a',
'b': 'b',
'c': 'c',
'd': '1'
})
class ViboraExtensionSuiteCase(TestSuite):
def setUp(self):
self.app = Vibora()
@self.app.route('/')
async def home():
return Response(b'')
self.app.initialize(debug=True)
async def test_url_for_inside_for_node(self):
template = Template(
'{% for x in range(0, 10)%}{% url "home" %}{% endfor %}')
self.app.template_engine.add_template(template, ['test'])
self.app.template_engine.compile_templates()
self.assertEqual(
self.app.url_for('home') * 10, await
self.app.template_engine.render('test'))
async def test_static_node(self):
template = Template("{% static 'js/app.js' %}")
self.app.template_engine.add_template(template, ['test'])
self.app.template_engine.compile_templates()
self.assertEqual('/static/js/app.js', await
self.app.template_engine.render('test'))
async def test_custom_cache_engine_skipping_hooks(self):
class AsyncEngine(CacheEngine):
def get(self, request: Request):
return self.cache.get(request.url)
def store(self, request: Request, response):
self.cache[request.url] = response
app = Vibora()
manager = Manager()
calls = manager.list()
def before_end():
calls.append('called_before_endpoint')
app.add_hook(Hook(Events.BEFORE_ENDPOINT, before_end))
@app.route('/', cache=AsyncEngine(skip_hooks=True))
async def home():
return JsonResponse({'now': time.time()})
client = app.test_client()
response1 = await client.get('/')
response2 = await client.get('/')
self.assertEqual(len(calls), 1)
self.assertEqual(response1.content, response2.content)
client.close()
def setUp(self):
self.data = b'1' * (10 * 1024) + b'2' * 1024
self.server = Vibora()
@self.server.route('/')
async def home():
return Response(self.data)
class ChunkedStreamingTestCase(TestSuite):
def setUp(self):
def generate_data():
yield b'1' * (10 * 1024)
yield b'2' * 1024
self.data = b''.join(generate_data())
self.server = Vibora()
@self.server.route('/')
async def home():
return StreamingResponse(generate_data)
async def test_streaming_client_reading_content__expects_successful(self):
async with self.server.test_client() as client:
response = await client.get('/', stream=True)
await response.read_content()
self.assertEqual(response.content, self.data)
async def test_streaming_client_reading_stream__expects_successful(self):
async with self.server.test_client() as client:
response = await client.get('/', stream=True)
received_data = bytearray()
async for chunk in response.stream():
received_data.extend(chunk)
self.assertEqual(received_data, self.data)
async def test_streaming_client_very_small_reads__expects_successful(self):
client = self.server.test_client()
response = await client.get('/', stream=True)
received_data = bytearray()
async for chunk in response.stream(chunk_size=1):
self.assertTrue(len(chunk) == 1)
received_data.extend(chunk)
self.assertEqual(received_data, self.data)
async def test_files_attribute_expects_correctly_parsed(self):
app = Vibora()
@app.route('/', methods=['POST'])
async def home(request: Request):
uploaded_files = {}
for file in await request.files():
uploaded_files[file.filename] = await file.read()
return JsonResponse(uploaded_files)
with app.test_client() as client:
response = await client.post(
'/',
form={
'a': FileUpload(content=b'a', name='a'),
'b': FileUpload(content=b'b', name='b'),
'c': FileUpload(content=b'c', name='c'),
'd': 1,
},
)
self.assertEqual(response.status_code, 200)
self.assertDictEqual(response.json(), {
'a': 'a',
'b': 'b',
'c': 'c'
})
async def create_app():
_app = Vibora()
yield _app
_app.clean_up()
def setUp(self):
self.app = Vibora()
@self.app.route('/')
async def home():
return Response(b'')
self.app.initialize()
def setUp(self):
self.app = Vibora()
@self.app.route("/123")
async def home():
return Response(b"")
self.app.initialize()
def create_app():
app = Vibora(router_strategy=RouterStrategy.CLONE)
# app.configure_static_files()
app.add_blueprint(bp_api)
app.logger = logger
job_queue = Queue(connection=StrictRedis.from_url(app_config.redis_conn))
app.components.add(job_queue)
return app
async def test_headers_bigger_than_expected_expects_rejected_request(self):
app = Vibora(server_limits=ServerLimits(max_headers_size=1))
@app.route('/', methods=['GET'])
async def home():
return Response(b'Wrong. Request should halted earlier.')
with app.test_client() as client:
response = await client.get('/')
self.assertEqual(response.status_code, 400)
async def test_simple_post__expects_correctly_interpreted():
app = Vibora()
@app.route("/", methods=["POST"])
async def home(request: Request):
return JsonResponse((await request.form()))
async with app.test_client() as client:
response = await client.post("/", form={"a": 1, "b": 2})
assert response.json() == {"a": "1", "b": "2"}
async def test_simple_case_expects_timeout_response(self):
app = Vibora()
@app.route("/", limits=RouteLimits(timeout=2))
async def home():
await asyncio.sleep(10)
return Response(b"Wrong. This request should timeout.")
async with app.test_client() as client:
response = await client.get("/", timeout=4)
self.assertEqual(response.status_code, 500)
async def static_server():
data = b"123"
app = Vibora()
@app.route("/")
async def home():
return Response(data)
yield app, data
app.clean_up()
def setUp(self):
def generate_data():
yield b'1' * (10 * 1024)
yield b'2' * 1024
self.data = b''.join(generate_data())
self.server = Vibora()
@self.server.route('/')
async def home():
return StreamingResponse(generate_data)
async def test_prefix_with_dynamic_route(self):
app = Vibora()
bp = Blueprint()
@bp.route("/<name>")
async def home(name: str):
return JsonResponse({"name": name})
app.add_blueprint(bp, prefixes={"test": "/test"})
response = await app.test_client().request("/test/test")
self.assertEqual(response.json(), {"name": "test"})
async def test_file_upload_with_another_values(self):
app = Vibora()
@app.route('/', methods=['POST'])
async def home(request: Request):
form = (await request.form())
return JsonResponse({'a': form['a'], 'b': await form['b'].read()})
with app.test_client() as client:
response = await client.post('/', form={'a': 1, 'b': FileUpload(content=b'uploaded_file')})
self.assertDictEqual(response.json(), {'a': '1', 'b': 'uploaded_file'})
async def test_body_smaller_than_limit_expects_200(self):
app = Vibora(route_limits=RouteLimits(max_body_size=2))
@app.route('/', methods=['POST'])
async def home(request: Request):
await request.stream.read()
return Response(b'Correct. Request should not be blocked.')
with app.test_client() as client:
response = await client.post('/', body=b'1')
self.assertEqual(response.status_code, 200)
async def test_custom_body_limit_per_route_expects_successful(self):
app = Vibora(route_limits=RouteLimits(max_body_size=1))
@app.route('/', methods=['POST'], limits=RouteLimits(max_body_size=2))
async def home(request: Request):
await request.stream.read()
return Response(b'Correct. Request should pass without problems.')
with app.test_client() as client:
response = await client.post('/', body=b'11')
self.assertEqual(response.status_code, 200)
async def test_simple_post__expects_correctly_interpreted(self):
app = Vibora()
@app.route('/', methods=['POST'])
async def home(request: Request):
return JsonResponse((await request.form()))
async with app.test_client() as client:
response = await client.post('/', form={'a': 1, 'b': 2})
self.assertDictEqual(response.json(), {'a': '1', 'b': '2'})
async def test_headers_smaller_than_limit_expects_200(self):
app = Vibora(server_limits=ServerLimits(max_headers_size=1 * 1024 *
1024))
@app.route('/', methods=['GET'])
async def home():
return Response(b'Correct. Request should pass without problems.')
with app.test_client() as client:
response = await client.get('/')
self.assertEqual(response.status_code, 200)
async def test_body_bigger_than_expected_expects_rejected(self):
app = Vibora(route_limits=RouteLimits(max_body_size=1))
@app.route('/', methods=['POST'])
async def home(request: Request):
await request.stream.read()
return Response(b'Wrong. Request should halted earlier.')
with app.test_client() as client:
response = await client.post('/', body=b'12')
self.assertEqual(response.status_code, 413)
async def test_extra_headers__expects_correctly_evaluated(self):
app = Vibora()
@app.route('/')
async def get_headers(request: Request):
return JsonResponse(request.headers.dump())
client = app.test_client()
token = str(uuid.uuid4())
response = await client.get('/', headers={'x-access-token': token})
response = json.loads(response.content)
self.assertEqual(response.get('x-access-token'), token)
class UrlForTestSuite(TestSuite):
def setUp(self):
self.app = Vibora()
@self.app.route('/123')
async def home():
return Response(b'')
self.app.initialize(debug=True)
def test_hello_world_situation(self):
self.assertEqual(self.app.url_for('home'), '/123/')
class UrlForTestSuite(TestSuite):
def setUp(self):
self.app = Vibora()
@self.app.route("/123")
async def home():
return Response(b"")
self.app.initialize()
def test_hello_world_situation(self):
self.assertEqual(self.app.url_for("home"), "/123/")
async def test_simple_form_expects_correctly_parsed(self):
app = Vibora()
@app.route("/", methods=["POST"])
async def home(request: Request):
form = await request.form()
return JsonResponse(form)
async with app.test_client() as client:
response = await client.post("/", form={"a": 1, "b": 2})
self.assertEqual(response.status_code, 200)
self.assertDictEqual(response.json(), {"a": "1", "b": "2"})
def create_app(config_name):
app = Vibora()
@app.handle(Events.AFTER_ENDPOINT)
async def before_response(response: Response):
response.headers['x-my-custom-header'] = 'Hello :)'
app.components.add(config[config_name]())
app.add_blueprint(api, prefixes={'v1': '/v1'})
return app
async def test_simple_form_expects_correctly_parsed(self):
app = Vibora()
@app.route('/', methods=['POST'])
async def home(request: Request):
form = await request.form()
return JsonResponse(form)
with app.test_client() as client:
response = await client.post('/', form={'a': 1, 'b': 2})
self.assertEqual(response.status_code, 200)
self.assertDictEqual(response.json(), {'a': '1', 'b': '2'})
from vibora import Vibora
from vibora.request import Request
from vibora.responses import JsonResponse, Response
from vibora.hooks import Events
from random import randint
from operator import itemgetter
import psycopg2
READ_ROW_SQL = 'SELECT * FROM "world" WHERE id={0}'
WRITE_ROW_SQL = 'UPDATE "world" SET "randomnumber"={0} WHERE id={1} RETURNING id, randomNumber'
READ_ALL_FORTUNES = 'SELECT * FROM "fortune"'
ADDITIONAL_ROW = [0, 'Additional fortune added at request time.']
sort_fortunes_key = itemgetter(1)
app = Vibora()
con = psycopg2.connect("dbname=hello_world user=benchmarkdbuser host=tfb-database password=benchmarkdbpass")
cur = con.cursor()
def getQueriesTotal(params):
try:
queries = params['queries']
query_count = int(queries)
except:
return 1
if query_count < 1:
return 1
if query_count > 500:
return 500
return query_count
"""
Sometimes you want to expose Prometheus metrics from within an existing web
service and don't want to start a separate Prometheus metrics server.
This example uses the aioprometheus package to add Prometheus instrumentation
to a Vibora application. In this example a registry and a counter metric is
instantiated. A '/metrics' route is added to the application and the render
function from aioprometheus is called to format the metrics into the
appropriate format.
"""
from aioprometheus import render, Counter, Registry
from vibora import Vibora, Request, Response
app = Vibora(__name__)
app.registry = Registry()
app.events_counter = Counter("events", "Number of events.")
app.registry.register(app.events_counter)
@app.route("/")
async def hello(request: Request):
app.events_counter.inc({"path": "/"})
return Response(b"hello")
@app.route("/metrics")
async def handle_metrics(request: Request):
"""
Negotiate a response format by inspecting the ACCEPTS headers and selecting
async def test_render_in_vibora_app(self):
""" check render usage in Vibora app """
app = Vibora(__name__)
app.registry = aioprometheus.Registry()
app.events_counter = aioprometheus.Counter("events", "Number of events.")
app.registry.register(app.events_counter)
@app.route("/")
async def index(request: Request):
app.events_counter.inc({"path": "/"})
return Response(b"hello")
@app.route("/metrics")
async def handle_metrics(request: Request):
"""
Negotiate a response format by inspecting the ACCEPTS headers and selecting
the most efficient format. Render metrics in the registry into the chosen
format and return a response.
"""
content, http_headers = aioprometheus.render(
app.registry, [request.headers.get("accept")]
)
return Response(content, headers=http_headers)
# NOTE: Vibora client.get HTTP headers handling seem to expect case-sensitive.
# Must use Accept and not accept or ACCEPT! Where as response handling of
# requests doesn't seem to care.
# Until Vibora #139 is resolved we must use "Accept".
# The test client also starts the web service
client = app.test_client()
# Access root to increment metric counter
response = await client.get("/")
self.assertEqual(response.status_code, 200)
# Get default format
response = await client.get("/metrics", headers={"Accept": "*/*"})
self.assertEqual(response.status_code, 200)
self.assertIn(
aioprometheus.formats.TEXT_CONTENT_TYPE,
[response.headers.get("Content-Type")],
)
# Get text format
response = await client.get("/metrics", headers={"Accept": "text/plain;"})
self.assertEqual(response.status_code, 200)
self.assertIn(
aioprometheus.formats.TEXT_CONTENT_TYPE,
[response.headers.get("content-type")],
)
# # Get binary format
response = await client.get(
"/metrics", headers={"Accept": aioprometheus.formats.BINARY_CONTENT_TYPE}
)
self.assertEqual(response.status_code, 200)
self.assertIn(
aioprometheus.formats.BINARY_CONTENT_TYPE,
[response.headers.get("content-type")],
)
