import org.sonar.api.ExtensionPoint;
import org.sonar.api.ce.ComputeEngineSide;
import org.sonar.ce.task.projectanalysis.analysis.AnalysisMetadataHolder;
+import org.sonar.ce.task.projectanalysis.analysis.Branch;
/**
* Extension point that is called during processing of a task
* Return the ncloc computed for the current analysis
*/
int getNcloc();
+
+ /**
+ * Return the organization
+ */
+ String getOrganizationUuid();
+
+ /**
+ * Return the organization
+ */
+ String getOrganizationKey();
+
+ /**
+ * Return the branch of the project
+ */
+ Branch getBranch();
}
}
import org.sonar.api.ce.ComputeEngineSide;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.ce.task.projectanalysis.analysis.AnalysisMetadataHolder;
+import org.sonar.ce.task.projectanalysis.analysis.Branch;
import org.sonar.ce.task.projectanalysis.component.TreeRootHolder;
import org.sonar.ce.task.projectanalysis.metric.Metric;
import org.sonar.ce.task.projectanalysis.metric.MetricRepository;
private final PostMeasuresComputationCheck[] extensions;
public PostMeasuresComputationChecksStep(TreeRootHolder treeRootHolder, MetricRepository metricRepository, MeasureRepository measureRepository,
- AnalysisMetadataHolder analysisMetadataHolder,
- PostMeasuresComputationCheck[] extensions) {
+ AnalysisMetadataHolder analysisMetadataHolder, PostMeasuresComputationCheck[] extensions) {
this.treeRootHolder = treeRootHolder;
this.metricRepository = metricRepository;
this.measureRepository = measureRepository;
Optional<Measure> nclocMeasure = measureRepository.getRawMeasure(treeRootHolder.getRoot(), nclocMetric);
return nclocMeasure.isPresent() ? nclocMeasure.get().getIntValue() : 0;
}
+
+ @Override
+ public String getOrganizationUuid() {
+ return analysisMetadataHolder.getOrganization().getUuid();
+ }
+
+ @Override
+ public String getOrganizationKey() {
+ return analysisMetadataHolder.getOrganization().getKey();
+ }
+
+ @Override
+ public Branch getBranch() {
+ return analysisMetadataHolder.getBranch();
+ }
}
}
try {
Organization organization = analysisMetadata.getOrganization();
BillingValidations.Organization billingOrganization = new BillingValidations.Organization(organization.getKey(), organization.getUuid());
- billingValidations.checkOnProjectAnalysis(billingOrganization);
+ billingValidations.checkBeforeProjectAnalysis(billingOrganization);
} catch (BillingValidations.BillingValidationsException e) {
throw MessageException.of(e.getMessage());
}
public void execute_fails_with_MessageException_when_organization_is_not_allowed_to_execute_analysis() {
doThrow(new BillingValidationsException("This organization cannot execute project analysis"))
.when(validations)
- .checkOnProjectAnalysis(any(BillingValidations.Organization.class));
+ .checkBeforeProjectAnalysis(any(BillingValidations.Organization.class));
VerifyBillingStep underTest = new VerifyBillingStep(analysisMetadata, validations);
VerifyBillingStep underTest = new VerifyBillingStep(analysisMetadata, validations);
underTest.execute();
- verify(validations).checkOnProjectAnalysis(orgCaptor.capture());
+ verify(validations).checkBeforeProjectAnalysis(orgCaptor.capture());
BillingValidations.Organization calledOrg = orgCaptor.getValue();
assertThat(calledOrg.getKey()).isEqualTo(organization.getKey());
}
/**
* @throws BillingValidationsException when projects analysis on organization is not allowed
*/
- void checkOnProjectAnalysis(Organization organization);
+ void checkBeforeProjectAnalysis(Organization organization);
/**
* @throws BillingValidationsException when the organization cannot use private projects
}
@Override
- public void checkOnProjectAnalysis(Organization organization) {
+ public void checkBeforeProjectAnalysis(Organization organization) {
if (billingValidationsExtension == null) {
return;
}
- billingValidationsExtension.checkOnProjectAnalysis(organization);
+ billingValidationsExtension.checkBeforeProjectAnalysis(organization);
}
@Override
underTest = new BillingValidationsProxyImpl(billingValidationsExtension);
Organization organization = new Organization(ORGANIZATION_KEY, ORGANIZATION_UUID);
- underTest.checkOnProjectAnalysis(organization);
+ underTest.checkBeforeProjectAnalysis(organization);
- verify(billingValidationsExtension).checkOnProjectAnalysis(organization);
+ verify(billingValidationsExtension).checkBeforeProjectAnalysis(organization);
}
@Test
underTest = new BillingValidationsProxyImpl();
Organization organization = new Organization(ORGANIZATION_KEY, ORGANIZATION_UUID);
- underTest.checkOnProjectAnalysis(organization);
+ underTest.checkBeforeProjectAnalysis(organization);
verifyZeroInteractions(billingValidationsExtension);
}