yura/test-kivy-app
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

first commit

Browse source
This commit is contained in:
Yura 2024-09-15 15:12:16 +03:00
commit 417e54da96
5696 changed files with 900003 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

BIN
kivy_venv/lib/python3.11/site-packages/kivy/tests/test_urlrequest/__pycache__/test_urlrequest_requests.cpython-311.pyc Normal file
View file

Binary file not shown.

BIN
kivy_venv/lib/python3.11/site-packages/kivy/tests/test_urlrequest/__pycache__/test_urlrequest_urllib.cpython-311.pyc Normal file
View file

Binary file not shown.

378
kivy_venv/lib/python3.11/site-packages/kivy/tests/test_urlrequest/test_urlrequest_requests.py Normal file
View file

@ -0,0 +1,378 @@
"""
UrlRequest tests
================
"""
import threading
from base64 import b64encode
from datetime import datetime
from time import sleep
import certifi
import pytest
import responses
from kivy.network.urlrequest import UrlRequestRequests as UrlRequest
from requests.auth import HTTPBasicAuth
from responses import matchers
class UrlRequestQueue:
def __init__(self, queue):
self.queue = queue
def _on_success(self, req, *args):
self.queue.append((threading.get_ident(), "success", args))
def _on_redirect(self, req, *args):
self.queue.append((threading.get_ident(), "redirect", args))
def _on_error(self, req, *args):
self.queue.append((threading.get_ident(), "error", args))
def _on_failure(self, req, *args):
self.queue.append((threading.get_ident(), "failure", args))
def _on_progress(self, req, *args):
self.queue.append((threading.get_ident(), "progress", args))
def _on_finish(self, req, *args):
self.queue.append((threading.get_ident(), "finish", args))
class TestCallbacks:
url = "https://example.com"
def _ensure_called_from_thread(self, queue):
tid = threading.get_ident()
for item in queue:
assert item[0] == tid
def _check_queue_values(self, queue_element, status):
assert queue_element[1] == status
def wait_request_is_finished(self, kivy_clock, request, timeout=10):
start_time = datetime.now()
timed_out = False
while not request.is_finished and not timed_out:
kivy_clock.tick()
sleep(0.1)
timed_out = (datetime.now() - start_time).total_seconds() > timeout
assert request.is_finished
@responses.activate
def test_on_success(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body="{}",
status=200,
content_type="application/json",
)
req = UrlRequest(
self.url,
on_success=_queue._on_success,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 1
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "success")
@responses.activate
def test_on_success_with_finish(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body="{}",
status=200,
content_type="application/json",
)
req = UrlRequest(
self.url,
on_success=_queue._on_success,
on_finish=_queue._on_finish,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 2
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "success")
self._check_queue_values(processed_queue[1], "finish")
@responses.activate
def test_on_redirect(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body="{}",
status=301,
content_type="application/json",
)
req = UrlRequest(
self.url,
on_redirect=_queue._on_redirect,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 1
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "redirect")
@responses.activate
def test_on_redirect_with_finish(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body="{}",
status=301,
content_type="application/json",
)
req = UrlRequest(
self.url,
on_redirect=_queue._on_redirect,
on_finish=_queue._on_finish,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 2
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "redirect")
self._check_queue_values(processed_queue[1], "finish")
@responses.activate
def test_on_error(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body=Exception("..."),
status=400,
content_type="application/json",
)
req = UrlRequest(
self.url,
on_error=_queue._on_error,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 1
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "error")
@responses.activate
def test_on_error_with_finis(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body=Exception("..."),
status=400,
content_type="application/json",
)
req = UrlRequest(
self.url,
on_error=_queue._on_error,
on_finish=_queue._on_finish,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 2
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "error")
self._check_queue_values(processed_queue[1], "finish")
@responses.activate
def test_on_failure(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body="{}",
status=400,
content_type="application/json",
)
req = UrlRequest(
self.url,
on_failure=_queue._on_failure,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 1
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "failure")
@responses.activate
def test_on_failure_with_finish(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body="{}",
status=400,
content_type="application/json",
)
req = UrlRequest(
self.url,
on_failure=_queue._on_failure,
on_finish=_queue._on_finish,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 2
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "failure")
self._check_queue_values(processed_queue[1], "finish")
@responses.activate
def test_on_progress(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body="x" * 100,
status=200,
content_type="text/plain",
auto_calculate_content_length=True
)
req = UrlRequest(
self.url,
on_progress=_queue._on_progress,
chunk_size=70,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 4
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "progress")
self._check_queue_values(processed_queue[1], "progress")
self._check_queue_values(processed_queue[2], "progress")
self._check_queue_values(processed_queue[3], "progress")
@responses.activate
def test_on_progress_with_finish(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body="x" * 100,
status=200,
content_type="text/plain",
auto_calculate_content_length=True
)
req = UrlRequest(
self.url,
on_progress=_queue._on_progress,
on_finish=_queue._on_finish,
chunk_size=70,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 5
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "progress")
self._check_queue_values(processed_queue[1], "progress")
self._check_queue_values(processed_queue[2], "progress")
self._check_queue_values(processed_queue[3], "progress")
self._check_queue_values(processed_queue[4], "finish")
@responses.activate
def test_on_finish(self, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
self.url,
body="{}",
status=400,
content_type="application/json",
)
req = UrlRequest(
self.url,
on_finish=_queue._on_finish,
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 1
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "finish")
@responses.activate
def test_auth_header(self, kivy_clock):
_queue = UrlRequestQueue([])
head = {
"Authorization": "Basic {}".format(
b64encode(b"exampleuser:examplepassword").decode("utf-8")
)
}
responses.get(
self.url,
body="{}",
status=400,
content_type="application/json",
match=[matchers.header_matcher(head)],
)
req = UrlRequest(
self.url,
req_headers=head,
on_finish=_queue._on_finish,
debug=True,
auth=HTTPBasicAuth("exampleuser", "examplepassword")
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 1
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "finish")
@pytest.mark.parametrize("scheme", ("http", "https"))
@responses.activate
def test_ca_file(self, scheme, kivy_clock):
_queue = UrlRequestQueue([])
responses.get(
f"{scheme}://example.com",
body="{}",
status=400,
content_type="application/json",
)
req = UrlRequest(
f"{scheme}://example.com",
on_finish=_queue._on_finish,
ca_file=certifi.where(),
debug=True,
)
self.wait_request_is_finished(kivy_clock, req)
processed_queue = _queue.queue
assert len(processed_queue) == 1
self._ensure_called_from_thread(processed_queue)
self._check_queue_values(processed_queue[0], "finish")

