Java Code Examples for hudson.model.Result#ABORTED

@Override
public void perform(
        @Nonnull Run<?, ?> run,
        @Nonnull FilePath filePath,
        @Nonnull Launcher launcher,
        @Nonnull TaskListener taskListener) throws InterruptedException, IOException {

    Result result = run.getResult();

    boolean success  = result == Result.SUCCESS  && whenSuccess;
    boolean unstable = result == Result.UNSTABLE && whenUnstable;
    boolean failed   = result == Result.FAILURE  && whenFailed;
    boolean aborted  = result == Result.ABORTED  && whenAborted;

    boolean neededToSend = success || unstable || failed || aborted;

    if (neededToSend) {
        TelegramBotRunner.getInstance().getBot()
                .sendMessage(getMessage(), run, filePath, taskListener);
    }
}
 

void processBuildResult(
        Result result,
        boolean commentOnSuccess,
        boolean commentWithConsoleLinkOnFailure,
        boolean runHarbormaster) {
    if (result == Result.SUCCESS) {
        if (comment.length() == 0 && (commentOnSuccess || !runHarbormaster)) {
            comment.append("Build is green");
        }
    } else if (result == Result.UNSTABLE) {
        comment.append("Build is unstable");
    } else if (result == Result.FAILURE) {
        if (!runHarbormaster || commentWithConsoleLinkOnFailure) {
            comment.append("Build has FAILED");
        }
    } else if (result == Result.ABORTED) {
        comment.append("Build was aborted");
    } else {
        logger.info(UBERALLS_TAG, "Unknown build status " + result.toString());
    }
}
 

@Test
public void DecisionMaker_OnPreviousBuild_StoresParameters() {

    // given
    Run run = mock(Run.class);
    Run previousRun = mock(Run.class);
    Result previousResult = Result.ABORTED;
    when(run.getPreviousBuild()).thenReturn(previousRun);
    when(previousRun.getResult()).thenReturn(previousResult);
    TaskListener taskListener = AbstractTest.mockListener();

    // when
    DecisionMaker decisionMaker = new DecisionMaker(run, taskListener);

    // then
    assertThat((Run) Deencapsulation.getField(decisionMaker, "run")).isSameAs(run);
    assertThat((TaskListener) Deencapsulation.getField(decisionMaker, "taskListener")).isSameAs(taskListener);
    assertThat((Result) Deencapsulation.getField(decisionMaker, "previousResult")).isEqualTo(previousResult);
}
 

@Test
public void calculateSummary_OnSuccess_ReturnsSuccess() {

    // given
    Result lastResult = Result.SUCCESS;
    boolean isRepeatedFailure = false;
    Result[] previousResults = {Result.SUCCESS, Result.NOT_BUILT, Result.ABORTED};

    for (Result previousResult : previousResults) {
        // when
        String status = cardBuilder.calculateSummary(lastResult, previousResult, isRepeatedFailure);

        // then
        assertThat(status).isEqualTo("Success");
    }
}
 

@Test
public void calculateStatus_OnSuccess_ReturnsSuccess() {

    // given
    Result lastResult = Result.SUCCESS;
    boolean isRepeatedFailure = false;
    Result[] previousResults = {Result.SUCCESS, Result.NOT_BUILT, Result.ABORTED};

    for (Result previousResult : previousResults) {
        // when
        String status = cardBuilder.calculateStatus(lastResult, previousResult, isRepeatedFailure);

        // then
        assertThat(status).isEqualTo("Build Success");
    }
}
 

String calculateSummary(Result completedResult, Result previousResult, boolean isRepeatedFailure) {

        if (completedResult == Result.SUCCESS) {
            // back to normal
            if (previousResult == Result.FAILURE || previousResult == Result.UNSTABLE) {
                return "Back to Normal";
            }
            // success remains
            return "Success";
        }
        if (completedResult == Result.FAILURE) {
            if (isRepeatedFailure) {
                return "Repeated Failure";
            }
            return "Failed";
        }
        if (completedResult == Result.ABORTED) {
            return "Aborted";
        }
        if (completedResult == Result.UNSTABLE) {
            return "Unstable";
        }

        return completedResult.toString();
    }
 

