import org.sonar.wsclient.issue.IssueClient;
import org.sonar.wsclient.issue.IssueQuery;
import org.sonar.wsclient.issue.Issues;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import org.sonar.wsclient.user.UserParameters;
import util.ItUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
+import static util.ItUtils.getComponent;
+import static util.ItUtils.getMeasureAsDouble;
public class IssuesModeTest {
assertThat(result.getLogs()).doesNotContain("'One Issue Per Line' skipped because there is no related file in current project");
ItUtils.assertIssuesInJsonReport(result, 3, 0, 17);
}
-
+
// SONAR-8518
@Test
public void shoud_support_sonar_profile_prop() throws IOException {
restoreProfile("empty.xml");
orchestrator.getServer().provisionProject("sample", "xoo-sample");
orchestrator.getServer().associateProjectToQualityProfile("sample", "xoo", "empty");
-
- SonarScanner runner = configureRunner("shared/xoo-sample",
+
+ SonarScanner runner = configureRunner("shared/xoo-sample",
"sonar.verbose", "true",
"sonar.analysis.mode", "issues",
"sonar.profile", "one-issue-per-line");
orchestrator.getServer().associateProjectToQualityProfile("sample", "xoo", "with-many-rules");
SonarScanner runner = configureRunner("analysis/xoo-sample-with-spaces/v2");
- BuildResult result = orchestrator.executeBuild(runner);
- assertThat(getResource("sample:my sources/main/xoo/sample/My Sample.xoo")).isNotNull();
+ orchestrator.executeBuild(runner);
+ assertThat(getComponent(orchestrator, "sample:my sources/main/xoo/sample/My Sample.xoo")).isNotNull();
runner = configureRunnerIssues("analysis/xoo-sample-with-spaces/v2", null);
- result = orchestrator.executeBuild(runner);
+ BuildResult result = orchestrator.executeBuild(runner);
// Analysis is not persisted in database
- Resource project = getResource("com.sonarsource.it.samples:simple-sample");
- assertThat(project).isNull();
+ assertThat(getComponent(orchestrator, "com.sonarsource.it.samples:simple-sample")).isNull();
assertThat(result.getLogs()).contains("Issues");
assertThat(result.getLogs()).contains("ANALYSIS SUCCESSFUL");
}
// First real scan with source
SonarScanner runner = configureRunner("shared/xoo-history-v2");
- BuildResult result = orchestrator.executeBuild(runner);
- assertThat(getResource("sample:src/main/xoo/sample/ClassAdded.xoo")).isNotNull();
+ orchestrator.executeBuild(runner);
+ assertThat(getComponent(orchestrator, "sample:src/main/xoo/sample/ClassAdded.xoo")).isNotNull();
// Second scan should remove ClassAdded.xoo
runner = configureRunner("shared/xoo-history-v1");
- result = orchestrator.executeBuild(runner);
- assertThat(getResource("sample:src/main/xoo/sample/ClassAdded.xoo")).isNull();
+ orchestrator.executeBuild(runner);
+ assertThat(getMeasureAsDouble(orchestrator, "sample:src/main/xoo/sample/ClassAdded.xoo", "ncloc")).isNull();
// Re-add ClassAdded.xoo in local workspace
runner = configureRunnerIssues("shared/xoo-history-v2", null);
- result = orchestrator.executeBuild(runner);
+ BuildResult result = orchestrator.executeBuild(runner);
- assertThat(getResource("sample:src/main/xoo/sample/ClassAdded.xoo")).isNull();
+ assertThat(getMeasureAsDouble(orchestrator, "sample:src/main/xoo/sample/ClassAdded.xoo", "ncloc")).isNull();
assertThat(result.getLogs()).contains("Issues");
assertThat(result.getLogs()).contains("ANALYSIS SUCCESSFUL");
}
orchestrator.getServer().restoreProfile(FileLocation.ofClasspath("/analysis/IssuesModeTest/" + fileName));
}
- private Resource getResource(String key) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(key, "lines"));
- }
-
private SonarScanner configureRunnerIssues(String projectDir, @Nullable File homeDir, String... props) throws IOException {
SonarScanner scanner = SonarScanner.create(ItUtils.projectDir(projectDir),
"sonar.working.directory", temp.newFolder().getAbsolutePath(),
import com.sonar.orchestrator.build.SonarScanner;
import com.sonar.orchestrator.locator.FileLocation;
import it.Category3Suite;
+import java.util.Map;
import org.junit.After;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import util.ItUtils;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasureAsDouble;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
public class MultiLanguageTest {
orchestrator.getServer().provisionProject("multi-language-sample", "multi-language-sample");
orchestrator.getServer().associateProjectToQualityProfile("multi-language-sample", "xoo", "one-issue-per-line");
- orchestrator.getServer().associateProjectToQualityProfile("multi-language-sample","xoo2", "one-issue-per-line-xoo2");
+ orchestrator.getServer().associateProjectToQualityProfile("multi-language-sample", "xoo2", "one-issue-per-line-xoo2");
SonarScanner build = SonarScanner.create().setProjectDir(ItUtils.projectDir("analysis/xoo-multi-languages"));
BuildResult result = orchestrator.executeBuild(build);
assertThat(result.getLogs()).contains("Quality profile for xoo2: one-issue-per-line-xoo2");
// modules
- Resource project = getResource("multi-language-sample", "files", "violations");
- assertThat(project.getMeasureIntValue("files")).isEqualTo(2);
- assertThat(project.getMeasureIntValue("violations")).isEqualTo(26);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, "multi-language-sample", "files", "violations");
+ assertThat(measures.get("files")).isEqualTo(2);
+ assertThat(measures.get("violations")).isEqualTo(26);
- Resource xooFile = getResource("multi-language-sample:src/sample/Sample.xoo", "violations");
- assertThat(xooFile.getMeasureIntValue("violations")).isEqualTo(13);
-
- Resource xoo2File = getResource("multi-language-sample:src/sample/Sample.xoo2", "violations");
- assertThat(xoo2File.getMeasureIntValue("violations")).isEqualTo(13);
- }
-
- private Resource getResource(String resourceKey, String... metricKeys) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(resourceKey, metricKeys));
+ assertThat(getMeasureAsDouble(orchestrator, "multi-language-sample:src/sample/Sample.xoo", "violations")).isEqualTo(13);
+ assertThat(getMeasureAsDouble(orchestrator, "multi-language-sample:src/sample/Sample.xoo2", "violations")).isEqualTo(13);
}
}
import com.sonar.orchestrator.Orchestrator;
import com.sonar.orchestrator.build.MavenBuild;
import it.Category3Suite;
+import java.util.Map;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import util.ItUtils;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getComponent;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
/**
* Test the extension point org.sonar.api.batch.bootstrap.ProjectBuilder
checkSubProject("project-builder-module-b");
checkFile("project-builder-module-a", "src/HelloA.java");
checkFile("project-builder-module-b", "src/HelloB.java");
- assertThat(getResource("com.sonarsource.it.projects.batch:project-builder-module-b:src/IgnoredFile.java")).isNull();
+ assertThat(getComponent(orchestrator, "com.sonarsource.it.projects.batch:project-builder-module-b:src/IgnoredFile.java")).isNull();
}
private void checkProject() {
- Resource project = getResource("com.sonarsource.it.projects.batch:project-builder");
-
// name has been changed by plugin
- assertThat(project.getName()).isEqualTo("Name changed by plugin");
+ assertThat(getComponent(orchestrator, "com.sonarsource.it.projects.batch:project-builder").getName()).isEqualTo("Name changed by plugin");
- assertThat(project).isNotNull();
- assertThat(project.getMeasureIntValue("files")).isEqualTo(2);
- assertThat(project.getMeasureIntValue("lines")).isGreaterThan(10);
+ Map<String, Double> measures = getMeasures("com.sonarsource.it.projects.batch:project-builder");
+ assertThat(measures.get("files")).isEqualTo(2);
+ assertThat(measures.get("lines")).isGreaterThan(10);
}
private void checkSubProject(String subProjectKey) {
- Resource subProject = getResource("com.sonarsource.it.projects.batch:" + subProjectKey);
- assertThat(subProject).isNotNull();
- assertThat(subProject.getMeasureIntValue("files")).isEqualTo(1);
- assertThat(subProject.getMeasureIntValue("lines")).isGreaterThan(5);
+ Map<String, Double> measures = getMeasures("com.sonarsource.it.projects.batch:" + subProjectKey);
+ assertThat(measures.get("files")).isEqualTo(1);
+ assertThat(measures.get("lines")).isGreaterThan(5);
}
private void checkFile(String subProjectKey, String fileKey) {
- Resource file = getResource("com.sonarsource.it.projects.batch:" + subProjectKey + ":" + fileKey);
- assertThat(file).isNotNull();
- assertThat(file.getMeasureIntValue("lines")).isGreaterThan(5);
+ Map<String, Double> measures = getMeasures("com.sonarsource.it.projects.batch:" + subProjectKey + ":" + fileKey);
+ assertThat(measures.get("lines")).isGreaterThan(5);
}
- private Resource getResource(String key) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(key, "lines", "files"));
+ private Map<String, Double> getMeasures(String key) {
+ return getMeasuresAsDoubleByMetricKey(orchestrator, key, "lines", "files");
}
}
import it.Category3Suite;
import java.io.File;
import java.io.IOException;
-import java.util.Date;
+import java.util.Map;
import org.apache.commons.io.FileUtils;
import org.junit.Assume;
import org.junit.Before;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
-import org.sonar.wsclient.Sonar;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.client.component.SearchWsRequest;
import util.ItUtils;
+import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getComponent;
+import static util.ItUtils.getComponentNavigation;
+import static util.ItUtils.getMeasureAsDouble;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
+import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.resetSettings;
import static util.ItUtils.setServerProperty;
scan("shared/xoo-multi-modules-sample");
scan("shared/xoo-multi-modules-sample", "sonar.branch", "branch/0.x");
- Sonar sonar = orchestrator.getServer().getWsClient();
- assertThat(sonar.findAll(new ResourceQuery().setQualifiers("TRK"))).hasSize(2);
-
- Resource master = sonar.find(new ResourceQuery("com.sonarsource.it.samples:multi-modules-sample"));
- assertThat(master.getName()).isEqualTo("Sonar :: Integration Tests :: Multi-modules Sample");
-
- Resource branch = sonar.find(new ResourceQuery("com.sonarsource.it.samples:multi-modules-sample:branch/0.x"));
- assertThat(branch.getName()).isEqualTo("Sonar :: Integration Tests :: Multi-modules Sample branch/0.x");
+ assertThat(newAdminWsClient(orchestrator).components().search(new SearchWsRequest().setQualifiers(singletonList("TRK"))).getComponentsList()).hasSize(2);
+ assertThat(getComponent(orchestrator, "com.sonarsource.it.samples:multi-modules-sample").getName()).isEqualTo("Sonar :: Integration Tests :: Multi-modules Sample");
+ assertThat(getComponent(orchestrator, "com.sonarsource.it.samples:multi-modules-sample:branch/0.x").getName())
+ .isEqualTo("Sonar :: Integration Tests :: Multi-modules Sample branch/0.x");
}
@Test
scan("shared/xoo-multi-modules-sample",
"sonar.profile", "one-issue-per-line",
"sonar.verbose", "true");
- Resource r = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("com.sonarsource.it.samples:multi-modules-sample", "violations"));
- assertThat(r.getMeasureIntValue("violations")).isEqualTo(61);
+ assertThat(getMeasureAsDouble(orchestrator, "com.sonarsource.it.samples:multi-modules-sample", "violations")).isEqualTo(61);
}
// SONAR-4680
orchestrator.getServer().associateProjectToQualityProfile("com.sonarsource.it.projects.batch:duplicate-source", "xoo", "one-issue-per-line");
scan("analysis/duplicate-source");
- Sonar sonar = orchestrator.getServer().getAdminWsClient();
- Resource project = sonar.find(new ResourceQuery("com.sonarsource.it.projects.batch:duplicate-source").setMetrics("files", "directories"));
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, "com.sonarsource.it.projects.batch:duplicate-source", "files", "directories");
// 2 main files and 1 test file all with same deprecated key
- assertThat(project.getMeasureIntValue("files")).isEqualTo(2);
- assertThat(project.getMeasureIntValue("directories")).isEqualTo(2);
+ assertThat(measures.get("files")).isEqualTo(2);
+ assertThat(measures.get("directories")).isEqualTo(2);
}
/**
}
private void assertNameAndVersion(String projectKey, String expectedProjectName, String expectedProjectVersion) {
- // new WS Client with api/components doesn't return the project version, so use the old one
- Resource resource = orchestrator.getServer().getAdminWsClient().find(new ResourceQuery(projectKey));
- assertThat(resource.getName()).isEqualTo(expectedProjectName);
- assertThat(resource.getVersion()).isEqualTo(expectedProjectVersion);
-
+ assertThat(getComponent(orchestrator, projectKey).getName()).isEqualTo(expectedProjectName);
+ assertThat(getComponentNavigation(orchestrator, projectKey).getVersion()).isEqualTo(expectedProjectVersion);
}
@Test
orchestrator.getServer().associateProjectToQualityProfile("case-sensitive-file-extensions", "xoo", "one-issue-per-line");
scan("analysis/case-sensitive-file-extensions");
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("case-sensitive-file-extensions", "files", "ncloc"));
- assertThat(project.getMeasureIntValue("files")).isEqualTo(2);
- assertThat(project.getMeasureIntValue("ncloc")).isEqualTo(5 + 2);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, "case-sensitive-file-extensions", "files", "ncloc");
+ assertThat(measures.get("files")).isEqualTo(2);
+ assertThat(measures.get("ncloc")).isEqualTo(5 + 2);
}
/**
orchestrator.getServer().provisionProject("com.sonarsource.it.samples:multi-modules-sample", "Sonar :: Integration Tests :: Multi-modules Sample");
orchestrator.getServer().associateProjectToQualityProfile("com.sonarsource.it.samples:multi-modules-sample", "xoo", "one-issue-per-line");
scan("analysis/custom-module-key");
- assertThat(getResource("com.sonarsource.it.samples:moduleA")).isNotNull();
- assertThat(getResource("com.sonarsource.it.samples:moduleB")).isNotNull();
+ assertThat(getComponent(orchestrator, "com.sonarsource.it.samples:moduleA")).isNotNull();
+ assertThat(getComponent(orchestrator, "com.sonarsource.it.samples:moduleB")).isNotNull();
}
/**
orchestrator.getServer().provisionProject("projectAB", "project AB");
orchestrator.getServer().associateProjectToQualityProfile("projectAB", "xoo", "one-issue-per-line");
scan("analysis/prevent-common-module/projectAB");
- assertThat(getResource("com.sonarsource.it.samples:moduleA")).isNotNull();
- assertThat(getResource("com.sonarsource.it.samples:moduleB")).isNotNull();
+ assertThat(getComponent(orchestrator, "com.sonarsource.it.samples:moduleA")).isNotNull();
+ assertThat(getComponent(orchestrator, "com.sonarsource.it.samples:moduleB")).isNotNull();
orchestrator.getServer().provisionProject("projectAC", "project AC");
orchestrator.getServer().associateProjectToQualityProfile("projectAC", "xoo", "one-issue-per-line");
assertThat(result.getLogs()).contains("Module \"com.sonarsource.it.samples:moduleA\" is already part of project \"projectAB\"");
}
- /**
- * SONAR-4235
- */
- @Test
- public void test_project_creation_date() {
- long before = new Date().getTime() - 2000l;
- orchestrator.getServer().provisionProject("sample", "xoo-sample");
- orchestrator.getServer().associateProjectToQualityProfile("sample", "xoo", "one-issue-per-line");
- orchestrator.executeBuild(SonarScanner.create(ItUtils.projectDir("shared/xoo-sample")));
- long after = new Date().getTime() + 2000l;
- Resource xooSample = orchestrator.getServer().getWsClient().find(new ResourceQuery().setResourceKeyOrId("sample"));
- assertThat(xooSample.getCreationDate().getTime()).isGreaterThan(before).isLessThan(after);
- }
-
/**
* SONAR-4334
*/
assertThat(result.getLogs()).contains("This property may only be used to rebuild the past in a chronological order.");
}
- private Resource getResource(String key) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(key, "lines"));
- }
-
private BuildResult scan(String projectPath, String... props) {
SonarScanner scanner = configureScanner(projectPath, props);
return orchestrator.executeBuild(scanner);
import com.sonar.orchestrator.build.SonarScanner;
import it.Category4Suite;
import java.util.List;
+import java.util.Map;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsComponents.Component;
+import org.sonarqube.ws.client.component.TreeWsRequest;
import util.ItUtils;
+import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
+import static util.ItUtils.newWsClient;
public class FileExclusionsTest {
static final String PROJECT = "exclusions";
"sonar.exclusions", "**/*Exclude*.xoo,src/main/xoo/org/sonar/tests/packageToExclude/**",
"sonar.test.exclusions", "**/ClassTwoTest.xoo");
- Resource project = projectWithMetrics("ncloc", "files", "directories");
-
- assertThat(project.getMeasureIntValue("files")).isEqualTo(4);
- assertThat(project.getMeasureIntValue("ncloc")).isEqualTo(60);
- assertThat(project.getMeasureIntValue("directories")).isEqualTo(2);
+ Map<String, Double> measures = getMeasuresAsDouble("ncloc", "files", "directories");
+ assertThat(measures.get("files").intValue()).isEqualTo(4);
+ assertThat(measures.get("ncloc").intValue()).isEqualTo(60);
+ assertThat(measures.get("directories").intValue()).isEqualTo(2);
}
/**
"sonar.exclusions", "**/*Exclude*.xoo,org/sonar/tests/packageToExclude/**",
"sonar.test.exclusions", "**/ClassTwoTest.xoo");
- List<Resource> testFiles = orchestrator.getServer().getWsClient()
- .findAll(new ResourceQuery(PROJECT).setQualifiers("UTS").setDepth(-1));
-
+ List<Component> testFiles = getComponents("UTS");
assertThat(testFiles).hasSize(2);
- assertThat(testFiles).extracting("name").doesNotContain("ClassTwoTest.xoo");
+ assertThat(testFiles).extracting(Component::getName).doesNotContain("ClassTwoTest.xoo");
}
/**
"sonar.dynamicAnalysis", "false",
"sonar.inclusions", "**/*One.xoo,**/*Two.xoo");
- Resource project = projectWithMetrics("files");
- assertThat(project.getMeasureIntValue("files")).isEqualTo(2);
-
- List<Resource> sourceFiles = orchestrator.getServer().getWsClient()
- .findAll(new ResourceQuery(PROJECT).setQualifiers("FIL").setDepth(-1));
+ assertThat(getMeasuresAsDouble("files").get("files")).isEqualTo(2);
+ List<Component> sourceFiles = getComponents("FIL");
assertThat(sourceFiles).hasSize(2);
- assertThat(sourceFiles).extracting("name").containsOnly("ClassOne.xoo", "ClassTwo.xoo");
+ assertThat(sourceFiles).extracting(Component::getName).containsOnly("ClassOne.xoo", "ClassTwo.xoo");
}
/**
public void include_test_files() {
scan("sonar.test.inclusions", "src/test/xoo/**/*One*.xoo,src/test/xoo/**/*Two*.xoo");
- Resource project = projectWithMetrics("tests");
- assertThat(project.getMeasureIntValue("tests")).isEqualTo(2);
-
- List<Resource> testFiles = orchestrator.getServer().getWsClient()
- .findAll(new ResourceQuery(PROJECT).setQualifiers("UTS").setDepth(-1));
+ assertThat(getMeasuresAsDouble("tests").get("tests")).isEqualTo(2);
+ List<Component> testFiles = getComponents("UTS");
assertThat(testFiles).hasSize(2);
- assertThat(testFiles).extracting("name").containsOnly("ClassOneTest.xoo", "ClassTwoTest.xoo");
+ assertThat(testFiles).extracting(Component::getName).containsOnly("ClassOneTest.xoo", "ClassTwoTest.xoo");
}
/**
// exclude ClassThree and ClassToExclude
"sonar.exclusions", "file:**/src/main/xoo/org/**/packageToExclude/*.xoo,file:**/src/main/xoo/org/**/*Exclude.xoo");
- List<Resource> sourceFiles = orchestrator.getServer().getWsClient()
- .findAll(new ResourceQuery(PROJECT).setQualifiers("FIL").setDepth(-1));
-
+ List<Component> sourceFiles = getComponents("FIL");
assertThat(sourceFiles).hasSize(4);
- assertThat(sourceFiles).extracting("name").containsOnly("ClassOne.xoo", "ClassToIgnoreGlobally.xoo", "ClassTwo.xoo", "NoSonarComment.xoo");
+ assertThat(sourceFiles).extracting(Component::getName).containsOnly("ClassOne.xoo", "ClassToIgnoreGlobally.xoo", "ClassTwo.xoo", "NoSonarComment.xoo");
}
- static Resource projectWithMetrics(String... metricKeys) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT, metricKeys));
+ static Map<String, Double> getMeasuresAsDouble(String... metricKeys) {
+ return getMeasuresAsDoubleByMetricKey(orchestrator, PROJECT, metricKeys);
}
private void scan(String... properties) {
.setProperties(properties);
orchestrator.executeBuild(build);
}
+
+ public static List<Component> getComponents(String qualifier) {
+ return newWsClient(orchestrator).components().tree(new TreeWsRequest().setBaseComponentKey(PROJECT).setQualifiers(singletonList(qualifier))).getComponentsList();
+ }
}
import com.sonar.orchestrator.build.SonarScanner;
import com.sonar.orchestrator.locator.FileLocation;
import it.Category4Suite;
+import java.util.Map;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import util.ItUtils;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
public class IssueExclusionsTest {
"sonar.issue.enforce.multicriteria.1.ruleKey", "*");
checkIssueCountBySeverity(
- 1 /* tag */+ 18 /* lines in HelloA1.xoo */+ 1 /* file */,
+ 1 /* tag */ + 18 /* lines in HelloA1.xoo */ + 1 /* file */,
0 + 1,
0 + 18,
0 + 1,
"sonar.issue.enforce.multicriteria.2.ruleKey", "*");
checkIssueCountBySeverity(
- 2 /* tags */+ 18 /* lines in HelloA1.xoo */+ 15 /* lines in HelloA2.xoo */+ 2 /* files */,
+ 2 /* tags */ + 18 /* lines in HelloA1.xoo */ + 15 /* lines in HelloA2.xoo */ + 2 /* files */,
0 + 2,
0 + 18 + 15,
0 + 2,
"sonar.issue.enforce.multicriteria.2.ruleKey", "xoo:HasTag");
checkIssueCountBySeverity(
- 1 /* tag in HelloA2 */+ 18 /* lines in HelloA1.xoo */+ 4 /* files */+ 4 /* modules */,
+ 1 /* tag in HelloA2 */ + 18 /* lines in HelloA1.xoo */ + 4 /* files */ + 4 /* modules */,
0 + 1,
0 + 18,
4,
"sonar.issue.ignore.allfile.1.fileRegexp", "EXTERMINATE-ALL-ISSUES");
checkIssueCountBySeverity(
- 67 - 1 /* tag */- 18 /* lines in HelloA1.xoo */- 1 /* file */,
+ 67 - 1 /* tag */ - 18 /* lines in HelloA1.xoo */ - 1 /* file */,
2 - 1,
57 - 18,
4 - 1,
"sonar.issue.ignore.block.1.endBlockRegexp", "UNMUTE-SONAR");
checkIssueCountBySeverity(
- 67 - 1 /* tag */- 5 /* lines in HelloA2.xoo */,
+ 67 - 1 /* tag */ - 5 /* lines in HelloA2.xoo */,
2 - 1,
57 - 5,
4,
"sonar.issue.ignore.block.1.endBlockRegexp", "");
checkIssueCountBySeverity(
- 67 - 1 /* tag */- 7 /* remaining lines in HelloA2.xoo */,
+ 67 - 1 /* tag */ - 7 /* remaining lines in HelloA2.xoo */,
2 - 1,
57 - 7,
4,
"sonar.issue.ignore.multicriteria.1.ruleKey", "xoo:OneIssuePerLine");
checkIssueCountBySeverity(
- 67 - 1 /* tag in HelloA1.xoo */- 1 /* tag in HelloA2.xoo */
- - 18 /* lines in HelloA1.xoo */- 5 /* lines in HelloA2.xoo */- 12 /* lines in HelloB1.xoo */
+ 67 - 1 /* tag in HelloA1.xoo */ - 1 /* tag in HelloA2.xoo */
+ - 18 /* lines in HelloA1.xoo */ - 5 /* lines in HelloA2.xoo */ - 12 /* lines in HelloB1.xoo */
- 1 /* HelloA1.xoo file */,
0,
57 - 18 - 5 - 12,
}
private void checkIssueCountBySeverity(int total, int taggedXoo, int perLine, int perFile, int blocker, int perModule) {
- Resource project = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(PROJECT_KEY, "violations", "info_violations", "minor_violations", "major_violations",
- "blocker_violations", "critical_violations"));
- assertThat(project.getMeasureIntValue("violations")).isEqualTo(total);
- assertThat(project.getMeasureIntValue("info_violations")).isEqualTo(taggedXoo); // Has tag 'xoo'
- assertThat(project.getMeasureIntValue("minor_violations")).isEqualTo(perLine); // One per line
- assertThat(project.getMeasureIntValue("major_violations")).isEqualTo(perFile); // One per file
- assertThat(project.getMeasureIntValue("blocker_violations")).isEqualTo(blocker);
- assertThat(project.getMeasureIntValue("critical_violations")).isEqualTo(perModule); // One per module
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, PROJECT_KEY, "violations", "info_violations", "minor_violations", "major_violations",
+ "blocker_violations", "critical_violations");
+ assertThat(measures.get("violations").intValue()).isEqualTo(total);
+ assertThat(measures.get("info_violations").intValue()).isEqualTo(taggedXoo); // Has tag 'xoo'
+ assertThat(measures.get("minor_violations").intValue()).isEqualTo(perLine); // One per line
+ assertThat(measures.get("major_violations").intValue()).isEqualTo(perFile); // One per file
+ assertThat(measures.get("blocker_violations").intValue()).isEqualTo(blocker);
+ assertThat(measures.get("critical_violations").intValue()).isEqualTo(perModule); // One per module
}
private void checkAnalysisFails(String... properties) {
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import util.ItUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static util.ItUtils.projectDir;
setBurnedBudget(1200.3);
setTeamSize(4);
- assertThat(getMeasure("team_size")).isNull();
- assertThat(getMeasure("burned_budget")).isNull();
+ assertThat(getMeasureAsDouble("team_size")).isNull();
+ assertThat(getMeasureAsDouble("burned_budget")).isNull();
analyzeProject();
- assertThat(getMeasure("burned_budget").getValue()).isEqualTo(1200.3);
- assertThat(getMeasure("team_size").getIntValue()).isEqualTo(4);
+ assertThat(getMeasureAsDouble("burned_budget")).isEqualTo(1200.3);
+ assertThat(getMeasureAsDouble("team_size")).isEqualTo(4d);
}
@Test
setTeamSize(4);
analyzeProject();
updateTeamSize(15);
- assertThat(getMeasure("team_size").getIntValue()).isEqualTo(4);
+ assertThat(getMeasureAsDouble("team_size")).isEqualTo(4d);
analyzeProject();// the value is available when the project is analyzed again
- assertThat(getMeasure("team_size").getIntValue()).isEqualTo(15);
+ assertThat(getMeasureAsDouble("team_size")).isEqualTo(15d);
}
@Test
setTeamSize(4);
analyzeProject();
deleteCustomMeasure("team_size");
- assertThat(getMeasure("team_size").getIntValue()).isEqualTo(4);// the value is still available. It will be removed during next analyzed
+ assertThat(getMeasureAsDouble("team_size")).isEqualTo(4d);// the value is still available. It will be removed during next
+ // analyzed
analyzeProject();
- assertThat(getMeasure("team_size")).isNull();
+ assertThat(getMeasureAsDouble("team_size")).isNull();
}
private void analyzeProject() {
orchestrator.getServer().adminWsClient().post("api/custom_measures/delete", "id", customMeasureId);
}
- private Measure getMeasure(String metricKey) {
- Resource resource = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT_KEY, metricKey));
- return resource != null ? resource.getMeasure(metricKey) : null;
+ private Double getMeasureAsDouble(String metricKey) {
+ return ItUtils.getMeasureAsDouble(orchestrator, PROJECT_KEY, metricKey);
}
}
import it.Category4Suite;
import java.io.File;
import java.io.IOException;
+import java.util.Map;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import util.ItUtils;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
public class CrossModuleDuplicationsTest {
private static final String PROJECT_KEY = "cross-module";
public void setUpProject() throws IOException {
orchestrator.resetData();
orchestrator.getServer().restoreProfile(FileLocation.ofClasspath("/duplication/xoo-duplication-profile.xml"));
-
+
FileUtils.copyDirectory(ItUtils.projectDir(PROJECT_DIR), temp.getRoot());
projectDir = temp.getRoot();
}
}
private static void verifyDuplicationMeasures(String componentKey, int duplicatedBlocks, int duplicatedLines, int duplicatedFiles, double duplicatedLinesDensity) {
- Resource file = getComponent(componentKey);
- assertThat(file.getMeasureValue("duplicated_blocks").intValue()).isEqualTo(duplicatedBlocks);
- assertThat(file.getMeasureValue("duplicated_lines").intValue()).isEqualTo(duplicatedLines);
- assertThat(file.getMeasureValue("duplicated_files").intValue()).isEqualTo(duplicatedFiles);
- assertThat(file.getMeasureValue("duplicated_lines_density")).isEqualTo(duplicatedLinesDensity);
- }
-
- private static Resource getComponent(String key) {
- Resource component = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(key, "duplicated_lines", "duplicated_blocks", "duplicated_files", "duplicated_lines_density"));
- assertThat(component).isNotNull();
- return component;
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, componentKey, "duplicated_lines", "duplicated_blocks", "duplicated_files", "duplicated_lines_density");
+ assertThat(measures.get("duplicated_blocks").intValue()).isEqualTo(duplicatedBlocks);
+ assertThat(measures.get("duplicated_lines").intValue()).isEqualTo(duplicatedLines);
+ assertThat(measures.get("duplicated_files").intValue()).isEqualTo(duplicatedFiles);
+ assertThat(measures.get("duplicated_lines_density")).isEqualTo(duplicatedLinesDensity);
}
}
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.ResourceQuery;
import static org.assertj.core.api.Assertions.assertThat;
import static org.skyscreamer.jsonassert.JSONAssert.assertEquals;
+import static util.ItUtils.getComponent;
import static util.ItUtils.runProjectAnalysis;
import static util.selenium.Selenese.runSelenese;
// Remove origin project
orchestrator.getServer().adminWsClient().post("api/projects/bulk_delete", "keys", ORIGIN_PROJECT);
- assertThat(orchestrator.getServer().getAdminWsClient().find(ResourceQuery.create(ORIGIN_PROJECT))).isNull();
+ assertThat(getComponent(orchestrator, ORIGIN_PROJECT)).isNull();
}
@Test
import com.sonar.orchestrator.Orchestrator;
import com.sonar.orchestrator.locator.FileLocation;
import it.Category4Suite;
-import java.util.List;
+import java.util.Map;
import org.apache.commons.io.IOUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.issue.Issue;
-import org.sonar.wsclient.issue.IssueQuery;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.client.GetRequest;
+import org.sonarqube.ws.client.issue.SearchWsRequest;
+import util.issue.IssueRule;
+import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.skyscreamer.jsonassert.JSONAssert.assertEquals;
+import static util.ItUtils.getMeasureAsDouble;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
+import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.runProjectAnalysis;
import static util.ItUtils.setServerProperty;
import static util.selenium.Selenese.runSelenese;
@ClassRule
public static Orchestrator orchestrator = Category4Suite.ORCHESTRATOR;
+ @ClassRule
+ public static final IssueRule issueRule = IssueRule.from(orchestrator);
+
@BeforeClass
public static void analyzeProjects() {
orchestrator.resetData();
@Test
public void duplicate_project_has_duplication_as_it_has_been_analyzed_twice() throws Exception {
- assertThat(getMeasure(DUPLICATE_PROJECT, "duplicated_lines")).isEqualTo(27);
- assertThat(getMeasure(DUPLICATE_PROJECT, "duplicated_blocks")).isEqualTo(1);
- assertThat(getMeasure(DUPLICATE_PROJECT, "duplicated_files")).isEqualTo(1);
- assertThat(getComponent(DUPLICATE_PROJECT, "duplicated_lines_density").getMeasureValue("duplicated_lines_density")).isEqualTo(45d);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, DUPLICATE_PROJECT, "duplicated_lines", "duplicated_blocks", "duplicated_files", "duplicated_lines_density");
+ assertThat(measures.get("duplicated_lines").intValue()).isEqualTo(27);
+ assertThat(measures.get("duplicated_blocks").intValue()).isEqualTo(1);
+ assertThat(measures.get("duplicated_files").intValue()).isEqualTo(1);
+ assertThat(measures.get("duplicated_lines_density")).isEqualTo(45d);
}
@Test
public void issue_on_duplicated_blocks_is_generated_on_file() throws Exception {
- List<Issue> issues = orchestrator.getServer().wsClient().issueClient()
- .find(IssueQuery.create()
- .components(DUPLICATE_FILE)
- .rules("common-xoo:DuplicatedBlocks"))
- .list();
- assertThat(issues).hasSize(1);
+ assertThat(issueRule.search(new SearchWsRequest().setComponentKeys(singletonList(DUPLICATE_FILE)).setRules(singletonList("common-xoo:DuplicatedBlocks"))).getIssuesList())
+ .hasSize(1);
}
@Test
additionalProperties, String.class));
}
- private static int getMeasure(String projectKey, String metricKey) {
- Integer intMeasure = getComponent(projectKey, metricKey).getMeasureIntValue(metricKey);
- assertThat(intMeasure).isNotNull();
- return intMeasure;
- }
-
- private static Resource getComponent(String projectKey, String metricKey) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(projectKey, metricKey));
- }
-
private static void assertProjectHasNoDuplication(String projectKey) {
- assertThat(getMeasure(projectKey, "duplicated_lines")).isZero();
+ assertThat(getMeasureAsDouble(orchestrator, projectKey, "duplicated_lines")).isZero();
}
private static void verifyWsResultOnDuplicateFile(String ws, String expectedFilePath) throws Exception {
- String duplication = orchestrator.getServer().adminWsClient().get(ws, "key", DUPLICATE_FILE);
+ String duplication = newAdminWsClient(orchestrator).wsConnector().call(new GetRequest(ws).setParam("key", DUPLICATE_FILE)).content();
assertEquals(IOUtils.toString(CrossProjectDuplicationsTest.class.getResourceAsStream("/duplication/CrossProjectDuplicationsTest/" + expectedFilePath), "UTF-8"), duplication,
false);
}
import com.sonar.orchestrator.Orchestrator;
import com.sonar.orchestrator.locator.FileLocation;
import it.Category4Suite;
-import java.util.List;
+import java.util.Map;
import org.apache.commons.io.IOUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.issue.Issue;
-import org.sonar.wsclient.issue.IssueQuery;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.client.issue.SearchWsRequest;
+import util.issue.IssueRule;
+import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.skyscreamer.jsonassert.JSONAssert.assertEquals;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
import static util.ItUtils.runProjectAnalysis;
import static util.ItUtils.setServerProperty;
@ClassRule
public static Orchestrator orchestrator = Category4Suite.ORCHESTRATOR;
+ @ClassRule
+ public static final IssueRule issueRule = IssueRule.from(orchestrator);
+
@BeforeClass
public static void analyzeProjects() {
orchestrator.resetData();
@Test
public void issues_on_duplicated_blocks_are_generated_on_each_file() throws Exception {
- List<Issue> issues = orchestrator.getServer().wsClient().issueClient()
- .find(IssueQuery.create()
- .rules("common-xoo:DuplicatedBlocks"))
- .list();
- assertThat(issues).hasSize(13);
+ assertThat(issueRule.search(new SearchWsRequest().setRules(singletonList("common-xoo:DuplicatedBlocks"))).getIssuesList()).hasSize(13);
}
@Test
"api/duplications/show", "duplications_show-expected.json");
}
- private static Resource getComponent(String key) {
- Resource component = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(key, "duplicated_lines", "duplicated_blocks", "duplicated_files", "duplicated_lines_density"));
- assertThat(component).isNotNull();
- return component;
+ private static Map<String, Double> getMeasures(String key) {
+ return getMeasuresAsDoubleByMetricKey(orchestrator, key, "duplicated_lines", "duplicated_blocks", "duplicated_files", "duplicated_lines_density");
}
private static void verifyDuplicationMeasures(String componentKey, int duplicatedBlocks, int duplicatedLines, int duplicatedFiles, double duplicatedLinesDensity) {
- Resource file = getComponent(componentKey);
- assertThat(file.getMeasureValue("duplicated_blocks").intValue()).isEqualTo(duplicatedBlocks);
- assertThat(file.getMeasureValue("duplicated_lines").intValue()).isEqualTo(duplicatedLines);
- assertThat(file.getMeasureValue("duplicated_files").intValue()).isEqualTo(duplicatedFiles);
- assertThat(file.getMeasureValue("duplicated_lines_density")).isEqualTo(duplicatedLinesDensity);
+ Map<String, Double> measures = getMeasures(componentKey);
+ assertThat(measures.get("duplicated_blocks").intValue()).isEqualTo(duplicatedBlocks);
+ assertThat(measures.get("duplicated_lines").intValue()).isEqualTo(duplicatedLines);
+ assertThat(measures.get("duplicated_files").intValue()).isEqualTo(duplicatedFiles);
+ assertThat(measures.get("duplicated_lines_density")).isEqualTo(duplicatedLinesDensity);
}
private static void analyzeProject(String projectKey, String... additionalProperties) {
import com.sonar.orchestrator.Orchestrator;
import it.Category4Suite;
+import java.util.Map;
import org.assertj.core.data.Offset;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsMeasures;
+import static java.lang.Double.parseDouble;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresWithVariationsByMetricKey;
import static util.ItUtils.runProjectAnalysis;
public class NewDuplicationsTest {
@Test
public void new_duplications_on_project() throws Exception {
- Resource project = getComponent("new-duplications");
- assertThat(project.getMeasure("new_lines").getVariation1()).isEqualTo(83d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_duplicated_lines").getVariation1()).isEqualTo(71d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_duplicated_lines_density").getVariation1()).isEqualTo(85.5d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_duplicated_blocks").getVariation1()).isEqualTo(12d, DEFAULT_OFFSET);
+ Map<String, WsMeasures.Measure> measures = getMeasures("new-duplications");
+ assertThat(parseDouble(measures.get("new_lines").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(83d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_duplicated_lines").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(71d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_duplicated_lines_density").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(85.5d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_duplicated_blocks").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(12d, DEFAULT_OFFSET);
}
@Test
public void new_duplications_on_directory() throws Exception {
- Resource project = getComponent("new-duplications:src/main/xoo/duplicated_lines_with_other_dir1");
- assertThat(project.getMeasure("new_lines").getVariation1()).isEqualTo(24d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_duplicated_lines").getVariation1()).isEqualTo(24d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_duplicated_lines_density").getVariation1()).isEqualTo(100d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_duplicated_blocks").getVariation1()).isEqualTo(7d, DEFAULT_OFFSET);
+ Map<String, WsMeasures.Measure> measures = getMeasures("new-duplications:src/main/xoo/duplicated_lines_with_other_dir1");
+ assertThat(parseDouble(measures.get("new_lines").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(24d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_duplicated_lines").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(24d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_duplicated_lines_density").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(100d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_duplicated_blocks").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(7d, DEFAULT_OFFSET);
}
@Test
public void new_duplications_on_file() throws Exception {
- Resource project = getComponent("new-duplications:src/main/xoo/duplicated_lines_within_same_file/DuplicatedLinesInSameFile.xoo");
- assertThat(project.getMeasure("new_lines").getVariation1()).isEqualTo(41d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_duplicated_lines").getVariation1()).isEqualTo(29d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_duplicated_lines_density").getVariation1()).isEqualTo(70.7d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_duplicated_blocks").getVariation1()).isEqualTo(2d, DEFAULT_OFFSET);
+ Map<String, WsMeasures.Measure> measures = getMeasures("new-duplications:src/main/xoo/duplicated_lines_within_same_file/DuplicatedLinesInSameFile.xoo");
+ assertThat(parseDouble(measures.get("new_lines").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(41d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_duplicated_lines").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(29d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_duplicated_lines_density").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(70.7d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_duplicated_blocks").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(2d, DEFAULT_OFFSET);
}
- private static Resource getComponent(String key) {
- Resource component = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(key, "new_lines", "new_duplicated_lines", "new_duplicated_lines_density", "new_duplicated_blocks").setIncludeTrends(true));
- assertThat(component).isNotNull();
- return component;
+ private static Map<String, WsMeasures.Measure> getMeasures(String key) {
+ return getMeasuresWithVariationsByMetricKey(orchestrator, key, "new_lines", "new_duplicated_lines", "new_duplicated_lines_density", "new_duplicated_blocks");
}
}
package it.issue;
import java.util.List;
+import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.wsclient.issue.Issue;
import org.sonar.wsclient.issue.IssueQuery;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import util.ProjectAnalysis;
import util.ProjectAnalysisRule;
+import util.issue.IssueRule;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasureAsDouble;
/**
* Tests the extension point IssueFilter
@Rule
public final ProjectAnalysisRule projectAnalysisRule = ProjectAnalysisRule.from(ORCHESTRATOR);
+ @ClassRule
+ public static final IssueRule issueRule = IssueRule.from(ORCHESTRATOR);
+
private final String manyRuleProfileKey = projectAnalysisRule.registerProfile("/issue/IssueFilterExtensionTest/xoo-with-many-rules.xml");
private final String xooMultiModuleProjectKey = projectAnalysisRule.registerProject("shared/xoo-multi-modules-sample");
private final ProjectAnalysis analysis = projectAnalysisRule.newProjectAnalysis(xooMultiModuleProjectKey)
assertThat(issue.componentKey()).doesNotContain("HelloA1");
}
- assertThat(getMeasure(xooMultiModuleProjectKey, "violations").getIntValue()).isEqualTo(issues.size());
+ assertThat(getMeasureAsDouble(ORCHESTRATOR, xooMultiModuleProjectKey, "violations").intValue()).isEqualTo(issues.size());
}
@Test
}
}
- private static List<Issue> searchUnresolvedIssues(String projectName) {
- return searchIssues(IssueQuery.create().componentRoots(projectName).resolved(true));
- }
-
- private static List<Issue> searchResolvedIssues(String projectName) {
- return searchIssues(IssueQuery.create().componentRoots(projectName).resolved(false));
+ private static List<Issue> searchUnresolvedIssues(String projectKey) {
+ return searchIssues(IssueQuery.create().componentRoots(projectKey).resolved(true));
}
- private static Measure getMeasure(String projectKey, String metricKey) {
- Resource resource = ORCHESTRATOR.getServer().getWsClient().find(ResourceQuery.createForMetrics(projectKey, metricKey));
- return resource == null ? null : resource.getMeasure(metricKey);
+ private static List<Issue> searchResolvedIssues(String projectKey) {
+ return searchIssues(IssueQuery.create().componentRoots(projectKey).resolved(false));
}
private static int countModuleIssues(List<Issue> issues) {
package it.issue;
import com.sonar.orchestrator.locator.FileLocation;
+import java.util.Map;
import org.junit.Before;
import org.junit.Test;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
import static util.ItUtils.runProjectAnalysis;
import static util.ItUtils.setServerProperties;
}
private void checkIssueCountBySeverity(int total, int perFile, int perCommonRule, int perModule) {
- Resource project = ORCHESTRATOR.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(PROJECT_KEY, "violations", "major_violations", "blocker_violations", "critical_violations"));
- assertThat(project.getMeasureIntValue("violations")).isEqualTo(total);
- assertThat(project.getMeasureIntValue("major_violations")).isEqualTo(perFile); // One per file
- assertThat(project.getMeasureIntValue("blocker_violations")).isEqualTo(perCommonRule); // On per common rule
- // 'InsufficientCommentDensity'
- assertThat(project.getMeasureIntValue("critical_violations")).isEqualTo(perModule); // One per module
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(ORCHESTRATOR, PROJECT_KEY, "violations", "major_violations", "blocker_violations", "critical_violations");
+ assertThat(measures.get("violations").intValue()).isEqualTo(total);
+ assertThat(measures.get("major_violations").intValue()).isEqualTo(perFile); // One per file
+ assertThat(measures.get("blocker_violations").intValue()).isEqualTo(perCommonRule); // On per common rule
+ assertThat(measures.get("critical_violations").intValue()).isEqualTo(perModule); // One per module
}
}
import com.sonar.orchestrator.locator.FileLocation;
import java.util.List;
+import java.util.Map;
import org.junit.Before;
import org.junit.Test;
-import org.sonar.wsclient.Sonar;
import org.sonar.wsclient.issue.Issue;
import org.sonar.wsclient.issue.IssueQuery;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
import static util.ItUtils.runProjectAnalysis;
public class IssueMeasureTest extends AbstractIssueTest {
assertThat(search(IssueQuery.create().componentRoots(MULTI_MODULE_SAMPLE_PROJECT_KEY)).paging().total()).isEqualTo(136);
- Resource project = ORCHESTRATOR.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(MULTI_MODULE_SAMPLE_PROJECT_KEY, "violations", "info_violations", "minor_violations", "major_violations",
- "blocker_violations", "critical_violations"));
- assertThat(project.getMeasureIntValue("violations")).isEqualTo(136);
- assertThat(project.getMeasureIntValue("info_violations")).isEqualTo(2);
- assertThat(project.getMeasureIntValue("minor_violations")).isEqualTo(61);
- assertThat(project.getMeasureIntValue("major_violations")).isEqualTo(65);
- assertThat(project.getMeasureIntValue("blocker_violations")).isEqualTo(4);
- assertThat(project.getMeasureIntValue("critical_violations")).isEqualTo(4);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(ORCHESTRATOR, MULTI_MODULE_SAMPLE_PROJECT_KEY, "violations", "info_violations", "minor_violations",
+ "major_violations",
+ "blocker_violations", "critical_violations");
+ assertThat(measures.get("violations")).isEqualTo(136);
+ assertThat(measures.get("info_violations")).isEqualTo(2);
+ assertThat(measures.get("minor_violations")).isEqualTo(61);
+ assertThat(measures.get("major_violations")).isEqualTo(65);
+ assertThat(measures.get("blocker_violations")).isEqualTo(4);
+ assertThat(measures.get("critical_violations")).isEqualTo(4);
}
/**
// Re analyze the project to compute measures
runProjectAnalysis(ORCHESTRATOR, "shared/xoo-sample");
- Resource project = ORCHESTRATOR.getServer().getWsClient().find(
- ResourceQuery.createForMetrics(SAMPLE_PROJECT_KEY, "false_positive_issues", "wont_fix_issues", "open_issues", "reopened_issues", "confirmed_issues"));
- assertThat(project.getMeasureIntValue("false_positive_issues")).isEqualTo(1);
- assertThat(project.getMeasureIntValue("wont_fix_issues")).isEqualTo(1);
- assertThat(project.getMeasureIntValue("open_issues")).isEqualTo(13);
- assertThat(project.getMeasureIntValue("reopened_issues")).isEqualTo(1);
- assertThat(project.getMeasureIntValue("confirmed_issues")).isEqualTo(1);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(ORCHESTRATOR, SAMPLE_PROJECT_KEY, "false_positive_issues", "wont_fix_issues", "open_issues", "reopened_issues",
+ "confirmed_issues");
+ assertThat(measures.get("false_positive_issues")).isEqualTo(1);
+ assertThat(measures.get("wont_fix_issues")).isEqualTo(1);
+ assertThat(measures.get("open_issues")).isEqualTo(13);
+ assertThat(measures.get("reopened_issues")).isEqualTo(1);
+ assertThat(measures.get("confirmed_issues")).isEqualTo(1);
}
@Test
assertThat(searchIssuesByProject(SAMPLE_PROJECT_KEY)).isEmpty();
- Resource project = ORCHESTRATOR.getServer().getWsClient().find(ResourceQuery.createForMetrics(SAMPLE_PROJECT_KEY, "violations", "blocker_violations"));
- assertThat(project.getMeasureIntValue("violations")).isEqualTo(0);
- assertThat(project.getMeasureIntValue("blocker_violations")).isEqualTo(0);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(ORCHESTRATOR, SAMPLE_PROJECT_KEY, "violations", "blocker_violations");
+ assertThat(measures.get("violations")).isEqualTo(0);
+ assertThat(measures.get("blocker_violations")).isEqualTo(0);
}
/**
ORCHESTRATOR.getServer().associateProjectToQualityProfile(projectKey, "xoo", "one-issue-per-file-profile");
runProjectAnalysis(ORCHESTRATOR, "shared/xoo-sample-with-tests");
- Sonar wsClient = ORCHESTRATOR.getServer().getAdminWsClient();
-
// Store current number of issues
- Resource project = wsClient.find(ResourceQuery.createForMetrics(testKey, "violations"));
- assertThat(project.getMeasureIntValue("violations")).isEqualTo(1);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(ORCHESTRATOR, testKey, "violations");
+ assertThat(measures.get("violations")).isEqualTo(1);
}
}
import com.sonar.orchestrator.build.SonarScanner;
import com.sonar.orchestrator.locator.FileLocation;
-import java.util.List;
+import java.util.Map;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.sonar.wsclient.issue.IssueQuery;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsMeasures;
+import org.sonarqube.ws.WsMeasures.Measure;
import util.ItUtils;
+import static java.lang.Integer.parseInt;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresWithVariationsByMetricKey;
+import static util.ItUtils.getPeriodMeasureValuesByIndex;
import static util.ItUtils.projectDir;
import static util.ItUtils.setServerProperty;
ORCHESTRATOR.executeBuild(SonarScanner.create(projectDir("shared/xoo-sample")));
assertThat(ORCHESTRATOR.getServer().wsClient().issueClient().find(IssueQuery.create()).list()).isNotEmpty();
- Resource newIssues = ORCHESTRATOR.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics("sample:src/main/xoo/sample/Sample.xoo", "new_violations").setIncludeTrends(true));
- List<Measure> measures = newIssues.getMeasures();
- assertThat(measures.get(0).getVariation1().intValue()).isEqualTo(17);
- assertThat(measures.get(0).getVariation2().intValue()).isEqualTo(17);
+ Map<Integer, Double> newIssues = getPeriodMeasureValuesByIndex(ORCHESTRATOR, "sample:src/main/xoo/sample/Sample.xoo", "new_violations");
+ assertThat(newIssues.get(1)).isEqualTo(17);
+ assertThat(newIssues.get(2)).isEqualTo(17);
// second analysis, with exactly the same profile -> no new issues
ORCHESTRATOR.executeBuild(SonarScanner.create(projectDir("shared/xoo-sample")));
assertThat(ORCHESTRATOR.getServer().wsClient().issueClient().find(IssueQuery.create()).list()).isNotEmpty();
- newIssues = ORCHESTRATOR.getServer().getWsClient().find(ResourceQuery.createForMetrics("sample:src/main/xoo/sample/Sample.xoo", "new_violations").setIncludeTrends(true));
- // No variation => measure is purged
- assertThat(newIssues).isNull();
+ assertThat(getPeriodMeasureValuesByIndex(ORCHESTRATOR, "sample:src/main/xoo/sample/Sample.xoo", "new_violations").values()).containsOnly(0d, 0d, 0d);
}
@Test
ORCHESTRATOR.executeBuild(SonarScanner.create(projectDir("shared/xoo-sample")));
// new issues measures should be to 0 on project on 2 periods as new issues has been created
- Resource file = ORCHESTRATOR.getServer().getWsClient().find(ResourceQuery.createForMetrics("sample", "new_violations").setIncludeTrends(true));
- List<Measure> measures = file.getMeasures();
- Measure newIssues = find(measures, "new_violations");
- assertThat(newIssues.getVariation1().intValue()).isEqualTo(0);
- assertThat(newIssues.getVariation2().intValue()).isEqualTo(0);
+ Map<Integer, Double> measures = getPeriodMeasureValuesByIndex(ORCHESTRATOR, "sample", "new_violations");
+ assertThat(measures.get(1)).isZero();
+ assertThat(measures.get(2)).isZero();
}
/**
ORCHESTRATOR.executeBuilds(SonarScanner.create(projectDir("shared/xoo-history-v2")));
assertThat(ORCHESTRATOR.getServer().wsClient().issueClient().find(IssueQuery.create()).list()).isNotEmpty();
- Resource file = ORCHESTRATOR.getServer().getWsClient().find(ResourceQuery.createForMetrics("sample", "new_violations", "violations", "ncloc").setIncludeTrends(true));
- List<Measure> measures = file.getMeasures();
- Measure newIssues = find(measures, "new_violations");
- assertThat(newIssues.getVariation1().intValue()).isEqualTo(17);
- assertThat(newIssues.getVariation2().intValue()).isEqualTo(17);
-
- Measure violations = find(measures, "violations");
- assertThat(violations.getValue().intValue()).isEqualTo(43);
- assertThat(violations.getVariation1().intValue()).isEqualTo(17);
- assertThat(violations.getVariation2().intValue()).isEqualTo(17);
-
- Measure ncloc = find(measures, "ncloc");
- assertThat(ncloc.getValue().intValue()).isEqualTo(40);
- assertThat(ncloc.getVariation1().intValue()).isEqualTo(16);
- assertThat(ncloc.getVariation2().intValue()).isEqualTo(16);
+
+ Map<String, Measure> measures = getMeasuresWithVariationsByMetricKey(ORCHESTRATOR, "sample", "new_violations", "violations", "ncloc");
+ assertThat(measures.get("new_violations").getPeriods().getPeriodsValueList()).extracting(WsMeasures.PeriodValue::getValue).containsOnly("17", "17", "17");
+
+ Measure violations = measures.get("violations");
+ assertThat(parseInt(violations.getValue())).isEqualTo(43);
+ assertThat(violations.getPeriods().getPeriodsValueList()).extracting(periodValue -> parseInt(periodValue.getValue())).containsOnly(17, 17, 17);
+
+ Measure ncloc = measures.get("ncloc");
+ assertThat(parseInt(ncloc.getValue())).isEqualTo(40);
+ assertThat(ncloc.getPeriods().getPeriodsValueList()).extracting(periodValue -> parseInt(periodValue.getValue())).containsOnly(16, 16, 16);
}
@Test
ORCHESTRATOR.getServer().associateProjectToQualityProfile("com.sonarsource.it.samples:multi-modules-sample", "xoo", "profile2");
ORCHESTRATOR.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- Resource project = ORCHESTRATOR.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics("com.sonarsource.it.samples:multi-modules-sample", "new_violations", "violations").setIncludeTrends(true));
- List<Measure> measures = project.getMeasures();
- Measure newIssues = find(measures, "new_violations");
- assertThat(newIssues.getVariation1().intValue()).isEqualTo(65);
- }
-
- private Measure find(List<Measure> measures, String metricKey) {
- for (Measure measure : measures) {
- if (measure.getMetricKey().equals(metricKey)) {
- return measure;
- }
- }
- return null;
+ Map<Integer, Double> periodMeasures = getPeriodMeasureValuesByIndex(ORCHESTRATOR, "com.sonarsource.it.samples:multi-modules-sample", "new_violations");
+ assertThat(periodMeasures.get(1)).isEqualTo(65);
}
}
import it.Category3Suite;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import util.ItUtils;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasureAsDouble;
/**
* SONAR-6939
"sonar.projectKey", projectKey,
"sonar.scanner.feedDecimalScaleMetric", String.valueOf(true));
- Resource resource = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(projectKey, metricKey));
- // Ability to define decimal scale of metrics was introduced in v5.3. By default it is 1.
- assertThat(resource.getMeasureValue(metricKey)).isEqualTo(0.0001);
- assertThat(resource.getMeasureFormattedValue(metricKey, null)).isEqualTo("0.0001");
+ assertThat(getMeasureAsDouble(orchestrator, projectKey, metricKey)).isEqualTo(0.0001);
}
}
*/
package it.measureHistory;
-import com.google.common.collect.ImmutableMap;
import com.sonar.orchestrator.Orchestrator;
import com.sonar.orchestrator.locator.FileLocation;
import it.Category1Suite;
-import java.util.ArrayList;
import java.util.Date;
-import java.util.List;
import java.util.Map;
-import java.util.stream.Collectors;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
-import org.sonarqube.ws.WsMeasures;
import org.sonarqube.ws.client.WsClient;
-import org.sonarqube.ws.client.measure.ComponentWsRequest;
import pageobjects.Navigation;
-import static java.util.Arrays.asList;
-import static java.util.Collections.singletonList;
import static org.apache.commons.lang.time.DateUtils.addDays;
import static org.assertj.core.api.Assertions.assertThat;
import static util.ItUtils.formatDate;
+import static util.ItUtils.getMeasure;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
+import static util.ItUtils.getPeriodMeasureValuesByIndex;
import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.resetPeriods;
import static util.ItUtils.runProjectAnalysis;
runProjectAnalysis(orchestrator, "shared/xoo-sample", "sonar.projectDate", formatDate(addDays(new Date(), -20)));
// New technical debt only comes from new issues
- Resource newTechnicalDebt = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics("sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt").setIncludeTrends(true));
- List<Measure> measures = newTechnicalDebt.getMeasures();
- assertThat(measures.get(0).getVariation4()).isEqualTo(17);
- assertThat(measures.get(0).getVariation5()).isEqualTo(17);
+ Map<Integer, Double> periodsMeasure = getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt");
+ assertThat(periodsMeasure.get(4)).isEqualTo(17);
+ assertThat(periodsMeasure.get(5)).isEqualTo(17);
// Third analysis, today, with exactly the same profile -> no new issues so no new technical debt
orchestrator.getServer().associateProjectToQualityProfile(PROJECT_KEY, "xoo", "one-issue-per-line");
runProjectAnalysis(orchestrator, "shared/xoo-sample");
- newTechnicalDebt = orchestrator.getServer().getWsClient().find(
- ResourceQuery.createForMetrics("sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt").setIncludeTrends(true));
-
// No variation => measure is purged
- assertThat(newTechnicalDebt).isNull();
+ assertThat(getMeasure(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt")).isNull();
}
/**
runProjectAnalysis(orchestrator, "shared/xoo-sample");
// Project should have 17 new issues for period 1
- Resource newTechnicalDebt = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(PROJECT_KEY, "violations").setIncludeTrends(true));
- List<Measure> measures = newTechnicalDebt.getMeasures();
- assertThat(measures.get(0).getVariation1()).isEqualTo(17);
+ Map<Integer, Double> periodsMeasure = getPeriodMeasureValuesByIndex(orchestrator, PROJECT_KEY, "violations");
+ assertThat(periodsMeasure.get(1)).isEqualTo(17);
// Check on ui that it's possible to define leak period on project
Navigation.get(orchestrator).openHomepage().logIn().asAdmin().openSettings("sample")
"sonar.modules", "module_a,module_b");
// Variation on module b should exist
- Resource ncloc = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(MULTI_MODULE_PROJECT_KEY + ":module_b", "ncloc").setIncludeTrends(true));
- List<Measure> measures = ncloc.getMeasures();
- assertThat(measures.get(0).getVariation1()).isEqualTo(24);
+ Map<Integer, Double> periodsMeasure = getPeriodMeasureValuesByIndex(orchestrator, MULTI_MODULE_PROJECT_KEY + ":module_b", "ncloc");
+ assertThat(periodsMeasure.get(1)).isEqualTo(24);
}
@Test
"sonar.scm.provider", "xoo", "sonar.scm.disabled", "false");
// New lines measures is zero
- assertMeasures(projectKey, ImmutableMap.of("new_lines", 0, "new_lines_to_cover", 0));
- }
-
- private void assertMeasures(String projectKey, Map<String, Integer> expectedMeasures) {
- WsMeasures.ComponentWsResponse response = CLIENT.measures().component(new ComponentWsRequest()
- .setComponentKey(projectKey)
- .setMetricKeys(new ArrayList<>(expectedMeasures.keySet()))
- .setAdditionalFields(singletonList("periods")));
- Map<String, Integer> measures = response.getComponent().getMeasuresList().stream()
- .collect(Collectors.toMap(WsMeasures.Measure::getMetric, m -> Integer.parseInt(m.getPeriods().getPeriodsValue(0).getValue())));
- assertThat(measures).isEqualTo(expectedMeasures);
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, projectKey, "new_lines").get(1)).isEqualTo(0);
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, projectKey, "new_lines_to_cover").get(1)).isEqualTo(0);
}
private void assertNoMeasures(String projectKey, String... metrics) {
- WsMeasures.ComponentWsResponse response = CLIENT.measures().component(new ComponentWsRequest()
- .setComponentKey(projectKey)
- .setMetricKeys(asList(metrics))
- .setAdditionalFields(singletonList("periods")));
- assertThat(response.getComponent().getMeasuresList()).isEmpty();
+ assertThat(getMeasuresAsDoubleByMetricKey(orchestrator, projectKey, metrics)).isEmpty();
}
-
}
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import util.ItUtils;
+import static java.lang.Integer.parseInt;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.groups.Tuple.tuple;
+import static org.sonarqube.ws.WsMeasures.Measure;
+import static org.sonarqube.ws.WsMeasures.PeriodValue;
+import static util.ItUtils.getMeasureWithVariations;
+import static util.ItUtils.getPeriodMeasureValuesByIndex;
import static util.ItUtils.projectDir;
import static util.ItUtils.setServerProperty;
analyzeProject("1.0-SNAPSHOT");
analyzeProject("1.0-SNAPSHOT");
- Resource project = getProject("files");
- Measure measure = project.getMeasure("files");
+ Measure measure = getMeasureWithVariations(orchestrator, PROJECT, "files");
// There are 4 files
- assertThat(measure.getValue()).isEqualTo(4);
-
- // nothing changed in the previous analysis
- assertThat(project.getPeriod1Mode()).isEqualTo("previous_analysis");
- assertThat(measure.getVariation1()).isEqualTo(0);
-
- // but 2 files were added since the first analysis which was version 0.9
- assertThat(project.getPeriod3Mode()).isEqualTo("previous_version");
- assertThat(project.getPeriod3Param()).isEqualTo("0.9");
- assertThat(measure.getVariation3()).isEqualTo(2);
+ assertThat(parseInt(measure.getValue())).isEqualTo(4);
+ assertThat(measure.getPeriods().getPeriodsValueList()).extracting(PeriodValue::getIndex, PeriodValue::getValue)
+ .contains(
+ // nothing changed in the previous analysis
+ tuple(1, "0"),
+ // but 2 files were added since the first analysis which was version 0.9
+ tuple(3, "2"));
}
/**
// Analyze project by excluding some files
analyzeProject("1.0-SNAPSHOT", "**/*2.xoo", toStringDate(DateUtils.addDays(now, -2)));
// No difference measure after first analysis
- assertThat(getProject("files").getMeasure("files").getVariation3()).isNull();
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, PROJECT, "files").get(3)).isNull();
analyzeProjectWithDate("1.0-SNAPSHOT", toStringDate(DateUtils.addDays(now, -1)));
// No new version, first analysis is used -> 2 new files
- assertThat(getProject("files").getMeasure("files").getVariation3()).isEqualTo(2);
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, PROJECT, "files").get(3)).isEqualTo(2);
analyzeProjectWithDate("1.0-SNAPSHOT", toStringDate(now));
// Still no new version, first analysis is used -> 2 new files
- assertThat(getProject("files").getMeasure("files").getVariation3()).isEqualTo(2);
- }
-
- private Resource getProject(String... metricKeys) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT, metricKeys).setIncludeTrends(true));
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, PROJECT, "files").get(3)).isEqualTo(2);
}
}
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsMeasures;
import util.ItUtils;
+import static java.lang.Integer.parseInt;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.groups.Tuple.tuple;
+import static util.ItUtils.getMeasureWithVariations;
import static util.ItUtils.projectDir;
import static util.ItUtils.setServerProperty;
ItUtils.resetPeriods(orchestrator);
}
- @Test
- public void periods_are_well_defined() throws Exception {
- Resource project = getProject("files");
-
- assertThat(project.getPeriod1Mode()).isEqualTo("previous_analysis");
-
- assertThat(project.getPeriod2Mode()).isEqualTo("days");
- assertThat(project.getPeriod2Param()).isEqualTo("30");
- }
-
@Test
public void check_files_variation() throws Exception {
checkMeasure("files", 2, 3);
checkMeasure("new_violations", 24, 45);
}
- private void checkMeasure(String measure, int variation1, int variation2){
- Resource project = getProject(measure);
- Measure newTechnicalDebt = project.getMeasure(measure);
-
- assertThat(newTechnicalDebt.getVariation1().intValue()).isEqualTo(variation1);
- assertThat(newTechnicalDebt.getVariation2().intValue()).isEqualTo(variation2);
- }
-
- private Resource getProject(String... metricKeys) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT, metricKeys).setIncludeTrends(true));
+ private void checkMeasure(String metric, int variation1, int variation2) {
+ WsMeasures.Measure measure = getMeasureWithVariations(orchestrator, PROJECT, metric);
+ assertThat(measure.getPeriods().getPeriodsValueList()).extracting(WsMeasures.PeriodValue::getIndex, periodValue -> parseInt(periodValue.getValue()))
+ .contains(tuple(1, variation1), tuple(2, variation2));
}
private static void analyzeProject() {
orchestrator.executeBuild(runner);
}
- private static String getPastDate(int nbPastDays){
+ private static String getPastDate(int nbPastDays) {
return new SimpleDateFormat("yyyy-MM-dd").format(DateUtils.addDays(new Date(), nbPastDays * -1));
}
import com.sonar.orchestrator.locator.FileLocation;
import it.Category1Suite;
import java.util.Date;
+import java.util.Map;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import org.sonar.wsclient.services.TimeMachine;
import org.sonar.wsclient.services.TimeMachineCell;
import org.sonar.wsclient.services.TimeMachineQuery;
+import org.sonarqube.ws.WsMeasures.Measure;
import util.ItUtils;
+import util.ItUtils.ComponentNavigation;
+import static java.lang.Double.parseDouble;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getComponentNavigation;
+import static util.ItUtils.getMeasuresByMetricKey;
+import static util.ItUtils.getMeasuresWithVariationsByMetricKey;
import static util.ItUtils.projectDir;
import static util.ItUtils.setServerProperty;
@Test
public void projectIsAnalyzed() {
- assertThat(orchestrator.getServer().getWsClient().find(new ResourceQuery(PROJECT)).getVersion()).isEqualTo("1.0-SNAPSHOT");
- assertThat(orchestrator.getServer().getWsClient().find(new ResourceQuery(PROJECT)).getDate().getMonth()).isEqualTo(10); // November
+ ComponentNavigation component = getComponentNavigation(orchestrator, PROJECT);
+ assertThat(component.getVersion()).isEqualTo("1.0-SNAPSHOT");
+ assertThat(component.getDate().getMonth()).isEqualTo(10); // November
}
@Test
@Test
public void test_measure_variations() {
- Resource project = getProject("files", "ncloc", "violations");
-
- // period 1 : previous analysis
- assertThat(project.getPeriod1Mode()).isEqualTo("previous_analysis");
- assertThat(project.getPeriod1Date()).isNotNull();
-
+ Map<String, Measure> measures = getMeasuresWithVariationsByMetricKey(orchestrator, PROJECT, "files", "ncloc", "violations");
// variations from previous analysis
- assertThat(project.getMeasure("files").getVariation1()).isEqualTo(1.0);
- assertThat(project.getMeasure("ncloc").getVariation1()).isEqualTo(16.0);
- assertThat(project.getMeasure("violations").getVariation1()).isGreaterThan(0.0);
+ assertThat(parseDouble(measures.get("files").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(1.0);
+ assertThat(parseDouble(measures.get("ncloc").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(16.0);
+ assertThat(parseDouble(measures.get("violations").getPeriods().getPeriodsValue(0).getValue())).isGreaterThan(0.0);
}
/**
* SONAR-4962
*/
@Test
- public void measure_variations_are_only_meaningful_when_includetrends() {
- String[] metricKeys = {"violations", "new_violations"};
-
- Resource projectWithTrends = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT, metricKeys).setIncludeTrends(true));
- assertThat(projectWithTrends.getMeasure("violations")).isNotNull();
- assertThat(projectWithTrends.getMeasure("new_violations")).isNotNull();
-
- Resource projectWithoutTrends = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT, metricKeys).setIncludeTrends(false));
- assertThat(projectWithoutTrends.getMeasure("violations")).isNotNull();
- assertThat(projectWithoutTrends.getMeasure("new_violations")).isNull();
- }
-
- private Resource getProject(String... metricKeys) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT, metricKeys).setIncludeTrends(true));
+ public void measure_variations_are_only_meaningful_when_additional_fields_contains_periods() {
+ Map<String, Measure> measures = getMeasuresWithVariationsByMetricKey(orchestrator, PROJECT, "violations", "new_violations");
+ assertThat(measures.get("violations")).isNotNull();
+ assertThat(measures.get("new_violations")).isNotNull();
+
+ measures = getMeasuresByMetricKey(orchestrator, PROJECT, "violations", "new_violations");
+ assertThat(measures.get("violations")).isNotNull();
+ assertThat(measures.get("new_violations")).isNull();
}
}
package it.plugins.checks;
import com.google.common.base.Joiner;
+import com.google.gson.Gson;
import com.sonar.orchestrator.Orchestrator;
import it.plugins.Project;
import java.io.File;
+import java.util.List;
+import java.util.Map;
import org.hamcrest.Matchers;
import org.junit.rules.ErrorCollector;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
-import org.sonar.wsclient.services.Source;
-import org.sonar.wsclient.services.SourceQuery;
+import org.sonarqube.ws.client.GetRequest;
+import org.sonarqube.ws.client.WsResponse;
import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
+import static util.ItUtils.newAdminWsClient;
/**
*
}
private void fileMustHaveMeasures(String filePath, String[] metricKeys, int min) {
- Resource resource = getMeasureForComponentKey(filePathToKey(filePath), metricKeys);
- errorCollector.checkThat("Measures " + Joiner.on(",").join(metricKeys) + " are set on file " + filePath, resource, notNullValue());
- if (resource != null) {
+ String componentKey = filePathToKey(filePath);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, componentKey, metricKeys);
+ errorCollector.checkThat("Measures " + Joiner.on(",").join(metricKeys) + " are set on file " + filePath, componentKey, notNullValue());
+ if (!measures.isEmpty()) {
for (String metricKey : metricKeys) {
- Measure measure = resource.getMeasure(metricKey);
+ Double measure = measures.get(metricKey);
errorCollector.checkThat("Measure " + metricKey + " is set on file " + filePath, measure, notNullValue());
- if (measure != null && measure.getIntValue() != null) {
- errorCollector.checkThat("Measure " + metricKey + " is positive on file " + filePath, measure.getIntValue(), Matchers.greaterThanOrEqualTo(min));
+ if (measure != null) {
+ errorCollector.checkThat("Measure " + metricKey + " is positive on file " + filePath, measure.intValue(), Matchers.greaterThanOrEqualTo(min));
}
}
}
private void mustHaveSourceWithAtLeast(String path, int minLines) {
for (String filePath : toFiles(path)) {
- Source source = orchestrator.getServer().getWsClient().find(SourceQuery.create(filePathToKey(filePath)));
- errorCollector.checkThat("Source is set on file " + filePath, source, notNullValue());
+ WsResponse response = newAdminWsClient(orchestrator).wsConnector().call(new GetRequest("api/sources/lines").setParam("key", filePathToKey(filePath)));
+ errorCollector.checkThat("Source is set on file " + filePath, response.isSuccessful(), is(true));
+ Sources source = Sources.parse(response.content());
if (source != null) {
- errorCollector.checkThat("Source is not empty on file " + filePath, source.getLines().size(), Matchers.greaterThanOrEqualTo(minLines));
+ errorCollector.checkThat("Source is empty on file " + filePath, source.getSources().size(), Matchers.greaterThanOrEqualTo(minLines));
}
}
}
return asList(path);
}
- public Resource getMeasureForComponentKey(String resourceKey, String... metricKeys) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(resourceKey, metricKeys));
- }
-
private String filePathToKey(String filePath) {
return "all-langs:" + filePath;
}
+
+ public static class Sources {
+
+ private List<Source> sources;
+
+ private Sources(List<Source> sources) {
+ this.sources = sources;
+ }
+
+ public List<Source> getSources() {
+ return sources;
+ }
+
+ public static Sources parse(String json) {
+ Gson gson = new Gson();
+ return gson.fromJson(json, Sources.class);
+ }
+
+ public static class Source {
+ private final String line;
+
+ private Source(String line) {
+ this.line = line;
+ }
+
+ public String getLine() {
+ return line;
+ }
+ }
+ }
}
import org.junit.rules.ExpectedException;
import org.sonar.wsclient.SonarClient;
import org.sonar.wsclient.base.HttpException;
-import org.sonar.wsclient.services.ResourceQuery;
import org.sonar.wsclient.user.UserParameters;
import pageobjects.Navigation;
import pageobjects.settings.SettingsPage;
import static org.apache.commons.lang.time.DateUtils.addDays;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getComponent;
import static util.ItUtils.projectDir;
import static util.selenium.Selenese.runSelenese;
public void delete_project_by_web_service() {
scanSampleWithDate(ANALYSIS_DATE);
- assertThat(orchestrator.getServer().getWsClient().find(ResourceQuery.create(PROJECT_KEY))).isNotNull();
- assertThat(orchestrator.getServer().getWsClient().find(ResourceQuery.create(FILE_KEY))).isNotNull();
+ assertThat(getComponent(orchestrator, PROJECT_KEY)).isNotNull();
+ assertThat(getComponent(orchestrator, FILE_KEY)).isNotNull();
orchestrator.getServer().adminWsClient().post(DELETE_WS_ENDPOINT, "keys", PROJECT_KEY);
- assertThat(orchestrator.getServer().getWsClient().find(ResourceQuery.create(PROJECT_KEY))).isNull();
- assertThat(orchestrator.getServer().getWsClient().find(ResourceQuery.create(FILE_KEY))).isNull();
+ assertThat(getComponent(orchestrator, PROJECT_KEY)).isNull();
+ assertThat(getComponent(orchestrator, FILE_KEY)).isNull();
}
@Test
expectedException.expect(HttpException.class);
scanSampleWithDate(ANALYSIS_DATE);
- assertThat(orchestrator.getServer().getWsClient().find(ResourceQuery.create(PROJECT_KEY))).isNotNull();
- assertThat(orchestrator.getServer().getWsClient().find(ResourceQuery.create(FILE_KEY))).isNotNull();
+ assertThat(getComponent(orchestrator, PROJECT_KEY)).isNotNull();
+ assertThat(getComponent(orchestrator, FILE_KEY)).isNotNull();
// it's forbidden to delete only some files
orchestrator.getServer().adminWsClient().post(DELETE_WS_ENDPOINT, "keys", FILE_KEY);
expectedException.expect(HttpException.class);
scanSampleWithDate(ANALYSIS_DATE);
- assertThat(orchestrator.getServer().getWsClient().find(ResourceQuery.create(PROJECT_KEY))).isNotNull();
+ assertThat(getComponent(orchestrator, PROJECT_KEY)).isNotNull();
// use wsClient() instead of adminWsClient()
orchestrator.getServer().wsClient().post(DELETE_WS_ENDPOINT, "keys", PROJECT_KEY);
import org.sonar.wsclient.qualitygate.NewCondition;
import org.sonar.wsclient.qualitygate.QualityGate;
import org.sonar.wsclient.qualitygate.QualityGateClient;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import org.sonarqube.ws.client.PostRequest;
import org.sonarqube.ws.client.WsClient;
-import org.sonarqube.ws.client.setting.SettingsService;
import org.subethamail.wiser.Wiser;
import org.subethamail.wiser.WiserMessage;
import util.user.UserRule;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonarqube.ws.WsMeasures.Measure;
+import static util.ItUtils.getMeasure;
import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.newUserWsClient;
import static util.ItUtils.projectDir;
private static Wiser smtpServer;
- private static SettingsService adminSettingsService;
-
@BeforeClass
public static void init() throws Exception {
- adminSettingsService = newAdminWsClient(orchestrator).settingsService();
-
DEFAULT_QUALITY_GATE = qgClient().list().defaultGate().id();
setServerProperty(orchestrator, "sonar.timemachine.period1", "previous_analysis");
SonarScanner analysis = SonarScanner.create(projectDir("qualitygate/xoo-sample"));
orchestrator.executeBuild(analysis);
- assertThat(fetchGateStatus().getData()).isEqualTo("OK");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("OK");
orchestrator.executeBuild(analysis);
- assertThat(fetchGateStatus().getData()).isEqualTo("WARN");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("WARN");
qgClient().unsetDefault();
qgClient().destroy(simple.id());
assertThat(emails.hasNext()).isFalse();
}
- private Measure fetchGateStatus() {
- return fetchResourceWithGateStatus().getMeasure("alert_status");
- }
-
- private Resource fetchResourceWithGateStatus() {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT_KEY, "alert_status").setIncludeAlerts(true));
+ private Measure getGateStatusMeasure() {
+ return getMeasure(orchestrator, PROJECT_KEY, "alert_status");
}
private static QualityGateClient qgClient() {
import org.junit.ClassRule;
import org.junit.Test;
import org.sonar.wsclient.qualitygate.QualityGateClient;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsMeasures;
import org.sonarqube.ws.client.WsClient;
import org.sonarqube.ws.client.qualitygate.CreateConditionRequest;
import org.sonarqube.ws.client.qualitygate.QualityGatesService;
import org.sonarqube.ws.client.qualitygate.SelectWsRequest;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasure;
import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.resetSettings;
import static util.ItUtils.runProjectAnalysis;
runProjectAnalysis(orchestrator, "qualitygate/xoo-sample");
- assertThat(fetchGateStatus().getData()).isEqualTo("WARN");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("WARN");
}
@Test
// Run first analysis with empty quality gate -> quality gate is green
orchestrator.getServer().associateProjectToQualityProfile(PROJECT_KEY, "xoo", "empty");
runProjectAnalysis(orchestrator, "qualitygate/xoo-sample");
- assertThat(fetchGateStatus().getData()).isEqualTo("OK");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("OK");
// Run second analysis with some rules that makes Security Rating to E -> quality gate is red
orchestrator.getServer().restoreProfile(FileLocation.ofClasspath("/qualityGate/QualityGateOnRatingMeasuresTest/with-many-rules.xml"));
orchestrator.getServer().associateProjectToQualityProfile(PROJECT_KEY, "xoo", "with-many-rules");
runProjectAnalysis(orchestrator, "qualitygate/xoo-sample");
- assertThat(fetchGateStatus().getData()).isEqualTo("ERROR");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("ERROR");
}
- private Measure fetchGateStatus() {
- return fetchResourceWithGateStatus().getMeasure("alert_status");
- }
-
- private Resource fetchResourceWithGateStatus() {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT_KEY, "alert_status").setIncludeAlerts(true));
+ private WsMeasures.Measure getGateStatusMeasure() {
+ return getMeasure(orchestrator, PROJECT_KEY, "alert_status");
}
private static QualityGateClient qgClient() {
*/
package it.qualityGate;
+import com.google.gson.Gson;
import com.sonar.orchestrator.Orchestrator;
import com.sonar.orchestrator.build.BuildResult;
import com.sonar.orchestrator.build.SonarScanner;
import java.io.IOException;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.stream.Collectors;
import org.sonar.wsclient.qualitygate.NewCondition;
import org.sonar.wsclient.qualitygate.QualityGate;
import org.sonar.wsclient.qualitygate.QualityGateClient;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import org.sonarqube.ws.MediaTypes;
import org.sonarqube.ws.WsCe;
+import org.sonarqube.ws.WsMeasures.Measure;
import org.sonarqube.ws.WsQualityGates.ProjectStatusWsResponse;
import org.sonarqube.ws.client.GetRequest;
import org.sonarqube.ws.client.WsClient;
import org.sonarqube.ws.client.WsResponse;
import org.sonarqube.ws.client.qualitygate.ProjectStatusWsRequest;
+import util.ItUtils;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.groups.Tuple.tuple;
import static util.ItUtils.extractCeTaskId;
+import static util.ItUtils.getMeasure;
import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.projectDir;
verifyQGStatusInPostTask(buildResult, TASK_STATUS_SUCCESS, QG_STATUS_NO_QG);
- assertThat(fetchResourceWithGateStatus()).isNull();
+ assertThat(getGateStatusMeasure()).isNull();
}
@Test
verifyQGStatusInPostTask(buildResult, TASK_STATUS_SUCCESS, QG_STATUS_OK);
- assertThat(fetchGateStatus().getData()).isEqualTo("OK");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("OK");
} finally {
qgClient().unsetDefault();
qgClient().destroy(empty.id());
verifyQGStatusInPostTask(buildResult, TASK_STATUS_SUCCESS, QG_STATUS_OK);
- assertThat(fetchGateStatus().getData()).isEqualTo("OK");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("OK");
} finally {
qgClient().unsetDefault();
qgClient().destroy(simple.id());
verifyQGStatusInPostTask(buildResult, TASK_STATUS_SUCCESS, QG_STATUS_WARN);
- assertThat(fetchGateStatus().getData()).isEqualTo("WARN");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("WARN");
} finally {
qgClient().unsetDefault();
qgClient().destroy(simple.id());
verifyQGStatusInPostTask(buildResult, TASK_STATUS_SUCCESS, QG_STATUS_ERROR);
- assertThat(fetchGateStatus().getData()).isEqualTo("ERROR");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("ERROR");
} finally {
qgClient().unsetDefault();
qgClient().destroy(simple.id());
verifyQGStatusInPostTask(buildResult, TASK_STATUS_SUCCESS, QG_STATUS_ERROR);
- assertThat(fetchGateStatus().getData()).isEqualTo("ERROR");
+ assertThat(getGateStatusMeasure().getValue()).isEqualTo("ERROR");
} finally {
qgClient().unsetDefault();
qgClient().destroy(alert.id());
verifyQGStatusInPostTask(buildResult, TASK_STATUS_SUCCESS, QG_STATUS_WARN);
- Measure alertStatus = fetchGateStatus();
- assertThat(alertStatus.getData()).isEqualTo("WARN");
- assertThat(alertStatus.getAlertText())
- .contains("Lines of Code > 10")
- .contains("Duplicated Lines (%) > 20");
+ Measure alertStatus = getGateStatusMeasure();
+ assertThat(alertStatus.getValue()).isEqualTo("WARN");
+
+ String qualityGateDetailJson = ItUtils.getMeasure(orchestrator, PROJECT_KEY, "quality_gate_details").getValue();
+ assertThat(QualityGateDetails.parse(qualityGateDetailJson).getConditions())
+ .extracting(QualityGateDetails.Conditions::getMetric, QualityGateDetails.Conditions::getOp, QualityGateDetails.Conditions::getWarning)
+ .contains(tuple("ncloc", "GT", "10"), tuple("duplicated_lines_density", "GT", "20"));
} finally {
qgClient().unsetDefault();
qgClient().destroy(allTypes.id());
return props.getProperty("ceTaskId");
}
- private Measure fetchGateStatus() {
- return fetchResourceWithGateStatus().getMeasure("alert_status");
- }
-
- private Resource fetchResourceWithGateStatus() {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT_KEY, "alert_status").setIncludeAlerts(true));
+ private Measure getGateStatusMeasure() {
+ return getMeasure(orchestrator, PROJECT_KEY, "alert_status");
}
private static QualityGateClient qgClient() {
.filter(s -> s.contains(taskUuid))
.collect(Collectors.toList());
}
+
+ static class QualityGateDetails {
+
+ private String level;
+
+ private List<Conditions> conditions = new ArrayList<>();
+
+ String getLevel() {
+ return level;
+ }
+
+ List<Conditions> getConditions() {
+ return conditions;
+ }
+
+ public static QualityGateDetails parse(String json) {
+ Gson gson = new Gson();
+ return gson.fromJson(json, QualityGateDetails.class);
+ }
+
+ public static class Conditions {
+ private final String metric;
+ private final String op;
+ private final String warning;
+ private final String actual;
+ private final String level;
+
+ private Conditions(String metric, String op, String values, String actual, String level) {
+ this.metric = metric;
+ this.op = op;
+ this.warning = values;
+ this.actual = actual;
+ this.level = level;
+ }
+
+ String getMetric() {
+ return metric;
+ }
+
+ String getOp() {
+ return op;
+ }
+
+ String getWarning() {
+ return warning;
+ }
+
+ String getActual() {
+ return actual;
+ }
+
+ String getLevel() {
+ return level;
+ }
+ }
+ }
}
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasureAsDouble;
import static util.ItUtils.projectDir;
/**
orchestrator.getServer().associateProjectToQualityProfile(PROJECT, "xoo", "with-many-rules");
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- assertThat(getMeasure(PROJECT, CODE_SMELLS_METRIC).getValue()).isEqualTo(71);
- assertThat(getMeasure(PROJECT, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC).getValue()).isEqualTo(445);
- assertThat(getMeasure(PROJECT, MAINTAINABILITY_RATING_METRIC).getData()).isEqualTo("C");
- assertThat(getMeasure(PROJECT, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC).getValue()).isEqualTo(292);
-
- assertThat(getMeasure(MODULE, CODE_SMELLS_METRIC).getValue()).isEqualTo(43);
- assertThat(getMeasure(MODULE, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC).getValue()).isEqualTo(231);
- assertThat(getMeasure(MODULE, MAINTAINABILITY_RATING_METRIC).getData()).isEqualTo("C");
- assertThat(getMeasure(MODULE, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC).getValue()).isEqualTo(150);
-
- assertThat(getMeasure(SUB_MODULE, CODE_SMELLS_METRIC).getValue()).isEqualTo(19);
- assertThat(getMeasure(SUB_MODULE, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC).getValue()).isEqualTo(113);
- assertThat(getMeasure(SUB_MODULE, MAINTAINABILITY_RATING_METRIC).getData()).isEqualTo("C");
- assertThat(getMeasure(SUB_MODULE, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC).getValue()).isEqualTo(77);
-
- assertThat(getMeasure(DIRECTORY, CODE_SMELLS_METRIC).getValue()).isEqualTo(18);
- assertThat(getMeasure(DIRECTORY, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC).getValue()).isEqualTo(28);
- assertThat(getMeasure(DIRECTORY, MAINTAINABILITY_RATING_METRIC).getData()).isEqualTo("A");
- assertThat(getMeasure(DIRECTORY, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC).getValue()).isEqualTo(0);
-
- assertThat(getMeasure(FILE, CODE_SMELLS_METRIC).getValue()).isEqualTo(18);
- assertThat(getMeasure(FILE, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC).getValue()).isEqualTo(28);
- assertThat(getMeasure(FILE, MAINTAINABILITY_RATING_METRIC).getData()).isEqualTo("A");
- assertThat(getMeasure(FILE, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC)).isNull();
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, CODE_SMELLS_METRIC)).isEqualTo(71);
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC)).isEqualTo(445);
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, MAINTAINABILITY_RATING_METRIC)).isEqualTo(3);
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC)).isEqualTo(292);
+
+ assertThat(getMeasureAsDouble(orchestrator, MODULE, CODE_SMELLS_METRIC)).isEqualTo(43);
+ assertThat(getMeasureAsDouble(orchestrator, MODULE, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC)).isEqualTo(231);
+ assertThat(getMeasureAsDouble(orchestrator, MODULE, MAINTAINABILITY_RATING_METRIC)).isEqualTo(3);
+ assertThat(getMeasureAsDouble(orchestrator, MODULE, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC)).isEqualTo(150);
+
+ assertThat(getMeasureAsDouble(orchestrator, SUB_MODULE, CODE_SMELLS_METRIC)).isEqualTo(19);
+ assertThat(getMeasureAsDouble(orchestrator, SUB_MODULE, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC)).isEqualTo(113);
+ assertThat(getMeasureAsDouble(orchestrator, SUB_MODULE, MAINTAINABILITY_RATING_METRIC)).isEqualTo(3);
+ assertThat(getMeasureAsDouble(orchestrator, SUB_MODULE, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC)).isEqualTo(77);
+
+ assertThat(getMeasureAsDouble(orchestrator, DIRECTORY, CODE_SMELLS_METRIC)).isEqualTo(18);
+ assertThat(getMeasureAsDouble(orchestrator, DIRECTORY, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC)).isEqualTo(28);
+ assertThat(getMeasureAsDouble(orchestrator, DIRECTORY, MAINTAINABILITY_RATING_METRIC)).isEqualTo(1);
+ assertThat(getMeasureAsDouble(orchestrator, DIRECTORY, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC)).isZero();
+
+ assertThat(getMeasureAsDouble(orchestrator, FILE, CODE_SMELLS_METRIC)).isEqualTo(18);
+ assertThat(getMeasureAsDouble(orchestrator, FILE, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC)).isEqualTo(28);
+ assertThat(getMeasureAsDouble(orchestrator, FILE, MAINTAINABILITY_RATING_METRIC)).isEqualTo(1);
+ assertThat(getMeasureAsDouble(orchestrator, FILE, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC)).isZero();
}
@Test
orchestrator.getServer().associateProjectToQualityProfile(PROJECT, "xoo", "without-type-code-smells");
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- assertThat(getMeasure(PROJECT, CODE_SMELLS_METRIC).getIntValue()).isEqualTo(0);
- assertThat(getMeasure(PROJECT, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(0);
- assertThat(getMeasure(PROJECT, MAINTAINABILITY_RATING_METRIC).getData()).isEqualTo("A");
- assertThat(getMeasure(PROJECT, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC).getIntValue()).isEqualTo(0);
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, CODE_SMELLS_METRIC)).isZero();
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, MAINTAINABILITY_REMEDIATION_EFFORT_METRIC)).isZero();
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, MAINTAINABILITY_RATING_METRIC)).isEqualTo(1);
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, EFFORT_TO_REACH_MAINTAINABILITY_RATING_A_METRIC)).isZero();
}
- private Measure getMeasure(String resource, String metricKey) {
- Resource res = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(resource, metricKey));
- if (res == null) {
- return null;
- }
- return res.getMeasure(metricKey);
- }
}
import com.sonar.orchestrator.build.SonarScanner;
import com.sonar.orchestrator.locator.FileLocation;
import it.Category2Suite;
-import javax.annotation.CheckForNull;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasureAsDouble;
import static util.ItUtils.projectDir;
/**
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- assertThat(getMeasure(PROJECT, "sqale_rating").getIntValue()).isEqualTo(3);
- assertThat(getMeasure(PROJECT, "sqale_rating").getData()).isEqualTo("C");
-
- assertThat(getMeasure(MODULE, "sqale_rating").getIntValue()).isEqualTo(3);
- assertThat(getMeasure(MODULE, "sqale_rating").getData()).isEqualTo("C");
-
- assertThat(getMeasure(SUB_MODULE, "sqale_rating").getIntValue()).isEqualTo(3);
- assertThat(getMeasure(SUB_MODULE, "sqale_rating").getData()).isEqualTo("C");
-
- assertThat(getMeasure(DIRECTORY, "sqale_rating").getIntValue()).isEqualTo(1);
- assertThat(getMeasure(DIRECTORY, "sqale_rating").getData()).isEqualTo("A");
-
- assertThat(getMeasure(FILE, "sqale_rating").getIntValue()).isEqualTo(1);
- assertThat(getMeasure(FILE, "sqale_rating").getData()).isEqualTo("A");
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, "sqale_rating")).isEqualTo(3);
+ assertThat(getMeasureAsDouble(orchestrator, MODULE, "sqale_rating")).isEqualTo(3);
+ assertThat(getMeasureAsDouble(orchestrator, SUB_MODULE, "sqale_rating")).isEqualTo(3);
+ assertThat(getMeasureAsDouble(orchestrator, DIRECTORY, "sqale_rating")).isEqualTo(1);
+ assertThat(getMeasureAsDouble(orchestrator, FILE, "sqale_rating")).isEqualTo(1);
}
@Test
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- assertThat(getMeasure(PROJECT, "sqale_debt_ratio").getValue()).isEqualTo(29.1d);
- assertThat(getMeasure(MODULE, "sqale_debt_ratio").getValue()).isEqualTo(28.5d);
- assertThat(getMeasure(SUB_MODULE, "sqale_debt_ratio").getValue()).isEqualTo(31.4d);
- assertThat(getMeasure(DIRECTORY, "sqale_debt_ratio").getValue()).isEqualTo(7.8d);
- assertThat(getMeasure(FILE, "sqale_debt_ratio").getValue()).isEqualTo(7.8d);
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, "sqale_debt_ratio")).isEqualTo(29.1d);
+ assertThat(getMeasureAsDouble(orchestrator, MODULE, "sqale_debt_ratio")).isEqualTo(28.5d);
+ assertThat(getMeasureAsDouble(orchestrator, SUB_MODULE, "sqale_debt_ratio")).isEqualTo(31.4d);
+ assertThat(getMeasureAsDouble(orchestrator, DIRECTORY, "sqale_debt_ratio")).isEqualTo(7.8d);
+ assertThat(getMeasureAsDouble(orchestrator, FILE, "sqale_debt_ratio")).isEqualTo(7.8d);
}
@Test
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-sample")));
- Measure rating = getMeasure("sample", "sqale_rating");
- assertThat(rating.getIntValue()).isEqualTo(1);
- assertThat(rating.getData()).isEqualTo("A");
+ assertThat(getMeasureAsDouble(orchestrator, "sample", "sqale_rating")).isEqualTo(1);
debtConfiguration.updateDevelopmentCost(2);
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-sample")));
- rating = getMeasure("sample", "sqale_rating");
- assertThat(rating.getIntValue()).isEqualTo(4);
- assertThat(rating.getData()).isEqualTo("D");
+ assertThat(getMeasureAsDouble(orchestrator, "sample", "sqale_rating")).isEqualTo(4);
}
@Test
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- Measure rating = getMeasure(PROJECT, "sqale_rating");
- assertThat(rating.getIntValue()).isEqualTo(1);
- assertThat(rating.getData()).isEqualTo("A");
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, "sqale_rating")).isEqualTo(1);
debtConfiguration.updateLanguageDevelopmentCost("xoo", 1);
orchestrator.executeBuild(
SonarScanner.create(projectDir("shared/xoo-multi-modules-sample"))
.setProfile("one-issue-per-line"));
- rating = getMeasure(PROJECT, "sqale_rating");
- assertThat(rating.getIntValue()).isEqualTo(5);
- assertThat(rating.getData()).isEqualTo("E");
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, "sqale_rating")).isEqualTo(5);
}
@Test
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-sample")));
- Measure rating = getMeasure("sample", "sqale_rating");
- assertThat(rating.getIntValue()).isEqualTo(1);
- assertThat(rating.getData()).isEqualTo("A");
+ assertThat(getMeasureAsDouble(orchestrator, "sample", "sqale_rating")).isEqualTo(1);
debtConfiguration.updateRatingGrid(0.001d, 0.005d, 0.01d, 0.015d);
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-sample")));
- rating = getMeasure("sample", "sqale_rating");
- assertThat(rating.getIntValue()).isEqualTo(5);
- assertThat(rating.getData()).isEqualTo("E");
+ assertThat(getMeasureAsDouble(orchestrator, "sample", "sqale_rating")).isEqualTo(5);
}
@Test
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- assertThat(getMeasure(PROJECT, "sqale_rating").getData()).isEqualTo("C");
- assertThat(getMeasure(PROJECT, "effort_to_reach_maintainability_rating_a").getIntValue()).isEqualTo(292);
-
- assertThat(getMeasure(MODULE, "sqale_rating").getData()).isEqualTo("C");
- assertThat(getMeasure(MODULE, "effort_to_reach_maintainability_rating_a").getIntValue()).isEqualTo(150);
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, "sqale_rating")).isEqualTo(3);
+ assertThat(getMeasureAsDouble(orchestrator, PROJECT, "effort_to_reach_maintainability_rating_a")).isEqualTo(292);
- assertThat(getMeasure(SUB_MODULE, "sqale_rating").getData()).isEqualTo("C");
- assertThat(getMeasure(SUB_MODULE, "effort_to_reach_maintainability_rating_a").getIntValue()).isEqualTo(77);
+ assertThat(getMeasureAsDouble(orchestrator, MODULE, "sqale_rating")).isEqualTo(3);
+ assertThat(getMeasureAsDouble(orchestrator, MODULE, "effort_to_reach_maintainability_rating_a")).isEqualTo(150);
- assertThat(getMeasure(DIRECTORY, "sqale_rating").getData()).isEqualTo("A");
- assertThat(getMeasure(DIRECTORY, "effort_to_reach_maintainability_rating_a").getIntValue()).isEqualTo(0);
+ assertThat(getMeasureAsDouble(orchestrator, SUB_MODULE, "sqale_rating")).isEqualTo(3);
+ assertThat(getMeasureAsDouble(orchestrator, SUB_MODULE, "effort_to_reach_maintainability_rating_a")).isEqualTo(77);
- assertThat(getMeasure(FILE, "sqale_rating").getData()).isEqualTo("A");
- // Best value is 0 => no measure
- assertThat(getMeasure(FILE, "effort_to_reach_maintainability_rating_a")).isNull();
- }
+ assertThat(getMeasureAsDouble(orchestrator, DIRECTORY, "sqale_rating")).isEqualTo(1);
+ assertThat(getMeasureAsDouble(orchestrator, DIRECTORY, "effort_to_reach_maintainability_rating_a")).isZero();
- @CheckForNull
- private Measure getMeasure(String resource, String metricKey) {
- Resource res = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(resource, metricKey));
- if (res == null) {
- return null;
- }
- return res.getMeasure(metricKey);
+ assertThat(getMeasureAsDouble(orchestrator, FILE, "sqale_rating")).isEqualTo(1);
+ assertThat(getMeasureAsDouble(orchestrator, FILE, "effort_to_reach_maintainability_rating_a")).isZero();
}
}
import com.sonar.orchestrator.locator.FileLocation;
import it.Category2Suite;
import java.util.Date;
-import java.util.List;
+import java.util.Map;
import javax.annotation.Nullable;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import util.ItUtils;
import static org.apache.commons.lang.time.DateUtils.addDays;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.within;
import static util.ItUtils.formatDate;
+import static util.ItUtils.getPeriodMeasureValuesByIndex;
import static util.ItUtils.resetPeriods;
import static util.ItUtils.setServerProperty;
import static util.ItUtils.toDate;
}
private void assertNoNewDebtRatio() {
- assertThat(getFileResourceWithVariations(NEW_DEBT_RATIO_METRIC_KEY)).isNull();
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", NEW_DEBT_RATIO_METRIC_KEY)).isEmpty();
}
private void assertNewDebtRatio(@Nullable Double valuePeriod1, @Nullable Double valuePeriod2) {
- Resource newTechnicalDebt = getFileResourceWithVariations(NEW_DEBT_RATIO_METRIC_KEY);
- List<Measure> measures = newTechnicalDebt.getMeasures();
- assertThat(measures.get(0).getVariation1()).isEqualTo(valuePeriod1, within(0.01));
- assertThat(measures.get(0).getVariation2()).isEqualTo(valuePeriod2, within(0.01));
+ Map<Integer, Double> newTechnicalDebt = getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", NEW_DEBT_RATIO_METRIC_KEY);
+ assertThat(newTechnicalDebt.get(1)).isEqualTo(valuePeriod1, within(0.01));
+ assertThat(newTechnicalDebt.get(2)).isEqualTo(valuePeriod2, within(0.01));
}
private void setSampleProjectQualityProfile(String qualityProfileKey) {
"sonar.scm.disabled", "false"));
}
- private Resource getFileResourceWithVariations(String metricKey) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("sample:src/main/xoo/sample/Sample.xoo", metricKey).setIncludeTrends(true));
- }
-
}
import com.sonar.orchestrator.build.SonarScanner;
import com.sonar.orchestrator.locator.FileLocation;
import it.Category2Suite;
-import javax.annotation.CheckForNull;
+import java.util.Map;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsMeasures;
+import static java.lang.Double.parseDouble;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresByMetricKey;
import static util.ItUtils.projectDir;
public class ReliabilityMeasureTest {
private static final String RELIABILITY_REMEDIATION_EFFORT_METRIC = "reliability_remediation_effort";
private static final String RELIABILITY_RATING_METRIC = "reliability_rating";
+ private static final String[] METRICS = new String[] {BUGS_METRIC, RELIABILITY_RATING_METRIC, RELIABILITY_REMEDIATION_EFFORT_METRIC};
+
@ClassRule
public static Orchestrator orchestrator = Category2Suite.ORCHESTRATOR;
orchestrator.getServer().associateProjectToQualityProfile(PROJECT, "xoo", "with-many-rules");
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- assertThat(getMeasure(PROJECT, BUGS_METRIC).getIntValue()).isEqualTo(61);
- assertThat(getMeasure(PROJECT, RELIABILITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(305);
- assertThat(getMeasure(PROJECT, RELIABILITY_RATING_METRIC).getData()).isEqualTo("D");
-
- assertThat(getMeasure(MODULE, BUGS_METRIC).getIntValue()).isEqualTo(37);
- assertThat(getMeasure(MODULE, RELIABILITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(185);
- assertThat(getMeasure(MODULE, RELIABILITY_RATING_METRIC).getData()).isEqualTo("D");
-
- assertThat(getMeasure(SUB_MODULE, BUGS_METRIC).getIntValue()).isEqualTo(16);
- assertThat(getMeasure(SUB_MODULE, RELIABILITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(80);
- assertThat(getMeasure(SUB_MODULE, RELIABILITY_RATING_METRIC).getData()).isEqualTo("D");
-
- assertThat(getMeasure(DIRECTORY, BUGS_METRIC).getIntValue()).isEqualTo(16);
- assertThat(getMeasure(DIRECTORY, RELIABILITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(80);
- assertThat(getMeasure(DIRECTORY, RELIABILITY_RATING_METRIC).getData()).isEqualTo("D");
-
- assertThat(getMeasure(FILE, BUGS_METRIC).getIntValue()).isEqualTo(16);
- assertThat(getMeasure(FILE, RELIABILITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(80);
- assertThat(getMeasure(FILE, RELIABILITY_RATING_METRIC).getData()).isEqualTo("D");
+ assertMeasures(PROJECT, 61, 305, 4);
+ assertMeasures(MODULE, 37, 185, 4);
+ assertMeasures(SUB_MODULE, 16, 80, 4);
+ assertMeasures(DIRECTORY, 16, 80, 4);
+ assertMeasures(FILE, 16, 80, 4);
}
@Test
orchestrator.getServer().associateProjectToQualityProfile(PROJECT, "xoo", "without-type-bug");
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- assertThat(getMeasure(PROJECT, BUGS_METRIC).getIntValue()).isEqualTo(0);
- assertThat(getMeasure(PROJECT, RELIABILITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(0);
- assertThat(getMeasure(PROJECT, RELIABILITY_RATING_METRIC).getData()).isEqualTo("A");
+ assertMeasures(PROJECT, 0, 0, 1);
}
- @CheckForNull
- private Measure getMeasure(String resource, String metricKey) {
- Resource res = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(resource, metricKey));
- if (res == null) {
- return null;
- }
- return res.getMeasure(metricKey);
+ private void assertMeasures(String componentKey, int expectedBugs, int expectedReliabilityRemediationEffort, int expectedReliabilityRating) {
+ Map<String, WsMeasures.Measure> measures = getMeasuresByMetricKey(orchestrator, componentKey, METRICS);
+ assertThat(parseDouble(measures.get(BUGS_METRIC).getValue())).isEqualTo(expectedBugs);
+ assertThat(parseDouble(measures.get(RELIABILITY_REMEDIATION_EFFORT_METRIC).getValue())).isEqualTo(expectedReliabilityRemediationEffort);
+ assertThat(parseDouble(measures.get(RELIABILITY_RATING_METRIC).getValue())).isEqualTo(expectedReliabilityRating);
}
+
}
import com.sonar.orchestrator.build.SonarScanner;
import com.sonar.orchestrator.locator.FileLocation;
import it.Category2Suite;
-import javax.annotation.CheckForNull;
+import java.util.Map;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsMeasures;
+import static java.lang.Double.parseDouble;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresByMetricKey;
import static util.ItUtils.projectDir;
public class SecurityMeasureTest {
private static final String SECURITY_REMEDIATION_EFFORT_METRIC = "security_remediation_effort";
private static final String SECURITY_RATING_METRIC = "security_rating";
+ private static final String[] METRICS = new String[] {VULNERABILITIES_METRIC, SECURITY_REMEDIATION_EFFORT_METRIC, SECURITY_RATING_METRIC};
+
@ClassRule
public static Orchestrator orchestrator = Category2Suite.ORCHESTRATOR;
orchestrator.getServer().associateProjectToQualityProfile(PROJECT, "xoo", "with-many-rules");
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- assertThat(getMeasure(PROJECT, VULNERABILITIES_METRIC).getIntValue()).isEqualTo(4);
- assertThat(getMeasure(PROJECT, SECURITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(340);
- assertThat(getMeasure(PROJECT, SECURITY_RATING_METRIC).getData()).isEqualTo("E");
-
- assertThat(getMeasure(MODULE, VULNERABILITIES_METRIC).getIntValue()).isEqualTo(2);
- assertThat(getMeasure(MODULE, SECURITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(170);
- assertThat(getMeasure(MODULE, SECURITY_RATING_METRIC).getData()).isEqualTo("E");
-
- assertThat(getMeasure(SUB_MODULE, VULNERABILITIES_METRIC).getIntValue()).isEqualTo(1);
- assertThat(getMeasure(SUB_MODULE, SECURITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(85);
- assertThat(getMeasure(SUB_MODULE, SECURITY_RATING_METRIC).getData()).isEqualTo("E");
-
- assertThat(getMeasure(DIRECTORY, VULNERABILITIES_METRIC).getIntValue()).isEqualTo(0);
- assertThat(getMeasure(DIRECTORY, SECURITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(0);
- assertThat(getMeasure(DIRECTORY, SECURITY_RATING_METRIC).getData()).isEqualTo("A");
-
- assertThat(getMeasure(FILE, VULNERABILITIES_METRIC)).isNull();
- assertThat(getMeasure(FILE, SECURITY_REMEDIATION_EFFORT_METRIC)).isNull();
- assertThat(getMeasure(FILE, SECURITY_RATING_METRIC).getData()).isEqualTo("A");
+ assertMeasures(PROJECT, 4, 340, 5);
+ assertMeasures(MODULE, 2, 170, 5);
+ assertMeasures(SUB_MODULE, 1, 85, 5);
+ assertMeasures(DIRECTORY, 0, 0, 1);
+ assertMeasures(FILE, 0, 0, 1);
}
@Test
orchestrator.getServer().associateProjectToQualityProfile(PROJECT, "xoo", "without-type-vulnerability");
orchestrator.executeBuild(SonarScanner.create(projectDir("shared/xoo-multi-modules-sample")));
- assertThat(getMeasure(PROJECT, VULNERABILITIES_METRIC).getIntValue()).isEqualTo(0);
- assertThat(getMeasure(PROJECT, SECURITY_REMEDIATION_EFFORT_METRIC).getIntValue()).isEqualTo(0);
- assertThat(getMeasure(PROJECT, SECURITY_RATING_METRIC).getData()).isEqualTo("A");
+ assertMeasures(PROJECT, 0, 0, 1);
}
- @CheckForNull
- private Measure getMeasure(String resource, String metricKey) {
- Resource res = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(resource, metricKey));
- if (res == null) {
- return null;
- }
- return res.getMeasure(metricKey);
+ private void assertMeasures(String componentKey, int expectedVulnerabilities, int expectedReliabilityRemediationEffort, int expectedReliabilityRating) {
+ Map<String, WsMeasures.Measure> measures = getMeasuresByMetricKey(orchestrator, componentKey, METRICS);
+ assertThat(parseDouble(measures.get(VULNERABILITIES_METRIC).getValue())).isEqualTo(expectedVulnerabilities);
+ assertThat(parseDouble(measures.get(SECURITY_REMEDIATION_EFFORT_METRIC).getValue())).isEqualTo(expectedReliabilityRemediationEffort);
+ assertThat(parseDouble(measures.get(SECURITY_RATING_METRIC).getValue())).isEqualTo(expectedReliabilityRating);
}
}
import com.sonar.orchestrator.Orchestrator;
import com.sonar.orchestrator.locator.FileLocation;
import it.Category2Suite;
-import java.util.List;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Measure;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import util.ItUtils;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.entry;
+import static util.ItUtils.getPeriodMeasureValuesByIndex;
import static util.ItUtils.setServerProperty;
/**
runSampleProjectAnalysis();
// New technical debt only comes from new issues
- Resource newTechnicalDebt = getSampleProjectResourceWithVariations("new_technical_debt");
- List<Measure> measures = newTechnicalDebt.getMeasures();
- assertThat(measures.get(0).getVariation1()).isEqualTo(17);
- assertThat(measures.get(0).getVariation2()).isEqualTo(17);
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt"))
+ .contains(entry(1, 17d), entry(2, 17d));
// Third analysis, with exactly the same profile -> no new issues so no new technical debt
runSampleProjectAnalysis();
-
- newTechnicalDebt = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics("sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt").setIncludeTrends(true));
-
- // No variation => measure is purged
- assertThat(newTechnicalDebt).isNull();
+ // No variation => measure is 0 (best value)
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt"))
+ .contains(entry(1, 0d), entry(2, 0d));
}
@Test
// Third analysis, existing issues on OneIssuePerFile will have their technical debt updated with the effort to fix
runSampleProjectAnalysis("sonar.oneIssuePerFile.effortToFix", "10");
-
- Resource newTechnicalDebt = getSampleProjectResourceWithVariations("new_technical_debt");
- List<Measure> measures = newTechnicalDebt.getMeasures();
- assertThat(measures.get(0).getVariation1()).isEqualTo(90);
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt")
+ .get(1)).isEqualTo(90);
// Fourth analysis, with exactly the same profile -> no new issues so no new technical debt since previous analysis
runSampleProjectAnalysis("sonar.oneIssuePerFile.effortToFix", "10");
-
- newTechnicalDebt = getSampleProjectResourceWithVariations("new_technical_debt");
- measures = newTechnicalDebt.getMeasures();
- assertThat(measures.get(0).getVariation1()).isEqualTo(0);
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt")
+ .get(1)).isZero();
}
@Test
// Third analysis, existing issues on OneIssuePerFile will have their technical debt updated with the effort to fix
runSampleProjectAnalysis("sonar.oneIssuePerFile.effortToFix", "10");
-
- Resource newTechnicalDebt = getSampleProjectResourceWithVariations("new_technical_debt");
- List<Measure> measures = newTechnicalDebt.getMeasures();
- assertThat(measures.get(0).getVariation2()).isEqualTo(90);
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt")
+ .get(2)).isEqualTo(90);
// Fourth analysis, with exactly the same profile -> no new issues so no new technical debt since previous analysis but still since 30
// days
runSampleProjectAnalysis("sonar.oneIssuePerFile.effortToFix", "10");
-
- newTechnicalDebt = getSampleProjectResourceWithVariations("new_technical_debt");
- measures = newTechnicalDebt.getMeasures();
- assertThat(measures.get(0).getVariation2()).isEqualTo(90);
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt")
+ .get(2)).isEqualTo(90);
}
/**
// Execute a second analysis with a smaller effort to fix -> Added technical debt should be 0, not negative
runSampleProjectAnalysis("sonar.oneIssuePerFile.effortToFix", "10");
-
- Resource newTechnicalDebt = getSampleProjectResourceWithVariations("new_technical_debt");
- assertThat(newTechnicalDebt).isNull();
+ assertThat(getPeriodMeasureValuesByIndex(orchestrator, "sample:src/main/xoo/sample/Sample.xoo", "new_technical_debt"))
+ .contains(entry(1, 0d), entry(2, 0d));
}
private void setSampleProjectQualityProfile(String qualityProfileKey) {
ItUtils.runVerboseProjectAnalysis(TechnicalDebtMeasureVariationTest.orchestrator, "shared/xoo-sample", properties);
}
- private Resource getSampleProjectResourceWithVariations(String metricKey) {
- return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("sample:src/main/xoo/sample/Sample.xoo", metricKey).setIncludeTrends(true));
- }
-
}
import com.sonar.orchestrator.build.SonarScanner;
import it.Category2Suite;
import java.io.File;
+import java.util.Map;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.filefilter.TrueFileFilter;
import org.junit.ClassRule;
import org.junit.Test;
import org.skyscreamer.jsonassert.JSONAssert;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
import static util.ItUtils.projectDir;
public class CoverageTest {
public void coverage() throws Exception {
orchestrator.executeBuilds(SonarScanner.create(projectDir("testing/xoo-sample-ut-coverage")));
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("sample-ut-coverage", ALL_COVERAGE_METRICS));
- assertThat(project.getMeasureValue("line_coverage")).isEqualTo(50.0);
- assertThat(project.getMeasureValue("lines_to_cover")).isEqualTo(4);
- assertThat(project.getMeasureValue("uncovered_lines")).isEqualTo(2);
- assertThat(project.getMeasureValue("branch_coverage")).isEqualTo(50.0);
- assertThat(project.getMeasureValue("conditions_to_cover")).isEqualTo(2);
- assertThat(project.getMeasureValue("uncovered_conditions")).isEqualTo(1);
- assertThat(project.getMeasureValue("coverage")).isEqualTo(50.0);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, "sample-ut-coverage", ALL_COVERAGE_METRICS);
+ assertThat(measures.get("line_coverage")).isEqualTo(50.0);
+ assertThat(measures.get("lines_to_cover")).isEqualTo(4d);
+ assertThat(measures.get("uncovered_lines")).isEqualTo(2d);
+ assertThat(measures.get("branch_coverage")).isEqualTo(50.0);
+ assertThat(measures.get("conditions_to_cover")).isEqualTo(2d);
+ assertThat(measures.get("uncovered_conditions")).isEqualTo(1d);
+ assertThat(measures.get("coverage")).isEqualTo(50.0);
- assertThat(project.getMeasureValue("it_coverage")).isNull();
+ assertThat(measures.get("it_coverage")).isNull();
- assertThat(project.getMeasureValue("overall_coverage")).isNull();
+ assertThat(measures.get("overall_coverage")).isNull();
String coverage = cleanupScmAndDuplication(orchestrator.getServer().adminWsClient().get("api/sources/lines", "key", "sample-ut-coverage:src/main/xoo/sample/Sample.xoo"));
// Use strict checking to be sure IT coverage is not present
public void coverage_no_condition() throws Exception {
orchestrator.executeBuilds(SonarScanner.create(projectDir("testing/xoo-sample-ut-coverage-no-condition")));
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("sample-ut-coverage", ALL_COVERAGE_METRICS));
- assertThat(project.getMeasureValue("line_coverage")).isEqualTo(50.0);
- assertThat(project.getMeasureValue("lines_to_cover")).isEqualTo(4);
- assertThat(project.getMeasureValue("uncovered_lines")).isEqualTo(2);
- assertThat(project.getMeasureValue("branch_coverage")).isNull();
- assertThat(project.getMeasureValue("conditions_to_cover")).isNull();
- assertThat(project.getMeasureValue("uncovered_conditions")).isNull();
- assertThat(project.getMeasureValue("coverage")).isEqualTo(50.0);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, "sample-ut-coverage", ALL_COVERAGE_METRICS);
+ assertThat(measures.get("line_coverage")).isEqualTo(50.0);
+ assertThat(measures.get("lines_to_cover")).isEqualTo(4d);
+ assertThat(measures.get("uncovered_lines")).isEqualTo(2d);
+ assertThat(measures.get("branch_coverage")).isNull();
+ assertThat(measures.get("conditions_to_cover")).isNull();
+ assertThat(measures.get("uncovered_conditions")).isNull();
+ assertThat(measures.get("coverage")).isEqualTo(50.0);
- assertThat(project.getMeasureValue("it_coverage")).isNull();
+ assertThat(measures.get("it_coverage")).isNull();
- assertThat(project.getMeasureValue("overall_coverage")).isNull();
+ assertThat(measures.get("overall_coverage")).isNull();
String coverage = cleanupScmAndDuplication(orchestrator.getServer().adminWsClient().get("api/sources/lines", "key", "sample-ut-coverage:src/main/xoo/sample/Sample.xoo"));
// Use strict checking to be sure IT coverage is not present
public void it_coverage_imported_as_coverage() throws Exception {
orchestrator.executeBuilds(SonarScanner.create(projectDir("testing/xoo-sample-it-coverage")));
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("sample-it-coverage", ALL_COVERAGE_METRICS));
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, "sample-it-coverage", ALL_COVERAGE_METRICS);
// Since SQ 6.2 all coverage reports are merged as coverage
- assertThat(project.getMeasureValue("line_coverage")).isEqualTo(50.0);
- assertThat(project.getMeasureValue("lines_to_cover")).isEqualTo(4);
- assertThat(project.getMeasureValue("uncovered_lines")).isEqualTo(2);
- assertThat(project.getMeasureValue("branch_coverage")).isEqualTo(50.0);
- assertThat(project.getMeasureValue("conditions_to_cover")).isEqualTo(2);
- assertThat(project.getMeasureValue("uncovered_conditions")).isEqualTo(1);
- assertThat(project.getMeasureValue("coverage")).isEqualTo(50.0);
+ assertThat(measures.get("line_coverage")).isEqualTo(50.0);
+ assertThat(measures.get("lines_to_cover")).isEqualTo(4d);
+ assertThat(measures.get("uncovered_lines")).isEqualTo(2d);
+ assertThat(measures.get("branch_coverage")).isEqualTo(50.0);
+ assertThat(measures.get("conditions_to_cover")).isEqualTo(2d);
+ assertThat(measures.get("uncovered_conditions")).isEqualTo(1d);
+ assertThat(measures.get("coverage")).isEqualTo(50.0);
- assertThat(project.getMeasureValue("it_coverage")).isNull();
+ assertThat(measures.get("it_coverage")).isNull();
- assertThat(project.getMeasureValue("overall_coverage")).isNull();
+ assertThat(measures.get("overall_coverage")).isNull();
String coverage = cleanupScmAndDuplication(orchestrator.getServer().adminWsClient().get("api/sources/lines", "key", "sample-it-coverage:src/main/xoo/sample/Sample.xoo"));
// Use strict checking to be sure UT coverage is not present
// Since SQ 6.2 all coverage reports are merged as coverage
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("sample-overall-coverage", ALL_COVERAGE_METRICS));
- assertThat(project.getMeasureValue("line_coverage")).isEqualTo(75.0);
- assertThat(project.getMeasureValue("lines_to_cover")).isEqualTo(4);
- assertThat(project.getMeasureValue("uncovered_lines")).isEqualTo(1);
- assertThat(project.getMeasureValue("branch_coverage")).isEqualTo(50.0);
- assertThat(project.getMeasureValue("conditions_to_cover")).isEqualTo(4);
- assertThat(project.getMeasureValue("uncovered_conditions")).isEqualTo(2);
- assertThat(project.getMeasureValue("coverage")).isEqualTo(62.5);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, "sample-overall-coverage", ALL_COVERAGE_METRICS);
+ assertThat(measures.get("line_coverage")).isEqualTo(75.0);
+ assertThat(measures.get("lines_to_cover")).isEqualTo(4);
+ assertThat(measures.get("uncovered_lines")).isEqualTo(1);
+ assertThat(measures.get("branch_coverage")).isEqualTo(50.0);
+ assertThat(measures.get("conditions_to_cover")).isEqualTo(4);
+ assertThat(measures.get("uncovered_conditions")).isEqualTo(2);
+ assertThat(measures.get("coverage")).isEqualTo(62.5);
- assertThat(project.getMeasureValue("it_coverage")).isNull();
+ assertThat(measures.get("it_coverage")).isNull();
- assertThat(project.getMeasureValue("overall_coverage")).isNull();
+ assertThat(measures.get("overall_coverage")).isNull();
String coverage = cleanupScmAndDuplication(orchestrator.getServer().adminWsClient().get("api/sources/lines", "key", "sample-overall-coverage:src/main/xoo/sample/Sample.xoo"));
// Use strict checking to be sure no extra coverage is present
public void should_compute_coverage_on_project() {
orchestrator.executeBuilds(SonarScanner.create(projectDir("testing/xoo-half-covered")));
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("xoo-half-covered", ALL_COVERAGE_METRICS));
- assertThat(project.getMeasureValue("coverage")).isEqualTo(50.0);
+ assertThat(getMeasuresAsDoubleByMetricKey(orchestrator, "xoo-half-covered", ALL_COVERAGE_METRICS).get("coverage")).isEqualTo(50.0);
verifyComputeEngineTempDirIsEmpty();
}
orchestrator.executeBuilds(SonarScanner.create(projectDir("testing/xoo-half-covered"))
.setProperty("sonar.coverage.exclusions", "src/main/xoo/org/sonar/tests/halfcovered/UnCovered.xoo"));
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("xoo-half-covered", ALL_COVERAGE_METRICS));
- assertThat(project.getMeasureValue("coverage")).isEqualTo(100.0);
+ assertThat(getMeasuresAsDoubleByMetricKey(orchestrator, "xoo-half-covered", ALL_COVERAGE_METRICS).get("coverage")).isEqualTo(100.0);
verifyComputeEngineTempDirIsEmpty();
}
orchestrator.executeBuilds(SonarScanner.create(projectDir("testing/xoo-half-covered"))
.setProperty("sonar.coverage.exclusions", "**/UnCovered*"));
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("xoo-half-covered", ALL_COVERAGE_METRICS));
- assertThat(project.getMeasureValue("coverage")).isEqualTo(100.0);
+ assertThat(getMeasuresAsDoubleByMetricKey(orchestrator, "xoo-half-covered", ALL_COVERAGE_METRICS).get("coverage")).isEqualTo(100.0);
verifyComputeEngineTempDirIsEmpty();
}
orchestrator.executeBuilds(SonarScanner.create(projectDir("testing/xoo-half-covered"))
.setProperty("sonar.coverage.exclusions", "**/*"));
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics("xoo-half-covered", ALL_COVERAGE_METRICS));
- assertThat(project.getMeasureValue("coverage")).isNull();
+ assertThat(getMeasuresAsDoubleByMetricKey(orchestrator, "xoo-half-covered", ALL_COVERAGE_METRICS).get("coverage")).isNull();
verifyComputeEngineTempDirIsEmpty();
}
import com.sonar.orchestrator.Orchestrator;
import com.sonar.orchestrator.build.SonarScanner;
import it.Category2Suite;
+import java.util.Map;
import org.assertj.core.data.Offset;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsMeasures;
+import static java.lang.Double.parseDouble;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresWithVariationsByMetricKey;
import static util.ItUtils.projectDir;
public class NewCoverageTest {
@Test
public void new_coverage() throws Exception {
- Resource project = orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(PROJECT_KEY, ALL_NEW_COVERAGE_METRICS).setIncludeTrends(true));
- assertThat(project.getMeasure("new_coverage").getVariation1()).isEqualTo(66.6d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_line_coverage").getVariation1()).isEqualTo(100d, DEFAULT_OFFSET);
- assertThat(project.getMeasure("new_branch_coverage").getVariation1()).isEqualTo(42.8, DEFAULT_OFFSET);
+ Map<String, WsMeasures.Measure> measures = getMeasuresWithVariationsByMetricKey(orchestrator, PROJECT_KEY, ALL_NEW_COVERAGE_METRICS);
+ assertThat(parseDouble(measures.get("new_coverage").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(66.6d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_line_coverage").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(100d, DEFAULT_OFFSET);
+ assertThat(parseDouble(measures.get("new_branch_coverage").getPeriods().getPeriodsValue(0).getValue())).isEqualTo(42.8, DEFAULT_OFFSET);
}
}
import com.sonar.orchestrator.Orchestrator;
import com.sonar.orchestrator.build.SonarScanner;
import it.Category2Suite;
+import java.util.Map;
import org.apache.commons.io.IOUtils;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
import org.skyscreamer.jsonassert.JSONAssert;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
import static org.assertj.core.api.Assertions.assertThat;
+import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
import static util.ItUtils.projectDir;
public class TestExecutionTest {
public void test_execution_details() throws Exception {
orchestrator.executeBuilds(SonarScanner.create(projectDir("testing/xoo-sample-with-tests-execution-details")));
- Resource project = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics("sample-with-tests", "test_success_density", "test_failures", "test_errors", "tests", "skipped_tests", "test_execution_time"));
- assertThat(project.getMeasureValue("test_success_density")).isEqualTo(33.3);
- assertThat(project.getMeasureIntValue("test_failures")).isEqualTo(1);
- assertThat(project.getMeasureIntValue("test_errors")).isEqualTo(1);
- assertThat(project.getMeasureIntValue("tests")).isEqualTo(3);
- assertThat(project.getMeasureIntValue("skipped_tests")).isEqualTo(1);
- assertThat(project.getMeasureIntValue("test_execution_time")).isEqualTo(8);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, "sample-with-tests",
+ "test_success_density", "test_failures", "test_errors", "tests", "skipped_tests", "test_execution_time");
+ assertThat(measures.get("test_success_density")).isEqualTo(33.3);
+ assertThat(measures.get("test_failures")).isEqualTo(1);
+ assertThat(measures.get("test_errors")).isEqualTo(1);
+ assertThat(measures.get("tests")).isEqualTo(3);
+ assertThat(measures.get("skipped_tests")).isEqualTo(1);
+ assertThat(measures.get("test_execution_time")).isEqualTo(8);
String json = orchestrator.getServer().adminWsClient().get("api/tests/list", "testFileKey", "sample-with-tests:src/test/xoo/sample/SampleTest.xoo");
JSONAssert.assertEquals(IOUtils.toString(this.getClass().getResourceAsStream("/test/TestExecutionTest/expected.json"), "UTF-8"), json, false);
public void test_execution_measures() throws Exception {
orchestrator.executeBuilds(SonarScanner.create(projectDir("testing/xoo-sample-with-tests-execution-measures")));
- Resource project = orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics("sample-with-tests", "test_success_density", "test_failures", "test_errors", "tests", "skipped_tests", "test_execution_time"));
- assertThat(project.getMeasureValue("test_success_density")).isEqualTo(33.3);
- assertThat(project.getMeasureIntValue("test_failures")).isEqualTo(1);
- assertThat(project.getMeasureIntValue("test_errors")).isEqualTo(1);
- assertThat(project.getMeasureIntValue("tests")).isEqualTo(3);
- assertThat(project.getMeasureIntValue("skipped_tests")).isEqualTo(1);
- assertThat(project.getMeasureIntValue("test_execution_time")).isEqualTo(8);
+ Map<String, Double> measures = getMeasuresAsDoubleByMetricKey(orchestrator, "sample-with-tests",
+ "test_success_density", "test_failures", "test_errors", "tests", "skipped_tests", "test_execution_time");
+ assertThat(measures.get("test_success_density")).isEqualTo(33.3);
+ assertThat(measures.get("test_failures")).isEqualTo(1);
+ assertThat(measures.get("test_errors")).isEqualTo(1);
+ assertThat(measures.get("tests")).isEqualTo(3);
+ assertThat(measures.get("skipped_tests")).isEqualTo(1);
+ assertThat(measures.get("test_execution_time")).isEqualTo(8);
}
}
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
+import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import org.sonar.wsclient.issue.Issue;
import org.sonar.wsclient.issue.IssueClient;
import org.sonar.wsclient.issue.IssueQuery;
+import org.sonarqube.ws.WsComponents.Component;
+import org.sonarqube.ws.WsMeasures;
+import org.sonarqube.ws.WsMeasures.Measure;
+import org.sonarqube.ws.client.GetRequest;
import org.sonarqube.ws.client.HttpConnector;
import org.sonarqube.ws.client.WsClient;
import org.sonarqube.ws.client.WsClientFactories;
+import org.sonarqube.ws.client.component.ShowWsRequest;
+import org.sonarqube.ws.client.measure.ComponentWsRequest;
import org.sonarqube.ws.client.setting.ResetRequest;
import org.sonarqube.ws.client.setting.SetRequest;
import static com.google.common.base.Preconditions.checkState;
import static com.sonar.orchestrator.container.Server.ADMIN_LOGIN;
import static com.sonar.orchestrator.container.Server.ADMIN_PASSWORD;
+import static java.lang.Double.parseDouble;
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
resetSettings(orchestrator, null, "sonar.timemachine.period1", "sonar.timemachine.period2", "sonar.timemachine.period3");
}
+ @CheckForNull
+ public static Measure getMeasure(Orchestrator orchestrator, String componentKey, String metricKey) {
+ return getMeasuresByMetricKey(orchestrator, componentKey, metricKey).get(metricKey);
+ }
+
+ @CheckForNull
+ public static Double getMeasureAsDouble(Orchestrator orchestrator, String componentKey, String metricKey) {
+ Measure measure = getMeasure(orchestrator, componentKey, metricKey);
+ return (measure == null) ? null : Double.parseDouble(measure.getValue());
+ }
+
+ public static Map<String, Measure> getMeasuresByMetricKey(Orchestrator orchestrator, String componentKey, String... metricKeys) {
+ return getStreamMeasures(orchestrator, componentKey, metricKeys)
+ .filter(Measure::hasValue)
+ .collect(Collectors.toMap(Measure::getMetric, Function.identity()));
+ }
+
+ public static Map<String, Double> getMeasuresAsDoubleByMetricKey(Orchestrator orchestrator, String componentKey, String... metricKeys) {
+ return getStreamMeasures(orchestrator, componentKey, metricKeys)
+ .filter(Measure::hasValue)
+ .collect(Collectors.toMap(Measure::getMetric, measure -> parseDouble(measure.getValue())));
+ }
+
+ private static Stream<Measure> getStreamMeasures(Orchestrator orchestrator, String componentKey, String... metricKeys) {
+ return newWsClient(orchestrator).measures().component(new ComponentWsRequest()
+ .setComponentKey(componentKey)
+ .setMetricKeys(asList(metricKeys)))
+ .getComponent().getMeasuresList()
+ .stream();
+ }
+
+ @CheckForNull
+ public static Measure getMeasureWithVariations(Orchestrator orchestrator, String componentKey, String metricKey) {
+ WsMeasures.ComponentWsResponse response = newWsClient(orchestrator).measures().component(new ComponentWsRequest()
+ .setComponentKey(componentKey)
+ .setMetricKeys(singletonList(metricKey))
+ .setAdditionalFields(singletonList("periods")));
+ List<Measure> measures = response.getComponent().getMeasuresList();
+ return measures.size() == 1 ? measures.get(0) : null;
+ }
+
+ @CheckForNull
+ public static Map<String, Measure> getMeasuresWithVariationsByMetricKey(Orchestrator orchestrator, String componentKey, String... metricKeys) {
+ return newWsClient(orchestrator).measures().component(new ComponentWsRequest()
+ .setComponentKey(componentKey)
+ .setMetricKeys(asList(metricKeys))
+ .setAdditionalFields(singletonList("periods"))).getComponent().getMeasuresList()
+ .stream()
+ .collect(Collectors.toMap(Measure::getMetric, Function.identity()));
+ }
+
+ /**
+ * Return period values as string by period index (from 1 to 5)
+ */
+ public static Map<Integer, Double> getPeriodMeasureValuesByIndex(Orchestrator orchestrator, String componentKey, String metricKey) {
+ return getMeasureWithVariations(orchestrator, componentKey, metricKey).getPeriods().getPeriodsValueList().stream()
+ .collect(Collectors.toMap(WsMeasures.PeriodValue::getIndex, measure -> parseDouble(measure.getValue())));
+ }
+
+ @CheckForNull
+ public static Component getComponent(Orchestrator orchestrator, String componentKey) {
+ try {
+ return newWsClient(orchestrator).components().show(new ShowWsRequest().setKey((componentKey))).getComponent();
+ } catch (org.sonarqube.ws.client.HttpException e) {
+ if (e.code() == 404) {
+ return null;
+ }
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @CheckForNull
+ public static ComponentNavigation getComponentNavigation(Orchestrator orchestrator, String componentKey) {
+ // Waiting for SONAR-7745 to have version in api/components/show, we use internal api/navigation/component WS to get the component
+ // version
+ String content = newWsClient(orchestrator).wsConnector().call(new GetRequest("api/navigation/component").setParam("componentKey", componentKey)).failIfNotSuccessful()
+ .content();
+ return ComponentNavigation.parse(content);
+ }
+
+ public static class ComponentNavigation {
+ private String version;
+ private String snapshotDate;
+
+ public String getVersion() {
+ return version;
+ }
+
+ public Date getDate() {
+ return toDatetime(snapshotDate);
+ }
+
+ public static ComponentNavigation parse(String json) {
+ Gson gson = new Gson();
+ return gson.fromJson(json, ComponentNavigation.class);
+ }
+ }
+
/**
* Concatenates a vararg to a String array.
*
@Test
public void show_provided_project() {
- componentDb.insertComponent(newProjectDto(db.organizations().insert(), "project-uuid"));
+ componentDb.insertComponent(newProjectDto(db.organizations().insert(), "project-uuid").setEnabled(false));
ShowWsResponse response = newRequest("project-uuid", null);
<artifactId>sonar-update-center-common</artifactId>
<version>1.12.1</version>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>sonar-ws</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
import com.sonar.orchestrator.Orchestrator;
import com.sonar.orchestrator.build.MavenBuild;
import com.sonar.orchestrator.locator.FileLocation;
-import org.sonarsource.sonarqube.perf.PerfTestCase;
import java.io.IOException;
+import java.util.Map;
+import java.util.stream.Collectors;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.rules.ErrorCollector;
import org.junit.rules.TemporaryFolder;
-import org.sonar.wsclient.services.Resource;
-import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsMeasures;
+import org.sonarqube.ws.client.HttpConnector;
+import org.sonarqube.ws.client.WsClient;
+import org.sonarqube.ws.client.WsClientFactories;
+import org.sonarqube.ws.client.measure.ComponentWsRequest;
+import org.sonarsource.sonarqube.perf.PerfTestCase;
+import static java.lang.Double.parseDouble;
+import static java.util.Arrays.asList;
import static org.fest.assertions.Assertions.assertThat;
public class DuplicationTest extends PerfTestCase {
.setProperty("sonar.sourceEncoding", "UTF-8")
.setCleanSonarGoals();
orchestrator.executeBuild(build);
- Resource file = getResource("com.sonarsource.it.samples:huge-file:src/main/java/huge/HugeFile.java");
- assertThat(file.getMeasureValue("duplicated_lines")).isGreaterThan(50000.0);
+ Map<String, Double> measure = getMeasures("com.sonarsource.it.samples:huge-file:src/main/java/huge/HugeFile.java");
+ assertThat(measure.get("duplicated_lines")).isGreaterThan(50000.0);
+ }
+
+ private Map<String, Double> getMeasures(String key) {
+ return newWsClient().measures().component(new ComponentWsRequest()
+ .setComponentKey(key)
+ .setMetricKeys(asList("duplicated_lines", "duplicated_blocks", "duplicated_files", "duplicated_lines_density")))
+ .getComponent().getMeasuresList()
+ .stream()
+ .collect(Collectors.toMap(WsMeasures.Measure::getMetric, measure -> parseDouble(measure.getValue())));
}
- private Resource getResource(String key) {
- return orchestrator.getServer().getWsClient()
- .find(ResourceQuery.createForMetrics(key, "duplicated_lines", "duplicated_blocks", "duplicated_files", "duplicated_lines_density", "useless-duplicated-lines"));
+ private WsClient newWsClient() {
+ return WsClientFactories.getDefault().newClient(HttpConnector.newBuilder()
+ .url(orchestrator.getServer().getUrl())
+ .build());
}
}
<dependencies>
<dependency>
- <groupId>org.codehaus.sonar</groupId>
- <artifactId>sonar-ws-client</artifactId>
- <version>5.1</version>
+ <groupId>org.sonarsource.sonarqube</groupId>
+ <artifactId>sonar-ws</artifactId>
+ <version>${project.version}</version>
<scope>test</scope>
</dependency>
<dependency>
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Arrays;
+import java.util.Collections;
import org.apache.commons.io.IOUtils;
import org.junit.After;
import org.junit.Test;
import org.sonar.wsclient.services.ResourceQuery;
+import org.sonarqube.ws.WsMeasures.Measure;
import org.sonarqube.ws.client.GetRequest;
import org.sonarqube.ws.client.HttpConnector;
import org.sonarqube.ws.client.WsClient;
import org.sonarqube.ws.client.WsClientFactories;
import org.sonarqube.ws.client.WsResponse;
+import org.sonarqube.ws.client.measure.ComponentWsRequest;
import static com.codeborne.selenide.Condition.hasText;
import static com.codeborne.selenide.Selenide.$;
+import static java.lang.Integer.parseInt;
import static org.assertj.core.api.Assertions.assertThat;
public class UpgradeTest {
checkUrlIsReturningOk("/api/system/db_migration_status");
checkUrlIsReturningOk("/api/webservices/list");
// TODO Reactivate when latest Sonarqube version will be in repox
-// checkUrlIsReturningOkOnlyForDevVersion("/api/l10n/index", sqVersion);
+ // checkUrlIsReturningOkOnlyForDevVersion("/api/l10n/index", sqVersion);
// These urls should not be available when system requires a migration
checkUrlIsReturningNotFound("/api/issues/search?projectKeys=org.apache.struts%3Astruts-core");
}
private int countFiles(String key) {
+ if (orchestrator.getConfiguration().getSonarVersion().isGreaterThanOrEquals("5.4")) {
+ Measure measure = newWsClient(orchestrator).measures().component(new ComponentWsRequest().setComponentKey(key).setMetricKeys(Collections.singletonList("files")))
+ .getComponent().getMeasures(0);
+ return parseInt(measure.getValue());
+ }
return orchestrator.getServer().getWsClient().find(ResourceQuery.createForMetrics(key, "files")).getMeasureIntValue("files");
}
projects / sonarqube.git / commitdiff