OmsApiTest::testCreateOrderForEmissionICWithSignature() - Code Metrics - Inspection of "Merge pull request #4 from lamoda/support_for_orde..." - lamoda/crpt-oms-api-client - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 9d78ee...ff666c )

by Agaletskiy

created 2019-10-28 09:32 UTC

testCreateOrderForEmissionICWithSignature() B

↳ Parent: OmsApiTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	66
rs	8.7418
c	0
b	0
f	0
cc	1
nc	1
nop	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace Lamoda\OmsClient\Tests\V2;

use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\BadResponseException;
use GuzzleHttp\Psr7\Response;
use GuzzleHttp\RequestOptions;
use Lamoda\OmsClient\Exception\OmsGeneralErrorException;
use Lamoda\OmsClient\Exception\OmsRequestErrorException;
use Lamoda\OmsClient\Exception\OmsSignerErrorException;
use Lamoda\OmsClient\Serializer\SerializerInterface;
use Lamoda\OmsClient\V2\Dto\CloseICArrayResponse;
use Lamoda\OmsClient\V2\Dto\CreateOrderForEmissionICRequestLight;
use Lamoda\OmsClient\V2\Dto\CreateOrderForEmissionICResponse;
use Lamoda\OmsClient\V2\Dto\GetICBufferStatusResponse;
use Lamoda\OmsClient\V2\Dto\GetICsFromOrderResponse;
use Lamoda\OmsClient\V2\Extension;
use Lamoda\OmsClient\V2\OmsApi;
use Lamoda\OmsClient\V2\Signer\SignerInterface;
use PHPUnit\Framework\Assert;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Psr\Http\Message\RequestInterface;
use function GuzzleHttp\Psr7\stream_for;

/**
 * @covers \Lamoda\OmsClient\V2\OmsApi
 */
final class OmsApiTest extends TestCase
{
    private const TOKEN = 'abcdefg12345678';
    private const API_RESPONSE = '{stub_result}';
    private const OMS_ID = '123456';
    private const ORDER_ID = 'af7a55ae-83de-470b-a1bd-6bbf657106ef';
    private const GTIN = '046000012345';
    private const MARKING_CODE = "010467003301005321gJk6o54AQBJfX\u{001d}91ffd0\u{001d}92LGYcm3FRQrRdNOO+8t0pz78QTyxxBmYKhLXaAS03jKV7oy+DWGy1SeU+BZ8o7B8+hs9LvPdNA7B6NPGjrCm34A==";
    private const LAST_BLOCK_ID = '123456';

    /**
     * @var ClientInterface | MockObject
     */
    private $client;
    /**
     * @var SerializerInterface | MockObject
     */
    private $serializer;
    /**
     * @var OmsApi
     */
    private $api;

    protected function setUp()
    {
        parent::setUp();

        $this->client = $this->createMock(ClientInterface::class);

        $this->serializer = $this->createMock(SerializerInterface::class);


        $this->api = new OmsApi(
            $this->client,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->serializer
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );
    }

    public function testExceptionWithHttpCode(): void
    {
        $this->client

            ->method('request')
            ->willThrowException(new BadResponseException('Bad response', $this->createMock(RequestInterface::class)));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->expectException(OmsRequestErrorException::class);
        $this->api->getICBufferStatus(Extension::light(), self::TOKEN, self::OMS_ID, self::ORDER_ID, self::GTIN);
    }

    public function testGeneralException(): void
    {
        $this->client

            ->method('request')
            ->willThrowException(new \RuntimeException());

        $this->expectException(OmsGeneralErrorException::class);
        $this->api->getICBufferStatus(Extension::light(), self::TOKEN, self::OMS_ID, self::ORDER_ID, self::GTIN);
    }

