Examples with Status jetbrains.buildServer.messages.Status used on opensource projects

Example 1 with Status

use of jetbrains.buildServer.messages.Status in project teamcity-rest by JetBrains.

the class TestOccurrenceFinder method tryGetCachedInfo.

/**
 * Checks whether response can be built only using ShortStatistics without fetching test occurrences given locator and fields. If so, get this statistics.
 * In addition, check if test runs in a returned statistics require filtering.
 * @return ShortStatistics with a post filtering flag if there is enough data to produce the response, TestOccurrencesCachedInfo.empty() otherwise.
 */
@NotNull
public TestOccurrencesCachedInfo tryGetCachedInfo(@Nullable final String locatorText, @Nullable final String fieldsText) {
    if (locatorText == null || fieldsText == null)
        return TestOccurrencesCachedInfo.empty();
    Locator locator = Locator.locator(locatorText);
    Fields fields = new Fields(fieldsText);
    boolean postFilteringRequired = false;
    boolean needsActualOccurrence = fields.isIncluded("testOccurrence", false, false);
    if (needsActualOccurrence) {
        Status status = Util.resolveNull(locator.lookupSingleDimensionValue(STATUS), TestOccurrence::getStatusFromPosted);
        if (status == null || status != Status.FAILURE) {
            return TestOccurrencesCachedInfo.empty();
        }
        Fields occurrenceFields = fields.getNestedField("testOccurrence");
        FieldInclusionChecker checker = FieldInclusionChecker.getForClass(TestOccurrence.class);
        if (!FASTPATH_ALLOWED_FIELDS.containsAll(checker.getAllPotentiallyIncludedFields(occurrenceFields))) {
            return TestOccurrencesCachedInfo.empty();
        }
        // let's just do it always if we need items
        postFilteringRequired = true;
    }
    String buildDimension = locator.getSingleDimensionValue(BUILD);
    if (buildDimension == null)
        return TestOccurrencesCachedInfo.empty();
    if (locator.getSingleDimensionValueAsStrictBoolean(EXPAND_INVOCATIONS, false)) {
        // Expand invocations requires additional logic
        return TestOccurrencesCachedInfo.empty();
    }
    List<BuildPromotion> buildPromotions = myBuildFinder.getBuilds(null, buildDimension).myEntries;
    if (buildPromotions.size() != 1) {
        // If there is not a single build to the criteria,
        return TestOccurrencesCachedInfo.empty();
    }
    SBuild build = buildPromotions.get(0).getAssociatedBuild();
    if (build == null)
        return TestOccurrencesCachedInfo.empty();
    // let's not construct a filter if we already know that we want to filter anyways
    if (!postFilteringRequired) {
        // If any kind of filter is defined then post filtering is necessary
        MultiCheckerFilter<STestRun> filter = (MultiCheckerFilter<STestRun>) getFilter(locator);
        // Personal builds filter is always there
        postFilteringRequired = filter.getSubFiltersCount() > 1;
    }
    return new TestOccurrencesCachedInfo(build.getShortStatistics(), postFilteringRequired);
}

Example 2 with Status

use of jetbrains.buildServer.messages.Status in project teamcity-rest by JetBrains.

the class BuildRequest method serveAggregatedBuildStatus.

@GET
@Path("/aggregated/{buildLocator}/status")
@ApiOperation(value = "Get the build status of aggregated matching builds.", nickname = "getAggregatedBuildStatus")
public String serveAggregatedBuildStatus(@ApiParam(format = LocatorName.BUILD) @PathParam("buildLocator") String locator) {
    final PagedSearchResult<BuildPromotion> builds = myBuildPromotionFinder.getItems(locator);
    Status resultingStatus = Status.UNKNOWN;
    for (BuildPromotion buildPromotion : builds.myEntries) {
        final SBuild build = buildPromotion.getAssociatedBuild();
        if (build != null) {
            final Status status = build.getStatusDescriptor().getStatus();
            resultingStatus = Status.getWorstStatus(resultingStatus, status);
        }
    }
    return resultingStatus.getText();
}

Example 3 with Status

use of jetbrains.buildServer.messages.Status in project teamcity-rest by JetBrains.

the class ChangeStatus method initCounters.

