kleaf: Test modules.dep to ensure modules in modules.load* can be loaded

Depmod generates the modules.dep file which contains the dependencies
for each module in the directory that depmod runs in. When specifying
module lists, it is important that there's an entry for each module
in each module list to ensure that the module's dependencies are loaded
before attempting to load the module.

Therefore, add a test to ensure that each module in each module list
has an entry in modules.dep.

Bug: 323710246
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
(cherry picked from https://android-review.googlesource.com/q/commit:2cef65c72ee9d91ebbbe184a47b1186a0954a950)
Merged-In: Ie6a7cb65cad336d4ccda9fa6957624448690e3c7
Change-Id: Ie6a7cb65cad336d4ccda9fa6957624448690e3c7

1 files changed, 63 insertions, 1 deletions

diff --git a/kleaf/artifact_tests/initramfs_modules_lists_test.py b/kleaf/artifact_tests/initramfs_modules_lists_test.py
index 19f14c78..4f7f4e2a 100644
--- a/kleaf/artifact_tests/initramfs_modules_lists_test.py
+++ b/kleaf/artifact_tests/initramfs_modules_lists_test.py
@@ -19,6 +19,7 @@ import sys
 import tempfile
 import unittest
 import re
+import pathlib
 
 from absl.testing import absltest
 
@@ -106,7 +107,7 @@ class InitramfsModulesLists(unittest.TestCase):
 
     def test_diff(self):
         initramfs_list = [f for f in arguments.files if os.path.basename(f) == "initramfs.img"]
-        self.assertEqual(1, len(initramfs_list))
+        self.assertEqual(len(initramfs_list), 1)
         initramfs = initramfs_list[0]
         modules_lists_map = {}
 
@@ -168,6 +169,67 @@ class InitramfsModulesLists(unittest.TestCase):
         if arguments.expected_modules_charger_list:
             self._verify_modules_load_lists("modules.load.charger", vendor_boot_name, arguments.files)
 
+    def _verify_modules_dep_contains_modules_lists(self, modules_lists, modules_dir):
+        """Ensures that modules.dep contains all entries needed for modules.load*.
+
+        Given a list of modules lists, this function ensures that modules.dep
+        contains an entry for each module in all of the modules lists.
+
+        Args:
+            modules_lists: The list of modules.load* that need to be tested.
+            modules_dir: The directory in which the modules reside in.
+        """
+        modules_dep_path = pathlib.Path(modules_dir, "modules.dep")
+        modules_dep_set = set()
+
+        self.assertTrue(modules_dep_path.is_file(), f"Can't find {modules_dep_path}")
+
+        with open(modules_dep_path) as modules_dep_file:
+            for line in modules_dep_file:
+                # depmod entries have the form:
+                # mod_path: dep_path_1 dep_path_2
+                mod_name = line.split(":")[0].strip()
+                modules_dep_set.add(pathlib.Path(mod_name).name)
+
+        for mod_list in modules_lists:
+            mod_list_path = pathlib.Path(modules_dir, mod_list)
+            self.assertTrue(mod_list_path.is_file(), f"Can't find {mod_list_path}")
+            mod_list_modules = set()
+
+            with open(mod_list_path) as mod_list_file:
+                for line in mod_list_file:
+                    mod_list_modules.add(pathlib.Path(line.strip()).name)
+
+            self.assertTrue(mod_list_modules.issubset(modules_dep_set),
+                            "modules.dep does not contain an entry for each module to be loaded")
+
+    def test_modules_dep_contains_all_modules_lists(self):
+        initramfs_list = [file
+                          for file in arguments.files
+                          if pathlib.Path(file).name == "initramfs.img"]
+        self.assertEqual(len(initramfs_list), 1)
+        initramfs = initramfs_list[0]
+        modules_lists = []
+
+        if arguments.expected_modules_list:
+            modules_lists.append("modules.load")
+
+        if arguments.expected_modules_recovery_list:
+            modules_lists.append("modules.load.recovery")
+
+        if arguments.expected_modules_charger_list:
+            modules_lists.append("modules.load.charger")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            self._decompress_initramfs(initramfs, temp_dir)
+
+            lib_modules = pathlib.Path(temp_dir, "lib/modules")
+            self.assertTrue(lib_modules.is_dir())
+
+            for kernel_version in lib_modules.iterdir():
+                modules_dir = pathlib.Path(lib_modules, kernel_version)
+                self._verify_modules_dep_contains_modules_lists(modules_lists, modules_dir)
+
 if __name__ == '__main__':
     arguments, unknown = load_arguments()
     sys.argv[1:] = unknown