chat-platform 1.2.3

package/.eslintrc

@@ -0,0 +1,17 @@
+{
+    "globals": {
+        "Promise": true
+    },
+    "env": {
+        "node": true,
+        "es6": true
+    },
+    "extends": "eslint:recommended",
+    "rules": {
+        "quotes": ["error", "single"],
+        "no-useless-escape": 0
+    },
+    "parserOptions": {
+        "ecmaVersion": 8
+    }
+}

package/__tests__/chat-platform.js

@@ -0,0 +1,223 @@
+const moment = require('moment');
+const assert = require('chai').assert;
+const RED = require('../lib/red-stub')();
+const ChatExpress = require('../chat-platform');
+const ContextProviders = require('../chat-context-factory');
+const EventEmitter = require('events').EventEmitter;
+const inherits = require('util').inherits;
+const contextProviders = ContextProviders(RED);
+
+
+const Connector = function() {
+  this.send = message => this.emit('message', message);
+  return this;
+};
+inherits(Connector, EventEmitter);
+const connector = new Connector();
+
+
+const promisify = (chatServer, payload) => new Promise(
+  resolve => {
+    chatServer.on('start', () => connector.send(payload));
+    chatServer.on('message', message => resolve(message));
+    chatServer.start();
+  }
+);
+
+describe('Chat platform framework', () => {
+
+  it('should create a simple platform and retain options', async () => {
+
+    const GenericPlatform = new ChatExpress({
+      optionKey1: 'value1',
+      chatIdKey: 'myChatIdKey',
+      userIdKey: 'myUserIdKey',
+      transport: 'generic',
+      inboundMessageEvent: 'message',
+      connector: connector,
+      debug: false
+    });
+    const chatServer = GenericPlatform.createServer({
+      optionKey2: 'value2',
+      contextProvider: contextProviders.getProvider('memory')
+    });
+
+    assert.equal(chatServer.getOptions().optionKey1, 'value1');
+    assert.equal(chatServer.getOptions().optionKey2, 'value2');
+
+    const message = await promisify(chatServer, {
+      myChatIdKey: '52',
+      myUserIdKey: '62',
+      type: 'a_kind_of_magic'
+    });
+
+    assert.equal(message.originalMessage.myChatIdKey, '52');
+    assert.equal(message.originalMessage.chatId, '52');
+    assert.equal(message.originalMessage.myUserIdKey, '62');
+    assert.equal(message.originalMessage.userId, '62');
+    assert.equal(message.originalMessage.transport, 'generic');
+    assert.equal(message.originalMessage.type, 'a_kind_of_magic');
+    assert.equal(message.payload.type, 'a_kind_of_magic');
+    assert.equal(message.payload.chatId, '52');
+    assert.equal(message.payload.userId, '62');
+    assert.equal(message.payload.inbound, true);
+    assert.equal(message.payload.transport, 'generic');
+    assert.isFunction(message.chat);
+    const variables = message.chat().all();
+    assert.equal(variables.pending, false);
+    assert.equal(variables.authorized, false);
+    assert.equal(variables.authorized, false);
+    const chatContext = message.chat();
+    assert.equal(chatContext.get('transport'), 'generic');
+    assert.equal(chatContext.get('chatId'), '52');
+    assert.equal(chatContext.get('userId'), '62');
+
+  });
+
+  it('should create a simple platform with callbacks', async () => {
+    const GenericPlatform = new ChatExpress({
+      chatIdKey: payload => payload.myChatIdKey,
+      userIdKey: payload => payload.myUserIdKey,
+      type: payload => payload.type,
+      tsKey: () => moment(),
+      transport: 'generic',
+      inboundMessageEvent: 'message',
+      connector: connector,
+      debug: false
+    });
+    const chatServer = GenericPlatform.createServer({
+      contextProvider: contextProviders.getProvider('memory')
+    });
+
+    const message = await promisify(chatServer, {
+      myChatIdKey: '52',
+      myUserIdKey: '62',
+      type: 'a_kind_of_magic'
+    });
+
+    assert.equal(message.originalMessage.myChatIdKey, '52');
+    assert.equal(message.originalMessage.myUserIdKey, '62');
+    assert.equal(message.originalMessage.type, 'a_kind_of_magic');
+    assert.equal(message.payload.type, 'a_kind_of_magic');
+    assert.equal(message.payload.chatId, '52');
+    assert.equal(message.payload.userId, '62');
+    assert.equal(message.payload.inbound, true);
+    assert.equal(message.payload.transport, 'generic');
+    assert.equal(message.payload.ts.isValid(), true);
+    assert.isFunction(message.chat);
+    const variables = message.chat().all();
+    assert.equal(variables.pending, false);
+    assert.equal(variables.authorized, false);
+    assert.equal(variables.authorized, false);
+    const chatContext = message.chat();
+    assert.equal(chatContext.get('transport'), 'generic');
+    assert.equal(chatContext.get('chatId'), '52');
+    assert.equal(chatContext.get('userId'), '62');
+  });
+
+  it('should create a platform with middlewares', async () => {
+    const GenericPlatform = new ChatExpress({
+      chatIdKey: 'myChatIdKey',
+      userIdKey: 'myUserIdKey',
+      transport: 'generic',
+      inboundMessageEvent: 'message',
+      connector: connector,
+      debug: false
+    });
+    GenericPlatform.use(message => {
+      message.payload.customKey = 'value';
+      return message;
+    });
+    GenericPlatform.in('a_kind_of_magic', message => {
+      message.payload.customKey2 = 'value2';
+      return message;
+    });
+    GenericPlatform.in('another_type', message => {
+      message.payload.customKey2 = 'value3';
+      return message;
+    });
+    GenericPlatform.in(message => {
+      message.payload.customKey3 = 'value3';
+      message.chat().set('customVar', 'ahaha');
+      return message;
+    });
+    GenericPlatform.registerMessageType('a_kind_of_magic', 'A Kind of Magic');
+
+    assert.isTrue(ChatExpress.isSupported('generic'));
+    assert.isTrue(ChatExpress.isSupported('generic', 'a_kind_of_magic'));
+    assert.isFalse(ChatExpress.isSupported('i_dont_exists'));
+    assert.isFalse(ChatExpress.isSupported('generic', 'strange_type'));
+
+    const chatServer = GenericPlatform.createServer({
+      contextProvider: contextProviders.getProvider('memory')
+    });
+
+    const message = await promisify(chatServer, {
+      myChatIdKey: '52',
+      myUserIdKey: '62',
+      type: 'a_kind_of_magic'
+    });
+
+    assert.equal(message.originalMessage.myChatIdKey, '52');
+    assert.equal(message.originalMessage.myUserIdKey, '62');
+    assert.equal(message.originalMessage.type, 'a_kind_of_magic');
+    assert.equal(message.payload.type, 'a_kind_of_magic');
+    assert.equal(message.payload.chatId, '52');
+    assert.equal(message.payload.userId, '62');
+    assert.equal(message.payload.inbound, true);
+    assert.equal(message.payload.transport, 'generic');
+    assert.equal(message.payload.customKey, 'value');
+    assert.equal(message.payload.customKey2, 'value2');
+    assert.equal(message.payload.customKey3, 'value3');
+    assert.isFunction(message.chat);
+    const variables = message.chat().all();
+    assert.equal(variables.pending, false);
+    assert.equal(variables.authorized, false);
+    assert.equal(variables.authorized, false);
+    assert.equal(variables.customVar, 'ahaha');
+    const chatContext = message.chat();
+    assert.equal(chatContext.get('transport'), 'generic');
+    assert.equal(chatContext.get('chatId'), '52');
+    assert.equal(chatContext.get('userId'), '62');
+  });
+
+  it('should default userId on chatId', async () => {
+    const GenericPlatform = new ChatExpress({
+      chatIdKey: 'myChatIdKey',
+      userIdKey: 'myUserIdKey',
+      transport: 'generic',
+      inboundMessageEvent: 'message',
+      connector: connector,
+      debug: false
+    });
+    const chatServer = GenericPlatform.createServer({
+      contextProvider: contextProviders.getProvider('memory')
+    });
+
+    const message = await promisify(chatServer, {
+      myChatIdKey: '52',
+      type: 'a_kind_of_magic'
+    });
+
+    assert.equal(message.originalMessage.myChatIdKey, '52');
+    assert.equal(message.originalMessage.chatId, '52');
+    assert.equal(message.originalMessage.userId, '52');
+    assert.equal(message.originalMessage.transport, 'generic');
+    assert.equal(message.originalMessage.type, 'a_kind_of_magic');
+    assert.equal(message.payload.type, 'a_kind_of_magic');
+    assert.equal(message.payload.chatId, '52');
+    assert.equal(message.payload.userId, '52');
+    assert.equal(message.payload.inbound, true);
+    assert.equal(message.payload.transport, 'generic');
+    assert.isFunction(message.chat);
+    const variables = message.chat().all();
+    assert.equal(variables.pending, false);
+    assert.equal(variables.authorized, false);
+    assert.equal(variables.authorized, false);
+    const chatContext = message.chat();
+    assert.equal(chatContext.get('transport'), 'generic');
+    assert.equal(chatContext.get('chatId'), '52');
+    assert.equal(chatContext.get('userId'), '52');
+  });
+
+});