private void initCounters() {
    // This is heavily inspired by ChangeDetailsCalculator, but with some simplifications, so not reusing it here.
    SecurityContext context = myBeanContext.getSingletonService(SecurityContext.class);
    SUser self = (SUser) context.getAuthorityHolder().getAssociatedUser();
    myCriticalCollector = new BuildsCollector(myFields.getNestedField("criticalBuilds"));
    myCompilationErrorCollector = new BuildsCollector(myFields.getNestedField("compilationErrorBuilds"));
    myNewTestsFailedCollector = new BuildsCollector(myFields.getNestedField("newTestsFailedBuilds"));
    myNotCriticalCollector = new BuildsCollector(myFields.getNestedField("notCriticalBuilds"));
    final boolean includePersonalBuilds = self != null && StringUtil.isTrue(self.getPropertyValue(StandardProperties.SHOW_ALL_PERSONAL_BUILDS));
    for (BuildTypeChangeStatus status : myChangeStatus.getBuildTypesStatus().values()) {
        final SBuild firstBuild = status.getFirstBuild();
        if (firstBuild == null) {
            SQueuedBuild queued = status.getQueuedBuild();
            if (queued != null && (includePersonalBuilds || !queued.isPersonal())) {
                myQueuedBuildsCount++;
            }
            if (status.getQueuedBuild() == null) {
                myPendingCount++;
            }
            continue;
        }
        if (firstBuild.isPersonal() && !includePersonalBuilds) {
            continue;
        }
        if (firstBuild.getCanceledInfo() != null) {
            myCancelledCount++;
            continue;
        }
        if (firstBuild.isFinished()) {
            myFinishedBuildsCount++;
            if (status.isSuccessful()) {
                mySuccessfulBuildsCount++;
                // no need to count problems, as our build is green
                continue;
            }
        } else {
            myRunningBuildsCount++;
            Status runningBuildStatus = firstBuild.getBuildStatus();
            if (runningBuildStatus.isSuccessful()) {
                myRunningSuccessfullyCount++;
                // no need to count problems, as our build is green
                continue;
            }
        }
        myFailedBuildsCount++;
        String statusText = BuildStatusText.getBuildStatus(firstBuild, self);
        final BuildPromotionEx buildPromo = (BuildPromotionEx) firstBuild.getBuildPromotion();
        switch(statusText) {
            case BuildStatusText.NEW_TESTS_FAILED:
                myNewTestsFailedCollector.put(buildPromo);
                break;
            case BuildStatusText.CRITICAL_PROBLEM:
                myCriticalCollector.put(buildPromo);
                break;
            case BuildStatusText.COMPILATION_ERROR:
                myCompilationErrorCollector.put(buildPromo);
                break;
            default:
                myNotCriticalCollector.put(buildPromo);
        }
        for (BuildProblem problem : buildPromo.getBuildProblems()) {
            if (problem.isMutedInBuild())
                continue;
            if (problem.getBuildProblemData().getType().equals(BuildProblemData.TC_FAILED_TESTS_TYPE) || ErrorData.isSnapshotDependencyError(problem.getBuildProblemData().getType()))
                continue;
            myTotalProblemCount++;
        }
    }
}

Example 4 with Status

use of jetbrains.buildServer.messages.Status in project teamcity-rest by JetBrains.

the class TestOccurrenceFinder method getFilter.

