Kivy-examples 2.3.1.dev0__py3-none-any.whl

kivy/tests/test_uix_videoplayer.py

@@ -0,0 +1,112 @@
+import pytest
+
+from kivy.tests import async_run, UnitKivyApp, GraphicUnitTest
+from unittest.mock import patch
+
+
+def videoplayer_app():
+    from kivy.app import App
+    from kivy.uix.videoplayer import VideoPlayer
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            root = VideoPlayer()
+            return root
+
+    return TestApp()
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_default_thumbnail(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_thumbnail"
+    ) as mock__load_thumbnail, patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations, patch(
+        "kivy.uix.videoplayer.exists"
+    ) as mock_exists:
+        mock_exists.return_value = True
+        kivy_app.root.source = "data/video.mp4"
+        await kivy_app.wait_clock_frames(2)
+        mock__load_thumbnail.assert_called_once_with("data/video.png")
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_default_annotation(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations, patch(
+        "kivy.uix.videoplayer.exists"
+    ) as mock_exists:
+        mock_exists.return_value = True
+        kivy_app.root.source = "data/video.mp4"
+        await kivy_app.wait_clock_frames(2)
+        mock__load_annotations.assert_called_once_with("data/video.jsa")
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_custom_thumbnail(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_thumbnail"
+    ) as mock__load_thumbnail, patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations, patch(
+        "kivy.uix.videoplayer.exists"
+    ) as mock_exists:
+        mock_exists.return_value = True
+        kivy_app.root.source = "data/video.mp4"
+        kivy_app.root.thumbnail = "data/custom.jpg"
+        await kivy_app.wait_clock_frames(2)
+        mock__load_thumbnail.assert_called_once_with("data/custom.jpg")
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_custom_annotation(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations, patch(
+        "kivy.uix.videoplayer.exists"
+    ) as mock_exists:
+        mock_exists.return_value = True
+        kivy_app.root.source = "data/video.mp4"
+        kivy_app.root.annotations = "data/custom.jsa"
+        await kivy_app.wait_clock_frames(2)
+        mock__load_annotations.assert_called_once_with("data/custom.jsa")
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_custom_thumbnail_reset(
+    kivy_app,
+):
+    kivy_app.root.thumbnail = "data/custom.jpg"
+    assert len(kivy_app.root.container.children) != 0
+
+    kivy_app.root.thumbnail = ""
+    assert len(kivy_app.root.container.children) == 0
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_custom_annotations_reset_no_fail(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations:
+        kivy_app.root.annotations = "data/annotations.jsa"
+
+    kivy_app.root.annotations = ""
+
+if __name__ == "__main__":
+    pytest.main(
+        args=[
+            __file__,
+        ]
+    )

kivy/tests/test_uix_widget.py

@@ -0,0 +1,137 @@
+from kivy.tests.common import GraphicUnitTest
+
+
+class UIXWidgetTestCase(GraphicUnitTest):
+
+    def test_default_widgets(self):
+        from kivy.uix.button import Button
+        from kivy.uix.slider import Slider
+        r = self.render
+        r(Button())
+        r(Slider())
+
+    def test_button_properties(self):
+        from kivy.uix.button import Button
+        r = self.render
+        # test label attribute inside button
+        r(Button(text='Hello world'))
+        r(Button(text='Multiline\ntext\nbutton'))
+        r(Button(text='Hello world', font_size=42))
+        r(Button(text='This is my first line\nSecond line', halign='center'))
+
+    def test_slider_properties(self):
+        from kivy.uix.slider import Slider
+        r = self.render
+        r(Slider(value=25))
+        r(Slider(value=50))
+        r(Slider(value=100))
+        r(Slider(min=-100, max=100, value=0))
+        r(Slider(orientation='vertical', value=25))
+        r(Slider(orientation='vertical', value=50))
+        r(Slider(orientation='vertical', value=100))
+        r(Slider(orientation='vertical', min=-100, max=100, value=0))
+
+    def test_image_properties(self):
+        from kivy.uix.image import Image
+        from os.path import dirname, join
+        r = self.render
+        filename = join(dirname(__file__), 'test_button.png')
+        r(Image(source=filename))
+
+    def test_add_widget_index_0(self):
+        from kivy.uix.widget import Widget
+        from kivy.uix.button import Button
+        r = self.render
+        root = Widget()
+        a = Button(text='Hello')
+        b = Button(text='World', pos=(50, 10))
+        c = Button(text='Kivy', pos=(10, 50))
+        root.add_widget(a)
+        root.add_widget(b)
+        root.add_widget(c, 0)
+        r(root)
+
+    def test_add_widget_index_1(self):
+        from kivy.uix.widget import Widget
+        from kivy.uix.button import Button
+        r = self.render
+        root = Widget()
+        a = Button(text='Hello')
+        b = Button(text='World', pos=(50, 10))
+        c = Button(text='Kivy', pos=(10, 50))
+        root.add_widget(a)
+        root.add_widget(b)
+        root.add_widget(c, 1)
+        r(root)
+
+    def test_add_widget_index_2(self):
+        from kivy.uix.widget import Widget
+        from kivy.uix.button import Button
+        r = self.render
+        root = Widget()
+        a = Button(text='Hello')
+        b = Button(text='World', pos=(50, 10))
+        c = Button(text='Kivy', pos=(10, 50))
+        root.add_widget(a)
+        root.add_widget(b)
+        root.add_widget(c, 2)
+        r(root)
+
+    def test_widget_root_from_code_with_kv(self):
+        from kivy.lang import Builder
+        from kivy.factory import Factory
+        from kivy.properties import StringProperty
+        from kivy.uix.floatlayout import FloatLayout
+
+        Builder.load_string("""
+<UIXWidget>:
+    Label:
+        text: root.title
+
+<BaseWidget>:
+    CallerWidget:
+""")
+
+        class CallerWidget(FloatLayout):
+
+            def __init__(self, **kwargs):
+                super(CallerWidget, self).__init__(**kwargs)
+                self.add_widget(UIXWidget(title="Hello World"))
+
+        class NestedWidget(FloatLayout):
+            title = StringProperty('aa')
+
+        class UIXWidget(NestedWidget):
+            pass
+
+        class BaseWidget(FloatLayout):
+            pass
+
+        Factory.register('UIXWidget', cls=UIXWidget)
+        Factory.register('CallerWidget', cls=CallerWidget)
+
+        r = self.render
+        root = BaseWidget()
+        r(root)
+
+    '''
+    def test_default_label(self):
+        from kivy.uix.label import Label
+        self.render(Label())
+
+    def test_button_state_down(self):
+        from kivy.uix.button import Button
+        self.render(Button(state='down'))
+
+    def test_label_text(self):
+        from kivy.uix.label import Label
+        self.render(Label(text='Hello world'))
+
+    def test_label_font_size(self):
+        from kivy.uix.label import Label
+        self.render(Label(text='Hello world', font_size=16))
+
+    def test_label_font_size(self):
+        from kivy.uix.label import Label
+        self.render(Label(text='Hello world'))
+    '''

kivy/tests/test_urlrequest/test_urlrequest_requests.py

@@ -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")