lucasraziel

import { Data } from '@fvsystem/cache-template';
import RedisCacheProvider from '../src/provider/RedisCacheProvider';

jest.mock('ioredis');

let redisCacheProvider: RedisCacheProvider;

describe('RedisCacheProvider', () => {
  beforeEach(() => {
    redisCacheProvider = new RedisCacheProvider({});

lucasraziel

/* eslint-disable no-restricted-syntax */
import { FakeCacheProvider } from '@fvsystem/cache-template';
import { RedisOptions } from 'ioredis';

class Redis {
  fakeCache: FakeCacheProvider;

  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  constructor(options: RedisOptions) {
    this.fakeCache = new FakeCacheProvider();

lucasraziel

import RedisCacheProvider from './provider/RedisCacheProvider';

export default RedisCacheProvider;

lucasraziel

import { CacheTemplate, Data, SaveOptions } from '@fvsystem/cache-template';
import Redis, { RedisOptions } from 'ioredis';
import debug from 'debug';

const log = debug('fvsystem-template-cache');

export default class RedisCacheProvider implements CacheTemplate {
  private client: Redis;

  constructor(options: RedisOptions) {

lucasraziel

import Data from './dto/data';
import SaveOptions from './dto/saveOptions';
import CacheTemplate from './template/CacheTemplate';
import FakeCacheProvider from './fake/FakeCacheProvider';

export { Data, CacheTemplate, FakeCacheProvider, SaveOptions };

export default CacheTemplate;

lucasraziel

 it('should be able to remove value after some time', async () => {
    const data: Data<number> = {
      key: 'test',
      data: 1,
    };

    jest.useFakeTimers();

    fakeCacheProvider.save(data, 'app:', { ttlInSeconds: 3 });

lucasraziel

 async save(
    value: Data,
    prefix: string,
    options?: SaveOptions
  ): Promise<void> {
    this.cache.set(`${prefix}${value.key}`, value.data);
    if (options?.ttlInSeconds) {
      setTimeout(() => {
        this.invalidate(value.key, prefix);
      }, options.ttlInSeconds * 1000);

lucasraziel

import Data from '../dto/data';
import SaveOptions from '../dto/saveOptions';

export default interface ICacheProvider {
  save(value: Data, prefix: string, options?: SaveOptions): Promise<void>;
  invalidate(key: string, prefix: string): Promise<void>;
  recover<T = unknown>(key: string, prefix: string): Promise<T | null>;
}

lucasraziel

export default interface SaveOptions {
  ttlInSeconds?: number;
}

lucasraziel

import { FakeCacheProvider, Data } from '../src/index';

 let fakeCacheProvider: FakeCacheProvider;

 describe('Tests', () => {
   beforeEach(() => {
     fakeCacheProvider = new FakeCacheProvider();
   });
   it('should be abble to add and recover value', async () => {
     const data: Data<number> = {