@NotNull
@Override
public ItemFilter<STestRun> getFilter(@NotNull final Locator locator) {
    final MultiCheckerFilter<STestRun> result = new MultiCheckerFilter<>();
    if (locator.isUnused(DIMENSION_ID)) {
        Long testRunId = locator.getSingleDimensionValueAsLong(DIMENSION_ID);
        // If someone voluntarily excluded personal build when searching by test run id, then assume that is exactly what they want.
        // Otherwise, return a test run in a personal build by default.
        locator.setDimensionIfNotPresent(INCLUDE_PERSONAL, "true");
        if (testRunId != null) {
            result.add(item -> testRunId.intValue() == item.getTestRunId());
        }
    }
    Status status = Util.resolveNull(locator.getSingleDimensionValue(STATUS), TestOccurrence::getStatusFromPosted);
    if (status != null) {
        result.add(item -> status.equals(item.getStatus()));
    }
    final Boolean ignoredDimension = locator.getSingleDimensionValueAsBoolean(IGNORED);
    if (ignoredDimension != null) {
        result.add(item -> FilterUtil.isIncludedByBooleanFilter(ignoredDimension, item.isIgnored()));
    }
    final String nameDimension = locator.getSingleDimensionValue(NAME);
    if (nameDimension != null) {
        ValueCondition nameCondition = ParameterCondition.createValueConditionFromPlainValueOrCondition(nameDimension);
        result.add(item -> nameCondition.matches(item.getTest().getName().getAsString()));
    }
    if (locator.getUnusedDimensions().contains(TEST)) {
        String testDimension = locator.getSingleDimensionValue(TEST);
        if (testDimension != null) {
            final PagedSearchResult<STest> tests = myTestFinder.getItems(testDimension);
            final HashSet<Long> testNameIds = new HashSet<>();
            for (STest test : tests.myEntries) {
                testNameIds.add(test.getTestNameId());
            }
            result.add(item -> testNameIds.contains(item.getTest().getTestNameId()));
        }
    }
    if (locator.isUnused(BUILD)) {
        String buildDimension = locator.getSingleDimensionValue(BUILD);
        if (buildDimension != null) {
            // Include test runs from personal build if user is looking for one specific build.
            boolean searchByBuildId = new Locator(buildDimension).isAnyPresent(BuildFinder.DIMENSION_ID);
            locator.setDimensionIfNotPresent(INCLUDE_PERSONAL, Boolean.toString(searchByBuildId));
            // todo: use buildPromotionFinder, use filter; drop personal builds filtering in test history
            List<BuildPromotion> builds = myBuildFinder.getBuilds(null, buildDimension).myEntries;
            result.add(item -> builds.contains(item.getBuild().getBuildPromotion()));
        }
    }
    if (locator.isUnused(BRANCH)) {
        String branchDimension = locator.getSingleDimensionValue(BRANCH);
        if (branchDimension != null) {
            Filter<STestRun> branchFilter = getBranchFilter(branchDimension);
            result.add(branchFilter::accept);
        }
    }
    if (locator.isUnused(BUILD_TYPE)) {
        String buildTypeDimension = locator.getSingleDimensionValue(BUILD_TYPE);
        if (buildTypeDimension != null) {
            final SBuildType buildType = myBuildTypeFinder.getBuildType(null, buildTypeDimension, false);
            result.add(item -> item.getBuild().getBuildTypeId().equals(buildType.getInternalId()));
        }
    }
    final Boolean currentlyInvestigatedDimension = locator.getSingleDimensionValueAsBoolean(CURRENTLY_INVESTIGATED);
    if (currentlyInvestigatedDimension != null) {
        result.add(item -> {
            // todo: check investigation in affected Project/buildType only, if set
            return FilterUtil.isIncludedByBooleanFilter(currentlyInvestigatedDimension, isCurrentlyInvestigated(item));
        });
    }
    final String investigationState = locator.getSingleDimensionValue(INVESTIGATION_STATE);
    if (investigationState != null) {
        result.add(hasInvestigationStateFilter(investigationState));
    }
    final Boolean currentlyMutedDimension = locator.getSingleDimensionValueAsBoolean(CURRENTLY_MUTED);
    if (currentlyMutedDimension != null) {
        // it is important to filter even if prefiltered items processed the tests as that does not consider mute scope
        result.add(item -> {
            // todo: check mute in affected Project/buildType only, if set
            return FilterUtil.isIncludedByBooleanFilter(currentlyMutedDimension, isCurrentlyMuted(item));
        });
    }
    final Boolean newFailure = locator.getSingleDimensionValueAsBoolean(NEW_FAILURE);
    if (newFailure != null) {
        // when newFailure is specified, do not match non-failed tests. This matches the logic of newFailure attribute presence in TestOccurrence
        result.add(item -> item.getStatus().isFailed() && FilterUtil.isIncludedByBooleanFilter(newFailure, item.isNewFailure()));
    }
    final Boolean muteDimension = locator.getSingleDimensionValueAsBoolean(MUTED);
    if (muteDimension != null) {
        result.add(item -> FilterUtil.isIncludedByBooleanFilter(muteDimension, item.isMuted()));
    }
    if (locator.isUnused(CURRENT)) {
        final Boolean currentDimension = locator.getSingleDimensionValueAsBoolean(CURRENT);
        if (currentDimension != null) {
            // todo: is this the same as the test occurring in current problems???
            result.add(item -> FilterUtil.isIncludedByBooleanFilter(currentDimension, !item.isFixed()));
        }
    }
    final String scopeDimension = locator.getSingleDimensionValue(SCOPE);
    if (scopeDimension != null) {
        final TestScopeFilter filter = myTestScopeFilterProducer.createFromLocatorString(scopeDimension);
        result.add(item -> filter.test(item));
    }
    if (locator.getUnusedDimensions().contains(INVOCATIONS)) {
        final String dimensionValue = locator.getSingleDimensionValue(INVOCATIONS);
        if (dimensionValue != null) {
            result.add(item -> {
                Collection<STestRun> testRuns = getInvocations(item);
                FinderSearchMatcher<STestRun> matcher = new FinderSearchMatcher<>(dimensionValue, new DelegatingAbstractFinder<STestRun>(TestOccurrenceFinder.this) {

                    @Nullable
                    @Override
                    public STestRun findSingleItem(@NotNull final Locator locator1) {
                        return null;
                    }

                    @NotNull
                    @Override
                    public ItemHolder<STestRun> getPrefilteredItems(@NotNull final Locator locator1) {
                        return getItemHolder(testRuns);
                    }
                });
                return matcher.matches(null);
            });
        }
    }
    // Exclude test runs form personal builds by default to , if not included by a special cases above.
    Filter<STestRun> personalBuildsFilter = getPersonalBuildsFilter(locator);
    result.add(personalBuildsFilter::accept);
    return result;
}