Rework of test_archs to adapt it to the new ndk-r19 build system

Also add some more tests (now we check if some of the functions we mock, `glob` and `find_executable`, are called with the expected arguments)

Author: opacam

tests/test_archs.py

@@ -1,13 +1,14 @@
 import os
-
 import unittest
+from os import environ
 
 try:
     from unittest import mock
 except ImportError:
     # `Python 2` or lower than `Python 3.3` does not
     # have the `unittest.mock` module built-in
     import mock
+
 from pythonforandroid.bootstrap import Bootstrap
 from pythonforandroid.distribution import Distribution
 from pythonforandroid.recipe import Recipe
@@ -53,6 +54,7 @@ class ArchSetUpBaseClass(object):
     """
 
     ctx = None
+    expected_compiler = ""
 
     def setUp(self):
         self.ctx = Context()
@@ -66,6 +68,12 @@ def setUp(self):
             self.ctx, name="sdl2", recipes=["python3", "kivy"]
         )
         self.ctx.python_recipe = Recipe.get_recipe("python3", self.ctx)
+        # Here we define the expected compiler, which, as per ndk >= r19,
+        # should be the same for all the tests (no more gcc compiler)
+        self.expected_compiler = (
+            "/opt/android/android-ndk/toolchains/"
+            "llvm/prebuilt/linux-x86_64/bin/clang"
+        )
 
 
 class TestArch(ArchSetUpBaseClass, unittest.TestCase):
@@ -82,11 +90,7 @@ def test_arch(self):
         self.assertEqual(
             e1.exception.args[0], "'Arch' object has no attribute 'arch'"
         )
-        with self.assertRaises(AttributeError) as e2:
-            getattr(arch, "target")
-        self.assertEqual(
-            e2.exception.args[0], "'NoneType' object has no attribute 'split'"
-        )
+        self.assertEqual(arch.target, "None21")
         self.assertIsNone(arch.toolchain_prefix)
         self.assertIsNone(arch.command_prefix)
         self.assertIsInstance(arch.include_dirs, list)
@@ -98,9 +102,10 @@ class TestArchARM(ArchSetUpBaseClass, unittest.TestCase):
     will be used to perform tests for :class:`~pythonforandroid.archs.ArchARM`.
     """
 
+    @mock.patch("pythonforandroid.archs.glob")
     @mock.patch("pythonforandroid.archs.find_executable")
     @mock.patch("pythonforandroid.build.ensure_dir")
-    def test_arch_arm(self, mock_ensure_dir, mock_find_executable):
+    def test_arch_arm(self, mock_ensure_dir, mock_find_executable, mock_glob):
         """
         Test that class :class:`~pythonforandroid.archs.ArchARM` returns some
         expected attributes and environment variables.
@@ -115,15 +120,16 @@ def test_arch_arm(self, mock_ensure_dir, mock_find_executable):
                   not exist)
 
         """
-        mock_find_executable.return_value = "arm-linux-androideabi-gcc"
+        mock_find_executable.return_value = self.expected_compiler
         mock_ensure_dir.return_value = True
+        mock_glob.return_value = ["llvm"]
 
         arch = ArchARM(self.ctx)
         self.assertEqual(arch.arch, "armeabi")
         self.assertEqual(arch.__str__(), "armeabi")
         self.assertEqual(arch.toolchain_prefix, "arm-linux-androideabi")
         self.assertEqual(arch.command_prefix, "arm-linux-androideabi")
-        self.assertEqual(arch.target, "armv7a-none-linux-androideabi")
+        self.assertEqual(arch.target, "armv7a-linux-androideabi21")
         self.assertEqual(arch.platform_dir, "arch-arm")
         arch = ArchARM(self.ctx)
 
@@ -134,9 +140,17 @@ def test_arch_arm(self, mock_ensure_dir, mock_find_executable):
             expected_env_gcc_keys, set(env.keys()) & expected_env_gcc_keys
         )
 
+        # check glob and find_executable calls
+        mock_glob.assert_called_once_with(
+            "{ndk_dir}/toolchains/llvm*".format(ndk_dir=self.ctx._ndk_dir)
+        )
+        mock_find_executable.assert_called_once_with(
+            self.expected_compiler, path=environ["PATH"]
+        )
+
         # check gcc compilers
-        self.assertEqual(env["CC"].split()[0], "arm-linux-androideabi-gcc")
-        self.assertEqual(env["CXX"].split()[0], "arm-linux-androideabi-g++")
+        self.assertEqual(env["CC"].split()[0], self.expected_compiler)
+        self.assertEqual(env["CXX"].split()[0], self.expected_compiler + "++")
         # check android binaries
         self.assertEqual(env["AR"], "arm-linux-androideabi-ar")
         self.assertEqual(env["LD"], "arm-linux-androideabi-ld")
