Allow using a Dockerfile for building and running tests (#253)

* Allow using a Dockerfile for building and running tests

* Update cpm version to 1.8.0

Co-authored-by: Jordi Sanchez <[email protected]>

Author: jorsanpe

cpm/domain/project/project_composer.py

@@ -25,8 +25,9 @@ def compose_target(target_name, project_descriptor):
     target.include_directories.update(project_descriptor.build.includes)
     target.main = target_description.main
     target.image = target_description.image
-    target.test_image = target_description.test_image
     target.dockerfile = target_description.dockerfile
+    target.test_image = target_description.test_image
+    target.test_dockerfile = target_description.test_dockerfile
     target.toolchain_prefix = target_description.toolchain_prefix
     target.post_build = target_description.post_build
     compose_packages(project_descriptor.build.packages, target)

cpm/domain/project/project_descriptor.py

@@ -46,6 +46,7 @@ class TargetDescription:
     dockerfile: str = ''
     image: str = ''
     test_image: str = ''
+    test_dockerfile: str = ''
     toolchain_prefix: str = ''
 
 

cpm/domain/project/project_descriptor_parser.py

@@ -40,8 +40,9 @@ def parse_targets(targets_description):
 def parse_target(target_name, target_description):
     target = TargetDescription(target_name)
     target.image = target_description.get('image', '')
-    target.test_image = target_description.get('test_image', '')
     target.dockerfile = target_description.get('dockerfile', '')
+    target.test_image = target_description.get('test_image', '')
+    target.test_dockerfile = target_description.get('test_dockerfile', '')
     target.toolchain_prefix = target_description.get('toolchain_prefix', '')
     target.format = target_description.get('format', 'binary')
     target.main = target_description.get('main', '')

cpm/domain/project_commands.py

@@ -30,16 +30,44 @@ def build_tests(self, project, files_or_dirs):
             self.__build_tests(project, [test.name for test in tests_to_run])
 
     def __build_tests(self, project, goals, post_build=''):
+        if project.target.test_image and project.target.test_dockerfile:
+            print('warning: both "test_image" and "test_dockerfile" options are specified, will use "test_image"')
         if project.target.test_image:
-            self.__build_using_image(project, project.target.test_image, goals, post_build)
+            self.__build_using_image(
+                project,
+                project.target.test_image,
+                goals,
+                post_build
+            )
+        elif project.target.test_dockerfile:
+            self.__build_using_dockerfile(
+                project,
+                project.target.test_dockerfile,
+                self.__test_image_name(project),
+                goals,
+                post_build
+            )
         else:
             self.__build_goal(goals)
 
     def __build(self, project, goals, post_build=''):
+        if project.target.image and project.target.dockerfile:
+            print('warning: both "image" and "dockerfile" options are specified, will use "image"')
         if project.target.image:
-            self.__build_using_image(project, project.target.image, goals, post_build)
+            self.__build_using_image(
+                project,
+                project.target.image,
+                goals,
+                post_build
+            )
         elif project.target.dockerfile:
-            self.__build_using_dockerfile(project, project.target.dockerfile, goals, post_build)
+            self.__build_using_dockerfile(
+                project,
+                project.target.dockerfile,
+                self.__build_image_name(project),
+                goals,
+                post_build
+            )
         else:
             self.__build_goal(goals)
 
@@ -61,10 +89,9 @@ def __build_using_image(self, project, image_name, goals, post_build):
             raise DockerImageNotFound(image_name)
         self.__build_inside_container(client, project, image_name, goals, post_build)
 
-    def __build_using_dockerfile(self, project, dockerfile, goals, post_build):
+    def __build_using_dockerfile(self, project, dockerfile, image_name, goals, post_build):
         client = docker.from_env()
         print(f'building image from {dockerfile}')
-        image_name = f'{project.name}_cpm_build'
         with open(dockerfile, 'rb') as fileobj:
             client.images.build(path='.', fileobj=fileobj, tag=image_name)
         self.__build_inside_container(client, project, image_name, goals, post_build)
@@ -92,10 +119,28 @@ def __build_inside_container(self, client, project, image_name, goals, post_buil
             raise BuildError
         container.remove()
 
+    def __build_image_name(self, project):
+        return f'{project.name}_cpm_build'
+
+    def __test_image_name(self, project):
+        return f'{project.name}_cpm_test'
+
     def run_tests(self, project, files_or_dirs, test_args=()):
         tests_to_run = project.test.test_suites if not files_or_dirs else self.tests_from_args(project, files_or_dirs)
         if project.target.test_image:
-            test_results = self.__run_tests_inside_container(project, tests_to_run, test_args)
+            test_results = self.__run_tests_using_image(
+                project,
+                project.target.test_image,
+                tests_to_run,
+                test_args
+            )
+        elif project.target.test_dockerfile:
+            test_results = self.__run_tests_using_dockerfile(
+                project,
+                self.__test_image_name(project),
+                tests_to_run,
+                test_args
+            )
         else:
             test_results = [self.run_test(test.name, test_args) for test in tests_to_run]
         if any(result != 0 for result in test_results):
@@ -109,9 +154,8 @@ def run_test(self, executable, test_args):
             print(f'{executable} failed with {result.returncode} ({signal.Signals(-result.returncode).name})')
         return result.returncode
 
-    def __run_tests_inside_container(self, project, tests_to_run, test_args):
+    def __run_tests_using_image(self, project, image_name, tests_to_run, test_args):
         client = docker.from_env()
-        image_name = project.target.test_image
         try:
             client.images.pull(image_name)
         except docker.errors.ImageNotFound:
@@ -120,6 +164,10 @@ def __run_tests_inside_container(self, project, tests_to_run, test_args):
             raise DockerImageNotFound(image_name)
         return [self.__run_test_inside_container(project, client, image_name, test.name, test_args) for test in tests_to_run]
 
+    def __run_tests_using_dockerfile(self, project, image_name, tests_to_run, test_args):
+        client = docker.from_env()
+        return [self.__run_test_inside_container(project, client, image_name, test.name, test_args) for test in tests_to_run]
+
     def __run_test_inside_container(self, project, client, image_name, executable, test_args):
         container = client.containers.run(
             image_name,
@@ -129,6 +177,8 @@ def __run_test_inside_container(self, project, client, image_name, executable, t
             user=f'{os.getuid()}:{os.getgid()}',
             detach=True
         )
+        for log in container.logs(stream=True):
+            sys.stdout.write(log.decode())
         exit_code = container.wait()
         result = exit_code['StatusCode']
         container.remove()

scripts/cpm

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3.7
+#!/usr/bin/env python3
 import cpm
 
 cpm.main()

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = cpm-cli
-version = 1.7.0
+version = 1.8.0
 description = Chromos Package Manager
 long_description = file: README.md
 long_description_content_type = text/markdown

test/domain/test_project_composer.py

@@ -99,6 +99,7 @@ def test_should_compose_project_from_project_description_with_one_target_build_p
                     'main': 'main.c',
                     'image': 'cpmbits/docker',
                     'test_image': 'cpmbits/docker_test',
+                    'test_dockerfile': 'test.Dockerfile',
                     'toolchain_prefix': 'arm-linux-gnueabi-'
                 }
             }
@@ -119,6 +120,7 @@ def test_should_compose_project_from_project_description_with_one_target_build_p
         assert project.target.main == 'main.c'
         assert project.target.image == 'cpmbits/docker'
         assert project.target.test_image == 'cpmbits/docker_test'
+        assert project.target.test_dockerfile == 'test.Dockerfile'
         assert project.target.toolchain_prefix == 'arm-linux-gnueabi-'
 
     @mock.patch('cpm.domain.project.project_composer.filesystem')

test/domain/test_project_descriptor_parser.py

@@ -86,6 +86,7 @@ def test_parse_project_descriptor_with_default_target_image(self):
                     'image': 'cpmbits/bender',
                     'main': 'main.c',
                     'test_image': 'cpmbits/bender_test',
+                    'test_dockerfile': 'test.Dockerfile',
                     'toolchain_prefix': 'arm-linux-gnueabi-'
                 }
             }