package/__tests__/context-provider-memory.js

@@ -0,0 +1,222 @@
+const _ = require('underscore');
+const assert = require('chai').assert;
+const RED = require('../lib/red-stub')();
+const ContextProviders = require('../chat-context-factory');
+const { when } = require('../lib/utils');
+
+describe('Chat context provider memory', () => {
+
+  const contextProviders = ContextProviders(RED);
+
+  beforeEach(() => {
+    const provider = contextProviders.getProvider('memory');
+    provider.reset();
+  });
+
+  it('should create a context provider with some default params with chatId', () => {
+
+    assert.isTrue(contextProviders.hasProvider('memory'));
+    const provider = contextProviders.getProvider('memory');
+    assert.isFunction(provider.getOrCreate);
+    assert.isFunction(provider.get);
+
+    return when(provider.getOrCreate(43, null, { myVariable: 'initial value'}))
+      .then(chatContext => {
+        assert.isFunction(chatContext.get);
+        assert.isFunction(chatContext.set);
+        assert.isFunction(chatContext.all);
+        assert.isFunction(chatContext.remove);
+        assert.isFunction(chatContext.clear);
+        return chatContext.get('myVariable');
+      }).then(myVariable => {
+        assert.equal(myVariable, 'initial value');
+      });
+  });
+
+  it('should create a context provider with some default params with userId', () => {
+
+    assert.isTrue(contextProviders.hasProvider('memory'));
+    const provider = contextProviders.getProvider('memory');
+    assert.isFunction(provider.getOrCreate);
+    assert.isFunction(provider.get);
+
+    return when(provider.getOrCreate(null, 44, { myVariable: 'initial value'}))
+      .then(chatContext => {
+        assert.isFunction(chatContext.get);
+        assert.isFunction(chatContext.set);
+        assert.isFunction(chatContext.all);
+        assert.isFunction(chatContext.remove);
+        assert.isFunction(chatContext.clear);
+        return chatContext.get('myVariable');
+      }).then(myVariable => {
+        assert.equal(myVariable, 'initial value');
+      });
+  });
+
+
+  it('should set some value and then get and remove it with chatId', () => {
+
+    const provider = contextProviders.getProvider('memory');
+
+    return when(provider.getOrCreate(42, null, {}))
+      .then(chatContext => chatContext.set('firstName', 'Guidone'))
+      .then(() => when(provider.get(42).get('firstName')))
+      .then(firstName => assert.equal(firstName, 'Guidone'))
+      .then(() => when(provider.get(42).remove('firstName')))
+      .then(() => when(provider.get(42).get('firstName')))
+      .then(
+        () => {},
+        firstName => {
+          assert.isUndefined(firstName);
+        });
+  });
+
+  it('should set some value and then get and remove it with userId', () => {
+
+    const provider = contextProviders.getProvider('memory');
+
+    return when(provider.getOrCreate(null, 43, {}))
+      .then(chatContext => chatContext.set('firstName', 'Guidone'))
+      .then(() => when(provider.get(null, 43).get('firstName')))
+      .then(firstName => assert.equal(firstName, 'Guidone'))
+      .then(() => when(provider.get(null, 43).remove('firstName')))
+      .then(() => when(provider.get(null, 43).get('firstName')))
+      .then(
+        () => {},
+        firstName => {
+          assert.isUndefined(firstName);
+        });
+  });
+
+  it('should set some values and then get and remove it with chatId', () => {
+
+    const provider = contextProviders.getProvider('memory');
+
+    return when(provider.getOrCreate(42, null, {}))
+      .then(chatContext => chatContext.set({firstName: 'Guido', lastName: 'Bellomo'}))
+      .then(() => when(provider.get(42).get('firstName')))
+      .then(firstName => assert.equal(firstName, 'Guido'))
+      .then(() =>when(provider.get(42).get('lastName')))
+      .then(lastName => assert.equal(lastName, 'Bellomo'))
+      .then(() => when(provider.get(42).get('firstName', 'lastName')))
+      .then(json => {
+        assert.isObject(json);
+        assert.equal(json.firstName, 'Guido');
+        assert.equal(json.lastName, 'Bellomo');
+      });
+  });
+
+  it('should set some values and then get and remove it with userId', () => {
+
+    const provider = contextProviders.getProvider('memory');
+
+    return when(provider.getOrCreate(null, 43, {}))
+      .then(chatContext => chatContext.set({firstName: 'Guido', lastName: 'Bellomo'}))
+      .then(() => when(provider.get(null, 43).get('firstName')))
+      .then(firstName => assert.equal(firstName, 'Guido'))
+      .then(() =>when(provider.get(null, 43).get('lastName')))
+      .then(lastName => assert.equal(lastName, 'Bellomo'))
+      .then(() => when(provider.get(null, 43).get('firstName', 'lastName')))
+      .then(json => {
+        assert.isObject(json);
+        assert.equal(json.firstName, 'Guido');
+        assert.equal(json.lastName, 'Bellomo');
+      });
+  });
+
+  it('should set some values and get the dump with chatId', () => {
+
+    const provider = contextProviders.getProvider('memory');
+
+    return when(provider.getOrCreate(42, null, {}))
+      .then(chatContext => chatContext.set({firstName: 'Guido', lastName: 'Bellomo', email: 'spam@gmail.com'}))
+      .then(() => when(provider.get(42).all()))
+      .then(json => {
+        assert.isObject(json);
+        assert.equal(json.firstName, 'Guido');
+        assert.equal(json.lastName, 'Bellomo');
+        assert.equal(json.email, 'spam@gmail.com');
+      });
+  });
+
+  it('should set some values and get the dump with userId', () => {
+
+    const provider = contextProviders.getProvider('memory');
+
+    return when(provider.getOrCreate(null, 43, {}))
+      .then(chatContext => chatContext.set({firstName: 'Guido', lastName: 'Bellomo', email: 'spam@gmail.com'}))
+      .then(() => when(provider.get(null, 43).all()))
+      .then(json => {
+        assert.isObject(json);
+        assert.equal(json.firstName, 'Guido');
+        assert.equal(json.lastName, 'Bellomo');
+        assert.equal(json.email, 'spam@gmail.com');
+      });
+  });
+
+  it('should set some values and remove all with chatId', () => {
+
+    const provider = contextProviders.getProvider('memory');
+
+    return when(provider.getOrCreate(42, null, {}))
+      .then(chatContext => chatContext.set({firstName: 'Guido', lastName: 'Bellomo'}))
+      .then(() => when(provider.get(42).clear()))
+      .then(() => when(provider.get(42).all()))
+      .then(json => {
+        assert.isObject(json);
+        assert.isTrue(_.isEmpty(json));
+      });
+  });
+
+  it('should set some values and remove all with userId', () => {
+
+    const provider = contextProviders.getProvider('memory');
+
+    return when(provider.getOrCreate(null, 43, {}))
+      .then(chatContext => chatContext.set({firstName: 'Guido', lastName: 'Bellomo'}))
+      .then(() => when(provider.get(null, 43).clear()))
+      .then(() => when(provider.get(null, 43).all()))
+      .then(json => {
+        assert.isObject(json);
+        assert.isTrue(_.isEmpty(json));
+      });
+  });
+
+  it('should set some value the remove with multiple arguments', () => {
+
+    const provider = contextProviders.getProvider('memory');
+
+    return when(provider.getOrCreate(42, null, {}))
+      .then(chatContext =>chatContext.set({firstName: 'Guidone', lastName: 'Bellomo', email: 'some@email'}))
+      .then(() => when(provider.get(42).get('firstName')))
+      .then(firstName => assert.equal(firstName, 'Guidone'))
+      .then(() => when(provider.get(42).remove('firstName', 'lastName', 'email')))
+      .then(() => when(provider.get(42).all()))
+      .then(json => {
+        assert.isUndefined(json.firstName);
+        assert.isUndefined(json.lastName);
+        assert.isUndefined(json.email);
+      });
+  });
+
+  it('should set some value with chatId and userId', () => {
+    const provider = contextProviders.getProvider('memory');
+    return when(provider.getOrCreate(42, 44, { myVar: 123 }))
+      .then(chatContext => chatContext.set('firstName', 'Guidone'))
+      .then(() => when(provider.get(null, 44).get('firstName')))
+      .then(firstName => assert.equal(firstName, 'Guidone'))
+      .then(() => when(provider.get(null, 44, { myVar: 123 })))
+      .then(chatContext => {
+        assert.equal(chatContext.get('firstName'), 'Guidone');
+        assert.equal(chatContext.get('myVar'), 123);
+      })
+      .then(() => when(provider.get(null, 44).remove('firstName')))
+      .then(() => when(provider.get(null, 44).get('firstName')))
+      /*.then(
+        () => {},
+        firstName => {
+          assert.isUndefined(firstName);
+        });*/
+  });
+
+});

