PerformanceContext::getSelfHostedPageResources() - Code Metrics - Inspection of "Bump PHP version and improve static checks" - marcortola/behat-seo-contexts - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( afef6b...b42680 )

by Marc

created 2019-08-18 16:57 UTC

PerformanceContext::getSelfHostedPageResources() A

↳ Parent: PerformanceContext

Complexity

Conditions	3
Paths	3

Size

Total Lines	17
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	9
nc	3
nop	1
dl	0
loc	17
rs	9.9666
c	0
b	0
f	0

<?php declare(strict_types=1);

namespace MOrtola\BehatSEOContexts\Context;

use Behat\Mink\Element\NodeElement;
use Behat\Mink\Exception\UnsupportedDriverActionException;
use Behat\Symfony2Extension\Driver\KernelDriver;
use Exception;
use InvalidArgumentException;
use PHPUnit\Framework\Assert;

class PerformanceContext extends BaseContext
{
    const RES_EXT = [
        'PNG'             => 'png',
        'HTML'            => 'html',
        'JPEG'            => 'jpeg',
        'GIF'             => 'gif',
        'ICO'             => 'ico',
        'JAVASCRIPT'      => 'js',
        'CSS'             => 'css',
        'CSS_INLINE_HEAD' => 'css-inline-head',
        'CSS_LINK_HEAD'   => 'css-link-head',
    ];

    /**
     * @throws Exception
     *
     * @Then /^Javascript code should load (async|defer)$/
     */
    public function javascriptFilesShouldLoadAsync(): void
    {
        foreach ($this->getSelfHostedPageResources(self::RES_EXT['JAVASCRIPT']) as $scriptElement) {
            Assert::assertTrue(
                $scriptElement->hasAttribute('async') || $scriptElement->hasAttribute('defer'),
                sprintf(
                    'Javascript file %s is render blocking in %s',
                    $this->getResourceUrl($scriptElement, self::RES_EXT['JAVASCRIPT']),
                    $this->getCurrentUrl()
                )
            );
        }
    }

    /**
     * @return NodeElement[]
     */
    private function getPageResources(string $resourceType, string $host = null): array
    {
        if (!$xpath = $this->getResourceXpath($resourceType)) {
            return [];
        }

        if ('external' === $host) {
            $xpath = preg_replace(
                '/\[contains\(@(.*),/',
                '[not(starts-with(@$1,"'.$this->webUrl.'") or starts-with(@$1,"/")) and contains(@$1,',
                $xpath
            );
        } elseif (null !== $host) {
            $xpath = preg_replace(
                '/\[contains\(@(.*),/',
                '[(starts-with(@$1,"'.$host.'") or starts-with(@$1,"/")) and contains(@$1,',
                $xpath
            );
        }

        if ($xpath) {
            return $this->getSession()->getPage()->findAll('xpath', $xpath);
        }

        return [];
    }

    /**
     * @return NodeElement[]
     */
    private function getSelfHostedPageResources(string $resourceType): array
    {
        if (!$xpath = $this->getResourceXpath($resourceType)) {
            return [];
        }

        $xpath = preg_replace(
            '/\[contains\(@(.*),/',
            sprintf('[(starts-with(@$1,"%s") or starts-with(@$1,"/")) and contains(@$1,', $this->webUrl),
            $xpath
        );

        if ($xpath) {
            return $this->getSession()->getPage()->findAll('xpath', $xpath);
        }

        return [];
    }

    private function getResourceXpath(string $resourceType): string
    {
        if (in_array($resourceType, [self::RES_EXT['JPEG'], self::RES_EXT['PNG'], self::RES_EXT['GIF']], true)) {
            return sprintf('//img[contains(@src,".%s")]', $resourceType);
        }
        if (in_array($resourceType, [self::RES_EXT['ICO'], self::RES_EXT['CSS']], true)) {
            return sprintf('//link[contains(@href,".%s")]', $resourceType);
        }
        if (self::RES_EXT['JAVASCRIPT'] === $resourceType) {
            return '//script[contains(@src,".js")]';
        }
        if (self::RES_EXT['CSS_INLINE_HEAD'] === $resourceType) {
            return '//head//style';
        }
        if (self::RES_EXT['CSS_LINK_HEAD'] === $resourceType) {
            return '//head//link[contains(@href,".css")]';
        }

        return '';
    }

