Spys with mirrors!

pkg/unittest/lib/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.
 
 /**
  * A simple mocking/spy library.
  *
  * ## Installing ##
  *
  * Use [pub][] to install this package. Add the following to your `pubspec.yaml`
@@ skipping 84 matching lines @@
  *     }
  *
  *     class MockFoo extends Mock implements Foo {
  *       Foo real;
  *       MockFoo() {
  *         real = new Foo();
  *         this.when(callsTo('bar')).alwaysCall(real.bar);
  *       }
  *     }
  *
+ * However, there is an even easier way, by calling [Mock.spy], e.g.:
+ *
+ *      var foo = new Foo();
+ *      var spy = new Mock.spy(foo);
+ *      print(spy.bar(1, 2, 3));
+ *
+ * Spys created with Mock.spy do not have user-defined behavior;
+ * they are simply proxies,  and thus will throw an exception if
+ * you call [when]. They capture all calls in the log, so you can
+ * do assertions on their history, such as:
+ *
+ *       spy.getLogs(callsTo('bar')).verify(happenedOnce);
+ *
  * [pub]: http://pub.dartlang.org
  */
 
 library mock;
 
-import 'dart:mirrors' show MirrorSystem;
+import 'dart:mirrors';
 import 'dart:collection' show LinkedHashMap;
 
 import 'matcher.dart';
 
 /**
  * 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 1118 matching lines @@
 
   /** The set of [Behavior]s supported. */
   LinkedHashMap<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;
 
+  /** For spys, the real object that we are spying on. */
+  Object _realObject;
+
   /** Whether to create an audit log or not. */
   bool _logging;
 
   bool get logging => _logging;
   set logging(bool value) {
     if (value && log == null) {
       log = new LogEntryList();
     }
     _logging = value;
   }
@@ skipping 20 matching lines @@
                throwIfNoBehavior: false,
                enableLogging: true}) : _throwIfNoBehavior = throwIfNoBehavior {
     if (log != null && name == null) {
       throw new Exception("Mocks with shared logs must have a name.");
     }
     logging = enableLogging;
     _behaviors = new LinkedHashMap<String,Behavior>();
   }
 
   /**
+   * This constructor creates a spy with no user-defined behavior.
+   * This is simply a proxy for a real object that passes calls
+   * through to that real object but captures an audit trail of
+   * calls made to the object that can be queried and validated
+   * later.
+   */
+  Mock.spy(this._realObject, {this.name, this.log})
+    : _behaviors = null,
+     _throwIfNoBehavior = true {
+    logging = true;
+  }
+
+  /**
    * [when] is used to create a new or extend an existing [Behavior].
    * A [CallMatcher] [filter] must be supplied, and the [Behavior]s for
    * that signature are returned (being created first if needed).
    *
    * Typical use case:
    *
    *     mock.when(callsTo(...)).alwaysReturn(...);
    */
   Behavior when(CallMatcher logFilter) {
     String key = logFilter.toString();
@@ skipping 18 matching lines @@
     var args = invocation.positionalArguments;
     if (invocation.isGetter) {
       method = 'get $method';
     } else if (invocation.isSetter) {
       method = 'set $method';
       // Remove the trailing '='.
       if (method[method.length-1] == '=') {
         method = method.substring(0, method.length - 1);
       }
     }
+    if (_behaviors == null) { // Spy.
+      var mirror = reflect(_realObject);
+      try {
+        var result = mirror.delegate(invocation);
+        log.add(new LogEntry(name, method, args, Action.PROXY, result));
+        return result;
+      } catch (e) {
+        log.add(new LogEntry(name, method, args, Action.THROW, e));
+        throw e;
+      }
+    }
     bool matchedMethodName = false;
     MatchState matchState = new MatchState();
     for (String k in _behaviors.keys) {
       Behavior b = _behaviors[k];
       if (b.matcher.nameFilter.matches(method, matchState)) {
         matchedMethodName = true;
       }
       if (b.matches(method, args)) {
         List actions = b.actions;
         if (actions == null || actions.length == 0) {
@@ skipping 16 matching lines @@
             log.add(new LogEntry(name, method, args, action, value));
           }
           return value;
         } else if (action == Action.THROW) {
           if (_logging && b.logging) {
             log.add(new LogEntry(name, method, args, action, value));
           }
           throw value;
         } else if (action == Action.PROXY) {
           // TODO(gram): Replace all this with:
-          //     var rtn = invocation.invokeOn(value);
+          //     var rtn = reflect(value).apply(invocation.positionalArguments,
+          //         invocation.namedArguments);
           // once that is supported.
           var rtn;
           switch (args.length) {
             case 0:
               rtn = value();
               break;
             case 1:
               rtn = value(args[0]);
               break;
             case 2:
@@ skipping 125 matching lines @@
       }
     }
   }
 
   /** Clear both logs and behavior. */
   void reset() {
     resetBehavior();
     clearLogs();
   }
 }