sockethub 4.0.0 → 5.0.0-alpha.0

package/src/middleware/validate.test.data.ts

@@ -0,0 +1,320 @@
+export default [
+  {
+    "name": "mismatched types",
+    "valid": false,
+    "type": "credentials",
+    "input":{
+      "id":"blah",
+      "type":"send",
+      "context":"dummy",
+      "actor":{
+        "id":"dood@irc.freenode.net",
+        "type":"person",
+        "name":"dood"
+      },
+      "target":{
+        "id":"irc.freenode.net/sockethub",
+        "type":"person",
+        "name":"sockethub"
+      },
+      "object":{
+        "type":"credentials",
+        "user": 'foo',
+        "pass": 'bar'
+      }
+    },
+    'error': "Error: credential activity streams must have credentials set as type"
+  },
+  {
+    "name": "basic",
+    "valid":true,
+    "type":"credentials",
+    "input":{
+      "id":"blah",
+      "type":"credentials",
+      "context":"dummy",
+      "actor":{
+        "id":"dood@irc.freenode.net",
+        "type":"person",
+        "name":"dood"
+      },
+      "object":{
+        'type': 'credentials',
+        "user": 'foo',
+        "pass": 'bar'
+      }
+    },
+    "output":"same"
+  },
+  {
+    "name":"irc credentials",
+    "valid":true,
+    "type":"credentials",
+    "input":{
+      "context":"irc",
+      "type":"credentials",
+      "actor":{
+        "id":"sh-9K3Vk@irc.freenode.net",
+        "type":"person",
+        "name":"sh-9K3Vk",
+        "image":{
+          "height":250,
+          "mediaType":"image/jpeg",
+          "url":"http://example.org/image.jpg",
+          "width":250
+        },
+        "url":"http://sockethub.org"
+      },
+      "object":{
+        "type":"credentials",
+        "nick":"sh-9K3Vk",
+        "port":6667,
+        "secure":false,
+        "server":"irc.freenode.net"
+      }
+    },
+    "output":"same"
+  },
+  {
+    "name":"bad irc credentials: user/nick host/server",
+    "valid":false,
+    "type":"credentials",
+    "input":{
+      "context":"irc",
+      "type":"credentials",
+      "actor":{
+        "id":"sh-9K3Vk@irc.freenode.net",
+        "type":"person",
+        "name":"sh-9K3Vk",
+        "image":{
+          "height":250,
+          "mediaType":"image/jpeg",
+          "url":"http://example.org/image.jpg",
+          "width":250
+        },
+        "url":"http://sockethub.org"
+      },
+      "object":{
+        "type":"credentials",
+        "user":"sh-9K3Vk",
+        "port":6667,
+        "secure":false,
+        "host":"irc.freenode.net"
+      }
+    },
+    "error":
+      "Error: /object: must NOT have additional properties"
+  },
+  {
+    "name":"no type specified",
+    "valid":false,
+    "type":"credentials",
+    "input":{
+      "actor":"hyper_rau@localhost",
+      "context":"xmpp",
+      "object":{
+        "username":"hyper_rau",
+        "password":"123",
+        "server":"localhost",
+        "port":5222,
+        "resource":"laptop"
+      }
+    },
+    "error": "Error: credential activity streams must have credentials set as type"
+  },
+  {
+    "name":"basic person",
+    "type":"activity-object",
+    "valid":true,
+    "input":{
+      "id":"blah",
+      "type":"person",
+      "name":"dood"
+    },
+    "output":"same"
+  },
+  {
+    "name":"person with extras",
+    "valid":true,
+    "type":"activity-object",
+    "input":{
+      "id":"blah",
+      "type":"person",
+      "name":"bob",
+      "hello":"there",
+      "i":[
+        "am",
+        "extras"
+      ]
+    },
+    "output":"same"
+  },
+  {
+    "name":"alone credentials (as activity-object)",
+    "valid":false,
+    "type":"activity-object",
+    "input":{
+      "type":"credentials",
+      "nick":"sh-9K3Vk",
+      "port":6667,
+      "secure":false,
+      "server":"irc.freenode.net"
+    },
+    "error":
+      "Error: /object: must match exactly one schema in oneOf: " +
+      "credentials, feed, message, me, person, room, service, website, " +
+      "attendance, presence, relationship, topic, address"
+  },
+  {
+    "name":"alone credentials (as credentials)",
+    "valid":false,
+    "type":"credentials",
+    "input":{
+      "type":"credentials",
+      "nick":"sh-9K3Vk",
+      "port":6667,
+      "secure":false,
+      "server":"irc.freenode.net"
+    },
+    "error": "Error: platform context undefined not registered with this sockethub instance."
+  },
+  {
+    "name":"new person",
+    "valid":true,
+    "type":"activity-object",
+    "input":{
+      "id":"sh-9K3Vk@irc.freenode.net",
+      "type":"person",
+      "name":"sh-9K3Vk",
+      "image":{
+        "height":250,
+        "mediaType":"image/jpeg",
+        "url":"http://example.org/image.jpg",
+        "width":250
+      },
+      "url":"http://sockethub.org"
+    },
+    "output":"same"
+  },
+  {
+    "name":"new person",
+    "valid":true,
+    "type":"activity-object",
+    "input":{
+      "id":"irc://sh-9K3Vk@irc.freenode.net",
+      "type":"person",
+      "name":"sh-9K3Vk",
+      "url":"http://sockethub.org"
+    },
+    "output":"same"
+  },
+  {
+    "name":"bad parent object",
+    "valid":false,
+    "type":"activity-stream",
+    "input":{
+      "string":"this is a string",
+      "array":[
+        "this",
+        "is",
+        {
+          "an":"array"
+        }
+      ],
+      "as":{
+        "id":"blah",
+        "type":"send",
+        "context":"hello",
+        "actor":{
+          "name":"dood"
+        },
+        "target":{
+          "type":"person",
+          "name":"bob"
+        },
+        "object":{
+          "type":"credentials"
+        }
+      },
+      "noId":{
+        "name":"dood"
+      },
+      "noId2":{
+        "type":"person",
+        "name":"bob"
+      },
+      "noDisplayName":{
+        "id":"larg"
+      }
+    },
+    "error": "Error: platform context undefined not registered with this sockethub instance."
+  },
+  {
+    "name":"unexpected AS",
+    "valid":false,
+    "type":"message",
+    "input":{
+      "actor":"irc://uuu@localhost",
+      "type":"join",
+      "context":"irc",
+      "target":"irc://irc.dooder.net/a-room"
+    },
+    "error": "Error: /actor: must be object"
+  },
+  {
+    "name":"missing type property",
+    "valid":false,
+    "type":"message",
+    "input":{
+      "actor": { "id": "irc://uuu@localhost", "type": "person" },
+      "context":"irc",
+      "target": { "id": "irc://irc.dooder.net/a-room", "type": "room" }
+    },
+    "error": "Error: activity stream: must have required property \'type\'"
+  },
+  {
+    "name":"invalid context property",
+    "valid":false,
+    "type":"message",
+    "input":{
+      "actor": { "id": "irc://uuu@localhost", "type": "person" },
+      "type":"foo",
+      "context": "foobar",
+      "target": { "id": "irc://irc.dooder.net/a-room", "type": "room" }
+    },
+    "error": "Error: platform context foobar not registered with this sockethub instance."
+  },
+  {
+    "name":"missing actor property",
+    "valid":false,
+    "type":"message",
+    "input":{
+      "type": "foo",
+      "context":"irc",
+      "target": { "id": "irc://irc.dooder.net/a-room", "type": "room" }
+    },
+    "error": "Error: activity stream: must have required property \'actor\'"
+  },
+  {
+    "name":"traditional message",
+    "valid":true,
+    "type":"message",
+    "input":{
+      "type": "update",
+      "context": "irc",
+      "actor": { "id": "irc://uuu@localhost", "type": "person" }
+    }
+  },
+  {
+    "name":"message with wrong type",
+    "valid":false,
+    "type":"message",
+    "input":{
+      "type": "foorg",
+      "context": "irc",
+      "actor": { "id": "irc://uuu@localhost", "type": "person" }
+    },
+    "error": "Error: platform type foorg not supported by irc platform. " +
+      "(types: credentials, connect, update, join, leave, send, query, announce)"
+  }
+];

