Skip to content

Commit 65a46be

Browse files
dominikzoggdominikzogg
committed
chubbyphp-mock-v2
1 parent 5d095ab commit 65a46be

File tree

6 files changed

+272
-248
lines changed

6 files changed

+272
-248
lines changed

‎composer.json‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -25,14 +25,14 @@
2525
"workerman/workerman": "^4.2.1"
2626
},
2727
"require-dev": {
28-
"blackfire/php-sdk": "^2.5.4",
28+
"blackfire/php-sdk": "^2.5.7",
2929
"chubbyphp/chubbyphp-dev-helper": "dev-master",
30-
"chubbyphp/chubbyphp-mock": "^1.8",
31-
"infection/infection": "^0.29.8",
30+
"chubbyphp/chubbyphp-mock": "^2.0@dev",
31+
"infection/infection": "^0.29.12",
3232
"php-coveralls/php-coveralls": "^2.7",
3333
"phpstan/extension-installer": "^1.4.3",
34-
"phpstan/phpstan": "^2.0.3",
35-
"phpunit/phpunit": "^11.5.0"
34+
"phpstan/phpstan": "^2.1.6",
35+
"phpunit/phpunit": "^11.5.9"
3636
},
3737
"autoload": {
3838
"psr-4": { "Chubbyphp\\WorkermanRequestHandler\\": "src/" }

‎tests/Unit/Adapter/BlackfireOnMessageAdapterTest.php‎

Lines changed: 101 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -8,12 +8,14 @@
88
use Blackfire\Exception\LogicException;
99
use Blackfire\Probe;
1010
use Blackfire\Profile\Configuration;
11-
use Chubbyphp\Mock\Argument\ArgumentInstanceOf;
12-
use Chubbyphp\Mock\Call;
13-
use Chubbyphp\Mock\MockByCallsTrait;
11+
use Chubbyphp\Mock\MockMethod\WithCallback;
12+
use Chubbyphp\Mock\MockMethod\WithException;
13+
use Chubbyphp\Mock\MockMethod\WithoutReturn;
14+
use Chubbyphp\Mock\MockMethod\WithReturn;
15+
use Chubbyphp\Mock\MockObjectBuilder;
1416
use Chubbyphp\WorkermanRequestHandler\Adapter\BlackfireOnMessageAdapter;
1517
use Chubbyphp\WorkermanRequestHandler\OnMessageInterface;
16-
use PHPUnit\Framework\MockObject\MockObject;
18+
use PHPUnit\Framework\Attributes\DoesNotPerformAssertions;
1719
use PHPUnit\Framework\TestCase;
1820
use Psr\Log\LoggerInterface;
1921
use Workerman\Connection\TcpConnection as WorkermanTcpConnection;
@@ -26,158 +28,174 @@
2628
*/
2729
final class BlackfireOnMessageAdapterTest extends TestCase
2830
{
29-
use MockByCallsTrait;
30-
31+
#[DoesNotPerformAssertions]
3132
public function testInvokeWithoutHeaderWithoutConfigAndWithoutLogger(): void
3233
{
33-
/** @var MockObject|WorkermanTcpConnection $workermanTcpConnection */
34-
$workermanTcpConnection = $this->getMockByCalls(WorkermanTcpConnection::class);
34+
$builder = new MockObjectBuilder();
35+
36+
/** @var WorkermanTcpConnection $workermanTcpConnection */
37+
$workermanTcpConnection = $builder->create(WorkermanTcpConnection::class, []);
3538

36-
/** @var MockObject|WorkermanRequest $workermanRequest */
37-
$workermanRequest = $this->getMockByCalls(WorkermanRequest::class, [
38-
Call::create('header')->with('x-blackfire-query', null)->willReturn(null),
39+
/** @var WorkermanRequest $workermanRequest */
40+
$workermanRequest = $builder->create(WorkermanRequest::class, [
41+
new WithReturn('header', ['x-blackfire-query', null], null),
3942
]);
4043

41-
/** @var MockObject|OnMessageInterface $onMessage */
42-
$onMessage = $this->getMockByCalls(OnMessageInterface::class, [
43-
Call::create('__invoke')->with($workermanTcpConnection, $workermanRequest),
44+
/** @var OnMessageInterface $onMessage */
45+
$onMessage = $builder->create(OnMessageInterface::class, [
46+
new WithoutReturn('__invoke', [$workermanTcpConnection, $workermanRequest]),
4447
]);
4548

46-
/** @var Client|MockObject $client */
47-
$client = $this->getMockByCalls(Client::class);
49+
/** @var Client $client */
50+
$client = $builder->create(Client::class, []);
4851

4952
$adapter = new BlackfireOnMessageAdapter($onMessage, $client);
5053
$adapter($workermanTcpConnection, $workermanRequest);
5154
}
5255

5356
public function testInvokeWithoutConfigAndWithoutLogger(): void
5457
{
55-
/** @var MockObject|WorkermanTcpConnection $workermanTcpConnection */
56-
$workermanTcpConnection = $this->getMockByCalls(WorkermanTcpConnection::class);
58+
$builder = new MockObjectBuilder();
5759

58-
/** @var MockObject|WorkermanRequest $workermanRequest */
59-
$workermanRequest = $this->getMockByCalls(WorkermanRequest::class, [
60-
Call::create('header')->with('x-blackfire-query', null)->willReturn('workerman'),
60+
/** @var WorkermanTcpConnection $workermanTcpConnection */
61+
$workermanTcpConnection = $builder->create(WorkermanTcpConnection::class, []);
62+
63+
/** @var WorkermanRequest $workermanRequest */
64+
$workermanRequest = $builder->create(WorkermanRequest::class, [
65+
new WithReturn('header', ['x-blackfire-query', null], 'workerman'),
6166
]);
6267

63-
/** @var MockObject|OnMessageInterface $onMessage */
64-
$onMessage = $this->getMockByCalls(OnMessageInterface::class, [
65-
Call::create('__invoke')->with($workermanTcpConnection, $workermanRequest),
68+
/** @var OnMessageInterface $onMessage */
69+
$onMessage = $builder->create(OnMessageInterface::class, [
70+
new WithoutReturn('__invoke', [$workermanTcpConnection, $workermanRequest]),
6671
]);
6772

68-
/** @var MockObject|Probe $probe */
69-
$probe = $this->getMockByCalls(Probe::class);
73+
/** @var Probe $probe */
74+
$probe = $builder->create(Probe::class, []);
75+
76+
/** @var Client $client */
77+
$client = $builder->create(Client::class, [
78+
new WithCallback('createProbe', static function (Configuration $configuration, bool $enabled) use ($probe): Probe {
79+
self::assertTrue($enabled);
7080

71-
/** @var Client|MockObject $client */
72-
$client = $this->getMockByCalls(Client::class, [
73-
Call::create('createProbe')->with(new ArgumentInstanceOf(Configuration::class), true)->willReturn($probe),
74-
Call::create('endProbe')->with($probe),
81+
return $probe;
82+
}),
83+
new WithoutReturn('endProbe', [$probe]),
7584
]);
7685

7786
$adapter = new BlackfireOnMessageAdapter($onMessage, $client);
7887
$adapter($workermanTcpConnection, $workermanRequest);
7988
}
8089

90+
#[DoesNotPerformAssertions]
8191
public function testInvokeWithConfigAndWithLogger(): void
8292
{
83-
/** @var MockObject|WorkermanTcpConnection $workermanTcpConnection */
84-
$workermanTcpConnection = $this->getMockByCalls(WorkermanTcpConnection::class);
93+
$builder = new MockObjectBuilder();
8594

86-
/** @var MockObject|WorkermanRequest $workermanRequest */
87-
$workermanRequest = $this->getMockByCalls(WorkermanRequest::class, [
88-
Call::create('header')->with('x-blackfire-query', null)->willReturn('workerman'),
95+
/** @var WorkermanTcpConnection $workermanTcpConnection */
96+
$workermanTcpConnection = $builder->create(WorkermanTcpConnection::class, []);
97+
98+
/** @var WorkermanRequest $workermanRequest */
99+
$workermanRequest = $builder->create(WorkermanRequest::class, [
100+
new WithReturn('header', ['x-blackfire-query', null], 'workerman'),
89101
]);
90102

91-
/** @var MockObject|OnMessageInterface $onMessage */
92-
$onMessage = $this->getMockByCalls(OnMessageInterface::class, [
93-
Call::create('__invoke')->with($workermanTcpConnection, $workermanRequest),
103+
/** @var OnMessageInterface $onMessage */
104+
$onMessage = $builder->create(OnMessageInterface::class, [
105+
new WithoutReturn('__invoke', [$workermanTcpConnection, $workermanRequest]),
94106
]);
95107

96-
/** @var Configuration|MockObject $config */
97-
$config = $this->getMockByCalls(Configuration::class);
108+
/** @var Configuration $config */
109+
$config = $builder->create(Configuration::class, []);
98110

99-
/** @var MockObject|Probe $probe */
100-
$probe = $this->getMockByCalls(Probe::class);
111+
/** @var Probe $probe */
112+
$probe = $builder->create(Probe::class, []);
101113

102-
/** @var Client|MockObject $client */
103-
$client = $this->getMockByCalls(Client::class, [
104-
Call::create('createProbe')->with($config, true)->willReturn($probe),
105-
Call::create('endProbe')->with($probe),
114+
/** @var Client $client */
115+
$client = $builder->create(Client::class, [
116+
new WithReturn('createProbe', [$config, true], $probe),
117+
new WithoutReturn('endProbe', [$probe]),
106118
]);
107119

108-
/** @var LoggerInterface|MockObject $logger */
109-
$logger = $this->getMockByCalls(LoggerInterface::class);
120+
/** @var LoggerInterface $logger */
121+
$logger = $builder->create(LoggerInterface::class, []);
110122

111123
$adapter = new BlackfireOnMessageAdapter($onMessage, $client, $config, $logger);
112124
$adapter($workermanTcpConnection, $workermanRequest);
113125
}
114126

127+
#[DoesNotPerformAssertions]
115128
public function testInvokeWithExceptionOnCreateProbe(): void
116129
{
117-
/** @var MockObject|WorkermanTcpConnection $workermanTcpConnection */
118-
$workermanTcpConnection = $this->getMockByCalls(WorkermanTcpConnection::class);
130+
$builder = new MockObjectBuilder();
131+
132+
/** @var WorkermanTcpConnection $workermanTcpConnection */
133+
$workermanTcpConnection = $builder->create(WorkermanTcpConnection::class, []);
119134

120-
/** @var MockObject|WorkermanRequest $workermanRequest */
121-
$workermanRequest = $this->getMockByCalls(WorkermanRequest::class, [
122-
Call::create('header')->with('x-blackfire-query', null)->willReturn('workerman'),
135+
/** @var WorkermanRequest $workermanRequest */
136+
$workermanRequest = $builder->create(WorkermanRequest::class, [
137+
new WithReturn('header', ['x-blackfire-query', null], 'workerman'),
123138
]);
124139

125-
/** @var MockObject|OnMessageInterface $onMessage */
126-
$onMessage = $this->getMockByCalls(OnMessageInterface::class, [
127-
Call::create('__invoke')->with($workermanTcpConnection, $workermanRequest),
140+
/** @var OnMessageInterface $onMessage */
141+
$onMessage = $builder->create(OnMessageInterface::class, [
142+
new WithoutReturn('__invoke', [$workermanTcpConnection, $workermanRequest]),
128143
]);
129144

130-
/** @var Configuration|MockObject $config */
131-
$config = $this->getMockByCalls(Configuration::class);
145+
/** @var Configuration $config */
146+
$config = $builder->create(Configuration::class, []);
132147

133148
$exception = new LogicException('Something went wrong');
134149

135-
/** @var Client|MockObject $client */
136-
$client = $this->getMockByCalls(Client::class, [
137-
Call::create('createProbe')->with($config, true)->willThrowException($exception),
150+
/** @var Client $client */
151+
$client = $builder->create(Client::class, [
152+
new WithException('createProbe', [$config, true], $exception),
138153
]);
139154

140-
/** @var LoggerInterface|MockObject $logger */
141-
$logger = $this->getMockByCalls(LoggerInterface::class, [
142-
Call::create('error')->with('Blackfire exception: Something went wrong', []),
155+
/** @var LoggerInterface $logger */
156+
$logger = $builder->create(LoggerInterface::class, [
157+
new WithoutReturn('error', ['Blackfire exception: Something went wrong', []]),
143158
]);
144159

145160
$adapter = new BlackfireOnMessageAdapter($onMessage, $client, $config, $logger);
146161
$adapter($workermanTcpConnection, $workermanRequest);
147162
}
148163

164+
#[DoesNotPerformAssertions]
149165
public function testInvokeWithExceptionOnProbeEnd(): void
150166
{
151-
/** @var MockObject|WorkermanTcpConnection $workermanTcpConnection */
152-
$workermanTcpConnection = $this->getMockByCalls(WorkermanTcpConnection::class);
167+
$builder = new MockObjectBuilder();
168+
169+
/** @var WorkermanTcpConnection $workermanTcpConnection */
170+
$workermanTcpConnection = $builder->create(WorkermanTcpConnection::class, []);
153171

154-
/** @var MockObject|WorkermanRequest $workermanRequest */
155-
$workermanRequest = $this->getMockByCalls(WorkermanRequest::class, [
156-
Call::create('header')->with('x-blackfire-query', null)->willReturn('workerman'),
172+
/** @var WorkermanRequest $workermanRequest */
173+
$workermanRequest = $builder->create(WorkermanRequest::class, [
174+
new WithReturn('header', ['x-blackfire-query', null], 'workerman'),
157175
]);
158176

159-
/** @var MockObject|OnMessageInterface $onMessage */
160-
$onMessage = $this->getMockByCalls(OnMessageInterface::class, [
161-
Call::create('__invoke')->with($workermanTcpConnection, $workermanRequest),
177+
/** @var OnMessageInterface $onMessage */
178+
$onMessage = $builder->create(OnMessageInterface::class, [
179+
new WithoutReturn('__invoke', [$workermanTcpConnection, $workermanRequest]),
162180
]);
163181

164-
/** @var Configuration|MockObject $config */
165-
$config = $this->getMockByCalls(Configuration::class);
182+
/** @var Configuration $config */
183+
$config = $builder->create(Configuration::class, []);
166184

167-
/** @var MockObject|Probe $probe */
168-
$probe = $this->getMockByCalls(Probe::class);
185+
/** @var Probe $probe */
186+
$probe = $builder->create(Probe::class, []);
169187

170188
$exception = new LogicException('Something went wrong');
171189

172-
/** @var Client|MockObject $client */
173-
$client = $this->getMockByCalls(Client::class, [
174-
Call::create('createProbe')->with($config, true)->willReturn($probe),
175-
Call::create('endProbe')->with($probe)->willThrowException($exception),
190+
/** @var Client $client */
191+
$client = $builder->create(Client::class, [
192+
new WithReturn('createProbe', [$config, true], $probe),
193+
new WithException('endProbe', [$probe], $exception),
176194
]);
177195

178-
/** @var LoggerInterface|MockObject $logger */
179-
$logger = $this->getMockByCalls(LoggerInterface::class, [
180-
Call::create('error')->with('Blackfire exception: Something went wrong', []),
196+
/** @var LoggerInterface $logger */
197+
$logger = $builder->create(LoggerInterface::class, [
198+
new WithoutReturn('error', ['Blackfire exception: Something went wrong', []]),
181199
]);
182200

183201
$adapter = new BlackfireOnMessageAdapter($onMessage, $client, $config, $logger);

‎tests/Unit/Adapter/NewRelicOnMessageAdapterTest.php‎

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -69,14 +69,13 @@ function newrelic_end_transaction(bool $ignore = false): void
6969

7070
namespace Chubbyphp\Tests\WorkermanRequestHandler\Unit\Adapter
7171
{
72-
use Chubbyphp\Mock\Call;
73-
use Chubbyphp\Mock\MockByCallsTrait;
72+
use Chubbyphp\Mock\MockMethod\WithoutReturn;
73+
use Chubbyphp\Mock\MockObjectBuilder;
7474
use Chubbyphp\WorkermanRequestHandler\Adapter\NewRelicOnMessageAdapter;
7575
use Chubbyphp\WorkermanRequestHandler\Adapter\TestNewRelicEndTransaction;
7676
use Chubbyphp\WorkermanRequestHandler\Adapter\TestNewRelicStartTransaction;
7777
use Chubbyphp\WorkermanRequestHandler\OnMessageInterface;
7878
use PHPUnit\Framework\TestCase;
79-
use PHPUnit\WorkermanRequestHandler\MockObject\MockObject;
8079
use Workerman\Connection\TcpConnection as WorkermanTcpConnection;
8180
use Workerman\Protocols\Http\Request as WorkermanRequest;
8281

@@ -87,22 +86,22 @@ function newrelic_end_transaction(bool $ignore = false): void
8786
*/
8887
final class NewRelicOnMessageAdapterTest extends TestCase
8988
{
90-
use MockByCallsTrait;
91-
9289
public function testInvoke(): void
9390
{
9491
TestNewRelicStartTransaction::reset();
9592
TestNewRelicEndTransaction::reset();
9693

97-
/** @var MockObject|WorkermanTcpConnection $workermanTcpConnection */
98-
$workermanTcpConnection = $this->getMockByCalls(WorkermanTcpConnection::class);
94+
$builder = new MockObjectBuilder();
95+
96+
/** @var WorkermanTcpConnection $workermanTcpConnection */
97+
$workermanTcpConnection = $builder->create(WorkermanTcpConnection::class, []);
9998

100-
/** @var MockObject|WorkermanRequest $workermanRequest */
101-
$workermanRequest = $this->getMockByCalls(WorkermanRequest::class);
99+
/** @var WorkermanRequest $workermanRequest */
100+
$workermanRequest = $builder->create(WorkermanRequest::class, []);
102101

103-
/** @var MockObject|OnMessageInterface $onMessage */
104-
$onMessage = $this->getMockByCalls(OnMessageInterface::class, [
105-
Call::create('__invoke')->with($workermanTcpConnection, $workermanRequest),
102+
/** @var OnMessageInterface $onMessage */
103+
$onMessage = $builder->create(OnMessageInterface::class, [
104+
new WithoutReturn('__invoke', [$workermanTcpConnection, $workermanRequest]),
106105
]);
107106

108107
$adapter = new NewRelicOnMessageAdapter($onMessage, 'myapp');

0 commit comments

Comments
 (0)