Java Result类代码示例

import hudson.model.Result; //导入依赖的package包/类
@Test public void junitResultArchiver() throws Exception {
    WorkflowJob p = r.jenkins.createProject(WorkflowJob.class, "p");
    p.setDefinition(new CpsFlowDefinition(
              "node {\n"
            + "    writeFile text: '''<testsuite name='a'><testcase name='a1'/><testcase name='a2'><error>a2 failed</error></testcase></testsuite>''', file: 'a.xml'\n"
            + "    writeFile text: '''<testsuite name='b'><testcase name='b1'/><testcase name='b2'/></testsuite>''', file: 'b.xml'\n"
            + "    junit '*.xml'\n"
            + "}", true));
    WorkflowRun b = r.assertBuildStatus(Result.UNSTABLE, p.scheduleBuild2(0).get());
    TestResultAction a = b.getAction(TestResultAction.class);
    assertNotNull(a);
    assertEquals(4, a.getTotalCount());
    assertEquals(1, a.getFailCount());
    List<FlowNode> coreStepNodes = new DepthFirstScanner().filteredNodes(b.getExecution(), new NodeStepTypePredicate("step"));
    assertThat(coreStepNodes, Matchers.hasSize(1));
    assertEquals("*.xml", ArgumentsAction.getStepArgumentsAsString(coreStepNodes.get(0)));
}
 

import hudson.model.Result; //导入依赖的package包/类
public static boolean isRelevant(OTCNotifier notifier, String phase, Result result){
    boolean onStarted;
    boolean onCompleted;
    boolean onFinalized;
    boolean failureOnly;

    //Make sure OTC Notifier was found in the publisherList
    if(notifier != null){
        onStarted = notifier.getOnStarted();
        onCompleted = notifier.getOnCompleted();
        onFinalized = notifier.getOnFinalized();
        failureOnly = notifier.getFailureOnly();

        if(onStarted && "STARTED".equals(phase) || onCompleted && "COMPLETED".equals(phase)
                || onFinalized && "FINALIZED".equals(phase)){//check selections
            if(failureOnly && result != null && result.equals(Result.FAILURE) || !failureOnly){//check failureOnly
                return true;
            }
        }
    }

    return false;
}
 

import hudson.model.Result; //导入依赖的package包/类
@Override public void onFailure(StepContext context, Throwable t) {
    try {
        TaskListener listener = context.get(TaskListener.class);
        Result r = Result.FAILURE;
        if (t instanceof AbortException) {
            listener.error(t.getMessage());
        } else if (t instanceof FlowInterruptedException) {
            FlowInterruptedException fie = (FlowInterruptedException) t;
            fie.handle(context.get(Run.class), listener);
            r = fie.getResult();
        } else {
            listener.getLogger().println(Functions.printThrowable(t).trim()); // TODO 2.43+ use Functions.printStackTrace
        }
        context.get(Run.class).setResult(r);
        context.onSuccess(null);
    } catch (Exception x) {
        context.onFailure(x);
    }
}
 

import hudson.model.Result; //导入依赖的package包/类
@Test public void failure() {
    story.addStep(new Statement() {
        @Override public void evaluate() throws Throwable {
            WorkflowJob p = story.j.jenkins.createProject(WorkflowJob.class, "p");
            p.setDefinition(new CpsFlowDefinition("waitUntil {semaphore 'wait'}", true));
            WorkflowRun b = p.scheduleBuild2(0).waitForStart();
            SemaphoreStep.waitForStart("wait/1", b);
            SemaphoreStep.success("wait/1", false);
            SemaphoreStep.waitForStart("wait/2", b);
            String message = "broken condition";
            SemaphoreStep.failure("wait/2", new AbortException(message));
            // TODO the following fails (missing message) when run as part of whole suite, but not standalone: story.j.assertLogContains(message, story.j.assertBuildStatus(Result.FAILURE, story.j.waitForCompletion(b)));
            story.j.waitForCompletion(b);
            story.j.assertBuildStatus(Result.FAILURE, b);
            story.j.assertLogContains(message, b); // TODO observed to flake on windows-8-2.32.3: see two `semaphore`s and a “Will try again after 0.25 sec” but no such message
        }
    });
}
 

