Add integration test case for formatting

Author: balthild

lib/Test/ChannelStream.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Phpactor\LanguageServer\Test;
+
+use Amp\ByteStream\ClosedException;
+use Amp\ByteStream\IteratorStream;
+use Amp\ByteStream\PendingReadError;
+use Amp\ByteStream\StreamException;
+use Amp\Emitter;
+use Amp\Promise;
+use Phpactor\LanguageServer\Core\Server\Stream\DuplexStream;
+
+final class ChannelStream implements DuplexStream
+{
+    private Emitter $emitter;
+
+    private IteratorStream $stream;
+
+    public function __construct()
+    {
+        $this->emitter = new Emitter();
+        $this->stream = new IteratorStream($this->emitter->iterate());
+    }
+
+    /**
+     * Reads data from the stream.
+     *
+     * @return Promise Resolves with a string when new data is available or `null` if the stream has closed.
+     *
+     * @psalm-return Promise<string|null>
+     *
+     * @throws PendingReadError Thrown if another read operation is still pending.
+     */
+    public function read(): Promise
+    {
+        return $this->stream->read();
+    }
+
+    /**
+     * Writes data to the stream.
+     *
+     * @param string $data Bytes to write.
+     *
+     * @return Promise Succeeds once the data has been successfully written to the stream.
+     *
+     * @throws ClosedException If the stream has already been closed.
+     * @throws StreamException If writing to the stream fails.
+     */
+    public function write(string $data): Promise
+    {
+        return $this->emitter->emit($data);
+    }
+
+    /**
+     * Marks the stream as no longer writable. Optionally writes a final data chunk before. Note that this is not the
+     * same as forcefully closing the stream. This method waits for all pending writes to complete before closing the
+     * stream. Socket streams implementing this interface should only close the writable side of the stream.
+     *
+     * @param string $finalData Bytes to write.
+     *
+     * @return Promise Succeeds once the data has been successfully written to the stream.
+     *
+     * @throws ClosedException If the stream has already been closed.
+     * @throws StreamException If writing to the stream fails.
+     */
+    public function end(string $finalData = ''): Promise
+    {
+        $promise = $this->emitter->emit($finalData);
+        $promise->onResolve(function (): void {
+            $this->emitter->complete();
+        });
+        return $promise;
+    }
+}

tests/Integration/Middleware/Handlers/FormattingHandlersTest.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Phpactor\LanguageServer\Tests\Integration\Middleware\Handlers;
+
+use Amp\Promise;
+use Generator;
+use Phpactor\LanguageServer\Adapter\Psr\AggregateEventDispatcher;
+use Phpactor\LanguageServer\Core\Handler\Handlers;
+use Phpactor\LanguageServer\Core\Rpc\RawMessage;
+use Phpactor\LanguageServer\Core\Server\Parser\LspMessageReader;
+use Phpactor\LanguageServer\Core\Server\Stream\DuplexStream;
+use Phpactor\LanguageServer\Core\Server\Transmitter\LspMessageFormatter;
+use Phpactor\LanguageServer\Core\Workspace\Workspace;
+use Phpactor\LanguageServer\Handler\TextDocument\FormattingHandler;
+use Phpactor\LanguageServer\Handler\TextDocument\TextDocumentHandler;
+use Phpactor\LanguageServer\Listener\WorkspaceListener;
+use Phpactor\LanguageServer\Test\ProtocolFactory;
+use Phpactor\LanguageServer\Tests\Unit\Handler\TextDocument\TestFormatter;
+use Phpactor\LanguageServer\Core\Rpc\RequestMessage;
+use PHPUnit\Framework\Assert;
+
+class FormattingHandlersTest extends HandlersTestCase
+{
+    /**
+     * @return Generator<Promise<string>>
+     */
+    public function testDispatchesFormattingRequest(): Generator
+    {
+        [$server, $stream] = yield $this->startServer($this->createHandlers());
+
+        $formatter = new LspMessageFormatter();
+        $reader = new LspMessageReader($stream);
+
+        $response = yield $this->dispatchRequest(
+            $stream,
+            $formatter,
+            $reader,
+            new RequestMessage(1, 'textDocument/didOpen', [
+                'textDocument' => [
+                    'uri' => 'file://foobar',
+                    'languageId' => 'php',
+                    'version' => 1,
+                    'text' => 'barfoo',
+                ],
+            ]),
+        );
+
+        Assert::assertArrayNotHasKey('error', $response->body());
+
+        $response = yield $this->dispatchRequest(
+            $stream,
+            $formatter,
+            $reader,
+            new RequestMessage(1, 'textDocument/formatting', [
+                'textDocument' => [
+                    'uri' => 'file://foobar',
+                ],
+                'options' => [
+                    'tabSize' => 4,
+                    'insertSpaces' => true,
+                ],
+            ]),
+        );
+
+        Assert::assertArrayNotHasKey('error', $response->body());
+
+        $server->shutdown();
+    }
+
+    /**
+     * @return Promise<RawMessage>
+     */
+    protected function dispatchRequest(
+        DuplexStream $stream,
+        LspMessageFormatter $formatter,
+        LspMessageReader $reader,
+        RequestMessage $request,
+    ): Promise {
+        return \Amp\call(function () use ($request, $stream, $formatter, $reader) {
+            $message = $formatter->format($request);
+            yield $stream->write($message);
+            return yield $reader->wait();
+        });
+    }
+
+    private function createHandlers(): Handlers
+    {
+        $workspace = new Workspace();
+        $formatter = new TestFormatter(
+            ProtocolFactory::textEdit(0, 0, 0, 0, 'Hello'),
+        );
+
+        $dispatcher = new AggregateEventDispatcher(
+            new WorkspaceListener($workspace),
+        );
+
+        return new Handlers(
+            new TextDocumentHandler($dispatcher),
+            new FormattingHandler($workspace, $formatter),
+        );
+    }
+}