package/src/middleware/validate.test.ts

@@ -0,0 +1,47 @@
+import { expect } from 'chai';
+import proxyquire from 'proxyquire';
+
+proxyquire.noPreserveCache();
+proxyquire.noCallThru();
+
+// @ts-ignore
+import platformLoad from './../bootstrap/platforms';
+const packageJSON = require('./../../package.json');
+const platforms = platformLoad(Object.keys(packageJSON.dependencies));
+
+const validateMod = proxyquire('./validate', {
+  '../bootstrap/init': {
+    platforms: platforms
+  }
+});
+const validate = validateMod.default;
+
+import asObjects from "./validate.test.data";
+
+describe('Middleware: Validate', () => {
+  describe('AS object validations', () => {
+    asObjects.forEach((obj) => {
+      it(`${obj.type}: ${obj.name}, should ${obj.valid ? 'pass' : 'fail'}`, (done) => {
+        // @ts-ignore
+        validate(obj.type, 'tests')(obj.input, (msg) => {
+          if (obj.output) {
+            if (obj.output === 'same') {
+              expect(msg).to.eql(obj.input);
+            } else {
+              expect(msg).to.eql(obj.output);
+            }
+          }
+          if (obj.valid) {
+            expect(msg).to.not.be.instanceof(Error);
+          } else {
+            expect(msg).to.be.instanceof(Error);
+            if (obj.error) {
+              expect(msg.toString()).to.equal(obj.error);
+            }
+          }
+          done();
+        });
+      });
+    });
+  });
+});

