Start hacking together a test

- Add a stub for `lsc#workspace#byMarker()` to make it easier to write
  the tests.
- Read client capabilities in `StubServer`.
- Outline some tests. Add a test reading client capabilities.

autoload/lsc/workspace.vim

@@ -1,3 +1,12 @@
+function! lsc#workspace#byMarker() abort
+  " TODO
+  return function('<SID>Cheat')
+endfunction
+
+function! s:Cheat(file_path) abort
+  return fnamemodify(a:file_path, ':h')
+endfunction
+
 function! lsc#workspace#findMarker(file_path, markers) abort
   for l:path in s:ParentDirectories(a:file_path)
     if s:ContainsAny(l:path, a:markers) | return l:path | endif

test/integration/lib/stub_lsp.dart

@@ -4,10 +4,13 @@ import 'package:json_rpc_2/json_rpc_2.dart';
 
 class StubServer {
   final Peer peer;
+  Future<Map<String, dynamic>> get initialization => _initialization.future;
+  final _initialization = Completer<Map<String, dynamic>>();
 
   StubServer(this.peer, {Map<String, dynamic> capabilities = const {}}) {
     peer
-      ..registerMethod('initialize', (_) {
+      ..registerMethod('initialize', (Parameters p) {
+        _initialization.complete(p.asMap.cast<String, dynamic>());
         return {'capabilities': capabilities};
       })
       ..registerMethod('initialized', (_) {

test/integration/lib/test_bed.dart

@@ -13,15 +13,17 @@ class TestBed {
   TestBed._(this.vim, this.clients);
 
   static Future<TestBed> setup(
-      {Future<void> Function(Vim) beforeRegister, String config = ''}) async {
+      {Future<void> Function(Vim) beforeRegister,
+      String config = '',
+      String workingDirectory}) async {
     final serverSocket = await ServerSocket.bind('localhost', 0);
 
     final clients = serverSocket
         .map((socket) => Peer(lspChannel(socket, socket),
             onUnhandledError: (error, stack) =>
                 fail('Unhandled server error: $error')))
         .asBroadcastStream();
-    final vim = await Vim.start();
+    final vim = await Vim.start(workingDirectory: workingDirectory);
     await beforeRegister?.call(vim);
     await vim.expr('RegisterLanguageServer("text", {'
         '"command":"localhost:${serverSocket.port}",'

test/integration/lib/vim_remote.dart

@@ -6,12 +6,13 @@ class Vim {
   final String name;
   final Process _process;
 
-  static Future<Vim> start() async {
+  static Future<Vim> start({String workingDirectory}) async {
     final version = (await Process.run('vim', ['--version'])).stdout as String;
     assert(version.contains('+clientserver'));
     final name = 'DARTVIM-${Random().nextInt(4294967296)}';
     final process = await Process.start(
         'vim', ['--servername', name, '-u', 'vimrc', '-U', 'NONE', '-V$name'],
+        workingDirectory: workingDirectory,
         mode: ProcessStartMode.detachedWithStdio);
     while (!await _isRunning(name)) {
       await Future.delayed(const Duration(milliseconds: 100));

test/integration/pubspec.yaml

@@ -9,3 +9,4 @@ dependencies:
   lsp: ^0.1.1
   path: ^1.7.0
   test: ^1.13.0
+  test_descriptor: ^1.2.0

test/integration/test/workspace_folders_test.dart

@@ -0,0 +1,170 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:async/async.dart';
+import 'package:_test/stub_lsp.dart';
+import 'package:_test/test_bed.dart';
+import 'package:json_rpc_2/json_rpc_2.dart';
+import 'package:test/test.dart';
+import 'package:test_descriptor/test_descriptor.dart' as d;
+
+void main() {
+  group('WorkspaceRoot configured', () {
+    TestBed testBed;
+    Peer client;
+
+    setUpAll(() async {
+      await d.dir('workspaces', [
+        d.dir('foo', [
+          d.file('makefile'),
+          d.dir('lib', [d.file('foo.txt')])
+        ]),
+        d.dir('bar', [
+          d.file('makefile'),
+          d.dir('lib', [d.file('bar.txt')])
+        ])
+      ]).create();
+      testBed = await TestBed.setup(
+        config: '"WorkspaceRoot": lsc#workspace#byMarker(),',
+        workingDirectory: d.sandbox,
+      );
+    });
+
+    setUp(() async {
+      final nextClient = testBed.clients.first;
+      await testBed.vim.edit('workspaces/lib/foo.txt');
+      await testBed.vim.sendKeys(':LSClientEnable<cr>');
+      client = await nextClient;
+    });
+
+    tearDown(() async {
+      await testBed.vim.sendKeys(':LSClientDisable<cr>');
+      await testBed.vim.sendKeys(':%bwipeout!<cr>');
+      await client.done;
+      client = null;
+    });
+
+    test('configuration honored in initialization', () async {
+      final server = StubServer(client);
+
+      await server.initialized;
+      final initialization = await server.initialization;
+      expect(initialization['capabilities']['workspace']['workspaceFolders'],
+          true);
+      expect(initialization['workspaceFolders'], [
+        {'uri': 'some uri', 'name': anything}
+      ]);
+    });
+
+    test('does not send notificaiton without capability', () async {
+      final server = StubServer(client, capabilities: {
+        'workspace': {
+          'workspaceFolders': {
+            'supported': true,
+            'changeNotifications': false,
+          }
+        }
+      });
+
+      server.peer.registerMethod('workspace/didChangeWorkspaceFolders',
+          (Parameters p) {
+        fail('Unexpected call to didChangeWorkspaceFolders');
+      });
+      // TODO
+    });
+
+    test('Deregister test', () async {
+      // TODO, no support for this at all today
+      // final server = StubServer(client, capabilities: {
+      //   'workspace': {
+      //     'workspacefolders': {
+      //       'supported': true,
+      //       'changenotifications': 'something?',
+      //     }
+      //   }
+      // });
+    });
+
+    test('sends notifications with capability', () async {
+      final server = StubServer(client, capabilities: {
+        'workspace': {
+          'workspaceFolders': {
+            'supported': true,
+            'changeNotifications': true,
+          }
+        }
+      });
+
+      final changeController = StreamController<Map<String, dynamic>>();
+      final changeEvents = StreamQueue(changeController.stream);
+      server.peer.registerMethod('workspace/didChangeWorkspaceFolders',
+          (Parameters p) {
+        changeController.add(p['event'].asMap.cast<String, dynamic>());
+      });
+
+      await server.initialized;
+
+      await testBed.vim.edit('workspaces/bar/bar.txt');
+
+      final change = await changeEvents.next;
+      expect(change['removed'], isEmpty);
+      expect(change['added'], [
+        {'uri': 'some uri', 'name': anything}
+      ]);
+
+      // TODO
+    });
+  });
+
+  group('WorkspaceRoot throws', () {
+    // TODO
+
+    test('can handle a WorkspaceRoot that throws', () async {
+      // TODO
+    });
+  });
+
+  group('No WorkspaceRoot configured', () {
+    TestBed testBed;
+    Peer client;
+
+    setUpAll(() async {
+      testBed = await TestBed.setup();
+      await d.dir('workspaces', [
+        d.dir('foo', [
+          d.file('makefile'),
+          d.dir('lib', [d.file('foo.txt')])
+        ]),
+        d.dir('bar', [
+          d.file('makefile'),
+          d.dir('lib', [d.file('bar.txt')])
+        ])
+      ]).create();
+    });
+
+    setUp(() async {
+      final nextClient = testBed.clients.first;
+      await testBed.vim.edit('foo.txt');
+      await testBed.vim.sendKeys(':LSClientEnable<cr>');
+      client = await nextClient;
+    });
+
+    tearDown(() async {
+      await testBed.vim.sendKeys(':LSClientDisable<cr>');
+      await testBed.vim.sendKeys(':%bwipeout!<cr>');
+      final file = File('foo.txt');
+      if (await file.exists()) await file.delete();
+      await client.done;
+      client = null;
+    });
+
+    test('does not advertise capability', () async {
+      final server = StubServer(client);
+
+      await server.initialized;
+      final initialization = await server.initialization;
+      expect(initialization['capabilities']['workspace']['workspaceFolders'],
+          false);
+    });
+  });
+}