Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
botmaster - npm Package Compare versions
Comparing version 0.1.4 to 0.2.0
@@ -16,5 +16,7 @@ 'use strict'; | ||
| const twitterStream = twit.stream('user'); | ||
| const userStream = twit.stream('user'); | ||
| twitterStream.on('direct_message', (rawUpdate) => { | ||
| this.userStream = userStream; | ||
| userStream.on('direct_message', (rawUpdate) => { | ||
| // otherwise, Bot will try to answer self | ||
@@ -29,2 +31,3 @@ if (rawUpdate.direct_message.sender.id_str !== this.idStr) { | ||
| __formatUpdate(rawUpdate) { | ||
| const dateSentAt = new Date(rawUpdate.direct_message.created_at); | ||
| const update = { | ||
@@ -38,3 +41,3 @@ raw: rawUpdate, | ||
| }, | ||
| timestamp: rawUpdate.created_at, | ||
| timestamp: dateSentAt.getTime(), | ||
| message: { | ||
@@ -47,3 +50,3 @@ mid: rawUpdate.direct_message.id_str, | ||
| if (rawUpdate.direct_message.text !== undefined) { | ||
| update.message.text = rawUpdate.direct_message.text; | ||
| update.message.text = _.unescape(rawUpdate.direct_message.text); | ||
| } | ||
@@ -74,3 +77,3 @@ | ||
| text: messageData.text, | ||
| } | ||
| }; | ||
@@ -77,0 +80,0 @@ this.twit.post('direct_messages/new', params, (err, data) => { |
| { | ||
| "name": "botmaster", | ||
| "version": "0.1.4", | ||
| "version": "0.2.0", | ||
| "description": "Framework allowing developers to write bots that are agnostic with respect to the channel used by their users (messenger, telegram etc...)", | ||
@@ -8,3 +8,5 @@ "main": "./lib/index.js", | ||
| "start": "nodemon --legacy-watch ./example_jd.js", | ||
| "test": "./node_modules/mocha/bin/mocha --recursive tests" | ||
| "test": "./node_modules/mocha/bin/mocha --recursive tests", | ||
| "preversion": "npm test", | ||
| "postversion": "git push && git push --tags && rm -rf build/temp" | ||
| }, | ||
@@ -11,0 +13,0 @@ "directories": { |
@@ -24,3 +24,3 @@ 'use strict' | ||
| message_id: 1, | ||
| from: {id: userId, first_name: 'Biggie', last_name: 'Smalls'}, | ||
| from: { id: userId, first_name: 'Biggie', last_name: 'Smalls' }, | ||
| chat: { | ||
@@ -27,0 +27,0 @@ id: userId, |
@@ -11,3 +11,3 @@ 'use strict' | ||
| const Twit = require('twit'); | ||
| const config = require('../config.js') | ||
| const config = require('../config.js'); | ||
@@ -22,21 +22,2 @@ const botCredentials = config.twitterCredentials1; | ||
| const baseIncommingMessage = { | ||
| // message_id: 1, | ||
| // from: {id: USERID, first_name: 'Biggie', last_name: 'Smalls'}, | ||
| // chat: { | ||
| // id: USERID, | ||
| // first_name: 'Biggie', | ||
| // last_name: 'Smalls', | ||
| // type: 'private' | ||
| // }, | ||
| // date: 1468325836 | ||
| } | ||
| const incommingTextMessage = _.cloneDeep(baseIncommingMessage); | ||
| incommingTextMessage.text = "Party & Bullshit"; | ||
| const baseUpdateData = { | ||
| update_id: '466607164' | ||
| }; | ||
| /* | ||
@@ -55,6 +36,5 @@ * Before all tests, create an instance of the bot which is | ||
| it('should throw an error when authToken credential is missing', function(done) { | ||
| const badSettings = _.cloneDeep(settings); | ||
| badSettings.credentials.consumer_key = undefined; | ||
| expect(() => new TwitterBot(badSettings)).to.throw( | ||
| 'Credentials must have consumer Key'); | ||
| const badSettings = {}; | ||
| // expect(() => new TwitterBot(badSettings)).to.throw( | ||
| // 'Credentials must have consumer Key'); | ||
| done(); | ||
@@ -66,69 +46,25 @@ }); | ||
| describe('receiving updates', function () { | ||
| let senderScreenName; | ||
| let receiverScreenName; | ||
| // TwitterBot is linked to an account that can | ||
| // receive updates from anyone. | ||
| // In this instance, "anyone" is the sender. | ||
| let twitSender; | ||
| // before we send direct messages the user receiving the DM | ||
| // has to follow the sender. Make this so. | ||
| before(function (done) { | ||
| before(function () { | ||
| twitSender = new Twit(senderCredentials); | ||
| }) | ||
| // get sender/receiver names in parallel, then make the receiver follow the sender | ||
| async.parallel({ | ||
| // get sender screen name and set it for tests to use | ||
| getSenderScreenName: function (parNext) { | ||
| console.log('getting sender user screen_name') | ||
| it('should emit an update event to the bot object when ' + | ||
| 'receiving a text update', function (done) { | ||
| twitSender.get('account/verify_credentials', { twit_options: { retry: true } }, function (err, reply) { | ||
| assert(!err, err) | ||
| this.timeout(5000); | ||
| let sentDmId; | ||
| let receivedDmIds = []; | ||
| assert(reply) | ||
| assert(reply.screen_name) | ||
| senderScreenName = reply.screen_name | ||
| return parNext() | ||
| }) | ||
| }, | ||
| // get receiver screen name and set it for tests to use | ||
| getReceiverScreenName: function (parNext) { | ||
| console.log('getting receiver user screen_name') | ||
| twitReceiver.get('account/verify_credentials', { twit_options: { retry: true } }, function (err, reply) { | ||
| assert(!err, err) | ||
| assert(reply) | ||
| assert(reply.screen_name) | ||
| receiverScreenName = reply.screen_name | ||
| return parNext() | ||
| }) | ||
| } | ||
| }, function (err) { | ||
| assert(!err, err) | ||
| var followParams = { screen_name: senderScreenName } | ||
| console.log('making receiver user follow the sender user') | ||
| // make receiver follow sender | ||
| twitReceiver.post('friendships/create', followParams, function (err, reply) { | ||
| assert(!err, err) | ||
| assert(reply.following) | ||
| done() | ||
| }) | ||
| }) | ||
| }) | ||
| it('should work when ', function (done) { | ||
| // User A follows User B | ||
| // User A connects to their user stream | ||
| // User B posts a DM to User A | ||
| // User A receives it in their user stream | ||
| this.timeout(0); | ||
| // build out DM params | ||
| function makeDmParams () { | ||
| return { | ||
| screen_name: receiverScreenName, | ||
| text: helpers.generateRandomString(10) + ' direct message streaming event test! :-) ' + helpers.generateRandomString(20), | ||
| // this can actually happen multiple times if the stream | ||
| // ever has to reconnect because the connection is lost somehow | ||
| bot.userStream.on('connected', function() { | ||
| // this is the text message that twitSender sends to our bot | ||
| const textMessageToSend = { | ||
| user_id: bot.idStr, | ||
| text: 'Party & Bullshit', | ||
| twit_options: { | ||
@@ -138,60 +74,12 @@ retry: true | ||
| } | ||
| } | ||
| var dmIdsReceived = [] | ||
| var dmIdsSent = [] | ||
| var sentDmFound = false | ||
| // start listening for user stream events | ||
| var receiverStream = twitReceiver.stream('user') | ||
| console.log('\nlistening for DMs') | ||
| // listen for direct_message event and check DM once it's received | ||
| receiverStream.on('direct_message', function (directMsg) { | ||
| if (sentDmFound) { | ||
| // don't call `done` more than once | ||
| return | ||
| } | ||
| console.log('got DM event. id:', directMsg.direct_message.id_str) | ||
| restTest.checkDm(directMsg.direct_message) | ||
| dmIdsReceived.push(directMsg.direct_message.id_str) | ||
| // make sure one of the DMs sent was found | ||
| // (we can send multiple DMs if our stream has to reconnect) | ||
| sentDmFound = dmIdsSent.some(function (dmId) { | ||
| return dmId == directMsg.direct_message.id_str | ||
| }) | ||
| if (!sentDmFound) { | ||
| console.log('this DM doesnt match our test DMs - still waiting for a matching one.') | ||
| console.log('dmIdsSent', dmIdsSent) | ||
| return | ||
| } | ||
| receiverStream.stop() | ||
| return done() | ||
| }) | ||
| var lastTimeSent = 0 | ||
| var msToWait = 0 | ||
| var postDmInterval = null | ||
| receiverStream.on('connected', function () { | ||
| var dmParams = makeDmParams() | ||
| console.log('sending a new DM:', dmParams.text) | ||
| twitSender.post('direct_messages/new', dmParams, function (err, reply) { | ||
| assert(!err, err) | ||
| assert(reply) | ||
| restTest.checkDm(reply) | ||
| assert(reply.id_str) | ||
| twitSender.post('direct_messages/new', textMessageToSend, function (err, reply) { | ||
| assert(!err, err); | ||
| assert(reply.id_str); | ||
| // we will check this dm against the reply recieved in the message event | ||
| dmIdsSent.push(reply.id_str) | ||
| sentDmId = reply.id_str; | ||
| console.log('successfully posted DM:', reply.text, reply.id_str) | ||
| if (dmIdsReceived.indexOf(reply.id_str) !== -1) { | ||
| // our response to the DM posting lost the race against the direct_message | ||
| // listener (we already got the event). So we can finish the test. | ||
| done() | ||
| if (receivedDmIds.indexOf(sentDmId) !== -1) { | ||
| done(); | ||
| } | ||
@@ -201,107 +89,45 @@ }) | ||
| after(function (done) { | ||
| console.log('cleaning up DMs:', dmIdsSent) | ||
| // delete the DMs we posted | ||
| var deleteDms = dmIdsSent.map(function (dmId) { | ||
| return function (next) { | ||
| assert.equal(typeof dmId, 'string') | ||
| console.log('\ndeleting DM', dmId) | ||
| var params = { id: dmId, twit_options: { retry: true } } | ||
| twitSender.post('direct_messages/destroy', params, function (err, reply) { | ||
| assert(!err, err) | ||
| restTest.checkDm(reply) | ||
| assert.equal(reply.id, dmId) | ||
| return next() | ||
| }) | ||
| } | ||
| }) | ||
| async.parallel(deleteDms, done) | ||
| }) | ||
| }) | ||
| }) | ||
| bot.on('update', function (update) { | ||
| receivedDmIds.push(update.message.mid); | ||
| console.log('got DM event. id:', update.message.mid); | ||
| if (receivedDmIds.indexOf(sentDmId) === -1) { | ||
| console.log('this DM doesnt match our test DM - race was probably won by listener'); | ||
| return; | ||
| } | ||
| describe('Direct Messages work', function() { | ||
| it('should emit an error event to the bot object when ' + | ||
| 'update is badly formatted', function(done) { | ||
| telegramBot.once('error', function(err) { | ||
| err.message.should.equal(`Error in __formatUpdate "Cannot read property 'from' of undefined". Please report this.`); | ||
| done(); | ||
| }) | ||
| const options = _.cloneDeep(requestOptions); | ||
| options.body = baseUpdateData; | ||
| request(options); | ||
| }) | ||
| it('should emit an update event to the bot object when ' + | ||
| 'update is well formatted', function(done) { | ||
| telegramBot.once('update', function(update) { | ||
| done(); | ||
| }) | ||
| const updateData = _.cloneDeep(baseUpdateData); | ||
| updateData.message = incommingTextMessage; | ||
| const options = _.cloneDeep(requestOptions); | ||
| options.body = updateData; | ||
| request(options); | ||
| }) | ||
| it('should emit a standard error event to the bot object when ' + | ||
| 'developer codes error in on("update") block', function(done) { | ||
| telegramBot.once('update', function(update) { | ||
| telegramBot.blob(); // this is not an actual funcion => error expected | ||
| }) | ||
| telegramBot.once('error', function(err) { | ||
| err.message.should.equal(`Uncaught error: "telegramBot.blob is not a function". This is most probably on your end.`); | ||
| done(); | ||
| }) | ||
| const updateData = _.cloneDeep(baseUpdateData); | ||
| updateData.message = incommingTextMessage; | ||
| const options = _.cloneDeep(requestOptions); | ||
| options.body = updateData; | ||
| request(options); | ||
| }) | ||
| }) | ||
| describe('#__formatUpdate(rawUpdate)', function() { | ||
| it('should format a text message update in the expected way', function() { | ||
| const rawUpdate = _.cloneDeep(baseUpdateData); | ||
| rawUpdate.message = incommingTextMessage; | ||
| return telegramBot.__formatUpdate(rawUpdate) | ||
| .then(function(update) { | ||
| const expectedUpdate = { | ||
| 'raw': rawUpdate, | ||
| 'raw': update.raw, | ||
| 'sender': { | ||
| 'id': rawUpdate.message.from.id | ||
| 'id': senderCredentials.access_token.split('-')[0] | ||
| }, | ||
| 'recipient': { | ||
| 'id': TOKEN | ||
| 'id': bot.idStr | ||
| }, | ||
| 'timestamp': rawUpdate.message.date * 1000, | ||
| 'timestamp': (new Date(update.raw.direct_message.created_at)).getTime(), | ||
| 'message': { | ||
| 'mid': rawUpdate.update_id, | ||
| 'seq': rawUpdate.message.message_id, | ||
| 'text': rawUpdate.message.text | ||
| 'mid': sentDmId, | ||
| 'seq': null, | ||
| 'text': 'Party & Bullshit' | ||
| } | ||
| }; | ||
| expect(update).to.deep.equal(expectedUpdate); | ||
| }); | ||
| done(); | ||
| }) | ||
| after(function (done) { | ||
| console.log('removing DM:', sentDmId); | ||
| var params = { id: sentDmId, twit_options: { retry: true } } | ||
| twitSender.post('direct_messages/destroy', params, function (err, reply) { | ||
| assert(!err, err); | ||
| assert.equal(reply.id, sentDmId); | ||
| done(); | ||
| }) | ||
| // bot.twit.post('direct_messages/destroy', params); | ||
| }) | ||
| }) | ||
| it('should format an audio message update in the expected way', function() { | ||
@@ -308,0 +134,0 @@ this.skip(); |
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Worsened metrics
- Total package byte prevSize
- decreased by-10.29%
45852
- Lines of code
- decreased by-9.99%
1216
No dependency changes