Refactor version_solver_test.

test/test_pub.dart

 // Copyright (c) 2013, 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.
 import 'dart:async';
@@ skipping 201 matching lines @@
   schedule(
       () => createSymlink(
           p.join(sandboxDir, target),
           p.join(sandboxDir, symlink)),
       'symlinking $target to $symlink');
 }
 
 /// Schedules a call to the Pub command-line utility.
 ///
 /// Runs Pub with [args] and validates that its results match [output] (or
-/// [outputJson]), [error], and [exitCode].
+/// [outputJson]), [error], [silent] (for logs that are silent by default), and
+/// [exitCode].
 ///
-/// [output] and [error] can be [String]s, [RegExp]s, or [Matcher]s.
+/// [output], [error], and [silent] can be [String]s, [RegExp]s, or [Matcher]s.
 ///
 /// If [outputJson] is given, validates that pub outputs stringified JSON
 /// matching that object, which can be a literal JSON object or any other
 /// [Matcher].
 ///
 /// If [environment] is given, any keys in it will override the environment
 /// variables passed to the spawned process.
-void schedulePub({List args, output, error, outputJson,
+void schedulePub({List args, output, error, outputJson, silent,
     int exitCode: exit_codes.SUCCESS, Map<String, String> environment}) {
   // Cannot pass both output and outputJson.
   assert(output == null || outputJson == null);
 
   var pub = startPub(args: args, environment: environment);
   pub.shouldExit(exitCode);
 
-  var failures = [];
-  var stderr;
+  expect(() async {
+    var actualOutput = (await pub.stdoutStream().toList()).join("\n");
+    var actualError = (await pub.stderrStream().toList()).join("\n");
+    var actualSilent = (await pub.silentStream().toList()).join("\n");
 
-  expect(Future.wait([
-    pub.stdoutStream().toList(),
-    pub.stderrStream().toList()
-  ]).then((results) {
-    var stdout = results[0].join("\n");
-    stderr = results[1].join("\n");
-
+    var failures = [];
     if (outputJson == null) {
-      _validateOutput(failures, 'stdout', output, stdout);
-      return null;
+      _validateOutput(failures, 'stdout', output, actualOutput);
+    } else {
+      _validateOutputJson(
+          failures, 'stdout', await awaitObject(outputJson), actualOutput);
     }
 
-    // Allow the expected JSON to contain futures.
-    return awaitObject(outputJson).then((resolved) {
-      _validateOutputJson(failures, 'stdout', resolved, stdout);
-    });
-  }).then((_) {
-    _validateOutput(failures, 'stderr', error, stderr);
+    _validateOutput(failures, 'stderr', error, actualError);
+    _validateOutput(failures, 'silent', silent, actualSilent);
 
     if (!failures.isEmpty) throw new TestFailure(failures.join('\n'));
-  }), completes);
+  }(), completes);
 }
 
 /// Like [startPub], but runs `pub lish` in particular with [server] used both
 /// as the OAuth2 server (with "/token" as the token endpoint) and as the
 /// package server.
 ///
 /// Any futures in [args] will be resolved before the process is started.
 ScheduledProcess startPublish(ScheduledServer server, {List args}) {
   var tokenEndpoint = server.url.then((url) =>
       url.resolve('/token').toString());
@@ skipping 92 matching lines @@
       description: args.isEmpty ? 'pub' : 'pub ${args.first}');
 }
 
 /// A subclass of [ScheduledProcess] that parses pub's verbose logging output
 /// and makes [stdout] and [stderr] work as though pub weren't running in
 /// verbose mode.
 class PubProcess extends ScheduledProcess {
   Stream<Pair<log.Level, String>> _log;
   Stream<String> _stdout;
   Stream<String> _stderr;
+  Stream<String> _silent;
 
   PubProcess.start(executable, arguments,
       {workingDirectory, environment, String description,
        Encoding encoding: UTF8})
     : super.start(executable, arguments,
         workingDirectory: workingDirectory,
         environment: environment,
         description: description,
         encoding: encoding);
 
@@ skipping 53 matching lines @@
           return [];
         }
         return [entry.last];
       });
     }
 
     var pair = tee(_stderr);
     _stderr = pair.first;
     return pair.last;
   }
+
+  /// A stream of log messages that are silent by default.
+  Stream<String> silentStream() {
+    if (_silent == null) {
+      _silent = _logStream().expand((entry) {
+        if (entry.first == log.Level.MESSAGE) return [];
+        if (entry.first == log.Level.ERROR) return [];
+        if (entry.first == log.Level.WARNING) return [];
+        return [entry.last];
+      });
+    }
+
+    var pair = tee(_silent);
+    _silent = pair.first;
+    return pair.last;
+  }
 }
 
 /// Fails the current test if Git is not installed.
 ///
 /// We require machines running these tests to have git installed. This
 /// validation gives an easier-to-understand error when that requirement isn't
 /// met than just failing in the middle of a test when pub invokes git.
 ///
 /// This also increases the [Schedule] timeout to 30 seconds on Windows,
 /// where Git runs really slowly.
@@ skipping 284 matching lines @@
         _lastMatcher.matches(item.last, matchState);
   }
 
   Description describe(Description description) {
     return description.addAll("(", ", ", ")", [_firstMatcher, _lastMatcher]);
   }
 }
 
 /// A [StreamMatcher] that matches multiple lines of output.
 StreamMatcher emitsLines(String output) => inOrder(output.split("\n"));