def test_skips_compile_if_classes_exist(self):
makedirs(self.original_classes_path)
create_file(join(self.source_path, "some.file"))
self.uut.process_project_version(self.project, self.version)
assert not exists(join(self.original_classes_path, "some.file"))
def test_forces_clean_copy_of_original_sources(self):
create_file(join(self.original_sources_path, "old.file"))
self.uut.force_compile = True
self.uut.process_project_version(self.project, self.version)
assert not exists(join(self.original_sources_path, "old.file"))
def test_skips_copy_of_original_sources_if_copy_exists(self):
makedirs(self.original_sources_path)
create_file(join(self.source_path, "b.file"))
self.uut.process_project_version(self.project, self.version)
assert not exists(join(self.original_sources_path, "b.file"))
def test_finds_versions(self):
version = create_version("v1", project=self.uut)
create_file(version._version_file)
versions = self.uut.versions
assert_equals([version], versions)
def test_exists(self):
checkout_path = join(self.checkouts_dir, "-project-", "-version-",
"checkout")
create_file(join(checkout_path, "bundle.zip"))
create_file(join(checkout_path, "foo"))
assert self.uut.exists()
def test_copies_misuse_sources(self):
create_file(join(self.source_path, "mu.file"))
self.version.misuses.append(create_misuse("1", meta={"location": {"file": "mu.file"}}, project=self.project))
self.uut.process_project_version(self.project, self.version)
assert exists(join(self.misuse_source_path, "mu.file"))
def setup(self):
self.tmp = mkdtemp()
self.remote_file = join(self.tmp, "remote.file")
create_file(self.remote_file)
self.url = Path(self.remote_file).as_uri()
self.target = join(self.tmp, "local.file")
def setup(self):
self.temp_dir = mkdtemp(prefix="mubench-pattern-test_")
self.orig_dir = join(join(self.temp_dir, "origin"))
makedirs(self.orig_dir, exist_ok=True)
self.pattern_file_name = "pattern.java"
self.pattern_file_path = join(self.temp_dir, self.pattern_file_name)
create_file(self.pattern_file_path)
def test_forces_copy_of_original_sources(self):
makedirs(self.original_sources_path)
create_file(join(self.source_path, "a.file"))
self.uut.force_compile = True
self.uut.process_project_version(self.project, self.version)
assert exists(join(self.original_sources_path, "a.file"))
def test_delete(self):
checkout_path = join(self.checkouts_dir, "-project-", "-version-", "checkout")
create_file(join(checkout_path, "bundle.zip"))
create_file(join(checkout_path, "foo"))
self.uut.delete()
assert not exists(checkout_path)
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_finds_all_projects(self):
p1 = create_project("p1", base_path=self.temp_dir)
create_file(p1._project_file)
p2 = create_project("p2", base_path=self.temp_dir)
create_file(p2._project_file)
self.uut.run()
assert_equals([call(p1), call(p2)], self.test_task.process_project.call_args_list)
def mock_compile(commands: List[str], cwd: str):
source_path = join(cwd, self.source_dir)
class_path = join(cwd, "classes")
makedirs(class_path, exist_ok=True)
for root, dirs, files in os.walk(source_path):
package = relpath(root, source_path)
for file in files:
file = file.replace(".java", ".class")
create_file(join(class_path, package, file))
print("fake compile: {}".format(join(class_path, package, file)))
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_removes_folder_completely(self):
create_file(join(self.temp_dir, "dir1", "dir2", "file1"))
create_file(join(self.temp_dir, "dir1", "file2"))
create_file(join(self.temp_dir, "file3"))
remove_tree(self.temp_dir)
assert not exists(self.temp_dir)
def test_copies_tree(self):
src = join(self.temp_dir, "src")
file1 = join("dir1", "dir2", "file1")
file2 = join("dir1", "file2")
file3 = join("file3")
create_file(join(src, file1))
create_file(join(src, file2))
create_file(join(src, file3))
copy_tree(src, self.temp_dir)
assert exists(join(self.temp_dir, file1))
assert exists(join(self.temp_dir, file2))
assert exists(join(self.temp_dir, file3))
def test_invalid_if_md5_mismatch(self):
create_file(self.file)
with assert_raises(ValueError):
validate_file(self.file, ":wrong-md5:")
def test_valid_if_exists(self):
create_file(self.file)
validate_file(self.file)
def test_is_valid(self):
create_file(self.file)
assert is_valid_file(self.file)
def test_accepts_project_path(self):
create_file(join(self.project_path, Project.PROJECT_FILE))
assert Project.is_project(self.project_path)
def test_ignores_non_project_directories(self):
create_file(join(self.temp_dir, "p1", "iamnotaproject.yml"))
self.uut.run()
self.test_task.process_project.assert_not_called()
def test_copies_additional_sources(self):
create_file(join(self.version_path, "compile", "additional.file"))
self.uut.process_project_version(self.project, self.version)
assert exists(join(self.build_path, "additional.file"))
def create_misuse_with_pattern(self, misuse_id, pattern_file):
misuse = create_misuse(misuse_id, project=self.project)
create_file(join(self.source_path, misuse.location.file))
misuse._PATTERNS = {self.create_pattern(pattern_file)}
self.version._MISUSES = [misuse]
def test_copies_original_sources(self):
create_file(join(self.source_path, "a.file"))
self.uut.process_project_version(self.project, self.version)
assert exists(join(self.original_sources_path, "a.file"))
def test_valid_by_md5(self):
create_file(self.file)
validate_file(self.file, EMPTY_FILE_MD5)
def test_valid_by_md5_file(self):
create_file(self.file)
md5_file = join(self.tmp, "my.md5")
safe_write(EMPTY_FILE_MD5, md5_file, append=False)
validate_file(self.file, md5_file)
def test_creates_file(self):
makedirs(dirname(self.test_file))
create_file(self.test_file)
assert exists(self.test_file)
def test_accepts_project_version_directory(self):
create_file(self.uut._version_file)
assert ProjectVersion.is_project_version(self.uut.path)
def create_pattern(self, filename):
pattern = Pattern(self.temp_dir, filename)
create_file(pattern.path)
return pattern
