def process_project_version(self, project: Project, version: ProjectVersion): self.__logger.info(" - Version : %s", version.version_id) revision = "-" if project.repository.vcstype == "git": revision = version.revision + "~1" elif project.repository.vcstype == "svn": revision = str(int(version.revision) - 1) self.__logger.info(" Revision : %s", revision) checkout = version.get_checkout(self.__checkouts_path) if not checkout.exists(): self.__logger.info(" Checkout : not checked out") else: self.__logger.info(" Checkout : %s", checkout.checkout_dir) version_compile = version.get_compile(self.__compiles_path) if version_compile.needs_compile(): compile_state = "not compiled" elif version_compile.needs_compile_patterns(): compile_state = "project compiled, patterns not compiled" else: compile_state = "compiled" self.__logger.info(" Compile : %s", compile_state) super().process_project_version(project, version)
def process_project_version(self, project: Project, version: ProjectVersion): logger = logging.getLogger("compile") logger.info("Compiling %s...", version) logger.debug("- Force compile = %r", self.force_compile) logger = logging.getLogger("compile.tasks") project_compile = version.get_compile(self.compiles_base_path) build_path = join(project_compile.base_path, Compile.__BUILD_DIR) sources_path = join(build_path, version.source_dir) classes_path = join(build_path, version.classes_dir) needs_copy_sources = project_compile.needs_copy_sources() or self.force_compile needs_compile = project_compile.needs_compile() or self.force_compile if needs_copy_sources or needs_compile: logger.debug("Copying to build directory...") checkout_path = version.get_checkout(self.checkouts_base_path).checkout_dir self.__clean_copy(checkout_path, build_path) logger.debug("Copying additional resources...") self.__copy_additional_compile_sources(version, build_path) if not needs_copy_sources: logger.debug("Already copied project source.") else: try: logger.info("Copying project sources...") self.__clean_copy(sources_path, project_compile.original_sources_path) self.__copy_misuse_sources(sources_path, version.misuses, project_compile.misuse_source_path) except IOError as e: logger.error("Failed to copy project sources: %s", e) return self.skip(version) if not version.compile_commands: logger.warn("Skipping compilation: not configured.") return self.skip(version) if not needs_compile: logger.info("Already compiled project.") else: try: logger.info("Compiling project...") self._compile(version.compile_commands, build_path) logger.debug("Copying project classes...") self.__clean_copy(classes_path, project_compile.original_classes_path) self.__copy_misuse_classes(classes_path, version.misuses, project_compile.misuse_classes_path) except CommandFailedError as e: logger.error("Compilation failed: %s", e) return self.skip(version) except FileNotFoundError as e: logger.error("Failed to copy classes: %s", e) return self.skip(version) if not version.patterns: logger.info("Skipping pattern compilation: no patterns.") return self.ok() needs_copy_pattern_sources = project_compile.needs_copy_pattern_sources() or self.force_compile needs_compile_patterns = project_compile.needs_compile_patterns() or self.force_compile if needs_copy_pattern_sources or needs_compile_patterns: logger.debug("Copying to build directory...") checkout_path = version.get_checkout(self.checkouts_base_path).checkout_dir self.__clean_copy(checkout_path, build_path) logger.debug("Copying additional resources...") self.__copy_additional_compile_sources(version, build_path) if not needs_copy_pattern_sources: logger.debug("Already copied pattern sources.") else: try: logger.info("Copying pattern sources...") self.__copy_pattern_sources(version.misuses, project_compile) except IOError as e: logger.error("Failed to copy pattern sources: %s", e) return self.skip(version) if not needs_compile_patterns: logger.info("Already compiled patterns.") else: try: logger.debug("Copying patterns to source directory...") self.__copy(version.patterns, sources_path) logger.info("Compiling patterns...") self._compile(version.compile_commands, build_path) logger.debug("Copying pattern classes...") self.__copy_pattern_classes(version.misuses, classes_path, project_compile) except FileNotFoundError as e: remove_tree(project_compile.pattern_classes_base_path) logger.error("Compilation failed: %s", e) return self.skip(version) except CommandFailedError as e: logger.error("Compilation failed: %s", e) return self.skip(version) return self.ok()
class TestProjectVersion: # noinspection PyAttributeOutsideInit def setup(self): self.temp_dir = mkdtemp(prefix="mubench-test-project-version_") self.project_id = "project" self.version_id = "v1" self.uut = ProjectVersion(self.temp_dir, self.project_id, self.version_id) def teardown(self): remove_tree(self.temp_dir) def test_sets_path(self): assert_equals(join(self.temp_dir, self.project_id, Project.VERSIONS_DIR, self.version_id), self.uut.path) def test_rejects_non_project_version_directory(self): assert not ProjectVersion.is_project_version(self.temp_dir) def test_accepts_project_version_directory(self): create_file(self.uut._version_file) assert ProjectVersion.is_project_version(self.uut.path) def test_reads_version_file(self): test_dict = {"revision": "42"} with safe_open(self.uut._version_file, 'w+') as stream: yaml.dump(test_dict, stream) assert_equals(test_dict, self.uut._yaml) def test_finds_misuses(self): misuse = create_misuse("1", project=create_project(self.project_id, base_path=self.temp_dir)) create_file(misuse.misuse_file) self.uut._YAML = {"misuses": ["1"]} actual_misuses = self.uut.misuses assert_equals([misuse], actual_misuses) def test_version_without_misuse(self): self.uut._YAML = {"misuses": None} actual_misuses = self.uut.misuses assert_equals([], actual_misuses) def test_finds_only_own_misuses(self): project = create_project(self.project_id, base_path=self.temp_dir) misuse1 = create_misuse("1", project=project) create_file(misuse1.misuse_file) misuse2 = create_misuse("2", project=project) create_file(misuse2.misuse_file) self.uut._YAML = {"misuses": ["2"]} misuses = self.uut.misuses assert_equals([misuse2], misuses) def test_creates_build_config(self): self.uut._YAML = {"build": {"src": "src/java/", "commands": ["mvn compile"], "classes": "target/classes/"}} assert_equals("src/java/", self.uut.source_dir) assert_equals(["mvn compile"], self.uut.compile_commands) assert_equals("target/classes/", self.uut.classes_dir) def test_creates_build_config_with_defaults(self): self.uut._YAML = {} assert_equals("", self.uut.source_dir) assert_equals([], self.uut.compile_commands) assert_equals("", self.uut.classes_dir) def test_id(self): assert_equals("{}.{}".format(self.project_id, self.version_id), self.uut.id) def test_derives_additional_compile_sources_path(self): assert_equals(join(self.uut.path, "compile"), self.uut.additional_compile_sources) def test_derives_compile_base_path(self): self.uut._MISUSES = [create_misuse("m")] # prevent version from loading misuses project_compile = self.uut.get_compile("/base/path") assert_equals(join("/base/path", self.project_id, self.version_id), project_compile.base_path)