import hudson.model.Result; //导入依赖的package包/类
@Issue("JENKINS-41276")
@Test
public void abortShouldNotRetry() throws Exception {
    r.jenkins.setSecurityRealm(r.createDummySecurityRealm());
    WorkflowJob p = r.jenkins.createProject(WorkflowJob.class, "p");
    p.setDefinition(new CpsFlowDefinition(
            "int count = 0; retry(3) { echo 'trying '+(count++); semaphore 'start'; echo 'NotHere' } echo 'NotHere'", true));
    final WorkflowRun b = p.scheduleBuild2(0).waitForStart();
    SemaphoreStep.waitForStart("start/1", b);
    ACL.impersonate(User.get("dev").impersonate(), new Runnable() {
        @Override public void run() {
            b.getExecutor().doStop();
        }
    });
    r.assertBuildStatus(Result.ABORTED, r.waitForCompletion(b));
    r.assertLogContains("trying 0", b);
    r.assertLogContains("Aborted by dev", b);
    r.assertLogNotContains("trying 1", b);
    r.assertLogNotContains("trying 2", b);
    r.assertLogNotContains("NotHere", b);

}
 

import hudson.model.Result; //导入依赖的package包/类
@Test public void toolWithoutSymbol() throws Exception {
    File toolHome = folder.newFolder("mockTools");
    MockToolWithoutSymbol tool = new MockToolWithoutSymbol("mock-tool-without-symbol", toolHome.getAbsolutePath(), JenkinsRule.NO_PROPERTIES);
    Jenkins.getInstance().getDescriptorByType(MockToolWithoutSymbol.MockToolWithoutSymbolDescriptor.class).setInstallations(tool);

    WorkflowJob p = r.jenkins.createProject(WorkflowJob.class, "p");
    p.setDefinition(new CpsFlowDefinition("node {def home = tool name: '" + tool.getName() + "', type: 'mockToolWithoutSymbol'}",
            true));

    r.assertLogContains("No mockToolWithoutSymbol named mock-tool-without-symbol found",
            r.assertBuildStatus(Result.FAILURE, p.scheduleBuild2(0)));

    p.setDefinition(new CpsFlowDefinition("node {def home = tool name: '" + tool.getName() + "', type: '" + MockToolWithoutSymbol.class.getName() + "'\n"
            + "echo \"${home}\"}",
            true));
    r.assertLogContains(toolHome.getAbsolutePath(),
            r.assertBuildStatusSuccess(p.scheduleBuild2(0)));
}
 

import hudson.model.Result; //导入依赖的package包/类
@Test public void specialStatus() throws Exception {
    User.get("smrt");
    WorkflowJob p = r.jenkins.createProject(WorkflowJob.class, "p");
    p.setDefinition(new CpsFlowDefinition(
            "catchError {\n" +
            "  semaphore 'specialStatus'\n" +
            "}", true));
    SemaphoreStep.failure("specialStatus/1", new FlowInterruptedException(Result.UNSTABLE, new CauseOfInterruption.UserInterruption("smrt")));
    WorkflowRun b = p.scheduleBuild2(0).get();
    r.assertLogContains("smrt", r.assertBuildStatus(Result.UNSTABLE, b));
    /* TODO fixing this is trickier since CpsFlowExecution.setResult does not implement a public method, and anyway CatchErrorStep in its current location could not refer to FlowExecution:
    List<FlowNode> heads = b.getExecution().getCurrentHeads();
    assertEquals(1, heads.size());
    assertEquals(Result.UNSTABLE, ((FlowEndNode) heads.get(0)).getResult());
    */
}
 