tests/Integration/Middleware/Handlers/HandlersTestCase.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace Phpactor\LanguageServer\Tests\Integration\Middleware\Handlers;
+
+use Amp\Loop;
+use Amp\PHPUnit\AsyncTestCase;
+use Amp\Promise;
+use Phpactor\LanguageServer\Core\Dispatcher\ArgumentResolver\ChainArgumentResolver;
+use Phpactor\LanguageServer\Core\Dispatcher\ArgumentResolver\LanguageSeverProtocolParamsResolver;
+use Phpactor\LanguageServer\Core\Dispatcher\ArgumentResolver\PassThroughArgumentResolver;
+use Phpactor\LanguageServer\Core\Dispatcher\Dispatcher\MiddlewareDispatcher;
+use Phpactor\LanguageServer\Core\Dispatcher\DispatcherFactory;
+use Phpactor\LanguageServer\Core\Handler\HandlerMethodRunner;
+use Phpactor\LanguageServer\Core\Handler\Handlers;
+use Phpactor\LanguageServer\Middleware\CancellationMiddleware;
+use Phpactor\LanguageServer\Middleware\ErrorHandlingMiddleware;
+use Phpactor\LanguageServer\Middleware\HandlerMiddleware;
+use Phpactor\LanguageServer\Test\ChannelStream;
+use Phpactor\LanguageServer\Core\Dispatcher\Factory\ClosureDispatcherFactory;
+use Phpactor\LanguageServer\Core\Server\Initializer\PredefinedInitializer;
+use Phpactor\LanguageServer\Core\Server\LanguageServer;
+use Phpactor\LanguageServer\Core\Server\StreamProvider\ResourceStreamProvider;
+use Phpactor\LanguageServer\Core\Server\Stream\ResourceDuplexStream;
+use Psr\Log\LoggerInterface;
+
+abstract class HandlersTestCase extends AsyncTestCase
+{
+    /**
+     * @param Handlers $handlers The handlers to be registered with the server
+     * @param int $lifetime The server will be shut down after this amount of time in milliseconds
+     * @return Promise<array{LanguageServer, ChannelStream}>
+     */
+    protected function startServer(Handlers $handlers, int $lifetime = 10): Promise
+    {
+        return \Amp\call(function () use ($handlers, $lifetime) {
+            $requests = new ChannelStream();
+            $responses = new ChannelStream();
+
+            $serverStream = new ResourceDuplexStream($requests, $responses);
+            $clientStream = new ResourceDuplexStream($responses, $requests);
+
+            $logger = $this->createMock(LoggerInterface::class);
+            $server = new LanguageServer(
+                $this->createDispatcherFactory($handlers),
+                $logger,
+                new ResourceStreamProvider($serverStream, $logger),
+                new PredefinedInitializer()
+            );
+
+            Loop::delay($lifetime, function () use ($server) {
+                yield $server->shutdown();
+            });
+
+            yield $server->start();
+
+            return [$server, $clientStream];
+        });
+    }
+
+    private function createDispatcherFactory(Handlers $handlers): DispatcherFactory
+    {
+        $logger = $this->createMock(LoggerInterface::class);
+
+        $runner = new HandlerMethodRunner(
+            $handlers,
+            new ChainArgumentResolver(
+                new LanguageSeverProtocolParamsResolver(),
+                new PassThroughArgumentResolver(),
+            ),
+        );
+
+        return new ClosureDispatcherFactory(
+            fn () => new MiddlewareDispatcher(
+                new ErrorHandlingMiddleware($logger),
+                new CancellationMiddleware($runner),
+                new HandlerMiddleware($runner),
+            ),
+        );
+    }
+}