restructure client api to use streams

pkg/analysis_server/test/mocks.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library mocks;
 
+import 'dart:async';
+import 'dart:convert';
 import 'dart:io';
-import 'dart:async';
 
 /**
- * A mock [WebSocket] that immediately passes data to the listener.
+ * A mock [WebSocket] for testing.
  */
 class MockSocket<T> implements WebSocket {

[Bob Nystrom, 2014/03/04 01:03:45]

I wonder if you can extend Stream here too and have this class just be a Stream,
instead of having to implement all of the Stream methods and forward?

I haven't tried to see how well subclassing it works.

-  var onData;
+
+  final JsonEncoder jsonEncoder = const JsonEncoder(null);
+
+  final JsonDecoder jsonDecoder = const JsonDecoder(null);

[Bob Nystrom, 2014/03/04 01:03:45]

You can probably just using the top-level "JSON" object in dart:convert instead
of storing your own instances here.

+
+  StreamController controller = new StreamController();
+  MockSocket twin;
+  Stream stream;
+
+  factory MockSocket.pair() {
+    MockSocket socket1 = new MockSocket();
+    MockSocket socket2 = new MockSocket();

[Bob Nystrom, 2014/03/04 01:03:45]

I prefer using "var" for locals. Fortunately, there's this really nice analyzer
than can infer the type from the initializer. :)

+    socket1.twin = socket2;
+    socket2.twin = socket1;
+    socket1.stream = socket2.controller.stream;
+    socket2.stream = socket1.controller.stream;
+    return socket1;
+  }
+
+  MockSocket();
+
+  void add(T text) => controller.add(text);
+
+  void allowMultipleListeners() {
+    stream = stream.asBroadcastStream();
+  }
+
   StreamSubscription<T> listen(void onData(T event),
-                     {Function onError, void onDone(), bool cancelOnError}) {
-    this.onData = onData;
-    return null;
-  }
-  void add(T event) => onData(event);
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
+                     { Function onError, void onDone(), bool cancelOnError}) =>
+    stream.listen(onData, onError: onError, onDone: onDone,
+        cancelOnError: cancelOnError);
 
-/**
- * A mock [WebSocket] for sending invalid JSON data and counting responses.
- */
-class InvalidJsonMockSocket<T> implements WebSocket {
-  int responseCount = 0;
-  var onData;
-  StreamSubscription<T> listen(void onData(T event),
-                     {Function onError, void onDone(), bool cancelOnError}) {
-    this.onData = onData;
-    return null;
-  }
-  void addInvalid(T event) => onData(event);
-  void add(T event) { responseCount++; }
+  Stream<T> where(bool test(T)) => stream.where(test);

[Bob Nystrom, 2014/03/04 01:03:45]

If you're going to forward these, it feels like you should forward all of them.

It would be nice if there was a forwarding mixing for these. The collection
package has something similar for the sync collection types.

+
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }