Support RedisTimeSeries

packages/time-series/lib/commands/ALTER.spec.ts

@@ -41,7 +41,7 @@ describe('ALTER', () => {
     });
 
     testUtils.testWithClient('client.ts.alter', async client => {
-        await client.ts.create('key');
+        await client.ts.create('key'); 
 
         assert.equal(
             await client.ts.alter('key', { RETENTION: 1 }),

packages/time-series/lib/commands/DECRBY.spec.ts

@@ -0,0 +1,81 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './DECRBY';
+
+describe('DECRBY', () => {
+    describe('transformArguments', () => {
+        it('without options', () => {
+            assert.deepEqual(
+                transformArguments('key', 1),
+                ['TS.DECRBY', 'key', '1']
+            );
+        });
+
+        it('with TIMESTAMP', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    TIMESTAMP: '*'
+                }),
+                ['TS.DECRBY', 'key', '1', 'TIMESTAMP', '*']
+            );
+        });
+
+        it('with RETENTION', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    RETENTION: 1
+                }),
+                ['TS.DECRBY', 'key', '1', 'RETENTION', '1']
+            );
+        });
+
+        it('with UNCOMPRESSED', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    UNCOMPRESSED: true
+                }),
+                ['TS.DECRBY', 'key', '1', 'UNCOMPRESSED']
+            );
+        });
+
+        it('with CHUNK_SIZE', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    CHUNK_SIZE: 100
+                }),
+                ['TS.DECRBY', 'key', '1', 'CHUNK_SIZE', '100']
+            );
+        });
+
+        it('with LABELS', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    LABELS: { label: 'value' }
+                }),
+                ['TS.DECRBY', 'key', '1', 'LABELS', 'label', 'value']
+            );
+        });
+
+        it('with TIMESTAMP, RETENTION, UNCOMPRESSED, CHUNK_SIZE and LABELS', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    TIMESTAMP: '*',
+                    RETENTION: 1,
+                    UNCOMPRESSED: true,
+                    CHUNK_SIZE: 2,
+                    LABELS: { label: 'value' }
+                }),
+                ['TS.DECRBY', 'key', '1', 'TIMESTAMP', '*', 'RETENTION', '1', 'UNCOMPRESSED', 'CHUNK_SIZE', '2', 'LABELS', 'label', 'value']
+            );
+        });
+    });
+
+    testUtils.testWithClient('client.ts.decrBy', async client => {
+        assert.equal(
+            await client.ts.decrBy('key', 1, {
+                TIMESTAMP: 0
+            }),
+            0
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/time-series/lib/commands/DEL.spec.ts

@@ -0,0 +1,21 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './DEL';
+
+describe('DEL', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key', '-', '+'),
+            ['TS.DEL', 'key', '-', '+']
+        );
+    });
+
+    testUtils.testWithClient('client.ts.del', async client => {
+        await client.ts.create('key');
+
+        assert.equal(
+            await client.ts.del('key', '-', '+'),
+            0
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/time-series/lib/commands/DELETERULE.spec.ts

@@ -0,0 +1,26 @@
+import { strict as assert } from 'assert';
+import { TimeSeriesAggregationType } from '.';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './DELETERULE';
+
+describe('DELETERULE', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('source', 'destination'),
+            ['TS.DELETERULE', 'source', 'destination']
+        );
+    });
+
+    testUtils.testWithClient('client.ts.deleteRule', async client => {
+        await Promise.all([
+            client.ts.create('source'),
+            client.ts.create('destination'),
+            client.ts.createRule('source', 'destination', TimeSeriesAggregationType.AVARAGE, 1)
+        ]);
+
+        assert.equal(
+            await client.ts.deleteRule('source', 'destination'),
+            'OK'
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/time-series/lib/commands/DELETERULE.ts

@@ -1,4 +1,6 @@
-export function transformArguments(sourceKey: string,destinationKey: string,): Array<string> {
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(sourceKey: string, destinationKey: string): Array<string> {
     return [
         'TS.DELETERULE',
         sourceKey,

packages/time-series/lib/commands/GET.spec.ts

@@ -0,0 +1,35 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './GET';
+
+describe('GET', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key'),
+            ['TS.GET', 'key']
+        );
+    });
+
+    describe('client.ts.get', () => {
+        testUtils.testWithClient('null', async client => {
+            await client.ts.create('key');
+
+            assert.equal(
+                await client.ts.get('key'),
+                null
+            );
+        }, GLOBAL.SERVERS.OPEN);
+
+        testUtils.testWithClient('with samples', async client => {
+            await client.ts.add('key', 0, 1);
+
+            assert.deepEqual(
+                await client.ts.get('key'),
+                {
+                    timestamp: 0,
+                    value: 1
+                }
+            );
+        }, GLOBAL.SERVERS.OPEN);
+    });
+});

packages/time-series/lib/commands/INCRBY.spec.ts

@@ -0,0 +1,91 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './INCRBY';
+
+describe('INCRBY', () => {
+    describe('transformArguments', () => {
+        it('without options', () => {
+            assert.deepEqual(
+                transformArguments('key', 1),
+                ['TS.INCRBY', 'key', '1']
+            );
+        });
+
+        it('with TIMESTAMP', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    TIMESTAMP: '*'
+                }),
+                ['TS.INCRBY', 'key', '1', 'TIMESTAMP', '*']
+            );
+        });
+
+        it('with RETENTION', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    RETENTION: 1
+                }),
+                ['TS.INCRBY', 'key', '1', 'RETENTION', '1']
+            );
+        });
+
+        it('with UNCOMPRESSED', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    UNCOMPRESSED: true
+                }),
+                ['TS.INCRBY', 'key', '1', 'UNCOMPRESSED']
+            );
+        });
+
+        it('without UNCOMPRESSED', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    UNCOMPRESSED: false
+                }),
+                ['TS.INCRBY', 'key', '1']
+            );
+        });
+
+        it('with CHUNK_SIZE', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    CHUNK_SIZE: 1
+                }),
+                ['TS.INCRBY', 'key', '1', 'CHUNK_SIZE', '1']
+            );
+        });
+
+        it('with LABELS', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    LABELS: { label: 'value' }
+                }),
+                ['TS.INCRBY', 'key', '1', 'LABELS', 'label', 'value']
+            );
+        });
+
+        it('with TIMESTAMP, RETENTION, UNCOMPRESSED, CHUNK_SIZE and LABELS', () => {
+            assert.deepEqual(
+                transformArguments('key', 1, {
+                    TIMESTAMP: '*',
+                    RETENTION: 1,
+                    UNCOMPRESSED: true,
+                    CHUNK_SIZE: 1,
+                    LABELS: { label: 'value' }
+                }),
+                ['TS.INCRBY', 'key', '1', 'TIMESTAMP', '*', 'RETENTION', '1', 'UNCOMPRESSED',
+                'CHUNK_SIZE', '1', 'LABELS', 'label', 'value']
+            );
+        });
+    });
+
+    testUtils.testWithClient('client.ts.incrBy', async client => {
+        assert.equal(
+            await client.ts.incrBy('key', 1, {
+                TIMESTAMP: 0
+            }),
+            0
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/time-series/lib/commands/INFO.spec.ts

@@ -0,0 +1,50 @@
+import { strict as assert } from 'assert';
+import { TimeSeriesAggregationType, TimeSeriesDuplicatePolicies } from '.';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './INFO';
+
+describe('INFO', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key'),
+            ['TS.INFO', 'key']
+        );
+    });
+
+    testUtils.testWithClient('client.ts.info', async client => {
+        await Promise.all([
+            client.ts.create('key', {
+                LABELS: { id: "2" },
+                DUPLICATE_POLICY: TimeSeriesDuplicatePolicies.LAST
+            }),
+            client.ts.create('key2'),
+            client.ts.createRule('key', 'key2', TimeSeriesAggregationType.COUNT, 5),
+            client.ts.add('key', 1, 10)
+        ]);
+
+        assert.deepEqual(
+            await client.ts.info('key'),
+            {
+                totalSamples: 1,
+                memoryUsage: 4261,
+                firstTimestamp: 1,
+                lastTimestamp: 1,
+                retentionTime: 0,
+                chunkCount: 1,
+                chunkSize: 4096,
+                chunkType: 'compressed',
+                duplicatePolicy: 'last',
+                labels: [{
+                    name: 'id',
+                    value: '2'
+                }],
+                rules: [{
+                    aggregationType: 'COUNT',
+                    key: 'key2',
+                    timeBucket: 5
+                }],
+                sourceKey: null
+            }
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/time-series/lib/commands/INFO_DEBUG.spec.ts

@@ -0,0 +1,57 @@
+import { strict as assert } from 'assert';
+import { TimeSeriesAggregationType, TimeSeriesDuplicatePolicies } from '.';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './INFO_DEBUG';
+
+describe('INFO_DEBUG', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key'),
+            ['TS.INFO', 'key', 'DEBUG']
+        );
+    });
+
+    testUtils.testWithClient('client.ts.get', async client => {
+        await Promise.all([
+            client.ts.create('key', {
+                LABELS: { id: "2" },
+                DUPLICATE_POLICY: TimeSeriesDuplicatePolicies.LAST
+            }),
+            client.ts.create('key2'),
+            client.ts.createRule('key', 'key2', TimeSeriesAggregationType.COUNT, 5),
+            client.ts.add('key', 1, 10)
+        ]);
+
+        assert.deepEqual(
+            await client.ts.infoDebug('key'),
+            {
+                totalSamples: 1,
+                memoryUsage: 4261,
+                firstTimestamp: 1,
+                lastTimestamp: 1,
+                retentionTime: 0,
+                chunkCount: 1,
+                chunkSize: 4096,
+                chunkType: 'compressed',
+                duplicatePolicy: 'last',
+                labels: [{
+                    name: 'id',
+                    value: '2'
+                }],
+                sourceKey: null,
+                rules: [{
+                    aggregationType: 'COUNT',
+                    key: 'key2',
+                    timeBucket: 5
+                }],
+                chunks: [{
+                    startTimestamp: 1,
+                    endTimestamp: 1,
+                    samples: 1,
+                    size: 4096,
+                    bytesPerSample: '4096'
+                }]
+            }
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});