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())