Merge IO v2 branch to bleeding edge

utils/tests/pub/test_pub.dart

 // Copyright (c) 2012, 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.
 
 /// Test infrastructure for testing pub. Unlike typical unit tests, most pub
 /// tests are integration tests that stage some stuff on the file system, run
 /// pub, and then validate the results. This library provides an API to build
 /// tests like that.
 library test_pub;
 
@@ skipping 84 matching lines @@
 
 /// Creates an HTTP server to serve [contents] as static files. This server will
 /// exist only for the duration of the pub run.
 ///
 /// Subsequent calls to [serve] will replace the previous server.
 void serve([List<Descriptor> contents]) {
   var baseDir = dir("serve-dir", contents);
 
   _schedule((_) {
     return _closeServer().then((_) {
-      _server = new HttpServer();
-      _server.defaultRequestHandler = (request, response) {
-        var path = request.uri.replaceFirst("/", "").split("/");
-        response.persistentConnection = false;
-        var stream;
-        try {
-          stream = baseDir.load(path);
-        } catch (e) {
-          response.statusCode = 404;
-          response.contentLength = 0;
-          response.outputStream.close();
-          return;
-        }
+      return HttpServer.bind("127.0.0.1", 0).then((server) {
+        _server = server;
+        server.listen((request) {
+          var response = request.response;
+          var path = request.uri.path.replaceFirst("/", "").split("/");
+          response.persistentConnection = false;
+          var stream;
+          try {
+            stream = baseDir.load(path);
+          } catch (e) {
+            response.statusCode = 404;
+            response.contentLength = 0;
+            response.close();
+            return;
+          }
 
-        stream.toBytes().then((data) {
-          response.statusCode = 200;
-          response.contentLength = data.length;
-          response.outputStream.write(data);
-          response.outputStream.close();
-        }).catchError((e) {
-          print("Exception while handling ${request.uri}: $e");
-          response.statusCode = 500;
-          response.reasonPhrase = e.message;
-          response.outputStream.close();
+          stream.toBytes().then((data) {
+            response.statusCode = 200;
+            response.contentLength = data.length;
+            response.add(data);
+            response.close();
+          }).catchError((e) {
+            print("Exception while handling ${request.uri}: $e");
+            response.statusCode = 500;
+            response.reasonPhrase = e.message;
+            response.close();
+          });
         });
-      };
-      _server.listen("127.0.0.1", 0);
-      _portCompleter.complete(_server.port);
-      _scheduleCleanup((_) => _closeServer());
-      return null;
+        _portCompleter.complete(_server.port);
+        _scheduleCleanup((_) => _closeServer());
+        return null;
+      });
     });
   });
 }
 
 /// Closes [_server]. Returns a [Future] that will complete after the [_server]
 /// is closed.
 Future _closeServer() {
   if (_server == null) return new Future.immediate(null);
   _server.close();
   _server = null;
@@ skipping 315 matching lines @@
 
 /// The path of the packages directory in the mock app used for tests. Relative
 /// to the sandbox directory.
 final String packagesPath = "$appPath/packages";
 
 /// The type for callbacks that will be fired during [schedulePub]. Takes the
 /// sandbox directory as a parameter.
 typedef Future _ScheduledEvent(String parentDir);
 
 /// The list of events that are scheduled to run as part of the test case.
-List<_ScheduledEvent> _scheduled;
+Queue<_ScheduledEvent> _scheduled;
 
 /// The list of events that are scheduled to run after the test case, even if
 /// it failed.
-List<_ScheduledEvent> _scheduledCleanup;
+Queue<_ScheduledEvent> _scheduledCleanup;
 
 /// The list of events that are scheduled to run after the test case only if it
 /// failed.
-List<_ScheduledEvent> _scheduledOnException;
+Queue<_ScheduledEvent> _scheduledOnException;
 
 /// Set to true when the current batch of scheduled events should be aborted.
 bool _abortScheduled = false;
 
 /// The time (in milliseconds) to wait for the entire scheduled test to
 /// complete.
 final _TIMEOUT = 30000;
 
 /// Defines an integration test. The [body] should schedule a series of
 /// operations which will be run asynchronously.
@@ skipping 208 matching lines @@
 /// Note that this will only affect HTTP requests made via http.dart in the
 /// parent process.
 void useMockClient(MockClient client) {
   var oldInnerClient = httpClient.inner;
   httpClient.inner = client;
   _scheduleCleanup((_) {
     httpClient.inner = oldInnerClient;
   });
 }
 
-Future _runScheduled(List<_ScheduledEvent> scheduled) {
+Future _runScheduled(Queue<_ScheduledEvent> scheduled) {
   if (scheduled == null) return new Future.immediate(null);
-  var iterator = scheduled.iterator;
 
   Future runNextEvent(_) {
-    if (_abortScheduled || !iterator.moveNext()) {
+    if (_abortScheduled || scheduled.isEmpty) {
       _abortScheduled = false;
-      scheduled.clear();
       return new Future.immediate(null);
     }
 
-    var future = iterator.current(_sandboxDir);
+    var future = scheduled.removeFirst()(_sandboxDir);
     if (future != null) {
       return future.then(runNextEvent);
     } else {
       return runNextEvent(null);
     }
   }
 
   return runNextEvent(null);
 }
 
@@ skipping 419 matching lines @@
   /// Loads the contents of this tar file.
   ByteStream load(List<String> path) {
     if (!path.isEmpty) {
       throw "Can't load ${path.join('/')} from within $name: not a directory.";
     }
 
     var controller = new StreamController<List<int>>();
     // TODO(nweiz): propagate any errors to the return value. See issue 3657.
     withTempDir((tempDir) {
       return create(tempDir).then((tar) {
-        var sourceStream = new File(tar).openInputStream();
-        return store(wrapInputStream(sourceStream), controller);
+        var sourceStream = new File(tar).openRead();
+        return store(sourceStream, controller);
       });
     });
     return new ByteStream(controller.stream);
   }
 }
 
 /// A descriptor that validates that no file exists with the given name.
 class NothingDescriptor extends Descriptor {
   NothingDescriptor(String name) : super(name);
 
@@ skipping 323 matching lines @@
   /// The requests to be ignored.
   final _ignored = new Set<Pair<String, String>>();
 
   ScheduledServer._(this._server);
 
   /// Creates a new server listening on an automatically-allocated port on
   /// localhost.
   factory ScheduledServer() {
     var scheduledServer;
     scheduledServer = new ScheduledServer._(_scheduleValue((_) {
-      var server = new HttpServer();
-      server.defaultRequestHandler = scheduledServer._awaitHandle;
-      server.listen("127.0.0.1", 0);
-      _scheduleCleanup((_) => server.close());
-      return new Future.immediate(server);
+      return HttpServer.bind("127.0.0.1", 0).then((server) {
+        server.listen(scheduledServer._awaitHandle);
+        _scheduleCleanup((_) => server.close());
+        return server;
+      });
     }));
     return scheduledServer;
   }
 
   /// The port on which the server is listening.
   Future<int> get port => _server.then((s) => s.port);
 
   /// The base URL of the server, including its port.
   Future<Uri> get url =>
     port.then((p) => Uri.parse("http://localhost:$p"));
 
   /// Assert that the next request has the given [method] and [path], and pass
   /// it to [handler] to handle. If [handler] returns a [Future], wait until
   /// it's completed to continue the schedule.
   void handle(String method, String path,
       Future handler(HttpRequest request, HttpResponse response)) {
     var handlerCompleter = new Completer<Function>();
     _scheduleValue((_) {
       var requestCompleteCompleter = new Completer();
       handlerCompleter.complete((request, response) {
         expect(request.method, equals(method));
-        // TODO(nweiz): Use request.path once issue 7464 is fixed.
-        expect(Uri.parse(request.uri).path, equals(path));
+        expect(request.uri.path, equals(path));
 
         var future = handler(request, response);
         if (future == null) future = new Future.immediate(null);
         chainToCompleter(future, requestCompleteCompleter);
       });
       return timeout(requestCompleteCompleter.future,
           _SCHEDULE_TIMEOUT, "waiting for $method $path");
     });
     _handlers.add(handlerCompleter.future);
   }
 
   /// Ignore all requests with the given [method] and [path]. If one is
   /// received, don't respond to it.
   void ignore(String method, String path) =>
     _ignored.add(new Pair(method, path));
 
   /// Raises an error complaining of an unexpected request.
-  void _awaitHandle(HttpRequest request, HttpResponse response) {
-    if (_ignored.contains(new Pair(request.method, request.path))) return;
+  void _awaitHandle(HttpRequest request) {
+    HttpResponse response = request.response;
+    if (_ignored.contains(new Pair(request.method, request.uri.path))) return;
     var future = timeout(defer(() {
       if (_handlers.isEmpty) {
-        fail('Unexpected ${request.method} request to ${request.path}.');
+        fail('Unexpected ${request.method} request to ${request.uri.path}.');
       }
       return _handlers.removeFirst();
     }).then((handler) {
       handler(request, response);
     }), _SCHEDULE_TIMEOUT, "waiting for a handler for ${request.method} "
-        "${request.path}");
+        "${request.uri.path}");
     expect(future, completes);
   }
 }
 
 /// Takes a simple data structure (composed of [Map]s, [List]s, scalar objects,
 /// and [Future]s) and recursively resolves all the [Future]s contained within.
 /// Completes with the fully resolved structure.
 Future _awaitObject(object) {
   // Unroll nested futures.
   if (object is Future) return object.then(_awaitObject);
@@ skipping 11 matching lines @@
     var map = {};
     for (var pair in resolvedPairs) {
       map[pair.first] = pair.last;
     }
     return map;
   });
 }
 
 /// Schedules a callback to be called as part of the test case.
 void _schedule(_ScheduledEvent event) {
-  if (_scheduled == null) _scheduled = [];
-  _scheduled.add(event);
+  if (_scheduled == null) _scheduled = new Queue();
+  _scheduled.addLast(event);
 }
 
 /// Like [_schedule], but pipes the return value of [event] to a returned
 /// [Future].
 Future _scheduleValue(_ScheduledEvent event) {
   var completer = new Completer();
   _schedule((parentDir) {
     chainToCompleter(event(parentDir), completer);
     return completer.future;
   });
   return completer.future;
 }
 
 /// Schedules a callback to be called after the test case has completed, even
 /// if it failed.
 void _scheduleCleanup(_ScheduledEvent event) {
-  if (_scheduledCleanup == null) _scheduledCleanup = [];
-  _scheduledCleanup.add(event);
+  if (_scheduledCleanup == null) _scheduledCleanup = new Queue();
+  _scheduledCleanup.addLast(event);
 }
 
 /// Schedules a callback to be called after the test case has completed, but
 /// only if it failed.
 void _scheduleOnException(_ScheduledEvent event) {
-  if (_scheduledOnException == null) _scheduledOnException = [];
-  _scheduledOnException.add(event);
+  if (_scheduledOnException == null) _scheduledOnException = new Queue();
+  _scheduledOnException.addLast(event);
 }
 
 /// Like [expect], but for [Future]s that complete as part of the scheduled
 /// test. This is necessary to ensure that the exception thrown by the
 /// expectation failing is handled by the scheduler.
 ///
 /// Note that [matcher] matches against the completed value of [actual], so
 /// calling [completion] is unnecessary.
 void expectLater(Future actual, matcher, {String reason,
     FailureHandler failureHandler, bool verbose: false}) {
   _schedule((_) {
     return actual.then((value) {
       expect(value, matcher, reason: reason, failureHandler: failureHandler,
           verbose: false);
     });
   });
 }