@@ -97,6 +98,7 @@ def test_parse_project_descriptor_with_default_target_image(self):
                 image='cpmbits/bender',
                 main='main.c',
                 test_image='cpmbits/bender_test',
+                test_dockerfile='test.Dockerfile',
                 toolchain_prefix='arm-linux-gnueabi-'
             )
         }

test/e2e/test_cpm.py

@@ -113,6 +113,17 @@ def test_run_tests_from_docker_image(self):
         result = test.execute([])
         assert result.status_code == 0
 
+    def test_run_tests_using_dockerfile(self):
+        os.chdir(self.PROJECT_DIRECTORY)
+        self.add_bit('test', 'cest', '1.0')
+        self.set_target_image('default', 'cpmbits/ubuntu:20.04')
+        self.set_target_test_dockerfile('default', f'../environment/Dockerfile')
+        self.set_test_ldflags(['-Wl,-s'])
+        self.add_test('test_case.cpp')
+        install.execute(['-s', 'http://localhost:8000'])
+        result = test.execute([])
+        assert result.status_code == 0
+
     def test_build_from_docker_image_with_non_default_target(self):
         os.chdir(self.PROJECT_DIRECTORY)
         self.set_target_image('ubuntu', 'cpmbits/ubuntu:20.04')
@@ -268,6 +279,11 @@ def set_target_dockerfile(self, target_name, dockerfile):
             lambda descriptor: descriptor.setdefault('targets', {}).setdefault(target_name, {}).update({'dockerfile': dockerfile})
         )
 
+    def set_target_test_dockerfile(self, target_name, dockerfile):
+        self.modify_descriptor(
+            lambda descriptor: descriptor.setdefault('targets', {}).setdefault(target_name, {}).update({'test_dockerfile': dockerfile})
+        )
+
     def set_target_ldflags(self, target_name, ldflags):
         self.modify_descriptor(
             lambda descriptor: descriptor.setdefault('targets', {}).setdefault(target_name, {}).update({'ldflags': ldflags})