    /**
     * @throws Exception
     */
    private function getResourceUrl(NodeElement $element, string $resourceType): ?string
    {
        $this->assertResourceTypeIsValid($resourceType);

        if (in_array(
            $resourceType,
            [self::RES_EXT['PNG'], self::RES_EXT['JPEG'], self::RES_EXT['GIF'], self::RES_EXT['JAVASCRIPT']],
            true
        )) {
            return $element->getAttribute('src');
        }

        if (in_array($resourceType, [self::RES_EXT['CSS'], self::RES_EXT['ICO']], true)) {
            return $element->getAttribute('href');
        }

        throw new InvalidArgumentException(
            sprintf('%s resource type url is not implemented', $resourceType)
        );
    }

    private function assertResourceTypeIsValid(string $resourceType): void
    {
        if (!in_array($resourceType, self::RES_EXT, true)) {
            throw new InvalidArgumentException(
                sprintf(
                    '%s resource type is not valid. Allowed types are: %s',
                    $resourceType,
                    implode(',', self::RES_EXT)
                )
            );
        }
    }

    /**
     * @throws Exception
     *
     * @Then HTML code should be minified
     */
    public function htmlShouldBeMinified(): void
    {
        $this->assertContentIsMinified(
            $this->getSession()->getPage()->getContent(),
            $this->minimizeHtml($this->getSession()->getPage()->getContent())
        );
    }

    private function assertContentIsMinified(string $content, string $contentMinified): void
    {
        Assert::assertSame(
            $content,
            $contentMinified,
            'Code is not minified.'
        );
    }

    private function minimizeHtml(string $html): string
    {
        return preg_replace('/(?<=>)\s+|\s+(?=<)/', '', $html) ?? $html;
    }

    /**
     * @throws Exception
     *
     * @Then CSS code should load deferred
     */
    public function cssFilesShouldLoadDeferred(): void
    {
        Assert::assertEmpty(
            $this->getSelfHostedPageResources(self::RES_EXT['CSS_LINK_HEAD']),
            sprintf(
                'Some self hosted css files are loading in head in %s',
                $this->getCurrentUrl()
            )
        );
    }

    /**
     * @throws Exception
     *
     * @Then critical CSS code should exist in head
     */
    public function criticalCssShouldExistInHead(): void
    {
        Assert::assertNotEmpty(
            $this->getSelfHostedPageResources(self::RES_EXT['CSS_INLINE_HEAD']),
            sprintf(
                'No inline css is loading in head in %s',
                $this->getCurrentUrl()
            )
        );
    }

    /**
     * @Then HTML code should not be minified
     */
    public function htmlShouldNotBeMinified(): void
    {
        $this->assertInverse(
            [$this, 'htmlShouldBeMinified'],
            'HTML should not be minified.'
        );
    }

    /**
     * @Then /^(CSS|Javascript) code should not be minified$/
     */
    public function cssOrJavascriptFilesShouldNotBeMinified(string $resourceType): void
    {
        $this->assertInverse(
            function () use ($resourceType) {
                $this->cssOrJavascriptFilesShouldBeMinified($resourceType);
            },
            sprintf('%s should not be minified.', $resourceType)
        );
    }

