mir/node-telegram-bot-api
2
0
Fork 0
mirror of https://github.com/yagop/node-telegram-bot-api synced 2025-08-22 18:07:16 +00:00
Code Issues Releases Wiki Activity

refactor: rewrite to babel, es6 & eslint

Browse Source
This commit is contained in:
AVVS 2016-03-17 02:44:34 +03:00
parent b9649c00bb
commit 83e42201ee
14 changed files with 1062 additions and 1019 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
.babelrc Normal file
View File

@ -0,0 +1,11 @@
{
"plugins": [
"transform-es2015-spread",
"transform-es2015-destructuring",
"transform-strict-mode",
"transform-es2015-parameters",
"transform-es2015-shorthand-properties",
"transform-object-rest-spread",
"transform-class-properties"
]
}

13
.editorconfig Normal file
View File

@ -0,0 +1,13 @@
# http://editorconfig.org
root = true
[*]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
[*.md]
trim_trailing_whitespace = false

2
.eslintignore Normal file
View File

@ -0,0 +1,2 @@
bin
*.md

18
.eslintrc Normal file
View File

@ -0,0 +1,18 @@
{
"extends": "airbnb/base",
"parser": "babel-eslint",
"rules": {
"new-cap": 0,
"prefer-arrow-callback": 0,
"no-param-reassign": [2,{"props":false}],
"max-len": [2, 150],
"arrow-body-style": 0,
"comma-dangle": 0
},
"plugins": [
"mocha"
],
"env": {
"mocha": true
}
}

1
.gitignore vendored
View File

@ -4,3 +4,4 @@ npm-debug.log
.package.json .package.json
output.md output.md
output/ output/
lib/

11
.jshintrc
View File

@ -1,11 +0,0 @@
{
"curly" : true,
"eqeqeq" : true,
"indent" : 2,
"latedef" : true,
"newcap" : true,
"quotmark": "single",
"strict" : true,
"undef" : true,
"node" : true
}

5
.travis.yml
View File

@ -1,8 +1,7 @@
language: node_js language: node_js
node_js: node_js:
- "stable" - "5"
- "0.12" - "4"
- "0.10"
after_success: after_success:
- npm run test-cov - npm run test-cov
cache: cache:

31
package.json
View File

