Subversion-Projekte lars-tiefland.laravel_shop

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
148 lars 1 
<?php
2 
 
3 
namespace Illuminate\Testing;
4 
 
5 
use Illuminate\Contracts\Container\Container;
6 
use Illuminate\Support\Str;
7 
 
8 
class ParallelTesting
9 
{
10 
    /**
11 
     * The container instance.
12 
     *
13 
     * @var \Illuminate\Contracts\Container\Container
14 
     */
15 
    protected $container;
16 
 
17 
    /**
18 
     * The options resolver callback.
19 
     *
20 
     * @var \Closure|null
21 
     */
22 
    protected $optionsResolver;
23 
 
24 
    /**
25 
     * The token resolver callback.
26 
     *
27 
     * @var \Closure|null
28 
     */
29 
    protected $tokenResolver;
30 
 
31 
    /**
32 
     * All of the registered "setUp" process callbacks.
33 
     *
34 
     * @var array
35 
     */
36 
    protected $setUpProcessCallbacks = [];
37 
 
38 
    /**
39 
     * All of the registered "setUp" test case callbacks.
40 
     *
41 
     * @var array
42 
     */
43 
    protected $setUpTestCaseCallbacks = [];
44 
 
45 
    /**
46 
     * All of the registered "setUp" test database callbacks.
47 
     *
48 
     * @var array
49 
     */
50 
    protected $setUpTestDatabaseCallbacks = [];
51 
 
52 
    /**
53 
     * All of the registered "tearDown" process callbacks.
54 
     *
55 
     * @var array
56 
     */
57 
    protected $tearDownProcessCallbacks = [];
58 
 
59 
    /**
60 
     * All of the registered "tearDown" test case callbacks.
61 
     *
62 
     * @var array
63 
     */
64 
    protected $tearDownTestCaseCallbacks = [];
65 
 
66 
    /**
67 
     * Create a new parallel testing instance.
68 
     *
69 
     * @param  \Illuminate\Contracts\Container\Container  $container
70 
     * @return void
71 
     */
72 
    public function __construct(Container $container)
73 
    {
74 
        $this->container = $container;
75 
    }
76 
 
77 
    /**
78 
     * Set a callback that should be used when resolving options.
79 
     *
80 
     * @param  \Closure|null  $resolver
81 
     * @return void
82 
     */
83 
    public function resolveOptionsUsing($resolver)
84 
    {
85 
        $this->optionsResolver = $resolver;
86 
    }
87 
 
88 
    /**
89 
     * Set a callback that should be used when resolving the unique process token.
90 
     *
91 
     * @param  \Closure|null  $resolver
92 
     * @return void
93 
     */
94 
    public function resolveTokenUsing($resolver)
95 
    {
96 
        $this->tokenResolver = $resolver;
97 
    }
98 
 
99 
    /**
100 
     * Register a "setUp" process callback.
101 
     *
102 
     * @param  callable  $callback
103 
     * @return void
104 
     */
105 
    public function setUpProcess($callback)
106 
    {
107 
        $this->setUpProcessCallbacks[] = $callback;
108 
    }
109 
 
110 
    /**
111 
     * Register a "setUp" test case callback.
112 
     *
113 
     * @param  callable  $callback
114 
     * @return void
115 
     */
116 
    public function setUpTestCase($callback)
117 
    {
118 
        $this->setUpTestCaseCallbacks[] = $callback;
119 
    }
120 
 
121 
    /**
122 
     * Register a "setUp" test database callback.
123 
     *
124 
     * @param  callable  $callback
125 
     * @return void
126 
     */
127 
    public function setUpTestDatabase($callback)
128 
    {
129 
        $this->setUpTestDatabaseCallbacks[] = $callback;
130 
    }
131 
 
132 
    /**
133 
     * Register a "tearDown" process callback.
134 
     *
135 
     * @param  callable  $callback
136 
     * @return void
137 
     */
138 
    public function tearDownProcess($callback)
139 
    {
140 
        $this->tearDownProcessCallbacks[] = $callback;
141 
    }
142 
 
143 
    /**
144 
     * Register a "tearDown" test case callback.
145 
     *
146 
     * @param  callable  $callback
147 
     * @return void
148 
     */
149 
    public function tearDownTestCase($callback)
150 
    {
151 
        $this->tearDownTestCaseCallbacks[] = $callback;
152 
    }
153 
 
154 
    /**
155 
     * Call all of the "setUp" process callbacks.
156 
     *
157 
     * @return void
158 
     */
159 
    public function callSetUpProcessCallbacks()
160 
    {
161 
        $this->whenRunningInParallel(function () {
162 
            foreach ($this->setUpProcessCallbacks as $callback) {
163 
                $this->container->call($callback, [
164 
                    'token' => $this->token(),
165 
                ]);
166 
            }
167 
        });
168 
    }
169 
 
170 
    /**
171 
     * Call all of the "setUp" test case callbacks.
172 
     *
173 
     * @param  \Illuminate\Foundation\Testing\TestCase  $testCase
174 
     * @return void
175 
     */
176 
    public function callSetUpTestCaseCallbacks($testCase)
177 
    {
178 
        $this->whenRunningInParallel(function () use ($testCase) {
179 
            foreach ($this->setUpTestCaseCallbacks as $callback) {
180 
                $this->container->call($callback, [
181 
                    'testCase' => $testCase,
182 
                    'token' => $this->token(),
183 
                ]);
184 
            }
185 
        });
186 
    }
187 
 
188 
    /**
189 
     * Call all of the "setUp" test database callbacks.
190 
     *
191 
     * @param  string  $database
192 
     * @return void
193 
     */
194 
    public function callSetUpTestDatabaseCallbacks($database)
195 
    {
196 
        $this->whenRunningInParallel(function () use ($database) {
197 
            foreach ($this->setUpTestDatabaseCallbacks as $callback) {
198 
                $this->container->call($callback, [
199 
                    'database' => $database,
200 
                    'token' => $this->token(),
201 
                ]);
202 
            }
203 
        });
204 
    }
205 
 
206 
    /**
207 
     * Call all of the "tearDown" process callbacks.
208 
     *
209 
     * @return void
210 
     */
211 
    public function callTearDownProcessCallbacks()
212 
    {
213 
        $this->whenRunningInParallel(function () {
214 
            foreach ($this->tearDownProcessCallbacks as $callback) {
215 
                $this->container->call($callback, [
216 
                    'token' => $this->token(),
217 
                ]);
218 
            }
219 
        });
220 
    }
221 
 
222 
    /**
223 
     * Call all of the "tearDown" test case callbacks.
224 
     *
225 
     * @param  \Illuminate\Foundation\Testing\TestCase  $testCase
226 
     * @return void
227 
     */
228 
    public function callTearDownTestCaseCallbacks($testCase)
229 
    {
230 
        $this->whenRunningInParallel(function () use ($testCase) {
231 
            foreach ($this->tearDownTestCaseCallbacks as $callback) {
232 
                $this->container->call($callback, [
233 
                    'testCase' => $testCase,
234 
                    'token' => $this->token(),
235 
                ]);
236 
            }
237 
        });
238 
    }
239 
 
240 
    /**
241 
     * Get a parallel testing option.
242 
     *
243 
     * @param  string  $option
244 
     * @return mixed
245 
     */
246 
    public function option($option)
247 
    {
248 
        $optionsResolver = $this->optionsResolver ?: function ($option) {
249 
            $option = 'LARAVEL_PARALLEL_TESTING_'.Str::upper($option);
250 
 
251 
            return $_SERVER[$option] ?? false;
252 
        };
253 
 
254 
        return $optionsResolver($option);
255 
    }
256 
 
257 
    /**
258 
     * Gets a unique test token.
259 
     *
260 
     * @return string|false
261 
     */
262 
    public function token()
263 
    {
264 
        return $this->tokenResolver
265 
            ? call_user_func($this->tokenResolver)
266 
            : ($_SERVER['TEST_TOKEN'] ?? false);
267 
    }
268 
 
269 
    /**
270 
     * Apply the callback if tests are running in parallel.
271 
     *
272 
     * @param  callable  $callback
273 
     * @return void
274 
     */
275 
    protected function whenRunningInParallel($callback)
276 
    {
277 
        if ($this->inParallel()) {
278 
            $callback();
279 
        }
280 
    }
281 
 
282 
    /**
283 
     * Indicates if the current tests are been run in parallel.
284 
     *
285 
     * @return bool
286 
     */
287 
    protected function inParallel()
288 
    {
289 
        return ! empty($_SERVER['LARAVEL_PARALLEL_TESTING']) && $this->token();
290 
    }
291 
}