484 | * For example, 485 | * 486 | *
487 | * build("job1")
488 | * x = extension.'foobar' // foobar is the name of the plugin
489 | * x.someMethod()
490 | *
491 | */
492 | def getExtension() {
493 | return new DynamicExtensionLoader(this);
494 | }
495 |
496 | def propertyMissing(String name) {
497 | throw new MissingPropertyException("Property ${name} doesn't exist.");
498 | }
499 |
500 | def methodMissing(String name, Object args) {
501 | throw new MissingMethodException(name, this.class, args);
502 | }
503 | }
504 |
505 | class DynamicExtensionLoader {
506 | FlowDelegate outer;
507 |
508 | DynamicExtensionLoader(FlowDelegate outer) {
509 | this.outer = outer
510 | }
511 |
512 | def propertyMissing(name) {
513 | def v = BuildFlowDSLExtension.all().findResult {
514 | BuildFlowDSLExtension ext -> ext.createExtension(name, outer)
515 | }
516 | if (v==null)
517 | throw new UnsupportedOperationException("No such extension available: "+name)
518 | return v;
519 | }
520 | }
521 |
--------------------------------------------------------------------------------
/src/main/groovy/com/cloudbees/plugins/flow/JobInvocation.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | * Cisco Systems, Inc., a California corporation
6 | *
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy
8 | * of this software and associated documentation files (the "Software"), to deal
9 | * in the Software without restriction, including without limitation the rights
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | * copies of the Software, and to permit persons to whom the Software is
12 | * furnished to do so, subject to the following conditions:
13 | *
14 | * The above copyright notice and this permission notice shall be included in
15 | * all copies or substantial portions of the Software.
16 | *
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 | * THE SOFTWARE.
24 | */
25 |
26 | package com.cloudbees.plugins.flow;
27 |
28 | import hudson.model.*
29 | import hudson.model.queue.QueueTaskFuture;
30 | import jenkins.model.Jenkins;
31 |
32 | import java.util.concurrent.ExecutionException;
33 | import java.util.concurrent.Future;
34 | import java.util.concurrent.locks.Lock;
35 | import java.util.concurrent.locks.ReentrantLock;
36 | import java.util.concurrent.locks.Condition;
37 | import java.util.logging.Logger;
38 |
39 | import java.text.DateFormat;
40 |
41 | /**
42 | * @author Nicolas De Loof
43 | */
44 | public class JobInvocation {
45 |
46 | private static final Logger LOGGER = Logger.getLogger(JobInvocation.class.getName());
47 |
48 | private final String name;
49 | private int buildNumber;
50 |
51 | // The FlowRun build that initiated this job
52 | private transient final FlowRun run;
53 |
54 | private transient AbstractProject> project;
55 |
56 | private transient Run build;
57 |
58 | private transient QueueTaskFuture> future;
59 |
60 | private final Lock lock;
61 | private final Condition finalizedCond;
62 |
63 | // Whether the build has started. If true, this.build should be set.
64 | private boolean started;
65 | // Whether the build has completed
66 | private boolean completed;
67 | // Whether the build has completed
68 | private boolean finalized;
69 |
70 | private final int uid
71 |
72 | public JobInvocation(FlowRun run, AbstractProject project) {
73 | this.uid = run.buildIndex.getAndIncrement()
74 | this.run = run;
75 | this.name = project.getFullName();
76 | this.project = project;
77 | this.lock = new ReentrantLock();
78 | this.finalizedCond = lock.newCondition();
79 | }
80 |
81 | public JobInvocation(FlowRun run, String name) {
82 | this(run, getProjectByName(run, name));
83 | }
84 |
85 | private static AbstractProject getProjectByName(FlowRun run, String name) {
86 | final ItemGroup context = run.getProject().getParent()
87 | AbstractProject item = Jenkins.getInstance().getItem(name, (ItemGroup) context, AbstractProject.class);
88 | if (item == null) {
89 | throw new JobNotFoundException("Item " + name + " not found (or isn't a job).");
90 | }
91 | return item;
92 | }
93 |
94 | /* package */ JobInvocation run(Cause cause, Listtrue if the run was aborted
109 | */
110 | /* package */ boolean abort() {
111 | def aborted = false
112 | if (!started) {
113 | // Need to search the queue for the correct job and cancel it in
114 | // the queue.
115 | def queue = Jenkins.instance.queue
116 | for (queueItem in queue.items) {
117 | if (future == queueItem.getFuture()) {
118 | aborted = queue.cancel(queueItem)
119 | break;
120 | }
121 | }
122 | }
123 | else if (!completed) {
124 | // as the task has already started we want to be kinder in recording the cause.
125 | def cause = new FlowAbortedCause(flowRun);
126 | def executor = build.executor ?: build.oneOffExecutor;
127 | if (executor != null) {
128 | executor.interrupt(Result.ABORTED, cause)
129 | aborted = true;
130 | }
131 | }
132 | return aborted;
133 | }
134 |
135 | /**
136 | * Delegate method calls we don't implement to the actual {@link Run} so that DSL feels like a Run object has been
137 | * returned, but we can lazy-resolve the actual Run object and add some helper methods
138 | */
139 | def invokeMethod(String name, args) {
140 | // Calling $name with $args on actual Run object
141 | getBuild()."$name"(*args)
142 | }
143 |
144 | def propertyMissing(String name) {
145 | // Retrieve property $name from actual Run object
146 | return getBuild()."$name"
147 | }
148 |
149 | public Result getResult() throws ExecutionException, InterruptedException {
150 | waitForCompletion();
151 | return getBuild().getResult();
152 | }
153 |
154 | public String getResultString() throws ExecutionException, InterruptedException {
155 | return getResult().toString().toLowerCase();
156 | }
157 |
158 | /* package */ Run getFlowRun() {
159 | return run;
160 | }
161 |
162 | /* package */ void buildStarted(Run build) {
163 | this.started = true;
164 | this.build = build;
165 | this.buildNumber = build.getNumber();
166 | }
167 |
168 | /* package */ void buildCompleted() {
169 | this.completed = true;
170 | }
171 |
172 | /* package */ void buildFinalized() {
173 | this.lock.lock();
174 | try {
175 | this.finalized = true;
176 | this.finalizedCond.signal();
177 | } finally {
178 | this.lock.unlock();
179 | }
180 | }
181 |
182 | public String getName() {
183 | return name;
184 | }
185 |
186 | public String getDisplayName() {
187 | return (build != null ? build.displayName : "");
188 | }
189 |
190 | public boolean isStarted() {
191 | return started;
192 | }
193 |
194 | public boolean isCompleted() {
195 | return completed;
196 | }
197 |
198 | public boolean isFinalized() {
199 | return finalized;
200 | }
201 |
202 | public String getBuildUrl() {
203 | return this.getBuild() != null ? this.getBuild().getAbsoluteUrl() : null;
204 | }
205 |
206 | public String getStartTime() {
207 | String formattedStartTime = "";
208 | if (getBuild().getTime() != null) {
209 | formattedStartTime = DateFormat.getDateTimeInstance(
210 | DateFormat.SHORT,
211 | DateFormat.SHORT)
212 | .format(getBuild().getTime());
213 | }
214 | return formattedStartTime;
215 | }
216 |
217 | public Run getBuild() throws ExecutionException, InterruptedException {
218 | if (build == null) {
219 | if (future != null) {
220 | // waiting for build to run
221 | build = future.get();
222 | buildNumber = build.getNumber();
223 | } else if (buildNumber > 0) {
224 | // loaded from persistent store
225 | build = getProject().getBuildByNumber(buildNumber);
226 | }
227 | }
228 | return build;
229 | }
230 |
231 | public AbstractProject> getProject() {
232 | if (project == null)
233 | project = Jenkins.getInstance().getItemByFullName(name, AbstractProject.class);
234 | return project;
235 | }
236 |
237 | public String toString() {
238 | return "${name} ${displayName}"
239 | }
240 |
241 | public Run waitForStart() throws ExecutionException, InterruptedException {
242 | return future.waitForStart();
243 | }
244 |
245 | public void waitForCompletion() throws ExecutionException, InterruptedException {
246 | if (!completed) {
247 | if (future != null) {
248 | future.get();
249 | } else {
250 | throw new RuntimeException("Can't wait for completion.");
251 | }
252 | }
253 | }
254 |
255 | public void waitForFinalization() throws ExecutionException, InterruptedException {
256 | if (!finalized) {
257 | this.lock.lock();
258 | try {
259 | this.finalizedCond.await();
260 | } finally {
261 | this.lock.unlock();
262 | }
263 | }
264 | }
265 |
266 | String getId() {
267 | return "build-" + uid;
268 | }
269 |
270 | /**
271 | * Initial vertex for the build DAG. To be used by FlowRun constructor to initiate the DAG
272 | */
273 | static class Start extends JobInvocation {
274 |
275 | public Start(FlowRun run) {
276 | super(run, run.getProject());
277 | }
278 | }
279 |
280 | @Override
281 | boolean equals(Object obj) {
282 | if (!(obj instanceof JobInvocation)) return false
283 | JobInvocation other = (JobInvocation) obj
284 | return hashCode() == other.hashCode();
285 | }
286 |
287 | @Override
288 | int hashCode() {
289 | return uid;
290 | }
291 | }
292 |
--------------------------------------------------------------------------------
/src/main/groovy/com/cloudbees/plugins/flow/SandBox.groovy:
--------------------------------------------------------------------------------
1 | package com.cloudbees.plugins.flow
2 |
3 | /**
4 | * @author Nicolas De Loof
5 | */
6 | class SandBox {
7 | }
8 |
--------------------------------------------------------------------------------
/src/main/java/com/cloudbees/plugins/flow/BuildFlow.java:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | package com.cloudbees.plugins.flow;
26 |
27 | import hudson.Extension;
28 | import hudson.model.*;
29 | import hudson.model.Descriptor.FormException;
30 | import hudson.model.Queue.FlyweightTask;
31 | import hudson.tasks.BuildStep;
32 | import hudson.tasks.BuildStepDescriptor;
33 | import hudson.tasks.Fingerprinter;
34 | import hudson.tasks.Publisher;
35 | import hudson.Util;
36 | import hudson.util.AlternativeUiTextProvider;
37 | import hudson.util.DescribableList;
38 | import hudson.util.FormValidation;
39 | import jenkins.model.Jenkins;
40 | import jenkins.triggers.SCMTriggerItem;
41 |
42 | import java.io.IOException;
43 | import java.util.List;
44 | import java.util.Map;
45 | import java.util.Set;
46 | import java.util.HashSet;
47 |
48 | import javax.servlet.ServletException;
49 |
50 | import net.sf.json.JSONObject;
51 |
52 | import org.kohsuke.stapler.QueryParameter;
53 | import org.kohsuke.stapler.StaplerRequest;
54 | import org.kohsuke.stapler.StaplerResponse;
55 | import org.codehaus.groovy.control.MultipleCompilationErrorsException;
56 | import groovy.lang.GroovyShell;
57 |
58 | /**
59 | * Defines the orchestration logic for a build flow as a succession of jobs to be executed and chained together
60 | *
61 | * @author Nicolas De loof
62 | */
63 | public class BuildFlow extends Project
27 |
32 |
28 | Checking this box will let the build use a workspace and will be
29 | an AbstractBuild rather and a RunExecution (flyweight task).
30 |
31 |
28 |
35 |
37 |
38 |
29 | Type in the Groovy DSL that describes how you invoke various other jobs in what order.
30 | For available DSL constructs, refer to
31 | the Wiki page.
32 | For Groovy and its syntax, see Groovy User Guide.
33 |
34 |
27 | Specify a file path relative to the workspace of the build where the DSL
28 | will be read. This option only works if "Flow run needs a workspace" is
29 | checked.
30 |
31 | 
30 | ${it.pronoun} ${it.displayName}
31 |
32 |
26 | ${%body}
27 |
--------------------------------------------------------------------------------
/src/main/resources/com/cloudbees/plugins/flow/BuildFlow/newJobDetail.properties:
--------------------------------------------------------------------------------
1 | #
2 | # The MIT License
3 | #
4 | # Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | #
6 | # Permission is hereby granted, free of charge, to any person obtaining a copy
7 | # of this software and associated documentation files (the "Software"), to deal
8 | # in the Software without restriction, including without limitation the rights
9 | # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | # copies of the Software, and to permit persons to whom the Software is
11 | # furnished to do so, subject to the following conditions:
12 | #
13 | # The above copyright notice and this permission notice shall be included in
14 | # all copies or substantial portions of the Software.
15 | #
16 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | # THE SOFTWARE.
23 | #
24 |
25 | body=\
26 | A Build Flow can manage job orchestration as a dedicated entity, in a centralized way with complex \
27 | orchestration and without polluting the jobs with various plugins to handle the upstream-downstream chain.
28 |
--------------------------------------------------------------------------------
/src/main/resources/com/cloudbees/plugins/flow/BuildFlowAction/badge.jelly:
--------------------------------------------------------------------------------
1 |
24 |
25 | 24 |
-
26 |
-
28 |
25 | Manage jobs orchestration as a dedicated "build flow" top level item
26 |
--------------------------------------------------------------------------------
/src/main/webapp/images/16x16/flow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jenkinsci/build-flow-plugin/d8d559258577e5009c9db95ec7e866e4cedc99e1/src/main/webapp/images/16x16/flow.png
--------------------------------------------------------------------------------
/src/main/webapp/images/24x24/flow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jenkinsci/build-flow-plugin/d8d559258577e5009c9db95ec7e866e4cedc99e1/src/main/webapp/images/24x24/flow.png
--------------------------------------------------------------------------------
/src/main/webapp/images/32x32/flow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jenkinsci/build-flow-plugin/d8d559258577e5009c9db95ec7e866e4cedc99e1/src/main/webapp/images/32x32/flow.png
--------------------------------------------------------------------------------
/src/main/webapp/images/48x48/flow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jenkinsci/build-flow-plugin/d8d559258577e5009c9db95ec7e866e4cedc99e1/src/main/webapp/images/48x48/flow.png
--------------------------------------------------------------------------------
/src/main/webapp/images/LICENSE:
--------------------------------------------------------------------------------
1 | License: CC-BY-SA 3.0 or LGPL
2 | http://openiconlibrary.sourceforge.net/gallery2/?./Icons/actions/code-class.png
--------------------------------------------------------------------------------
/src/test/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jenkinsci/build-flow-plugin/d8d559258577e5009c9db95ec7e866e4cedc99e1/src/test/.DS_Store
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/AbortTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, Cisco Systems, Inc., a California corporation
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 | package com.cloudbees.plugins.flow
25 |
26 | import hudson.model.Job
27 | import hudson.model.Result
28 | import jenkins.model.Jenkins
29 | import hudson.model.Cause.UserIdCause;
30 | import hudson.model.ParametersAction;
31 | import hudson.model.StringParameterValue;
32 | import org.junit.Test
33 |
34 | /**
35 | * Tests that when a flow is aborted is it reported correctly.
36 | * @author James Nord
37 | */
38 | class AbortTest extends DSLTestCase {
39 |
40 |
41 | /**
42 | * Tests that when a Flow is aborted it correctly aborts jobs that it started.
43 | */
44 | @Test
45 | public void testThatAbortAbortsStartedJobs() {
46 | File f1 = new File("target", "${name.getMethodName()}_job1.lock")
47 | f1.mkdirs()
48 | f1.createNewFile()
49 |
50 | def job1 = createBlockingJob("job1", f1)
51 | def job2 = jenkinsRule.createFreeStyleProject("job2")
52 |
53 | def future = schedule("""
54 | build("job1")
55 | build("job2")
56 | """)
57 |
58 | def flow = future.waitForStart()
59 | // wait for job1 to start
60 | while (!job1.building) {
61 | Thread.sleep(10L)
62 | }
63 | println("job has started")
64 |
65 | // abort the flow
66 | println("aborting...")
67 | flow.oneOffExecutor.interrupt(Result.ABORTED)
68 | println("aborting request sent...")
69 | // wait for the flow to finish executing.
70 | future.get();
71 |
72 | jenkinsRule.assertBuildStatus(Result.ABORTED, flow)
73 | jenkinsRule.assertBuildStatus(Result.ABORTED, job1.lastBuild)
74 | assertDidNotRun(job2)
75 | }
76 |
77 | /**
78 | * Tests that when a Flow is aborted it correctly aborts jobs that it started
79 | * in a parallel block.
80 | */
81 | @Test
82 | public void testThatAbortAbortsStartedJobs_ParallelBlock() {
83 | File f1 = new File("target", "${name.getMethodName()}_job1.lock")
84 | File f2 = new File("target", "${name.getMethodName()}_job2.lock")
85 | f1.mkdirs()
86 | f1.createNewFile()
87 | f2.mkdirs()
88 | f2.createNewFile()
89 |
90 | Job job1 = createBlockingJob("job1", f1)
91 | Job job2 = createBlockingJob("job2", f2)
92 |
93 | def future = schedule("""
94 | parallel(
95 | { build("job1") },
96 | { build("job2") },
97 | )
98 | build.state.result = FAILURE
99 | fail()
100 | """)
101 |
102 | def flow = future.waitForStart()
103 | // wait for job1 to start
104 | while (!job1.building) {
105 | Thread.sleep(10L)
106 | }
107 | println("job has started")
108 |
109 | // abort the flow
110 | println("aborting...")
111 | flow.oneOffExecutor.interrupt(Result.ABORTED)
112 | println("aborting request sent...")
113 | // wait for the flow to finish executing.
114 | future.get();
115 |
116 | jenkinsRule.assertBuildStatus(Result.ABORTED, job1.lastBuild)
117 | jenkinsRule.assertBuildStatus(Result.ABORTED, job2.lastBuild)
118 | jenkinsRule.assertBuildStatus(Result.ABORTED, flow)
119 | }
120 |
121 | /**
122 | * Ensures an ignored parallel block does not supress the aborted job status.
123 | */
124 | @Test
125 | public void testThatAbortAbortsStartedJobs_IgnoredParallel() {
126 | File f1 = new File("target", "${name.getMethodName()}_job1.lock")
127 | File f2 = new File("target", "${name.getMethodName()}_job2.lock")
128 | f1.mkdirs()
129 | f1.createNewFile()
130 | f2.mkdirs()
131 | f2.createNewFile()
132 |
133 | Job job1 = createBlockingJob("job1", f1)
134 | Job job2 = createBlockingJob("job2", f2)
135 |
136 | def future = schedule("""
137 | ignore(ABORTED) {
138 | parallel(
139 | { build("job1") },
140 | { build("job2") },
141 | )
142 | }
143 | build.state.result = FAILURE
144 | fail()
145 | """)
146 |
147 | def flow = future.waitForStart()
148 | // wait for job1 to start
149 | while (!job1.building) {
150 | Thread.sleep(10L)
151 | }
152 | println("job has started")
153 |
154 | // abort the flow
155 | println("aborting...")
156 | flow.oneOffExecutor.interrupt(Result.ABORTED)
157 | println("aborting request sent...")
158 | // wait for the flow to finish executing.
159 | future.get();
160 |
161 | jenkinsRule.assertBuildStatus(Result.ABORTED, job1.lastBuild)
162 | jenkinsRule.assertBuildStatus(Result.ABORTED, job2.lastBuild)
163 | jenkinsRule.assertBuildStatus(Result.ABORTED, flow)
164 | }
165 |
166 | /**
167 | * Tests that when a Flow is aborted it correctly aborts jobs that it queued.
168 | */
169 | @Test
170 | public void testThatAbortAbortsQueuedJobs() {
171 | File f1 = new File("target", "${name.getMethodName()}_job1.lock")
172 | f1.createNewFile()
173 |
174 | Job job1 = createBlockingJob("job1", f1)
175 |
176 | BuildFlow flow = new BuildFlow(Jenkins.instance, name.getMethodName())
177 | flow.concurrentBuild = true;
178 | flow.onCreatedFromScratch()
179 | flow.dsl = """ build("job1", param1: build.number) """
180 |
181 | // Start an initially blocked job to to create a queue.
182 | def sfr1 = job1.scheduleBuild2(0,new UserIdCause(), new ParametersAction(new StringParameterValue("param1", "first")));
183 | def fr1 = sfr1.waitForStart()
184 |
185 | println("Starting build flows...")
186 | // Start three concurrent flows queueing up a job1,
187 | // wait for the job1 to queue up before starting the next
188 | // flow to ensure a consistent queue.
189 | def queue = Jenkins.instance.queue;
190 | def flows = []
191 | for (i in 1..3) {
192 | def scheduled = flow.scheduleBuild2(0)
193 | def future = scheduled.waitForStart()
194 | while (queue.getItems(job1).size() < i ) {
195 | Thread.sleep(10L);
196 | }
197 | flows.add([flow:scheduled, future: future])
198 | }
199 |
200 | // abort the second flow
201 | println("aborting flow #2...")
202 | flows[1].future.oneOffExecutor.interrupt(Result.ABORTED)
203 | println("aborting request sent...")
204 | // wait for the flow to finish executing.
205 | jenkinsRule.assertBuildStatus(Result.ABORTED, flows[1].flow.get())
206 |
207 | // Release the blocked job
208 | System.out.println("releasing jobs")
209 | f1.delete()
210 |
211 | jenkinsRule.waitUntilNoActivityUpTo(25000)
212 |
213 | assertRan(job1, 3, Result.SUCCESS)
214 |
215 | // Needs to assert that only the aborted build, (param1:2), is missing
216 | // since no records exist when queued builds are cancelled.
217 | assertHasParameter(job1.builds[2], 'param1', 'first')
218 | assertHasParameter(job1.builds[1], 'param1', '1')
219 | assertHasParameter(job1.builds[0], 'param1', '3')
220 |
221 | // Assert that non aborted flows succeeded.
222 | jenkinsRule.assertBuildStatusSuccess(flows[0].flow.get())
223 | jenkinsRule.assertBuildStatusSuccess(flows[2].flow.get())
224 | }
225 | }
226 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/BindingTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | package com.cloudbees.plugins.flow
26 |
27 | import hudson.model.Result
28 |
29 | import static hudson.model.Result.SUCCESS
30 | import static hudson.model.Result.FAILURE
31 | import hudson.model.Job
32 | import jenkins.model.Jenkins
33 | import org.junit.Ignore
34 | import org.junit.Test
35 | import hudson.slaves.EnvironmentVariablesNodeProperty
36 | import hudson.slaves.EnvironmentVariablesNodeProperty.Entry
37 |
38 | class BindingTest extends DSLTestCase {
39 |
40 | @Test
41 | public void testBindings() {
42 | Job job1 = createJob("job1")
43 | def flow = run("""
44 | out.println("yeah")
45 | build("job1", param1: build.number)
46 | """)
47 | def build = assertSuccess(job1)
48 | assertHasParameter(build, "param1", "1")
49 | assert SUCCESS == flow.result
50 | }
51 |
52 | @Test
53 | public void testEnvBinding() {
54 | jenkinsRule.jenkins.globalNodeProperties.add(new EnvironmentVariablesNodeProperty(new Entry("someGlobalProperty", "expectedGlobalPropertyValue")))
55 | jenkinsRule.jenkins.nodeProperties.add(new EnvironmentVariablesNodeProperty(new Entry("someNodeProperty", "expectedNodePropertyValue")))
56 |
57 | Job job1 = createJob("job1")
58 | def flow = run("""
59 | out.println("yeah")
60 | build("job1", param1: env["someGlobalProperty"], param2: env["someNodeProperty"])
61 | """)
62 | def build = assertSuccess(job1)
63 | assertHasParameter(build, "param1", "expectedGlobalPropertyValue")
64 | assertHasParameter(build, "param2", "expectedNodePropertyValue")
65 | assert SUCCESS == flow.result
66 | }
67 |
68 | @Test
69 | public void testBuiltinImports() {
70 | def flow = run("""
71 | println "test="+SUCCESS.class.name;
72 | """)
73 | assert SUCCESS == flow.result
74 | assert flow.log.contains("test="+ Result.SUCCESS.class.name)
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/BuildFlowDSLExtensionTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | package com.cloudbees.plugins.flow
26 |
27 | import com.cloudbees.plugin.flow.TestDSLExtension
28 | import hudson.model.Result
29 | import org.junit.Test
30 |
31 | class BuildFlowDSLExtensionTest extends DSLTestCase {
32 |
33 | @Test
34 | public void testUseExtension() {
35 | BuildFlowDSLExtension.all().add(new TestDSLExtension())
36 | def flow = run("""
37 | x = extension.test123
38 | println "name="+x.name
39 | println "dsl="+x.dsl.class.name
40 | """)
41 | System.out.println flow.log
42 | assert Result.SUCCESS == flow.result
43 | assert flow.log.contains("name=test123")
44 | assert flow.log.contains("dsl="+FlowDelegate.class.name)
45 | }
46 |
47 | }
48 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/BuildTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | * Cisco Systems, Inc., a California corporation
6 | *
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy
8 | * of this software and associated documentation files (the "Software"), to deal
9 | * in the Software without restriction, including without limitation the rights
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | * copies of the Software, and to permit persons to whom the Software is
12 | * furnished to do so, subject to the following conditions:
13 | *
14 | * The above copyright notice and this permission notice shall be included in
15 | * all copies or substantial portions of the Software.
16 | *
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 | * THE SOFTWARE.
24 | */
25 |
26 | package com.cloudbees.plugins.flow
27 |
28 | import hudson.model.Result
29 | import org.jvnet.hudson.test.Issue
30 |
31 | import static hudson.model.Result.SUCCESS
32 | import static hudson.model.Result.FAILURE
33 | import jenkins.model.Jenkins
34 | import hudson.model.Job
35 | import hudson.model.Action
36 | import hudson.model.ParametersAction
37 | import hudson.model.ParameterValue
38 | import hudson.model.StringParameterValue
39 | import hudson.model.ParametersDefinitionProperty
40 | import hudson.model.ParameterDefinition
41 | import hudson.model.StringParameterDefinition
42 | import hudson.model.FreeStyleProject
43 |
44 | import static hudson.model.Result.UNSTABLE
45 | import org.junit.Test
46 |
47 | class BuildTest extends DSLTestCase {
48 |
49 | @Test
50 | public void testUnknownJob() {
51 | def flow = run("""
52 | build("unknown")
53 | """)
54 | assert FAILURE == flow.result
55 | jenkinsRule.assertLogContains("Item unknown not found (or isn't a job).", flow)
56 | }
57 |
58 | @Test
59 | public void testDisabledJob() {
60 | def disabledJob = createJob("disabledJob")
61 | disabledJob.disable()
62 |
63 | def flow = run("""
64 | build("disabledJob")
65 | """)
66 |
67 | jenkinsRule.assertBuildStatus(FAILURE, flow);
68 | jenkinsRule.assertLogContains("Could not schedule job disabledJob, ensure it is not already queued with the same parameters or is not disabled", flow)
69 | }
70 |
71 | @Test
72 | public void testSingleBuild() {
73 | Job job1 = createJob("job1")
74 | def flow = run("""
75 | build("job1")
76 | """)
77 | assertSuccess(job1)
78 | assert SUCCESS == flow.result
79 | }
80 |
81 | @Test
82 | public void testBuildWithParams() {
83 | Job job1 = createJob("job1")
84 | def flow = run("""
85 | build("job1",
86 | param1: "one",
87 | param2: "two")
88 | """)
89 | def build = assertSuccess(job1)
90 | assertHasParameter(build, "param1", "one")
91 | assertHasParameter(build, "param2", "two")
92 | assert SUCCESS == flow.result
93 | }
94 |
95 | @Test
96 | public void testBuildWithParamsAsMap() {
97 | Job job1 = createJob("job1")
98 | def flow = run("""
99 | def params = ["param1": "one", "param2": "two"]
100 | build(params, "job1")
101 | """)
102 | def build = assertSuccess(job1)
103 | assertHasParameter(build, "param1", "one")
104 | assertHasParameter(build, "param2", "two")
105 | assert SUCCESS == flow.result
106 | }
107 |
108 | @Test
109 | public void testJobFailure() {
110 | Job willFail = createFailJob("willFail");
111 | def flow = run("""
112 | build("willFail")
113 | build("willNotRun")
114 | """)
115 | assertFailure(willFail)
116 | assert FAILURE == flow.result
117 | }
118 |
119 | @Test
120 | public void testJobUnstable() {
121 | Job unstable = createUnstableJob("unstable");
122 | def flow = run("""
123 | build("unstable")
124 | build("willNotRun")
125 | """)
126 | assertUnstable(unstable)
127 | assert UNSTABLE == flow.result
128 | }
129 |
130 | @Test
131 | public void testSequentialBuilds() {
132 | def jobs = createJobs(["job1", "job2", "job3"])
133 | def flow = run("""
134 | build("job1")
135 | build("job2")
136 | build("job3")
137 | """)
138 | assertAllSuccess(jobs)
139 | assert SUCCESS == flow.result
140 | println flow.jobsGraph.edgeSet()
141 | }
142 |
143 | @Test
144 | public void testSequentialBuildsWithFailure() {
145 | def jobs = createJobs(["job1", "job2", "job3"])
146 | def willFail = createFailJob("willFail")
147 | def notRan = createJob("notRan")
148 | def flow = run("""
149 | build("job1")
150 | build("job2")
151 | build("job3")
152 | build("willFail")
153 | build("notRan")
154 | """)
155 | assertAllSuccess(jobs)
156 | assertFailure(willFail)
157 | assertDidNotRun(notRan)
158 | assert FAILURE == flow.result
159 | println flow.jobsGraph.edgeSet()
160 | }
161 |
162 | @Test
163 | public void testParametersFromBuild() {
164 | Job job1 = createJob("job1")
165 | Job job2 = createJob("job2")
166 | def flow = run("""
167 | b = build("job1")
168 | build("job2",
169 | param1: b.result.name,
170 | param2: b.name)
171 | """)
172 | assertSuccess(job1)
173 | def build = assertSuccess(job2)
174 | assertHasParameter(build, "param1", "SUCCESS")
175 | assertHasParameter(build, "param2", "job1")
176 | assert SUCCESS == flow.result
177 | }
178 |
179 | @Test
180 | public void testParametersFromBuildWithDefaultValues() {
181 | FreeStyleProject job1 = createJob("job1")
182 | def parametersDefinitions = new ParametersDefinitionProperty(new StringParameterDefinition("param1", "0"), new StringParameterDefinition("param2", "0"))
183 | job1.addProperty(parametersDefinitions)
184 |
185 | def flow = run("""
186 | b = build("job1",
187 | param1:"1",
188 | param3:"3")
189 | """)
190 |
191 | def build = assertSuccess(job1)
192 | assertHasParameter(build, "param1", "1")
193 | assertHasParameter(build, "param2", "0")
194 | assertHasParameter(build, "param3", "3")
195 | assert SUCCESS == flow.result
196 | }
197 |
198 | @Issue("JENKINS-17199")
199 | @Test
200 | public void testImportStatement() {
201 | def flow = run("""
202 | import java.util.Date;
203 | println "Hello from date: "+new Date();
204 | """)
205 | assert SUCCESS == flow.result
206 | assert flow.log.contains("Hello from date: ")
207 | }
208 |
209 | @Test
210 | public void testParallelThreadName() {
211 | BuildFlow flow = new BuildFlow(Jenkins.instance, "project_name")
212 | flow.dsl = """
213 | parallel(
214 | { println Thread.currentThread().name }
215 | );
216 | """
217 | flow.onCreatedFromScratch() // need this to updateTransientActions
218 | def build = flow.scheduleBuild2(0).get()
219 |
220 | assert SUCCESS == build.result
221 | assert build.log.contains("BuildFlow parallel statement thread for project_name")
222 | }
223 | }
224 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/CombinationTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | package com.cloudbees.plugins.flow
26 |
27 | import hudson.model.Cause
28 | import hudson.model.FreeStyleBuild
29 | import hudson.model.Job
30 |
31 | import static hudson.model.Result.SUCCESS
32 | import static hudson.model.Result.FAILURE
33 | import org.junit.Test
34 |
35 | public class CombinationTest extends DSLTestCase {
36 |
37 | @Test
38 | public void testRetryWithGuard() {
39 | Job job1 = createJob("job1")
40 | Job willFail = createFailJob("willFail")
41 | def flow = run("""
42 | retry(3) {
43 | guard {
44 | build("job1")
45 | } rescue {
46 | build("willFail")
47 | }
48 | }
49 | """)
50 | assertRan(job1, 3, SUCCESS)
51 | assertRan(willFail, 3, FAILURE)
52 | assert FAILURE == flow.result
53 | }
54 |
55 | @Test
56 | public void testGuardWithParallel() {
57 | def jobs = createJobs(["job1", "job2", "rescue"])
58 | Job willFail = createFailJob("willFail")
59 | def flow = run("""
60 | guard {
61 | parallel (
62 | { build("job1") },
63 | { build("job2") },
64 | { build("willFail") }
65 | )
66 | } rescue {
67 | build("rescue")
68 | }
69 | """)
70 | assertAllSuccess(jobs)
71 | assertRan(willFail, 1, FAILURE)
72 | assert FAILURE == flow.result
73 | }
74 |
75 | @Test
76 | public void testParallelSubFlows() {
77 | def jobs = createJobs(["job1", "job2", "job3"])
78 | Job willFail = createFailJob("willFail")
79 | Job job5 = createJob("job5")
80 |
81 | def flow = run("""
82 | parallel (
83 | {
84 | guard {
85 | build("job1")
86 | } rescue {
87 | build("job2")
88 | }
89 | },
90 | {
91 | build("job3")
92 | retry(3) {
93 | build("willFail")
94 | }
95 | }
96 | )
97 | build("job5")
98 | """)
99 | assertAllSuccess(jobs)
100 | assertRan(willFail, 3, FAILURE)
101 | assertDidNotRun(job5)
102 | assert FAILURE == flow.result
103 | println flow.jobsGraph.edgeSet()
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/ConcurrencyTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, Cisco Systems, Inc., a California corporation
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 | package com.cloudbees.plugins.flow
25 |
26 | import hudson.model.Cause
27 | import hudson.model.ParametersDefinitionProperty
28 | import hudson.model.RunParameterDefinition
29 | import jenkins.model.Jenkins
30 |
31 | import static hudson.model.Result.FAILURE
32 | import static hudson.model.Result.SUCCESS
33 | import org.junit.Test
34 | import static org.junit.Assert.assertTrue
35 |
36 | class ConcurrencyTest extends DSLTestCase {
37 |
38 | /**
39 | * Test that triggering multiple builds of the same concurrent build is ok.
40 | * This relies on the default quiet period of 5 seconds.
41 | */
42 | @Test
43 | public void testConcurrency() {
44 | Jenkins.instance.numExecutors = 8
45 | Jenkins.instance.reload()
46 |
47 | File f1 = new File("target", "concjob1.block")
48 | // this will prevent job1 from running.
49 | f1.mkdirs();
50 | f1.createNewFile();
51 |
52 | def concjob1 = createBlockingJob("concjob1", f1)
53 | concjob1.concurrentBuild = true
54 | concjob1.properties.put(ParametersDefinitionProperty.DescriptorImpl,
55 | new ParametersDefinitionProperty(new RunParameterDefinition("param1", name.getMethodName(), "ignored", null)))
56 |
57 | BuildFlow flow = new BuildFlow(Jenkins.instance, name.getMethodName())
58 | flow.concurrentBuild = true;
59 | flow.dsl = """ build("concjob1", param1: build.number) """
60 | flow.onCreatedFromScratch()
61 |
62 | def sfr1 = flow.scheduleBuild2(0, new Cause.UserIdCause())
63 | def fr1 = sfr1.waitForStart()
64 |
65 | def sfr2 = flow.scheduleBuild2(0, new Cause.UserIdCause())
66 | def fr2 = sfr2.waitForStart()
67 |
68 | def sfr3 = flow.scheduleBuild2(0, new Cause.UserIdCause())
69 | def fr3 = sfr3.waitForStart()
70 |
71 | def sfr4 = flow.scheduleBuild2(0, new Cause.UserIdCause())
72 | def fr4 = sfr4.waitForStart()
73 |
74 | // we have a 5 second quiet period!
75 | // This sleep does not add to the execution time of the test as we just wait for the builds to complete anyway.
76 | Thread.sleep(6000L);
77 | println("releasing jobs")
78 | f1.delete();
79 |
80 | // wait for all the flows to finish.
81 | sfr1.get();
82 | sfr2.get();
83 | sfr3.get();
84 | sfr4.get();
85 |
86 | assertRan(flow, 4, SUCCESS);
87 | assertRan(concjob1, 4, SUCCESS);
88 | }
89 |
90 | }
91 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/DSLTestCase.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | * Cisco Systems, Inc., a California corporation
6 | *
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy
8 | * of this software and associated documentation files (the "Software"), to deal
9 | * in the Software without restriction, including without limitation the rights
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | * copies of the Software, and to permit persons to whom the Software is
12 | * furnished to do so, subject to the following conditions:
13 | *
14 | * The above copyright notice and this permission notice shall be included in
15 | * all copies or substantial portions of the Software.
16 | *
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 | * THE SOFTWARE.
24 | */
25 |
26 | package com.cloudbees.plugins.flow
27 |
28 | import com.cloudbees.plugin.flow.UnstableBuilder
29 | import com.cloudbees.plugins.flow.FlowDSL
30 | import hudson.model.Result
31 | import org.jvnet.hudson.test.FailureBuilder
32 | import hudson.model.AbstractBuild
33 | import hudson.model.ParametersAction
34 | import com.cloudbees.plugins.flow.BuildFlow
35 | import jenkins.model.Jenkins
36 | import static hudson.model.Result.SUCCESS
37 | import java.util.concurrent.Future
38 | import java.util.concurrent.TimeUnit
39 | import static hudson.model.Result.FAILURE
40 | import java.util.logging.Logger
41 | import java.util.logging.Level
42 | import java.util.logging.Handler
43 | import java.util.logging.ConsoleHandler
44 | import com.cloudbees.plugins.flow.JobInvocation
45 | import com.cloudbees.plugins.flow.FlowDelegate
46 | import hudson.Launcher
47 | import hudson.model.BuildListener
48 | import hudson.tasks.Builder
49 | import com.cloudbees.plugin.flow.ConfigurableFailureBuilder
50 | import com.cloudbees.plugin.flow.BlockingBuilder
51 | import hudson.model.Job
52 | import org.junit.Assert
53 | import org.junit.Rule
54 | import org.junit.rules.TestName
55 | import org.jvnet.hudson.test.JenkinsRule
56 |
57 |
58 | import static hudson.model.Result.UNSTABLE
59 |
60 | abstract class DSLTestCase {
61 | @Rule
62 | public JenkinsRule jenkinsRule = new JenkinsRule()
63 |
64 | @Rule
65 | public TestName name = new TestName()
66 |
67 | def createJob = {String name ->
68 | return jenkinsRule.createFreeStyleProject(name);
69 | }
70 |
71 | def createJobs = { names ->
72 | def jobs = []
73 | names.each {
74 | jobs.add(createJob(it))
75 | }
76 | return jobs
77 | }
78 |
79 | def createFailJob = {String name, int failures = Integer.MAX_VALUE ->
80 | def job = createJob(name)
81 | job.getBuildersList().add(new ConfigurableFailureBuilder(failures));
82 | return job
83 | }
84 |
85 | def createUnstableJob = {String name ->
86 | def job = createJob(name)
87 | job.getBuildersList().add(new UnstableBuilder());
88 | job.onCreatedFromScratch() // need this to updateTransientActions
89 | return job
90 | }
91 |
92 | def createBlockingJob = {String name, File file = BlockingBuilder.DEFAULT_FILE ->
93 | def job = createJob(name)
94 | job.getBuildersList().add(new BlockingBuilder(file));
95 | job.onCreatedFromScratch() // need this to updateTransientActions
96 | return job
97 | }
98 |
99 | def run = { script ->
100 | BuildFlow flow = new BuildFlow(Jenkins.instance, name.getMethodName())
101 | flow.dsl = script
102 | flow.onCreatedFromScratch() // need this to updateTransientActions
103 | return flow.scheduleBuild2(0).get()
104 | }
105 |
106 | def runWithWorkspace = { script ->
107 | BuildFlow flow = new BuildFlow(Jenkins.instance, name.getMethodName())
108 | flow.dsl = script
109 | flow.buildNeedsWorkspace = true
110 | flow.onCreatedFromScratch() // need this to updateTransientActions
111 | return flow.scheduleBuild2(0).get()
112 | }
113 |
114 | def schedule = { script ->
115 | BuildFlow flow = new BuildFlow(Jenkins.instance, name.getMethodName())
116 | flow.dsl = script
117 | flow.onCreatedFromScratch() // need this to updateTransientActions
118 | return flow.scheduleBuild2(0)
119 | }
120 |
121 | def runWithCause = { script, cause ->
122 | BuildFlow flow = new BuildFlow(Jenkins.instance, name.getMethodName())
123 | flow.dsl = script
124 | flow.onCreatedFromScratch() // need this to updateTransientActions
125 | return flow.scheduleBuild2(0, cause).get()
126 | }
127 |
128 | def assertSuccess = { job ->
129 | Assert.assertNotNull("job ${job.name} didn't run", job.builds.lastBuild)
130 | assert SUCCESS == job.builds.lastBuild.result
131 | return job.builds.lastBuild
132 | }
133 |
134 | def assertDidNotRun = { job ->
135 | assert 0 == job.builds.size()
136 | }
137 |
138 | def assertAllSuccess = { jobs ->
139 | jobs.each {
140 | Assert.assertNotNull("job ${it.name} didn't run", it.builds.lastBuild)
141 | assert SUCCESS == it.builds.lastBuild.result
142 | }
143 | }
144 |
145 | def assertFailure = { job ->
146 | assert FAILURE == job.builds.lastBuild.result
147 | }
148 |
149 | def assertUnstable = { job ->
150 | assert UNSTABLE == job.builds.lastBuild.result
151 | }
152 |
153 | def assertException(Class exClass, Closure closure) {
154 | def thrown = false
155 | try {
156 | closure()
157 | } catch (Exception e) {
158 | if (exClass.isAssignableFrom(e.getClass())) {
159 | thrown = true
160 | }
161 | }
162 | assert thrown
163 | }
164 |
165 | void assertHasParameter(Job job, String name, String value) {
166 | assertHasParameter(job.builds.lastBuild, name, value)
167 | }
168 |
169 | void assertHasParameter(AbstractBuild build, String name, String value) {
170 | boolean found = false
171 | build.actions.each {action ->
172 | if (action instanceof ParametersAction)
173 | if (action.getParameter(name)?.value == value) {
174 | found = true
175 | return
176 | }
177 | }
178 | Assert.assertTrue("build don't have expected parameter set " + name + "=" + value, found)
179 | }
180 |
181 | void assertRan(Job job, int times, Result result) {
182 | assert job.builds.size() == times
183 | job.builds.each { build ->
184 | assert build.result == result
185 | }
186 | }
187 | }
188 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/FlowCauseTest.groovy:
--------------------------------------------------------------------------------
1 | package com.cloudbees.plugins.flow
2 |
3 | import com.gargoylesoftware.htmlunit.html.HtmlPage
4 | import hudson.model.Cause
5 | import hudson.model.CauseAction
6 | import org.junit.Rule
7 | import org.junit.Test
8 | import org.jvnet.hudson.test.JenkinsRule
9 |
10 | import static org.junit.Assert.assertTrue
11 |
12 | class FlowCauseTest {
13 |
14 | @Rule
15 | public JenkinsRule j = new JenkinsRule()
16 |
17 | protected BuildFlow createFlow(String name, String dsl) {
18 | def job = j.jenkins.createProject(BuildFlow, name)
19 | job.dsl = dsl
20 | job.save()
21 | return job
22 | }
23 |
24 | /**
25 | * Given a pipeline A --> FLOW --> B, then the build for a B build must display Flow <-- A.
26 | */
27 | @Test
28 | void 'Flow cause not blocking the upstream causes'() {
29 | // Jobs
30 | def a = createFlow('A', 'build("B")')
31 | def b = createFlow('B', 'build("C")')
32 | def c = createFlow('C', '')
33 |
34 | // Triggers A
35 | j.assertBuildStatusSuccess(a.scheduleBuild2(0, new Cause.UserIdCause()))
36 |
37 | // Checks the builds
38 | j.assertBuildStatusSuccess(b.builds.lastBuild)
39 |
40 | // Last build in the sequence
41 | def build = c.builds.lastBuild
42 | j.assertBuildStatusSuccess(build)
43 |
44 | // Checks the cause tree
45 | def causeAction = build.actions.find { it instanceof CauseAction } as CauseAction
46 | assert causeAction != null: "A cause action must be associated with the build"
47 | assert causeAction.causes.size() == 1
48 | def cause = causeAction.causes.first() as Cause.UpstreamCause
49 | assert cause.shortDescription == 'Started by build flow B#1'
50 | def upstreamCause = cause.upstreamCauses.first() as Cause.UpstreamCause
51 | assert upstreamCause.shortDescription == 'Started by upstream project "A" build number 1'
52 |
53 | // Goes to the build status page of C
54 | HtmlPage page = j.createWebClient().goTo(c.builds.lastBuild.url)
55 | assert page.titleText == 'C #1 [Jenkins]'
56 |
57 | // Just checking the different causes are in the page (a bit primitive)
58 | def bPosition = page.body.textContent.indexOf('Started by build flow B')
59 | assertTrue(bPosition > 0)
60 | assertTrue(page.body.textContent.indexOf('Started by upstream project A build number 1') > bPosition)
61 |
62 | }
63 |
64 | }
65 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/GuardTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | package com.cloudbees.plugins.flow
26 |
27 | import static hudson.model.Result.SUCCESS
28 | import hudson.model.Job
29 | import static hudson.model.Result.FAILURE
30 | import org.junit.Test
31 |
32 | class GuardTest extends DSLTestCase {
33 |
34 | @Test
35 | public void testGuardPass() {
36 | def jobs = createJobs(["job1", "job2", "job3", "clean"])
37 | def ret = run("""
38 | guard {
39 | build("job1")
40 | build("job2")
41 | build("job3")
42 | } rescue {
43 | build("clean")
44 | }
45 | """)
46 | assertAllSuccess(jobs)
47 | assert SUCCESS == ret.result
48 | }
49 |
50 | /*@Test
51 | public void testGuardWithFail() {
52 | Job job1 = createJob("job1");
53 | def failure = createFailJob("fails")
54 | Job job3 = createJob("job3");
55 | Job clean = createJob("clean");
56 |
57 | def ret = run("""
58 | guard {
59 | build("job1")
60 | build("fails")
61 | build("job3")
62 | } rescue {
63 | build("clean")
64 | }
65 | """)
66 | assertSuccess(job1)
67 | assertFailure(failure)
68 | assertDidNotRun(job3)
69 | assertSuccess(clean)
70 | assert FAILURE == ret.result
71 | }
72 |
73 | def successBuildPar = """
74 | def g, r
75 | guard {
76 | build("job1")
77 | par = parallel {
78 | a = build("job2")
79 | assert !a.future.done
80 | b = build("job3")
81 | assert !b.future.done
82 | }
83 | par.values().each {
84 | assert it.future.done
85 | }
86 | g = true
87 | } rescue {
88 | build("clean")
89 | r = true
90 | }
91 | assert g
92 | assert r
93 | """
94 |
95 | @Test
96 | public void testGuardPassPar() {
97 | def jobs = createJobs(["job1", "job2", "job3", "clean"])
98 | def ret = run(successBuildPar)
99 | assertAllSuccess(jobs)
100 | assert SUCCESS == ret.result
101 | }
102 |
103 | def successBuildParRetry = """
104 | def a = 0
105 | def g, r
106 | guard {
107 | build("job1")
108 | par = parallel {
109 | job1 = build("job2")
110 | assert !job1.future.done
111 | job2 = build("job3")
112 | assert !job2.future.done
113 | }
114 | par.values().each {
115 | assert it.future.done
116 | }
117 | 2.times retry {
118 | build("job3")
119 | a++
120 | }
121 | g = true
122 | } rescue {
123 | build("clean")
124 | r = true
125 | }
126 | assert a == 1
127 | """
128 | @Test
129 | public void testGuardPassParRetry() {
130 | def jobs = createJobs(["job1", "job2", "job3", "clean"])
131 | def ret = run(successBuildParRetry)
132 | assertAllSuccess(jobs)
133 | assert SUCCESS == ret.result
134 | }*/
135 | }
136 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/IgnoreTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | package com.cloudbees.plugins.flow
26 |
27 | import hudson.model.FreeStyleProject
28 | import hudson.model.Job
29 | import hudson.model.ParametersDefinitionProperty
30 | import hudson.model.StringParameterDefinition
31 |
32 | import static hudson.model.Result.*
33 | import org.junit.Test
34 |
35 | class IgnoreTest extends DSLTestCase {
36 |
37 | @Test
38 | public void testIgnoreJobFailure() {
39 | Job willFail = createFailJob("willFail");
40 | Job wontRun= createJob("wontRun");
41 | def flow = run("""
42 | ignore(FAILURE) {
43 | build("willFail")
44 | build("wontRun")
45 | }
46 | """)
47 | assertFailure(willFail)
48 | assertDidNotRun(wontRun)
49 | assert SUCCESS == flow.result
50 | }
51 |
52 | @Test
53 | public void testIgnoreJobUnstable() {
54 | Job unstable = createUnstableJob("unstable");
55 | Job wontRun= createJob("wontRun");
56 | def flow = run("""
57 | ignore(UNSTABLE) {
58 | build("unstable")
59 | build("wontRun")
60 | }
61 | """)
62 | assertUnstable(unstable)
63 | assertDidNotRun(wontRun)
64 | assert SUCCESS == flow.result
65 | }
66 |
67 | @Test
68 | public void testIgnoreJobUnstableButFailureFailure() {
69 | Job willFail = createFailJob("willFail");
70 | Job wontRun= createJob("wontRun");
71 | def flow = run("""
72 | ignore(UNSTABLE) {
73 | build("willFail")
74 | build("wontRun")
75 | }
76 | """)
77 | assertFailure(willFail)
78 | assertDidNotRun(wontRun)
79 | assert FAILURE == flow.result
80 | }
81 |
82 | }
83 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/ParallelTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | package com.cloudbees.plugins.flow
26 |
27 | import static hudson.model.Result.SUCCESS
28 | import hudson.model.Result
29 | import static hudson.model.Result.FAILURE
30 | import org.junit.Test
31 |
32 | class ParallelTest extends DSLTestCase {
33 |
34 | @Test
35 | public void testParallel() {
36 | def jobs = createJobs(["job1", "job2", "job3", "job4"])
37 | def flow = run("""
38 | parallel(
39 | { build("job1") },
40 | { build("job2") },
41 | { build("job3") }
42 | )
43 | build("job4")
44 | """)
45 | assertAllSuccess(jobs)
46 | assert SUCCESS == flow.result
47 | println flow.jobsGraph.edgeSet()
48 | }
49 |
50 | @Test
51 | public void testFailOnParallelFailed() {
52 | createJobs(["job1", "job2"])
53 | createFailJob("willFail")
54 | def job4 = createJob("job4")
55 | def flow = run("""
56 | parallel (
57 | { build("job1") },
58 | { build("job2") },
59 | { build("willfail") }
60 | )
61 | build("job4")
62 | """)
63 | assertDidNotRun(job4)
64 | assert FAILURE == flow.result
65 | println flow.jobsGraph.edgeSet()
66 | }
67 |
68 |
69 | @Test
70 | public void testFailOnJobSequenceFailed() {
71 | def jobs = createJobs(["job1", "job2", "job3"])
72 | createFailJob("willFail")
73 | def job4 = createJob("job4")
74 | def flow = run("""
75 | parallel (
76 | {
77 | build("job1")
78 | build("job2")
79 | },
80 | {
81 | build("job3")
82 | build("willfail")
83 | }
84 | )
85 | build("job4")
86 | """)
87 | assertDidNotRun(job4)
88 | assertAllSuccess(jobs)
89 | assert FAILURE == flow.result
90 | println flow.jobsGraph.edgeSet()
91 | }
92 |
93 | @Test
94 | public void testGetParallelResults() {
95 | def jobs = createJobs(["job1", "job2", "job3"])
96 | def job4 = createJob("job4")
97 | def flow = run("""
98 | join = parallel (
99 | { build("job1") },
100 | { build("job2") },
101 | { build("job3") }
102 | )
103 | build("job4",
104 | r1: join[0].result.name,
105 | r2: join[1].lastBuild.parent.name)
106 | """)
107 | assertAllSuccess(jobs)
108 | assertSuccess(job4)
109 | assertHasParameter(job4, "r1", "SUCCESS")
110 | assertHasParameter(job4, "r2", "job2")
111 | assert SUCCESS == flow.result
112 | println flow.jobsGraph.edgeSet()
113 | }
114 |
115 | @Test
116 | public void testParallelMap() {
117 | def jobs = createJobs(["job1", "job2", "job3"])
118 | def job4 = createJob("job4")
119 | def flow = run("""
120 | join = parallel ([
121 | first: { build("job1") },
122 | second: { build("job2") },
123 | third: { build("job3") }
124 | ])
125 | build("job4",
126 | r1: join.first.result.name,
127 | r2: join.second.lastBuild.parent.name)
128 | """)
129 | assertAllSuccess(jobs)
130 | assertSuccess(job4)
131 | assertHasParameter(job4, "r1", "SUCCESS")
132 | assertHasParameter(job4, "r2", "job2")
133 | assert SUCCESS == flow.result
134 | println flow.jobsGraph.edgeSet()
135 | }
136 |
137 | }
138 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/PipelineTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2016, Tom Fenelly, Craig Rodrigues
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 | package com.cloudbees.plugins.flow
25 |
26 | import com.cloudbees.plugin.flow.ConfigurableFailureBuilder
27 |
28 | import hudson.model.FreeStyleBuild
29 | import hudson.model.FreeStyleProject
30 | import hudson.model.ParametersAction
31 | import hudson.model.ParametersDefinitionProperty
32 | import hudson.model.Job
33 | import hudson.model.Result
34 | import hudson.model.Run
35 |
36 | import org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition
37 | import org.jenkinsci.plugins.workflow.job.WorkflowJob
38 | import org.jenkinsci.plugins.workflow.job.WorkflowRun
39 | import org.junit.Assert
40 | import org.junit.Rule
41 | import org.junit.Test
42 | import org.jvnet.hudson.test.JenkinsRule
43 |
44 | import java.io.IOException
45 | import java.util.List
46 |
47 | public class PipelineTest extends DSLTestCase {
48 |
49 | @Test
50 | public void test_SuccessfulPipeline() throws Exception {
51 | // From a pipeline, build a job that succeeds
52 | def proj1 = jenkinsRule.createFreeStyleProject("proj1")
53 | def build_flow1 = createFlow("build_flow1",
54 | """build 'proj1'""")
55 | def pipeline_1 = createPipeline("pipeline_proj1",
56 | """build job: 'build_flow1'""")
57 | def pipeline_1_result = pipeline_1.scheduleBuild2(0).get()
58 | jenkinsRule.assertBuildStatusSuccess(pipeline_1_result)
59 | jenkinsRule.assertBuildStatusSuccess(proj1.getLastBuild())
60 | }
61 |
62 | @Test
63 | public void test_FailedPipeline() throws Exception {
64 | // From a pipeline, build a job that fails
65 | def proj2 = jenkinsRule.createFreeStyleProject("proj2")
66 | proj2.getBuildersList().add(new ConfigurableFailureBuilder(1))
67 | def build_flow2 = createFlow("build_flow2",
68 | """build 'proj2'""")
69 | def pipeline_2 = createPipeline("pipeline_proj2",
70 | """build job: 'build_flow2'""")
71 | def pipeline_2_result = pipeline_2.scheduleBuild2(0).get()
72 | jenkinsRule.assertBuildStatus(Result.FAILURE, pipeline_2_result)
73 | jenkinsRule.assertBuildStatus(Result.FAILURE, proj2.getLastBuild())
74 | }
75 |
76 | private def createPipeline(String name, String script) throws IOException {
77 | def job = jenkinsRule.jenkins.createProject(WorkflowJob.class, name)
78 | job.setDefinition(new CpsFlowDefinition("node {" + script + "}", true))
79 | return job
80 | }
81 |
82 | private BuildFlow createFlow(String name, String dsl) {
83 | def job = jenkinsRule.jenkins.createProject(BuildFlow, name)
84 | job.dsl = dsl
85 | return job
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/RetryTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | package com.cloudbees.plugins.flow
26 |
27 | import hudson.model.Result
28 | import static hudson.model.Result.SUCCESS
29 | import static hudson.model.Result.UNSTABLE
30 | import static hudson.model.Result.FAILURE
31 | import hudson.model.Job
32 | import org.junit.Test
33 |
34 | class RetryTest extends DSLTestCase {
35 |
36 | @Test
37 | public void testNoRetry() {
38 | Job job1 = createJob("job1")
39 | def flow = run("""
40 | retry(3) {
41 | build("job1")
42 | }
43 | """)
44 | assertRan(job1, 1, SUCCESS)
45 | assert SUCCESS == flow.result
46 | }
47 |
48 | @Test
49 | public void testRetry() {
50 | def job1 = createFailJob("willFail")
51 | def flow = run("""
52 | retry(3) {
53 | build("willFail")
54 | }
55 | """)
56 | assertRan(job1, 3, FAILURE)
57 | assert FAILURE == flow.result
58 | }
59 |
60 | @Test
61 | public void testRetryThenSuccess() {
62 | testRetryThenSuccess("""
63 | retry(3) {
64 | build("willFail2times")
65 | }
66 | """)
67 | }
68 |
69 | @Test
70 | public void testNoQuotesNotation() {
71 | testRetryThenSuccess("""
72 | retry 3, {
73 | build("willFail2times")
74 | }
75 | """)
76 | }
77 |
78 | /*
79 | @Test
80 | public void testNTimesNotation() {
81 | testRetryThenSuccess("""
82 | 3.times retry {
83 | build("willFail2times")
84 | }
85 | """)
86 | }
87 | */
88 |
89 | public void testRetryThenSuccess(String script) {
90 | def job1 = createFailJob("willFail2times", 2)
91 | def flow = run(script)
92 | assert job1.builds.size() == 3
93 | assert job1.builds[2].result == FAILURE
94 | assert job1.builds[1].result == FAILURE
95 | assert job1.builds[0].result == SUCCESS
96 |
97 | assert SUCCESS == flow.result
98 | println flow.jobsGraph.edgeSet()
99 | }
100 |
101 | @Test
102 | public void testRetryGuard() {
103 | def fail = createFailJob("willFail")
104 | def rescue = createJob("rescue")
105 | def flow = run("""
106 | retry(3) {
107 | guard {
108 | build("willFail")
109 | } rescue {
110 | build("rescue")
111 | }
112 | }
113 | """)
114 |
115 | assertRan(fail, 3, FAILURE)
116 | assertRan(rescue, 3, SUCCESS)
117 | assert FAILURE == flow.result
118 | println flow.jobsGraph.edgeSet()
119 | }
120 |
121 | @Test
122 | public void testNoRetryUnstable() {
123 | Job job1 = createUnstableJob("job1")
124 | def flow = run("""
125 | retry(3, 'UNSTABLE') {
126 | build("job1")
127 | }
128 | """)
129 | assertRan(job1, 1, UNSTABLE)
130 | assert UNSTABLE == flow.result
131 | }
132 |
133 |
134 |
135 | }
136 |
--------------------------------------------------------------------------------
/src/test/groovy/com/cloudbees/plugins/flow/UpstreamTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, CloudBees, Inc., Nicolas De Loof.
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | package com.cloudbees.plugins.flow
26 |
27 | import hudson.model.Cause
28 |
29 | import static hudson.model.Result.SUCCESS
30 | import hudson.model.Job
31 | import org.junit.Test
32 |
33 | class UpstreamTest extends DSLTestCase {
34 |
35 | @Test
36 | public void testUpstream() {
37 |
38 | Job job1 = createJob("job1")
39 | def root = jenkinsRule.createFreeStyleProject("root").createExecutable()
40 | def cause = new Cause.UpstreamCause(root)
41 | def run = runWithCause("""
42 | build("job1",
43 | param1: upstream.parent.name,
44 | param2: upstream.number)
45 | """, cause)
46 | def build = assertSuccess(job1)
47 | assertHasParameter(build, "param1", "root")
48 | assertHasParameter(build, "param2", "1")
49 |
50 | assert SUCCESS == run.result
51 | }
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/src/test/java/com/cloudbees/plugin/flow/BlockingBuilder.java:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License
3 | *
4 | * Copyright (c) 2013, Cisco Systems, Inc., a California corporation
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 | package com.cloudbees.plugin.flow;
25 |
26 | import hudson.Extension;
27 | import hudson.Launcher;
28 | import hudson.model.AbstractBuild;
29 | import hudson.model.BuildListener;
30 | import hudson.model.Descriptor;
31 | import hudson.tasks.Builder;
32 | import net.sf.json.JSONObject;
33 | import org.kohsuke.stapler.StaplerRequest;
34 |
35 | import java.io.File;
36 |
37 | import static hudson.model.Result.ABORTED;
38 | import static hudson.model.Result.FAILURE;
39 | import static hudson.model.Result.SUCCESS;
40 |
41 | /**
42 | * A Builder that will block until a file exists.
43 | *
44 | * @author James Nord
45 | */
46 | public class BlockingBuilder extends Builder {
47 |
48 | public final static File DEFAULT_FILE = new File("target", "build_block.txt");
49 |
50 | public final File file;
51 |
52 | BlockingBuilder(File file) {
53 | this.file = file;
54 | }
55 |
56 |
57 | public boolean perform(AbstractBuild build, Launcher launcher, BuildListener listener) {
58 | System.out.println("Blocking Builder in build " + build.getFullDisplayName() + "starting");
59 | try {
60 | System.out.println("Blocking Builder in build " + build.getFullDisplayName() + "waiting");
61 | while (file.exists()) {
62 | Thread.sleep(10L);
63 | }
64 | build.setResult(SUCCESS);
65 | } catch (InterruptedException ex) {
66 | build.setResult(ABORTED);
67 | }
68 | System.out.println("Blocking Builder in build " + build.getFullDisplayName() + " completing " + build.getResult());
69 | return true;
70 | }
71 |
72 | @Extension
73 | public static final class DescriptorImpl extends Descriptor