A bunch of tests for library recipes (#1982)

The main idea is to test as many recipes as we can with the less code possible and without creating any file/directory so our tests can be performed as fast as possible (all this tests will only add between 2 and 3 seconds to our CI tests and will cover almost 100% of the code for each tested recipe)

To do so, we create a couple of modules:

    tests.recipe_ctx: allow us to create a proper Context to test our recipes
    tests.recipe_lib_test: which holds some base classes to be used to test a recipe depending on the build method used. For starters we introduce two kind of base classes:
        BaseTestForMakeRecipe: To test an standard library build (this will iinclude the recipes which requires the classical build commandsconfigure/make)
        BaseTestForCmakeRecipe: To test an library recipe which is compiled with cmake

We also refactor the existing recipes tests, so we can remove some lines in there...the ones that creates a Context.

* [test] Add module `tests.recipe_ctx`

A helper module to test recipes.
Here we will initialize a `Context` to test recipes.

* [test] Refactor `setUp/tearDown` for `test_icu`

* [test] Refactor `setUp/tearDown` for `test_pyicu`

* [test] Refactor `setUp` for `test_reportlab`

* [test] Refactor `setUp` for `test_gevent`

* [test] Add module `tests.recipe_lib_test`

A helper module to test recipes which will allow to test any recipe using `configure/make` commands.

* [test] Add test for `libffi`

* [test] Add test for `libexpat`

* [test] Add test for `libcurl`

* [test] Add test for `libiconv`

* [test] Add test for `libogg`

* [test] Add test for `libpq`

* [test] Add test for `libsecp256k1`

* [test] Add test for `libshine`

* [test] Add test for `libvorbis`

* [test] Add test for `libx264`

* [test] Add test for `libxml2`

* [test] Add test for `libxslt`

* [test] Add test for `png`

* [test] Add test for `freetype`

* [test] Add test for `harfbuzz`

* [test] Add test for `openssl`

* [test] Add `BaseTestForCmakeRecipe`

* [test] Add test for `jpeg` and clean code

We can remove the `get_recipe_env` because the environment that we use is already using a clang as default compiler (not the case when we migrated the jpeg recipe to use `cmake`)...so we can do a little refactor :)

* [test] Add test for `snappy`

* [test] Add test for `leveldb`

* [test] Add test for `libgeos`

* [test] Add test for `libmysqlclient`

* [test] Add test for `openal`

* [test] Make the `super` calls Python3 style

* [test] Move mock tests outside context manager...

Because there is no need to do it there.

Also rewrote the inline comments.

Author: opacam

pythonforandroid/recipes/jpeg/__init__.py

@@ -2,7 +2,6 @@
 from pythonforandroid.logger import shprint
 from pythonforandroid.util import current_directory
 from os.path import join
-from os import environ, uname
 import sh
 
 
@@ -35,10 +34,9 @@ def build_arch(self, arch):
                     '-DCMAKE_POSITION_INDEPENDENT_CODE=1',
                     '-DCMAKE_ANDROID_ARCH_ABI={arch}'.format(arch=arch.arch),
                     '-DCMAKE_ANDROID_NDK=' + self.ctx.ndk_dir,
-                    '-DCMAKE_C_COMPILER={toolchain}/bin/clang'.format(
-                        toolchain=env['TOOLCHAIN']),
-                    '-DCMAKE_CXX_COMPILER={toolchain}/bin/clang++'.format(
-                        toolchain=env['TOOLCHAIN']),
+                    '-DCMAKE_C_COMPILER={cc}'.format(cc=arch.get_clang_exe()),
+                    '-DCMAKE_CXX_COMPILER={cc_plus}'.format(
+                        cc_plus=arch.get_clang_exe(plus_plus=True)),
                     '-DCMAKE_BUILD_TYPE=Release',
                     '-DCMAKE_INSTALL_PREFIX=./install',
                     '-DCMAKE_TOOLCHAIN_FILE=' + toolchain_file,
@@ -54,16 +52,5 @@ def build_arch(self, arch):
                     _env=env)
             shprint(sh.make, _env=env)
 
-    def get_recipe_env(self, arch=None, with_flags_in_cc=False):
-        env = environ.copy()
-
-        build_platform = '{system}-{machine}'.format(
-            system=uname()[0], machine=uname()[-1]).lower()
-        env['TOOLCHAIN'] = join(self.ctx.ndk_dir, 'toolchains/llvm/'
-                                'prebuilt/{build_platform}'.format(
-                                    build_platform=build_platform))
-
-        return env
-
 
 recipe = JpegRecipe()

tests/recipes/recipe_ctx.py

