| <?php |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| declare(strict_types=1); |
| |
| namespace Test\Thrift\Unit\Lib\Transport; |
| |
| use phpmock\phpunit\PHPMock; |
| use PHPUnit\Framework\TestCase; |
| use PHPUnit\Framework\Attributes\DataProvider; |
| use Psr\Log\LoggerInterface; |
| use Psr\Log\LogLevel; |
| use Test\Thrift\Unit\Lib\ReflectionHelper; |
| use Test\Thrift\Unit\Lib\UserDeprecationCapture; |
| use Thrift\Exception\TException; |
| use Thrift\Exception\TTransportException; |
| use Thrift\Transport\TSocket; |
| |
| class TSocketTest extends TestCase |
| { |
| use PHPMock; |
| use ReflectionHelper; |
| use UserDeprecationCapture; |
| |
| protected function setUp(): void |
| { |
| $this->getAccessibleProperty(TSocket::class, 'hasSocketsExtension') |
| ->setValue(null, null); |
| } |
| |
| #[DataProvider('openExceptionDataProvider')] |
| public function testOpenException( |
| $host, |
| $port, |
| $persist, |
| $debugHandler, |
| $fsockopenCallCount, |
| $expectedException, |
| $expectedMessage, |
| $expectedCode |
| ) { |
| $this->expectException($expectedException); |
| $this->expectExceptionMessage($expectedMessage); |
| $this->expectExceptionCode($expectedCode); |
| |
| $this->getFunctionMock('Thrift\Transport', 'fsockopen') |
| ->expects($this->exactly($fsockopenCallCount)) |
| ->with( |
| $host, |
| $port, |
| $this->anything(), #$errno, |
| $this->anything(), #$errstr, |
| $this->anything() #$this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000), |
| ) |
| ->willReturn(false); |
| |
| $socket = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| $socket->open(); |
| } |
| |
| public static function openExceptionDataProvider() |
| { |
| yield 'host is empty' => [ |
| 'host' => '', |
| 'port' => 9090, |
| 'persist' => null, |
| 'debugHandler' => false, |
| 'fsockopenCallCount' => 0, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'Cannot open null host', |
| 'expectedCode' => TTransportException::NOT_OPEN, |
| ]; |
| yield 'port is not positive' => [ |
| 'host' => 'localhost', |
| 'port' => 0, |
| 'persist' => false, |
| 'debugHandler' => null, |
| 'fsockopenCallCount' => 0, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'Cannot open without port', |
| 'expectedCode' => TTransportException::NOT_OPEN, |
| ]; |
| yield 'connection failure' => [ |
| 'host' => 'nonexistent-host', |
| 'port' => 9090, |
| 'persist' => false, |
| 'debugHandler' => null, |
| 'fsockopenCallCount' => 1, |
| 'expectedException' => TException::class, |
| 'expectedMessage' => 'TSocket: Could not connect to', |
| 'expectedCode' => TTransportException::UNKNOWN, |
| ]; |
| } |
| |
| public function testDoubleConnect(): void |
| { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $handle = fopen('php://memory', 'r+'); |
| $this->getFunctionMock('Thrift\Transport', 'fsockopen') |
| ->expects($this->once()) |
| ->with( |
| $host, |
| $port, |
| $this->anything(), #$errno, |
| $this->anything(), #$errstr, |
| $this->anything() #$this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000), |
| ) |
| ->willReturn($handle); |
| |
| $this->getFunctionMock('Thrift\Transport', 'socket_import_stream') |
| ->expects($this->once()) |
| ->with($handle) |
| ->willReturn(true); |
| |
| $this->getFunctionMock('Thrift\Transport', 'socket_set_option') |
| ->expects($this->once()) |
| ->with( |
| $this->anything(), #$socket, |
| SOL_TCP, #$level |
| TCP_NODELAY, #$option |
| 1 #$value |
| ) |
| ->willReturn(true); |
| |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| |
| $transport->open(); |
| $this->expectException(TTransportException::class); |
| $this->expectExceptionMessage('Socket already connected'); |
| $this->expectExceptionCode(TTransportException::ALREADY_OPEN); |
| $transport->open(); |
| } |
| |
| public function testDebugHandler() |
| { |
| $host = 'nonexistent-host'; |
| $port = 9090; |
| $false = false; |
| |
| $debugHandler = function ($error) { |
| $this->assertEquals( |
| 'TSocket: Could not connect to nonexistent-host:9090 (Connection refused [999])', |
| $error |
| ); |
| }; |
| |
| $this->getFunctionMock('Thrift\Transport', 'fsockopen') |
| ->expects($this->once()) |
| ->with( |
| $host, |
| $port, |
| $this->anything(), #$errno, |
| $this->anything(), #$errstr, |
| $this->anything() #$this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000), |
| ) |
| ->willReturnCallback( |
| function ( |
| string $hostname, |
| int $port, |
| &$error_code, |
| &$error_message, |
| ?float $timeout |
| ) { |
| $error_code = 999; |
| $error_message = 'Connection refused'; |
| |
| return false; |
| } |
| ); |
| |
| $transport = null; |
| $deprecations = self::captureUserDeprecations( |
| static function () use (&$transport, $host, $port, $false, $debugHandler): void { |
| $transport = new TSocket($host, $port, $false, $debugHandler); |
| $transport->setDebug(true); |
| }, |
| ); |
| $this->assertCount(2, $deprecations); |
| |
| $this->expectException(\Exception::class); |
| $this->expectExceptionMessage('TSocket: Could not connect to'); |
| $this->expectExceptionCode(0); |
| $transport->open(); |
| } |
| |
| public function testOpenPersist() |
| { |
| $host = 'persist-localhost'; |
| $port = 9090; |
| $persist = true; |
| $debugHandler = null; |
| |
| $handle = fopen('php://memory', 'r+'); |
| |
| $this->getFunctionMock('Thrift\Transport', 'pfsockopen') |
| ->expects($this->once()) |
| ->with( |
| $host, |
| $port, |
| $this->anything(), #$errno, |
| $this->anything(), #$errstr, |
| $this->anything() #$this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000), |
| ) |
| ->willReturn($handle); |
| |
| $this->getFunctionMock('Thrift\Transport', 'socket_import_stream') |
| ->expects($this->once()) |
| ->with($handle) |
| ->willReturn(true); |
| |
| $this->getFunctionMock('Thrift\Transport', 'socket_set_option') |
| ->expects($this->once()) |
| ->with( |
| $this->anything(), #$socket, |
| SOL_TCP, #$level |
| TCP_NODELAY, #$option |
| 1 #$value |
| ) |
| ->willReturn(true); |
| |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| |
| $transport->open(); |
| $this->assertTrue($transport->isOpen()); |
| } |
| |
| public function testOpenUnixSocket() |
| { |
| $host = 'unix:///tmp/ipc.sock'; |
| $port = -1; |
| $persist = false; |
| $debugHandler = null; |
| $handle = fopen('php://memory', 'r+'); |
| |
| $this->getFunctionMock('Thrift\Transport', 'fsockopen') |
| ->expects($this->once()) |
| ->with( |
| $host, |
| $port, |
| $this->anything(), #$errno, |
| $this->anything(), #$errstr, |
| $this->anything() #$this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000), |
| ) |
| ->willReturn($handle); |
| |
| $this->getFunctionMock('Thrift\Transport', 'socket_import_stream') |
| ->expects($this->once()) |
| ->with($handle) |
| ->willReturn(true); |
| |
| $this->getFunctionMock('Thrift\Transport', 'socket_set_option') |
| ->expects($this->once()) |
| ->with( |
| $this->anything(), #$socket, |
| SOL_TCP, #$level |
| TCP_NODELAY, #$option |
| 1 #$value |
| ) |
| ->willReturn(true); |
| |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| |
| $transport->open(); |
| } |
| |
| #[DataProvider('openThrift5132DataProvider')] |
| public function testOpenThrift5132( |
| $socketImportResult |
| ) { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| |
| $this->getFunctionMock('Thrift\Transport', 'fsockopen') |
| ->expects($this->once()) |
| ->with( |
| $host, |
| $port, |
| $this->anything(), #$errno, |
| $this->anything(), #$errstr, |
| $this->anything() #$this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000), |
| ) |
| ->willReturn(fopen('php://input', 'r+')); |
| |
| $this->getFunctionMock('Thrift\Transport', 'socket_import_stream') |
| ->expects($this->once()) |
| ->willReturn($socketImportResult); |
| |
| $this->getFunctionMock('Thrift\Transport', 'socket_set_option') |
| ->expects($socketImportResult ? $this->once() : $this->never()) |
| ->with( |
| $this->anything(), #$socket, |
| SOL_TCP, #$level |
| TCP_NODELAY, #$option |
| 1 #$value |
| ) |
| ->willReturn(true); |
| |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| |
| $transport->open(); |
| $this->assertTrue($transport->isOpen()); |
| } |
| |
| public static function openThrift5132DataProvider() |
| { |
| yield 'socket_import_stream success' => [ |
| 'socketImportResult' => true, |
| ]; |
| yield 'socket_import_stream fail' => [ |
| 'socketImportResult' => false, |
| ]; |
| } |
| |
| public function testSetHandle() |
| { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| |
| $this->assertFalse($transport->isOpen()); |
| $transport->setHandle(fopen('php://memory', 'r+')); |
| $this->assertTrue($transport->isOpen()); |
| } |
| |
| public function testSetSendTimeout() |
| { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| |
| $transport->setSendTimeout(9999); |
| $this->assertEquals(9.0, $this->getPropertyValue($transport, 'sendTimeoutSec')); |
| $this->assertEquals(999000, $this->getPropertyValue($transport, 'sendTimeoutUsec')); |
| } |
| |
| public function testSetRecvTimeout() |
| { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| |
| $transport->setRecvTimeout(9999); |
| $this->assertEquals(9.0, $this->getPropertyValue($transport, 'recvTimeoutSec')); |
| $this->assertEquals(999000, $this->getPropertyValue($transport, 'recvTimeoutUsec')); |
| } |
| |
| #[DataProvider('hostDataProvider')] |
| public function testGetHost($host, $expected) |
| { |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| $this->assertEquals($expected, $transport->getHost()); |
| } |
| |
| public static function hostDataProvider() |
| { |
| yield 'localhost' => ['localhost', 'localhost']; |
| yield 'ssl_localhost' => ['ssl://localhost', 'ssl://localhost']; |
| yield 'http_localhost' => ['http://localhost', 'http://localhost']; |
| } |
| |
| public function testGetPort() |
| { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| $this->assertEquals($port, $transport->getPort()); |
| } |
| |
| public function testClose() |
| { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| $transport->setHandle(fopen('php://memory', 'r+')); |
| $this->assertNotNull($this->getPropertyValue($transport, 'handle')); |
| |
| $transport->close(); |
| $this->assertNull($this->getPropertyValue($transport, 'handle')); |
| } |
| |
| #[DataProvider('writeFailDataProvider')] |
| public function testWriteFail( |
| $streamSelectResult, |
| $fwriteCallCount, |
| $expectedException, |
| $expectedMessage, |
| $expectedCode |
| ) { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $handle = fopen('php://memory', 'r+'); |
| |
| $this->getFunctionMock('Thrift\Transport', 'stream_select') |
| ->expects($this->once()) |
| ->with( |
| $this->anything(), #$null, |
| [$handle], |
| $this->anything(), #$null, |
| $this->anything(), #$this->sendTimeoutSec_, |
| $this->anything() #$this->sendTimeoutUsec_ |
| ) |
| ->willReturn($streamSelectResult); |
| |
| $this->getFunctionMock('Thrift\Transport', 'fwrite') |
| ->expects($this->exactly($fwriteCallCount)) |
| ->with( |
| $handle, |
| 'test1234456789132456798' |
| ) |
| ->willReturn(false); |
| |
| $this->expectException($expectedException); |
| $this->expectExceptionMessage($expectedMessage); |
| $this->expectExceptionCode($expectedCode); |
| |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| $transport->setHandle($handle); |
| |
| $transport->write('test1234456789132456798'); |
| } |
| |
| public function testWrite() |
| { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| $fileName = sys_get_temp_dir() . '/' . md5(mt_rand(0, time()) . time()); |
| touch($fileName); |
| $handle = fopen($fileName, 'r+'); |
| $transport->setHandle($handle); |
| $transport->write('test1234456789132456798'); |
| $this->assertEquals('test1234456789132456798', file_get_contents($fileName)); |
| |
| register_shutdown_function(function () use ($fileName) { |
| is_file($fileName) && unlink($fileName); |
| }); |
| } |
| |
| public static function writeFailDataProvider() |
| { |
| yield 'stream_select timeout' => [ |
| 'streamSelectResult' => 0, |
| 'fwriteCallCount' => 0, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'TSocket: timed out writing 23 bytes from localhost:9090', |
| 'expectedCode' => 0, |
| ]; |
| yield 'stream_select fail write' => [ |
| 'streamSelectResult' => 1, |
| 'fwriteCallCount' => 1, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'TSocket: Could not write 23 bytes localhost:9090', |
| 'expectedCode' => 0, |
| ]; |
| yield 'stream_select fail' => [ |
| 'streamSelectResult' => false, |
| 'fwriteCallCount' => 0, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'TSocket: Could not write 23 bytes localhost:9090', |
| 'expectedCode' => 0, |
| ]; |
| } |
| |
| public function testRead() |
| { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| $fileName = sys_get_temp_dir() . '/' . md5(mt_rand(0, time()) . time()); |
| file_put_contents($fileName, '12345678901234567890'); |
| $handle = fopen($fileName, 'r+'); |
| $transport->setHandle($handle); |
| $this->assertEquals('12345', $transport->read(5)); |
| |
| register_shutdown_function(function () use ($fileName) { |
| is_file($fileName) && unlink($fileName); |
| }); |
| } |
| |
| #[DataProvider('readFailDataProvider')] |
| public function testReadFail( |
| $streamSelectResult, |
| $freadResult, |
| $feofResult, |
| $expectedException, |
| $expectedMessage, |
| $expectedCode |
| ) { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $handle = fopen('php://memory', 'r+'); |
| |
| $this->getFunctionMock('Thrift\Transport', 'stream_select') |
| ->expects($this->once()) |
| ->with( |
| [$handle], |
| $this->anything(), #$null, |
| $this->anything(), #$null, |
| $this->anything(), #$this->recvTimeoutSec_, |
| $this->anything() #$this->recvTimeoutUsec_ |
| ) |
| ->willReturn($streamSelectResult); |
| |
| $this->getFunctionMock('Thrift\Transport', 'fread') |
| ->expects($this->exactly($streamSelectResult ? 1 : 0)) |
| ->with( |
| $handle, |
| 5 |
| ) |
| ->willReturn($freadResult); |
| $this->getFunctionMock('Thrift\Transport', 'feof') |
| ->expects($this->exactly($feofResult ? 1 : 0)) |
| ->with($handle) |
| ->willReturn($feofResult); |
| |
| $this->expectException($expectedException); |
| $this->expectExceptionMessage($expectedMessage); |
| $this->expectExceptionCode($expectedCode); |
| |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| $transport->setHandle($handle); |
| |
| $transport->read(5); |
| } |
| |
| public static function readFailDataProvider() |
| { |
| yield 'stream_select timeout' => [ |
| 'streamSelectResult' => 0, |
| 'freadResult' => '', |
| 'feofResult' => false, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'TSocket: timed out reading 5 bytes from localhost:9090', |
| 'expectedCode' => 0, |
| ]; |
| yield 'stream_select fail read' => [ |
| 'streamSelectResult' => 1, |
| 'freadResult' => '', |
| 'feofResult' => true, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'TSocket read 0 bytes', |
| 'expectedCode' => 0, |
| ]; |
| yield 'stream_select fail' => [ |
| 'streamSelectResult' => false, |
| 'freadResult' => '', |
| 'feofResult' => false, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'TSocket: Could not read 5 bytes from localhost:9090', |
| 'expectedCode' => 0, |
| ]; |
| yield 'fread false' => [ |
| 'streamSelectResult' => 1, |
| 'freadResult' => false, |
| 'feofResult' => false, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'TSocket: Could not read 5 bytes from localhost:9090', |
| 'expectedCode' => 0, |
| ]; |
| yield 'fread empty' => [ |
| 'streamSelectResult' => 1, |
| 'freadResult' => '', |
| 'feofResult' => true, |
| 'expectedException' => TTransportException::class, |
| 'expectedMessage' => 'TSocket read 0 bytes', |
| 'expectedCode' => 0, |
| ]; |
| } |
| |
| public function testFlush() |
| { |
| $host = 'localhost'; |
| $port = 9090; |
| $persist = false; |
| $debugHandler = null; |
| $transport = new TSocket( |
| $host, |
| $port, |
| $persist, |
| $debugHandler |
| ); |
| $this->assertNUll($transport->flush()); |
| } |
| |
| public function testDebugHandlerWithLoggerInterface(): void |
| { |
| $host = 'nonexistent-host'; |
| $port = 9090; |
| $expectedMessage = 'TSocket: Could not connect to nonexistent-host:9090 (Connection refused [999])'; |
| |
| $logger = $this->createMock(LoggerInterface::class); |
| $logger->expects($this->once()) |
| ->method('log') |
| ->with(LogLevel::ERROR, $expectedMessage); |
| |
| $this->getFunctionMock('Thrift\Transport', 'fsockopen') |
| ->expects($this->once()) |
| ->willReturnCallback( |
| function ( |
| string $hostname, |
| int $port, |
| &$error_code, |
| &$error_message, |
| ?float $timeout |
| ) { |
| $error_code = 999; |
| $error_message = 'Connection refused'; |
| |
| return false; |
| } |
| ); |
| |
| $transport = new TSocket($host, $port, false, $logger); |
| |
| $this->expectException(TException::class); |
| $transport->open(); |
| } |
| |
| public function testStringDebugHandlerTriggersDeprecation(): void |
| { |
| $errors = self::captureUserDeprecations(static function (): void { |
| new TSocket('localhost', 9090, false, 'error_log'); |
| }); |
| |
| $this->assertCount(1, $errors); |
| $this->assertSame(E_USER_DEPRECATED, $errors[0]['errno']); |
| $this->assertStringContainsString( |
| 'Passing a callable as $debugHandler is deprecated', |
| $errors[0]['errstr'], |
| ); |
| } |
| |
| public function testClosureDebugHandlerTriggersDeprecation(): void |
| { |
| $errors = self::captureUserDeprecations(static function (): void { |
| new TSocket('localhost', 9090, false, static function (string $m): void { |
| }); |
| }); |
| |
| $this->assertCount(1, $errors); |
| $this->assertSame(E_USER_DEPRECATED, $errors[0]['errno']); |
| $this->assertStringContainsString( |
| 'Passing a callable as $debugHandler is deprecated', |
| $errors[0]['errstr'], |
| ); |
| } |
| |
| public function testNullDebugHandlerDoesNotTriggerDeprecation(): void |
| { |
| $errors = self::captureUserDeprecations(static function (): void { |
| new TSocket('localhost', 9090, false, null); |
| }); |
| |
| $this->assertSame([], $errors); |
| } |
| |
| public function testLoggerInterfaceDebugHandlerDoesNotTriggerDeprecation(): void |
| { |
| $logger = $this->createMock(LoggerInterface::class); |
| $errors = self::captureUserDeprecations(function () use ($logger): void { |
| new TSocket('localhost', 9090, false, $logger); |
| }); |
| |
| $this->assertSame([], $errors); |
| } |
| |
| public function testSendTimeoutUsedForConnectWhenConnectTimeoutNotSet(): void |
| { |
| $handle = fopen('php://memory', 'r+'); |
| $this->getFunctionMock('Thrift\Transport', 'fsockopen') |
| ->expects($this->once()) |
| ->with( |
| 'localhost', |
| 9090, |
| $this->anything(), |
| $this->anything(), |
| 2.5, // 2500ms send timeout (no connect timeout set) |
| ) |
| ->willReturn($handle); |
| |
| $socket = new TSocket('localhost', 9090, false, null); |
| $socket->setSendTimeout(2500); |
| |
| $deprecations = self::captureUserDeprecations(static function () use ($socket): void { |
| $socket->open(); |
| }); |
| |
| $this->assertCount(1, $deprecations); |
| $this->assertStringContainsString('setConnectTimeout()', $deprecations[0]); |
| } |
| |
| public function testOpenWithDefaultTimeoutsDoesNotTriggerDeprecation(): void |
| { |
| $handle = fopen('php://memory', 'r+'); |
| $this->getFunctionMock('Thrift\Transport', 'fsockopen') |
| ->expects($this->once()) |
| ->willReturn($handle); |
| |
| $socket = new TSocket('localhost', 9090, false, null); |
| |
| $deprecations = self::captureUserDeprecations(static function () use ($socket): void { |
| $socket->open(); |
| }); |
| |
| $this->assertSame([], $deprecations); |
| } |
| |
| public function testConnectTimeoutOverridesSendTimeoutDuringOpen(): void |
| { |
| $handle = fopen('php://memory', 'r+'); |
| $this->getFunctionMock('Thrift\Transport', 'fsockopen') |
| ->expects($this->once()) |
| ->with( |
| 'localhost', |
| 9090, |
| $this->anything(), |
| $this->anything(), |
| 0.75, // 750ms connect timeout, NOT the 5s sendTimeout below |
| ) |
| ->willReturn($handle); |
| |
| $socket = new TSocket('localhost', 9090, false, null); |
| $socket->setSendTimeout(5000); |
| $socket->setConnectTimeout(750); |
| |
| $deprecations = self::captureUserDeprecations(static function () use ($socket): void { |
| $socket->open(); |
| }); |
| |
| $this->assertSame([], $deprecations); |
| } |
| } |
