@sockethub/server 5.0.0-alpha.3

package/src/middleware/store-credentials.test.ts

@@ -0,0 +1,73 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+
+import storeCredentials from "./store-credentials";
+
+const creds = {
+  "id":"blah",
+  "type":"credentials",
+  "context":"dummy",
+  "actor":{
+    "id":"dood@irc.freenode.net",
+    "type":"person",
+    "name":"dood"
+  },
+  "target":{
+    "id":"irc.freenode.net/service",
+    "type":"person",
+    "name":"service"
+  },
+  "object":{
+    "type":"credentials"
+  }
+};
+
+describe('Middleware: storeCredentials', () => {
+  let storeSuccess: any, storeError: any, saveErrorFake: any,
+      saveSuccessFake: any, sessionLogStub: any;
+
+  beforeEach(() => {
+    storeSuccess = {
+      save: (id: any, creds: any, cb: Function) => {
+        cb();
+      }
+    };
+    storeError = {
+      save: (id: any, creds: any, cb: Function) => {
+        cb('some error');
+      }
+    };
+    saveSuccessFake = sinon.replace(storeSuccess, 'save', sinon.fake(storeSuccess.save));
+    saveErrorFake = sinon.replace(storeError, 'save', sinon.fake(storeError.save));
+    sessionLogStub = sinon.stub();
+  });
+
+  afterEach(() => {
+    sinon.reset();
+  });
+
+  it('returns a middleware handler', () => {
+    const sc = storeCredentials(storeSuccess, sessionLogStub);
+    expect(typeof sc).to.equal('function');
+    expect(saveSuccessFake.callCount).to.equal(0);
+    expect(sessionLogStub.callCount).to.equal(0);
+  });
+
+  it('successfully store credentials', () => {
+    const sc = storeCredentials(storeSuccess, sessionLogStub);
+    sc(creds, (err: any) => {
+      expect(saveSuccessFake.callCount).to.equal(1);
+      expect(saveSuccessFake.firstArg).to.equal(creds.actor.id);
+      expect(err).to.be.undefined;
+    });
+  });
+
+  it('handle error while storing credentials', () => {
+    const sc = storeCredentials(storeError, sessionLogStub);
+    sc(creds, (err: any) => {
+      expect(saveErrorFake.callCount).to.equal(1);
+      expect(saveErrorFake.firstArg).to.equal(creds.actor.id);
+      expect(err).to.eql('some error');
+    });
+  });
+});

package/src/middleware/store-credentials.ts

@@ -0,0 +1,16 @@
+import { IActivityStream } from "@sockethub/schemas";
+import { ISecureStoreInstance } from "../store";
+
+export default function storeCredentials(store: ISecureStoreInstance, sessionLog: Function) {
+  return (creds: IActivityStream, done: Function) => {
+    store.save(creds.actor.id, creds, (err) => {
+      if (err) {
+        sessionLog('error saving credentials to store ' + err);
+        done(err);
+      } else {
+        sessionLog('credentials encrypted and saved');
+        done();
+      }
+    });
+  };
+};

package/src/middleware/validate.d.ts

@@ -0,0 +1 @@
+export default function validate(type: any): (next: any, msg: any) => void;

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

@@ -0,0 +1,261 @@
+export default [
+  {
+    "name": "mismatched types",
+    "valid": false,
+    "type": "credentials",
+    "input":{
+      "id":"blah",
+      "type":"send",
+      "context":"fake",
+      "actor":{
+        "id":"dood@irc.freenode.net",
+        "type":"person",
+        "name":"dood"
+      },
+      "target":{
+        "id":"irc.freenode.net/service",
+        "type":"person",
+        "name":"service"
+      },
+      "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":"fake",
+      "actor":{
+        "id":"dood@irc.freenode.net",
+        "type":"person",
+        "name":"dood"
+      },
+      "object":{
+        'type': 'credentials',
+        "user": 'foo',
+        "pass": 'bar'
+      }
+    },
+    "output":"same"
+  },
+  {
+    "name":"no type specified",
+    "valid":false,
+    "type":"credentials",
+    "input":{
+      "actor":"hyper_rau@localhost",
+      "context":"fake",
+      "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":"fake",
+      "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":"fake",
+      "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":"fake",
+      "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": "echo",
+      "context": "fake",
+      "actor": { "id": "irc://uuu@localhost", "type": "person" }
+    }
+  },
+  {
+    "name":"message with wrong type",
+    "valid":false,
+    "type":"message",
+    "input":{
+      "type": "foorg",
+      "context": "fake",
+      "actor": { "id": "irc://uuu@localhost", "type": "person" }
+    },
+    "error": "Error: platform type foorg not supported by fake platform. " +
+      "(types: credentials, echo, fail)"
+  }
+];

