def setup(self):
self.project = create_project("p1")
self.version1 = create_version("v1", project=self.project)
self.version2 = create_version("v2", project=self.project)
self.uut = ProjectVersionTask()
self.uut.black_list = []
self.uut.white_list = []
self.uut.process_project_version = MagicMock()
def test_publish_url(self, post_mock, snippets_mock):
misuse = create_misuse("-m-", project=self.project)
create_version("-v-", project=self.project, misuses=[misuse])
task = PublishMetadataTask("-compiles-path-", "http://test.url")
task.process_project_misuse(self.project, misuse)
task.end()
assert_equals(post_mock.call_args[0][0],
"http://test.url/api/upload/metadata")
def test_post_auth_provided(self, pass_mock, post_mock, snippets_mock):
misuse = create_misuse("-m-", project=self.project)
create_version("-v-", project=self.project, misuses=[misuse])
pass_mock.side_effect = UserWarning("should skip prompt")
task = PublishMetadataTask("-compiles-path-", "http://test.url",
"-username-", "-password-")
task.start() # should not ask for password, since already set
task.process_project_misuse(self.project, misuse)
task.end()
assert_equals(post_mock.call_args[1]["username"], "-username-")
assert_equals(post_mock.call_args[1]["password"], "-password-")
def test_white_list_misuse(self):
project = create_project("-p-")
misuse1 = create_misuse("-m1-", project=project)
misuse2 = create_misuse("-m2-", project=project)
version1 = create_version("-v1-", misuses=[misuse1], project=project)
create_version("-v2-", misuses=[misuse2], project=project)
self.uut.white_list = [misuse1.id]
self.uut.process_project(project)
assert_equals([call(project, version1)],
self.uut.process_project_version.call_args_list)
def test_post_auth_prompt(self, pass_mock, post_mock, snippets_mock):
misuse = create_misuse("-m-", project=self.project)
create_version("-v-", project=self.project, misuses=[misuse])
pass_mock.return_value = "-password-"
task = PublishMetadataTask("-compiles-path-", "http://test.url",
"-username-")
task.start() # should ask for password once
task.process_project_misuse(self.project, misuse)
task.end()
assert_equals(post_mock.call_args[1]["username"], "-username-")
assert_equals(post_mock.call_args[1]["password"], "-password-")
def test_white_list_misuse(self):
uut = ProjectMisuseTask()
uut.process_project_misuse = MagicMock()
project = create_project("-p-")
misuse1 = create_misuse("-m1-", project=project)
misuse2 = create_misuse("-m2-", project=project)
create_version("-v-", misuses=[misuse1, misuse2], project=project)
uut.white_list = [misuse1.id]
uut.process_project(project)
assert_equals([call(project, misuse1)],
uut.process_project_misuse.call_args_list)
def test_publishes_pattern_code_without_trailing_newlines(
self, read_mock, post_mock, snippets_mock):
pattern_code = "public class P1 {}"
read_mock.return_value = pattern_code + "\n\n\n"
misuse = create_misuse("-m-",
project=self.project,
patterns=[Pattern("/", "P1.java")])
create_version("-v-", project=self.project, misuses=[misuse])
task = PublishMetadataTask("-compiles-path-", "http://test.url")
task.process_project_misuse(self.project, misuse)
task.end()
assert_equals(
post_mock.call_args[0][1][0]["patterns"][0]["snippet"]["code"],
pattern_code)
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.project = create_project("-p-")
self.misuse = create_misuse("-m-", project=self.project)
self.version = create_version("-v-", project=self.project, misuses=[self.misuse],
meta={"build": {"src": "", "classes": ""}})
self.version_compile = self.version.get_compile("/sources")
self.test_detector_execution = MagicMock() # type: DetectorRun
self.test_detector_execution.is_success = lambda: False
self.test_detector_execution.is_error = lambda: False
self.test_detector_execution.is_timeout = lambda: False
self.test_detector_execution.runtime = 0
self.test_detector_execution.number_of_findings = 0
self.test_run_timestamp = 1337
self.test_detector_execution.get_run_info = lambda: {
'number_of_findings': self.test_detector_execution.number_of_findings,
'runtime': self.test_detector_execution.runtime,
'timestamp': self.test_run_timestamp
}
self.test_detector_execution.findings_path = "-findings-"
self.created_files_per_finding = dict()
self.detector = StubDetector() # type: Detector
self.detector.id = "test_detector"
self.experiment_id = "ex1"
self.test_potential_hits = PotentialHits([])
self.uut = PublishFindingsTask(self.experiment_id, "/sources", "http://dummy.url", "-username-", "-password-")
def test_misuses_none(self, _):
project = create_project("-project-", meta={})
version = create_version("-id-", meta={"misuses": None}, project=project)
self.uut.run(project, version)
self.uut._report_missing_key.assert_any_call("misuses", "-project-/versions/-id-/version.yml")
def setup(self):
self.temp_dir = mkdtemp(prefix="mubench-compile-test_")
self.project_path = join(self.temp_dir, "project")
self.version_path = join(self.project_path, "versions", "v0")
self.checkout_base_path = join(self.temp_dir, "checkouts")
self.compile_base_path = self.checkout_base_path
self.source_dir = "src"
self.project = create_project(self.project_path, meta={"repository": {"type": "git", "url": "-url-"}})
self.version = create_version(self.version_path, project=self.project,
meta={"build": {"src": self.source_dir,
"commands": ["mkdir classes"],
"classes": "classes"},
"revision": "0"},
misuses=[])
checkout = self.version.get_checkout(self.checkout_base_path)
self.checkout_path = checkout.checkout_dir
self.source_path = join(self.checkout_path, self.source_dir)
makedirs(self.source_path)
self.base_path = dirname(self.checkout_path)
self.build_path = join(self.base_path, "build")
self.original_sources_path = join(self.base_path, "original-src")
self.original_classes_path = join(self.base_path, "original-classes")
self.misuse_source_path = join(self.base_path, "misuse-src")
self.misuse_classes_path = join(self.base_path, "misuse-classes")
self.pattern_sources_path = join(self.base_path, "patterns-src")
self.pattern_classes_path = join(self.base_path, "patterns-classes")
self.dep_path = join(self.base_path, "dependencies")
self.uut = Compile(self.checkout_base_path, self.compile_base_path, False, False)
def setup(self):
self.dataset = "-d-"
self.project = create_project("-p-")
self.misuse = create_misuse("-m-", project=self.project)
self.version = create_version("-v-",
project=self.project,
misuses=[self.misuse])
self.test_run = Run([MagicMock()])
self.test_run.is_success = lambda: False
self.test_run.is_error = lambda: False
self.test_run.is_timeout = lambda: False
self.test_run.get_runtime = lambda: 0
self.test_run.get_number_of_findings = lambda: 0
self.detector = StubDetector() # type: Detector
self.detector.id = "test_detector"
self.experiment = MagicMock() # type: Experiment
self.experiment.id = "test_experiment"
self.experiment.get_run = lambda v: self.test_run
self.experiment.detector = self.detector
self.uut = PublishFindingsTask(self.experiment, self.dataset,
"/sources", "http://dummy.url",
"-username-")
def setup(self):
self.temp_dir = mkdtemp(prefix='mubench-detect-test_')
self.compiles_path = join(self.temp_dir, "checkout")
self.findings_path = join(self.temp_dir, "findings")
os.chdir(self.temp_dir)
self.project = create_project("-project-")
self.version = create_version("-version-", project=self.project)
self.detector = StubDetector()
self.test_run_execution = MineAndDetectExecution(
self.detector, self.version, self.findings_path,
AllFindings(self.detector))
self.test_run = Run([self.test_run_execution])
self.test_run.execute = MagicMock(
return_value="test execution successful")
self.experiment = Experiment(Experiment.TOP_FINDINGS, self.detector,
self.findings_path)
self.experiment.get_run = lambda v: self.test_run
self.uut = Detect(self.compiles_path, self.experiment, None, False)
self.last_invoke = None
# mock command-line invocation
def mock_invoke_detector(detect, absolute_misuse_detector_path: str,
detector_args: str):
self.last_invoke = absolute_misuse_detector_path, detector_args
def test_publishes_metadata(self, post_mock, snippets_mock):
misuse = create_misuse(
"-m-",
meta={
"description": "-description-",
"fix": {
"description": "-fix-description-",
"commit": "http://fake.diff/url"
},
"characteristics":
["-violation-type-1-", "-violation-type-2-"],
"location": {
"file": "/some/file.java",
"method": "-some.method()-"
}
},
project=self.project)
create_version("-v-", project=self.project, misuses=[misuse])
snippets_mock.return_value = [Snippet("-code-", 42)]
task = PublishMetadataTask("-compiles-path-", "http://test.url")
task.process_project_misuse(self.project, misuse)
task.end()
assert_equals(
post_mock.call_args[0][1],
[{
"project": self.project.id,
"version": "-v-",
"misuse": misuse.id,
"description": "-description-",
"fix": {
"description": "-fix-description-",
"diff-url": "http://fake.diff/url"
},
"violation_types":
["-violation-type-1-", "-violation-type-2-"],
"location": {
"file": "/some/file.java",
"method": "-some.method()-"
},
"target_snippets": [{
"first_line_number": 42,
"code": "-code-"
}],
"patterns": []
}])
def test_missing_misuses(self, _):
meta = {"revision": "1"}
project = create_project("-project-", meta={})
version = create_version("-id-", meta=meta, project=project)
self.uut.run(project, version)
self.uut._report_missing_key.assert_any_call("misuses", "-project-/versions/-id-/version.yml")
def test_missing_build_src(self, _):
meta = {"build": {}}
project = create_project("-project-", meta={})
version = create_version("-id-", meta=meta, project=project)
self.uut.run(project, version)
self.uut._report_missing_key.assert_any_call("build.src", "-project-/versions/-id-/version.yml")
def test_unknown_type(self):
version = create_version("-v-",
project=create_project(
"-p-",
meta={"repository": {
"type": "unknown"
}}))
assert_raises(ValueError, version.get_checkout, "-base_path-")
def test_empty_build_commands(self, _):
meta = {"build": {"commands": []}}
project = create_project("-project-", meta={})
version = create_version("-id-", meta=meta, project=project)
self.uut.run(project, version)
self.uut._report_missing_key.assert_any_call("build.commands", "-project-/versions/-id-/version.yml")
def test_non_existent_misuse(self, _):
self.uut._report_unknown_misuse = MagicMock()
project = create_project("-project-", meta={})
version = create_version("-id-", meta={"misuses": ["-misuse-"]}, project=project)
version._MISUSES = []
self.uut.run(project, version)
self.uut._report_unknown_misuse.assert_any_call(version.id, "-misuse-")
def test_no_warning_on_known_version(self):
project = create_project("-project-", meta=EMPTY_META)
version = create_version("-version-", project=project, meta=EMPTY_META)
self.uut.datasets = {"-dataset-": [version.id]}
self.uut.process_project_version(project, version)
self.uut.end()
self.uut._report_unknown_dataset_entry.assert_not_called()
def setup(self):
self.version = create_version("-version-", project=create_project("-project-"))
self.detector = StubDetector()
self.findings_base_path = "-findings-"
self.logger = logging.getLogger("test")
self.uut = DetectorExecutionTestImpl(DetectorMode.detect_only, self.detector, self.version,
self.findings_base_path, AllFindings())
def test_missing_build_commands(self):
meta = {"build": {}}
project = create_project("-project-", meta=EMPTY_META)
version = create_version("-id-", meta=meta, project=project)
self.uut.process_project_version(project, version)
self.uut._report_missing_key.assert_any_call(
"build.commands", "-project-/versions/-id-/version.yml")
def test_version_and_misuse_from_different_version_with_same_name(self):
self.uut._report_id_conflict = MagicMock()
project = create_project("-project-", meta=EMPTY_META)
misuse_with_conflict = create_misuse("-conflict-",
project=project,
meta=EMPTY_META)
version = create_version("-version-",
project=project,
misuses=[misuse_with_conflict],
meta=EMPTY_META)
version_with_conflict = create_version("-conflict-",
project=project,
misuses=[],
meta=EMPTY_META)
self.uut.process_project(project)
self.uut._report_id_conflict.assert_any_call("-project-.-conflict-")
def test_process_misuse(self):
uut = ProjectVersionMisuseTask()
uut.process_project_version_misuse = MagicMock()
project = create_project("p1")
m1 = create_misuse("m1")
m2 = create_misuse("m2")
m3 = create_misuse("m3")
v1 = create_version("v1", misuses=[m1, m2], project=project)
v2 = create_version("v2", misuses=[m3], project=project)
uut.process_project(project)
assert_equals([
call(project, v1, m1),
call(project, v1, m2),
call(project, v2, m3)
], uut.process_project_version_misuse.call_args_list)
def test_process_misuse(self):
uut = ProjectMisuseTask()
uut.process_project_misuse = MagicMock()
project = create_project("p1")
m1 = create_misuse("m1")
m2 = create_misuse("m2")
m3 = create_misuse("m3")
create_version("v1", misuses=[m1, m2], project=project)
create_version("v2", misuses=[m3], project=project)
uut.process_project(project)
actual_call = uut.process_project_misuse.call_args_list
assert_equals(3, len(actual_call))
assert_in(call(project, m1), actual_call)
assert_in(call(project, m2), actual_call)
assert_in(call(project, m3), actual_call)
def test_empty_misuses(self):
meta = {"misuses": []}
project = create_project("-project-", meta=EMPTY_META)
version = create_version("-id-", meta=meta, project=project)
self.uut.process_project_version(project, version)
self.uut._report_missing_key.assert_any_call(
"misuses", "-project-/versions/-id-/version.yml")
def test_creates_empty_execution_if_no_patterns(self):
detector = StubDetector()
project = create_project("-project-")
version = create_version("-version-", project=project)
experiment = ProvidedPatternsExperiment(detector, "-base-path-")
run = experiment.get_run(version)
assert not run.executions
def test_synthetic_no_revision(self, repository_mock):
meta = {"misuses": ["1"]}
project = create_project("-project-", meta={})
version = create_version("-id-", meta=meta, project=project)
repository_mock.vcstype = "synthetic"
self.uut.run(project, version)
assert call("revision", "-project-/versions/-id-/version.yml") \
not in self.uut._report_missing_key.call_args_list
def setUp(self):
self.checkout = ProjectCheckout("-url-", "-base_path-", "-name-")
self.checkout.create = MagicMock()
self.checkout.delete = MagicMock()
self.project = create_project("-project-")
self.version = create_version("-version-", project=self.project)
self.version.get_checkout = MagicMock(return_value=self.checkout)
self.uut = Checkout("-checkouts-", force_checkout=False, use_temp_dir=False)
def setup(self):
self.temp_dir = mkdtemp(prefix='mubench-run-test_')
self.findings_path = join(self.temp_dir, "-findings-")
self.detector = StubDetector()
self.version = create_version("-v-")
self.findings_base_path = "-findings-"
self.uut = DetectorExecutionTestImpl(DetectorMode.detect_only, self.detector, self.version,
self.findings_base_path, AllFindings())