import hudson.model.Result; //导入依赖的package包/类
@Test
public void downstreamJobTriggerByRestrictedUser() throws Exception {
    String allowedUsername = "foo";
    UserSelector selector = new UserSelector(allowedUsername);
    JobRestriction restriction = new StartedByUserRestriction(singletonList(selector), false, false, false);
    setUpDiskPoolRestriction(restriction);

    authenticate(allowedUsername);
    WorkflowRun upstreamRun = createWorkflowJobAndRun();

    j.assertBuildStatusSuccess(upstreamRun);
    j.assertLogContains(format("Selected Disk ID '%s' from the Disk Pool ID '%s'", DISK_ID_ONE, DISK_POOL_ID), upstreamRun);

    String notAllowedUsername = "bar";
    authenticate(notAllowedUsername);

    WorkflowJob downstreamJob = j.jenkins.createProject(WorkflowJob.class, randomAlphanumeric(7));
    downstreamJob.setDefinition(new CpsFlowDefinition(format("" +
            "def run = selectRun '%s' \n" +
            "exwsAllocate selectedRun: run", upstreamRun.getParent().getFullName())));
    WorkflowRun downstreamRun = downstreamJob.scheduleBuild2(0, new CauseAction(new Cause.UserIdCause())).get();

    j.assertBuildStatus(Result.FAILURE, downstreamRun);
    j.assertLogContains(format("Disk Pool identified by '%s' is not accessible due to the applied Disk Pool restriction: Started By User", DISK_POOL_ID), downstreamRun);
}
 

import hudson.model.Result; //导入依赖的package包/类
@Test
public void notAllowedGroup() throws Exception {
    String username = "foobar";
    String group = "allowed";

    GroupSelector groupSelector = new GroupSelector("not-allowed-group");
    JobRestriction restriction = new StartedByMemberOfGroupRestriction(singletonList(groupSelector), false);
    setUpDiskPoolRestriction(restriction);

    JenkinsRule.DummySecurityRealm securityRealm = j.createDummySecurityRealm();
    securityRealm.addGroups(username, group);
    j.jenkins.setSecurityRealm(securityRealm);

    authenticate(username);
    WorkflowRun run = createWorkflowJobAndRun();

    j.assertBuildStatus(Result.FAILURE, run);
    j.assertLogContains(format("Disk Pool identified by '%s' is not accessible due to the applied Disk Pool restriction: Started By member of group", DISK_POOL_ID), run);
}
 

import hudson.model.Result; //导入依赖的package包/类
@Test
@Parameters({"fastestWriteSpeed(estimatedWorkspaceSize: 300)",
             "[$class: 'FastestWriteSpeedStrategy'\\, estimatedWorkspaceSize: 300]"})
public void diskHasNotEnoughUsableSpace(String strategy) throws Exception {
    // The Disk mounting point parameter isn't an actual mount.
    // Therefore, the disk's usable space will be 0, and the job will fail as expected
    Disk disk = new Disk("disk", null, "not-an-actual-mounting-point", null, null);
    DiskPool diskPool = TestUtil.createDiskPool(disk);
    TestUtil.setUpDiskPools(j.jenkins, diskPool);
    long estimatedWorkspaceSize = 300;

    WorkflowRun run = TestUtil.createWorkflowJobAndRun(j.jenkins, format("" +
            "exwsAllocate diskPoolId: '%s', " +
            " strategy: %s", diskPool.getDiskPoolId(), strategy));

    j.assertBuildStatus(Result.FAILURE, run);
    j.assertLogContains(format("Using Disk allocation strategy: '%s'", new FastestWriteSpeedStrategy().getDescriptor().getDisplayName()), run);
    j.assertLogContains(format("Couldn't find any Disk with at least %s MB usable space", estimatedWorkspaceSize), run);
}
 

import hudson.model.Result; //导入依赖的package包/类
private String runToBuildPhase(Run run) {
	if (run != null && !run.hasntStartedYet()) {
		if (run.isBuilding()) {
			return BuildPhases.RUNNING;
		} else {
			Result result = run.getResult();
			if (result != null) {
				if (result.equals(Result.SUCCESS)) {
					return BuildPhases.COMPLETE;
				} else if (result.equals(Result.ABORTED)) {
					return BuildPhases.CANCELLED;
				} else if (result.equals(Result.FAILURE)) {
					return BuildPhases.FAILED;
				} else if (result.equals(Result.UNSTABLE)) {
					return BuildPhases.FAILED;
				} else {
					return BuildPhases.PENDING;
				}
			}
		}
	}
	return BuildPhases.NEW;
}
 

