@Override public boolean apply(InputFile f) { return key.equals(f.key()); } }
@Override public void store(DefaultCoverage defaultCoverage) { String fileKey = defaultCoverage.inputFile().key(); coverageByComponent.put(fileKey, defaultCoverage); }
@Override public void store(DefaultHighlighting highlighting) { String fileKey = highlighting.inputFile().key(); // Emulate duplicate storage check if (highlightingByComponent.containsKey(fileKey)) { throw new UnsupportedOperationException("Trying to save highlighting twice for the same file is not supported: " + highlighting.inputFile()); } highlightingByComponent.put(fileKey, highlighting); }
@Override public void store(DefaultSymbolTable symbolTable) { String fileKey = symbolTable.inputFile().key(); // Emulate duplicate storage check if (symbolsPerComponent.containsKey(fileKey)) { throw new UnsupportedOperationException("Trying to save symbol table twice for the same file is not supported: " + symbolTable.inputFile()); } symbolsPerComponent.put(fileKey, symbolTable); }
@Override public void store(DefaultCpdTokens defaultCpdTokens) { String fileKey = defaultCpdTokens.inputFile().key(); // Emulate duplicate storage check if (cpdTokensByComponent.containsKey(fileKey)) { throw new UnsupportedOperationException("Trying to save CPD tokens twice for the same file is not supported: " + defaultCpdTokens.inputFile()); } cpdTokensByComponent.put(fileKey, defaultCpdTokens); }
@Override public void store(DefaultSignificantCode significantCode) { String fileKey = significantCode.inputFile().key(); // Emulate duplicate storage check if (significantCodePerComponent.containsKey(fileKey)) { throw new UnsupportedOperationException("Trying to save significant code information twice for the same file is not supported: " + significantCode.inputFile()); } significantCodePerComponent.put(fileKey, significantCode); } }
private boolean isCoverageMeasuresAlreadyDefined(InputFile f) { Set<String> metricKeys = StreamSupport.stream(measureCache.byComponentKey(f.key()).spliterator(), false) .map(m -> m.metric().key()).collect(toSet()); Set<String> allCoverageMetricKeys = CoverageType.UNIT.allMetrics().stream().map(Metric::key).collect(toSet()); return !Sets.intersection(metricKeys, allCoverageMetricKeys).isEmpty(); }
public InputComponentStore put(String moduleKey, InputFile inputFile) { DefaultInputFile file = (DefaultInputFile) inputFile; addToLanguageCache(moduleKey, file); inputFileByModuleCache.put(moduleKey, file.getModuleRelativePath(), inputFile); globalInputFileCache.put(file.getProjectRelativePath(), inputFile); inputComponents.put(inputFile.key(), inputFile); filesByNameCache.put(inputFile.filename(), inputFile); filesByExtensionCache.put(FileExtensionPredicate.getExtension(inputFile), inputFile); return this; }
private Map<Integer, Object> loadData(String metricKey, Converter<? extends Object> converter) { DefaultMeasure<?> measure = measureCache.byMetric(inputFile.key(), metricKey); String data = measure != null ? (String) measure.value() : null; if (data != null) { return ImmutableMap.copyOf(KeyValueFormat.parse(data, KeyValueFormat.newIntegerConverter(), converter)); } // no such measure return ImmutableMap.of(); }
public Map<String, List<ScannerReport.Measure>> allMeasures() { Map<String, List<ScannerReport.Measure>> result = new HashMap<>(); List<ScannerReport.Measure> projectMeasures = new ArrayList<>(); try (CloseableIterator<ScannerReport.Measure> it = reader.readComponentMeasures(((DefaultInputComponent) project).scannerId())) { Iterators.addAll(projectMeasures, it); } result.put(project.key(), projectMeasures); for (InputFile inputFile : inputFilesByKeys.values()) { List<ScannerReport.Measure> measures = new ArrayList<>(); try (CloseableIterator<ScannerReport.Measure> it = reader.readComponentMeasures(((DefaultInputComponent) inputFile).scannerId())) { Iterators.addAll(measures, it); } result.put(inputFile.key(), measures); } return result; }
private void updateTestExecutionFromTestPlan(final InputFile inputFile) { final MutableTestPlan testPlan = testPlanBuilder.getTestPlanByFile(inputFile); if (testPlan == null || Iterables.isEmpty(testPlan.testCases())) { return; } long nonSkippedTests = StreamSupport.stream(testPlan.testCases().spliterator(), false).filter(t -> t.status() != Status.SKIPPED).count(); measureCache.put(inputFile.key(), TESTS_KEY, new DefaultMeasure<Integer>().forMetric(TESTS).withValue((int) nonSkippedTests)); long executionTime = StreamSupport.stream(testPlan.testCases().spliterator(), false).mapToLong(t -> t.durationInMs() != null ? t.durationInMs().longValue() : 0L).sum(); measureCache.put(inputFile.key(), TEST_EXECUTION_TIME_KEY, new DefaultMeasure<Long>().forMetric(TEST_EXECUTION_TIME).withValue(executionTime)); long errorTests = StreamSupport.stream(testPlan.testCases().spliterator(), false).filter(t -> t.status() == Status.ERROR).count(); measureCache.put(inputFile.key(), TEST_ERRORS_KEY, new DefaultMeasure<Integer>().forMetric(TEST_ERRORS).withValue((int) errorTests)); long skippedTests = StreamSupport.stream(testPlan.testCases().spliterator(), false).filter(t -> t.status() == Status.SKIPPED).count(); measureCache.put(inputFile.key(), SKIPPED_TESTS_KEY, new DefaultMeasure<Integer>().forMetric(SKIPPED_TESTS).withValue((int) skippedTests)); long failedTests = StreamSupport.stream(testPlan.testCases().spliterator(), false).filter(t -> t.status() == Status.FAILURE).count(); measureCache.put(inputFile.key(), TEST_FAILURES_KEY, new DefaultMeasure<Integer>().forMetric(TEST_FAILURES).withValue((int) failedTests)); }
private void saveCoverageMetricInternal(InputFile file, Metric<?> metric, DefaultMeasure<?> measure) { if (COVERAGE_BY_LINE_METRIC_KEYS.contains(metric.key())) { validateCoverageMeasure((String) measure.value(), file); DefaultMeasure<?> previousMeasure = measureCache.byMetric(file.key(), metric.key()); if (previousMeasure != null) { measureCache.put(file.key(), metric.key(), new DefaultMeasure<String>() .forMetric((Metric<String>) metric) .withValue(mergeCoverageLineMetric(metric, (String) previousMeasure.value(), (String) measure.value()))); } else { measureCache.put(file.key(), metric.key(), measure); } } else { // Other coverage metrics are all integer values. Just erase value, it will be recomputed at the end anyway measureCache.put(file.key(), metric.key(), measure); } }
private void createIndex(Iterable<InputFile> sourceFiles) { TokenChunker tokenChunker = JavaTokenProducer.build(); StatementChunker statementChunker = JavaStatementBuilder.build(); BlockChunker blockChunker = new BlockChunker(BLOCK_SIZE); for (InputFile inputFile : sourceFiles) { LOG.debug("Populating index from {}", inputFile); String resourceEffectiveKey = inputFile.key(); List<Statement> statements; try (InputStream is = inputFile.inputStream(); Reader reader = new InputStreamReader(is, inputFile.charset())) { statements = statementChunker.chunk(tokenChunker.chunk(reader)); } catch (FileNotFoundException e) { throw new IllegalStateException("Cannot find file " + inputFile.file(), e); } catch (IOException e) { throw new IllegalStateException("Exception handling file: " + inputFile.file(), e); } List<Block> blocks; try { blocks = blockChunker.chunk(resourceEffectiveKey, statements); } catch (Exception e) { throw new IllegalStateException("Cannot process file " + inputFile.file(), e); } index.insert(inputFile, blocks); } }
@Test public void should_save_file_measure() { InputFile file = new TestInputFileBuilder("foo", "src/Foo.php").build(); ArgumentCaptor<DefaultMeasure> argumentCaptor = ArgumentCaptor.forClass(DefaultMeasure.class); when(measureCache.put(eq(file.key()), eq(CoreMetrics.NCLOC_KEY), argumentCaptor.capture())).thenReturn(null); underTest.store(new DefaultMeasure() .on(file) .forMetric(CoreMetrics.NCLOC) .withValue(10)); DefaultMeasure m = argumentCaptor.getValue(); assertThat(m.value()).isEqualTo(10); assertThat(m.metric()).isEqualTo(CoreMetrics.NCLOC); }
@Test public void should_not_skip_file_measures_on_short_lived_branch_or_pull_request_when_file_status_is_SAME() { InputFile file = new TestInputFileBuilder("foo", "src/Foo.php").setStatus(InputFile.Status.SAME).build(); when(branchConfiguration.isShortOrPullRequest()).thenReturn(true); ArgumentCaptor<DefaultMeasure> argumentCaptor = ArgumentCaptor.forClass(DefaultMeasure.class); when(measureCache.put(eq(file.key()), eq(CoreMetrics.LINES_TO_COVER_KEY), argumentCaptor.capture())).thenReturn(null); underTest.store(new DefaultMeasure() .on(file) .forMetric(CoreMetrics.LINES_TO_COVER) .withValue(10)); DefaultMeasure m = argumentCaptor.getValue(); assertThat(m.value()).isEqualTo(10); assertThat(m.metric()).isEqualTo(CoreMetrics.LINES_TO_COVER); }
private void parseFiles(SMInputCursor fileCursor, SensorContext context) throws XMLStreamException { while (fileCursor.getNext() != null) { checkElementName(fileCursor, "file"); String filePath = mandatoryAttribute(fileCursor, "path"); InputFile inputFile = context.fileSystem().inputFile(context.fileSystem().predicates().hasPath(filePath)); if (inputFile == null) { numberOfUnknownFiles++; if (numberOfUnknownFiles <= MAX_STORED_UNKNOWN_FILE_PATHS) { firstUnknownFiles.add(filePath); } continue; } Preconditions.checkState( inputFile.language() != null, "Line %s of report refers to a file with an unknown language: %s", fileCursor.getCursorLocation().getLineNumber(), filePath); matchedFileKeys.add(inputFile.key()); NewCoverage newCoverage = context.newCoverage().onFile(inputFile); SMInputCursor lineToCoverCursor = fileCursor.childElementCursor(); while (lineToCoverCursor.getNext() != null) { parseLineToCover(lineToCoverCursor, newCoverage); } newCoverage.save(); } }
@Test public void scanProjectWithBranch() throws IOException { File srcDir = new File(baseDir, "src"); srcDir.mkdir(); File xooFile = new File(srcDir, "sample.xoo"); FileUtils.write(xooFile, "Sample xoo\ncontent"); AnalysisResult result = tester.newAnalysis() .properties(ImmutableMap.<String, String>builder() .putAll(commonProps) .put("sonar.branch", "branch") .build()) .execute(); assertThat(result.inputFiles()).hasSize(1); assertThat(result.inputFile("src/sample.xoo").key()).isEqualTo("com.foo.project:src/sample.xoo"); DefaultInputFile inputfile = (DefaultInputFile) result.inputFile("src/sample.xoo"); assertThat(result.getReportReader().readComponent(inputfile.scannerId()).getProjectRelativePath()).isEqualTo("src/sample.xoo"); assertThat(result.getReportReader().readMetadata().getDeprecatedBranch()).isEqualTo("branch"); result = tester.newAnalysis() .properties(ImmutableMap.<String, String>builder() .putAll(commonProps) .put("sonar.branch", "") .build()) .execute(); assertThat(result.inputFiles()).hasSize(1); assertThat(result.inputFile("src/sample.xoo").key()).isEqualTo("com.foo.project:src/sample.xoo"); }
@Override public void execute(final SensorContext context) { FileSystem fs = context.fileSystem(); for (InputFile f : fs.inputFiles(fs.predicates().hasType(Type.MAIN))) { if (((DefaultInputFile) f).isExcludedForCoverage()) { continue; } if (!isCoverageMeasuresAlreadyDefined(f)) { DefaultMeasure<String> execLines = (DefaultMeasure<String>) measureCache.byMetric(f.key(), CoreMetrics.EXECUTABLE_LINES_DATA_KEY); if (execLines != null) { storeZeroCoverageForEachExecutableLine(context, f, execLines); } } } }
@Test public void singleReport() { File projectDir = new File("test-resources/mediumtest/xoo/sample-generic-test-exec"); AnalysisResult result = tester .setLogOutput((msg, level) -> logs.add(msg)) .newAnalysis(new File(projectDir, "sonar-project.properties")) .property("sonar.testExecutionReportPaths", "unittest.xml") .execute(); InputFile testFile = result.inputFile("testx/ClassOneTest.xoo"); assertThat(result.allMeasures().get(testFile.key())).extracting("metricKey", "intValue.value", "longValue.value") .containsOnly( tuple(CoreMetrics.TESTS_KEY, 3, 0L), tuple(CoreMetrics.SKIPPED_TESTS_KEY, 1, 0L), tuple(CoreMetrics.TEST_ERRORS_KEY, 1, 0L), tuple(CoreMetrics.TEST_EXECUTION_TIME_KEY, 0, 1105L), tuple(CoreMetrics.TEST_FAILURES_KEY, 1, 0L)); assertThat(logs).noneMatch(l -> l.contains("Please use 'sonar.testExecutionReportPaths'")); }
@Test public void twoReports() { File projectDir = new File("test-resources/mediumtest/xoo/sample-generic-test-exec"); AnalysisResult result = tester .setLogOutput((msg, level) -> logs.add(msg)) .newAnalysis(new File(projectDir, "sonar-project.properties")) .property("sonar.testExecutionReportPaths", "unittest.xml,unittest2.xml") .execute(); InputFile testFile = result.inputFile("testx/ClassOneTest.xoo"); assertThat(result.allMeasures().get(testFile.key())).extracting("metricKey", "intValue.value", "longValue.value") .containsOnly( tuple(CoreMetrics.TESTS_KEY, 4, 0L), tuple(CoreMetrics.SKIPPED_TESTS_KEY, 2, 0L), tuple(CoreMetrics.TEST_ERRORS_KEY, 1, 0L), tuple(CoreMetrics.TEST_EXECUTION_TIME_KEY, 0, 1610L), tuple(CoreMetrics.TEST_FAILURES_KEY, 1, 0L)); assertThat(logs).noneMatch(l -> l.contains("Please use 'sonar.testExecutionReportPaths'")); }