    /**
     * @throws UnsupportedDriverActionException
     * @throws Exception
     * @Then /^(CSS|Javascript) code should be minified$/
     */
    public function cssOrJavascriptFilesShouldBeMinified(string $resourceType): void
    {
        $this->doesNotSupportDriver(KernelDriver::class);

        $resourceType = 'Javascript' === $resourceType ? 'js' : 'css';

        foreach ($this->getSelfHostedPageResources($resourceType) as $element) {
            if ($url = $this->getResourceUrl($element, $resourceType)) {
                $this->getSession()->visit($url);
            }

            $this->assertContentIsMinified(
                $this->getSession()->getPage()->getContent(),
                'js' === $resourceType ?
                    $this->minimizeJs($this->getSession()->getPage()->getContent())
                    : $this->minimizeCss($this->getSession()->getPage()->getContent())
            );

            $this->getSession()->back();
        }
    }

    private function minimizeJs(string $javascript): string
    {
        return preg_replace(
            [
                       '#\s*("(?:[^"\\\]++|\\\.)*+"|\'(?:[^\'\\\\]++|\\\.)*+\')\s*|\s*\/\*(?!\!|@cc_on)(?>[\s\S]*?\*\/)\s*|
                \s*(?<![\:\=])\/\/.*(?=[\n\r]|$)|^\s*|\s*$#',
                       '#("(?:[^"\\\]++|\\\.)*+"|\'(?:[^\'\\\\]++|\\\.)*+\'|\/\*(?>.*?\*\/)|\/(?!\/)[^\n\r]*?\/(?=[\s.,;]|
                [gimuy]|$))|\s*([!%&*\(\)\-=+\[\]\{\}|;:,.<>?\/])\s*#s',
                   ],
            ['$1', '$1$2'],
            $javascript
        ) ?? $javascript;
    }

    private function minimizeCss(string $css): string
    {
        return preg_replace(
            [
                       '#("(?:[^"\\\]++|\\\.)*+"|\'(?:[^\'\\\\]++|\\\.)*+\')|\/\*(?!\!)(?>.*?\*\/)|^\s*|\s*$#s',
                       '#("(?:[^"\\\]++|\\\.)*+"|\'(?:[^\'\\\\]++|\\\.)*+\'|\/\*(?>.*?\*\/))|\s*+;\s*+(})\s*+|\s*+([*$~^|
                ]?+=|[{};,>~+]|\s*+-(?![0-9\.])|!important\b)\s*+|([[(:])\s++|\s++([])])|\s++(:)\s*+(?!(?>[^{}"\']++|
                "(?:[^"\\\]++|\\\.)*+"|\'(?:[^\'\\\\]++|\\\.)*+\')*+{)|^\s++|\s++\z|(\s)\s+#si',
                   ],
            ['$1', '$1$2$3$4$5$6$7'],
            $css
        ) ?? $css;
    }

    /**
     * @Then critical CSS code should not exist in head
     */
    public function criticalCssShouldNotExistInHead(): void
    {
        $this->assertInverse(
            [$this, 'criticalCssShouldExistInHead'],
            'Critical CSS exist in head.'
        );
    }

    /**
     * @Then /^browser cache should not be enabled for (.+|external|internal) (png|jpeg|gif|ico|js|css) resources$/
     */
    public function browserCacheMustNotBeEnabledForResources(string $host, string $resourceType): void
    {
        $this->assertInverse(
            function () use ($host, $resourceType) {
                $this->browserCacheMustBeEnabledForResources($host, $resourceType);
            },
            sprintf('Browser cache is enabled for %s resources.', $resourceType)
        );
    }

    /**
     * @throws UnsupportedDriverActionException
     * @throws Exception
     * @Then /^browser cache should be enabled for (.+|external|internal) (png|jpeg|gif|ico|js|css) resources$/
     */
    public function browserCacheMustBeEnabledForResources(string $host, string $resourceType): void
    {
        $this->doesNotSupportDriver(KernelDriver::class);

        switch ($host) {
            case 'internal':
                $elements = $this->getSelfHostedPageResources($resourceType);
                break;
            default:
                $elements = $this->getPageResources($resourceType, $host);
                break;
        }

        Assert::assertNotEmpty(
            $elements,
            sprintf(
                'The are not %s resources in %s.',
                $host,
                $this->getCurrentUrl()
            )
        );

        $this->checkResourceCache(
            $elements[array_rand($elements)],
            $resourceType
        );
    }

    /**
     * @throws Exception
     */
    private function checkResourceCache(NodeElement $element, string $resourceType): void
    {
        if ($url = $this->getResourceUrl($element, $resourceType)) {
            $this->getSession()->visit($url);
        }

        $headers = array_change_key_case($this->getSession()->getResponseHeaders());
        $this->getSession()->back();

        Assert::assertTrue(
            array_key_exists('cache-control', $headers),
            sprintf(
                'Browser cache is not enabled for %s resources. Cache-Control HTTP header was not received.',
                $resourceType
            )
        );

        Assert::assertNotContains(
            'no-cache',
            $headers['cache-control'],
            sprintf(
                'Browser cache is not enabled for %s resources. Cache-Control HTTP header is "no-cache".',
                $resourceType
            )
        );

        Assert::assertNotContains(
            'max-age=0',
            $headers['cache-control'],
            sprintf(
                'Browser cache is not enabled for %s resources. Cache-Control HTTP header is "max-age=0".',
                $resourceType
            )
        );
    }

    /**
     * @Then /^Javascript code should not load (async|defer)$/
     */
    public function jsShouldNotLoadAsyncOr(): void
    {
        $this->assertInverse(
            [$this, 'javascriptFilesShouldLoadAsync'],
            'All JS files load async.'
        );
    }
}