String calculateStatus(Result lastResult, Result previousResult, boolean isRepeatedFailure) {
    if (lastResult == Result.SUCCESS) {
        // back to normal
        if (previousResult == Result.FAILURE || previousResult == Result.UNSTABLE) {
            return "Back to Normal";
        }
        // success remains
        return "Build Success";
    }
    if (lastResult == Result.FAILURE) {
        if (isRepeatedFailure) {
            return "Repeated Failure";
        }
        return "Build Failed";
    }
    if (lastResult == Result.ABORTED) {
        return "Build Aborted";
    }
    if (lastResult == Result.UNSTABLE) {
        return "Build Unstable";
    }

    return lastResult.toString();
}
 

private String getNote(Run<?, ?> build, TaskListener listener) {
    String message;
    if (this.replaceSuccessNote && build.getResult() == Result.SUCCESS) {
        message = replaceMacros(build, listener, this.getSuccessNoteText());
    } else if (this.replaceAbortNote && build.getResult() == Result.ABORTED) {
        message = replaceMacros(build, listener, this.getAbortNoteText());
    } else if (this.replaceUnstableNote && build.getResult() == Result.UNSTABLE) {
        message = replaceMacros(build, listener, this.getUnstableNoteText());
    } else if (this.replaceFailureNote && build.getResult() == Result.FAILURE) {
        message = replaceMacros(build, listener, this.getFailureNoteText());
    } else {
        String icon = getResultIcon(build.getResult());
        String buildUrl = Jenkins.getInstance().getRootUrl() + build.getUrl();
        message = MessageFormat.format("{0} Jenkins Build {1}\n\nResults available at: [Jenkins [{2} #{3}]]({4})",
                                       icon, build.getResult().toString(), build.getParent().getDisplayName(), build.getNumber(), buildUrl);
    }
    return message;
}
 

private Run findLastCompletedBuild() {
    Run previousBuild = run.getPreviousBuild();
    while (previousBuild != null && previousBuild.getResult() == Result.ABORTED) {
        previousBuild = previousBuild.getPreviousCompletedBuild();
    }
    return previousBuild;
}
 

@Test
public void calculateStatus_OnAborted_ReturnsAborted() {

    // given
    Result lastResult = Result.ABORTED;
    boolean isRepeatedFailure = true;
    Result previousResult = null;

    // when
    String status = cardBuilder.calculateStatus(lastResult, previousResult, isRepeatedFailure);

    // then
    assertThat(status).isEqualTo("Build Aborted");
}
 

@Test
public void calculateSummary_OnAborted_ReturnsAborted() {

    // given
    Result lastResult = Result.ABORTED;
    boolean isRepeatedFailure = true;
    Result previousResult = null;

    // when
    String status = cardBuilder.calculateSummary(lastResult, previousResult, isRepeatedFailure);

    // then
    assertThat(status).isEqualTo("Aborted");
}
 

@Test
public void getCardThemeColor_OnAbortedResult_ReturnsBallColor() {
    // given
    Result abortedResult = Result.ABORTED;
    String ballColorString = Result.ABORTED.color.getHtmlBaseColor();

    // when
    String themeColor = Deencapsulation.invoke(CardBuilder.class, "getCardThemeColor", abortedResult);
    
    // then
    assertThat(themeColor).isEqualToIgnoringCase(ballColorString);
}
 

