9555551525

Committed 17 Jun 2024 10:16PM UTC coverage: 70.262% (-1.1%) from 71.395%

Build # 9555551525

Build Type

push

github

Committed by

prolic

Commit Message

update coveralls repo token

Run Details

3466 of 4933 relevant lines covered (70.26%)

67.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.36

/src/ClientOperations/ReadAllEventsBackwardOperation.php

<?php

/**
 * This file is part of `prooph/event-store-client`.
 * (c) 2018-2024 Alexander Miertsch <kontakt@codeliner.ws>
 * (c) 2018-2024 Sascha-Oliver Prolic <saschaprolic@googlemail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Prooph\EventStoreClient\ClientOperations;

use Amp\DeferredFuture;
use Google\Protobuf\Internal\Message;
use Prooph\EventStore\AllEventsSlice;
use Prooph\EventStore\Exception\AccessDenied;
use Prooph\EventStore\Exception\ServerError;
use Prooph\EventStore\Position;
use Prooph\EventStore\ReadDirection;
use Prooph\EventStore\ResolvedEvent;
use Prooph\EventStore\UserCredentials;
use Prooph\EventStoreClient\Internal\EventMessageConverter;
use Prooph\EventStoreClient\Messages\ClientMessages\ReadAllEvents;
use Prooph\EventStoreClient\Messages\ClientMessages\ReadAllEventsCompleted;
use Prooph\EventStoreClient\Messages\ClientMessages\ReadAllEventsCompleted\ReadAllResult;
use Prooph\EventStoreClient\SystemData\InspectionDecision;
use Prooph\EventStoreClient\SystemData\InspectionResult;
use Prooph\EventStoreClient\SystemData\TcpCommand;
use Psr\Log\LoggerInterface as Logger;

/**
 * @internal
 * @extends AbstractOperation<ReadAllEventsCompleted, AllEventsSlice>
 */
class ReadAllEventsBackwardOperation extends AbstractOperation
{
    public function __construct(
        Logger $logger,
        DeferredFuture $deferred,
        private readonly bool $requireMaster,
        private readonly Position $position,
        private readonly int $maxCount,
        private readonly bool $resolveLinkTos,
        ?UserCredentials $userCredentials
    ) {
        parent::__construct(
            $logger,
            $deferred,
            $userCredentials,
            TcpCommand::ReadAllEventsBackward,
            TcpCommand::ReadAllEventsBackwardCompleted,
            ReadAllEventsCompleted::class
        );
    }

    protected function createRequestDto(): Message
    {
        $message = new ReadAllEvents();
        $message->setRequireMaster($this->requireMaster);
        $message->setCommitPosition($this->position->commitPosition());
        $message->setPreparePosition($this->position->preparePosition());
        $message->setMaxCount($this->maxCount);
        $message->setResolveLinkTos($this->resolveLinkTos);

        return $message;
    }

    /**
     * @param ReadAllEventsCompleted $response
     * @return InspectionResult
     */
    protected function inspectResponse(Message $response): InspectionResult
    {
        switch ($response->getResult()) {
            case ReadAllResult::Success:
                $this->succeed($response);

                return new InspectionResult(InspectionDecision::EndOperation, 'Success');
            case ReadAllResult::Error:
                $this->fail(new ServerError($response->getError()));

                return new InspectionResult(InspectionDecision::EndOperation, 'Error');
            case
            ReadAllResult::AccessDenied:
                $this->fail(AccessDenied::toAllStream());

                return new InspectionResult(InspectionDecision::EndOperation, 'AccessDenied');
            default:
                throw new ServerError('Unexpected ReadAllResult');
        }
    }

    /**
     * @param ReadAllEventsCompleted $response
     * @return AllEventsSlice
     */
    protected function transformResponse(Message $response): AllEventsSlice
    {
        $resolvedEvents = [];

        foreach ($response->getEvents() as $record) {
            $resolvedEvents[] = new ResolvedEvent(
                EventMessageConverter::convertEventRecordMessageToEventRecord($record->getEvent()),
                EventMessageConverter::convertEventRecordMessageToEventRecord($record->getLink()),
                new Position(
                    $record->getCommitPosition(),
                    $record->getPreparePosition()
                )
            );
        }

        return new AllEventsSlice(
            ReadDirection::Backward,
            new Position((int) $response->getCommitPosition(), (int) $response->getPreparePosition()),
            new Position((int) $response->getNextCommitPosition(), (int) $response->getNextPreparePosition()),
            $resolvedEvents
        );
    }

    public function name(): string
    {
        return 'ReadAllEventsBackward';
    }

    public function __toString(): string
    {
        return \sprintf(
            'Position: %s, MaxCount: %d, ResolveLinkTos: %s, RequireMaster: %s',
            (string) $this->position,
            $this->maxCount,
            $this->resolveLinkTos ? 'yes' : 'no',
            $this->requireMaster ? 'yes' : 'no'
        );
    }
}

