MultiRequestTest::testGetHeaders() - Code Metrics - sunrise-php/http-client-curl - Measure and Improve Code Quality continuously with Scrutinizer

MultiRequestTest::testGetHeaders() A
last analyzed 2025-05-10 13:45 UTC

↳ Parent: MultiRequestTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	5
c	1
b	0
f	0
dl	0
loc	7
rs	10
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace Sunrise\Http\Client\Curl\Tests;

use InvalidArgumentException;
use LogicException;
use PHPUnit\Framework\TestCase;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UriInterface;
use Sunrise\Http\Client\Curl\MultiRequest;

final class MultiRequestTest extends TestCase
{
    public function testCreateWithoutRequests(): void
    {
        $this->expectException(InvalidArgumentException::class);
        new MultiRequest();
    }

    public function testGetRequests(): void
    {
        $requests = [
            $this->createMock(RequestInterface::class),
            $this->createMock(RequestInterface::class),
        ];

        self::assertSame($requests, (new MultiRequest(...$requests))->getRequests());
    }

    public function testGetProtocolVersion(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->getProtocolVersion();
    }

    public function testWithProtocolVersion(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->withProtocolVersion('1.1');
    }

    public function testGetHeaders(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->getHeaders();
    }

    public function testHasHeader(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->hasHeader('X-Test');
    }

    public function testGetHeader(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->getHeader('X-Test');
    }

    public function testGetHeaderLine(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->getHeaderLine('X-Test');
    }

    public function testWithHeader(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->withHeader('X-Test', 'test');
    }

    public function testWithAddedHeader(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->withAddedHeader('X-Test', 'test');
    }

    public function testWithoutHeader(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->withoutHeader('X-Test');
    }

    public function testGetBody(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->getBody();
    }

    public function testWithBody(): void
    {
        $body = $this->createMock(StreamInterface::class);
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->withBody($body);
    }

    public function testGetRequestTarget(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->getRequestTarget();
    }

    public function testWithRequestTarget(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->withRequestTarget('/');
    }

    public function testGetMethod(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->getMethod();
    }

    public function testWithMethod(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->withMethod('GET');
    }

    public function testGetUri(): void
    {
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->getUri();
    }

