BrowserKitBrowserTests::response_multi_header_assertions() - Code Metrics - Inspection of "Remove mink" - zenstruck/browser - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — 1.x (#62)

by Kevin
created 2021-10-13 17:08 UTC
response_multi_header_assertions() A

↳ Parent: BrowserKitBrowserTests
Complexity

Conditions	1
Paths	1
Size

Total Lines	13
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	11
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	13
rs	9.9
<?php

namespace Zenstruck\Browser\Tests;

use Zenstruck\Browser\HttpOptions;
use Zenstruck\Browser\Response;
use Zenstruck\Browser\Tests\Fixture\CustomHttpOptions;

/**
 * @author Kevin Bond <[email protected]>
 */
trait BrowserKitBrowserTests
{
    use BrowserTests;

    /**
     * @test
     */
    public function following_redirect_follows_all_by_default(): void
    {
        $this->browser()
            ->interceptRedirects()
            ->/** @scrutinizer ignore-call */ interceptRedirects()
            ->visit('/redirect1')
            ->assertOn('/redirect1')
            ->followRedirect()
            ->assertOn('/page1')
            ->assertSuccessful()
        ;
    }

    /**
     * @test
     */
    public function can_re_enable_following_redirects(): void
    {
        $this->browser()
            ->interceptRedirects()
            ->visit('/redirect1')
            ->assertOn('/redirect1')
            ->followRedirects()
            ->visit('/redirect1')
            ->assertOn('/page1')
        ;
    }

    /**
     * @test
     */
    public function calling_follow_redirects_when_the_response_is_a_redirect_follows_the_redirect(): void
    {
        $this->browser()
            ->interceptRedirects()
            ->visit('/redirect1')
            ->followRedirects()
            ->assertOn('/page1')
            ->interceptRedirects()
            ->visit('/page1')
            ->followRedirects()
            ->assertOn('/page1')
        ;
    }

    /**
     * @test
     */
    public function calling_follow_redirects_before_a_request_has_been_made_just_enables_following_redirects(): void
    {
        $this->browser()
            ->followRedirects()
            ->/** @scrutinizer ignore-call */ followRedirects()
            ->visit('/redirect1')
            ->assertOn('/page1')
        ;
    }

    /**
     * @test
     */
    public function can_limit_redirects_followed(): void
    {
        $this->browser()
            ->interceptRedirects()
            ->visit('/redirect1')
            ->assertOn('/redirect1')
            ->assertRedirected()
            ->followRedirect(1)
            ->assertOn('/redirect2')
            ->assertRedirected()
            ->followRedirect(1)
            ->assertOn('/redirect3')
            ->assertRedirected()
            ->followRedirect(1)
            ->assertOn('/page1')
            ->assertSuccessful()
        ;
    }

    /**
     * @test
     */
    public function assert_redirected_to_follows_all_redirects_by_default(): void
    {
        $this->browser()
            ->interceptRedirects()
            ->visit('/redirect1')
            ->assertRedirectedTo('/page1')
        ;
    }

    /**
     * @test
     */
    public function assert_redirected_to_can_configure_number_of_redirects_to_follow(): void
    {
        $this->browser()
            ->interceptRedirects()
            ->visit('/redirect1')
            ->assertRedirectedTo('/redirect2', 1)
        ;
    }

    /**
     * @test
     */
    public function exception_thrown_if_asserting_redirected_and_not_intercepting_redirects(): void
    {
        $this->expectException(\RuntimeException::class);
               expectException(\RuntimeException::class);
        $this->expectExceptionMessage('Cannot assert redirected if not intercepting redirects. Call ->interceptRedirects() before making the request.');
               expectExceptionMessage('Cannot assert redirected if not intercepting redirects. Call ->interceptRedirects() before making the request.');

        $this->browser()
            ->visit('/redirect1')
            ->assertRedirected()
            ->/** @scrutinizer ignore-call */ assertRedirected()
        ;
    }

    /**
     * @test
     */
    public function exception_thrown_if_asserting_redirected_to_and_not_intercepting_redirects(): void
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('Cannot assert redirected if not intercepting redirects. Call ->interceptRedirects() before making the request.');

        $this->browser()
            ->visit('/redirect1')
            ->assertRedirectedTo('/page1')
            ->/** @scrutinizer ignore-call */ assertRedirectedTo('/page1')
        ;
    }

    /**
     * @test
     */
    public function exceptions_are_caught_by_default(): void
    {
        $this->browser()
            ->visit('/exception')
            ->assertStatus(500)
            ->/** @scrutinizer ignore-call */ assertStatus(500)
        ;
    }

    /**
     * @test
     */
    public function response_header_assertions(): void
    {
        $this->browser()
            ->visit('/page1')
            ->assertHeaderEquals('Content-Type', 'text/html; charset=UTF-8')
            ->/** @scrutinizer ignore-call */ assertHeaderEquals('Content-Type', 'text/html; charset=UTF-8')
            ->assertHeaderContains('Content-Type', 'text/html')
        ;
    }

    /**
     * @test
     */
    public function response_multi_header_assertions(): void
    {
        $this->browser()
            ->visit('/multi-headers')
            ->assertSuccessful()
            ->/** @scrutinizer ignore-call */ assertSuccessful()
            ->assertHeaderEquals('X-FOO', 'bar 1')
            ->assertHeaderEquals('x-foo', 'bar 1')
            ->assertHeaderEquals('x-foo', 'bar 2')
            ->assertHeaderContains('x-foo', '1')
            ->assertHeaderContains('x-foo', '2')
            ->use(function(Response $response) {
                $this->assertStringContainsString('X-Foo:         bar 1', $response->raw());
                       assertStringContainsString('X-Foo:         bar 1', $response->raw());
                $this->assertStringContainsString('X-Foo:         bar 1', $response->raw());
            })
        ;
    }

    /**
     * @test
     */
    public function http_method_actions(): void
    {
        $this->browser()
            ->get('/http-method')
            ->/** @scrutinizer ignore-call */ get('/http-method')
            ->assertSuccessful()
            ->assertContains('"method":"GET"')
            ->post('/http-method')
            ->assertSuccessful()
            ->assertContains('"method":"POST"')
            ->delete('/http-method')
            ->assertSuccessful()
            ->assertContains('"method":"DELETE"')
            ->put('/http-method')
            ->assertSuccessful()
            ->assertContains('"method":"PUT"')
            ->assertContains('"ajax":false')
            ->post('/http-method', [
                'json' => ['foo' => 'bar'],
                'headers' => ['X-Foo' => 'Bar'],
                'ajax' => true,
            ])
            ->assertContains('"content-type":["application\/json"]')
            ->assertContains('"x-foo":["Bar"]')
            ->assertContains('"content":"{\u0022foo\u0022:\u0022bar\u0022}"')
            ->assertContains('"ajax":true')
            ->post('/http-method', HttpOptions::jsonAjax(['foo' => 'bar'])->withHeader('X-Foo', 'Bar'))
            ->assertContains('"content-type":["application\/json"]')
            ->assertContains('"x-foo":["Bar"]')
            ->assertContains('"content":"{\u0022foo\u0022:\u0022bar\u0022}"')
            ->assertContains('"ajax":true')
            ->post('/http-method', CustomHttpOptions::api('my-token'))
            ->assertContains('"content-type":["application\/json"]')
            ->assertContains('"x-token":["my-token"]')
            ->post('/http-method', HttpOptions::json()->withHeader('content-type', 'application/ld+json'))
            ->assertContains('"content-type":["application\/ld+json"]')
            ->post('/http-method?q1=qv1')
            ->assertContains('"query":{"q1":"qv1"}')
            ->post('/http-method', ['query' => ['q1' => 'qv1']])
            ->assertContains('"query":{"q1":"qv1"}')
            ->post('/http-method?q1=qv1', ['query' => ['q2' => 'qv2']])
            ->assertContains('"query":{"q1":"qv1","q2":"qv2"}')
            ->post('/http-method', ['body' => ['b1' => 'bv1']])
            ->assertContains('"request":{"b1":"bv1"}')
        ;
    }

    /**
     * @test
     */
    public function can_set_default_http_options(): void
    {
        $this->browser()
            ->setDefaultHttpOptions(['headers' => ['x-foo' => 'bar']])
            ->/** @scrutinizer ignore-call */ setDefaultHttpOptions(['headers' => ['x-foo' => 'bar']])
            ->post('/http-method')
            ->assertContains('"x-foo":["bar"]')
            ->post('/http-method', ['headers' => ['x-bar' => 'foo']])
            ->assertContains('"x-bar":["foo"]')
            ->assertContains('"x-foo":["bar"]')
        ;
    }

    /**
     * @test
     */
    public function can_handle_any_content_type(): void
    {
        $this->browser()
            ->get('/text')
            ->assertHeaderContains('content-type', 'text/plain')
            ->assertSuccessful()
            ->assertStatus(200)
            ->assertContains('text content')
        ;
    }

    /**
     * @test
     */
    public function can_assert_json_matches(): void
    {
        $this->browser()
            ->post('/json', ['json' => [
            ->/** @scrutinizer ignore-call */ post('/json', ['json' => [
                'foo' => [
                    'bar' => ['baz' => 1],
                    'bam' => ['baz' => 2],
                    'boo' => ['baz' => 3],
                ],
            ]])
            ->assertJson()
            ->assertJsonMatches('foo.bar.baz', 1)
            ->assertJsonMatches('foo.*.baz', [1, 2, 3])
            ->assertJsonMatches('length(foo)', 3)
        ;
    }

    /**
     * @test
     */
    public function assert_json_alternate_content_types(): void
    {
        $this->browser()
            ->get('/json?content-type=application/vnd.custom.json', ['json' => 'foo'])
            ->assertSuccessful()
            ->assertJson()
            ->assertJson('application/vnd.custom.json')
        ;
    }

    /**
     * @test
     */
    public function can_dump_empty_json_request(): void
    {
        $output = self::catchVarDumperOutput(function() {
            $this->browser()
                ->post('/json')
                ->dump()
            ;
        });

        $this->assertStringContainsString('Content-Type:  application/json', $output[0]);
    }

    /**
     * @test
     */
    public function can_dump_json_response_as_array(): void
    {
        $output = self::catchVarDumperOutput(function() {
            $this->browser()
                ->post('/json', ['json' => ['foo' => 'bar']])
                ->dump()
            ;
        });

        $this->assertStringContainsString('    "foo": "bar"', $output[0]);
    }

    /**
     * @test
     */
    public function dump_includes_headers_and_status(): void
    {
        $output = self::catchVarDumperOutput(function() {
            $this->browser()
                ->visit('/page1')
                ->dump()
            ;
        });

        $this->assertStringContainsString('(200)', $output[0]);
        $this->assertStringContainsString('Content-Type:  text/html;', $output[0]);
    }

    /**
     * @test
     */
    public function can_dump_json_array_key(): void
    {
        $output = self::catchVarDumperOutput(function() {
            $this->browser()
                ->post('/json', ['json' => ['foo' => 'bar']])
                ->dump('foo')
            ;
        });

        $this->assertSame('bar', $output[0]);
               assertSame('bar', $output[0]);
    }

    /**
     * @test
     */
    public function can_dump_json_path_expression(): void
    {
        $output = self::catchVarDumperOutput(function() {
            $this->browser()
                ->post('/json', ['json' => [
                    'foo' => [
                        'bar' => ['baz' => 1],
                        'bam' => ['baz' => 2],
                        'boo' => ['baz' => 3],
                    ],
                ]])
                ->dump('foo.*.baz')
            ;
        });

        $this->assertSame([1, 2, 3], $output[0]);
    }

    /**
     * @test
     */
    public function can_save_formatted_json_source(): void
    {
        $contents = self::catchFileContents(__DIR__.'/../var/browser/source/source.txt', function() {
            $this->browser()
                ->visit('/http-method')
                ->saveSource('/source.txt')
            ;
        });

        $this->assertStringContainsString('/http-method', $contents);
        $this->assertStringContainsString('    "content": "",', $contents);
    }

    /**
     * @test
     */
    public function can_access_json_response(): void
    {
        $response = $this->browser()
            ->post('/json', ['json' => $expected = ['foo' => 'bar']])
            ->assertSuccessful()
            ->response()
            ->ensureJson()
        ;

        $this->assertSame($expected, $response->json());
        $this->assertSame('bar', $response->search('foo'));
    }

    /**
     * @test
     */
    public function can_access_the_profiler(): void
    {
        $profile = $this->browser()
            ->visit('/page1')
            ->profile()
            ->/** @scrutinizer ignore-call */ profile()
        ;

        $this->assertTrue($profile->hasCollector('request'));
               assertTrue($profile->hasCollector('request'));
    }

    /**
     * @test
     */
    public function can_dump_xml_selector(): void
    {
        $output = self::catchVarDumperOutput(function() {
            $this->browser()
                ->visit('/xml')
                ->dump('url loc')
            ;
        });

        $this->assertCount(2, $output);
               assertCount(2, $output);
        $this->assertSame('<loc>https://www.example.com/page1</loc>', $output[0]);
        $this->assertSame('<loc attr="attribute">https://www.example.com/page2</loc>', $output[1]);
    }

    /**
     * @test
     */
    public function can_access_the_xml_crawler(): void
    {
        $crawler = $this->browser()
            ->visit('/xml')
            ->response()
            ->ensureXml()
            ->crawler()
            ->filter('url loc')
        ;

        $this->assertCount(2, $crawler);
    }
}

zenstruck / browser

Pull Request — 1.x (#62)

response_multi_header_assertions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