1	<?php
2
3	/**
4	* This file is part of `prooph/event-store-client`.
5	* (c) 2018-2024 Alexander Miertsch <kontakt@codeliner.ws>
6	* (c) 2018-2024 Sascha-Oliver Prolic <saschaprolic@googlemail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace Prooph\EventStoreClient\ClientOperations;
15
16	use Amp\DeferredFuture;
17	use Google\Protobuf\Internal\Message;
18	use Prooph\EventStore\AllEventsSlice;
19	use Prooph\EventStore\Exception\AccessDenied;
20	use Prooph\EventStore\Exception\ServerError;
21	use Prooph\EventStore\Position;
22	use Prooph\EventStore\ReadDirection;
23	use Prooph\EventStore\ResolvedEvent;
24	use Prooph\EventStore\UserCredentials;
25	use Prooph\EventStoreClient\Internal\EventMessageConverter;
26	use Prooph\EventStoreClient\Messages\ClientMessages\ReadAllEvents;
27	use Prooph\EventStoreClient\Messages\ClientMessages\ReadAllEventsCompleted;
28	use Prooph\EventStoreClient\Messages\ClientMessages\ReadAllEventsCompleted\ReadAllResult;
29	use Prooph\EventStoreClient\SystemData\InspectionDecision;
30	use Prooph\EventStoreClient\SystemData\InspectionResult;
31	use Prooph\EventStoreClient\SystemData\TcpCommand;
32	use Psr\Log\LoggerInterface as Logger;
33
34	/**
35	* @internal
36	* @extends AbstractOperation<ReadAllEventsCompleted, AllEventsSlice>
37	*/
38	class ReadAllEventsBackwardOperation extends AbstractOperation
39	{
40	public function __construct(
41	Logger $logger,
42	DeferredFuture $deferred,
43	private readonly bool $requireMaster,
44	private readonly Position $position,
45	private readonly int $maxCount,
46	private readonly bool $resolveLinkTos,
47	?UserCredentials $userCredentials
48	) {
49	parent::__construct(	18✔
50	$logger,	18✔
51	$deferred,	18✔
52	$userCredentials,	18✔
53	TcpCommand::ReadAllEventsBackward,	18✔
54	TcpCommand::ReadAllEventsBackwardCompleted,	18✔
55	ReadAllEventsCompleted::class	18✔
56	);	18✔
57	}
58
59	protected function createRequestDto(): Message
60	{
61	$message = new ReadAllEvents();	17✔
62	$message->setRequireMaster($this->requireMaster);	17✔
63	$message->setCommitPosition($this->position->commitPosition());	17✔
64	$message->setPreparePosition($this->position->preparePosition());	17✔
65	$message->setMaxCount($this->maxCount);	17✔
66	$message->setResolveLinkTos($this->resolveLinkTos);	17✔
67
68	return $message;	17✔
69	}
70
71	/**
72	* @param ReadAllEventsCompleted $response
73	* @return InspectionResult
74	*/
75	protected function inspectResponse(Message $response): InspectionResult
76	{
77	switch ($response->getResult()) {	17✔
78	case ReadAllResult::Success:
79	$this->succeed($response);	17✔
80
81	return new InspectionResult(InspectionDecision::EndOperation, 'Success');	17✔
82	case ReadAllResult::Error:
83	$this->fail(new ServerError($response->getError()));	×
84
85	return new InspectionResult(InspectionDecision::EndOperation, 'Error');	×
86	case
87	ReadAllResult::AccessDenied:
88	$this->fail(AccessDenied::toAllStream());	×
89
90	return new InspectionResult(InspectionDecision::EndOperation, 'AccessDenied');	×
91	default:
92	throw new ServerError('Unexpected ReadAllResult');	×
93	}
94	}
95
96	/**
97	* @param ReadAllEventsCompleted $response
98	* @return AllEventsSlice
99	*/
100	protected function transformResponse(Message $response): AllEventsSlice
101	{
102	$resolvedEvents = [];	17✔
103
104	foreach ($response->getEvents() as $record) {	17✔
105	$resolvedEvents[] = new ResolvedEvent(	17✔
106	EventMessageConverter::convertEventRecordMessageToEventRecord($record->getEvent()),	17✔
107	EventMessageConverter::convertEventRecordMessageToEventRecord($record->getLink()),	17✔
108	new Position(	17✔
109	$record->getCommitPosition(),	17✔
110	$record->getPreparePosition()	17✔
111	)	17✔
112	);	17✔
113	}
114
115	return new AllEventsSlice(	17✔
116	ReadDirection::Backward,	17✔
117	new Position((int) $response->getCommitPosition(), (int) $response->getPreparePosition()),	17✔
118	new Position((int) $response->getNextCommitPosition(), (int) $response->getNextPreparePosition()),	17✔
119	$resolvedEvents	17✔
120	);	17✔
121	}
122
123	public function name(): string
124	{
125	return 'ReadAllEventsBackward';	17✔
126	}
127
128	public function __toString(): string
129	{
130	return \sprintf(	17✔
131	'Position: %s, MaxCount: %d, ResolveLinkTos: %s, RequireMaster: %s',	17✔
132	(string) $this->position,	17✔
133	$this->maxCount,	17✔
134	$this->resolveLinkTos ? 'yes' : 'no',	17✔
135	$this->requireMaster ? 'yes' : 'no'	17✔
136	);	17✔
137	}
138	}

prooph / event-store-client / 9555551525

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous