Gelf\Test\Transport\KeepAliveRetryTransportWrapperTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	5	1
A	testSendSuccess()	0	10	1
A	testSendFailTwiceWithoutResponse()	0	17	1
A	testSendSuccessAfterRetry()	0	15	1
A	testSendFailWithUnmanagedException()	0	13	1

<?php
declare(strict_types=1);

namespace Gelf\Test\Transport;

use Gelf\Message;
use Gelf\Transport\HttpTransport;
use Gelf\Transport\KeepAliveRetryTransportWrapper;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\MockObject\MockObject;
use RuntimeException;

class KeepAliveRetryTransportWrapperTest extends TestCase
{
    private const FAILURE_MESSAGE
        = "Graylog-Server didn't answer properly, expected 'HTTP/1.x 202 Accepted', response is ''";

    private Message $message;
    private HttpTransport|MockObject $transport;
    private KeepAliveRetryTransportWrapper $wrapper;

    public function setUp(): void
    {
        $this->message = new Message();
        $this->transport = $this->createMock(HttpTransport::class);
        $this->wrapper   = new KeepAliveRetryTransportWrapper($this->transport);
    }

    public function testSendSuccess(): void
    {
        $this->transport->expects($this->once())

The method expects() does not exist on Gelf\Transport\HttpTransport.

            ->method('send')
            ->with($this->message)
            ->will($this->returnValue(42));

        $bytes = $this->wrapper->send($this->message);

        self::assertEquals(42, $bytes);
    }

    public function testSendSuccessAfterRetry(): void
    {
        $expectedException = new RuntimeException(self::FAILURE_MESSAGE);

        $this->transport->expects($this->exactly(2))
            ->method('send')
            ->with($this->message)
            ->will($this->onConsecutiveCalls(
                $this->throwException($expectedException),
                42
            ));

        $bytes = $this->wrapper->send($this->message);

        self::assertEquals(42, $bytes);
    }

    public function testSendFailTwiceWithoutResponse(): void
    {
        self::expectException(RuntimeException::class);

The method PHPUnit\Framework\TestCase::expectException() is not static, but was called statically.

        self::expectExceptionMessage("response is ''");

The method PHPUnit\Framework\TestCase::expectExceptionMessage() is not static, but was called statically.

        $expectedException1 = new RuntimeException(self::FAILURE_MESSAGE);
        $expectedException2 = new RuntimeException(self::FAILURE_MESSAGE);

        $this->transport->expects($this->exactly(2))
            ->method('send')
            ->with($this->message)
            ->will($this->onConsecutiveCalls(
                $this->throwException($expectedException1),
                $this->throwException($expectedException2)
            ));

        $this->wrapper->send($this->message);
    }

    public function testSendFailWithUnmanagedException(): void
    {
        $this->expectException(RuntimeException::class);
        $this->expectExceptionMessage("foo");

        $expectedException = new RuntimeException('foo');

        $this->transport->expects($this->once())
            ->method('send')
            ->with($this->message)
            ->willThrowException($expectedException);

        $this->wrapper->send($this->message);
    }
}