@@ -0,0 +1,52 @@
+import os
+
+from pythonforandroid.bootstrap import Bootstrap
+from pythonforandroid.distribution import Distribution
+from pythonforandroid.recipe import Recipe
+from pythonforandroid.build import Context
+from pythonforandroid.archs import ArchAarch_64
+
+
+class RecipeCtx:
+    """
+    An base class for unit testing a recipe. This will create a context so we
+    can test any recipe using this context. Implement `setUp` and `tearDown`
+    methods used by unit testing.
+    """
+
+    ctx = None
+    arch = None
+    recipe = None
+
+    recipe_name = ""
+    "The name of the recipe to test."
+
+    recipes = []
+    """A List of recipes to pass to `Distribution.get_distribution`. Should
+    contain the target recipe to test as well as a python recipe."""
+    recipe_build_order = []
+    """A recipe_build_order which should take into account the recipe we want
+    to test as well as the possible dependant recipes"""
+
+    def setUp(self):
+        self.ctx = Context()
+        self.ctx.ndk_api = 21
+        self.ctx.android_api = 27
+        self.ctx._sdk_dir = "/opt/android/android-sdk"
+        self.ctx._ndk_dir = "/opt/android/android-ndk"
+        self.ctx.setup_dirs(os.getcwd())
+        self.ctx.bootstrap = Bootstrap().get_bootstrap("sdl2", self.ctx)
+        self.ctx.bootstrap.distribution = Distribution.get_distribution(
+            self.ctx, name="sdl2", recipes=self.recipes
+        )
+        self.ctx.recipe_build_order = self.recipe_build_order
+        self.ctx.python_recipe = Recipe.get_recipe("python3", self.ctx)
+        self.arch = ArchAarch_64(self.ctx)
+        self.ctx.ndk_platform = (
+            f"{self.ctx._ndk_dir}/platforms/"
+            f"android-{self.ctx.ndk_api}/{self.arch.platform_dir}"
+        )
+        self.recipe = Recipe.get_recipe(self.recipe_name, self.ctx)
+
+    def tearDown(self):
+        self.ctx = None

tests/recipes/recipe_lib_test.py

