Session::sendMessageAsync() - Code Metrics - Inspection of "Integration test" - Bit-Wasp/trezor-bridge-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#12)

by thomas

created 2018-04-09 22:24 UTC

Session::sendMessageAsync() A

↳ Parent: Session

Complexity

Conditions	2
Paths	1

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	11
ccs	6
cts	6
cp	1
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	7
nc	1
nop	1
crap	2

<?php

declare(strict_types=1);

namespace BitWasp\Trezor\Bridge;

use BitWasp\Trezor\Bridge\Exception\InactiveSessionException;
use BitWasp\Trezor\Bridge\Message\Device;
use BitWasp\Trezor\Device\Exception\FailureException;
use BitWasp\Trezor\Device\Message;
use BitWasp\Trezor\Device\MessageBase;
use BitWasp\TrezorProto\Failure;
use GuzzleHttp\Promise\PromiseInterface;
use Protobuf\Message as ProtoMessage;

class Session
{
    /**
     * @var Client
     */
    private $client;

    /**
     * @var Device
     */
    private $device;

    /**
     * @var string
     */
    private $sessionId;

    /**
     * @var bool
     */
    private $active = true;

    /**
     * Session constructor.
     * @param Client $client
     * @param Device $device
     * @param string $sessionId
     */
    public function __construct(Client $client, Device $device, string $sessionId)
    {
        $this->client = $client;
        $this->device = $device;
        $this->sessionId = $sessionId;
    }

    /**
     * @throws InactiveSessionException
     */
    private function assertSessionIsActive()
    {
        if (!$this->active) {
            throw new InactiveSessionException("Attempted command on inactive session");
        }
    }

    /**
     * @return bool
     */
    public function isActive(): bool
    {
        return $this->active;
    }

    /**
     * @throws InactiveSessionException
     */
    public function release()
    {
        $this->assertSessionIsActive();
        $this->client->release($this->sessionId);
        $this->active = false;
    }

    /**
     * @return string
     * @throws InactiveSessionException
     */
    public function getSessionId(): string
    {
        $this->assertSessionIsActive();
        return $this->sessionId;
    }

    /**
     * @return Device
     */
    public function getDevice(): Device
    {
        return $this->device;
    }
    /**
     * @param MessageBase $message
     * @return ProtoMessage
     * @throws FailureException
     * @throws InactiveSessionException
     */
    public function sendMessageAsync(MessageBase $request): PromiseInterface
    {
        $this->assertSessionIsActive();
        return $this->client->callAsync($this->getSessionId(), $request)

            ->then(function (Message $message) use ($request) {

                $proto = $message->getProto();
                if ($proto instanceof Failure) {
                    FailureException::handleFailure($proto);
                }

                return $proto;
            });
    }

    /**
     * @param MessageBase $message
     * @return ProtoMessage
     * @throws FailureException
     * @throws InactiveSessionException
     */
    public function sendMessage(MessageBase $message): ProtoMessage
    {
        $this->assertSessionIsActive();
        return $this->sendMessageAsync($message)
            ->wait(true);
    }

    /**
     * @param MessageBase $message
     * @throws FailureException
     * @throws InactiveSessionException
     */
    public function postMessage(MessageBase $message)
    {
        $this->assertSessionIsActive();
        return $this->client->post($this->getSessionId(), $message);
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace BitWasp\Trezor\Bridge;
6
7		use BitWasp\Trezor\Bridge\Exception\InactiveSessionException;
8		use BitWasp\Trezor\Bridge\Message\Device;
9		use BitWasp\Trezor\Device\Exception\FailureException;
10		use BitWasp\Trezor\Device\Message;
11		use BitWasp\Trezor\Device\MessageBase;
12		use BitWasp\TrezorProto\Failure;
13		use GuzzleHttp\Promise\PromiseInterface;
14		use Protobuf\Message as ProtoMessage;
15
16		class Session
17		{
18		/**
19		* @var Client
20		*/
21		private $client;
22
23		/**
24		* @var Device
25		*/
26		private $device;
27
28		/**
29		* @var string
30		*/
31		private $sessionId;
32
33		/**
34		* @var bool
35		*/
36		private $active = true;
37
38		/**
39		* Session constructor.
40		* @param Client $client
41		* @param Device $device
42	32	* @param string $sessionId
43		*/
44	32	public function __construct(Client $client, Device $device, string $sessionId)
45	32	{
46	32	$this->client = $client;
47	32	$this->device = $device;
48		$this->sessionId = $sessionId;
49		}
50
51		/**
52	32	* @throws InactiveSessionException
53		*/
54	32	private function assertSessionIsActive()
55	1	{
56		if (!$this->active) {
57	32	throw new InactiveSessionException("Attempted command on inactive session");
58		}
59		}
60
61		/**
62	2	* @return bool
63		*/
64	2	public function isActive(): bool
65		{
66		return $this->active;
67		}
68
69		/**
70	2	* @throws InactiveSessionException
71		*/
72	2	public function release()
73	2	{
74	2	$this->assertSessionIsActive();
75	2	$this->client->release($this->sessionId);
76		$this->active = false;
77		}
78
79		/**
80		* @return string
81	30	* @throws InactiveSessionException
82		*/
83	30	public function getSessionId(): string
84	30	{
85		$this->assertSessionIsActive();
86		return $this->sessionId;
87		}
88
89		/**
90	2	* @return Device
91		*/
92	2	public function getDevice(): Device
93		{
94		return $this->device;
95		}
96		/**
97		* @param MessageBase $message
98		* @return ProtoMessage
99		* @throws FailureException
100		* @throws InactiveSessionException
101	29	*/
102		public function sendMessageAsync(MessageBase $request): PromiseInterface
103	29	{
104	28	$this->assertSessionIsActive();
105	28	return $this->client->callAsync($this->getSessionId(), $request)
		0 ignored issues – show Bug Best Practice introduced 2018-04-09 22:41 UTC by Report Bug Copy Issue Report The expression `return $this->client->ca...ion(...) { /* ... */ })` returns the type `GuzzleHttp\Promise\PromiseInterface` which is incompatible with the documented return type `Protobuf\Message`. Loading history...
106	28	->then(function (Message $message) use ($request) {
		0 ignored issues – show Unused Code introduced 2018-04-09 22:41 UTC by Report Bug Copy Issue Report The import `$request` is not used and could be removed. This check looks for imports that have been defined, but are not used in the scope. Loading history...
107	1	$proto = $message->getProto();
108		if ($proto instanceof Failure) {
109		FailureException::handleFailure($proto);
110	28	}
111
112		return $proto;
113		});
114		}
115
116		/**
117		* @param MessageBase $message
118		* @return ProtoMessage
119		* @throws FailureException
120		* @throws InactiveSessionException
121		*/
122		public function sendMessage(MessageBase $message): ProtoMessage
123		{
124		$this->assertSessionIsActive();
125		return $this->sendMessageAsync($message)
126		->wait(true);
127		}
128
129		/**
130		* @param MessageBase $message
131		* @throws FailureException
132		* @throws InactiveSessionException
133		*/
134		public function postMessage(MessageBase $message)
135		{
136		$this->assertSessionIsActive();
137		return $this->client->post($this->getSessionId(), $message);
138		}
139		}
140

Bit-Wasp / trezor-bridge-client

Pull Request — master (#12)

Session::sendMessageAsync() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like