public NodeRunStatus(@Nonnull FlowNode endNode) {
    Result result = null;
    ErrorAction errorAction = endNode.getError();
    WarningAction warningAction = endNode.getPersistentAction(WarningAction.class);
    if (errorAction != null) {
        if(errorAction.getError() instanceof FlowInterruptedException) {
            result = ((FlowInterruptedException) errorAction.getError()).getResult();
        }
        if(result == null || result != Result.ABORTED) {
            this.result = BlueRun.BlueRunResult.FAILURE;
        } else {
            this.result = BlueRun.BlueRunResult.ABORTED;
        }
        this.state = endNode.isActive() ? BlueRun.BlueRunState.RUNNING : BlueRun.BlueRunState.FINISHED;
    } else if (warningAction != null) {
        this.result = new NodeRunStatus(GenericStatus.fromResult(warningAction.getResult())).result;
        this.state = endNode.isActive() ? BlueRun.BlueRunState.RUNNING : BlueRun.BlueRunState.FINISHED;
    } else if (QueueItemAction.getNodeState(endNode) == QueueItemAction.QueueState.QUEUED) {
        this.result = BlueRun.BlueRunResult.UNKNOWN;
        this.state = BlueRun.BlueRunState.QUEUED;
    } else if (QueueItemAction.getNodeState(endNode) == QueueItemAction.QueueState.CANCELLED) {
        this.result = BlueRun.BlueRunResult.ABORTED;
        this.state = BlueRun.BlueRunState.FINISHED;
    } else if (endNode.isActive()) {
        this.result = BlueRun.BlueRunResult.UNKNOWN;
        this.state = BlueRun.BlueRunState.RUNNING;
    } else if (NotExecutedNodeAction.isExecuted(endNode)) {
        this.result = BlueRun.BlueRunResult.SUCCESS;
        this.state = BlueRun.BlueRunState.FINISHED;
    } else {
        this.result = BlueRun.BlueRunResult.NOT_BUILT;
        this.state = BlueRun.BlueRunState.QUEUED;
    }
}
 

public CurrentBuildState waitForCompletion(final DynamicSubProject c, final TaskListener listener) throws InterruptedException {

        // wait for the completion
        int appearsCancelledCount = 0;
        while (true) {
            Thread.sleep(1000);
            final CurrentBuildState b = c.getCurrentStateByNumber(this.dynamicBuild.getNumber());
            if (b != null) { // its building or is done
                if (b.isBuilding()) {
                    continue;
                } else {
                    final Result buildResult = b.getResult();
                    if (buildResult != null) {
                        return b;
                    }
                }
            } else { // not building or done, check queue
                final Queue.Item qi = c.getQueueItem();
                if (qi == null) {
                    appearsCancelledCount++;
                    listener.getLogger().println(c.getName() + " appears cancelled: " + appearsCancelledCount);
                } else {
                    appearsCancelledCount = 0;
                }

                if (appearsCancelledCount >= 5) {
                    listener.getLogger().println(Messages.MatrixBuild_AppearsCancelled(ModelHyperlinkNote.encodeTo(c)));
                    return new CurrentBuildState("COMPLETED", Result.ABORTED);
                }
            }

        }
    }
 

private BuildStatus getStatus(Run<?, ?> build) {
    if (build == null) {
        return BuildStatus.NOT_FOUND;
    } else if (build.isBuilding()) {
        return BuildStatus.RUNNING;
    } else if (build.getResult() == Result.ABORTED) {
        return BuildStatus.CANCELED;
    } else if (build.getResult() == Result.SUCCESS) {
        return BuildStatus.SUCCESS;
    } else if (build.getResult() == Result.UNSTABLE) {
        return BuildStatus.UNSTABLE;
    } else {
        return BuildStatus.FAILED;
    }
}
 

@Override
public boolean perform(AbstractBuild<?, ?> build, Launcher launcher, BuildListener listener) throws InterruptedException, IOException {
    Result buildResult = build.getResult();
    if (buildResult == Result.SUCCESS || (buildResult == Result.UNSTABLE && markUnstableAsSuccess)) {
        CommitStatusUpdater.updateCommitStatus(build, listener, BuildState.success, name);
    } else if (buildResult == Result.ABORTED) {
        CommitStatusUpdater.updateCommitStatus(build, listener, BuildState.canceled, name);
    } else {
        CommitStatusUpdater.updateCommitStatus(build, listener, BuildState.failed, name);
    }
    return true;
}
 

private String getResultIcon(Result result) {
    if (result == Result.SUCCESS) {
        return ":white_check_mark:";
    } else if (result == Result.ABORTED) {
        return ":point_up:";
    } else if (result == Result.UNSTABLE) {
        return ":warning:";
    } else {
        return ":negative_squared_cross_mark:";
    }
}
 

private Result getResult(final CurrentBuildState run) {
    return run != null ? run.getResult() : Result.ABORTED;
}
 

private boolean isNotifyAborted(Result result, Webhook webhook) {
    return webhook.isNotifyAborted()
            && result == Result.ABORTED;
}
 

private boolean isCompletedOrAborted(){
    Result result = run.getResult();
    return result != null && (result == Result.ABORTED || result.isCompleteBuild());
}