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_finds_versions(self):
version = create_version("v1", project=self.uut)
create_file(version._version_file)
versions = self.uut.versions
assert_equals([version], versions)
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 test_copies_original_sources(self):
self.mock_with_fake_compile()
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_copies_additional_sources(self):
self.mock_with_fake_compile()
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 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_skips_compile_if_classes_exist(self):
self.mock_with_fake_compile()
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):
self.mock_with_fake_compile()
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_filters_blacklisted(self):
project = create_project("-id-", base_path=self.temp_dir)
create_file(project._project_file)
uut = CollectProjectsTask(self.temp_dir)
actual = uut.run(DataEntityLists([], ["-id-"]))
assert_equals([], actual)
def test_copies_misuse_sources(self):
self.mock_with_fake_compile()
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 create_classes(source, destination, _):
for root, dirs, files in os.walk(source):
package = relpath(root, source)
for file in files:
file = file.replace(".java", ".class")
create_file(join(destination, package, file))
print("fake compile: {}".format(
join(destination, package, file)))
def setup(self):
self.temp_dir = mkdtemp(prefix="mubench-correct_usage-test_")
self.orig_dir = join(join(self.temp_dir, "origin"))
makedirs(self.orig_dir, exist_ok=True)
self.correct_usage_file_name = "correct_usage.java"
self.correct_usage_file_path = join(self.temp_dir,
self.correct_usage_file_name)
create_file(self.correct_usage_file_path)
def setup(self):
self.checkouts_path = mkdtemp(prefix="mubench-checkout-local_")
self.data_path = mkdtemp(prefix="mubench-checkout-local-data_")
self.data_file_name = "some.file"
create_file(join(self.data_path, "repo", self.data_file_name))
self.uut = SyntheticProjectCheckout("-project-", "-id-",
self.data_path,
self.checkouts_path)
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_forces_compile(self):
self.mock_with_fake_compile()
makedirs(self.original_classes_path)
create_file(join(self.source_path, "some.file"))
makedirs(self.pattern_classes_path)
self.uut.force_compile = True
self.uut.process_project_version(self.project, self.version)
assert exists(join(self.original_classes_path, "some.file"))
def mock_compile(commands: List[str], cwd: str, dep_dir: 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_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)
uut = CollectProjectsTask(self.temp_dir)
actual = uut.run(DataEntityLists([], []))
assert_equals([p1, p2], actual)
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 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 setup(self):
self.temp_dir = mkdtemp(prefix="mubench-compile-correct_usages-test_")
self.data_base_path = join(self.temp_dir, "data")
self.compile_base_path = join(self.temp_dir, "-compile-")
self.project = create_project("-project-",
base_path=self.data_base_path)
self.version = create_version("-version-", project=self.project)
self.correct_usage = CorrectUsage(
join(self.data_base_path, "-project-", "misuses", "-misuse-",
"correct-usages"), join("-package-", "-correct_usage-.java"))
create_file(self.correct_usage.path)
self.misuse = create_misuse("-misuse-",
project=self.project,
version=self.version,
correct_usages=[self.correct_usage],
meta={})
self.version._YAML = {
"build": {
"src": "src/java",
"classes": "target/classes"
}
}
self.compile = self.version.get_compile(self.compile_base_path)
self.compile.get_full_classpath = lambda: join(self.temp_dir,
"dependencies.jar")
create_file(
join(self.compile.original_sources_paths[0],
self.misuse.location.file))
self.misuse_compile = self.misuse.get_misuse_compile(
self.compile_base_path)
self.misuse.get_misuse_compile = lambda *_: self.misuse_compile
self.compile_patch = patch(
'tasks.implementations.compile_misuse.CompileMisuseTask._compile_correct_usages'
)
self.compile_mock = self.compile_patch.start()
def create_classes(source, destination, _):
for root, dirs, files in os.walk(source):
package = relpath(root, source)
for file in files:
file = file.replace(".java", ".class")
create_file(join(destination, package, file))
print("fake compile: {}".format(
join(destination, package, file)))
self.compile_mock.side_effect = create_classes
def test_copies_misuse_sources(self):
uut = CompileMisuseTask(self.compile_base_path, 0, force_compile=False)
create_file(join(self.compile.original_sources_paths[0], "mu.file"))
misuse = create_misuse("1",
meta={"location": {
"file": "mu.file"
}},
project=self.project,
version=self.version)
correct_usage_compile = uut.run(misuse, self.compile)
assert exists(join(correct_usage_compile.misuse_source_path,
"mu.file"))
def test_existent_misuse(self, _):
self.uut._report_unknown_misuse = MagicMock()
project = create_project("-project-", meta={})
version = create_version("-id-", meta={"misuses": ["-misuse-"]}, project=project)
project.path = mkdtemp(prefix="mubench_test-dataset-check_")
try:
misuse_yml_path = join(project.path, Project.MISUSES_DIR, "-misuse-", Misuse.MISUSE_FILE)
create_file(misuse_yml_path)
self.uut.run(project, version)
self.uut._report_unknown_misuse.assert_not_called()
finally:
remove_tree(project.path)
def test_zip_dir_contents(self):
src1 = join(self.temp_dir, "src1")
src2 = join(self.temp_dir, "src2")
create_file(join(src1, "file1"))
create_file(join(src2, "file2"))
sources = [src1, src2]
destination = join(self.temp_dir, "archive")
zip_dir_contents(sources, destination)
extract_destination = join(self.temp_dir, "extracted")
with zipfile.ZipFile(destination, 'r') as zip_file:
zip_file.extractall(extract_destination)
assert exists(join(extract_destination, "file1"))
assert exists(join(extract_destination, "file2"))
def test_copies_misuse_inner_classes(self):
self.mock_with_fake_compile()
def mock_compile(commands: List[str], cwd: str, dep_dir: str, compile_base_path: str, logger: Logger):
class_path = join(cwd, "classes")
makedirs(class_path, exist_ok=True)
create_file(join(class_path, "mu.class"))
create_file(join(class_path, "mu$1.class"))
create_file(join(class_path, "mu$Inner.class"))
self.uut._compile = MagicMock(side_effect=mock_compile)
create_file(join(self.source_path, "mu.java"))
self.version.misuses.append(create_misuse("1", meta={"location": {"file": "mu.java"}}, project=self.project))
self.uut.process_project_version(self.project, self.version)
assert exists(join(self.misuse_classes_path, "mu.class"))
assert exists(join(self.misuse_classes_path, "mu$1.class"))
assert exists(join(self.misuse_classes_path, "mu$Inner.class"))
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_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 create_pattern(self, filename):
pattern = Pattern(self.temp_dir, filename)
create_file(pattern.path)
return pattern
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]
