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

kivy/tests/common.py

@@ -0,0 +1,524 @@
+'''
+This is a extended unittest module for Kivy, to make unittests based on
+graphics with an OpenGL context.
+
+The idea is to render a Widget tree, and after 1, 2 or more frames, a
+screenshot will be made and be compared to the original one.
+If no screenshot exists for the current test, the very first one will be used.
+
+The screenshots live in the 'kivy/tests/results' folder and are in PNG format,
+320x240 pixels.
+'''
+
+__all__ = (
+    'GraphicUnitTest', 'UnitTestTouch', 'UTMotionEvent', 'async_run',
+    'requires_graphics', 'ensure_web_server')
+
+import unittest
+import logging
+import pytest
+import sys
+from functools import partial
+import os
+import threading
+from kivy.graphics.cgl import cgl_get_backend_name
+from kivy.input.motionevent import MotionEvent
+log = logging.getLogger('unittest')
+
+
+_base = object
+if 'mock' != cgl_get_backend_name():
+    # check what the gl backend might be, we can't know for sure
+    # what it'll be until actually initialized by the window.
+    _base = unittest.TestCase
+
+make_screenshots = os.environ.get('KIVY_UNITTEST_SCREENSHOTS')
+http_server = None
+http_server_ready = threading.Event()
+kivy_eventloop = os.environ.get('KIVY_EVENTLOOP', 'asyncio')
+
+
+def requires_graphics(func):
+    if 'mock' == cgl_get_backend_name():
+        return pytest.mark.skip(
+            reason='Skipping because gl backend is set to mock')(func)
+    return func
+
+
+def ensure_web_server(root=None):
+    if http_server is not None:
+        return True
+
+    if not root:
+        root = os.path.join(os.path.dirname(__file__), "..", "..")
+    need_chdir = sys.version_info.major == 3 and sys.version_info.minor <= 6
+    curr_dir = os.getcwd()
+
+    def _start_web_server():
+        global http_server
+        from http.server import SimpleHTTPRequestHandler
+        from socketserver import TCPServer
+
+        try:
+            if need_chdir:
+                os.chdir(root)
+                handler = SimpleHTTPRequestHandler
+            else:
+                handler = partial(SimpleHTTPRequestHandler, directory=root)
+
+            http_server = TCPServer(
+                ("", 8000), handler, bind_and_activate=False)
+            http_server.daemon_threads = True
+            http_server.allow_reuse_address = True
+            http_server.server_bind()
+            http_server.server_activate()
+            http_server_ready.set()
+            http_server.serve_forever()
+        except:
+            import traceback
+            traceback.print_exc()
+        finally:
+            http_server = None
+            http_server_ready.set()
+
+            if need_chdir:
+                os.chdir(curr_dir)
+
+    th = threading.Thread(target=_start_web_server)
+    th.daemon = True
+    th.start()
+    http_server_ready.wait()
+    if http_server is None:
+        raise Exception("Unable to start webserver")
+
+
+class GraphicUnitTest(_base):
+    framecount = 0
+
+    def _force_refresh(self, *largs):
+        # this prevent in some case to be stuck if the screen doesn't refresh
+        # and we wait for a number of self.framecount that never goes down
+        from kivy.base import EventLoop
+        win = EventLoop.window
+        if win and win.canvas:
+            win.canvas.ask_update()
+
+    def render(self, root, framecount=1):
+        '''Call rendering process using the `root` widget.
+        The screenshot will be done in `framecount` frames.
+        '''
+        from kivy.base import runTouchApp
+        from kivy.clock import Clock
+        self.framecount = framecount
+        try:
+            Clock.schedule_interval(self._force_refresh, 1)
+            runTouchApp(root)
+        finally:
+            Clock.unschedule(self._force_refresh)
+
+        # reset for the next test, but nobody will know if it will be used :/
+        if self.test_counter != 0:
+            self.tearDown(fake=True)
+            self.setUp()
+
+    def run(self, *args, **kwargs):
+        '''Extend the run of unittest, to check if results directory have been
+        found. If no results directory exists, the test will be ignored.
+        '''
+        from os.path import join, dirname, exists
+        results_dir = join(dirname(__file__), 'results')
+        if make_screenshots and not exists(results_dir):
+            log.warning('No result directory found, cancel test.')
+            os.mkdir(results_dir)
+        self.test_counter = 0
+        self.results_dir = results_dir
+        self.test_failed = False
+        return super(GraphicUnitTest, self).run(*args, **kwargs)
+
+    def setUp(self):
+        '''Prepare the graphic test, with:
+            - Window size fixed to 320x240
+            - Default kivy configuration
+            - Without any kivy input
+        '''
+
+        # use default kivy configuration (don't load user file.)
+        from os import environ
+        environ['KIVY_USE_DEFAULTCONFIG'] = '1'
+
+        # force window size + remove all inputs
+        from kivy.config import Config
+        Config.set('graphics', 'width', '320')
+        Config.set('graphics', 'height', '240')
+        for items in Config.items('input'):
+            Config.remove_option('input', items[0])
+
+        # bind ourself for the later screenshot
+        from kivy.core.window import Window
+        self.Window = Window
+        Window.bind(on_flip=self.on_window_flip)
+
+        # ensure our window is correctly created
+        Window.create_window()
+        Window.register()
+        Window.initialized = True
+        Window.close = lambda *s: None
+        self.clear_window_and_event_loop()
+
+    def clear_window_and_event_loop(self):
+        from kivy.base import EventLoop
+        window = self.Window
+        for child in window.children[:]:
+            window.remove_widget(child)
+        window.canvas.before.clear()
+        window.canvas.clear()
+        window.canvas.after.clear()
+        EventLoop.touches.clear()
+        for post_proc in EventLoop.postproc_modules:
+            if hasattr(post_proc, 'touches'):
+                post_proc.touches.clear()
+            elif hasattr(post_proc, 'last_touches'):
+                post_proc.last_touches.clear()
+
+    def on_window_flip(self, window):
+        '''Internal method to be called when the window have just displayed an
+        image.
+        When an image is showed, we decrement our framecount. If framecount is
+        come to 0, we are taking the screenshot.
+
+        The screenshot is done in a temporary place, and is compared to the
+        original one -> test ok/ko.
+        If no screenshot is available in the results directory, a new one will
+        be created.
+        '''
+        from kivy.base import EventLoop
+        from tempfile import mkstemp
+        from os.path import join, exists
+        from os import unlink, close
+        from shutil import move, copy
+
+        # don't save screenshot until we have enough frames.
+        # log.debug('framecount %d' % self.framecount)
+        # ! check if there is 'framecount', otherwise just
+        # ! assume zero e.g. if handling runTouchApp manually
+        self.framecount = getattr(self, 'framecount', 0) - 1
+        if self.framecount > 0:
+            return
+
+        # don't create screenshots if not requested manually
+        if not make_screenshots:
+            EventLoop.stop()
+            return
+
+        reffn = None
+        match = False
+        try:
+            # just get a temporary name
+            fd, tmpfn = mkstemp(suffix='.png', prefix='kivyunit-')
+            close(fd)
+            unlink(tmpfn)
+
+            # get a filename for the current unit test
+            self.test_counter += 1
+            test_uid = '%s-%d.png' % (
+                '_'.join(self.id().split('.')[-2:]),
+                self.test_counter)
+
+            # capture the screen
+            log.info('Capturing screenshot for %s' % test_uid)
+            tmpfn = window.screenshot(tmpfn)
+            log.info('Capture saved at %s' % tmpfn)
+
+            # search the file to compare to
+            reffn = join(self.results_dir, test_uid)
+            log.info('Compare with %s' % reffn)
+
+            # get sourcecode
+            import inspect
+            frame = inspect.getouterframes(inspect.currentframe())[6]
+            sourcecodetab, line = inspect.getsourcelines(frame[0])
+            line = frame[2] - line
+            currentline = sourcecodetab[line]
+            sourcecodetab[line] = '<span style="color: red;">%s</span>' % (
+                currentline)
+            sourcecode = ''.join(sourcecodetab)
+            sourcecodetab[line] = '>>>>>>>>\n%s<<<<<<<<\n' % currentline
+            sourcecodeask = ''.join(sourcecodetab)
+
+            if not exists(reffn):
+                log.info('No image reference, move %s as ref ?' % test_uid)
+                if self.interactive_ask_ref(sourcecodeask, tmpfn, self.id()):
+                    move(tmpfn, reffn)
+                    tmpfn = reffn
+                    log.info('Image used as reference')
+                    match = True
+                else:
+                    log.info('Image discarded')
+            else:
+                from kivy.core.image import Image as CoreImage
+                s1 = CoreImage(tmpfn, keep_data=True)
+                sd1 = s1.image._data[0].data
+                s2 = CoreImage(reffn, keep_data=True)
+                sd2 = s2.image._data[0].data
+                if sd1 != sd2:
+                    log.critical(
+                        '%s at render() #%d, images are different.' % (
+                            self.id(), self.test_counter))
+                    if self.interactive_ask_diff(sourcecodeask,
+                                                 tmpfn, reffn, self.id()):
+                        log.critical('user ask to use it as ref.')
+                        move(tmpfn, reffn)
+                        tmpfn = reffn
+                        match = True
+                    else:
+                        self.test_failed = True
+                else:
+                    match = True
+
+            # generate html
+            from os.path import join, dirname, exists, basename
+            from os import mkdir
+            build_dir = join(dirname(__file__), 'build')
+            if not exists(build_dir):
+                mkdir(build_dir)
+            copy(reffn, join(build_dir, 'ref_%s' % basename(reffn)))
+            if tmpfn != reffn:
+                copy(tmpfn, join(build_dir, 'test_%s' % basename(reffn)))
+            with open(join(build_dir, 'index.html'), 'at') as fd:
+                color = '#ffdddd' if not match else '#ffffff'
+                fd.write('<div style="background-color: %s">' % color)
+                fd.write('<h2>%s #%d</h2>' % (self.id(), self.test_counter))
+                fd.write('<table><tr><th>Reference</th>'
+                         '<th>Test</th>'
+                         '<th>Comment</th>')
+                fd.write('<tr><td><img src="ref_%s"/></td>' %
+                         basename(reffn))
+                if tmpfn != reffn:
+                    fd.write('<td><img src="test_%s"/></td>' %
+                             basename(reffn))
+                else:
+                    fd.write('<td>First time, no comparison.</td>')
+                fd.write('<td><pre>%s</pre></td>' % sourcecode)
+                fd.write('</table></div>')
+        finally:
+            try:
+                if reffn != tmpfn:
+                    unlink(tmpfn)
+            except:
+                pass
+            EventLoop.stop()
+
+    def tearDown(self, fake=False):
+        '''When the test is finished, stop the application, and unbind our
+        current flip callback.
+        '''
+        from kivy.base import stopTouchApp
+        from kivy.core.window import Window
+        Window.unbind(on_flip=self.on_window_flip)
+        self.clear_window_and_event_loop()
+        self.Window = None
+        stopTouchApp()
+        if not fake and self.test_failed:
+            self.assertTrue(False)
+        super(GraphicUnitTest, self).tearDown()
+
+    def interactive_ask_ref(self, code, imagefn, testid):
+        from os import environ
+        if 'UNITTEST_INTERACTIVE' not in environ:
+            return True
+
+        from tkinter import Tk, Label, LEFT, RIGHT, BOTTOM, Button
+        from PIL import Image, ImageTk
+
+        self.retval = False
+
+        root = Tk()
+
+        def do_close():
+            root.destroy()
+
+        def do_yes():
+            self.retval = True
+            do_close()
+
+        image = Image.open(imagefn)
+        photo = ImageTk.PhotoImage(image)
+        Label(root, text='The test %s\nhave no reference.' % testid).pack()
+        Label(root, text='Use this image as a reference ?').pack()
+        Label(root, text=code, justify=LEFT).pack(side=RIGHT)
+        Label(root, image=photo).pack(side=LEFT)
+        Button(root, text='Use as reference', command=do_yes).pack(side=BOTTOM)
+        Button(root, text='Discard', command=do_close).pack(side=BOTTOM)
+        root.mainloop()
+
+        return self.retval
+
+    def interactive_ask_diff(self, code, tmpfn, reffn, testid):
+        from os import environ
+        if 'UNITTEST_INTERACTIVE' not in environ:
+            return False
+
+        from tkinter import Tk, Label, LEFT, RIGHT, BOTTOM, Button
+        from PIL import Image, ImageTk
+
+        self.retval = False
+
+        root = Tk()
+
+        def do_close():
+            root.destroy()
+
+        def do_yes():
+            self.retval = True
+            do_close()
+
+        phototmp = ImageTk.PhotoImage(Image.open(tmpfn))
+        photoref = ImageTk.PhotoImage(Image.open(reffn))
+        Label(root, text='The test %s\nhave generated an different'
+              'image as the reference one..' % testid).pack()
+        Label(root, text='Which one is good ?').pack()
+        Label(root, text=code, justify=LEFT).pack(side=RIGHT)
+        Label(root, image=phototmp).pack(side=RIGHT)
+        Label(root, image=photoref).pack(side=LEFT)
+        Button(root, text='Use the new image -->',
+               command=do_yes).pack(side=BOTTOM)
+        Button(root, text='<-- Use the reference',
+               command=do_close).pack(side=BOTTOM)
+        root.mainloop()
+
+        return self.retval
+
+    def advance_frames(self, count):
+        '''Render the new frames and:
+
+        * tick the Clock
+        * dispatch input from all registered providers
+        * flush all the canvas operations
+        * redraw Window canvas if necessary
+        '''
+        from kivy.base import EventLoop
+        for i in range(count):
+            EventLoop.idle()
+
+
+class UnitTestTouch(MotionEvent):
+    '''Custom MotionEvent representing a single touch. Similar to `on_touch_*`
+    methods from the Widget class, this one introduces:
+
+    * touch_down
+    * touch_move
+    * touch_up
+
+    Create a new touch with::
+
+        touch = UnitTestTouch(x, y)
+
+    then you press it on the default position with::
+
+        touch.touch_down()
+
+    or move it or even release with these simple calls::
+
+        touch.touch_move(new_x, new_y)
+        touch.touch_up()
+    '''
+
+    def __init__(self, x, y):
+        '''Create a MotionEvent instance with X and Y of the first
+        position a touch is at.
+        '''
+        from kivy.base import EventLoop
+        self.eventloop = EventLoop
+        win = EventLoop.window
+        super(UnitTestTouch, self).__init__(
+            # device, (tuio) id, args
+            self.__class__.__name__, 99, {
+                "x": x / (win.width - 1.0),
+                "y": y / (win.height - 1.0),
+            },
+            is_touch=True,
+            type_id='touch'
+        )
+        # set profile to accept x, y and pos properties
+        self.profile = ['pos']
+
+    def touch_down(self, *args):
+        self.eventloop.post_dispatch_input("begin", self)
+
+    def touch_move(self, x, y):
+        win = self.eventloop.window
+        self.move({
+            "x": x / (win.width - 1.0),
+            "y": y / (win.height - 1.0)
+        })
+        self.eventloop.post_dispatch_input("update", self)
+
+    def touch_up(self, *args):
+        self.eventloop.post_dispatch_input("end", self)
+
+    def depack(self, args):
+        # set sx/sy properties to ratio (e.g. X / win.width)
+        self.sx = args['x']
+        self.sy = args['y']
+        # run depack after we set the values
+        super().depack(args)
+
+
+# https://gist.github.com/tito/f111b6916aa6a4ed0851
+# subclass for touch event in unit test
+class UTMotionEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ['pos']
+
+    def depack(self, args):
+        self.sx = args['x']
+        self.sy = args['y']
+        super().depack(args)
+
+
+def async_run(func=None, app_cls_func=None):
+    def inner_func(func):
+        if 'mock' == cgl_get_backend_name():
+            return pytest.mark.skip(
+                reason='Skipping because gl backend is set to mock')(func)
+
+        if sys.version_info[0] < 3 or sys.version_info[1] <= 5:
+            return pytest.mark.skip(
+                reason='Skipping because graphics tests are not supported on '
+                       'py3.5, only on py3.6+')(func)
+
+        if app_cls_func is not None:
+            func = pytest.mark.parametrize(
+                "kivy_app", [[app_cls_func], ], indirect=True)(func)
+
+        if kivy_eventloop == 'asyncio':
+            try:
+                import pytest_asyncio
+                return pytest.mark.asyncio(pytest_asyncio.fixture(func))
+            except ImportError:
+                return pytest.mark.skip(
+                    reason='KIVY_EVENTLOOP == "asyncio" but '
+                           '"pytest-asyncio" is not installed')(func)
+        elif kivy_eventloop == 'trio':
+            try:
+                import trio
+                from pytest_trio import trio_fixture
+                func._force_trio_fixture = True
+                return func
+            except ImportError:
+                return pytest.mark.skip(
+                    reason='KIVY_EVENTLOOP == "trio" but '
+                           '"pytest-trio" is not installed')(func)
+        else:
+            return pytest.mark.skip(
+                reason='KIVY_EVENTLOOP must be set to either of "asyncio" or '
+                       '"trio" to run async tests')(func)
+
+    if func is None:
+        return inner_func
+
+    return inner_func(func)

kivy/tests/conftest.py

@@ -0,0 +1,33 @@
+import pytest
+import os
+
+kivy_eventloop = os.environ.get('KIVY_EVENTLOOP', 'asyncio')
+
+try:
+    from .fixtures import kivy_app, kivy_clock, kivy_metrics, \
+        kivy_exception_manager
+except SyntaxError:
+    # async app tests would be skipped due to async_run forcing it to skip so
+    # it's ok to fail here as it won't be used anyway
+    pass
+
+if kivy_eventloop != 'trio':
+    @pytest.fixture()
+    def nursery():
+        pass
+
+
+def pytest_runtest_makereport(item, call):
+    # from https://docs.pytest.org/en/latest/example/simple.html
+    if "incremental" in item.keywords:
+        if call.excinfo is not None:
+            parent = item.parent
+            parent._previousfailed = item
+
+
+def pytest_runtest_setup(item):
+    # from https://docs.pytest.org/en/latest/example/simple.html
+    if "incremental" in item.keywords:
+        previousfailed = getattr(item.parent, "_previousfailed", None)
+        if previousfailed is not None:
+            pytest.xfail("previous test failed (%s)" % previousfailed.name)