Merged PR 69: Requirement 187

- added build-types task to tasks.json
- improved typing of ContractHandler
- Moved ContractHandler to static definition
- Implemented Unit test

Related work items: #187

.vscode/tasks.json

@@ -10,6 +10,15 @@
             "problemMatcher": [
                 "$tsc"
             ]
+        },
+        {
+            "label": "build-types",
+            "type": "npm",
+            "script": "build-types",
+            "problemMatcher": [
+                "$tsc"
+            ],
+            "group": "build"
         }
     ]
 }

src/ContractHandler.ts

@@ -9,7 +9,7 @@ import Assertion from './Assertion';
 const contractHandler = Symbol('Contract handler');
 
 /**
- * The ContractHandler manages the registraction and evaluation of contracts associated with a class
+ * The ContractHandler manages the registration and evaluation of contracts associated with a class
  */
 class ContractHandler {
     protected _assert: typeof Assertion.prototype.assert;
@@ -35,7 +35,7 @@ class ContractHandler {
      * @param feature
      * @param target
      */
-    protected _decorated(feature: any, target: any) {
+    protected _decorated(feature: Function, target: object) {
         this.assertInvariants(target);
         let result = feature.apply(target, arguments);
         this.assertInvariants(target);
@@ -62,7 +62,7 @@ class ContractHandler {
      *
      * @param self - The context class
      */
-    assertInvariants(self: any) {
+    assertInvariants(self: object) {
         this._invariantRegistry.forEach((message, predicate) => {
             this._assert(predicate(self), message);
         });
@@ -74,7 +74,7 @@ class ContractHandler {
      * @param target - The target object
      * @param prop - The name or Symbol  of the property to get
      */
-    get(target: any, prop: any) {
+    get(target: object, prop: keyof typeof target) {
         let feature = target[prop];
 
         // TODO: get could be a getter
@@ -90,7 +90,7 @@ class ContractHandler {
      * @param prop - The name or Symbol  of the property to set
      * @param value - The new value of the property to set.
      */
-    set(target: any, prop: any, value: any) {
+    set(target: object, prop: keyof typeof target, value: (typeof target)[keyof typeof target]) {
         this.assertInvariants(target);
         target[prop] = value;
         this.assertInvariants(target);

src/InvariantDecorator.test.ts

@@ -663,4 +663,51 @@ describe('An invariant decorator must accept multiple assertions', () => {
             return Stack;
         }).not.toThrow();
     });
+});
+
+/**
+ * Requirement 187
+ * https://dev.azure.com/thenewobjective/decorator-contracts/_workitems/edit/187
+ */
+describe('A subclass with its own invariants must enforce all ancestor invariants', () => {
+    test('Debug Mode', () => {
+        let {invariant} = new Contracts(true);
+
+        expect(() => {
+            @invariant(
+                self => self instanceof Base,
+                self => self != null
+            )
+            class Base {}
+
+            @invariant(self => self instanceof Sub)
+            class Sub extends Base {}
+
+            return new Sub();
+        }).not.toThrow();
+
+        expect(() => {
+            @invariant(self => self instanceof Array)
+            class Base {}
+
+            @invariant(self => self instanceof Sub)
+            class Sub extends Base {}
+
+            return new Sub();
+        }).toThrow(AssertionError);
+
+        expect(() => {
+            @invariant(
+                self => self instanceof Base,
+                'I thought I was a Base!'
+            )
+            class Base {}
+
+            @invariant(self => self instanceof Array)
+            // @ts-ignore : Ignore unused error
+            class Sub extends Base {}
+
+            return new Base();
+        }).not.toThrow();
+    });
 });

src/InvariantDecorator.ts

@@ -30,38 +30,35 @@ export default class InvariantDecorator {
     invariant<Self>(predicate: Predicate<Self> | [Predicate<Self>, Message][], message?: any, ...rest: Predicate<Self>[]): ClassDecorator {
         let assert = this._assert,
             debugMode = this.debugMode,
-            defaultMessage = 'Invariant violated',
-            rs = rest == undefined ? [] : rest;
+            defaultMessage = 'Invariant violated';
 
         let invariants: [Predicate<Self>, Message][] =
             Array.isArray(predicate) ? predicate :
             typeof message == 'string' ? [[predicate, message]] :
             message == undefined ? [[predicate, defaultMessage]] :
-            typeof message == 'function' ? [
-                predicate, message, ...rs
-            ].map(pred => [pred, defaultMessage]) : [];
+            [predicate, message, ...rest].map(pred => [pred, defaultMessage]);
 
-        return function<T extends Constructor<any>>(Constructor: T) {
+        return function<T extends Constructor<any>>(Base: T) {
             if(!debugMode) {
-                return Constructor;
+                return Base;
             }
 
-            let hasHandler = Object.getOwnPropertySymbols(Constructor.prototype).includes(contractHandler);
-            let handler = hasHandler ?
-                Constructor.prototype[contractHandler] :
+            let hasHandler = Object.getOwnPropertySymbols(Base).includes(contractHandler);
+            let handler: ContractHandler = hasHandler ?
+                (Base as any)[contractHandler] :
                 new ContractHandler(assert);
             invariants.forEach(([pred, message]) => {
                 handler.addInvariant(pred, message);
             });
             if(hasHandler) {
-                return Constructor;
+                return Base;
             } else {
-                return class InvariantClass extends Constructor {
-                    [contractHandler] = handler;
+                return class InvariantClass extends Base {
+                    static [contractHandler]: ContractHandler = handler;
 
                     constructor(...args: any[]) {
                         super(...args);
-                        this[contractHandler].assertInvariants(this);
+                        InvariantClass[contractHandler].assertInvariants(this);
 
                         return new Proxy(this, handler);
                     }