mudhorn/n8n
1
0
Fork 0
mirror of https://github.com/n8n-io/n8n.git synced 2024-12-24 04:04:06 -08:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

feat(Redis Node): Add support for TLS (#9266)

Browse source
This commit is contained in:
कारतोफ्फेलस्क्रिप्ट™ 2024-05-02 17:35:41 +02:00 committed by GitHub
parent 30c8efc4cc
commit 0a2de093c0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
3 changed files with 158 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
packages/nodes-base/credentials/Redis.credentials.ts
View file

@ -35,5 +35,11 @@ export class Redis implements ICredentialType {
type: 'number',
default: 0,
},
{
displayName: 'SSL',
name: 'ssl',
type: 'boolean',
default: false,
},
];
}

251
packages/nodes-base/nodes/Redis/test/Redis.node.test.ts
View file

@ -1,36 +1,79 @@
import { mock } from 'jest-mock-extended';
import type { RedisClientType } from '@redis/client';
import type { IExecuteFunctions } from 'n8n-workflow';
import { Redis } from '../Redis.node';
const mockClient = mock<RedisClientType>();
jest.mock('redis', () => ({
createClient: () => mockClient,
}));
const createClient = jest.fn().mockReturnValue(mockClient);
jest.mock('redis', () => ({ createClient }));
import { Redis } from '../Redis.node';
import { setupRedisClient } from '../utils';
describe('Redis Node', () => {
const mockCredential = {
host: 'redis',
port: 1234,
database: 0,
password: 'random',
};
const node = new Redis();
const thisArg = mock<IExecuteFunctions>({});
thisArg.getCredentials.calledWith('redis').mockResolvedValue(mockCredential);
beforeEach(() => jest.clearAllMocks());
afterEach(() => {
expect(mockClient.connect).toHaveBeenCalled();
expect(mockClient.ping).toHaveBeenCalled();
expect(mockClient.quit).toHaveBeenCalled();
describe('setupRedisClient', () => {
it('should not configure TLS by default', () => {
setupRedisClient({
host: 'redis.domain',
port: 1234,
database: 0,
});
expect(createClient).toHaveBeenCalledWith({
database: 0,
password: undefined,
socket: {
host: 'redis.domain',
port: 1234,
tls: false,
},
});
});
it('should configure TLS', () => {
setupRedisClient({
host: 'redis.domain',
port: 1234,
database: 0,
ssl: true,
});
expect(createClient).toHaveBeenCalledWith({
database: 0,
password: undefined,
socket: {
host: 'redis.domain',
port: 1234,
tls: true,
},
});
});
});
it('info operation', async () => {
thisArg.getNodeParameter.calledWith('operation', 0).mockReturnValue('info');
mockClient.info.mockResolvedValue(`
describe('operations', () => {
const thisArg = mock<IExecuteFunctions>({});
const mockCredential = {
host: 'redis',
port: 1234,
database: 0,
password: 'random',
};
thisArg.getCredentials.calledWith('redis').mockResolvedValue(mockCredential);
afterEach(() => {
expect(createClient).toHaveBeenCalled();
expect(mockClient.connect).toHaveBeenCalled();
expect(mockClient.ping).toHaveBeenCalled();
expect(mockClient.quit).toHaveBeenCalled();
});
describe('info operation', () => {
it('should return info', async () => {
thisArg.getNodeParameter.calledWith('operation', 0).mockReturnValue('info');
mockClient.info.mockResolvedValue(`
# Server
redis_version:6.2.14
redis_git_sha1:00000000
@ -55,104 +98,108 @@ connected_slaves:0
master_failover_state:no-failover
`);
const output = await node.execute.call(thisArg);
const output = await node.execute.call(thisArg);
expect(mockClient.info).toHaveBeenCalled();
expect(output[0][0].json).toEqual({
redis_version: 6.2,
redis_git_sha1: 0,
redis_git_dirty: 0,
redis_mode: 'standalone',
arch_bits: 64,
tcp_port: 6379,
uptime_in_seconds: 429905,
uptime_in_days: 4,
connected_clients: 1,
cluster_connections: 0,
max_clients: 10000,
used_memory: 876648,
role: 'master',
connected_slaves: 0,
master_failover_state: 'no-failover',
});
});
it('delete operation', async () => {
thisArg.getInputData.mockReturnValue([{ json: { x: 1 } }]);
thisArg.getNodeParameter.calledWith('operation', 0).mockReturnValue('delete');
thisArg.getNodeParameter.calledWith('key', 0).mockReturnValue('key1');
mockClient.del.calledWith('key1').mockResolvedValue(1);
const output = await node.execute.call(thisArg);
expect(mockClient.del).toHaveBeenCalledWith('key1');
expect(output[0][0].json).toEqual({ x: 1 });
});
describe('get operation', () => {
beforeEach(() => {
thisArg.getInputData.mockReturnValue([{ json: { x: 1 } }]);
thisArg.getNodeParameter.calledWith('operation', 0).mockReturnValue('get');
thisArg.getNodeParameter.calledWith('options', 0).mockReturnValue({ dotNotation: true });
thisArg.getNodeParameter.calledWith('key', 0).mockReturnValue('key1');
thisArg.getNodeParameter.calledWith('propertyName', 0).mockReturnValue('x.y');
expect(mockClient.info).toHaveBeenCalled();
expect(output[0][0].json).toEqual({
redis_version: 6.2,
redis_git_sha1: 0,
redis_git_dirty: 0,
redis_mode: 'standalone',
arch_bits: 64,
tcp_port: 6379,
uptime_in_seconds: 429905,
uptime_in_days: 4,
connected_clients: 1,
cluster_connections: 0,
max_clients: 10000,
used_memory: 876648,
role: 'master',
connected_slaves: 0,
master_failover_state: 'no-failover',
});
});
});
it('keyType = automatic', async () => {
thisArg.getNodeParameter.calledWith('keyType', 0).mockReturnValue('automatic');
mockClient.type.calledWith('key1').mockResolvedValue('string');
mockClient.get.calledWith('key1').mockResolvedValue('value');
describe('delete operation', () => {
it('should delete', async () => {
thisArg.getInputData.mockReturnValue([{ json: { x: 1 } }]);
thisArg.getNodeParameter.calledWith('operation', 0).mockReturnValue('delete');
thisArg.getNodeParameter.calledWith('key', 0).mockReturnValue('key1');
mockClient.del.calledWith('key1').mockResolvedValue(1);
const output = await node.execute.call(thisArg);
expect(mockClient.type).toHaveBeenCalledWith('key1');
expect(mockClient.get).toHaveBeenCalledWith('key1');
expect(output[0][0].json).toEqual({ x: { y: 'value' } });
const output = await node.execute.call(thisArg);
expect(mockClient.del).toHaveBeenCalledWith('key1');
expect(output[0][0].json).toEqual({ x: 1 });
});
});
it('keyType = hash', async () => {
thisArg.getNodeParameter.calledWith('keyType', 0).mockReturnValue('hash');
mockClient.hGetAll.calledWith('key1').mockResolvedValue({
field1: '1',
field2: '2',
describe('get operation', () => {
beforeEach(() => {
thisArg.getInputData.mockReturnValue([{ json: { x: 1 } }]);
thisArg.getNodeParameter.calledWith('operation', 0).mockReturnValue('get');
thisArg.getNodeParameter.calledWith('options', 0).mockReturnValue({ dotNotation: true });
thisArg.getNodeParameter.calledWith('key', 0).mockReturnValue('key1');
thisArg.getNodeParameter.calledWith('propertyName', 0).mockReturnValue('x.y');
});
const output = await node.execute.call(thisArg);
expect(mockClient.hGetAll).toHaveBeenCalledWith('key1');
expect(output[0][0].json).toEqual({
x: {
y: {
field1: '1',
field2: '2',
it('keyType = automatic', async () => {
thisArg.getNodeParameter.calledWith('keyType', 0).mockReturnValue('automatic');
mockClient.type.calledWith('key1').mockResolvedValue('string');
mockClient.get.calledWith('key1').mockResolvedValue('value');
const output = await node.execute.call(thisArg);
expect(mockClient.type).toHaveBeenCalledWith('key1');
expect(mockClient.get).toHaveBeenCalledWith('key1');
expect(output[0][0].json).toEqual({ x: { y: 'value' } });
});
it('keyType = hash', async () => {
thisArg.getNodeParameter.calledWith('keyType', 0).mockReturnValue('hash');
mockClient.hGetAll.calledWith('key1').mockResolvedValue({
field1: '1',
field2: '2',
});
const output = await node.execute.call(thisArg);
expect(mockClient.hGetAll).toHaveBeenCalledWith('key1');
expect(output[0][0].json).toEqual({
x: {
y: {
field1: '1',
field2: '2',
},
},
},
});
});
});
});
describe('keys operation', () => {
beforeEach(() => {
thisArg.getInputData.mockReturnValue([{ json: { x: 1 } }]);
thisArg.getNodeParameter.calledWith('operation', 0).mockReturnValue('keys');
thisArg.getNodeParameter.calledWith('keyPattern', 0).mockReturnValue('key*');
mockClient.keys.calledWith('key*').mockResolvedValue(['key1', 'key2']);
});
describe('keys operation', () => {
beforeEach(() => {
thisArg.getInputData.mockReturnValue([{ json: { x: 1 } }]);
thisArg.getNodeParameter.calledWith('operation', 0).mockReturnValue('keys');
thisArg.getNodeParameter.calledWith('keyPattern', 0).mockReturnValue('key*');
mockClient.keys.calledWith('key*').mockResolvedValue(['key1', 'key2']);
});
it('getValues = false', async () => {
thisArg.getNodeParameter.calledWith('getValues', 0).mockReturnValue(false);
it('getValues = false', async () => {
thisArg.getNodeParameter.calledWith('getValues', 0).mockReturnValue(false);
const output = await node.execute.call(thisArg);
expect(mockClient.keys).toHaveBeenCalledWith('key*');
expect(output[0][0].json).toEqual({ keys: ['key1', 'key2'] });
});
const output = await node.execute.call(thisArg);
expect(mockClient.keys).toHaveBeenCalledWith('key*');
expect(output[0][0].json).toEqual({ keys: ['key1', 'key2'] });
});
it('getValues = true', async () => {
thisArg.getNodeParameter.calledWith('getValues', 0).mockReturnValue(true);
mockClient.type.mockResolvedValue('string');
mockClient.get.calledWith('key1').mockResolvedValue('value1');
mockClient.get.calledWith('key2').mockResolvedValue('value2');
it('getValues = true', async () => {
thisArg.getNodeParameter.calledWith('getValues', 0).mockReturnValue(true);
mockClient.type.mockResolvedValue('string');
mockClient.get.calledWith('key1').mockResolvedValue('value1');
mockClient.get.calledWith('key2').mockResolvedValue('value2');
const output = await node.execute.call(thisArg);
expect(mockClient.keys).toHaveBeenCalledWith('key*');
expect(output[0][0].json).toEqual({ key1: 'value1', key2: 'value2' });
const output = await node.execute.call(thisArg);
expect(mockClient.keys).toHaveBeenCalledWith('key*');
expect(output[0][0].json).toEqual({ key1: 'value1', key2: 'value2' });
});
});
});
});

5
packages/nodes-base/nodes/Redis/utils.ts
View file

@ -8,14 +8,15 @@ import type {
} from 'n8n-workflow';
import { NodeOperationError } from 'n8n-workflow';
import { createClient } from 'redis';
import { type RedisClientOptions, createClient } from 'redis';
export type RedisClientType = ReturnType<typeof createClient>;
export function setupRedisClient(credentials: ICredentialDataDecryptedObject): RedisClientType {
const redisOptions = {
const redisOptions: RedisClientOptions = {
socket: {
host: credentials.host as string,
port: credentials.port as number,
tls: credentials.ssl === true,
},
database: credentials.database as number,
password: (credentials.password as string) || undefined,