@@ -0,0 +1,157 @@
+from unittest import mock
+from tests.recipes.recipe_ctx import RecipeCtx
+
+
+class BaseTestForMakeRecipe(RecipeCtx):
+    """
+    An unittest for testing any recipe using the standard build commands
+    (`configure/make`).
+
+    .. note:: Note that Some cmake recipe may need some more specific testing
+        ...but this should cover the basics.
+    """
+
+    recipe_name = None
+    recipes = ["python3", "kivy"]
+    recipe_build_order = ["hostpython3", "python3", "sdl2", "kivy"]
+    expected_compiler = (
+        "{android_ndk}/toolchains/llvm/prebuilt/linux-x86_64/bin/clang"
+    )
+
+    sh_command_calls = ["./configure"]
+    """The expected commands that the recipe runs via `sh.command`."""
+
+    extra_env_flags = {}
+    """
+    This must be a dictionary containing pairs of key (env var) and value.
+    """
+
+    def __new__(cls, *args):
+        obj = super().__new__(cls)
+        if obj.recipe_name is not None:
+            print(f"We are testing recipe: {obj.recipe_name}")
+            obj.recipes.append(obj.recipe_name)
+            obj.recipe_build_order.insert(1, obj.recipe_name)
+            return obj
+
+    @mock.patch("pythonforandroid.recipe.Recipe.check_recipe_choices")
+    @mock.patch("pythonforandroid.build.ensure_dir")
+    @mock.patch("pythonforandroid.archs.glob")
+    @mock.patch("pythonforandroid.archs.find_executable")
+    def test_get_recipe_env(
+        self,
+        mock_find_executable,
+        mock_glob,
+        mock_ensure_dir,
+        mock_check_recipe_choices,
+    ):
+        """
+        Test that get_recipe_env contains some expected arch flags and that
+        some internal methods has been called.
+        """
+        mock_find_executable.return_value = self.expected_compiler.format(
+                android_ndk=self.ctx._ndk_dir
+        )
+        mock_glob.return_value = ["llvm"]
+        mock_check_recipe_choices.return_value = sorted(
+            self.ctx.recipe_build_order
+        )
+
+        # make sure the arch flags are in env
+        env = self.recipe.get_recipe_env(self.arch)
+        for flag in self.arch.arch_cflags:
+            self.assertIn(flag, env["CFLAGS"])
+        self.assertIn(
+            f"-target {self.arch.target}",
+            env["CFLAGS"],
+        )
+
+        for flag, value in self.extra_env_flags.items():
+            self.assertIn(value, env[flag])
+
+        # make sure that the mocked methods are actually called
+        mock_glob.assert_called()
+        mock_ensure_dir.assert_called()
+        mock_find_executable.assert_called()
+        mock_check_recipe_choices.assert_called()
+
+    @mock.patch("pythonforandroid.util.chdir")
+    @mock.patch("pythonforandroid.build.ensure_dir")
+    @mock.patch("pythonforandroid.archs.glob")
+    @mock.patch("pythonforandroid.archs.find_executable")
+    def test_build_arch(
+        self,
+        mock_find_executable,
+        mock_glob,
+        mock_ensure_dir,
+        mock_current_directory,
+    ):
+        mock_find_executable.return_value = self.expected_compiler.format(
+                android_ndk=self.ctx._ndk_dir
+        )
+        mock_glob.return_value = ["llvm"]
+
+        # Since the following mocks are dynamic,
+        # we mock it inside a Context Manager
+        with mock.patch(
+            f"pythonforandroid.recipes.{self.recipe_name}.sh.Command"
+        ) as mock_sh_command, mock.patch(
+            f"pythonforandroid.recipes.{self.recipe_name}.sh.make"
+        ) as mock_make:
+            self.recipe.build_arch(self.arch)
+
+        # make sure that the mocked methods are actually called
+        for command in self.sh_command_calls:
+            self.assertIn(
+                mock.call(command),
+                mock_sh_command.mock_calls,
+            )
+        mock_make.assert_called()
+        mock_glob.assert_called()
+        mock_ensure_dir.assert_called()
+        mock_current_directory.assert_called()
+        mock_find_executable.assert_called()
+
+
+class BaseTestForCmakeRecipe(BaseTestForMakeRecipe):
+    """
+    An unittest for testing any recipe using `cmake`. It inherits from
+    `BaseTestForMakeRecipe` but we override the build method to match the cmake
+    build method.
+
+    .. note:: Note that Some cmake recipe may need some more specific testing
+        ...but this should cover the basics.
+    """
+
+    @mock.patch("pythonforandroid.util.chdir")
+    @mock.patch("pythonforandroid.build.ensure_dir")
+    @mock.patch("pythonforandroid.archs.glob")
+    @mock.patch("pythonforandroid.archs.find_executable")
+    def test_build_arch(
+        self,
+        mock_find_executable,
+        mock_glob,
+        mock_ensure_dir,
+        mock_current_directory,
+    ):
+        mock_find_executable.return_value = self.expected_compiler.format(
+                android_ndk=self.ctx._ndk_dir
+        )
+        mock_glob.return_value = ["llvm"]
+
+        # Since the following mocks are dynamic,
+        # we mock it inside a Context Manager
+        with mock.patch(
+            f"pythonforandroid.recipes.{self.recipe_name}.sh.make"
+        ) as mock_make, mock.patch(
+            f"pythonforandroid.recipes.{self.recipe_name}.sh.cmake"
+        ) as mock_cmake:
+            self.recipe.build_arch(self.arch)
+
+        # make sure that the mocked methods are actually called
+        mock_cmake.assert_called()
+        mock_make.assert_called()
+        mock_glob.assert_called()
+        mock_ensure_dir.assert_called()
+        mock_current_directory.assert_called()
+        mock_find_executable.assert_called()

tests/recipes/test_freetype.py

@@ -0,0 +1,10 @@
+import unittest
+from tests.recipes.recipe_lib_test import BaseTestForMakeRecipe
+
+
+class TestFreetypeRecipe(BaseTestForMakeRecipe, unittest.TestCase):
+    """
+    An unittest for recipe :mod:`~pythonforandroid.recipes.freetype`
+    """
+    recipe_name = "freetype"
+    sh_command_calls = ["./configure"]

tests/recipes/test_gevent.py

@@ -1,21 +1,11 @@
 import unittest
 from mock import patch
-from pythonforandroid.archs import ArchARMv7_a
-from pythonforandroid.build import Context
-from pythonforandroid.recipe import Recipe
+from tests.recipes.recipe_ctx import RecipeCtx
 
 
-class TestGeventRecipe(unittest.TestCase):
+class TestGeventRecipe(RecipeCtx, unittest.TestCase):
 
-    def setUp(self):
-        """
-        Setups recipe and context.
-        """
-        self.context = Context()
-        self.context.ndk_api = 21
-        self.context.android_api = 27
-        self.arch = ArchARMv7_a(self.context)
-        self.recipe = Recipe.get_recipe('gevent', self.context)
+    recipe_name = "gevent"
 
     def test_get_recipe_env(self):
         """

tests/recipes/test_harfbuzz.py

@@ -0,0 +1,10 @@
+import unittest
+from tests.recipes.recipe_lib_test import BaseTestForMakeRecipe
+
+
+class TestHarfbuzzRecipe(BaseTestForMakeRecipe, unittest.TestCase):
+    """
+    An unittest for recipe :mod:`~pythonforandroid.recipes.harfbuzz`
+    """
+    recipe_name = "harfbuzz"
+    sh_command_calls = ["./configure"]