    public function testWithUri(): void
    {
        $uri = $this->createMock(UriInterface::class);
        $request = $this->createMock(RequestInterface::class);
        $multiRequest = new MultiRequest($request);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Not implemented.');
        $multiRequest->withUri($uri);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Sunrise\Http\Client\Curl\Tests;
6
7			use InvalidArgumentException;
8			use LogicException;
9			use PHPUnit\Framework\TestCase;
10			use Psr\Http\Message\RequestInterface;
11			use Psr\Http\Message\StreamInterface;
12			use Psr\Http\Message\UriInterface;
13			use Sunrise\Http\Client\Curl\MultiRequest;
14
15			final class MultiRequestTest extends TestCase
16			{
17			public function testCreateWithoutRequests(): void
18			{
19			$this->expectException(InvalidArgumentException::class);
20			new MultiRequest();
21			}
22
23			public function testGetRequests(): void
24			{
25			$requests = [
26			$this->createMock(RequestInterface::class),
27			$this->createMock(RequestInterface::class),
28			];
29
30			self::assertSame($requests, (new MultiRequest(...$requests))->getRequests());
31			}
32
33			public function testGetProtocolVersion(): void
34			{
35			$request = $this->createMock(RequestInterface::class);
36			$multiRequest = new MultiRequest($request);
37			$this->expectException(LogicException::class);
38			$this->expectExceptionMessage('Not implemented.');
39			$multiRequest->getProtocolVersion();
40			}
41
42			public function testWithProtocolVersion(): void
43			{
44			$request = $this->createMock(RequestInterface::class);
45			$multiRequest = new MultiRequest($request);
46			$this->expectException(LogicException::class);
47			$this->expectExceptionMessage('Not implemented.');
48			$multiRequest->withProtocolVersion('1.1');
49			}
50
51			public function testGetHeaders(): void
52			{
53			$request = $this->createMock(RequestInterface::class);
54			$multiRequest = new MultiRequest($request);
55			$this->expectException(LogicException::class);
56			$this->expectExceptionMessage('Not implemented.');
57			$multiRequest->getHeaders();
58			}
59
60			public function testHasHeader(): void
61			{
62			$request = $this->createMock(RequestInterface::class);
63			$multiRequest = new MultiRequest($request);
64			$this->expectException(LogicException::class);
65			$this->expectExceptionMessage('Not implemented.');
66			$multiRequest->hasHeader('X-Test');
67			}
68
69			public function testGetHeader(): void
70			{
71			$request = $this->createMock(RequestInterface::class);
72			$multiRequest = new MultiRequest($request);
73			$this->expectException(LogicException::class);
74			$this->expectExceptionMessage('Not implemented.');
75			$multiRequest->getHeader('X-Test');
76			}
77
78			public function testGetHeaderLine(): void
79			{
80			$request = $this->createMock(RequestInterface::class);
81			$multiRequest = new MultiRequest($request);
82			$this->expectException(LogicException::class);
83			$this->expectExceptionMessage('Not implemented.');
84			$multiRequest->getHeaderLine('X-Test');
85			}
86
87			public function testWithHeader(): void
88			{
89			$request = $this->createMock(RequestInterface::class);
90			$multiRequest = new MultiRequest($request);
91			$this->expectException(LogicException::class);
92			$this->expectExceptionMessage('Not implemented.');
93			$multiRequest->withHeader('X-Test', 'test');
94			}
95
96			public function testWithAddedHeader(): void
97			{
98			$request = $this->createMock(RequestInterface::class);
99			$multiRequest = new MultiRequest($request);
100			$this->expectException(LogicException::class);
101			$this->expectExceptionMessage('Not implemented.');
102			$multiRequest->withAddedHeader('X-Test', 'test');
103			}
104
105			public function testWithoutHeader(): void
106			{
107			$request = $this->createMock(RequestInterface::class);
108			$multiRequest = new MultiRequest($request);
109			$this->expectException(LogicException::class);
110			$this->expectExceptionMessage('Not implemented.');
111			$multiRequest->withoutHeader('X-Test');
112			}
113
114			public function testGetBody(): void
115			{
116			$request = $this->createMock(RequestInterface::class);
117			$multiRequest = new MultiRequest($request);
118			$this->expectException(LogicException::class);
119			$this->expectExceptionMessage('Not implemented.');
120			$multiRequest->getBody();
121			}
122
123			public function testWithBody(): void
124			{
125			$body = $this->createMock(StreamInterface::class);
126			$request = $this->createMock(RequestInterface::class);
127			$multiRequest = new MultiRequest($request);
128			$this->expectException(LogicException::class);
129			$this->expectExceptionMessage('Not implemented.');
130			$multiRequest->withBody($body);
131			}
132
133			public function testGetRequestTarget(): void
134			{
135			$request = $this->createMock(RequestInterface::class);
136			$multiRequest = new MultiRequest($request);
137			$this->expectException(LogicException::class);
138			$this->expectExceptionMessage('Not implemented.');
139			$multiRequest->getRequestTarget();
140			}
141
142			public function testWithRequestTarget(): void
143			{
144			$request = $this->createMock(RequestInterface::class);
145			$multiRequest = new MultiRequest($request);
146			$this->expectException(LogicException::class);
147			$this->expectExceptionMessage('Not implemented.');
148			$multiRequest->withRequestTarget('/');
149			}
150
151			public function testGetMethod(): void
152			{
153			$request = $this->createMock(RequestInterface::class);
154			$multiRequest = new MultiRequest($request);
155			$this->expectException(LogicException::class);
156			$this->expectExceptionMessage('Not implemented.');
157			$multiRequest->getMethod();
158			}
159
160			public function testWithMethod(): void
161			{
162			$request = $this->createMock(RequestInterface::class);
163			$multiRequest = new MultiRequest($request);
164			$this->expectException(LogicException::class);
165			$this->expectExceptionMessage('Not implemented.');
166			$multiRequest->withMethod('GET');
167			}
168
169			public function testGetUri(): void
170			{
171			$request = $this->createMock(RequestInterface::class);
172			$multiRequest = new MultiRequest($request);
173			$this->expectException(LogicException::class);
174			$this->expectExceptionMessage('Not implemented.');
175			$multiRequest->getUri();
176			}
177
178			public function testWithUri(): void
179			{
180			$uri = $this->createMock(UriInterface::class);
181			$request = $this->createMock(RequestInterface::class);
182			$multiRequest = new MultiRequest($request);
183			$this->expectException(LogicException::class);
184			$this->expectExceptionMessage('Not implemented.');
185			$multiRequest->withUri($uri);
186			}
187			}
188

sunrise-php / http-client-curl

MultiRequestTest::testGetHeaders() A last analyzed 2025-05-10 13:45 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

MultiRequestTest::testGetHeaders() A
last analyzed 2025-05-10 13:45 UTC