Skip to content

Commit 4c8d6fe

Browse files
dominikzoggdominikzogg
committed
chubbyphp-mock-v2
1 parent 5d095ab commit 4c8d6fe

File tree

6 files changed

+269
-248
lines changed

6 files changed

+269
-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: 98 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,171 @@
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

56+
#[DoesNotPerformAssertions]
5357
public function testInvokeWithoutConfigAndWithoutLogger(): void
5458
{
55-
/** @var MockObject|WorkermanTcpConnection $workermanTcpConnection */
56-
$workermanTcpConnection = $this->getMockByCalls(WorkermanTcpConnection::class);
59+
$builder = new MockObjectBuilder();
60+
61+
/** @var WorkermanTcpConnection $workermanTcpConnection */
62+
$workermanTcpConnection = $builder->create(WorkermanTcpConnection::class, []);
5763

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

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

68-
/** @var MockObject|Probe $probe */
69-
$probe = $this->getMockByCalls(Probe::class);
74+
/** @var Probe $probe */
75+
$probe = $builder->create(Probe::class, []);
7076

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),
77+
/** @var Client $client */
78+
$client = $builder->create(Client::class, [
79+
new WithCallback('createProbe', static fn (Configuration $configuration): Probe => $probe),
80+
new WithoutReturn('endProbe', [$probe]),
7581
]);
7682

7783
$adapter = new BlackfireOnMessageAdapter($onMessage, $client);
7884
$adapter($workermanTcpConnection, $workermanRequest);
7985
}
8086

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

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

91-
/** @var MockObject|OnMessageInterface $onMessage */
92-
$onMessage = $this->getMockByCalls(OnMessageInterface::class, [
93-
Call::create('__invoke')->with($workermanTcpConnection, $workermanRequest),
100+
/** @var OnMessageInterface $onMessage */
101+
$onMessage = $builder->create(OnMessageInterface::class, [
102+
new WithoutReturn('__invoke', [$workermanTcpConnection, $workermanRequest]),
94103
]);
95104

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

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

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),
111+
/** @var Client $client */
112+
$client = $builder->create(Client::class, [
113+
new WithReturn('createProbe', [$config, true], $probe),
114+
new WithoutReturn('endProbe', [$probe]),
106115
]);
107116

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

111120
$adapter = new BlackfireOnMessageAdapter($onMessage, $client, $config, $logger);
112121
$adapter($workermanTcpConnection, $workermanRequest);
113122
}
114123

124+
#[DoesNotPerformAssertions]
115125
public function testInvokeWithExceptionOnCreateProbe(): void
116126
{
117-
/** @var MockObject|WorkermanTcpConnection $workermanTcpConnection */
118-
$workermanTcpConnection = $this->getMockByCalls(WorkermanTcpConnection::class);
127+
$builder = new MockObjectBuilder();
128+
129+
/** @var WorkermanTcpConnection $workermanTcpConnection */
130+
$workermanTcpConnection = $builder->create(WorkermanTcpConnection::class, []);
119131

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

125-
/** @var MockObject|OnMessageInterface $onMessage */
126-
$onMessage = $this->getMockByCalls(OnMessageInterface::class, [
127-
Call::create('__invoke')->with($workermanTcpConnection, $workermanRequest),
137+
/** @var OnMessageInterface $onMessage */
138+
$onMessage = $builder->create(OnMessageInterface::class, [
139+
new WithoutReturn('__invoke', [$workermanTcpConnection, $workermanRequest]),
128140
]);
129141

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

133145
$exception = new LogicException('Something went wrong');
134146

135-
/** @var Client|MockObject $client */
136-
$client = $this->getMockByCalls(Client::class, [
137-
Call::create('createProbe')->with($config, true)->willThrowException($exception),
147+
/** @var Client $client */
148+
$client = $builder->create(Client::class, [
149+
new WithException('createProbe', [$config, true], $exception),
138150
]);
139151

140-
/** @var LoggerInterface|MockObject $logger */
141-
$logger = $this->getMockByCalls(LoggerInterface::class, [
142-
Call::create('error')->with('Blackfire exception: Something went wrong', []),
152+
/** @var LoggerInterface $logger */
153+
$logger = $builder->create(LoggerInterface::class, [
154+
new WithoutReturn('error', ['Blackfire exception: Something went wrong', []]),
143155
]);
144156

145157
$adapter = new BlackfireOnMessageAdapter($onMessage, $client, $config, $logger);
146158
$adapter($workermanTcpConnection, $workermanRequest);
147159
}
148160

161+
#[DoesNotPerformAssertions]
149162
public function testInvokeWithExceptionOnProbeEnd(): void
150163
{
151-
/** @var MockObject|WorkermanTcpConnection $workermanTcpConnection */
152-
$workermanTcpConnection = $this->getMockByCalls(WorkermanTcpConnection::class);
164+
$builder = new MockObjectBuilder();
165+
166+
/** @var WorkermanTcpConnection $workermanTcpConnection */
167+
$workermanTcpConnection = $builder->create(WorkermanTcpConnection::class, []);
153168

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

159-
/** @var MockObject|OnMessageInterface $onMessage */
160-
$onMessage = $this->getMockByCalls(OnMessageInterface::class, [
161-
Call::create('__invoke')->with($workermanTcpConnection, $workermanRequest),
174+
/** @var OnMessageInterface $onMessage */
175+
$onMessage = $builder->create(OnMessageInterface::class, [
176+
new WithoutReturn('__invoke', [$workermanTcpConnection, $workermanRequest]),
162177
]);
163178

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

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

170185
$exception = new LogicException('Something went wrong');
171186

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),
187+
/** @var Client $client */
188+
$client = $builder->create(Client::class, [
189+
new WithReturn('createProbe', [$config, true], $probe),
190+
new WithException('endProbe', [$probe], $exception),
176191
]);
177192

178-
/** @var LoggerInterface|MockObject $logger */
179-
$logger = $this->getMockByCalls(LoggerInterface::class, [
180-
Call::create('error')->with('Blackfire exception: Something went wrong', []),
193+
/** @var LoggerInterface $logger */
194+
$logger = $builder->create(LoggerInterface::class, [
195+
new WithoutReturn('error', ['Blackfire exception: Something went wrong', []]),
181196
]);
182197

183198
$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)