@@ -166,9 +180,9 @@ def test_arch_arm(self, mock_ensure_dir, mock_find_executable):
         self.assertEqual(
             e.exception.args[0],
             "Couldn't find executable for CC. This indicates a problem "
-            "locating the arm-linux-androideabi-gcc executable in the Android "
+            "locating the {expected_compiler} executable in the Android "
             "NDK, not that you don't have a normal compiler installed. "
-            "Exiting.",
+            "Exiting.".format(expected_compiler=self.expected_compiler),
         )
 
 
@@ -197,7 +211,7 @@ def test_arch_armv7a(
             tests the `get_env` with clang
 
         """
-        mock_find_executable.return_value = "arm-linux-androideabi-gcc"
+        mock_find_executable.return_value = self.expected_compiler
         mock_ensure_dir.return_value = True
         mock_glob.return_value = ["llvm"]
 
@@ -206,10 +220,18 @@ def test_arch_armv7a(
         self.assertEqual(arch.__str__(), "armeabi-v7a")
         self.assertEqual(arch.toolchain_prefix, "arm-linux-androideabi")
         self.assertEqual(arch.command_prefix, "arm-linux-androideabi")
-        self.assertEqual(arch.target, "armv7a-none-linux-androideabi")
+        self.assertEqual(arch.target, "armv7a-linux-androideabi21")
         self.assertEqual(arch.platform_dir, "arch-arm")
 
-        env = arch.get_env(clang=True)
+        env = arch.get_env()
+        # check glob and find_executable calls
+        mock_glob.assert_called_once_with(
+            "{ndk_dir}/toolchains/llvm*".format(ndk_dir=self.ctx._ndk_dir)
+        )
+        mock_find_executable.assert_called_once_with(
+            self.expected_compiler, path=environ["PATH"]
+        )
+
         # check clang
         build_platform = "{system}-{machine}".format(
             system=os.uname()[0], machine=os.uname()[-1]
@@ -242,29 +264,43 @@ class TestArchX86(ArchSetUpBaseClass, unittest.TestCase):
     will be used to perform tests for :class:`~pythonforandroid.archs.Archx86`.
     """
 
+    @mock.patch("pythonforandroid.archs.glob")
     @mock.patch("pythonforandroid.archs.find_executable")
     @mock.patch("pythonforandroid.build.ensure_dir")
-    def test_arch_x86(self, mock_ensure_dir, mock_find_executable):
+    def test_arch_x86(self, mock_ensure_dir, mock_find_executable, mock_glob):
         """
         Test that class :class:`~pythonforandroid.archs.Archx86` returns
         some expected attributes and environment variables.
 
-        .. note:: Here we mock the same functions than
-                  :meth:`TestArchARM.test_arch_arm`
+        .. note::
+            Here we mock the same functions than
+            :meth:`TestArchARM.test_arch_arm` plus `glob`, so we make sure that
+            the glob result is the expected even if the folder doesn't exist,
+            which is probably the case. This has to be done because here we
+            tests the `get_env` with clang
         """
-        mock_find_executable.return_value = "arm-linux-androideabi-gcc"
+        mock_find_executable.return_value = self.expected_compiler
         mock_ensure_dir.return_value = True
+        mock_glob.return_value = ["llvm"]
 
         arch = Archx86(self.ctx)
         self.assertEqual(arch.arch, "x86")
         self.assertEqual(arch.__str__(), "x86")
         self.assertEqual(arch.toolchain_prefix, "x86")
         self.assertEqual(arch.command_prefix, "i686-linux-android")
-        self.assertEqual(arch.target, "i686-none-linux-android")
+        self.assertEqual(arch.target, "i686-linux-android21")
         self.assertEqual(arch.platform_dir, "arch-x86")
 
-        # For x86 we expect some extra cflags in our `environment`
         env = arch.get_env()
+        # check glob and find_executable calls
+        mock_glob.assert_called_once_with(
+            "{ndk_dir}/toolchains/llvm*".format(ndk_dir=self.ctx._ndk_dir)
+        )
+        mock_find_executable.assert_called_once_with(
+            self.expected_compiler, path=environ["PATH"]
+        )
+
+        # For x86 we expect some extra cflags in our `environment`
         self.assertIn(
             " -march=i686 -mtune=intel -mssse3 -mfpmath=sse -m32",
             env["CFLAGS"],
@@ -278,29 +314,47 @@ class TestArchX86_64(ArchSetUpBaseClass, unittest.TestCase):
     :class:`~pythonforandroid.archs.Archx86_64`.
     """
 
+    @mock.patch("pythonforandroid.archs.glob")
     @mock.patch("pythonforandroid.archs.find_executable")
     @mock.patch("pythonforandroid.build.ensure_dir")
-    def test_arch_x86_64(self, mock_ensure_dir, mock_find_executable):
+    def test_arch_x86_64(
+        self, mock_ensure_dir, mock_find_executable, mock_glob
+    ):
         """
         Test that class :class:`~pythonforandroid.archs.Archx86_64` returns
         some expected attributes and environment variables.
 
-        .. note:: Here we mock the same functions than
-                  :meth:`TestArchARM.test_arch_arm`
+        .. note::
+            Here we mock the same functions than
+            :meth:`TestArchARM.test_arch_arm` plus `glob`, so we make sure that
+            the glob result is the expected even if the folder doesn't exist,
+            which is probably the case. This has to be done because here we
+            tests the `get_env` with clang
         """
-        mock_find_executable.return_value = "arm-linux-androideabi-gcc"
+        mock_find_executable.return_value = self.expected_compiler
         mock_ensure_dir.return_value = True
+        mock_glob.return_value = ["llvm"]
 
         arch = Archx86_64(self.ctx)
         self.assertEqual(arch.arch, "x86_64")
         self.assertEqual(arch.__str__(), "x86_64")
         self.assertEqual(arch.toolchain_prefix, "x86_64")
         self.assertEqual(arch.command_prefix, "x86_64-linux-android")
-        self.assertEqual(arch.target, "x86_64-none-linux-android")
+        self.assertEqual(arch.target, "x86_64-linux-android21")
         self.assertEqual(arch.platform_dir, "arch-x86_64")
 
-        # For x86_64 we expect some extra cflags in our `environment`
         env = arch.get_env()
+        # check glob and find_executable calls
+        mock_glob.assert_called_once_with(
+            "{ndk_dir}/toolchains/llvm*".format(ndk_dir=self.ctx._ndk_dir)
+        )
+        mock_find_executable.assert_called_once_with(
+            self.expected_compiler, path=environ["PATH"]
+        )
+
+        # For x86_64 we expect some extra cflags in our `environment`
+        mock_glob.assert_called_once()
+        mock_find_executable.assert_called_once()
         self.assertIn(
             " -march=x86-64 -msse4.2 -mpopcnt -m64 -mtune=intel", env["CFLAGS"]
         )
@@ -313,27 +367,43 @@ class TestArchAArch64(ArchSetUpBaseClass, unittest.TestCase):
     :class:`~pythonforandroid.archs.ArchAarch_64`.
     """
 
+    @mock.patch("pythonforandroid.archs.glob")
     @mock.patch("pythonforandroid.archs.find_executable")
     @mock.patch("pythonforandroid.build.ensure_dir")
-    def test_arch_aarch_64(self, mock_ensure_dir, mock_find_executable):
+    def test_arch_aarch_64(
+        self, mock_ensure_dir, mock_find_executable, mock_glob
+    ):
         """
         Test that class :class:`~pythonforandroid.archs.ArchAarch_64` returns
         some expected attributes and environment variables.
 
-        .. note:: Here we mock the same functions than
-                  :meth:`TestArchARM.test_arch_arm`
+        .. note::
+            Here we mock the same functions than
+            :meth:`TestArchARM.test_arch_arm` plus `glob`, so we make sure that
+            the glob result is the expected even if the folder doesn't exist,
+            which is probably the case. This has to be done because here we
+            tests the `get_env` with clang
         """
-        mock_find_executable.return_value = "arm-linux-androideabi-gcc"
+        mock_find_executable.return_value = self.expected_compiler
         mock_ensure_dir.return_value = True
+        mock_glob.return_value = ["llvm"]
 
         arch = ArchAarch_64(self.ctx)
         self.assertEqual(arch.arch, "arm64-v8a")
         self.assertEqual(arch.__str__(), "arm64-v8a")
         self.assertEqual(arch.toolchain_prefix, "aarch64-linux-android")
         self.assertEqual(arch.command_prefix, "aarch64-linux-android")
-        self.assertEqual(arch.target, "aarch64-none-linux-android")
+        self.assertEqual(arch.target, "aarch64-linux-android21")
         self.assertEqual(arch.platform_dir, "arch-arm64")
 
-        # For x86_64 we expect to find an extra key in`environment`
         env = arch.get_env()
+        # check glob and find_executable calls
+        mock_glob.assert_called_once_with(
+            "{ndk_dir}/toolchains/llvm*".format(ndk_dir=self.ctx._ndk_dir)
+        )
+        mock_find_executable.assert_called_once_with(
+            self.expected_compiler, path=environ["PATH"]
+        )
+
+        # For x86_64 we expect to find an extra key in`environment`
         self.assertIn("EXTRA_CFLAGS", env.keys())