CallMatchers can now be null, or take null for a method name. This might be

lib/unittest/mock.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.
 
 /**
  * The error formatter for mocking is a bit different from the default one
  * for unit testing; instead of the third argument being a 'reason'
  * it is instead a [signature] describing the method signature filter
  * that was used to select the logs that were verified.
  */
@@ skipping 63 matching lines @@
 }
 
 /**
  * A [CallMatcher] is a special matcher used to match method calls (i.e.
  * a method name and set of arguments). It is not a [Matcher] like the
  * unit test [Matcher], but instead represents a method name and a
  * collection of [Matcher]s, one per argument, that will be applied
  * to the parameters to decide if the method call is a match.
  */
 class CallMatcher {
-  String name;
+  Matcher nameFilter;
   List<Matcher> argMatchers;
 
-  CallMatcher(this.name, [
+  /**
+   * Constructor for [CallMatcher]. [name] can be null to
+   * match anything, or a literal [String], a predicate [Function],
+   * or a [Matcher]. The various arguments can be scalar values or
+   * [Matcher]s.
+   */
+  CallMatcher([name,
               arg0 = _noArg,
               arg1 = _noArg,
               arg2 = _noArg,
               arg3 = _noArg,
               arg4 = _noArg,
               arg5 = _noArg,
               arg6 = _noArg,
               arg7 = _noArg,
               arg8 = _noArg,
               arg9 = _noArg]) {
+    if (name == null) {
+      nameFilter = anything;
+    } else {
+      nameFilter = wrapMatcher(name);
+    }
     argMatchers = new List<Matcher>();
     if (arg0 == _noArg) return;
     argMatchers.add(wrapMatcher(arg0));
     if (arg1 == _noArg) return;
     argMatchers.add(wrapMatcher(arg1));
     if (arg2 == _noArg) return;
     argMatchers.add(wrapMatcher(arg2));
     if (arg3 == _noArg) return;
     argMatchers.add(wrapMatcher(arg3));
     if (arg4 == _noArg) return;
@@ skipping 11 matching lines @@
   }
 
   /**
    * We keep our behavior specifications in a Map, which is keyed
    * by the [CallMatcher]. To make the keys unique and to get a
    * descriptive value for the [CallMatcher] we have this override
    * of [toString()].
    */
   String toString() {
     Description d = new StringDescription();
-    d.add(name).add('(');
+    d.addDescriptionOf(nameFilter);
+    d.add('(');
     for (var i = 0; i < argMatchers.length; i++) {
       if (i > 0) d.add(', ');
       d.addDescriptionOf(argMatchers[i]);
     }
     d.add(')');
     return d.toString();
   }
 
   /**
    * Given a [method] name and list of [arguments], return true
    * if it matches this [CallMatcher.
    */
   bool matches(String method, List arguments) {
-    if (method != this.name) {
+    if (!nameFilter.matches(method)) {
       return false;
     }
     if (arguments.length < argMatchers.length) {
-      throw new Exception("Less arguments than matchers for $name");
+      throw new Exception("Less arguments than matchers for $method");
     }
     for (var i = 0; i < argMatchers.length; i++) {
       if (!argMatchers[i].matches(arguments[i])) {
         return false;
       }
     }
     return true;
   }
 }
 
-/** [callsTo] returns a CallMatcher for the specified signature. */
-CallMatcher callsTo(String method, [
-                        arg0 = _noArg,
-                        arg1 = _noArg,
-                        arg2 = _noArg,
-                        arg3 = _noArg,
-                        arg4 = _noArg,
-                        arg5 = _noArg,
-                        arg6 = _noArg,
-                        arg7 = _noArg,
-                        arg8 = _noArg,
-                        arg9 = _noArg]) {
+/**
+ * Returns a [CallMatcher] for the specified signature. [method] can be
+ * null to match anything, or a literal [String], a predicate [Function],
+ * or a [Matcher]. The various arguments can be scalar values or [Matcher]s.
+ */
+CallMatcher callsTo([method,
+                     arg0 = _noArg,
+                     arg1 = _noArg,
+                     arg2 = _noArg,
+                     arg3 = _noArg,
+                     arg4 = _noArg,
+                     arg5 = _noArg,
+                     arg6 = _noArg,
+                     arg7 = _noArg,
+                     arg8 = _noArg,
+                     arg9 = _noArg]) {
   return new CallMatcher(method, arg0, arg1, arg2, arg3, arg4,
       arg5, arg6, arg7, arg8, arg9);
 }
 
 /**
  * A [Behavior] represents how a [Mock] will respond to one particular
  * type of method call.
  */
 class Behavior {
   CallMatcher matcher; // The method call matcher.
@@ skipping 112 matching lines @@
       if (i != 0) d.add(', ');
       d.addDescriptionOf(args[i]);
     }
     d.add(') ${action == _Action.THROW ? "threw" : "returned"} ');
     d.addDescriptionOf(value);
     return d.toString();
   }
 }
 
 /** Utility function for optionally qualified method names */
-String _qualifiedName(String owner, String method) {
+String _qualifiedName(owner, String method) {
   if (owner == null) {
     return method;
+  } else if (owner is Matcher) {
+    Description d = new StringDescription();
+    d.addDescriptionOf(owner);
+    d.add('.');
+    d.add(method);
+    return d.toString();
   } else {
     return '$owner.$method';
   }
 }
 
 /**
  * We do verification on a list of [LogEntry]s. To allow chaining
  * of calls to verify, we encapsulate such a list in the [LogEntryList]
  * class.
  */
 class LogEntryList {
   final String filter;
   List<LogEntry> logs;
   LogEntryList([this.filter]) {
     logs = new List<LogEntry>();
   }
 
   /** Add a [LogEntry] to the log. */
   add(LogEntry entry) => logs.add(entry);
 
   /**
    * Create a new [LogEntryList] consisting of [LogEntry]s from
-   * this list that match the specified [mockName] and [logFilter].
-   * If [mockName] is null, all entries will be checked. If [destructive]
-   * is true, the log entries are removed from the original list.
+   * this list that match the specified [mockNameFilter] and [logFilter].
+   * [mockNameFilter] can be null, a [String], a predicate [Function],
+   * or a [Matcher]. If [mockNameFilter] is null, only Mocks with no name
+   * will be checked.
+   * If [logFilter] is null, all entries in the log will be returned.
+   * If [destructive] is true, the log entries are removed from the
+   * original list.
    */
-  LogEntryList getMatches(String mockName,
+  LogEntryList getMatches([mockNameFilter,
                           CallMatcher logFilter,
-                          [Matcher actionMatcher,
+                          Matcher actionMatcher,
                           bool destructive = false]) {
-    String filterName = _qualifiedName(mockName, logFilter.toString());
+    mockNameFilter = wrapMatcher(mockNameFilter);
+    if (logFilter == null) {
+      logFilter = new CallMatcher();
+    }
+    String filterName = _qualifiedName(mockNameFilter, logFilter.toString());
     LogEntryList rtn = new LogEntryList(filterName);
     for (var i = 0; i < logs.length; i++) {
       LogEntry entry = logs[i];
-      if (mockName != null && mockName != entry.mockName) {
+      if (!mockNameFilter.matches(entry.mockName)) {
         continue;
       }
       if (logFilter.matches(entry.methodName, entry.args)) {
         if (actionMatcher == null || actionMatcher.matches(entry)) {
           rtn.add(entry);
           if (destructive) {
             logs.removeRange(i--, 1);
           }
         }
       }
@@ skipping 350 matching lines @@
 
   /** The set of [behavior]s supported. */
   Map<String,Behavior> behaviors;
 
   /** The [log] of calls made. Only used if [name] is null. */
   LogEntryList log;
 
   /** How to handle unknown method calls - swallow or throw. */
   final bool throwIfNoBehavior = false;
 
-  /*
+  /**
    * Default constructor. Unknown method calls are allowed and logged,
    * the mock has no name, and has its own log.
    */
   Mock() : throwIfNoBehavior = false, name = null {
     log = new LogEntryList();
     behaviors = new Map<String,Behavior>();
   }
 
   /**
    * This constructor makes a mock that has a [name] and possibly uses
@@ skipping 37 matching lines @@
    * return value. If we find no [Behavior] to apply an exception is
    * thrown.
    */
   noSuchMethod(String method, List args) {
     if (method.startsWith('get:')) {
       method = 'get ${method.substring(4)}';
     }
     bool matchedMethodName = false;
     for (String k in behaviors.getKeys()) {
       Behavior b = behaviors[k];
-      if (b.matcher.name == method) {
+      if (b.matcher.nameFilter.matches(method)) {
         matchedMethodName = true;
       }
       if (b.matches(method, args)) {
         List actions = b.actions;
         if (actions == null || actions.length == 0) {
           continue; // No return values left in this Behavior.
         }
         // Get the first response.
         Responder response = actions[0];
         // If it is exhausted, remove it from the list.
@@ skipping 85 matching lines @@
    * [LogEntry]s. If [destructive] is false (the default) the matching
    * calls are left in the log, else they are removed. Removal allows
    * us to verify a set of interactions and then verify that there are
    * no other interactions left. [actionMatcher] can be used to further
    * restrict the returned logs based on the action the mock performed.
    *
    * Typical usage:
    *
    *     getLogs(callsTo(...)).verify(...);
    */
-  LogEntryList getLogs(CallMatcher logFilter, [Matcher actionMatcher,
-                    bool destructive = false]) {
+  LogEntryList getLogs([CallMatcher logFilter,
+                        Matcher actionMatcher,
+                        bool destructive = false]) {
     return log.getMatches(name, logFilter, actionMatcher, destructive);
   }
 }