    /**
     * @dataProvider dataCorrectUsageOfExtensions
     */
    public function testCorrectUsageOfExtensions(Extension $extension, string $extensionName): void
    {
        $this->client->expects($this->once())

            ->method('request')
            ->with(
                $this->anything(),
                sprintf('api/v2/%s/buffer/status', $extensionName),
                $this->anything()
            )
            ->willReturn(
                (new Response())
                    ->withBody(stream_for(self::API_RESPONSE))
            );

        $expectedResult = new GetICBufferStatusResponse('', '', '', 0, 0, 0, [], '');
        $this->serializer->expects($this->once())

            ->method('deserialize')
            ->willReturn($expectedResult);

        $this->api->getICBufferStatus($extension, self::TOKEN, self::OMS_ID, self::ORDER_ID, self::GTIN);
    }

    public function dataCorrectUsageOfExtensions(): array
    {
        return [
            [
                Extension::light(),
                'light',
            ],
            [
                Extension::pharma(),
                'pharma',
            ],
        ];
    }

    public function testCreateOrderForEmissionIC(): void
    {
        $createOrderForEmissionICRequestLight = new CreateOrderForEmissionICRequestLight(
            '',
            '',
            '',
            '',
            '',
            new \DateTimeImmutable(),
            []
        );

        $serializedRequest = '{"test": "value"}';

        $this->serializer->expects($this->once())

            ->method('serialize')
            ->with(
                $createOrderForEmissionICRequestLight
            )
            ->willReturn($serializedRequest);

        $this->client->expects($this->once())

            ->method('request')
            ->with(
                'POST',
                'api/v2/light/orders',
                [
                    RequestOptions::BODY => $serializedRequest,
                    RequestOptions::HEADERS => [
                        'Content-Type' => 'application/json',
                        'clientToken' => self::TOKEN,
                    ],
                    RequestOptions::QUERY => [
                        'omsId' => self::OMS_ID,
                    ],
                    RequestOptions::HTTP_ERRORS => true,
                ]
            )
            ->willReturn(
                (new Response())
                    ->withBody(stream_for(self::API_RESPONSE))
            );

        $expectedResult = new CreateOrderForEmissionICResponse(self::OMS_ID, self::ORDER_ID, 100);
        $this->serializer->expects($this->once())

            ->method('deserialize')
            ->with(
                CreateOrderForEmissionICResponse::class,
                self::API_RESPONSE
            )
            ->willReturn($expectedResult);


        $result = $this->api->createOrderForEmissionIC(
            Extension::light(),
            self::TOKEN,
            self::OMS_ID,
            $createOrderForEmissionICRequestLight
        );

        $this->assertEquals($expectedResult, $result);
    }

    public function testCreateOrderForEmissionICWithSignature(): void
    {
        $createOrderForEmissionICRequestLight = new CreateOrderForEmissionICRequestLight(
            '',
            '',
            '',
            '',
            '',
            new \DateTimeImmutable(),
            []
        );

        $serializedRequest = '{"test": "value"}';
        $signature = 'signature';

        $this->serializer->expects($this->once())

            ->method('serialize')
            ->with(
                $createOrderForEmissionICRequestLight
            )
            ->willReturn($serializedRequest);


        $this->client->expects($this->once())

            ->method('request')
            ->with(
                'POST',
                'api/v2/light/orders',
                [
                    RequestOptions::BODY => $serializedRequest,
                    RequestOptions::HEADERS => [
                        'Content-Type' => 'application/json',
                        'clientToken' => self::TOKEN,
                        'X-Signature' => $signature
                    ],
                    RequestOptions::QUERY => [
                        'omsId' => self::OMS_ID,
                    ],
                    RequestOptions::HTTP_ERRORS => true,
                ]
            )
            ->willReturn(
                (new Response())
                    ->withBody(stream_for(self::API_RESPONSE))
            );

        $expectedResult = new CreateOrderForEmissionICResponse(self::OMS_ID, self::ORDER_ID, 100);
        $this->serializer

            ->method('deserialize')
            ->willReturn($expectedResult);

        $signer = $this->createMock(SignerInterface::class);
        $signer->method('sign')
            ->with(base64_encode($serializedRequest))
            ->willReturn($signature);

        $result = $this->api->createOrderForEmissionIC(
            Extension::light(),
            self::TOKEN,
            self::OMS_ID,
            $createOrderForEmissionICRequestLight,
            $signer
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );

        $this->assertEquals($expectedResult, $result);
    }

