-
-
Notifications
You must be signed in to change notification settings - Fork 2k
/
Runtime.java
156 lines (131 loc) · 4.98 KB
/
Runtime.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
package cucumber.runtime;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import cucumber.io.ClasspathResourceLoader;
import cucumber.io.ResourceLoader;
import cucumber.runtime.autocomplete.MetaStepdef;
import cucumber.runtime.autocomplete.StepdefGenerator;
import cucumber.runtime.model.CucumberFeature;
import cucumber.runtime.model.CucumberTagStatement;
import gherkin.formatter.Formatter;
import gherkin.formatter.Reporter;
import gherkin.formatter.model.Step;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import static cucumber.runtime.model.CucumberFeature.load;
import static java.util.Collections.emptyList;
/**
* This is the main entry point for running Cucumber features.
*/
public class Runtime {
private static final byte ERRORS = 0x1;
private static final List<Object> NO_FILTERS = emptyList();
private final UndefinedStepsTracker tracker;
private final List<Throwable> errors = new ArrayList<Throwable>();
private final Collection<? extends Backend> backends;
private final boolean isDryRun;
private final ResourceLoader resourceLoader;
private World world;
public Runtime(List<String> gluePaths, ResourceLoader resourceLoader) {
this(gluePaths, resourceLoader, false);
}
public Runtime(List<String> gluePaths, ResourceLoader resourceLoader, boolean isDryRun) {
this(gluePaths, resourceLoader, loadBackends(resourceLoader), isDryRun);
}
public Runtime(List<String> gluePaths, ResourceLoader resourceLoader, Collection<? extends Backend> backends, boolean isDryRun) {
this.backends = backends;
this.resourceLoader = resourceLoader;
this.isDryRun = isDryRun;
this.tracker = new UndefinedStepsTracker(backends);
this.world = new RuntimeWorld(this);
for (Backend backend : backends) {
backend.loadGlue(world, gluePaths);
}
}
private static Collection<? extends Backend> loadBackends(ResourceLoader resourceLoader) {
return new ClasspathResourceLoader().instantiateSubclasses(Backend.class, "cucumber/runtime", new Class[]{ResourceLoader.class}, new Object[]{resourceLoader});
}
public void addError(Throwable error) {
errors.add(error);
}
/**
* This is where the first entry happens. World should be passed along through this through the various scopes
*
* @param featurePaths
* @param filters
* @param formatter
* @param reporter
*/
public void run(List<String> featurePaths, final List<Object> filters, gherkin.formatter.Formatter formatter, Reporter reporter) {
for (CucumberFeature cucumberFeature : load(resourceLoader, featurePaths, filters)) {
run(cucumberFeature, formatter, reporter);
}
}
public void run(CucumberFeature cucumberFeature, Formatter formatter, Reporter reporter) {
formatter.uri(cucumberFeature.getUri());
formatter.feature(cucumberFeature.getFeature());
for (CucumberTagStatement cucumberTagStatement : cucumberFeature.getFeatureElements()) {
cucumberTagStatement.run(formatter, reporter, world);
}
formatter.eof();
}
public void buildBackendWorlds() {
for (Backend backend : backends) {
backend.buildWorld();
}
tracker.reset();
}
public void disposeBackendWorlds() {
for (Backend backend : backends) {
backend.disposeWorld();
}
}
/**
* This is the second entry to running features
*
* @param featurePaths
* @param dotCucumber
* @throws IOException
*/
public void writeStepdefsJson(List<String> featurePaths, File dotCucumber) throws IOException {
List<CucumberFeature> features = load(resourceLoader, featurePaths, NO_FILTERS);
buildBackendWorlds();
List<StepDefinition> stepDefs = world.getStepDefinitions();
List<MetaStepdef> metaStepdefs = new StepdefGenerator().generate(stepDefs, features);
Gson gson = new GsonBuilder().setPrettyPrinting().create();
String json = gson.toJson(metaStepdefs);
FileWriter metaJson = new FileWriter(new File(dotCucumber, "stepdefs.json"));
metaJson.append(json);
metaJson.close();
}
public boolean isDryRun() {
return isDryRun;
}
public List<Throwable> getErrors() {
return errors;
}
public byte exitStatus() {
byte result = 0x0;
if (!errors.isEmpty()) {
result |= ERRORS;
}
return result;
}
public void storeStepKeyword(Step step, Locale locale) {
tracker.storeStepKeyword(step, locale);
}
public void addUndefinedStep(Step step, Locale locale) {
tracker.addUndefinedStep(step, locale);
}
public List<String> getSnippets() {
return tracker.getSnippets();
}
public World getWorld() {
return world;
}
}