155
kivy_venv/lib/python3.11/site-packages/kivy/tests/test_urlrequest/test_urlrequest_urllib.py Normal file
View file

@ -0,0 +1,155 @@
'''
UrlRequest tests
================
'''
import os
import threading
from base64 import b64encode
from datetime import datetime
from time import sleep
import pytest
from kivy.network.urlrequest import UrlRequestUrllib as UrlRequest
def wait_request_is_finished(kivy_clock, request, timeout=10):
start_time = datetime.now()
timed_out = False
while not request.is_finished and not timed_out:
kivy_clock.tick()
sleep(.1)
timed_out = (datetime.now() - start_time).total_seconds() > timeout
assert request.is_finished
def ensure_called_from_thread(queue):
"""Ensures the callback is called from this thread (main)."""
tid = threading.get_ident()
assert queue[0][0] == tid
assert queue[-2][0] == tid
assert queue[-1][0] == tid
def check_queue_values(queue):
"""Helper function verifying the queue contains the expected values."""
# we should have 2 progress minimum and one success
assert len(queue) >= 3
assert queue[0][1] == 'progress'
assert queue[-2][1] == 'progress'
assert queue[-1][1] in ('success', 'redirect')
assert queue[0][2][0] == 0
assert queue[-2][2][0] == queue[-2][2][1]
class UrlRequestQueue:
def __init__(self, queue):
self.queue = queue
def _on_success(self, req, *args):
self.queue.append((threading.get_ident(), 'success', args))
def _on_redirect(self, req, *args):
self.queue.append((threading.get_ident(), 'redirect', args))
def _on_error(self, req, *args):
self.queue.append((threading.get_ident(), 'error', args))
def _on_progress(self, req, *args):
self.queue.append((threading.get_ident(), 'progress', args))
@pytest.mark.skipif(os.environ.get('NONETWORK'), reason="No network")
def test_callbacks(kivy_clock):
obj = UrlRequestQueue([])
queue = obj.queue
req = UrlRequest('http://google.com',
on_success=obj._on_success,
on_progress=obj._on_progress,
on_error=obj._on_error,
on_redirect=obj._on_redirect,
debug=True)
wait_request_is_finished(kivy_clock, req)
if req.error and req.error.errno == 11001:
pytest.skip('Cannot connect to get address')
ensure_called_from_thread(queue)
check_queue_values(queue)
@pytest.mark.skipif(os.environ.get('NONETWORK'), reason="No network")
def test_auth_header(kivy_clock):
obj = UrlRequestQueue([])
queue = obj.queue
head = {
"Authorization": "Basic {}".format(b64encode(
"{}:{}".format('user', 'passwd').encode('utf-8')
).decode('utf-8'))
}
req = UrlRequest(
'http://httpbin.org/basic-auth/user/passwd',
on_success=obj._on_success,
on_progress=obj._on_progress,
on_error=obj._on_error,
on_redirect=obj._on_redirect,
req_headers=head,
debug=True
)
wait_request_is_finished(kivy_clock, req, timeout=60)
if req.error and req.error.errno == 11001:
pytest.skip('Cannot connect to get address')
ensure_called_from_thread(queue)
check_queue_values(queue)
assert queue[-1][2] == ({'authenticated': True, 'user': 'user'}, )
@pytest.mark.skipif(os.environ.get('NONETWORK'), reason="No network")
def test_auth_auto(kivy_clock):
obj = UrlRequestQueue([])
queue = obj.queue
req = UrlRequest(
'http://user:passwd@httpbin.org/basic-auth/user/passwd',
on_success=obj._on_success,
on_progress=obj._on_progress,
on_error=obj._on_error,
on_redirect=obj._on_redirect,
debug=True
)
wait_request_is_finished(kivy_clock, req, timeout=60)
if req.error and req.error.errno == 11001:
pytest.skip('Cannot connect to get address')
ensure_called_from_thread(queue)
check_queue_values(queue)
assert queue[-1][2] == ({'authenticated': True, 'user': 'user'}, )
@pytest.mark.skipif(os.environ.get('nonetwork'), reason="no network")
@pytest.mark.parametrize("scheme", ("http", "https"))
def test_ca_file(kivy_clock, scheme):
"""Passing a `ca_file` should not crash on http scheme, refs #6946"""
import certifi
obj = UrlRequestQueue([])
queue = obj.queue
req = UrlRequest(
f"{scheme}://httpbin.org/get",
on_success=obj._on_success,
on_progress=obj._on_progress,
on_error=obj._on_error,
on_redirect=obj._on_redirect,
ca_file=certifi.where(),
debug=True
)
wait_request_is_finished(kivy_clock, req, timeout=60)
if req.error and req.error.errno == 11001:
pytest.skip('Cannot connect to get address')
ensure_called_from_thread(queue)
check_queue_values(queue)