package/__tests__/context-provider-plain-file.js

@@ -0,0 +1,174 @@
+const _ = require('underscore');
+const assert = require('chai').assert;
+const RED = require('../lib/red-stub')();
+const ContextProviders = require('../chat-context-factory');
+const os = require('os');
+const fs = require('fs');
+const { when } = require('../lib/utils');
+
+
+describe('Chat context provider file', () => {
+
+  const contextProviders = ContextProviders(RED);
+  //const path = os.tmpdir();
+  const path = __dirname + '/test-files';
+  const provider = contextProviders.getProvider('plain-file', { path });
+
+  beforeEach(() => {
+    return provider.reset({ path });
+  });
+
+  afterAll(() => {
+    return provider.reset({ path });
+  });
+
+  it('should create a context provider with some default params', () => {
+
+    assert.isTrue(contextProviders.hasProvider('plain-file'));
+    const provider = contextProviders.getProvider('plain-file', { path });
+    assert.isFunction(provider.getOrCreate);
+    assert.isFunction(provider.get);
+
+    return when(provider.getOrCreate(42, null, { myVariable: 'initial value'}))
+      .then(chatContext => {
+        assert.isFunction(chatContext.get);
+        assert.isFunction(chatContext.set);
+        assert.isFunction(chatContext.all);
+        assert.isFunction(chatContext.remove);
+        assert.isFunction(chatContext.clear);
+        return chatContext.get('myVariable');
+      }).then(myVariable => {
+        assert.equal(myVariable, 'initial value');
+        // assert.isTrue(fs.existsSync(`${path}/store-7369f3c86bf3c0a354615432832d9e8f.json`));
+      });
+  });
+
+  it('should set some value and then get and remove it', async () => {
+    const chatContext = await provider.getOrCreate(42, null, {});
+    await chatContext.set('firstName', 'Guidone');
+    let firstName =await chatContext.get('firstName');
+    assert.equal(firstName, 'Guidone');
+    await chatContext.remove('firstName');
+    firstName = await chatContext.get('firstName');
+    assert.isUndefined(firstName);
+  });
+
+
+  it('should set some values and then get and remove it', async () => {
+    const chatContext = await provider.getOrCreate(42, null, {});
+    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo'});
+    let firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guido');
+    let lastName = await chatContext.get('lastName');
+    assert.equal(lastName, 'Bellomo');
+    let json = await chatContext.get('firstName', 'lastName');
+    assert.isObject(json);
+    assert.equal(json.firstName, 'Guido');
+    assert.equal(json.lastName, 'Bellomo');
+  });
+
+  it('should set some values and then get and remove it with userId', async () => {
+    const chatContext = await provider.getOrCreate(null, 43, {});
+    await chatContext.set({ firstName: 'Guido', lastName: 'Bellomo' });
+    let firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guido');
+    let lastName = await chatContext.get('lastName');
+    assert.equal(lastName, 'Bellomo');
+    let json = await chatContext.get('firstName', 'lastName');
+    assert.isObject(json);
+    assert.equal(json.firstName, 'Guido');
+    assert.equal(json.lastName, 'Bellomo');
+  });
+
+  it('should set some values and get the dump with chatId', async () => {
+    const chatContext = await provider.getOrCreate(42, null, {});
+    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo', email: 'spam@gmail.com'});
+    const json = await chatContext.all();
+    assert.isObject(json);
+    assert.equal(json.firstName, 'Guido');
+    assert.equal(json.lastName, 'Bellomo');
+    assert.equal(json.email, 'spam@gmail.com');
+  });
+
+  it('should set some values and get the dump with userId', async () => {
+    const chatContext = await provider.getOrCreate(null, 43, {});
+    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo', email: 'spam@gmail.com'});
+    const json = await chatContext.all();
+    assert.isObject(json);
+    assert.equal(json.firstName, 'Guido');
+    assert.equal(json.lastName, 'Bellomo');
+    assert.equal(json.email, 'spam@gmail.com');
+  });
+
+  it('should set some values and remove all for chatId', async () => {
+    const chatContext = await provider.getOrCreate(42, {});
+    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo'});
+    await chatContext.clear();
+    let firstName = await chatContext.get('firstName');
+    assert.isUndefined(firstName);
+    let lastName = await chatContext.get('lastName');
+    assert.isUndefined(lastName);
+    const json = await chatContext.all();
+    assert.isObject(json);
+    assert.isTrue(_.isEmpty(json));
+  });
+
+  it('should set some values and remove all for userId', async () => {
+    const chatContext = await provider.getOrCreate(null, 43,  {});
+    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo'});
+    await chatContext.clear();
+    const firstName = await chatContext.get('firstName');
+    assert.isUndefined(firstName)
+    const lastName = await chatContext.get('lastName');
+    assert.isUndefined(lastName)
+    const json = await chatContext.all();
+    assert.isObject(json);
+    assert.isTrue(_.isEmpty(json));
+  });
+
+  it('should set some value the remove with multiple arguments for chatId', async () => {
+    const chatContext = await provider.getOrCreate(42, {});
+    await chatContext.set({firstName: 'Guidone', lastName: 'Bellomo', email: 'some@email'})
+    const firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guidone');
+    await chatContext.remove('firstName', 'lastName', 'email');
+    const json = await chatContext.all();
+    assert.isUndefined(json.firstName);
+    assert.isUndefined(json.lastName);
+    assert.isUndefined(json.email);
+  });
+
+  it('should set some value the remove with multiple arguments for userId', async () => {
+    const chatContext = await provider.getOrCreate(null, 43, {});
+    await chatContext.set({firstName: 'Guidone', lastName: 'Bellomo', email: 'some@email'});
+    const firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guidone');
+    await chatContext.remove('firstName', 'lastName', 'email');
+    const json = await chatContext.all();
+    assert.isUndefined(json.firstName);
+    assert.isUndefined(json.lastName);
+    assert.isUndefined(json.email);
+  });
+
+  it('should set some value with chatId and userId', async () => {
+    const chatContext = await provider.getOrCreate(42, 44, { userId: 44, chatId: 42 });
+    await chatContext.set('firstName', 'Guidone');
+    let firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guidone');
+    let userId = await chatContext.get('userId');
+    assert.equal(userId, 44);
+    let chatId = await chatContext.get('chatId');
+    assert.equal(chatId, 42);
+    const chatContext2 = await provider.getOrCreate(null, 44, { userId: 44, chatId: 42 });
+    firstName = await chatContext2.get('firstName');
+    assert.equal(firstName, 'Guidone');
+    userId = await chatContext2.get('userId');
+    assert.equal(userId, 44);
+    chatId = await chatContext2.get('chatId');
+    assert.equal(chatId, 42);
+    await chatContext2.remove('firstName');
+    firstName = await chatContext2.get('firstName');
+    assert.isUndefined(firstName);
+  });
+
+});