package/src/middleware/validate.test.ts

@@ -0,0 +1,83 @@
+import { expect } from 'chai';
+import proxyquire from 'proxyquire';
+
+proxyquire.noPreserveCache();
+proxyquire.noCallThru();
+
+class FakeSockethubPlatform {
+  constructor() {}
+  get config() {
+    return {};
+  }
+  get schema() {
+    return {
+      name: 'fake',
+      version: 'infinity',
+      credentials: {},
+      messages: {
+        "required": ["type"],
+        "properties": {
+          "type": {
+            "enum": ["echo", "fail"]
+          }
+        }
+      }
+    }
+  }
+}
+const modules = {
+  'fake-sockethub-platform': FakeSockethubPlatform
+}
+
+// @ts-ignore
+import platformLoad from './../bootstrap/platforms';
+const platforms = platformLoad(['fake-sockethub-platform'], (module) => {
+  return modules[module];
+});
+const validateMod = proxyquire('./validate', {
+  '../bootstrap/init': {
+    platforms: platforms
+  }
+});
+const validate = validateMod.default;
+
+import asObjects from "./validate.test.data";
+
+describe('platformLoad', () => {
+  it('loads all platforms', () => {
+    const expectedPlatforms = ['fake'];
+    expect(platforms.size).to.equal(expectedPlatforms.length);
+    for (let platform of expectedPlatforms) {
+      expect(platforms.has(platform)).to.be.true;
+    }
+  });
+});
+
+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 schemas from '@sockethub/schemas';
+import { IActivityStream } from "@sockethub/schemas";
+
+// @ts-ignore
+import init from "../bootstrap/init";
+
+init.platforms.forEach((platform) => {
+  Object.keys(platform.schemas).forEach((key) => {
+    if (! platform.schemas[key]) { return; }
+    schemas.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: IActivityStream, done: Function) => {
+    sessionLog('applying schema validation for ' + type);
+    if (type === 'activity-object') {
+      const err = schemas.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.validateCredentials(msg);
+      err ? done(new Error(err)) : done(msg);
+    } else {
+      const err = schemas.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.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ *
+ */
+declare function Middleware(errorHandler: any): void;
+export default Middleware;

package/src/middleware.test.ts

@@ -0,0 +1,154 @@
+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: any, cb: Function) => { cb(data); };
+    const funcs = [ sinon.spy(callback), sinon.spy(callback), sinon.spy(callback) ];
+    const mw = middleware('test');
+    for (let func of funcs) {
+      // @ts-ignore
+      const entry = mw.use(func);
+    }
+    mw.done()('some data', (data: any) => {
+      expect(data).to.eql('some data');
+      // @ts-ignore
+      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: any, cb: (arg0: Error) => void) => {
+      cb(new Error('some error')); };
+    const funcs = [ sinon.spy(callbackError) ];
+    const mw = middleware('test');
+    for (let func of funcs) {
+      mw.use(func);
+    }
+    mw.use((err: any, data: any, next: Function) => {
+      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: any, cb: Function) => { cb(data); };
+    const callbackError = (data: any, cb: (arg0: Error) => void) => {
+      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: any, data: any, next: Function) => {
+      expect(err.toString()).to.equal('Error: some error');
+      errorHandlerCalled = true;
+      next(err);
+    });
+    mw.done()('foobar', (data: any) => {
+      // 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: any, cb: Function) => { cb(data); };
+    const callbackError = (data: any, cb: (arg0: Error) => void) => {
+      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: any, data: any, next: Function) => {
+      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: any, cb: Function) => { cb(data); };
+    let funcs: Array<any> = [];
+    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: any, data: any, next: Function) => {
+      expect(err.toString()).to.equal('Error: some error');
+      errorHandlerCalled = true;
+    });
+    mw.done()('some data', (data: any) => {
+      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();
+    });
+  });
+});