5 |
6 |
7 |
8 |
51 | @endsection
52 |
--------------------------------------------------------------------------------
/src/Browser/Concerns/ExecutesWindowCommands.php:
--------------------------------------------------------------------------------
1 | command(new CloseBrowserWindow());
22 | }
23 |
24 | public function fitContent(): static
25 | {
26 | return $this->command(new FitContent());
27 | }
28 |
29 | public function maximize(): static
30 | {
31 | return $this->command(new Maximize());
32 | }
33 |
34 | public function openNewWindow(): static
35 | {
36 | return $this->command(new OpenNewWindow());
37 | }
38 |
39 | public function resize(int $width, int $height): static
40 | {
41 | return $this->command(new Resize($width, $height));
42 | }
43 |
44 | public function setPosition(int $x, int $y): static
45 | {
46 | return $this->command(new SetPosition($x, $y));
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertHasCookie.php:
--------------------------------------------------------------------------------
1 | actual = $manager->manage()->getCookieNamed($this->name);
29 | } catch (NoSuchCookieException) {
30 | $this->actual = null;
31 | }
32 | }
33 |
34 | protected function performAssertions(RemoteWebDriverBroker $broker): void
35 | {
36 | $value = $this->getValue();
37 |
38 | Assert::assertNotNull($value, "Did not find expected cookie [{$this->name}].");
39 |
40 | if (null !== $this->expected) {
41 | Assert::assertEquals(
42 | $value,
43 | $this->expected,
44 | "Cookie [{$this->name}] had value [{$value}], but expected [{$this->expected}]."
45 | );
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertSelectionState.php:
--------------------------------------------------------------------------------
1 | resolver->{$this->resolver}($this->selector(), $this->value);
32 |
33 | $this->selected = $element->isSelected();
34 | $this->indeterminate = 'true' === $element->getAttribute('indeterminate');
35 | }
36 |
37 | protected function performAssertions(RemoteWebDriverBroker $broker): void
38 | {
39 | $selector = $this->selector()->getValue();
40 |
41 | Assert::assertEquals(
42 | $this->expected,
43 | $this->selected,
44 | sprintf($this->message, $selector),
45 | );
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/src/Support/ResponseQueue.php:
--------------------------------------------------------------------------------
1 | queue = new Collection();
18 | }
19 |
20 | public function push(string $request_id, $response): static
21 | {
22 | $this->queue->put($request_id, $response);
23 |
24 | return $this;
25 | }
26 |
27 | public function waitForResponse(string $request_id, float $timeout = 10): mixed
28 | {
29 | $this->loop->addPeriodicTimer(0.1, function($timer) use ($request_id) {
30 | if ($this->queue->has($request_id)) {
31 | $this->loop->cancelTimer($timer);
32 | $this->loop->stop();
33 | }
34 | });
35 |
36 | $timed_out = false;
37 | $this->loop->addTimer($timeout, function() use (&$timed_out) {
38 | $timed_out = true;
39 | $this->loop->stop();
40 | });
41 |
42 | while (! $this->queue->has($request_id)) {
43 | if ($timed_out) {
44 | throw new RuntimeException('Background process timed out.');
45 | }
46 | $this->loop->run();
47 | }
48 |
49 | $response = $this->queue->pull($request_id);
50 |
51 | if ($response instanceof Throwable) {
52 | throw $response;
53 | }
54 |
55 | return $response;
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertOptionPresence.php:
--------------------------------------------------------------------------------
1 | resolver->resolveSelectOptions($this->selector, $this->options);
29 |
30 | $this->count = collect($options)
31 | ->unique(fn(RemoteWebElement $option) => $option->getAttribute('value'))
32 | ->count();
33 | }
34 |
35 | protected function performAssertions(RemoteWebDriverBroker $broker): void
36 | {
37 | $selector = $this->selector()->getValue();
38 |
39 | $expected = $this->expected
40 | ? count($this->options)
41 | : 0;
42 |
43 | Assert::assertEquals(
44 | $expected,
45 | $this->count,
46 | sprintf($this->message, implode(', ', $this->options), $selector),
47 | );
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertLinkVisibility.php:
--------------------------------------------------------------------------------
1 | partial
29 | ? WebDriverBy::partialLinkText($this->text)
30 | : WebDriverBy::linkText($this->text);
31 |
32 | $manager->findElement($selector);
33 |
34 | $this->actual = true; // $this->isElementVisible($manager, $link);
35 | } catch (Throwable) {
36 | $this->actual = false;
37 | }
38 | }
39 |
40 | protected function performAssertions(RemoteWebDriverBroker $broker): void
41 | {
42 | $message = $this->expected
43 | ? "Did not see expected link [{$this->text}]."
44 | : "Saw unexpected link [{$this->text}].";
45 |
46 | Assert::assertEquals(
47 | $this->expected,
48 | $this->actual,
49 | $message
50 | );
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/tests/Feature/WaitTest.php:
--------------------------------------------------------------------------------
1 | openBrowser()->visit('/');
18 |
19 | $original = $browser->getText('#random');
20 |
21 | $browser->clickAndWaitForReload('#reload');
22 |
23 | $reloaded = $browser->getText('#random');
24 |
25 | $this->assertNotEquals($original, $reloaded);
26 | }
27 |
28 | public function test_location_waits(): void
29 | {
30 | Route::get('a', function() {
31 | return response('Go to B', headers: ['Content-Type' => 'text/html']);
32 | });
33 |
34 | Route::get('b', function() {
35 | return response('Go to C', headers: ['Content-Type' => 'text/html']);
36 | });
37 |
38 | Route::get('c', function() {
39 | return response('Go to A', headers: ['Content-Type' => 'text/html']);
40 | });
41 |
42 | $this->expectNotToPerformAssertions();
43 |
44 | $this->openBrowser()
45 | ->visit('/a')
46 | ->clickLink('Go to B')
47 | ->waitForLocation('/b')
48 | ->clickLink('Go to C')
49 | ->waitForLocation('/c')
50 | ->clickLink('Go to A')
51 | ->waitForLocation('/a');
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertVue.php:
--------------------------------------------------------------------------------
1 | resolver->findOrFail($this->selector ?? '');
29 |
30 | $this->actual = (new Vue($manager))->attribute($element, $this->key);
31 | }
32 |
33 | protected function performAssertions(RemoteWebDriverBroker $broker): void
34 | {
35 | [$assertion, $message] = $this->getAssertion();
36 |
37 | $assertion($this->value, $this->actual, sprintf($message, json_encode($this->value), $this->key));
38 | }
39 |
40 | protected function getAssertion(): array
41 | {
42 | if ($this->not) {
43 | return [Assert::assertNotEquals(...), 'Saw unexpected value [%s] at the key [%s].'];
44 | }
45 |
46 | return [Assert::assertEquals(...), 'Did not see expected value [%s] at the key [%s].'];
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/BrowserAssertionCommand.php:
--------------------------------------------------------------------------------
1 | browser_manager->switchToBrowser($this->browser_id);
27 | $this->loadData($context->browser_manager);
28 | $context->sendCommand($this);
29 | $context->respond($this);
30 | } catch (Throwable $exception) {
31 | $context->sendException($exception);
32 | }
33 | }
34 |
35 | // If we're executing in the main process, we'll run the assertions
36 | if ($context instanceof RemoteWebDriverBroker) {
37 | $this->performAssertions($context);
38 | }
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/src/IO/Commands/ThrowException.php:
--------------------------------------------------------------------------------
1 | exception)) {
34 | $this->exception = new Exception($this->exception);
35 | }
36 |
37 | throw $this->exception;
38 | }
39 |
40 | public function toData(): string
41 | {
42 | try {
43 | return parent::toData();
44 | } catch (Throwable $exception) {
45 | // If the full exception can't be serialized, then we'll just send the message
46 | if (! is_string($this->exception)) {
47 | $this->exception = class_basename($this->exception).': '.$this->exception->getMessage();
48 | return parent::toData();
49 | }
50 |
51 | // If we already have a string, we'll just re-throw
52 | throw $exception;
53 | }
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/src/Browser/RemoteWebDriverBroker.php:
--------------------------------------------------------------------------------
1 | queue = new ResponseQueue($loop);
27 | }
28 |
29 | public function addToResponseQueue(string $request_id, $response): static
30 | {
31 | $this->queue->push($request_id, $response);
32 |
33 | return $this;
34 | }
35 |
36 | public function stop(): void
37 | {
38 | $this->debug('Stopping remote web driver.');
39 |
40 | $this->process->signal(SIGTERM);
41 | }
42 |
43 | public function sendCommandAndWaitForResponse(Command $command): mixed
44 | {
45 | $this->sendCommand($command);
46 |
47 | return $this->queue->waitForResponse($command->id);
48 | }
49 |
50 | protected function startBackgroundProcess(InputStream $stdin): Process
51 | {
52 | $process = $this->artisan(['dawn:drive', $this->url], $stdin);
53 |
54 | register_shutdown_function(fn() => $process->stop(1, SIGKILL));
55 |
56 | $process->start();
57 |
58 | return $process;
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "glhd/dawn",
3 | "description": "",
4 | "keywords": [
5 | "laravel"
6 | ],
7 | "authors": [
8 | {
9 | "name": "Chris Morrell",
10 | "homepage": "http://www.cmorrell.com"
11 | }
12 | ],
13 | "license": "MIT",
14 | "require": {
15 | "php": "^8.1",
16 | "ext-json": "*",
17 | "ext-pcntl": "*",
18 | "ext-sockets": "*",
19 | "ext-zip": "*",
20 | "illuminate/support": "9.*|10.*|dev-master",
21 | "nyholm/psr7": "^1.5",
22 | "php-webdriver/webdriver": "^1.14",
23 | "react/http": "^1.8",
24 | "symfony/psr-http-message-bridge": "^2.1"
25 | },
26 | "require-dev": {
27 | "orchestra/testbench": "7.*|^8.2.2|dev-master",
28 | "friendsofphp/php-cs-fixer": "^3.0",
29 | "mockery/mockery": "^1.3",
30 | "phpunit/phpunit": "^9.5",
31 | "laravel/sanctum": "^3.0",
32 | "nunomaduro/collision": "^6.1",
33 | "spatie/laravel-ignition": "1.*|2.*"
34 | },
35 | "autoload": {
36 | "psr-4": {
37 | "Glhd\\Dawn\\": "src/"
38 | }
39 | },
40 | "autoload-dev": {
41 | "classmap": [
42 | "tests/TestCase.php"
43 | ],
44 | "psr-4": {
45 | "Glhd\\Dawn\\Tests\\": "tests/"
46 | }
47 | },
48 | "scripts": {
49 | "fix-style": "vendor/bin/php-cs-fixer fix",
50 | "check-style": "vendor/bin/php-cs-fixer fix --diff --dry-run"
51 | },
52 | "extra": {
53 | "laravel": {
54 | "providers": [
55 | "Glhd\\Dawn\\Providers\\DawnServiceProvider"
56 | ]
57 | }
58 | },
59 | "minimum-stability": "dev",
60 | "prefer-stable": true
61 | }
62 |
--------------------------------------------------------------------------------
/src/Browser/SeleniumDriverProcess.php:
--------------------------------------------------------------------------------
1 | findChromeDriverExecutable();
14 |
15 | array_unshift($arguments, "--port={$port}");
16 | array_unshift($arguments, $executable);
17 |
18 | parent::__construct(command: $arguments, env: $this->getSeleniumDriverEnvironment());
19 |
20 | register_shutdown_function(fn() => $this->signal(SIGKILL));
21 |
22 | $this->start();
23 |
24 | $this->waitUntil(function($type, $output) {
25 | return Str::of($output)->contains('started successfully');
26 | });
27 | }
28 |
29 | protected function findChromeDriverExecutable(): string
30 | {
31 | $finder = new ExecutableFinder();
32 |
33 | $default = file_exists('/opt/homebrew/bin/chromedriver')
34 | ? '/opt/homebrew/bin/chromedriver'
35 | : '/usr/local/bin/chromedriver';
36 |
37 | return $finder->find('chromedriver', $default);
38 | }
39 |
40 | protected function getSeleniumDriverEnvironment(): array
41 | {
42 | if ($this->onMacOrWindows()) {
43 | return [];
44 | }
45 |
46 | return [
47 | 'DISPLAY' => $_ENV['DISPLAY'] ?? ':0',
48 | ];
49 | }
50 |
51 | protected function onMacOrWindows(): bool
52 | {
53 | return PHP_OS === 'Darwin'
54 | || PHP_OS === 'WINNT'
55 | || Str::contains(php_uname(), 'Microsoft');
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/IO/CommandIO.php:
--------------------------------------------------------------------------------
1 | buffer = new CommandBuffer($this->handleCommand(...));
23 | $in->on('data', fn($chunk) => $this->buffer->write($chunk));
24 | }
25 |
26 | public function sendCommand(Command $command): static
27 | {
28 | $this->out->write($command->toData());
29 |
30 | return $this;
31 | }
32 |
33 | protected function handleCommand(Command $command): void
34 | {
35 | if (! method_exists($command, 'execute')) {
36 | return;
37 | }
38 |
39 | $reflection = new ReflectionMethod($command, 'execute');
40 | if (! count($parameters = $reflection->getParameters())) {
41 | return;
42 | }
43 |
44 | foreach (Reflector::getParameterClassNames($parameters[0]) as $type_hint) {
45 | if (is_a($this->context, $type_hint)) {
46 | try {
47 | $command->execute($this->context);
48 | } catch (Throwable $exception) {
49 | if ($this->context instanceof BackgroundProcess) {
50 | $this->context->sendException($exception);
51 | } else {
52 | throw $exception;
53 | }
54 | }
55 | return;
56 | }
57 | }
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertInputValue.php:
--------------------------------------------------------------------------------
1 | actual = $this->getValue($manager);
27 | }
28 |
29 | protected function getValue(BrowserManager $manager): mixed
30 | {
31 | $element = $manager->resolver->resolveForTyping($this->selector);
32 |
33 | return match ($element->getTagName()) {
34 | 'input', 'textarea' => $element->getAttribute('value'),
35 | default => $element->getText(),
36 | };
37 | }
38 |
39 | protected function performAssertions(RemoteWebDriverBroker $broker): void
40 | {
41 | $selector = $this->selector()->getValue();
42 |
43 | if ($this->not) {
44 | Assert::assertNotEquals(
45 | $this->value,
46 | $this->actual,
47 | "Value [{$this->value}] for the [{$selector}] input should not equal the actual value."
48 | );
49 | }
50 |
51 | Assert::assertEquals(
52 | $this->value,
53 | $this->actual,
54 | "Expected value [{$this->value}] for the [{$selector}] input does not equal the actual value [{$this->actual}]."
55 | );
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertQueryStringHas.php:
--------------------------------------------------------------------------------
1 | actual = $manager->getCurrentURL();
24 | }
25 |
26 | protected function performAssertions(RemoteWebDriverBroker $broker): void
27 | {
28 | $parts = parse_url($this->actual);
29 |
30 | Assert::assertArrayHasKey(
31 | 'query',
32 | $parts,
33 | 'Did not see expected query string in ['.$this->actual.'].'
34 | );
35 |
36 | parse_str($parts['query'], $output);
37 |
38 | Assert::assertTrue(
39 | Arr::has($output, $this->name),
40 | "Did not see expected query string parameter [{$this->name}] in [{$this->actual}]."
41 | );
42 |
43 | if (! $this->value) {
44 | return;
45 | }
46 |
47 | $actual = Arr::get($output, $this->name, new stdClass());
48 |
49 | $actual_for_message = is_array($actual)
50 | ? implode(',', $actual)
51 | : $actual;
52 |
53 | $expected_for_message = is_array($this->value)
54 | ? implode(',', $this->value)
55 | : $this->value;
56 |
57 | Assert::assertEquals(
58 | $this->value,
59 | $actual,
60 | "Query string parameter [{$this->name}] had value [{$actual_for_message}], but expected [{$expected_for_message}]."
61 | );
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/src/Http/Commands/SendWebResponse.php:
--------------------------------------------------------------------------------
1 | getStatusCode(),
17 | static::getPsrHeaders($response),
18 | static::getContent($response),
19 | $response->getProtocolVersion(),
20 | );
21 | }
22 |
23 | protected static function getPsrHeaders(SymfonyResponse $response): array
24 | {
25 | $headers = $response->headers->all();
26 |
27 | if (! empty($cookies = $response->headers->getCookies())) {
28 | $headers['Set-Cookie'] = [];
29 | foreach ($cookies as $cookie) {
30 | $headers['Set-Cookie'][] = $cookie->__toString();
31 | }
32 | }
33 |
34 | return $headers;
35 | }
36 |
37 | protected static function getContent(SymfonyResponse $response): string
38 | {
39 | // This accounts for binary responses that are typically streamed
40 | ob_start();
41 | $response->sendContent();
42 | return ob_get_clean();
43 | }
44 |
45 | public function __construct(
46 | public string $request_id,
47 | public int $status,
48 | public array $headers,
49 | public string $content,
50 | public string $version,
51 | ) {
52 | }
53 |
54 | public function execute(WebServerProcess $server)
55 | {
56 | $server->relay->handleResponse(
57 | request_id: $this->request_id,
58 | response: new ReactResponse($this->status, $this->headers, $this->content, $this->version),
59 | );
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/IO/CommandBuffer.php:
--------------------------------------------------------------------------------
1 | open) {
25 | throw new BadMethodCallException('Cannot write to a closed message buffer.');
26 | }
27 |
28 | $this->buffer .= $chunk;
29 |
30 | $this->emit();
31 |
32 | return $this;
33 | }
34 |
35 | public function close(): static
36 | {
37 | $this->emit();
38 |
39 | $this->open = false;
40 |
41 | return $this;
42 | }
43 |
44 | protected function emit(): void
45 | {
46 | if (! str_contains($this->buffer, "\n")) {
47 | return;
48 | }
49 |
50 | $chunks = Str::of($this->buffer)->explode("\n");
51 |
52 | // Since the last chunk is either a new line or a partial line,
53 | // we'll push it back to the buffer until we get more data
54 | $this->buffer = $chunks->pop();
55 |
56 | try {
57 | $chunks->filter()
58 | ->map(fn(string $chunk) => Command::fromData($chunk))
59 | ->each($this->callback);
60 | } catch (UnableToInstantiateCommandFromData) {
61 | // If we're unable to process a command, we'll assume that there's error output
62 | // that could not be serialized as a command. If that's the case, it's best to just
63 | // dump the whole message for debugging purposes (better of two evils).
64 | throw new RuntimeException("Error processing background output:\n\n".$chunks->join("\n"));
65 | }
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertHasClass.php:
--------------------------------------------------------------------------------
1 | resolver->findOrFail($this->selector);
27 | $class = $element->getAttribute('class') ?? '';
28 |
29 | $this->actual = explode(' ', $class);
30 | }
31 |
32 | protected function performAssertions(RemoteWebDriverBroker $broker): void
33 | {
34 | $selector = $this->selector()->getValue();
35 | $classes = (array) $this->class;
36 |
37 | if ($this->not) {
38 | $this->performNotContainsAssertions($classes, $selector);
39 | } else {
40 | $this->performContainsAssertions($classes, $selector);
41 | }
42 | }
43 |
44 | protected function performContainsAssertions(array $classes, string $selector): void
45 | {
46 | foreach ($classes as $class) {
47 | Assert::assertContains($class, $this->actual, "Did not find [{$class}] in class list for [{$selector}].");
48 | }
49 | }
50 |
51 | protected function performNotContainsAssertions(array $classes, string $selector): void
52 | {
53 | foreach ($classes as $class) {
54 | Assert::assertNotContains($class, $this->actual, "Found unexpected [{$class}] in class list for [{$selector}].");
55 | }
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Wait/WaitUsing.php:
--------------------------------------------------------------------------------
1 | getApply();
28 | }
29 |
30 | $this->closure = new SerializableClosure($wait->bindTo(null));
31 | $this->seconds ??= 5;
32 | }
33 |
34 | protected function executeWithBrowser(BrowserManager $manager)
35 | {
36 | $manager->wait($this->seconds, $this->interval)
37 | ->until($this->getClosure($manager), $this->message);
38 | }
39 |
40 | protected function getClosure(BrowserManager $manager): Closure
41 | {
42 | $closure = $this->closure->getClosure();
43 |
44 | // If our wait callback needs access to the BrowserManager instance, we'll need
45 | // to wrap it in a native "until" callback because that's handled inside the webdriver package.
46 | try {
47 | if (BrowserManager::class === $this->firstClosureParameterType($closure)) {
48 | return static function() use ($closure, $manager) {
49 | return $closure($manager);
50 | };
51 | }
52 | } catch (RuntimeException) {
53 | // If the closure doesn't have a typed parameter, we'll just leave it be
54 | }
55 |
56 | return $closure;
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/.github/workflows/coverage.yml:
--------------------------------------------------------------------------------
1 | name: Code Coverage
2 |
3 | on:
4 | push:
5 | branches:
6 | - main
7 |
8 | jobs:
9 | coverage:
10 | runs-on: ubuntu-latest
11 |
12 | name: Publish code coverage
13 |
14 | steps:
15 | - name: Checkout code
16 | uses: actions/checkout@v2
17 |
18 | - name: Setup PHP
19 | uses: shivammathur/setup-php@v2
20 | with:
21 | php-version: 8.1
22 | extensions: dom, curl, libxml, mbstring, zip, pcntl, bcmath, intl, iconv
23 | coverage: pcov
24 |
25 | - name: Setup Chrome Driver
26 | uses: nanasess/setup-chromedriver@v1
27 |
28 | - name: Start Chrome Driver
29 | run: |
30 | export DISPLAY=:99
31 | chromedriver --port=9515 &
32 | sudo Xvfb -ac :99 -screen 0 1280x1024x24 > /dev/null 2>&1 &
33 |
34 | - name: Cache dependencies
35 | uses: actions/cache@v2
36 | with:
37 | path: |
38 | vendor
39 | ${{ steps.composer-cache-files-dir.outputs.dir }}
40 | key: ${{ runner.os }}-composer-${{ hashFiles('composer.json') }}
41 | restore-keys: |
42 | ${{ runner.os }}-composer-
43 |
44 | - name: Install dependencies
45 | env:
46 | COMPOSER_DISCARD_CHANGES: true
47 | run: composer require --no-suggest --no-progress --no-interaction --prefer-dist --update-with-all-dependencies "laravel/framework:^9.0" "orchestra/testbench:^7.0"
48 |
49 | - name: Run and publish code coverage
50 | uses: paambaati/codeclimate-action@v2.4.0
51 | env:
52 | CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
53 | with:
54 | coverageCommand: vendor/bin/phpunit --coverage-clover ${{ github.workspace }}/clover.xml
55 | debug: true
56 | coverageLocations:
57 | "${{github.workspace}}/clover.xml:clover"
58 |
--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
1 | setUpRunsBrowserTests();
20 |
21 | View::getFinder()->addLocation(__DIR__.'/views');
22 |
23 | Route::get('/_dawn/alpine.js', fn() => response(file_get_contents(__DIR__.'/resources/alpine.js'), 200, ['Content-Type' => 'application/javascript']));
24 | Route::get('/_dawn/tailwind.css', fn() => response(file_get_contents(__DIR__.'/resources/tailwind.css'), 200, ['Content-Type' => 'text/css']));
25 |
26 | // This forces the testbench binary to load our service provider on the CLI
27 | file_put_contents(base_path('testbench.yaml'), "providers:\n - ".DawnServiceProvider::class);
28 |
29 | // This tricks the `testbench` CLI to have access to the correct autoloader
30 | $vendor_dir = dirname(base_path()).'/vendor';
31 | if (! file_exists($vendor_dir)) {
32 | symlink(dirname(__DIR__).'/vendor', $vendor_dir);
33 | }
34 | }
35 |
36 | protected function tearDown(): void
37 | {
38 | $this->tearDownRunsBrowserTests();
39 |
40 | // Clean up our custom yaml file
41 | if (file_exists(base_path('testbench.yaml'))) {
42 | unlink(base_path('testbench.yaml'));
43 | }
44 |
45 | parent::tearDown();
46 | }
47 |
48 | protected function getPackageProviders($app)
49 | {
50 | return [
51 | DawnServiceProvider::class,
52 | ];
53 | }
54 |
55 | protected function getPackageAliases($app)
56 | {
57 | return [];
58 | }
59 |
60 | protected function getApplicationTimezone($app)
61 | {
62 | return 'America/New_York';
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/src/Support/ProcessManager.php:
--------------------------------------------------------------------------------
1 | config !== $config) {
23 | static::$instance->stop();
24 | static::$instance = null;
25 | }
26 |
27 | return static::$instance ??= new static($config);
28 | }
29 |
30 | public static function clearInstance(): void
31 | {
32 | static::$instance = null;
33 |
34 | Container::getInstance()->forgetInstance(static::class);
35 | }
36 |
37 | public function __construct(
38 | public readonly array $config
39 | ) {
40 | $this->remote_web_driver = new RemoteWebDriverBroker(
41 | url: $this->config('dawn.browser_url', 'http://localhost:9515')
42 | );
43 |
44 | $this->web_server = new WebServerBroker(
45 | host: $this->config('dawn.server_host', '127.0.0.1'),
46 | port: $this->config('dawn.server_port') ?? $this->findOpenPort(),
47 | );
48 | }
49 |
50 | public function stop(): void
51 | {
52 | $this->web_server->stop();
53 | $this->remote_web_driver->stop();
54 | }
55 |
56 | protected function config(string $key, $default = null): mixed
57 | {
58 | return Arr::get($this->config, $key, $default);
59 | }
60 |
61 | protected function findOpenPort(): int
62 | {
63 | $sock = socket_create_listen(0);
64 |
65 | socket_getsockname($sock, $addr, $port);
66 | socket_close($sock);
67 |
68 | return $port;
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/src/Browser/Concerns/ExecutesMouseCommands.php:
--------------------------------------------------------------------------------
1 | command(new ClickAndHold($selector));
25 | }
26 |
27 | public function doubleClick(WebDriverBy|string|null $selector): static
28 | {
29 | return $this->command(new DoubleClick($selector));
30 | }
31 |
32 | public function dragAndDrop(WebDriverBy|string $from, WebDriverBy|string $to): static
33 | {
34 | return $this->command(new DragAndDrop($from, $to));
35 | }
36 |
37 | public function dragAndDropBy(WebDriverBy|string $selector, int $x = 0, int $y = 0): static
38 | {
39 | return $this->command(new DragAndDropBy($selector, $x, $y));
40 | }
41 |
42 | public function mouseOver(WebDriverBy|string $by): static
43 | {
44 | return $this->command(new MouseOver($by));
45 | }
46 |
47 | public function moveByOffset(int $x, int $y): static
48 | {
49 | return $this->command(new MoveByOffset($x, $y));
50 | }
51 |
52 | public function releaseMouse(): static
53 | {
54 | return $this->command(new ReleaseMouse());
55 | }
56 |
57 | public function rightClick(WebDriverBy|string|null $selector): static
58 | {
59 | return $this->command(new RightClick($selector));
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertAttribute.php:
--------------------------------------------------------------------------------
1 | resolver->findOrFail($this->selector);
29 |
30 | $this->actual = $element->getAttribute($this->attribute);
31 | }
32 |
33 | protected function performAssertions(RemoteWebDriverBroker $broker): void
34 | {
35 | $selector = $this->selector()->getValue();
36 |
37 | Assert::assertNotNull(
38 | $this->actual,
39 | "Did not see expected attribute [{$this->attribute}] within element [{$selector}]."
40 | );
41 |
42 | [$assertion, $message] = $this->getAssertion();
43 |
44 | $assertion($this->value, $this->actual, sprintf($message, $this->attribute, $this->value, $this->actual));
45 | }
46 |
47 | protected function getAssertion(): array
48 | {
49 | return match ([$this->not, $this->contains]) {
50 | [false, false] => [Assert::assertEquals(...), 'Expected \'%s\' attribute [%s] does not equal actual value [%s].'],
51 | [false, true] => [Assert::assertStringContainsString(...), 'Attribute \'%s\' does not contain [%s]. Full attribute value was [%s].'],
52 | [true, true] => [Assert::assertStringNotContainsString(...), 'Attribute \'%s\' should not contain [%s].'],
53 | [true, false] => [Assert::assertNotEquals(...), 'Attribute \'%s\' should not equal [%s].'],
54 | };
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Visit.php:
--------------------------------------------------------------------------------
1 | url = match (true) {
20 | Str::is('about:*', $url) => $url,
21 | default => url($url),
22 | };
23 |
24 | $this->rewriteUrlIfHandledByApplication();
25 | }
26 |
27 | protected function rewriteUrlIfHandledByApplication()
28 | {
29 | try {
30 | Route::getRoutes()->match(Request::create($this->url));
31 | } catch (NotFoundHttpException) {
32 | return;
33 | }
34 |
35 | // FIXME: Maybe include the original URL as the user parameter?
36 |
37 | $parts = array_merge(
38 | parse_url($this->url),
39 | parse_url(app(WebServerBroker::class)->url()),
40 | );
41 |
42 | $this->url = $this->rebuildUrl($parts);
43 | }
44 |
45 | protected function rebuildUrl(array $parts): string
46 | {
47 | $url = '';
48 | $keys = ['scheme', 'user', 'pass', 'host', 'port', 'path', 'query', 'fragment'];
49 |
50 | foreach ($keys as $key) {
51 | if (! $value = Arr::get($parts, $key)) {
52 | continue;
53 | }
54 |
55 | $url .= match ($key) {
56 | 'scheme' => "{$value}://",
57 | 'user' => $value,
58 | 'pass' => ":{$value}",
59 | 'host' => isset($parts['user'])
60 | ? "@{$value}"
61 | : $value,
62 | 'port' => 80 === (int) $value
63 | ? ''
64 | : ":{$value}",
65 | 'path' => $value,
66 | 'query' => "?{$value}",
67 | 'fragment' => "#{$value}",
68 | };
69 | }
70 |
71 | return $url;
72 | }
73 |
74 | protected function executeWithBrowser(BrowserManager $manager)
75 | {
76 | $manager->get($this->url);
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Assertions/AssertValue.php:
--------------------------------------------------------------------------------
1 | resolver->findOrFail($this->selector);
30 |
31 | if (! $this->elementSupportsValueAttribute($element)) {
32 | $this->is_supported = false;
33 | return;
34 | }
35 |
36 | $this->actual = $element->getAttribute('value');
37 | }
38 |
39 | protected function performAssertions(RemoteWebDriverBroker $broker): void
40 | {
41 | $selector = $this->selector()->getValue();
42 |
43 | [$assertion, $message] = $this->getAssertion();
44 |
45 | $assertion(
46 | expected: $this->value,
47 | actual: $this->actual,
48 | message: sprintf($message, $this->value, $selector)
49 | );
50 | }
51 |
52 | protected function getAssertion(): array
53 | {
54 | if ($this->not) {
55 | return [Assert::assertNotEquals(...), 'Saw unexpected value [%s] within element [%s].'];
56 | }
57 |
58 | return [Assert::assertEquals(...), 'Did not see expected value [%s] within element [%s].'];
59 | }
60 |
61 | protected function elementSupportsValueAttribute(RemoteWebElement $element): bool
62 | {
63 | return in_array($element->getTagName(), [
64 | 'textarea',
65 | 'select',
66 | 'button',
67 | 'input',
68 | 'li',
69 | 'meter',
70 | 'option',
71 | 'param',
72 | 'progress',
73 | ]);
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/src/Browser/Commands/Elements/SendKeys.php:
--------------------------------------------------------------------------------
1 | keys)) {
25 | $this->sendKeysDirectly($manager);
26 | return;
27 | }
28 |
29 | $element = $manager->resolver->resolveForTyping($this->selector);
30 |
31 | if ($this->clear_input) {
32 | $element->clear();
33 | }
34 |
35 | if ($this->pause > 0) {
36 | $this->sendKeysWithDelay($element);
37 | return;
38 | }
39 |
40 | $element->sendKeys($this->keys);
41 | }
42 |
43 | protected function sendKeysDirectly(BrowserManager $manager)
44 | {
45 | $manager->resolver->findOrFail($this->selector)
46 | ->sendKeys($this->parseKeys($this->keys));
47 | }
48 |
49 | protected function sendKeysWithDelay(RemoteWebElement $element)
50 | {
51 | foreach (preg_split('//u', $this->keys, -1, PREG_SPLIT_NO_EMPTY) as $key) {
52 | $element->sendKeys($key);
53 | usleep($this->pause * 1000);
54 | }
55 | }
56 |
57 | protected function parseKeys(array $keys): array
58 | {
59 | return collect($keys)
60 | ->map(function($key) {
61 | if (is_string($key) && Str::startsWith($key, '{') && Str::endsWith($key, '}')) {
62 | $key = constant(WebDriverKeys::class.'::'.strtoupper(trim($key, '{}')));
63 | }
64 |
65 | if (is_array($key) && Str::startsWith($key[0], '{')) {
66 | $key[0] = constant(WebDriverKeys::class.'::'.strtoupper(trim($key[0], '{}')));
67 | }
68 |
69 | return $key;
70 | })
71 | ->all();
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/.idea/watcherTasks.xml:
--------------------------------------------------------------------------------
1 |
2 |
9 |
12 |
13 |
16 |
17 |
23 |
24 |
29 |
30 |
33 |
34 |
39 |
40 |
45 |
46 |
49 |
50 | 
7 | 
31 | -
132 |
- I get an error like `Failed to connect to localhost port 9515 after 2 ms: Couldn't connect to server` 133 |
- Make sure you have both `chromedriver` and the same version of Google Chrome installed. 134 |
-
139 |
- Does it work on anything other that Chris's Mac? 140 |
- 🤷♂️ 141 |
- Will it ever work on Windows? 142 |
- 🤷♂️ Probably? 143 |
- When can I use this? 144 |
- Fortune favors the brave. 145 |
- Is this the final API? 146 |
- Most of the `RunsBrowserTests` is pretty solid. The underlying implementation may change a ton before 1.0. 147 |