Add a testbed app to verify the support library is complete and correct.

Author: freakboy3742

.gitignore

@@ -8,4 +8,8 @@ diff/*
 dist/*
 .envrc
 .vscode/
-local/*
+local/*
+*.dist-info
+__pycache__
+tests/testbed/macOS
+tests/testbed/iOS

tests/testbed/README.rst

@@ -0,0 +1,13 @@
+Python Apple Support Testbed
+============================
+
+This is a testbed application that can be used to do basic verification checks
+of the Python Apple Support builds.
+
+The app can be deployed with Briefcase. When executed, (using `briefcase run
+macOS Xcode` or `briefcase run iOS`) the app will generate output on the console
+log that is similar to a unit test suite. If it returns 0 test failures, you can
+have some confidence that the support build is functioning as expected.
+
+The default configuration assumes that you have already run `make` in the root
+directory of this repository.

tests/testbed/pyproject.toml

@@ -0,0 +1,44 @@
+[tool.briefcase]
+project_name = "Testbed"
+bundle = "org.beeware"
+version = "0.0.1"
+url = "https://beeware.org"
+license = "BSD license"
+author = 'Russell Keith-Magee'
+author_email = "[email protected]"
+
+[tool.briefcase.app.testbed]
+formal_name = "Testbed"
+description = "A testbed for the Apple Support packages."
+icon = "src/testbed/resources/testbed"
+sources = ['src/testbed']
+requires = [
+]
+
+
+[tool.briefcase.app.testbed.macOS]
+requires = [
+    "rubicon-objc",
+    "std-nslog",
+]
+template_branch = "m1-compile"
+support_package = "../../dist/Python-3.10-macOS-support.custom.tar.gz"
+
+[tool.briefcase.app.testbed.linux]
+requires = []
+system_requires = []
+
+[tool.briefcase.app.testbed.windows]
+requires = []
+
+# Mobile deployments
+[tool.briefcase.app.testbed.iOS]
+requires = [
+    "rubicon-objc",
+]
+template = "../../../../templates/briefcase-iOS-Xcode-template"
+# template_branch = "m1-compile"
+support_package = "../../dist/Python-3.10-iOS-support.custom.tar.gz"
+
+[tool.briefcase.app.testbed.android]
+requires = []

tests/testbed/src/testbed/__init__.py

@@ -0,0 +1,4 @@
+from testbed.app import main
+
+if __name__ == "__main__":
+    main()

tests/testbed/src/testbed/__main__.py

@@ -0,0 +1,55 @@
+"""
+A testbed for the Apple Support packages.
+"""
+import platform
+import sys
+import traceback
+
+from . import common
+from . import macos
+
+
+def discover_tests(module):
+    "Discover all the test methods in the given module"
+    return [
+        (getattr(module, "__name__").split(".")[-1], getattr(module, name))
+        for name in dir(module)
+        if name.startswith("test_")
+    ]
+
+
+def main():
+    # This should start and launch your app!
+    print("=" * 80)
+    print(f"Python {platform.python_version()} Apple Support verification suite")
+    print(f"Running on {platform.platform()}")
+    print("=" * 80)
+    # Discover the suite
+    suite = discover_tests(common)
+    if sys.platform == "darwin":
+        suite.extend(discover_tests(macos))
+
+    # Run the suite
+    failures = 0
+    tests = 0
+    for sys_platform, test in suite:
+        try:
+            tests += 1
+            # If the test has a docstring, use that text;
+            # otherwise, use the test name
+            if test.__doc__:
+                print(f"{sys_platform}: {test.__doc__}", end="...")
+            else:
+                print(f"{sys_platform}: {test.__name__}", end="...")
+            test()
+            print(" ok")
+        except Exception as e:
+            failures += 1
+            print(" FAILED!")
+            print("-" * 80)
+            traceback.print_exception(e)
+            print("-" * 80)
+
+    print("=" * 80)
+    print(f"Tests complete; {tests} tests, {failures} failures.")
+    sys.exit(int(failures != 0))

tests/testbed/src/testbed/app.py

@@ -0,0 +1,189 @@
+###########################################################################
+# Common tests
+###########################################################################
+from .utils import assert_
+
+
+def test_bzip2():
+    "BZip2 compression with the bz2 module works"
+    import bz2
+
+    data = bz2.compress(b"Hello world")
+    assert_(
+        data == b"BZh91AY&SY\x059\x88u\x00\x00\x00\x95\x80@\x00\x00@\x06\x04"
+        b'\x90\x80 \x00"\x06\x9bHC\x02\x1a|\n\xa1<]\xc9\x14\xe1B@\x14\xe6!\xd4'
+    )
+
+
+def test_ctypes():
+    "The FFI module has been compiled, and ctypes works on ObjC objects"
+    from rubicon.objc import ObjCClass
+
+    NSURL = ObjCClass("NSURL")
+
+    base = NSURL.URLWithString("https://beeware.org/")
+    full = NSURL.URLWithString("contributing", relativeToURL=base)
+    absolute = full.absoluteURL
+    assert_(absolute.description == "https://beeware.org/contributing")
+
+
+def test_decimal():
+    "The decimal module works"
+    from decimal import Decimal, getcontext
+
+    getcontext().prec = 28
+    assert str(Decimal(1) / Decimal(7)) == "0.1428571428571428571428571429"
+
+
+def test_hashlib():
+    "Hashlib can compute hashes"
+    import hashlib
+
+    algorithms = {
+        "md5": "3e25960a79dbc69b674cd4ec67a72c62",
+        "sha1": "7b502c3a1f48c8609ae212cdfb639dee39673f5e",
+        "sha224": "ac230f15fcae7f77d8f76e99adf45864a1c6f800655da78dea956112",
+        "sha256": ("64ec88ca00b268e5ba1a35678a1b5316d212f4f366b2477232534a8aeca37f3c"),
+        "sha384": (
+            "9203b0c4439fd1e6ae5878866337b7c532acd6d9260150c80318e8ab8c27ce33"
+            "0189f8df94fb890df1d298ff360627e1"
+        ),
+        "sha512": (
+            "b7f783baed8297f0db917462184ff4f08e69c2d5e5f79a942600f9725f58ce1f"
+            "29c18139bf80b06c0fff2bdd34738452ecf40c488c22a7e3d80cdf6f9c1c0d47"
+        ),
+        "blake2b": (
+            "6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33"
+            "343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183"
+        ),
+        "blake2s": "619a15b0f4dd21ef4bd626a9146af64561caf1325b21bccf755e4d7fbc31a65f",
+        "sha3_224": "3b8570ec1335c461747d016460ff91cb41fad08051911c50dd8e1995",
+        "sha3_256": (
+            "369183d3786773cef4e56c7b849e7ef5f742867510b676d6b38f8e38a222d8a2"
+        ),
+        "sha3_384": (
+            "ff3917192427ea1aa7f3ad47ac10152d179af30126c52835ee8dc7e6ea12aed9"
+            "1ad91b316e15c3b250469ef17a03e529"
+        ),
+        "sha3_512": (
+            "e2e1c9e522efb2495a178434c8bb8f11000ca23f1fd679058b7d7e141f0cf343"
+            "3f94fc427ec0b9bebb12f327a3240021053db6091196576d5e6d9bd8fac71c0c"
+        ),
+        "shake_128": (
+            40,
+            "c1301df86b1dc67ce3b5a067dc9b47affca8caa08f41d1efa614cea56f526897"
+            "d61ded8ab01421f1",
+        ),
+        "shake_256": (
+            40,
+            "20740b4c7a7997765e9cc254b44a1589e60849be0fe70b68a6fb732415edaa13"
+            "3bb6eb7825ffa531",
+        ),
+    }
+    for algorithm, details in algorithms.items():
+        try:
+            length, expected = details
+            digest_args = {"length": length}
+        except ValueError:
+            expected = details
+            digest_args = {}
+        msg = getattr(hashlib, algorithm)()
+        msg.update(b"Hello world")
+        assert_(
+            msg.hexdigest(**digest_args) == expected,
+            msg=f"{algorithm} digest was {msg.hexdigest(**digest_args)}",
+        )
+
+
+def test_sqlite3():
+    "The sqlite3 module works"
+    import sqlite3
+
+    conn = sqlite3.connect(":memory:")
+    try:
+        cursor = conn.cursor()
+
+        cursor.execute(
+            "CREATE TABLE stonks (date text, symbol text, qty real, price real)"
+        )
+        cursor.execute("INSERT INTO stonks VALUES ('2022-05-04', 'JEDI', 10, 2.50)")
+        cursor.execute("INSERT INTO stonks VALUES ('2022-05-04', 'SITH', 2, 6.66)")
+        conn.commit()
+
+        assert_(
+            list(cursor.execute("SELECT * FROM stonks ORDER BY symbol DESC"))
+            == [("2022-05-04", "SITH", 2.0, 6.66), ("2022-05-04", "JEDI", 10.0, 2.5)]
+        )
+    finally:
+        conn.close()
+
+
+def test_ssl():
+    "The SSL modules has been compiled"
+    import ssl
+
+    # Result doesn't really matter; we just need to be able to invoke
+    # a method whose implementation is in the C module
+    ssl.get_default_verify_paths()
+
+
+XML_DOCUMENT = """<?xml version="1.0"?>
+<data>
+    <device name="iPhone">
+        <os>iOS</os>
+        <type>phone</type>
+    </device>
+    <device name="macBook">
+        <os>macOS</os>
+        <type>laptop</type>
+    </device>
+</data>
+"""
+
+
+def test_xml_elementtree():
+    "The elementtree XML parser works"
+    import xml.etree.ElementTree as ET
+
+    root = ET.fromstring(XML_DOCUMENT)
+    assert_(
+        [(child.tag, child.attrib["name"]) for child in root]
+        == [("device", "iPhone"), ("device", "macBook")]
+    )
+
+
+def test_xml_expat():
+    "The expat XML parser works"
+    from xml.parsers.expat import ParserCreate
+
+    starts = []
+
+    def start_element(name, attrs):
+        starts.append(name)
+
+    parser = ParserCreate()
+    parser.StartElementHandler = start_element
+    parser.Parse(XML_DOCUMENT)
+
+    assert_(starts == ["data", "device", "os", "type", "device", "os", "type"])
+
+
+def test_xz():
+    "XZ compression with the lzma module works"
+    import lzma
+
+    data = lzma.compress(b"Hello world")
+    assert_(
+        data == b"\xfd7zXZ\x00\x00\x04\xe6\xd6\xb4F\x02\x00!\x01\x16\x00\x00\x00t/"
+        b"\xe5\xa3\x01\x00\nHello world\x00\x00\xbfVw\xd4\xb9\xf2\xa5\xf4\x00"
+        b"\x01#\x0b\xc2\x1b\xfd\t\x1f\xb6\xf3}\x01\x00\x00\x00\x00\x04YZ"
+    )
+
+
+def test_zoneinfo():
+    "Zoneinfo database is available"
+    from zoneinfo import ZoneInfo
+    from datetime import datetime
+
+    dt = datetime(2022, 5, 4, 13, 40, 42, tzinfo=ZoneInfo("Australia/Perth"))
+    assert_(str(dt) == "2022-05-04 13:40:42+08:00")

tests/testbed/src/testbed/common.py

@@ -0,0 +1,51 @@
+###########################################################################
+# macOS specific tests
+###########################################################################
+from .utils import assert_
+
+
+def test_scproxy():
+    "The _scproxy module has been compiled"
+    import _scproxy
+
+    _scproxy._get_proxy_settings()
+
+
+def test_curses():
+    "The curses module has been compiled"
+    import curses
+
+    try:
+        curses.can_change_color()
+    except curses.error:
+        # We can't invoke curses methods without raising a curses error;
+        # but if we get the error, the module works.
+        pass
+
+
+def test_posix_shmem():
+    "POSIX shared memory works"
+    from multiprocessing import shared_memory
+
+    # FIXME: For now, we can't actually test multiprocessing
+    # because it involves invoking a subprocess, and the macOS app
+    # shim doesn't support process duplication. The import is
+    # enough to test that the _posixshmem C module exists.
+    # try:
+    #     obj = shared_memory.ShareableList(
+    #         ["howdy", b"HoWdY", -273.154, 100, None, True, 42]
+    #     )
+    #
+    #     assert obj[3] == 100
+    # finally:
+    #     obj.shm.close()
+    #     obj.shm.unlink()
+    #     del obj
+
+
+def test_posix_subprocess():
+    "Subprocesses can be invoked"
+    import subprocess
+
+    result = subprocess.run(["uname", "-s"], capture_output=True)
+    assert_(result.stdout == b"Darwin\n")