import hudson.model.Result; //导入依赖的package包/类
@Test
public void testBuildThenWaitThenSuccess() throws Exception {
    setUpBuildEnvironment();
    Build inProgress = new Build().withBuildStatus(StatusType.IN_PROGRESS).withStartTime(new Date(1));
    Build succeeded = new Build().withBuildStatus(StatusType.SUCCEEDED.toString().toUpperCase()).withStartTime(new Date(2));
    when(mockClient.batchGetBuilds(any(BatchGetBuildsRequest.class))).thenReturn(
            new BatchGetBuildsResult().withBuilds(inProgress),
            new BatchGetBuildsResult().withBuilds(inProgress),
            new BatchGetBuildsResult().withBuilds(succeeded));
    CodeBuilder test = createDefaultCodeBuilder();
    ArgumentCaptor<Result> savedResult = ArgumentCaptor.forClass(Result.class);

    test.perform(build, ws, launcher, listener);

    verify(build).setResult(savedResult.capture());
    assertEquals(savedResult.getValue(), Result.SUCCESS);
}
 

import hudson.model.Result; //导入依赖的package包/类
@Test
public void testBuildThenWaitThenFails() throws Exception {
    setUpBuildEnvironment();
    Build inProgress = new Build().withBuildStatus(StatusType.IN_PROGRESS).withStartTime(new Date(1));
    Build failed = new Build().withBuildStatus(StatusType.FAILED).withStartTime(new Date(2));
    when(mockClient.batchGetBuilds(any(BatchGetBuildsRequest.class))).thenReturn(
            new BatchGetBuildsResult().withBuilds(inProgress),
            new BatchGetBuildsResult().withBuilds(inProgress),
            new BatchGetBuildsResult().withBuilds(failed));
    CodeBuilder test = createDefaultCodeBuilder();
    ArgumentCaptor<Result> savedResult = ArgumentCaptor.forClass(Result.class);

    test.perform(build, ws, launcher, listener);

    verify(build).setResult(savedResult.capture());
    assertEquals(savedResult.getValue(), Result.FAILURE);
}
 

import hudson.model.Result; //导入依赖的package包/类
@Override
public boolean perform(AbstractBuild<?, ?> build, Launcher launcher, BuildListener listener)
        throws InterruptedException, IOException {

    try {
        GoogleRobotCredentials credentials = GoogleRobotCredentials.getById(getCredentialsId());
        GoogleDriveManager driveManager = new GoogleDriveManager(authorize(credentials));

        String pattern = Util.replaceMacro(getPattern(), build.getEnvironment(listener));
        String workspace = build.getWorkspace().getRemote();
        String[] filesToUpload = listFiles(workspace, pattern);
        for (String file : filesToUpload) {
            listener.getLogger().println("Uploading file: " + file);
            driveManager.store(file, getDriveLocation());
        }
    } catch (GeneralSecurityException e) {
        build.setResult(Result.FAILURE);
        return false;
    }
    return true;
}
 

import hudson.model.Result; //导入依赖的package包/类
@Override
protected Void run() throws Exception {
    if (step.getAppid() != null && !step.getAppid().equals("")) {
        listener.getLogger().println("[Marathon] DEPRECATION WARNING: This configuration is using \"appid\" instead of \"id\". Please update this configuration.");
        step.setId(step.getAppid());
    }

    try {
        MarathonBuilder
                .getBuilder(step)
                .setEnvVars(envVars)
                .setWorkspace(ws)
                .read(step.filename)
                .build()
                .toFile()
                .update();
    } catch (MarathonException | MarathonFileInvalidException | MarathonFileMissingException me) {
        final String errorMsg = String.format("[Marathon] %s", me.getMessage());
        listener.error(errorMsg);
        run.setResult(Result.FAILURE);
    }

    return null;
}