    public function testCreateOrderForEmissionFinishedWithSignerException(): void
    {
        $createOrderForEmissionICRequestLight = new CreateOrderForEmissionICRequestLight(
            '',
            '',
            '',
            '',
            '',
            new \DateTimeImmutable(),
            []
        );

        $serializedRequest = '{"test": "value"}';

        $this->serializer->expects($this->once())

            ->method('serialize')
            ->with(
                $createOrderForEmissionICRequestLight
            )
            ->willReturn($serializedRequest);


        $this->client->expects($this->never())

            ->method('request');

        $signer = $this->createMock(SignerInterface::class);
        $signer->method('sign')
            ->willThrowException(new \Exception('Something happened in signer'));

        $this->expectException(OmsSignerErrorException::class);
        $this->api->createOrderForEmissionIC(
            Extension::light(),
            self::TOKEN,
            self::OMS_ID,
            $createOrderForEmissionICRequestLight,
            $signer
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );
    }

    public function testGetICBufferStatus(): void
    {
        $this->client->expects($this->once())

            ->method('request')
            ->with(
                'GET',
                'api/v2/light/buffer/status',
                [
                    RequestOptions::BODY => null,
                    RequestOptions::HEADERS => [
                        'Content-Type' => 'application/json',
                        'clientToken' => self::TOKEN,
                    ],
                    RequestOptions::QUERY => [
                        'omsId' => self::OMS_ID,
                        'orderId' => self::ORDER_ID,
                        'gtin' => self::GTIN,
                    ],
                    RequestOptions::HTTP_ERRORS => true,
                ]
            )
            ->willReturn(
                (new Response())
                    ->withBody(stream_for(self::API_RESPONSE))
            );

        $expectedResult = new GetICBufferStatusResponse('', '', '', 0, 0, 0, [], '');
        $this->serializer->expects($this->once())

            ->method('deserialize')
            ->with(
                GetICBufferStatusResponse::class,
                self::API_RESPONSE
            )
            ->willReturn($expectedResult);

        $result = $this->api->getICBufferStatus(Extension::light(), self::TOKEN, self::OMS_ID, self::ORDER_ID,
            self::GTIN);

        $this->assertEquals($expectedResult, $result);
    }

    public function testGetICsFromOrder(): void
    {
        $this->client->expects($this->once())

            ->method('request')
            ->with(
                'GET',
                'api/v2/light/codes',
                [
                    RequestOptions::BODY => null,
                    RequestOptions::HEADERS => [
                        'Content-Type' => 'application/json',
                        'clientToken' => self::TOKEN,
                    ],
                    RequestOptions::QUERY => [
                        'omsId' => self::OMS_ID,
                        'orderId' => self::ORDER_ID,
                        'gtin' => self::GTIN,
                        'quantity' => 2,
                        'lastBlockId' => '1',
                    ],
                    RequestOptions::HTTP_ERRORS => true,
                ]
            )
            ->willReturn(
                (new Response())
                    ->withBody(stream_for(self::API_RESPONSE))
            );

        $expectedResult = new GetICsFromOrderResponse(self::OMS_ID, [self::MARKING_CODE], '2');
        $this->serializer->expects($this->once())

            ->method('deserialize')
            ->with(
                GetICsFromOrderResponse::class,
                self::API_RESPONSE
            )
            ->willReturn($expectedResult);

        $result = $this->api->getICsFromOrder(Extension::light(), self::TOKEN, self::OMS_ID, self::ORDER_ID, self::GTIN,
            2, '1');

        $this->assertEquals($expectedResult, $result);
    }