@ -2,7 +2,7 @@
"name": "node-telegram-bot-api", "name": "node-telegram-bot-api",
"version": "0.21.1", "version": "0.21.1",
"description": "Telegram Bot API", "description": "Telegram Bot API",
"main": "index.js", "main": "./lib/telegram.js",
"directories": { "directories": {
"example": "examples", "example": "examples",
"test": "test" "test": "test"
@ -14,29 +14,46 @@
"bot" "bot"
], ],
"scripts": { "scripts": {
"prepublish": "./node_modules/.bin/babel -d ./lib src",
"test": "./node_modules/.bin/mocha test/index.js", "test": "./node_modules/.bin/mocha test/index.js",
"test-cov": "./node_modules/.bin/istanbul cover ./node_modules/mocha/bin/_mocha --report lcovonly -- -R spec && cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js && rm -rf ./coverage", "test-cov": "./node_modules/.bin/istanbul cover ./node_modules/mocha/bin/_mocha --report lcovonly -- -R spec && cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js && rm -rf ./coverage",
"gen-doc": "./node_modules/.bin/jsdoc2md --src src/telegram.js -t README.hbs > README.md", "gen-doc": "./node_modules/.bin/jsdoc2md --src src/telegram.js -t README.hbs > README.md",
"jshint": "./node_modules/.bin/jshint src test" "eslint": "./node_modules/.bin/eslint ./src"
}, },
"author": "Yago Pérez <yagoperezs@gmail.com>", "author": "Yago Pérez <yagoperezs@gmail.com>",
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
"bluebird": "^2.10.2", "bl": "^1.1.2",
"bluebird": "^3.3.4",
"debug": "^2.2.0", "debug": "^2.2.0",
"eventemitter3": "^1.2.0",
"file-type": "^3.8.0", "file-type": "^3.8.0",
"mime": "^1.3.4", "mime": "^1.3.4",
"request": "^2.69.0" "pump": "^1.0.1",
"request": "^2.69.0",
"request-promise": "^2.0.1"
}, },
"devDependencies": { "devDependencies": {
"babel-cli": "^6.6.5",
"babel-eslint": "^5.0.0",
"babel-plugin-transform-class-properties": "^6.6.0",
"babel-plugin-transform-es2015-destructuring": "^6.6.5",
"babel-plugin-transform-es2015-parameters": "^6.7.0",
"babel-plugin-transform-es2015-shorthand-properties": "^6.5.0",
"babel-plugin-transform-es2015-spread": "^6.6.5",
"babel-plugin-transform-object-rest-spread": "^6.6.5",
"babel-plugin-transform-strict-mode": "^6.6.5",
"babel-register": "^6.7.2",
"contributor": "^0.1.25", "contributor": "^0.1.25",
"coveralls": "^2.11.8", "coveralls": "^2.11.8",
"eslint": "^2.4.0",
"eslint-config-airbnb": "^6.1.0",
"eslint-plugin-mocha": "^2.0.0",
"is": "^3.1.0",
"istanbul": "^0.4.2", "istanbul": "^0.4.2",
"jsdoc-to-markdown": "^1.3.3", "jsdoc-to-markdown": "^1.3.3",
"jshint": "^2.9.1",
"mocha": "^2.4.5", "mocha": "^2.4.5",
"mocha-lcov-reporter": "^1.2.0", "mocha-lcov-reporter": "^1.2.0"
"should": "^8.2.2"
}, },
"repository": { "repository": {
"type": "git", "type": "git",

1046
src/telegram.js
View File

File diff suppressed because it is too large Load Diff

183
src/telegramPolling.js
View File

@ -1,90 +1,103 @@
'use strict'; const Promise = require('bluebird');
const debug = require('debug')('node-telegram-bot-api');
const request = require('request-promise');
const URL = require('url');
var debug = require('debug')('node-telegram-bot-api'); class TelegramBotPolling {
var Promise = require('bluebird');
var request = require('request');
var util = require('util');
var URL = require('url');
var requestPromise = Promise.promisify(request); constructor(token, options = {}, callback) {
// enable cancellation
var TelegramBotPolling = function (token, options, callback) { Promise.config({
options = options || {}; cancellation: true,
if (typeof options === 'function') {
callback = options;
options = {};
}
this.offset = 0;
this.token = token;
this.callback = callback;
this.timeout = options.timeout || 10;
this.interval = (typeof options.interval === 'number') ? options.interval : 300;
this.lastUpdate = 0;
this.lastRequest = null;
this.abort = false;
this._polling();
};
TelegramBotPolling.prototype._polling = function () {
this.lastRequest = this._getUpdates()
.then(function (updates) {
this.lastUpdate = Date.now();
debug('polling data %j', updates);
updates.forEach(function (update, index) {
this.offset = update.update_id;
debug('updated offset: %s', this.offset);
this.callback(update);
}.bind(this));
}.bind(this))
.catch(function (err) {
debug('polling error: %s', err.message);
throw err;
})
.finally(function () {
if (this.abort) {
debug('Polling is aborted!');
} else {
debug('setTimeout for %s miliseconds', this.interval);
setTimeout(this._polling.bind(this), this.interval);
}
}.bind(this));
};
TelegramBotPolling.prototype._getUpdates = function () {
var opts = {
qs: {
offset: this.offset+1,
limit: this.limit,
timeout: this.timeout
},
url: URL.format({
protocol: 'https',
host: 'api.telegram.org',
pathname: '/bot'+this.token+'/getUpdates'
})
};
debug('polling with options: %j', opts);
return requestPromise(opts)
.cancellable()
.timeout((10 + this.timeout) * 1000)
.then(function (resp) {
if (resp[0].statusCode !== 200) {
throw new Error(resp[0].statusCode+' '+resp[0].body);
}
var data;
try {
data = JSON.parse(resp[0].body);
} catch (err) {
var text = util.format('Error parsing Telegram response: %s',
resp[0].body);
throw new Error(text);
}
if (data.ok) {
return data.result;
} else {
throw new Error(data.error_code+' '+data.description);
}
}); });
};
if (typeof options === 'function') {
callback = options; // eslint-disable-line no-param-reassign
options = {}; // eslint-disable-line no-param-reassign
}
this.offset = 0;
this.token = token;
this.callback = callback;
this.timeout = options.timeout || 10;
this.interval = (typeof options.interval === 'number') ? options.interval : 300;
this.lastUpdate = 0;
this.lastRequest = null;
this.abort = false;
this._polling();
}
_polling() {
this.lastRequest = this
._getUpdates()
.then(updates => {
this.lastUpdate = Date.now();
debug('polling data %j', updates);
updates.forEach(update => {
this.offset = update.update_id;
debug('updated offset: %s', this.offset);
this.callback(update);
});
})
.catch(err => {
debug('polling error: %s', err.message);
throw err;
})
.finally(() => {
if (this.abort) {
debug('Polling is aborted!');
} else {
debug('setTimeout for %s miliseconds', this.interval);
setTimeout(() => this._polling(), this.interval);
}
});
}
// used so that other funcs are not non-optimizable
_safeParse(json) {
try {
return JSON.parse(json);
} catch (err) {
throw new Error(`Error parsing Telegram response: ${String(json)}`);
}
}
_getUpdates() {
const opts = {
qs: {
offset: this.offset + 1,
limit: this.limit,
timeout: this.timeout
},
url: URL.format({
protocol: 'https',
host: 'api.telegram.org',
pathname: `/bot${this.token}/getUpdates`
}),
simple: false,
resolveWithFullResponse: true,
forever: true,
};
debug('polling with options: %j', opts);
return request(opts)
.promise()
.timeout((10 + this.timeout) * 1000)
.then(resp => {
if (resp.statusCode !== 200) {
throw new Error(`${resp.statusCode} ${resp.body}`);
}
const data = this._safeParse(resp.body);
if (data.ok) {
return data.result;
}
throw new Error(`${data.error_code} ${data.description}`);
});
}
}
module.exports = TelegramBotPolling; module.exports = TelegramBotPolling;

134
src/telegramWebHook.js
View File

@ -1,67 +1,85 @@
'use strict'; const debug = require('debug')('node-telegram-bot-api');
const https = require('https');
const http = require('http');
const fs = require('fs');
const bl = require('bl');
var debug = require('debug')('node-telegram-bot-api'); class TelegramBotWebHook {
var https = require('https');
var http = require('http');
var fs = require('fs');
var TelegramBotWebHook = function (token, options, callback) { constructor(token, options, callback) {
this.token = token; this.token = token;
this.callback = callback; this.callback = callback;
if (typeof options === 'boolean') { this.regex = new RegExp(this.token);
options = {};
}
options.port = options.port || 8443;
var binded = this._requestListener.bind(this);
if (options.key && options.cert) { // HTTPS Server // define opts
debug('HTTPS WebHook enabled'); if (typeof options === 'boolean') {
var opts = { options = {}; // eslint-disable-line no-param-reassign
key: fs.readFileSync(options.key), }
cert: fs.readFileSync(options.cert) options.port = options.port || 8443;
};
this._webServer = https.createServer(opts, binded);
} else {
debug('HTTP WebHook enabled');
this._webServer = http.createServer(binded);
}
this._webServer.listen(options.port, options.host, function () { if (options.key && options.cert) { // HTTPS Server
debug('WebHook listening on port %s', options.port); debug('HTTPS WebHook enabled');
}); const opts = {
}; key: fs.readFileSync(options.key),
cert: fs.readFileSync(options.cert)
};
this._webServer = https.createServer(opts, this._requestListener);
} else {
debug('HTTP WebHook enabled');
this._webServer = http.createServer(this._requestListener);
}
TelegramBotWebHook.prototype._requestListener = function (req, res) { this._webServer.listen(options.port, options.host, () => {
var self = this; debug('WebHook listening on port %s', options.port);
var regex = new RegExp(this.token);
debug('WebHook request URL:', req.url);
debug('WebHook request headers: %j', req.headers);
// If there isn't token on URL
if (!regex.test(req.url)) {
debug('WebHook request unauthorized');
res.statusCode = 401;
res.end();
} else if (req.method === 'POST') {
var fullBody = '';
req.on('data', function (chunk) {
fullBody += chunk.toString();
}); });
req.on('end', function () {
try {
debug('WebHook request fullBody', fullBody);
var data = JSON.parse(fullBody);
self.callback(data);
} catch (error) {
debug(error);
}
res.end('OK');
});
} else { // Authorized but not a POST
debug('WebHook request isn\'t a POST');
res.statusCode = 418; // I'm a teabot!
res.end();
} }
};
// used so that other funcs are not non-optimizable
_safeParse(json) {
try {
return JSON.parse(json);
} catch (err) {
debug(err);
return null;
}
}
// pipe+parse body
_parseBody = (err, body) => {
if (err) {
return debug(err);
}
const data = this._safeParse(body);
if (data) {
return this.callback(data);
}
return null;
}
// bound req listener
_requestListener = (req, res) => {
debug('WebHook request URL:', req.url);
debug('WebHook request headers: %j', req.headers);
// If there isn't token on URL
if (!this.regex.test(req.url)) {
debug('WebHook request unauthorized');
res.statusCode = 401;
res.end();
} else if (req.method === 'POST') {
req
.pipe(bl(this._parseBody))
.on('end', () => res.end('OK'));
} else {
// Authorized but not a POST
debug('WebHook request isn\'t a POST');
res.statusCode = 418; // I'm a teabot!
res.end();
}
}
}
module.exports = TelegramBotWebHook; module.exports = TelegramBotWebHook;

12
test/.jshintrc
View File

@ -1,12 +0,0 @@
{
"mocha" : true,
"curly" : true,
"eqeqeq" : true,
"indent" : 2,
"latedef" : true,
"newcap" : true,
"quotmark": "single",
"strict" : true,
"undef" : true,
"node" : true
}

611
test/index.js
View File

@ -1,533 +1,506 @@
'use strict'; const TelegramPolling = require('../src/telegramPolling');
const Telegram = require('../index');
var TelegramPolling = require('../src/telegramPolling'); const Promise = require('bluebird');
var Telegram = require('../index'); const request = require('request-promise');
var Promise = require('bluebird'); const assert = require('assert');
var request = require('request'); const fs = require('fs');
var should = require('should'); const is = require('is');
var fs = require('fs');
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
var TOKEN = process.env.TEST_TELEGRAM_TOKEN; const TOKEN = process.env.TEST_TELEGRAM_TOKEN;
if (!TOKEN) { if (!TOKEN) {
throw new Error('Bot token not provided'); throw new Error('Bot token not provided');
} }
// Telegram service if not User Id // Telegram service if not User Id
var USERID = process.env.TEST_USER_ID || 777000; const USERID = process.env.TEST_USER_ID || 777000;
describe('Telegram', function () { describe('Telegram', function telegramSuite() {
describe('#setWebHook', function setWebHookSuite() {
describe('#setWebHook', function () { it('should set a webHook', function test() {
it('should set a webHook', function (done) { const bot = new Telegram(TOKEN);
var bot = new Telegram(TOKEN);
// Google IP ¯\_(ツ)_/¯ // Google IP ¯\_(ツ)_/¯
bot.setWebHook('216.58.210.174').then(function (resp) { return bot
resp.should.be.exactly(true); .setWebHook('216.58.210.174')
done(); .then(resp => {
}); assert.equal(resp, true);
});
}); });
it('should set a webHook with certificate', function (done) { it('should set a webHook with certificate', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var cert = __dirname+'/../examples/crt.pem'; const cert = `${__dirname}/../examples/crt.pem`;
bot.setWebHook('216.58.210.174', cert).then(function (resp) { return bot
resp.should.be.exactly(true); .setWebHook('216.58.210.174', cert)
done(); .then(resp => {
}); assert.equal(resp, true);
});
}); });
it('should delete the webHook', function (done) { it('should delete the webHook', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
bot.setWebHook('').then(function (resp) { return bot
resp.should.be.exactly(true); .setWebHook('')
done(); .then(resp => {
}); assert.equal(resp, true);
});
}); });
}); });
describe('#WebHook', function () { describe('#WebHook', function WebHookSuite() {
it('should reject request if same token not provided', function (done) { it('should reject request if same token not provided', function test() {
var bot = new Telegram(TOKEN, {webHook: true}); const bot = new Telegram(TOKEN, { webHook: true });
request({
return request({
url: 'http://localhost:8443/NOT_REAL_TOKEN', url: 'http://localhost:8443/NOT_REAL_TOKEN',
method: 'POST' method: 'POST',
}, function (error, response, body) { simple: false,
response.statusCode.should.not.be.equal(200); resolveWithFullResponse: true
}).then(response => {
assert.notEqual(response.statusCode, 200);
bot._WebHook._webServer.close(); bot._WebHook._webServer.close();
done();
}); });
}); });
it('should reject request if authorized but not a POST', function (done) { it('should reject request if authorized but not a POST', function test() {
var bot = new Telegram(TOKEN, {webHook: true}); const bot = new Telegram(TOKEN, { webHook: true });
request({ return request({
url: 'http://localhost:8443/bot'+TOKEN, url: `http://localhost:8443/bot${TOKEN}`,
method: 'GET' method: 'GET',
}, function (error, response, body) { simple: false,
response.statusCode.should.not.be.equal(200); resolveWithFullResponse: true
})
.then(response => {
assert.notEqual(response.statusCode, 200);
bot._WebHook._webServer.close(); bot._WebHook._webServer.close();
done();
}); });
}); });
it('should emit a `message` on HTTP WebHook', function (done) { it('should emit a `message` on HTTP WebHook', function test(done) {
var bot = new Telegram(TOKEN, {webHook: true}); const bot = new Telegram(TOKEN, { webHook: true });
bot.on('message', function (msg) { bot.on('message', () => {
bot._WebHook._webServer.close(); bot._WebHook._webServer.close();
done(); done();
}); });
var url = 'http://localhost:8443/bot'+TOKEN;
const url = `http://localhost:8443/bot${TOKEN}`;
request({ request({
url: url, url,
method: 'POST', method: 'POST',
json: true, json: true,
headers: { headers: {
'content-type': 'application/json', 'content-type': 'application/json',
}, },
body: {update_id: 0, message: {text: 'test'}} body: { update_id: 0, message: { text: 'test' } }
}); });
}); });
it('should emit a `message` on HTTPS WebHook', function (done) { it('should emit a `message` on HTTPS WebHook', function test(done) {
var opts = { const opts = {
webHook: { webHook: {
port: 8443, port: 8443,
key: __dirname+'/../examples/key.pem', key: `${__dirname}/../examples/key.pem`,
cert: __dirname+'/../examples/crt.pem' cert: `${__dirname}/../examples/crt.pem`
} }
}; };
var bot = new Telegram(TOKEN, opts); const bot = new Telegram(TOKEN, opts);
bot.on('message', function (msg) { bot.on('message', () => {
bot._WebHook._webServer.close(); bot._WebHook._webServer.close();
done(); done();
}); });
var url = 'https://localhost:8443/bot'+TOKEN; const url = `https://localhost:8443/bot${TOKEN}`;
request({ request({
url: url, url,
method: 'POST', method: 'POST',
json: true, json: true,
headers: { headers: {
'content-type': 'application/json', 'content-type': 'application/json',
}, },
rejectUnhauthorized: false, rejectUnhauthorized: false,
body: {update_id: 0, message: {text: 'test'}} body: { update_id: 0, message: { text: 'test' } }
}); });
}); });
}); });
describe('#getMe', function () { describe('#getMe', function getMeSuite() {
it('should return an User object', function (done) { it('should return an User object', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
bot.getMe().then(function (resp) { return bot.getMe().then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
}); });
describe('#getUpdates', function () { describe('#getUpdates', function getUpdatesSuite() {
it('should return an Array', function (done) { it('should return an Array', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
bot.getUpdates().then(function (resp) { return bot.getUpdates().then(resp => {
resp.should.be.an.instanceOf(Array); assert.equal(Array.isArray(resp), true);
done();
}); });
}); });
}); });
describe('#sendMessage', function () { describe('#sendMessage', function sendMessageSuite() {
it('should send a message', function (done) { it('should send a message', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
bot.sendMessage(USERID, 'test').then(function (resp) { return bot.sendMessage(USERID, 'test').then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
}); });
describe('#forwardMessage', function () { describe('#forwardMessage', function forwardMessageSuite() {
it('should forward a message', function (done) { it('should forward a message', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
bot.sendMessage(USERID, 'test').then(function (resp) { return bot.sendMessage(USERID, 'test').then(resp => {
var messageId = resp.message_id; const messageId = resp.message_id;
bot.forwardMessage(USERID, USERID, messageId) return bot.forwardMessage(USERID, USERID, messageId)
.then(function (resp) { .then(forwarded => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(forwarded));
done();
}); });
}); });
}); });
}); });
describe('#sendPhoto', function () { describe('#sendPhoto', function sendPhotoSuite() {
var photoId; let photoId;
it('should send a photo from file', function (done) { it('should send a photo from file', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var photo = __dirname+'/bot.gif'; const photo = `${__dirname}/bot.gif`;
bot.sendPhoto(USERID, photo).then(function (resp) { return bot.sendPhoto(USERID, photo).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
photoId = resp.photo[0].file_id; photoId = resp.photo[0].file_id;
done();
}); });
}); });
it('should send a photo from id', function (done) { it('should send a photo from id', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
// Send the same photo as before // Send the same photo as before
var photo = photoId; const photo = photoId;
bot.sendPhoto(USERID, photo).then(function (resp) { return bot.sendPhoto(USERID, photo).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a photo from fs.readStream', function (done) { it('should send a photo from fs.readStream', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var photo = fs.createReadStream(__dirname+'/bot.gif'); const photo = fs.createReadStream(`${__dirname}/bot.gif`);
bot.sendPhoto(USERID, photo).then(function (resp) { return bot.sendPhoto(USERID, photo).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a photo from request Stream', function (done) { it('should send a photo from request Stream', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var photo = request('https://telegram.org/img/t_logo.png'); const photo = request('https://telegram.org/img/t_logo.png');
bot.sendPhoto(USERID, photo).then(function (resp) { return bot.sendPhoto(USERID, photo).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a photo from a Buffer', function (done) { it('should send a photo from a Buffer', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var photo = fs.readFileSync(__dirname+'/bot.gif'); const photo = fs.readFileSync(`${__dirname}/bot.gif`);
bot.sendPhoto(USERID, photo).then(function (resp) { return bot.sendPhoto(USERID, photo).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
}); });
describe('#sendChatAction', function () { describe('#sendChatAction', function sendChatActionSuite() {
it('should send a chat action', function (done) { it('should send a chat action', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var action = 'typing'; const action = 'typing';
bot.sendChatAction(USERID, action).then(function (resp) { return bot.sendChatAction(USERID, action).then(resp => {
resp.should.be.exactly(true); assert.equal(resp, true);
done();
}); });
}); });
}); });
describe('#sendAudio', function () { describe('#sendAudio', function sendAudioSuite() {
it('should send an OGG audio', function (done) { it('should send an OGG audio', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var audio = request('https://upload.wikimedia.org/wikipedia/commons/c/c8/Example.ogg'); const audio = request('https://upload.wikimedia.org/wikipedia/commons/c/c8/Example.ogg');
bot.sendAudio(USERID, audio).then(function (resp) { return bot.sendAudio(USERID, audio).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
}); });
describe('#sendDocument', function () { describe('#sendDocument', function sendDocumentSuite() {
var documentId; let documentId;
it('should send a document from file', function (done) { it('should send a document from file', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var document = __dirname+'/bot.gif'; const document = `${__dirname}/bot.gif`;
bot.sendDocument(USERID, document).then(function (resp) { return bot.sendDocument(USERID, document).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
documentId = resp.document.file_id; documentId = resp.document.file_id;
done();
}); });
}); });
it('should send a document from id', function (done) { it('should send a document from id', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
// Send the same photo as before // Send the same photo as before
var document = documentId; const document = documentId;
bot.sendDocument(USERID, document).then(function (resp) { return bot.sendDocument(USERID, document).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a document from fs.readStream', function (done) { it('should send a document from fs.readStream', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var document = fs.createReadStream(__dirname+'/bot.gif'); const document = fs.createReadStream(`${__dirname}/bot.gif`);
bot.sendDocument(USERID, document).then(function (resp) { return bot.sendDocument(USERID, document).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a document from request Stream', function (done) { it('should send a document from request Stream', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var document = request('https://telegram.org/img/t_logo.png'); const document = request('https://telegram.org/img/t_logo.png');
bot.sendDocument(USERID, document).then(function (resp) { return bot.sendDocument(USERID, document).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a document from a Buffer', function (done) { it('should send a document from a Buffer', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var document = fs.readFileSync(__dirname+'/bot.gif'); const document = fs.readFileSync(`${__dirname}/bot.gif`);
bot.sendDocument(USERID, document).then(function (resp) { return bot.sendDocument(USERID, document).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
}); });
describe('#sendSticker', function () { describe('#sendSticker', function sendStickerSuite() {
var stickerId; let stickerId;
it('should send a sticker from file', function (done) { it('should send a sticker from file', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var sticker = __dirname+'/sticker.webp'; const sticker = `${__dirname}/sticker.webp`;
bot.sendSticker(USERID, sticker).then(function (resp) { return bot.sendSticker(USERID, sticker).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
stickerId = resp.sticker.file_id; stickerId = resp.sticker.file_id;
done();
}); });
}); });
it('should send a sticker from id', function (done) { it('should send a sticker from id', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
// Send the same photo as before // Send the same photo as before
bot.sendSticker(USERID, stickerId).then(function (resp) { return bot.sendSticker(USERID, stickerId).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a sticker from fs.readStream', function (done) { it('should send a sticker from fs.readStream', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var sticker = fs.createReadStream(__dirname+'/sticker.webp'); const sticker = fs.createReadStream(`${__dirname}/sticker.webp`);
bot.sendSticker(USERID, sticker).then(function (resp) { return bot.sendSticker(USERID, sticker).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a sticker from request Stream', function (done) { it('should send a sticker from request Stream', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var sticker = request('https://www.gstatic.com/webp/gallery3/1_webp_ll.webp'); const sticker = request('https://www.gstatic.com/webp/gallery3/1_webp_ll.webp');
bot.sendSticker(USERID, sticker).then(function (resp) { return bot.sendSticker(USERID, sticker).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a sticker from a Buffer', function (done) { it('should send a sticker from a Buffer', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var sticker = fs.readFileSync(__dirname+'/sticker.webp'); const sticker = fs.readFileSync(`${__dirname}/sticker.webp`);
bot.sendDocument(USERID, sticker).then(function (resp) { return bot.sendDocument(USERID, sticker).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
}); });
describe('#sendVideo', function () { describe('#sendVideo', function sendVideoSuite() {
var videoId; let videoId;
it('should send a video from file', function (done) { it('should send a video from file', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var video = __dirname+'/video.mp4'; const video = `${__dirname}/video.mp4`;
bot.sendVideo(USERID, video).then(function (resp) { return bot.sendVideo(USERID, video).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
videoId = resp.video.file_id; videoId = resp.video.file_id;
done();
}); });
}); });
it('should send a video from id', function (done) { it('should send a video from id', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
// Send the same photo as before // Send the same photo as before
bot.sendVideo(USERID, videoId).then(function (resp) { return bot.sendVideo(USERID, videoId).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a video from fs.readStream', function (done) { it('should send a video from fs.readStream', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var video = fs.createReadStream(__dirname+'/video.mp4'); const video = fs.createReadStream(`${__dirname}/video.mp4`);
bot.sendVideo(USERID, video).then(function (resp) { return bot.sendVideo(USERID, video).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a video from request Stream', function (done) { it('should send a video from request Stream', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var sticker = request('http://techslides.com/demos/sample-videos/small.mp4'); const sticker = request('http://techslides.com/demos/sample-videos/small.mp4');
bot.sendVideo(USERID, sticker).then(function (resp) { return bot.sendVideo(USERID, sticker).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
it('should send a video from a Buffer', function (done) { it('should send a video from a Buffer', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var video = fs.readFileSync(__dirname+'/video.mp4'); const video = fs.readFileSync(`${__dirname}/video.mp4`);
bot.sendVideo(USERID, video).then(function (resp) { return bot.sendVideo(USERID, video).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
}); });
describe('#sendVoice', function () { describe('#sendVoice', function sendVoiceSuite() {
it('should send an OGG audio as voice', function (done) { it('should send an OGG audio as voice', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var voice = request('https://upload.wikimedia.org/wikipedia/commons/c/c8/Example.ogg'); const voice = request('https://upload.wikimedia.org/wikipedia/commons/c/c8/Example.ogg');
bot.sendVoice(USERID, voice).then(function (resp) { return bot.sendVoice(USERID, voice).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
done();
}); });
}); });
}); });
describe('#getUserProfilePhotos', function () { describe('#getUserProfilePhotos', function getUserProfilePhotosSuite() {
it('should get user profile photos', function (done) { it('should get user profile photos', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
bot.getUserProfilePhotos(USERID).then(function (resp) { return bot.getUserProfilePhotos(USERID).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
resp.total_count.should.be.an.instanceOf(Number); assert.ok(is.number(resp.total_count));
resp.photos.should.be.an.instanceOf(Array); assert.ok(is.array(resp.photos));
done();
}); });
}); });
}); });
describe('#sendLocation', function () { describe('#sendLocation', function sendLocationSuite() {
it('should send a location', function (done) { it('should send a location', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var lat = 47.5351072; const lat = 47.5351072;
var long = -52.7508537; const long = -52.7508537;
bot.sendLocation(USERID, lat, long).then(function (resp) { return bot.sendLocation(USERID, lat, long).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
resp.location.should.be.an.instanceOf(Object); assert.ok(is.object(resp.location));
resp.location.latitude.should.be.an.instanceOf(Number); assert.ok(is.number(resp.location.latitude));
resp.location.longitude.should.be.an.instanceOf(Number); assert.ok(is.number(resp.location.longitude));
done();
}); });
}); });
}); });
describe('#getFile', function () { describe('#getFile', function getFileSuite() {
var fileId; let fileId;
// To get a file we have to send any file first // To get a file we have to send any file first
it('should send a photo from file', function (done) { it('should send a photo from file', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var photo = __dirname + '/bot.gif'; const photo = `${__dirname}/bot.gif`;
bot.sendPhoto(USERID, photo).then(function (resp) { return bot.sendPhoto(USERID, photo).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
fileId = resp.photo[0].file_id; fileId = resp.photo[0].file_id;
done();
}); });
}); });
it('should get a file', function (done) { it('should get a file', function test() {
const bot = new Telegram(TOKEN);
var bot = new Telegram(TOKEN); return bot
.getFile(fileId)
bot.getFile(fileId).then(function (resp) { .then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
resp.file_path.should.be.an.instanceOf(String); assert.ok(is.string(resp.file_path));
done(); });
});
}); });
}); });
describe('#getFileLink', function () { describe('#getFileLink', function getFileLinkSuite() {
var fileId; let fileId;
// To get a file we have to send any file first // To get a file we have to send any file first
it('should send a photo from file', function (done) { it('should send a photo from file', function test() {
var bot = new Telegram(TOKEN); const bot = new Telegram(TOKEN);
var photo = __dirname + '/bot.gif'; const photo = `${__dirname}/bot.gif`;
bot.sendPhoto(USERID, photo).then(function (resp) { return bot.sendPhoto(USERID, photo).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
fileId = resp.photo[0].file_id; fileId = resp.photo[0].file_id;
done();
}); });
}); });
it('should get a file link', function (done) { it('should get a file link', function test() {
const bot = new Telegram(TOKEN);
var bot = new Telegram(TOKEN); return bot
.getFileLink(fileId)
bot.getFileLink(fileId).then(function (fileURI) { .then(fileURI => {
fileURI.should.be.an.instanceOf(String); assert.ok(is.string(fileURI));
fileURI.should.startWith('https'); assert.equal(fileURI.indexOf('https'), 0);
done(); // TODO: validate URL with some library or regexp // TODO: validate URL with some library or regexp
}); });
}); });
}); });
describe('#downloadFile', function () { describe('#downloadFile', function downloadFileSuite() {
const downloadPath = __dirname;
var downloadPath = __dirname; it('should download a file', function test() {
const bot = new Telegram(TOKEN);
it('should download a file', function (done) { const photo = `${__dirname}/bot.gif`;
var bot = new Telegram(TOKEN);
var photo = __dirname + '/bot.gif';
// Send a file to get the ID // Send a file to get the ID
bot.sendPhoto(USERID, photo).then(function (resp) { return bot.sendPhoto(USERID, photo).then(resp => {
resp.should.be.an.instanceOf(Object); assert.ok(is.object(resp));
var fileId = resp.photo[0].file_id; const fileId = resp.photo[0].file_id;
bot.downloadFile(fileId, downloadPath) return bot
.then(function (filePath) { .downloadFile(fileId, downloadPath)
filePath.should.be.an.instanceOf(String); .then(filePath => {
fs.existsSync(filePath).should.be.true(); assert.ok(is.string(filePath));
assert.ok(fs.existsSync(filePath));
fs.unlinkSync(filePath); // Delete file after test fs.unlinkSync(filePath); // Delete file after test
done(); });
});
}); });
}); });
}); });
it('should call `onText` callback on match', function (done) { it('should call `onText` callback on match', function test(done) {
var bot = new Telegram(TOKEN, {webHook: true}); const bot = new Telegram(TOKEN, { webHook: true });
bot.onText(/\/echo (.+)/, function (msg, match) { bot.onText(/\/echo (.+)/, (msg, match) => {
bot._WebHook._webServer.close(); bot._WebHook._webServer.close();
match[1].should.be.exactly('ECHO ALOHA'); assert.equal(match[1], 'ECHO ALOHA');
done(); done();
}); });
var url = 'http://localhost:8443/bot'+TOKEN; const url = `http://localhost:8443/bot${TOKEN}`;
request({ request({
url: url, url,
method: 'POST', method: 'POST',
json: true, json: true,
headers: { headers: {
'content-type': 'application/json', 'content-type': 'application/json',
}, },
body: {update_id: 0, message: {text: '/echo ECHO ALOHA'}} body: { update_id: 0, message: { text: '/echo ECHO ALOHA' } }
}); });
}); });
}); // End Telegram }); // End Telegram
describe('#TelegramBotPolling', function TelegramBotPollingSuite() {
describe('#TelegramBotPolling', function () { it('should call the callback on polling', function test(done) {
it('should call the callback on polling', function (done) { const opts = { interval: 100, timeout: 1 };
var opts = {interval: 100, timeout: 1}; const polling = new TelegramPolling(TOKEN, opts, (msg) => {
var polling = new TelegramPolling(TOKEN, opts, function (msg) {
if (msg.update_id === 10) { if (msg.update_id === 10) {
done(); done();
} }
}); });
// The second time _getUpdates is called it will return a message // The second time _getUpdates is called it will return a message
// Really dirty but it works // Really dirty but it works
polling._getUpdates = function () { polling._getUpdates = () => {
return new Promise.resolve([{update_id: 10, message: {}}]); return new Promise.resolve([{ update_id: 10, message: {} }]);
}; };
}); });
}); });

1
test/mocha.opts Normal file
View File

@ -0,0 +1 @@
--require babel-register