package/src/middleware/validate.ts

@@ -0,0 +1,49 @@
+/**
+ * responsible for handling the validation and expansion (when applicable) of all incoming objects
+ */
+import debug from 'debug';
+import * as Schemas from 'sockethub-schemas';
+import { ActivityStream } from "../sockethub";
+
+// @ts-ignore
+import init from "../bootstrap/init";
+
+init.platforms.forEach((platform) => {
+  Object.keys(platform.schemas).forEach((key) => {
+    if (! platform.schemas[key]) { return; }
+    Schemas.validator.addPlatformSchema(platform.schemas[key], `${platform.id}/${key}`);
+  });
+});
+
+// called when registered with the middleware function, define the type of validation
+// that will be called when the middleware eventually does.
+export default function validate(type: string, sockethubId: string) {
+  const sessionLog = debug(`sockethub:validate:${sockethubId}`);
+  return (msg: ActivityStream, done: Function) => {
+    sessionLog('applying schema validation for ' + type);
+    if (type === 'activity-object') {
+      const err = Schemas.validator.validateActivityObject(msg);
+      err ? done(new Error(err)) : done(msg);
+    } else if (! init.platforms.has(msg.context)) {
+      return done(
+        new Error(`platform context ${msg.context} not registered with this sockethub instance.`)
+      );
+    } else if (type === 'credentials') {
+      const err = Schemas.validator.validateCredentials(msg);
+      err ? done(new Error(err)) : done(msg);
+    } else {
+      const err = Schemas.validator.validateActivityStream(msg);
+      if (err) {
+        done(new Error(err));
+      } else {
+        const platformMeta = init.platforms.get(msg.context);
+        if (!platformMeta.types.includes(msg.type)) {
+          return done(new Error(`platform type ${msg.type} not supported by ${msg.context} ` +
+            `platform. (types: ${platformMeta.types.join(', ')})`));
+        } else {
+          done(msg);
+        }
+      }
+    }
+  };
+};

package/src/middleware.test.ts

