@SafeVarargs public final IssueDto insert(RuleDefinitionDto rule, ComponentDto project, ComponentDto file, Consumer<IssueDto>... populators) { IssueDto issue = newIssue(rule, project, file); stream(populators).forEach(p -> p.accept(issue)); return insertIssue(issue); }
private IssueDto newIssue() { RuleDto rule = db.rules().insertRule(newRuleDto()); return newDto(rule, file, project); }
@SafeVarargs public final IssueChangeDto insertChange(IssueDto issueDto, Consumer<IssueChangeDto>... populators) { IssueChangeDto dto = IssueTesting.newIssuechangeDto(issueDto); stream(populators).forEach(p -> p.accept(dto)); return insertChange(dto); }
@Test public void merge_confirmed_issues() { db.issues().insertIssue(IssueTesting.newIssue(rule, branch1Dto, fileOnBranch1Dto).setKee("issue1").setStatus(Issue.STATUS_CONFIRMED).setLine(1).setChecksum("checksum")); DefaultIssue newIssue = createIssue("issue2", rule.getKey(), Issue.STATUS_OPEN, null, new Date()); copier.tryMerge(FILE_1, Collections.singleton(newIssue)); ArgumentCaptor<DefaultIssue> issueToMerge = ArgumentCaptor.forClass(DefaultIssue.class); verify(issueLifecycle).mergeConfirmedOrResolvedFromShortLivingBranch(eq(newIssue), issueToMerge.capture(), eq("myBranch1")); assertThat(issueToMerge.getValue().key()).isEqualTo("issue1"); }
private IssueDto newIssue() { RuleDto rule = newRuleDto().setId(10); ComponentDto project = ComponentTesting.newPrivateProjectDto(OrganizationTesting.newOrganizationDto()); ComponentDto file = (newFileDto(project)); return newDto(rule, file, project); }
@SafeVarargs public final IssueDto insertIssue(OrganizationDto organizationDto, Consumer<IssueDto>... populators) { RuleDefinitionDto rule = db.rules().insert(); ComponentDto project = db.components().insertPrivateProject(organizationDto); ComponentDto file = db.components().insertComponent(newFileDto(project)); IssueDto issue = newIssue(rule, project, file); stream(populators).forEach(p -> p.accept(issue)); return insertIssue(issue); }
private IssueDto insertIssue() { RuleDto rule = ruleDbTester.insertRule(newRuleDto()); ComponentDto project = componentDbTester.insertPrivateProject(); ComponentDto file = componentDbTester.insertComponent(newFileDto(project)); return issueDbTester.insertIssue(newDto(rule, file, project)); }
@Test public void prefer_confirmed_issues_if_no_resolved() { db.issues().insertIssue(IssueTesting.newIssue(rule, branch1Dto, fileOnBranch1Dto).setKee("issue1").setStatus(Issue.STATUS_REOPENED).setLine(1).setChecksum("checksum")); db.issues().insertIssue(IssueTesting.newIssue(rule, branch2Dto, fileOnBranch2Dto).setKee("issue2").setStatus(Issue.STATUS_OPEN).setLine(1).setChecksum("checksum")); db.issues().insertIssue(IssueTesting.newIssue(rule, branch3Dto, fileOnBranch3Dto).setKee("issue3").setStatus(Issue.STATUS_CONFIRMED).setLine(1).setChecksum("checksum")); DefaultIssue newIssue = createIssue("newIssue", rule.getKey(), Issue.STATUS_OPEN, null, new Date()); copier.tryMerge(FILE_1, Collections.singleton(newIssue)); ArgumentCaptor<DefaultIssue> issueToMerge = ArgumentCaptor.forClass(DefaultIssue.class); verify(issueLifecycle).mergeConfirmedOrResolvedFromShortLivingBranch(eq(newIssue), issueToMerge.capture(), eq("myBranch3")); assertThat(issueToMerge.getValue().key()).isEqualTo("issue3"); }
private IssueDto newIssue() { RuleDto rule = db.rules().insertRule(newRuleDto()); ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); return newDto(rule, file, project); }
@Test public void prefer_older_issues() { Instant now = Instant.now(); db.issues().insertIssue(IssueTesting.newIssue(rule, branch1Dto, fileOnBranch1Dto).setKee("issue1").setStatus(Issue.STATUS_REOPENED).setLine(1).setChecksum("checksum") .setIssueCreationDate(Date.from(now.plus(2, ChronoUnit.SECONDS)))); db.issues().insertIssue(IssueTesting.newIssue(rule, branch2Dto, fileOnBranch2Dto).setKee("issue2").setStatus(Issue.STATUS_OPEN).setLine(1).setChecksum("checksum") .setIssueCreationDate(Date.from(now.plus(1, ChronoUnit.SECONDS)))); db.issues().insertIssue(IssueTesting.newIssue(rule, branch3Dto, fileOnBranch3Dto).setKee("issue3").setStatus(Issue.STATUS_OPEN).setLine(1).setChecksum("checksum") .setIssueCreationDate(Date.from(now))); DefaultIssue newIssue = createIssue("newIssue", rule.getKey(), Issue.STATUS_OPEN, null, new Date()); copier.tryMerge(FILE_1, Collections.singleton(newIssue)); ArgumentCaptor<DefaultIssue> issueToMerge = ArgumentCaptor.forClass(DefaultIssue.class); verify(issueLifecycle).mergeConfirmedOrResolvedFromShortLivingBranch(eq(newIssue), issueToMerge.capture(), eq("myBranch3")); assertThat(issueToMerge.getValue().key()).isEqualTo("issue3"); }
private IssueDto newIssue() { RuleDto rule = dbTester.rules().insertRule(newRuleDto()); ComponentDto project = dbTester.components().insertPrivateProject(); ComponentDto file = dbTester.components().insertComponent(newFileDto(project)); return newDto(rule, file, project); }
@Test public void prefer_resolved_issues() { db.issues().insertIssue(IssueTesting.newIssue(rule, branch1Dto, fileOnBranch1Dto).setKee("issue1").setStatus(Issue.STATUS_REOPENED).setLine(1).setChecksum("checksum")); db.issues().insertIssue(IssueTesting.newIssue(rule, branch2Dto, fileOnBranch2Dto).setKee("issue2").setStatus(Issue.STATUS_CONFIRMED).setLine(1).setChecksum("checksum")); db.issues().insertIssue(IssueTesting.newIssue(rule, branch3Dto, fileOnBranch3Dto).setKee("issue3").setStatus(Issue.STATUS_RESOLVED) .setResolution(Issue.RESOLUTION_FALSE_POSITIVE).setLine(1).setChecksum("checksum")); DefaultIssue newIssue = createIssue("newIssue", rule.getKey(), Issue.STATUS_OPEN, null, new Date()); copier.tryMerge(FILE_1, Collections.singleton(newIssue)); ArgumentCaptor<DefaultIssue> issueToMerge = ArgumentCaptor.forClass(DefaultIssue.class); verify(issueLifecycle).mergeConfirmedOrResolvedFromShortLivingBranch(eq(newIssue), issueToMerge.capture(), eq("myBranch3")); assertThat(issueToMerge.getValue().key()).isEqualTo("issue3"); }
private IssueDto newIssue() { RuleDto rule = db.rules().insertRule(newRuleDto()); ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); return newDto(rule, file, project); }
@Test public void do_nothing_if_no_new_issue() { db.issues().insertIssue(IssueTesting.newIssue(rule, branch1Dto, fileOnBranch1Dto).setKee("issue1").setStatus(Issue.STATUS_CONFIRMED).setLine(1).setChecksum("checksum")); copier.tryMerge(FILE_1, Collections.emptyList()); verifyZeroInteractions(issueLifecycle); }
private IssueDto newIssue() { RuleDto rule = dbTester.rules().insertRule(newRuleDto()); ComponentDto project = dbTester.components().insertPrivateProject(); ComponentDto file = dbTester.components().insertComponent(newFileDto(project)); return newDto(rule, file, project); }
@Test public void rule_id_is_set_on_updated_issue() { RuleDefinitionDto rule = db.rules().insert(); ComponentDto project = db.components().insertMainBranch(); ComponentDto module = db.components().insertComponent(newModuleDto(project)); ComponentDto file = db.components().insertComponent(newFileDto(module)); DefaultIssue issue = newIssue(rule, project, file).toDefaultIssue(); Collection<IssueDto> results = underTest.save(db.getSession(), singletonList(issue)); assertThat(results).hasSize(1); assertThat(results.iterator().next().getRuleId()).isEqualTo(rule.getId()); }
@Test public void sort_by_updated_at() { RuleDto rule = newRule(); OrganizationDto organization = db.organizations().insert(o -> o.setKey("my-org-2")); ComponentDto project = db.components().insertComponent(ComponentTesting.newPublicProjectDto(organization, "PROJECT_ID").setDbKey("PROJECT_KEY")); indexPermissions(); ComponentDto file = db.components().insertComponent(newFileDto(project, null, "FILE_ID").setDbKey("FILE_KEY")); dbClient.issueDao().insert(session, newDto(rule, file, project) .setKee("82fd47d4-b650-4037-80bc-7b112bd4eac1") .setIssueUpdateDate(parseDateTime("2014-11-02T00:00:00+0100"))); dbClient.issueDao().insert(session, newDto(rule, file, project) .setKee("82fd47d4-b650-4037-80bc-7b112bd4eac2") .setIssueUpdateDate(parseDateTime("2014-11-01T00:00:00+0100"))); dbClient.issueDao().insert(session, newDto(rule, file, project) .setKee("82fd47d4-b650-4037-80bc-7b112bd4eac3") .setIssueUpdateDate(parseDateTime("2014-11-03T00:00:00+0100"))); session.commit(); indexIssues(); TestResponse response = ws.newRequest() .setParam("sort", IssueQuery.SORT_BY_UPDATE_DATE) .setParam("asc", "false") .execute(); JsonElement parse = new JsonParser().parse(response.getInput()); assertThat(parse.getAsJsonObject().get("issues").getAsJsonArray()) .extracting(o -> o.getAsJsonObject().get("key").getAsString()) .containsExactly("82fd47d4-b650-4037-80bc-7b112bd4eac3", "82fd47d4-b650-4037-80bc-7b112bd4eac1", "82fd47d4-b650-4037-80bc-7b112bd4eac2"); }
@Test public void index_issue_in_non_main_branch() { RuleDefinitionDto rule = db.rules().insert(); ComponentDto project = db.components().insertPrivateProject(organization); ComponentDto branch = db.components().insertProjectBranch(project, b -> b.setKey("feature/foo")); ComponentDto dir = db.components().insertComponent(ComponentTesting.newDirectory(branch, "src/main/java/foo")); ComponentDto file = db.components().insertComponent(newFileDto(branch, dir, "F1")); IssueDto issue = db.issues().insertIssue(IssueTesting.newIssue(rule, branch, file)); underTest.indexOnStartup(emptySet()); IssueDoc doc = es.getDocuments(INDEX_TYPE_ISSUE, IssueDoc.class).get(0); assertThat(doc.getId()).isEqualTo(issue.getKey()); assertThat(doc.organizationUuid()).isEqualTo(organization.getUuid()); assertThat(doc.componentUuid()).isEqualTo(file.uuid()); assertThat(doc.projectUuid()).isEqualTo(branch.getMainBranchProjectUuid()); assertThat(doc.branchUuid()).isEqualTo(branch.uuid()); assertThat(doc.isMainBranch()).isFalse(); }
@Test public void changelog_of_file_move_contains_file_names() { RuleDto rule = db.rules().insertRule(newRuleDto()); OrganizationDto org = db.organizations().insert(); ComponentDto project = db.components().insertPrivateProject(org); ComponentDto file1 = db.components().insertComponent(newFileDto(project)); ComponentDto file2 = db.components().insertComponent(newFileDto(project)); IssueDto issueDto = db.issues().insertIssue(newDto(rule, file2, project)); userSession.logIn("john") .addMembership(org) .addProjectPermission(USER, project, file); db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setDiff("file", file1.uuid(), file2.uuid()).setCreationDate(new Date())); ChangelogWsResponse result = call(issueDto.getKey()); assertThat(result.getChangelogList()).hasSize(1); assertThat(result.getChangelogList().get(0).hasUser()).isFalse(); assertThat(result.getChangelogList().get(0).getCreationDate()).isNotEmpty(); assertThat(result.getChangelogList().get(0).getDiffsList()).extracting(Diff::getKey, Diff::getOldValue, Diff::getNewValue) .containsOnly(tuple("file", file1.longName(), file2.longName())); }
@Test public void indexing_recovers_multiple_errors_on_the_same_project() { RuleDefinitionDto rule = db.rules().insert(); ComponentDto project = db.components().insertPrivateProject(organization); ComponentDto file = db.components().insertComponent(newFileDto(project)); IssueDto issue1 = db.issues().insertIssue(IssueTesting.newIssue(rule, project, file)); IssueDto issue2 = db.issues().insertIssue(IssueTesting.newIssue(rule, project, file)); es.lockWrites(INDEX_TYPE_ISSUE); IndexingResult result = indexProject(project.uuid(), ProjectIndexer.Cause.PROJECT_DELETION); assertThat(result.getTotal()).isEqualTo(2L); assertThat(result.getFailures()).isEqualTo(2L); // index is still read-only, fail to recover result = recover(); assertThat(result.getTotal()).isEqualTo(2L); assertThat(result.getFailures()).isEqualTo(2L); assertThatIndexHasSize(0); es.unlockWrites(INDEX_TYPE_ISSUE); result = recover(); assertThat(result.getTotal()).isEqualTo(2L); assertThat(result.getFailures()).isEqualTo(0L); assertThatIndexHasSize(2); assertThatEsQueueTableHasSize(0); }