feat(test_lib): implement SpyObject

modules/test_lib/src/test_lib.dart

@@ -24,6 +24,7 @@ class Expect extends gns.Expect {
   void toEqual(expected) => toHaveSameProps(expected);
   void toThrowError([message=""]) => this.toThrowWith(message: message);
   void toBePromise() => _expect(actual is Future, equals(true));
+  void toImplement(expected) => toBeA(expected);
   Function get _expect => gns.guinness.matchers.expect;
 }
 

modules/test_lib/src/test_lib.es6

@@ -73,10 +73,51 @@ window.beforeEach(function() {
           };
         }
       };
+    },
+
+    toImplement: function() {
+      return {
+        compare: function(actualObject, expectedInterface) {
+          var objProps = Object.keys(actualObject.constructor.prototype);
+          var intProps = Object.keys(expectedInterface.prototype);
+
+          var missedMethods = [];
+          intProps.forEach((k) => {
+            if (!actualObject.constructor.prototype[k]) missedMethods.push(k);
+          });
+
+          return {
+            pass: missedMethods.length == 0,
+            get message() {
+              return 'Expected ' + actualObject + ' to have the following methods: ' + missedMethods.join(", ");
+            }
+          };
+        }
+      };
     }
   });
 });
 
+export class SpyObject {
+  spy(name){
+    if (! this[name]) {
+      this[name] = this._createGuinnessCompatibleSpy();
+    }
+    return this[name];
+  }
+
+  rttsAssert(value) {
+    return true;
+  }
+
+  _createGuinnessCompatibleSpy(){
+    var newSpy = jasmine.createSpy();
+    newSpy.andCallFake = newSpy.and.callFake;
+    return newSpy;
+  }
+}
+
+
 function mapToString(m) {
   if (!m) {
     return ''+m;

modules/test_lib/test/test_lib_spec.js

@@ -1,6 +1,7 @@
-import {describe, it, iit, ddescribe, expect, tick, async} from 'test_lib/test_lib';
+import {describe, it, iit, ddescribe, expect, tick, async, SpyObject, beforeEach} from 'test_lib/test_lib';
 import {MapWrapper, ListWrapper} from 'facade/collection';
 import {PromiseWrapper} from 'facade/async';
+import {IMPLEMENTS, proxy} from 'facade/lang';
 
 class TestObj {
   prop;
@@ -9,6 +10,10 @@ class TestObj {
   }
 }
 
+@proxy
+@IMPLEMENTS(TestObj)
+class SpyTestObj extends SpyObject {noSuchMethod(m){return super.noSuchMethod(m)}}
+
 export function main() {
   describe('test_lib', () => {
     describe('equality', () => {
@@ -48,5 +53,29 @@ export function main() {
         expect(MapWrapper.createFromStringMap({'a': 1})).not.toEqual(MapWrapper.createFromStringMap({'a': 1, 'b': 1}));
       });
     });
+
+    describe("spy objects", () => {
+      var spyObj;
+
+      beforeEach(() => {
+        spyObj = new SpyTestObj();
+      });
+
+      it("should pass the runtime check", () => {
+        var t:TestObj = spyObj;
+        expect(t).toBeDefined();
+      });
+
+      it("should return a new spy func with no calls", () => {
+        expect(spyObj.spy("someFunc")).not.toHaveBeenCalled();
+      });
+
+      it("should record function calls", () => {
+        spyObj.spy("someFunc").andCallFake((a,b) => a + b);
+
+        expect(spyObj.someFunc(1,2)).toEqual(3);
+        expect(spyObj.spy("someFunc")).toHaveBeenCalledWith(1,2);
+      });
+    });
   });
 }