setup integration test

node_modules/bottleneck/test.ts

@@ -0,0 +1,335 @@
+/// <reference path="bottleneck.d.ts" />
+
+import Bottleneck from "bottleneck";
+// import * as assert from "assert";
+function assert(b: boolean): void { }
+
+/*
+This file is run by scripts/build.sh.
+It is used to validate the typings in bottleneck.d.ts.
+The command is: tsc --noEmit --strictNullChecks test.ts
+This file cannot be run directly.
+In order to do that, you must comment out the first line,
+and change "bottleneck" to "." on the third line.
+*/
+
+function withCb(foo: number, bar: () => void, cb: (err: any, result: string) => void) {
+  let s: string = `cb ${foo}`;
+  cb(null, s);
+}
+
+console.log(Bottleneck);
+
+let limiter = new Bottleneck({
+  maxConcurrent: 5,
+  minTime: 1000,
+  highWater: 20,
+  strategy: Bottleneck.strategy.LEAK,
+  reservoirRefreshInterval: 1000 * 60,
+  reservoirRefreshAmount: 10,
+  reservoirIncreaseInterval: 1000 * 60,
+  reservoirIncreaseAmount: 2,
+  reservoirIncreaseMaximum: 15
+});
+
+limiter.ready().then(() => { console.log('Ready') });
+limiter.clients().client;
+limiter.disconnect();
+
+limiter.currentReservoir().then(function (x) {
+  if (x != null) {
+    let i: number = x;
+  }
+});
+
+limiter.incrementReservoir(5).then(function (x) {
+  if (x != null) {
+    let i: number = x;
+  }
+});
+
+limiter.running().then(function (x) {
+  let i: number = x;
+});
+
+limiter.clusterQueued().then(function (x) {
+  let i: number = x;
+});
+
+limiter.done().then(function (x) {
+  let i: number = x;
+});
+
+limiter.submit(withCb, 1, () => {}, (err, result) => {
+  let s: string = result;
+  console.log(s);
+  assert(s == "cb 1");
+});
+
+function withPromise(foo: number, bar: () => void): PromiseLike<string> {
+  let s: string = `promise ${foo}`;
+  return Promise.resolve(s);
+}
+
+let foo: Promise<string> = limiter.schedule(withPromise, 1, () => {});
+foo.then(function (result: string) {
+  let s: string = result;
+  console.log(s);
+  assert(s == "promise 1");
+});
+
+limiter.on("message", (msg) => console.log(msg));
+
+limiter.publish(JSON.stringify({ a: "abc", b: { c: 123 }}));
+
+function checkEventInfo(info: Bottleneck.EventInfo) {
+  const numArgs: number = info.args.length;
+  const id: string = info.options.id;
+}
+
+limiter.on('dropped', (info) => {
+  checkEventInfo(info)
+  const task: Function = info.task;
+  const promise: Promise<any> = info.promise;
+})
+
+limiter.on('received', (info) => {
+  checkEventInfo(info)
+})
+
+limiter.on('queued', (info) => {
+  checkEventInfo(info)
+  const blocked: boolean = info.blocked;
+  const reachedHWM: boolean = info.reachedHWM;
+})
+
+limiter.on('scheduled', (info) => {
+  checkEventInfo(info)
+})
+
+limiter.on('executing', (info) => {
+  checkEventInfo(info)
+  const count: number = info.retryCount;
+})
+
+limiter.on('failed', (error, info) => {
+  checkEventInfo(info)
+  const message: string = error.message;
+  const count: number = info.retryCount;
+  return Promise.resolve(10)
+})
+
+limiter.on('failed', (error, info) => {
+  checkEventInfo(info)
+  const message: string = error.message;
+  const count: number = info.retryCount;
+  return Promise.resolve(null)
+})
+
+limiter.on('failed', (error, info) => {
+  checkEventInfo(info)
+  const message: string = error.message;
+  const count: number = info.retryCount;
+  return Promise.resolve()
+})
+
+limiter.on('failed', (error, info) => {
+  checkEventInfo(info)
+  const message: string = error.message;
+  const count: number = info.retryCount;
+  return 10
+})
+
+limiter.on('failed', (error, info) => {
+  checkEventInfo(info)
+  const message: string = error.message;
+  const count: number = info.retryCount;
+  return null
+})
+
+limiter.on('failed', (error, info) => {
+  checkEventInfo(info)
+  const message: string = error.message;
+  const count: number = info.retryCount;
+})
+
+limiter.on('retry', (message: string, info) => {
+  checkEventInfo(info)
+  const count: number = info.retryCount;
+})
+
+limiter.on('done', (info) => {
+  checkEventInfo(info)
+  const count: number = info.retryCount;
+})
+
+let group = new Bottleneck.Group({
+  maxConcurrent: 5,
+  minTime: 1000,
+  highWater: 10,
+  strategy: Bottleneck.strategy.LEAK,
+  datastore: "ioredis",
+  clearDatastore: true,
+  clientOptions: {},
+  clusterNodes: []
+});
+
+group.on('created', (limiter, key) => {
+  assert(limiter.empty())
+  assert(key.length > 0)
+})
+
+group.key("foo").submit(withCb, 2, () => {}, (err, result) => {
+    let s: string = `${result} foo`;
+    console.log(s);
+    assert(s == "cb 2 foo");
+});
+
+group.key("bar").submit({ priority: 4 }, withCb, 3, () => {}, (err, result) => {
+    let s: string = `${result} bar`;
+    console.log(s);
+    assert(s == "cb 3 foo");
+});
+
+let f1: Promise<string> = group.key("pizza").schedule(withPromise, 2, () => {});
+f1.then(function (result: string) {
+  let s: string = result;
+  console.log(s);
+  assert(s == "promise 2");
+});
+
+let f2: Promise<string> = group.key("pie").schedule({ priority: 4 }, withPromise, 3, () => {});
+f2.then(function (result: string) {
+  let s: string = result;
+  console.log(s);
+  assert(s == "promise 3");
+});
+
+let wrapped = limiter.wrap((a: number, b: number) => {
+  let s: string = `Total: ${a + b}`;
+  return Promise.resolve(s);
+});
+
+wrapped(1, 2).then((x) => {
+  let s: string = x;
+  console.log(s);
+  assert(s == "Total: 3");
+});
+
+wrapped.withOptions({ priority: 1, id: 'some-id' }, 9, 9).then((x) => {
+  let s: string = x;
+  console.log(s);
+  assert(s == "Total: 18");
+})
+
+let counts = limiter.counts();
+console.log(`${counts.EXECUTING + 2}`);
+console.log(limiter.jobStatus('some-id'))
+console.log(limiter.jobs());
+console.log(limiter.jobs(Bottleneck.Status.RUNNING));
+
+
+group.deleteKey("pizza")
+.then(function (deleted: boolean) {
+  console.log(deleted)
+});
+group.updateSettings({ timeout: 5, maxConcurrent: null, reservoir: null });
+
+let keys: string[] = group.keys();
+assert(keys.length == 3);
+
+group.clusterKeys()
+.then(function (allKeys: string[]) {
+  let count = allKeys.length;
+})
+
+let queued: number = limiter.chain(group.key("pizza")).queued();
+
+limiter.stop({
+  dropWaitingJobs: true,
+  dropErrorMessage: "Begone!",
+  enqueueErrorMessage: "Denied!"
+}).then(() => {
+  console.log('All stopped.')
+})
+
+wrapped(4, 5).catch((e) => {
+  assert(e.message === "Denied!")
+})
+
+const id: string = limiter.id;
+const datastore: string = limiter.datastore;
+const channel: string = limiter.channel();
+
+const redisConnection = new Bottleneck.RedisConnection({
+  client: "NodeRedis client object",
+  clientOptions: {}
+})
+
+redisConnection.ready()
+.then(function (redisConnectionClients) {
+  const client = redisConnectionClients.client;
+  const subscriber = redisConnectionClients.subscriber;
+})
+
+redisConnection.on("error", (err) => {
+  console.log(err.message)
+})
+
+const limiterWithConn = new Bottleneck({
+  connection: redisConnection
+})
+
+const ioredisConnection = new Bottleneck.IORedisConnection({
+  client: "ioredis client object",
+  clientOptions: {},
+  clusterNodes: []
+})
+
+ioredisConnection.ready()
+.then(function (ioredisConnectionClients) {
+  const client = ioredisConnectionClients.client;
+  const subscriber = ioredisConnectionClients.subscriber;
+})
+
+ioredisConnection.on("error", (err: Bottleneck.BottleneckError) => {
+  console.log(err.message)
+})
+
+const groupWithConn = new Bottleneck.Group({
+  connection: ioredisConnection
+})
+
+const limiterWithConnFromGroup = new Bottleneck({
+  connection: groupWithConn.connection
+})
+
+const groupWithConnFromLimiter = new Bottleneck.Group({
+  connection: limiterWithConn.connection
+})
+
+
+const batcher = new Bottleneck.Batcher({
+  maxTime: 1000,
+  maxSize: 10
+})
+
+batcher.on("batch", (batch) => {
+  const len: number = batch.length
+  console.log("Number of elements:", len)
+})
+
+batcher.on("error", (err: Bottleneck.BottleneckError) => {
+  console.log(err.message)
+})
+
+batcher.add("abc")
+batcher.add({ xyz: 5 })
+.then(() => console.log("Flushed!"))
+
+const object = {}
+const emitter = new Bottleneck.Events(object)
+const listenerCount: number = emitter.listenerCount('info')
+emitter.trigger('info', 'hello', 'world', 123).then(function (result) {
+  console.log(result)
+})