    public function testCloseICArray(): void
    {
        $this->client->expects($this->once())

            ->method('request')
            ->with(
                'POST',
                'api/v2/light/buffer/close',
                [
                    RequestOptions::BODY => null,
                    RequestOptions::HEADERS => [
                        'Content-Type' => 'application/json',
                        'clientToken' => self::TOKEN,
                    ],
                    RequestOptions::QUERY => [
                        'omsId' => self::OMS_ID,
                        'orderId' => self::ORDER_ID,
                        'gtin' => self::GTIN,
                        'lastBlockId' => self::LAST_BLOCK_ID,
                    ],
                    RequestOptions::HTTP_ERRORS => true,
                ]
            )
            ->willReturn(
                (new Response())
                    ->withBody(stream_for(self::API_RESPONSE))
            );

        $expectedResult = new CloseICArrayResponse(self::OMS_ID);
        $this->serializer->expects($this->once())

            ->method('deserialize')
            ->with(
                CloseICArrayResponse::class,
                self::API_RESPONSE
            )
            ->willReturn($expectedResult);

        $result = $this->api->closeICArray(
            Extension::light(),
            self::TOKEN,
            self::OMS_ID,
            self::ORDER_ID,
            self::GTIN,
            self::LAST_BLOCK_ID
        );

        $this->assertEquals($expectedResult, $result);
    }

}

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Lamoda\OmsClient\Tests\V2;
6
7			use GuzzleHttp\ClientInterface;
8			use GuzzleHttp\Exception\BadResponseException;
9			use GuzzleHttp\Psr7\Response;
10			use GuzzleHttp\RequestOptions;
11			use Lamoda\OmsClient\Exception\OmsGeneralErrorException;
12			use Lamoda\OmsClient\Exception\OmsRequestErrorException;
13			use Lamoda\OmsClient\Exception\OmsSignerErrorException;
14			use Lamoda\OmsClient\Serializer\SerializerInterface;
15			use Lamoda\OmsClient\V2\Dto\CloseICArrayResponse;
16			use Lamoda\OmsClient\V2\Dto\CreateOrderForEmissionICRequestLight;
17			use Lamoda\OmsClient\V2\Dto\CreateOrderForEmissionICResponse;
18			use Lamoda\OmsClient\V2\Dto\GetICBufferStatusResponse;
19			use Lamoda\OmsClient\V2\Dto\GetICsFromOrderResponse;
20			use Lamoda\OmsClient\V2\Extension;
21			use Lamoda\OmsClient\V2\OmsApi;
22			use Lamoda\OmsClient\V2\Signer\SignerInterface;
23			use PHPUnit\Framework\Assert;
24			use PHPUnit\Framework\MockObject\MockObject;
25			use PHPUnit\Framework\TestCase;
26			use Psr\Http\Message\RequestInterface;
27			use function GuzzleHttp\Psr7\stream_for;
28
29			/**
30			* @covers \Lamoda\OmsClient\V2\OmsApi
31			*/
32			final class OmsApiTest extends TestCase
33			{
34			private const TOKEN = 'abcdefg12345678';
35			private const API_RESPONSE = '{stub_result}';
36			private const OMS_ID = '123456';
37			private const ORDER_ID = 'af7a55ae-83de-470b-a1bd-6bbf657106ef';
38			private const GTIN = '046000012345';
39			private const MARKING_CODE = "010467003301005321gJk6o54AQBJfX\u{001d}91ffd0\u{001d}92LGYcm3FRQrRdNOO+8t0pz78QTyxxBmYKhLXaAS03jKV7oy+DWGy1SeU+BZ8o7B8+hs9LvPdNA7B6NPGjrCm34A==";
40			private const LAST_BLOCK_ID = '123456';

lamoda / crpt-oms-api-client

Push — master ( 9d78ee...ff666c )

testCreateOrderForEmissionICWithSignature() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like