@@ -0,0 +1,148 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+
+import middleware, { MiddlewareChain } from "./middleware";
+
+describe("Middleware", () => {
+  it("middleware() is a function", () => {
+    expect(typeof middleware).to.be.equal('function');
+  });
+
+  it('returns a MiddlewareChain instance', () => {
+    const mw = middleware('testa');
+    expect(mw).to.be.instanceof(MiddlewareChain);
+    const mwc = new MiddlewareChain('testa');
+    expect(mw.name).to.be.eql(mwc.name);
+  });
+
+  it("only accepts functions", () => {
+    const mw = middleware('test');
+    // @ts-ignore
+    expect(()=>{mw.use('foobar');}).to.throw(
+      'middleware use() can only take a function as an argument');
+  });
+
+  it("only accepts functions that expect 2 or 3 params", () => {
+    const mw = middleware('test');
+    // @ts-ignore
+    expect(()=>{mw.use((one, two, three, four) => {});}).to.throw(
+      'middleware function provided with incorrect number of params: 4');
+  });
+
+  it("calls each member of call list", (done) => {
+    const callback = (data, cb) => { cb(data); };
+    const funcs = [ sinon.spy(callback), sinon.spy(callback), sinon.spy(callback) ];
+    const mw = middleware('test');
+    for (let func of funcs) {
+      mw.use(func);
+    }
+    mw.done()('some data', (data) => {
+      expect(data).to.eql('some data');
+      funcs.unshift(callback);
+      for (let i = 1; i < funcs.length; i++) {
+        expect(funcs[i].calledOnce).to.be.true;
+        expect(funcs[i].calledWith('foobar', funcs[i - 1]));
+      }
+      done();
+    });
+  });
+
+  it("does not throw exception on error with no callback provided", (done) => {
+    let errorHandlerCalled = false;
+    const callbackError = (data, cb) => {
+      cb(new Error('some error')); };
+    const funcs = [ sinon.spy(callbackError) ];
+    const mw = middleware('test');
+    for (let func of funcs) {
+      const entry = mw.use(func);
+    }
+    mw.use((err, data, next) => {
+      expect(err.toString()).to.equal('Error: some error');
+      errorHandlerCalled = true;
+      next(err);
+    });
+    mw.done()('foobar', () => {
+      expect(errorHandlerCalled).to.be.true;
+      done();
+    });
+  });
+
+  it("aborts call stack on error - calls error handler, and callback", (done) => {
+    let errorHandlerCalled = false;
+    const callback = (data, cb) => { cb(data); };
+    const callbackError = (data, cb) => { cb(new Error('some error')); };
+    const funcs = [ sinon.spy(callback), sinon.spy(callbackError), sinon.spy(callback) ];
+    const mw = middleware('test');
+    for (let func of funcs) {
+      mw.use(func);
+    }
+    mw.use((err, data, next) => {
+      expect(err.toString()).to.equal('Error: some error');
+      errorHandlerCalled = true;
+      next(err);
+    });
+    mw.done()('foobar', (data) => {
+      // FIXME -- We need to also handle socket.io callbacks!
+      expect(data instanceof Error).to.be.true;
+      expect(funcs[0].calledOnce).to.be.true;
+      expect(funcs[0].calledWith('foobar', callback));
+      expect(funcs[1].calledOnce).to.be.true;
+      expect(funcs[1].calledWith('foobar', funcs[0]));
+      expect(funcs[2].calledOnce).to.be.false;
+      expect(errorHandlerCalled).to.be.true;
+      done();
+    });
+  });
+
+  it("error handler receives error and no callback provided", (done) => {
+    let errorHandlerCalled = false;
+    const callback = (data, cb) => { cb(data); };
+    const callbackError = (data, cb) => { cb(new Error('some error')); };
+    const funcs = [ sinon.spy(callback), sinon.spy(callback), sinon.spy(callbackError) ];
+    const mw = middleware('test');
+    for (let func of funcs) {
+      mw.use(func);
+    }
+    mw.use((err, data, next) => {
+      expect(err instanceof Error).to.be.true;
+      expect(err.toString()).to.equal('Error: some error');
+      errorHandlerCalled = true;
+      expect(funcs[0].calledOnce).to.be.true;
+      expect(funcs[0].calledWith('foobar', callback));
+      expect(funcs[1].calledOnce).to.be.true;
+      expect(funcs[1].calledWith('foobar', funcs[0]));
+      expect(funcs[2].calledOnce).to.be.true;
+      expect(funcs[2].calledWith('foobar', funcs[1]));
+      expect(errorHandlerCalled).to.be.true;
+      setTimeout(done, 0);
+    });
+    mw.done()('foobar', () => {});
+  });
+
+  it("calls each member of chain (50)", (done) => {
+    let errorHandlerCalled = false;
+    const callback = (data, cb) => { cb(data); };
+    let funcs = [];
+    for (let i = 0; i <= 50; i++) {
+      funcs.push(sinon.spy(callback));
+    }
+    const mw = middleware('test');
+    for (let func of funcs) {
+      mw.use(func);
+    }
+    mw.use((err, next, data) => {
+      expect(err.toString()).to.equal('Error: some error');
+      errorHandlerCalled = true;
+    });
+    mw.done()('some data', (data) => {
+      expect(data).to.equal('some data');
+      funcs.unshift(callback);
+      for (let i = 1; i < funcs.length; i++) {
+        expect(funcs[i].calledOnce).to.be.true;
+        expect(funcs[i].calledWith('foo', funcs[i - 1]));
+      }
+      expect(errorHandlerCalled).to.be.false;
+      done();
+    });
+  });
+});

