@Test
public void return_existing_uuids() {
setAnalysisMetadataHolder();
- ComponentDto project = insertComponent(newPrivateProjectDto("ABCD").setKey(REPORT_PROJECT_KEY));
+ ComponentDto project = dbTester.components().insertPrivateProject("ABCD", p -> p.setKey(REPORT_PROJECT_KEY));
ComponentDto directory = newDirectory(project, "CDEF", REPORT_DIR_PATH_1);
insertComponent(directory.setKey(REPORT_PROJECT_KEY + ":" + REPORT_DIR_PATH_1));
insertComponent(newFileDto(project, directory, "DEFG")
@Test
public void set_base_project_snapshot_when_last_snapshot_exist() {
setAnalysisMetadataHolder();
- ComponentDto project = insertComponent(newPrivateProjectDto("ABCD").setKey(REPORT_PROJECT_KEY));
+ ComponentDto project = dbTester.components().insertPrivateProject("ABCD", p -> p.setKey(REPORT_PROJECT_KEY));
insertSnapshot(newAnalysis(project).setLast(true));
reportReader.putComponent(component(ROOT_REF, PROJECT, REPORT_PROJECT_KEY));
@UseDataProvider("oneParameterNullNonNullCombinations")
public void set_projectVersion_to_previous_analysis_when_not_set(@Nullable String previousAnalysisProjectVersion) {
setAnalysisMetadataHolder();
- ComponentDto project = insertComponent(newPrivateProjectDto("ABCD").setKey(REPORT_PROJECT_KEY));
+ ComponentDto project = dbTester.components().insertPrivateProject("ABCD", p -> p.setKey(REPORT_PROJECT_KEY));
insertSnapshot(newAnalysis(project).setProjectVersion(previousAnalysisProjectVersion).setLast(true));
reportReader.putComponent(component(ROOT_REF, PROJECT, REPORT_PROJECT_KEY));
}
@Test
- public void select_by_keys() {
+ public void selectByKeys_whenPassingKeys_shouldReturnComponentsInMainBranch() {
ComponentDto project1 = db.components().insertPrivateProject();
ComponentDto branch = db.components().insertProjectBranch(project1);
ComponentDto project2 = db.components().insertPrivateProject();
}
@Test
- public void select_by_keys_throws_ISE_if_both_branch_and_pr_are_passed() {
+ public void selectByKeys_whenAppWithMultipleBranches_shouldReturnMainBranch() {
+ ProjectDto proj = db.components().insertPrivateProjectDto();
+ BranchDto projBranch = db.components().insertProjectBranch(proj);
+
+ ProjectDto app = db.components().insertPrivateApplicationDto();
+ BranchDto appBranch = db.components().insertProjectBranch(app);
+
+ db.components().addApplicationProject(app, proj);
+ db.components().addProjectBranchToApplicationBranch(appBranch, projBranch);
+
+ ComponentDto projInApp = db.components().insertComponent(newProjectCopy(db.components().getComponentDto(proj), db.components().getComponentDto(app)));
+ db.components().insertComponent(ComponentTesting.newProjectCopy(db.components().getComponentDto(projBranch), db.components().getComponentDto(appBranch)));
+
+ List<ComponentDto> results = underTest.selectByKeys(dbSession, asList(projInApp.getKey()));
+
+ assertThat(results)
+ .extracting(ComponentDto::uuid, ComponentDto::getKey)
+ .containsOnly(tuple(projInApp.uuid(), projInApp.getKey()));
+ }
+
+ @Test
+ public void selectByKeys_whenBranchMissingDueToCorruption_shouldNotReturnComponents() {
+ // this will create an entry in the components table, but not in the project_branches table
+ ComponentDto project1 = db.components().insertComponent(ComponentTesting.newPublicProjectDto());
+
+ List<ComponentDto> results = underTest.selectByKeys(dbSession, asList(project1.getKey()));
+
+ assertThat(results)
+ .extracting(ComponentDto::uuid, ComponentDto::getKey)
+ .isEmpty();
+ }
+
+ @Test
+ public void selectByKeys_whenPortfolio_shouldReturnIt() {
+ ComponentDto portfolio = db.components().insertPrivatePortfolio();
+
+ List<ComponentDto> results = underTest.selectByKeys(dbSession, asList(portfolio.getKey()));
+
+ assertThat(results)
+ .extracting(ComponentDto::uuid, ComponentDto::getKey)
+ .containsExactlyInAnyOrder(tuple(portfolio.uuid(), portfolio.getKey()));
+ }
+
+ @Test
+ public void selectByKeys_whenSubPortfolio_shouldReturnIt() {
+ ComponentDto portfolio = db.components().insertPrivatePortfolio();
+ ComponentDto subPortfolio = db.components().insertSubView(portfolio);
+
+ List<ComponentDto> results = underTest.selectByKeys(dbSession, asList(subPortfolio.getKey()));
+
+ assertThat(results)
+ .extracting(ComponentDto::uuid, ComponentDto::getKey)
+ .containsExactlyInAnyOrder(tuple(subPortfolio.uuid(), subPortfolio.getKey()));
+ }
+
+ @Test
+ public void selectByKeys_whenBothBranchAndPrPassed_shouldThrowISE() {
DbSession session = db.getSession();
List<String> keys = List.of("key");
assertThatThrownBy(() -> underTest.selectByKeys(session, keys, "branch", "pr"))
}
@Test
- public void select_by_keys_with_branch() {
+ public void selectByKeys_whenSpecifyingBranch_shouldReturnComponentsInIt() {
String branchKey = "my_branch";
ComponentDto project = db.components().insertPublicProject();
ComponentDto branch = db.components().insertProjectBranch(project, b -> b.setKey(branchKey));
}
@Test
- public void select_by_keys_with_pr() {
+ public void selectByKeys_whenSpecifyingPR_shouldReturnComponentsInIt() {
String prKey = "my_branch";
ComponentDto project = db.components().insertPublicProject();
ComponentDto pr = db.components().insertProjectBranch(project, b -> b.setKey(prKey).setBranchType(PULL_REQUEST));
@Test
public void selectByQuery_filter_on_visibility() {
- db.components().insertComponent(newPrivateProjectDto().setKey("private-key"));
- db.components().insertComponent(ComponentTesting.newPublicProjectDto().setKey("public-key"));
+ db.components().insertPrivateProject(p -> p.setKey("private-key"));
+ db.components().insertPublicProject(p -> p.setKey("public-key"));
ComponentQuery privateProjectsQuery = ComponentQuery.builder().setPrivate(true).setQualifiers(PROJECT).build();
ComponentQuery publicProjectsQuery = ComponentQuery.builder().setPrivate(false).setQualifiers(PROJECT).build();
@Test
public void selectByQuery_on_component_keys() {
- ComponentDto sonarqube = db.components().insertComponent(newPrivateProjectDto());
- ComponentDto jdk8 = db.components().insertComponent(newPrivateProjectDto());
- ComponentDto cLang = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto sonarqube = db.components().insertPrivateProject();
+ ComponentDto jdk8 = db.components().insertPrivateProject();
+ ComponentDto cLang = db.components().insertPrivateProject();
ComponentQuery query = ComponentQuery.builder().setQualifiers(PROJECT)
.setComponentKeys(newHashSet(sonarqube.getKey(), jdk8.getKey())).build();
@Test
public void selectByQuery_on_component_uuids() {
- ComponentDto sonarqube = db.components().insertComponent(newPrivateProjectDto());
- ComponentDto jdk8 = db.components().insertComponent(newPrivateProjectDto());
- ComponentDto cLang = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto sonarqube = db.components().insertPrivateProject();
+ ComponentDto jdk8 = db.components().insertPrivateProject();
+ ComponentDto cLang = db.components().insertPrivateProject();
ComponentQuery query = ComponentQuery.builder().setQualifiers(PROJECT)
.setComponentUuids(newHashSet(sonarqube.uuid(), jdk8.uuid())).build();
p.created_at as createdAt
</sql>
+ <sql id="mainBranchOrPortfolio">
+ (pb.is_main = ${_true} OR (pb.uuid is NULL AND (p.qualifier IN ('VW', 'SVW') OR (p.qualifier = 'TRK' AND p.scope = 'FIL'))))
+ </sql>
+
<select id="selectByKey" parameterType="String" resultType="Component">
SELECT
<include refid="componentColumns"/>
left outer join project_branches pb on pb.uuid = p.branch_uuid
where
p.kee=#{key,jdbcType=VARCHAR}
- and (pb.is_main = null or pb.is_main = ${_true}) </select>
+ and <include refid="mainBranchOrPortfolio"/>
+ </select>
<select id="selectByKeyCaseInsensitive" parameterType="String" resultType="Component">
SELECT
inner join project_branches pb on pb.uuid = p.branch_uuid
where
lower(p.kee)=lower(#{key,jdbcType=VARCHAR})
- and pb.is_main = ${_true}
+ and <include refid="mainBranchOrPortfolio"/>
</select>
<select id="selectByKeyAndBranchKey" parameterType="String" resultType="Component">
AND pb.branch_type = 'PULL_REQUEST'
</when>
<otherwise>
- AND (pb.is_main = ${_true} OR p.qualifier IN ('VW', 'SVW') OR (p.qualifier = 'TRK' AND p.scope = 'FIL'))
+ AND <include refid="mainBranchOrPortfolio"/>
</otherwise>
</choose>
</select>
AND pb.branch_type = 'PULL_REQUEST'
</when>
<otherwise>
- AND (pb.is_main = ${_true} OR p.qualifier IN ('VW', 'SVW') OR (p.qualifier = 'TRK' AND p.scope = 'FIL'))
+ AND <include refid="mainBranchOrPortfolio"/>
</otherwise>
</choose>
</select>
left join project_branches pb on pb.uuid = p.branch_uuid
where
p.enabled=${_true}
- AND (pb.uuid is null or pb.is_main=${_true})
+ AND <include refid="mainBranchOrPortfolio"/>
AND p.copy_component_uuid is null
<if test="query.qualifiers!=null">
and p.qualifier in
AND pb.branch_type = 'PULL_REQUEST'
</when>
<otherwise>
- (pb.uuid is null or pb.is_main = ${_true})
+ <include refid="mainBranchOrPortfolio"/>
</otherwise>
</choose>
</select>
where
p.enabled=${_true}
and p.copy_component_uuid is null
- and (pb.uuid is null or pb.is_main = ${_true})
+ and <include refid="mainBranchOrPortfolio"/>
and p.scope = 'PRJ'
and p.qualifier in ('TRK','VW','SVW','APP')
<if test="branchUuid != null">
}
public final ComponentDto insertSubView(ComponentDto view, Consumer<ComponentDto> dtoPopulator) {
- return insertComponentAndBranchAndProject(ComponentTesting.newSubPortfolio(view), view.isPrivate(), defaults(), dtoPopulator);
+ ComponentDto subViewComponent = ComponentTesting.newSubPortfolio(view);
+ return insertComponentAndPortfolio(subViewComponent, view.isPrivate(), dtoPopulator, p -> p.setParentUuid(view.uuid()));
}
public void addPortfolioApplicationBranch(String portfolioUuid, String applicationUuid, String branchUuid) {
return branch;
}
- private static <T> T firstNonNull(@Nullable T first, T second) {
- return (first != null) ? first : second;
- }
-
// TODO temporary constructor to quickly create project from previous project component.
public static ProjectDto toProjectDto(ComponentDto componentDto, long createTime) {
return new ProjectDto()
import com.google.common.base.Joiner;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
import org.junit.Before;
import org.junit.Rule;
import org.sonar.api.utils.System2;
import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
-import org.sonar.db.component.ComponentTesting;
import org.sonar.db.component.ResourceTypesRule;
import org.sonar.db.user.UserDto;
import org.sonar.server.component.index.ComponentIndex;
import static org.sonar.api.server.ws.WebService.Param.TEXT_QUERY;
import static org.sonar.db.component.ComponentTesting.newDirectory;
import static org.sonar.db.component.ComponentTesting.newPortfolio;
-import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
import static org.sonar.test.JsonAssert.assertJson;
import static org.sonarqube.ws.client.component.ComponentsWsParameters.PARAM_QUALIFIERS;
@Test
public void search_by_key_query() {
- insertProjectsAuthorizedForUser(
- ComponentTesting.newPrivateProjectDto().setKey("project-_%-key"),
- ComponentTesting.newPrivateProjectDto().setKey("project-key-without-escaped-characters"));
+ ComponentDto p1 = db.components().insertPrivateProject(p -> p.setKey("project-_%-key"));
+ ComponentDto p2 = db.components().insertPrivateProject(p -> p.setKey("project-key-without-escaped-characters"));
+ insertProjectsAuthorizedForUser(List.of(p1, p2));
SearchWsResponse response = call(new SearchRequest().setQuery("project-_%-key").setQualifiers(singletonList(PROJECT)));
assertThat(response.getComponentsList()).extracting(Component::getKey).containsOnly("project-_%-key");
public void search_with_pagination() {
List<ComponentDto> componentDtoList = new ArrayList<>();
for (int i = 1; i <= 9; i++) {
- componentDtoList.add(newPrivateProjectDto("project-uuid-" + i).setKey("project-key-" + i).setName("Project Name " + i));
+ int j = i;
+ componentDtoList.add(db.components().insertPrivateProject("project-uuid-" + j, p -> p.setKey("project-key-" + j).setName("Project Name " + j)));
}
- insertProjectsAuthorizedForUser(componentDtoList.toArray(new ComponentDto[] {}));
+ insertProjectsAuthorizedForUser(componentDtoList);
SearchWsResponse response = call(new SearchRequest().setPage(2).setPageSize(3).setQualifiers(singletonList(PROJECT)));
@Test
public void return_only_projects_on_which_user_has_browse_permission() {
- ComponentDto project1 = ComponentTesting.newPrivateProjectDto();
- ComponentDto project2 = ComponentTesting.newPrivateProjectDto();
- ComponentDto portfolio = ComponentTesting.newPortfolio();
+ ComponentDto project1 = db.components().insertPrivateProject();
+ ComponentDto project2 = db.components().insertPrivateProject();
+ ComponentDto portfolio = db.components().insertPrivatePortfolio();
- db.components().insertComponents(project1, project2, portfolio);
- setBrowsePermissionOnUserAndIndex(project1);
+ setBrowsePermissionOnUserAndIndex(List.of(project1));
SearchWsResponse response = call(new SearchRequest().setQualifiers(singletonList(PROJECT)));
@Test
public void return_project_key() {
- ComponentDto project = ComponentTesting.newPublicProjectDto();
+ ComponentDto project = db.components().insertPublicProject();
ComponentDto dir1 = newDirectory(project, "dir1").setKey("dir1");
ComponentDto dir2 = newDirectory(project, "dir2").setKey("dir2");
ComponentDto dir3 = newDirectory(project, "dir3").setKey("dir3");
- db.components().insertComponents(project, dir1, dir2, dir3);
- setBrowsePermissionOnUserAndIndex(project);
+ db.components().insertComponents(dir1, dir2, dir3);
+ setBrowsePermissionOnUserAndIndex(List.of(project));
SearchWsResponse response = call(new SearchRequest().setQualifiers(asList(PROJECT, APP)));
public void does_not_return_branches() {
ComponentDto project = db.components().insertPublicProject();
ComponentDto branch = db.components().insertProjectBranch(project);
- setBrowsePermissionOnUserAndIndex(project, branch);
+ setBrowsePermissionOnUserAndIndex(List.of(project, branch));
SearchWsResponse response = call(new SearchRequest().setQualifiers(asList(PROJECT)));
@Test
public void test_json_example() {
db.components().insertComponent(newPortfolio());
- ComponentDto project = newPrivateProjectDto("project-uuid").setName("Project Name").setKey("project-key");
+ ComponentDto project = db.components().insertPrivateProject("project-uuid", p -> p.setName("Project Name").setKey("project-key"));
ComponentDto directory = newDirectory(project, "path/to/directoy").setUuid("directory-uuid").setKey("directory-key").setName("Directory Name");
ComponentDto view = newPortfolio();
- db.components().insertComponents(project, directory, view);
- setBrowsePermissionOnUserAndIndex(project);
+ db.components().insertComponents(directory, view);
+ setBrowsePermissionOnUserAndIndex(List.of(project));
String response = underTest.newRequest()
.setMediaType(MediaTypes.JSON)
assertJson(response).isSimilarTo(underTest.getDef().responseExampleAsString());
}
- private void insertProjectsAuthorizedForUser(ComponentDto... projects) {
- db.components().insertComponents(projects);
+ private void insertProjectsAuthorizedForUser(List<ComponentDto> projects) {
setBrowsePermissionOnUserAndIndex(projects);
db.commit();
}
- private void setBrowsePermissionOnUserAndIndex(ComponentDto... projects) {
+ private void setBrowsePermissionOnUserAndIndex(List<ComponentDto> projects) {
index();
- Arrays.stream(projects).forEach(project -> authorizationIndexerTester.allowOnlyUser(project, user));
+ projects.forEach(project -> authorizationIndexerTester.allowOnlyUser(project, user));
}
private SearchWsResponse call(SearchRequest wsRequest) {
@Test
public void suggestions_without_query_should_contain_recently_browsed() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
componentIndexer.indexAll();
userSessionRule.addProjectPermission(USER, project);
@Test
public void suggestions_without_query_should_contain_recently_browsed_public_project() {
- ComponentDto project = db.components().insertComponent(newPublicProjectDto());
+ ComponentDto project = db.components().insertPublicProject();
componentIndexer.indexAll();
@Test
public void suggestions_without_query_should_not_contain_recently_browsed_without_permission() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
componentIndexer.indexAll();
@Test
public void suggestions_without_query_should_contain_favorites() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
doReturn(singletonList(project)).when(favoriteFinder).list();
componentIndexer.indexAll();
@Test
public void suggestions_without_query_should_not_contain_favorites_without_permission() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
doReturn(singletonList(project)).when(favoriteFinder).list();
componentIndexer.indexAll();
@Test
public void suggestions_without_query_should_contain_recently_browsed_favorites() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
doReturn(singletonList(project)).when(favoriteFinder).list();
componentIndexer.indexAll();
@Test
public void suggestions_without_query_should_not_contain_matches_that_are_neither_favorites_nor_recently_browsed() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
componentIndexer.indexAll();
userSessionRule.addProjectPermission(USER, project);
@Test
public void suggestions_without_query_should_order_results() {
- ComponentDto project1 = db.components().insertComponent(newPrivateProjectDto().setName("Alpha"));
- ComponentDto project2 = db.components().insertComponent(newPrivateProjectDto().setName("Bravo"));
- ComponentDto project3 = db.components().insertComponent(newPrivateProjectDto().setName("Charlie"));
- ComponentDto project4 = db.components().insertComponent(newPrivateProjectDto().setName("Delta"));
+ ComponentDto project1 = db.components().insertPrivateProject(p -> p.setName("Alpha"));
+ ComponentDto project2 = db.components().insertPrivateProject(p -> p.setName("Bravo"));
+ ComponentDto project3 = db.components().insertPrivateProject(p -> p.setName("Charlie"));
+ ComponentDto project4 = db.components().insertPrivateProject(p -> p.setName("Delta"));
doReturn(asList(project4, project2)).when(favoriteFinder).list();
componentIndexer.indexAll();
@Test
public void suggestions_without_query_should_return_empty_qualifiers() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
componentIndexer.indexOnAnalysis(project.branchUuid());
userSessionRule.addProjectPermission(USER, project);
@Test
public void suggestions_should_filter_allowed_qualifiers() {
resourceTypes.setAllQualifiers(PROJECT, FILE, UNIT_TEST_FILE);
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
componentIndexer.indexOnAnalysis(project.branchUuid());
userSessionRule.addProjectPermission(USER, project);
@Test
public void exact_match_in_one_qualifier() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
componentIndexer.indexAll();
authorizationIndexerTester.allowOnlyAnyone(project);
@Test
public void should_not_return_suggestion_on_non_existing_project() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
componentIndexer.indexAll();
authorizationIndexerTester.allowOnlyAnyone(project);
@Test
public void must_not_search_if_no_valid_tokens_are_provided() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto().setName("SonarQube"));
+ ComponentDto project = db.components().insertPrivateProject(p -> p.setName("SonarQube"));
componentIndexer.indexAll();
authorizationIndexerTester.allowOnlyAnyone(project);
@Test
public void should_warn_about_short_inputs_but_return_results_based_on_other_terms() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto().setName("SonarQube"));
+ ComponentDto project = db.components().insertPrivateProject(p -> p.setName("SonarQube"));
componentIndexer.indexAll();
authorizationIndexerTester.allowOnlyAnyone(project);
@Test
public void should_contain_component_names() {
- ComponentDto project1 = db.components().insertComponent(newPrivateProjectDto().setName("Project1"));
+ ComponentDto project1 = db.components().insertPrivateProject(p -> p.setName("Project1"));
componentIndexer.indexOnAnalysis(project1.branchUuid());
authorizationIndexerTester.allowOnlyAnyone(project1);
@Test
public void should_mark_recently_browsed_items() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto().setName("ProjectTest"));
+ ComponentDto project = db.components().insertPrivateProject(p -> p.setName("ProjectTest"));
ComponentDto file1 = newFileDto(project).setName("File1");
ComponentDto file2 = newFileDto(project).setName("File2");
componentIndexer.indexOnAnalysis(project.branchUuid());
@Test
public void should_mark_favorite_items() {
- ComponentDto favouriteProject = db.components().insertComponent(newPrivateProjectDto().setName("Project1"));
- ComponentDto nonFavouriteProject = db.components().insertComponent(newPublicProjectDto().setName("Project2"));
+ ComponentDto favouriteProject = db.components().insertPrivateProject(p -> p.setName("Project1"));
+ ComponentDto nonFavouriteProject = db.components().insertPublicProject(p -> p.setName("Project2"));
doReturn(singletonList(favouriteProject)).when(favoriteFinder).list();
componentIndexer.indexOnAnalysis(favouriteProject.branchUuid());
@Test
public void should_return_empty_qualifiers() {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
componentIndexer.indexOnAnalysis(project.branchUuid());
authorizationIndexerTester.allowOnlyAnyone(project);
String namePrefix = "MyProject";
List<ComponentDto> projects = range(0, numberOfProjects)
- .mapToObj(i -> db.components().insertComponent(newPublicProjectDto().setName(namePrefix + i)))
+ .mapToObj(i -> db.components().insertPublicProject(p -> p.setName(namePrefix + i)))
.collect(Collectors.toList());
componentIndexer.indexAll();
public void apply_template_by_qualifiers() {
ComponentDto publicProject = db.components().insertPublicProject();
ComponentDto privateProject = db.components().insertPrivateProject();
- ComponentDto view = db.components().insertComponent(newPortfolio());
- ComponentDto application = db.components().insertComponent(newApplication());
+ ComponentDto view = db.components().insertPrivatePortfolio();
+ ComponentDto application = db.components().insertPublicApplication();
loginAsAdmin();
newRequest()
@Test
public void search_by_key_query_with_partial_match_case_insensitive() {
userSession.addPermission(ADMINISTER);
- db.components().insertComponents(
- ComponentTesting.newPrivateProjectDto().setKey("project-_%-key"),
- ComponentTesting.newPrivateProjectDto().setKey("PROJECT-_%-KEY"),
- ComponentTesting.newPrivateProjectDto().setKey("project-key-without-escaped-characters"));
+ db.components().insertPrivateProject(p -> p.setKey("project-_%-key"));
+ db.components().insertPrivateProject(p -> p.setKey("PROJECT-_%-KEY"));
+ db.components().insertPrivateProject(p -> p.setKey("project-key-without-escaped-characters"));
SearchWsResponse response = call(SearchRequest.builder().setQuery("JeCt-_%-k").build());
@Test
public void search_private_projects() {
userSession.addPermission(ADMINISTER);
- db.components().insertComponents(
- ComponentTesting.newPrivateProjectDto().setKey("private-key"),
- ComponentTesting.newPublicProjectDto().setKey("public-key"));
+ db.components().insertPrivateProject(p -> p.setKey("private-key"));
+ db.components().insertPublicProject(p -> p.setKey("public-key"));
SearchWsResponse response = call(SearchRequest.builder().setVisibility("private").build());
@Test
public void search_public_projects() {
userSession.addPermission(ADMINISTER);
- db.components().insertComponents(
- ComponentTesting.newPrivateProjectDto().setKey("private-key"),
- ComponentTesting.newPublicProjectDto().setKey("public-key"));
+ db.components().insertPrivateProject(p -> p.setKey("private-key"));
+ db.components().insertPublicProject(p -> p.setKey("public-key"));
SearchWsResponse response = call(SearchRequest.builder().setVisibility("public").build());
@Test
public void search_projects_when_no_qualifier_set() {
userSession.addPermission(ADMINISTER);
- db.components().insertComponents(
- ComponentTesting.newPrivateProjectDto().setKey(PROJECT_KEY_1),
- newPortfolio());
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1));
+ db.components().insertPublicPortfolio();
SearchWsResponse response = call(SearchRequest.builder().build());
@Test
public void search_projects() {
userSession.addPermission(ADMINISTER);
- ComponentDto project = ComponentTesting.newPrivateProjectDto().setKey(PROJECT_KEY_1);
+ ComponentDto project = db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1));
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_2));
+ db.components().insertPublicPortfolio();
+
ComponentDto directory = newDirectory(project, "dir");
ComponentDto file = newFileDto(directory);
- db.components().insertComponents(
- project, directory, file,
- ComponentTesting.newPrivateProjectDto().setKey(PROJECT_KEY_2),
- newPortfolio());
+ db.components().insertComponents(directory, file);
SearchWsResponse response = call(SearchRequest.builder().setQualifiers(singletonList("TRK")).build());
@Test
public void search_views() {
userSession.addPermission(ADMINISTER);
- db.components().insertComponents(
- ComponentTesting.newPrivateProjectDto().setKey(PROJECT_KEY_1),
- newPortfolio().setKey("view1"));
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1));
+ db.components().insertPublicPortfolio(p -> p.setKey("view1"));
SearchWsResponse response = call(SearchRequest.builder().setQualifiers(singletonList("VW")).build());
@Test
public void search_projects_and_views() {
userSession.addPermission(ADMINISTER);
- db.components().insertComponents(
- ComponentTesting.newPrivateProjectDto().setKey(PROJECT_KEY_1),
- newPortfolio().setKey("view1"));
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1));
+ db.components().insertPublicPortfolio(p -> p.setKey("view1"));
SearchWsResponse response = call(SearchRequest.builder().setQualifiers(asList("TRK", "VW")).build());
@Test
public void search_all() {
userSession.addPermission(ADMINISTER);
- db.components().insertComponents(
- ComponentTesting.newPrivateProjectDto().setKey(PROJECT_KEY_1),
- ComponentTesting.newPrivateProjectDto().setKey(PROJECT_KEY_2),
- ComponentTesting.newPrivateProjectDto().setKey(PROJECT_KEY_3));
-
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1));
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_2));
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_3));
SearchWsResponse response = call(SearchRequest.builder().build());
assertThat(response.getComponentsList()).extracting(Component::getKey).containsOnly(PROJECT_KEY_1, PROJECT_KEY_2, PROJECT_KEY_3);
userSession.addPermission(ADMINISTER);
List<ComponentDto> componentDtoList = new ArrayList<>();
for (int i = 1; i <= 9; i++) {
- componentDtoList.add(newPrivateProjectDto("project-uuid-" + i).setKey("project-key-" + i).setName("Project Name " + i));
+ int j = i;
+ componentDtoList.add(db.components().insertPrivateProject("project-uuid-" + i, p -> p.setKey("project-key-" + j).setName("Project Name " + j)));
}
- db.components().insertComponents(componentDtoList.toArray(new ComponentDto[] {}));
SearchWsResponse response = call(SearchRequest.builder().setPage(2).setPageSize(3).build());
-
assertThat(response.getComponentsList()).extracting(Component::getKey).containsExactly("project-key-4", "project-key-5", "project-key-6");
}
@Test
public void json_example() {
userSession.addPermission(ADMINISTER);
- ComponentDto publicProject = newPrivateProjectDto("project-uuid-1").setName("Project Name 1").setKey("project-key-1").setPrivate(false);
- ComponentDto privateProject = newPrivateProjectDto("project-uuid-2").setName("Project Name 1").setKey("project-key-2");
- db.components().insertComponents(
- publicProject,
- privateProject);
+ ComponentDto publicProject = db.components().insertPublicProject("project-uuid-1", p -> p.setName("Project Name 1").setKey("project-key-1").setPrivate(false));
+ ComponentDto privateProject = db.components().insertPrivateProject("project-uuid-2", p->p.setName("Project Name 1").setKey("project-key-2"));
db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(publicProject)
.setCreatedAt(parseDateTime("2017-03-01T11:39:03+0300").getTime())
.setRevision("cfb82f55c6ef32e61828c4cb3db2da12795fd767"));
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
-import org.sonar.db.component.ComponentTesting;
import org.sonar.db.component.ProjectLinkDto;
import org.sonar.db.component.SnapshotDto;
import org.sonar.db.metric.MetricDto;
@Test
public void return_only_first_1000_projects() {
IntStream.range(0, 1_010).forEach(i -> {
- ComponentDto project = db.components().insertComponent(newPrivateProjectDto());
+ ComponentDto project = db.components().insertPrivateProject();
db.users().insertProjectPermissionOnUser(user, UserRole.ADMIN, project);
});
@Test
public void sort_projects_by_name() {
- ComponentDto b_project = db.components().insertComponent(ComponentTesting.newPrivateProjectDto().setName("B_project_name"));
- ComponentDto c_project = db.components().insertComponent(ComponentTesting.newPrivateProjectDto().setName("c_project_name"));
- ComponentDto a_project = db.components().insertComponent(ComponentTesting.newPrivateProjectDto().setName("A_project_name"));
+ ComponentDto b_project = db.components().insertPrivateProject(p -> p.setName("B_project_name"));
+ ComponentDto c_project = db.components().insertPrivateProject(p -> p.setName("c_project_name"));
+ ComponentDto a_project = db.components().insertPrivateProject(p -> p.setName("A_project_name"));
db.users().insertProjectPermissionOnUser(user, UserRole.ADMIN, b_project);
db.users().insertProjectPermissionOnUser(user, UserRole.ADMIN, a_project);
@Test
public void paginate_projects() {
for (int i = 0; i < 10; i++) {
- ComponentDto project = db.components().insertComponent(ComponentTesting.newPrivateProjectDto().setName("project-" + i));
+ int j = i;
+ ComponentDto project = db.components().insertPrivateProject(p -> p.setName("project-" + j));
db.users().insertProjectPermissionOnUser(user, UserRole.ADMIN, project);
}
}
private ComponentDto insertClang() {
- return db.components().insertComponent(newPrivateProjectDto(Uuids.UUID_EXAMPLE_01)
+ return db.components().insertPrivateProject(Uuids.UUID_EXAMPLE_01, p -> p
.setName("Clang")
.setKey("clang"));
}
private ComponentDto insertJdk7() {
- return db.components().insertComponent(newPrivateProjectDto(Uuids.UUID_EXAMPLE_02)
+ return db.components().insertPrivateProject(Uuids.UUID_EXAMPLE_02, p -> p
.setName("JDK 7")
.setKey("net.java.openjdk:jdk7")
.setDescription("JDK"));