1			<?php declare(strict_types=1);
2
3			namespace MOrtola\BehatSEOContexts\Context;
4
5			use Behat\Mink\Element\NodeElement;
6			use Behat\Mink\Exception\UnsupportedDriverActionException;
7			use Behat\Symfony2Extension\Driver\KernelDriver;
8			use Exception;
9			use InvalidArgumentException;
10			use PHPUnit\Framework\Assert;
11
12			class PerformanceContext extends BaseContext
13			{
14			const RES_EXT = [
15			'PNG' => 'png',
16			'HTML' => 'html',
17			'JPEG' => 'jpeg',
18			'GIF' => 'gif',
19			'ICO' => 'ico',
20			'JAVASCRIPT' => 'js',
21			'CSS' => 'css',
22			'CSS_INLINE_HEAD' => 'css-inline-head',
23			'CSS_LINK_HEAD' => 'css-link-head',
24			];
25
26			/**
27			* @throws Exception
28			*
29			* @Then /^Javascript code should load (async\|defer)$/
30			*/
31			public function javascriptFilesShouldLoadAsync(): void
32			{
33			foreach ($this->getSelfHostedPageResources(self::RES_EXT['JAVASCRIPT']) as $scriptElement) {
34			Assert::assertTrue(
35			$scriptElement->hasAttribute('async') \|\| $scriptElement->hasAttribute('defer'),
36			sprintf(
37			'Javascript file %s is render blocking in %s',
38			$this->getResourceUrl($scriptElement, self::RES_EXT['JAVASCRIPT']),
39			$this->getCurrentUrl()
40			)
41			);
42			}
43			}
44
45			/**
46			* @return NodeElement[]
47			*/
48			private function getPageResources(string $resourceType, string $host = null): array
49			{
50			if (!$xpath = $this->getResourceXpath($resourceType)) {
51			return [];
52			}
53
54			if ('external' === $host) {
55			$xpath = preg_replace(
56			'/\[contains\(@(.*),/',
57			'[not(starts-with(@$1,"'.$this->webUrl.'") or starts-with(@$1,"/")) and contains(@$1,',
58			$xpath
59			);
60			} elseif (null !== $host) {
61			$xpath = preg_replace(
62			'/\[contains\(@(.*),/',
63			'[(starts-with(@$1,"'.$host.'") or starts-with(@$1,"/")) and contains(@$1,',
64			$xpath
65			);
66			}
67
68			if ($xpath) {
69			return $this->getSession()->getPage()->findAll('xpath', $xpath);
70			}
71
72			return [];
73			}
74
75			/**
76			* @return NodeElement[]
77			*/
78			private function getSelfHostedPageResources(string $resourceType): array
79			{
80			if (!$xpath = $this->getResourceXpath($resourceType)) {
81			return [];
82			}
83
84			$xpath = preg_replace(
85			'/\[contains\(@(.*),/',
86			sprintf('[(starts-with(@$1,"%s") or starts-with(@$1,"/")) and contains(@$1,', $this->webUrl),
87			$xpath
88			);
89
90			if ($xpath) {
91			return $this->getSession()->getPage()->findAll('xpath', $xpath);
92			}
93
94			return [];
95			}
96
97			private function getResourceXpath(string $resourceType): string
98			{
99			if (in_array($resourceType, [self::RES_EXT['JPEG'], self::RES_EXT['PNG'], self::RES_EXT['GIF']], true)) {
100			return sprintf('//img[contains(@src,".%s")]', $resourceType);
101			}
102			if (in_array($resourceType, [self::RES_EXT['ICO'], self::RES_EXT['CSS']], true)) {
103			return sprintf('//link[contains(@href,".%s")]', $resourceType);
104			}
105			if (self::RES_EXT['JAVASCRIPT'] === $resourceType) {
106			return '//script[contains(@src,".js")]';
107			}
108			if (self::RES_EXT['CSS_INLINE_HEAD'] === $resourceType) {
109			return '//head//style';
110			}
111			if (self::RES_EXT['CSS_LINK_HEAD'] === $resourceType) {
112			return '//head//link[contains(@href,".css")]';
113			}
114
115			return '';
116			}
117
118			/**
119			* @throws Exception
120			*/
121			private function getResourceUrl(NodeElement $element, string $resourceType): ?string
122			{
123			$this->assertResourceTypeIsValid($resourceType);
124
125			if (in_array(
126			$resourceType,
127			[self::RES_EXT['PNG'], self::RES_EXT['JPEG'], self::RES_EXT['GIF'], self::RES_EXT['JAVASCRIPT']],
128			true
129			)) {
130			return $element->getAttribute('src');
131			}
132
133			if (in_array($resourceType, [self::RES_EXT['CSS'], self::RES_EXT['ICO']], true)) {
134			return $element->getAttribute('href');
135			}
136
137			throw new InvalidArgumentException(
138			sprintf('%s resource type url is not implemented', $resourceType)
139			);
140			}
141
142			private function assertResourceTypeIsValid(string $resourceType): void
143			{
144			if (!in_array($resourceType, self::RES_EXT, true)) {
145			throw new InvalidArgumentException(
146			sprintf(
147			'%s resource type is not valid. Allowed types are: %s',
148			$resourceType,
149			implode(',', self::RES_EXT)
150			)
151			);
152			}
153			}
154
155			/**
156			* @throws Exception
157			*
158			* @Then HTML code should be minified
159			*/
160			public function htmlShouldBeMinified(): void
161			{
162			$this->assertContentIsMinified(
163			$this->getSession()->getPage()->getContent(),
164			$this->minimizeHtml($this->getSession()->getPage()->getContent())
165			);
166			}
167
168			private function assertContentIsMinified(string $content, string $contentMinified): void
169			{
170			Assert::assertSame(
171			$content,
172			$contentMinified,
173			'Code is not minified.'
174			);
175			}
176
177			private function minimizeHtml(string $html): string
178			{
179			return preg_replace('/(?<=>)\s+\|\s+(?=<)/', '', $html) ?? $html;
180			}
181
182			/**
183			* @throws Exception
184			*
185			* @Then CSS code should load deferred
186			*/
187			public function cssFilesShouldLoadDeferred(): void
188			{
189			Assert::assertEmpty(
190			$this->getSelfHostedPageResources(self::RES_EXT['CSS_LINK_HEAD']),
191			sprintf(
192			'Some self hosted css files are loading in head in %s',
193			$this->getCurrentUrl()
194			)
195			);
196			}
197
198			/**
199			* @throws Exception
200			*
201			* @Then critical CSS code should exist in head
202			*/
203			public function criticalCssShouldExistInHead(): void
204			{
205			Assert::assertNotEmpty(
206			$this->getSelfHostedPageResources(self::RES_EXT['CSS_INLINE_HEAD']),
207			sprintf(
208			'No inline css is loading in head in %s',
209			$this->getCurrentUrl()
210			)
211			);
212			}
213
214			/**
215			* @Then HTML code should not be minified
216			*/
217			public function htmlShouldNotBeMinified(): void
218			{
219			$this->assertInverse(
220			[$this, 'htmlShouldBeMinified'],
221			'HTML should not be minified.'
222			);
223			}
224
225			/**
226			* @Then /^(CSS\|Javascript) code should not be minified$/
227			*/
228			public function cssOrJavascriptFilesShouldNotBeMinified(string $resourceType): void
229			{
230			$this->assertInverse(
231			function () use ($resourceType) {
232			$this->cssOrJavascriptFilesShouldBeMinified($resourceType);
233			},
234			sprintf('%s should not be minified.', $resourceType)
235			);
236			}
237
238			/**
239			* @throws UnsupportedDriverActionException
240			* @throws Exception
241			* @Then /^(CSS\|Javascript) code should be minified$/
242			*/
243			public function cssOrJavascriptFilesShouldBeMinified(string $resourceType): void
244			{
245			$this->doesNotSupportDriver(KernelDriver::class);
246
247			$resourceType = 'Javascript' === $resourceType ? 'js' : 'css';
248
249			foreach ($this->getSelfHostedPageResources($resourceType) as $element) {
250			if ($url = $this->getResourceUrl($element, $resourceType)) {
251			$this->getSession()->visit($url);
252			}
253
254			$this->assertContentIsMinified(
255			$this->getSession()->getPage()->getContent(),
256			'js' === $resourceType ?
257			$this->minimizeJs($this->getSession()->getPage()->getContent())
258			: $this->minimizeCss($this->getSession()->getPage()->getContent())
259			);
260
261			$this->getSession()->back();
262			}
263			}
264
265			private function minimizeJs(string $javascript): string
266			{
267			return preg_replace(
268			[
269			'#\s("(?:[^"\\\]++\|\\\.)+"\|\'(?:[^\'\\\\]++\|\\\.)+\')\s\|\s\/\(?!\!\|@cc_on)(?>[\s\S]?\\/)\s*\|
270			\s(?<![\:\=])\/\/.(?=[\n\r]\|$)\|^\s\|\s$#',
271			'#("(?:[^"\\\]++\|\\\.)+"\|\'(?:[^\'\\\\]++\|\\\.)+\'\|\/\(?>.?\\/)\|\/(?!\/)[^\n\r]?\/(?=[\s.,;]\|
272			[gimuy]\|$))\|\s([!%&\(\)\-=+\[\]\{\}\|;:,.<>?\/])\s*#s',
273			],
274			['$1', '$1$2'],
275			$javascript
276			) ?? $javascript;
277			}
278
279			private function minimizeCss(string $css): string
280			{
281			return preg_replace(
282			[
283			'#("(?:[^"\\\]++\|\\\.)+"\|\'(?:[^\'\\\\]++\|\\\.)+\')\|\/\(?!\!)(?>.?\\/)\|^\s\|\s*$#s',
284			'#("(?:[^"\\\]++\|\\\.)+"\|\'(?:[^\'\\\\]++\|\\\.)+\'\|\/\(?>.?\\/))\|\s+;\s+(})\s+\|\s+([$~^\|
285			]?+=\|[{};,>~+]\|\s+-(?![0-9\.])\|!important\b)\s+\|([[(:])\s++\|\s++([])])\|\s++(:)\s*+(?!(?>[^{}"\']++\|
286			"(?:[^"\\\]++\|\\\.)+"\|\'(?:[^\'\\\\]++\|\\\.)+\')*+{)\|^\s++\|\s++\z\|(\s)\s+#si',
287			],
288			['$1', '$1$2$3$4$5$6$7'],
289			$css
290			) ?? $css;
291			}
292
293			/**
294			* @Then critical CSS code should not exist in head
295			*/
296			public function criticalCssShouldNotExistInHead(): void
297			{
298			$this->assertInverse(
299			[$this, 'criticalCssShouldExistInHead'],
300			'Critical CSS exist in head.'
301			);
302			}
303
304			/**
305			* @Then /^browser cache should not be enabled for (.+\|external\|internal) (png\|jpeg\|gif\|ico\|js\|css) resources$/
306			*/
307			public function browserCacheMustNotBeEnabledForResources(string $host, string $resourceType): void
308			{
309			$this->assertInverse(
310			function () use ($host, $resourceType) {
311			$this->browserCacheMustBeEnabledForResources($host, $resourceType);
312			},
313			sprintf('Browser cache is enabled for %s resources.', $resourceType)
314			);
315			}
316
317			/**
318			* @throws UnsupportedDriverActionException
319			* @throws Exception
320			* @Then /^browser cache should be enabled for (.+\|external\|internal) (png\|jpeg\|gif\|ico\|js\|css) resources$/
321			*/
322			public function browserCacheMustBeEnabledForResources(string $host, string $resourceType): void
323			{
324			$this->doesNotSupportDriver(KernelDriver::class);
325
326			switch ($host) {
327			case 'internal':
328			$elements = $this->getSelfHostedPageResources($resourceType);
329			break;
330			default:
331			$elements = $this->getPageResources($resourceType, $host);
332			break;
333			}
334
335			Assert::assertNotEmpty(
336			$elements,
337			sprintf(
338			'The are not %s resources in %s.',
339			$host,
340			$this->getCurrentUrl()
341			)
342			);
343
344			$this->checkResourceCache(
345			$elements[array_rand($elements)],
346			$resourceType
347			);
348			}
349
350			/**
351			* @throws Exception
352			*/
353			private function checkResourceCache(NodeElement $element, string $resourceType): void
354			{
355			if ($url = $this->getResourceUrl($element, $resourceType)) {
356			$this->getSession()->visit($url);
357			}
358
359			$headers = array_change_key_case($this->getSession()->getResponseHeaders());
360			$this->getSession()->back();
361
362			Assert::assertTrue(
363			array_key_exists('cache-control', $headers),
364			sprintf(
365			'Browser cache is not enabled for %s resources. Cache-Control HTTP header was not received.',
366			$resourceType
367			)
368			);
369
370			Assert::assertNotContains(
371			'no-cache',
372			$headers['cache-control'],
373			sprintf(
374			'Browser cache is not enabled for %s resources. Cache-Control HTTP header is "no-cache".',
375			$resourceType
376			)
377			);
378
379			Assert::assertNotContains(
380			'max-age=0',
381			$headers['cache-control'],
382			sprintf(
383			'Browser cache is not enabled for %s resources. Cache-Control HTTP header is "max-age=0".',
384			$resourceType
385			)
386			);
387			}
388
389			/**
390			* @Then /^Javascript code should not load (async\|defer)$/
391			*/
392			public function jsShouldNotLoadAsyncOr(): void
393			{
394			$this->assertInverse(
395			[$this, 'javascriptFilesShouldLoadAsync'],
396			'All JS files load async.'
397			);
398			}
399			}
400

marcortola / behat-seo-contexts

Push — master ( afef6b...b42680 )

PerformanceContext::getSelfHostedPageResources() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like