package/src/middleware.ts

@@ -1,57 +1,52 @@
-/**
- * a very simple middleware handler
- *
- * When initialized, provide a function which will be called if there were any failures during
- * the execution of functions along the chain.
- *
- * Use middleware.chain, passing in a list of functions to call in order. It then returns
- * a function which accepts the message from the input. That function then will
- * call each of the originally passed in functions, in order, with a `next` callback as
- * the first parameter, and any number of originating parameters.
- *
- * As one middleware function is done, they call `next` with the first argument `true`
- * (succeeded, continue) any parameters to pass along.
- *
- * If any of the middleware function calls the `next` handler with `false` as the first param, the
- * execution of the function chain is halted, and the failure callback is called. Again, any
- * number of params passed after the `false` will be passed to the failure callback.
- *
- */
-function Middleware(errorHandler: Function) {
-  this.errorHandler = errorHandler;
+import { debug } from 'debug';
+
+export default function middleware(name: string): MiddlewareChain {
+  return new MiddlewareChain(name);
 }
 
-Middleware.prototype.chain = function (...funcs) {
-  let self = this;
-  return (...params) => {
-    let count = 0;
-    if (typeof funcs[count] !== 'function') {
-      throw new Error('middleware function can only take other functions as arguments.');
-    }
+export class MiddlewareChain {
+  public name: string;
+  private chain: Array<Function> = [];
+  private errHandler: Function = (err: Error) => { throw err; };
+  private logger: Function;
 
-    function _callFunc(pos: number) {
-      if (pos + 1 === funcs.length) {
-        // last call, don't wait for next callback
-        funcs[pos].apply(this, params);
-        return;
-      }
-
-      function _nextFunc(status, ..._params) {
-        if ((typeof status === 'boolean') && (! status)) {
-          // failed, abort.
-          self.errorHandler(..._params);
-        } else if ((status) && (_params.length > -1)) {
-          // re-assign/update the payload object
-          params = _params;
-        }
-        count = count + 1;
-        setTimeout(_callFunc.bind(this, count), 0);
-      }
+  constructor(name: string) {
+    this.name = name;
+    this.logger = debug(`sockethub:middleware:${name}`);
+  }
 
-      funcs[pos].apply(this, [_nextFunc].concat(params));
+  use(func: Function): this {
+    if (typeof func !== 'function') {
+      throw new Error('middleware use() can only take a function as an argument');
+    }
+    if (func.length === 3) {
+      this.errHandler = func;
+    } else if (func.length === 2) {
+      this.chain.push(func);
+    } else {
+      throw new Error(
+        'middleware function provided with incorrect number of params: ' + func.length);
     }
-    _callFunc(count);
-  };
-};
+    return this;
+  }
 
-export default Middleware;
+  done() {
+    return (data: any, callback: Function) => {
+      let position = 0;
+      if (typeof callback !== 'function') {
+        callback = () => {};
+      }
+      const next = (_data: any) => {
+        if (_data instanceof Error) {
+          this.logger(_data);
+          this.errHandler(_data, data, callback);
+        } else if (typeof this.chain[position] === 'function') {
+          this.chain[position++](_data, next);
+        } else {
+          callback(_data);
+        }
+      };
+      next(data);
+    };
+  }
+}