7298481371

Committed 22 Dec 2023 09:46AM UTC coverage: 90.379% (-0.05%) from 90.429%

Build # 7298481371

Build Type

Pull #970

github

Committed by

hectorgomezv

Commit Message

Add comments explaining tests expectations

Pull Request Pull Request #970: Check datasources request lifespan before caching its response

Run Details

1441 of 1716 branches covered (0.0%)

Branch coverage included in aggregate %.

17 of 29 new or added lines in 3 files covered. (58.62%)

1 existing line in 1 file now uncovered.

5407 of 5861 relevant lines covered (92.25%)

151.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.67

/src/datasources/config-api/config-api.service.ts

import { Inject, Injectable } from '@nestjs/common';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';
import { CacheRouter } from '@/datasources/cache/cache.router';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';
import { Chain } from '@/domain/chains/entities/chain.entity';
import { Page } from '@/domain/entities/page.entity';
import { IConfigApi } from '@/domain/interfaces/config-api.interface';
import { SafeApp } from '@/domain/safe-apps/entities/safe-app.entity';
import { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';

@Injectable()
export class ConfigApi implements IConfigApi {
  private readonly baseUri: string;
  private readonly defaultExpirationTimeInSeconds: number;
  private readonly defaultNotFoundExpirationTimeSeconds: number;

  constructor(
    private readonly dataSource: CacheFirstDataSource,
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    private readonly httpErrorFactory: HttpErrorFactory,
  ) {
    this.baseUri =
      this.configurationService.getOrThrow<string>('safeConfig.baseUri');
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
    this.defaultNotFoundExpirationTimeSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.notFound.default',
      );
  }

  async getChains(args: {
    limit?: number;
    offset?: number;
  }): Promise<Page<Chain>> {
    try {
      const url = `${this.baseUri}/api/v1/chains`;
      const params = { limit: args.limit, offset: args.offset };
      const cacheDir = CacheRouter.getChainsCacheDir(args);
      return await this.dataSource.get({
        cacheDir,
        url,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: { params },
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async clearChains(): Promise<void> {
    const pattern = CacheRouter.getChainsCachePattern();
    const key = CacheRouter.getChainsCacheKey();
    await Promise.all([
      this.cacheService.deleteByKey(key),
      this.cacheService.deleteByKeyPattern(pattern),
      // TODO: call _setInvalidationTimeForKey for each item matching the pattern
      this._setInvalidationTimeForKey(key),
    ]);
  }

  async getChain(chainId: string): Promise<Chain> {
    try {
      const url = `${this.baseUri}/api/v1/chains/${chainId}`;
      const cacheDir = CacheRouter.getChainCacheDir(chainId);
      return await this.dataSource.get({
        cacheDir,
        url,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: undefined,
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async clearChain(chainId: string): Promise<void> {
    const chainCacheKey = CacheRouter.getChainCacheKey(chainId);
    const chainsCacheKey = CacheRouter.getChainsCacheKey();
    await Promise.all([
      this.cacheService.deleteByKey(chainCacheKey),
      this.cacheService.deleteByKey(chainsCacheKey),
      this._setInvalidationTimeForKey(chainCacheKey),
      this._setInvalidationTimeForKey(chainsCacheKey),
    ]);
  }

  async getSafeApps(args: {
    chainId?: string;
    clientUrl?: string;
    url?: string;
  }): Promise<SafeApp[]> {
    try {
      const providerUrl = `${this.baseUri}/api/v1/safe-apps/`;
      const params = {
        chainId: args.chainId,
        clientUrl: args.clientUrl,
        url: args.url,
      };
      const cacheDir = CacheRouter.getSafeAppsCacheDir(args);
      return await this.dataSource.get({
        cacheDir,
        url: providerUrl,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: { params },
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async clearSafeApps(chainId?: string): Promise<void> {
    if (chainId) {
      // if a chain id is provided, delete the safe apps data for that chain id
      const key = CacheRouter.getSafeAppsKey(chainId);
      await this.cacheService.deleteByKey(key);
      await this._setInvalidationTimeForKey(key);
    } else {
      // if a chain id is not provided, delete all the safe apps data
      const pattern = CacheRouter.getSafeAppsCachePattern();
      await this.cacheService.deleteByKeyPattern(pattern);
      // TODO: call _setInvalidationTimeForKey for each item matching the pattern
    }
  }

  private async _setInvalidationTimeForKey(key: string): Promise<void> {
    await this.cacheService.set(
      new CacheDir(`invalidationTimeMs:${key}`, ''),
      Date.now().toString(),
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      ),
    );
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	78✔
2	import { IConfigurationService } from '@/config/configuration.service.interface';	78✔
3	import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';	78✔
4	import { CacheRouter } from '@/datasources/cache/cache.router';	78✔
5	import {	78✔
6	CacheService,
7	ICacheService,
8	} from '@/datasources/cache/cache.service.interface';
9	import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';	78✔
10	import { Chain } from '@/domain/chains/entities/chain.entity';
11	import { Page } from '@/domain/entities/page.entity';
12	import { IConfigApi } from '@/domain/interfaces/config-api.interface';
13	import { SafeApp } from '@/domain/safe-apps/entities/safe-app.entity';
14	import { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';	78✔
15
16	@Injectable()
17	export class ConfigApi implements IConfigApi {	78✔
18	private readonly baseUri: string;
19	private readonly defaultExpirationTimeInSeconds: number;
20	private readonly defaultNotFoundExpirationTimeSeconds: number;
21
22	constructor(
23	private readonly dataSource: CacheFirstDataSource,	578✔
24	@Inject(CacheService) private readonly cacheService: ICacheService,	578✔
25	@Inject(IConfigurationService)
26	private readonly configurationService: IConfigurationService,	578✔
27	private readonly httpErrorFactory: HttpErrorFactory,	578✔
28	) {
29	this.baseUri =	578✔
30	this.configurationService.getOrThrow<string>('safeConfig.baseUri');
31	this.defaultExpirationTimeInSeconds =	576✔
32	this.configurationService.getOrThrow<number>(
33	'expirationTimeInSeconds.default',
34	);
35	this.defaultNotFoundExpirationTimeSeconds =	576✔
36	this.configurationService.getOrThrow<number>(
37	'expirationTimeInSeconds.notFound.default',
38	);
39	}
40
41	async getChains(args: {
42	limit?: number;
43	offset?: number;
44	}): Promise<Page<Chain>> {
45	try {	12✔
46	const url = `${this.baseUri}/api/v1/chains`;	12✔
47	const params = { limit: args.limit, offset: args.offset };	12✔
48	const cacheDir = CacheRouter.getChainsCacheDir(args);	12✔
49	return await this.dataSource.get({	12✔
50	cacheDir,
51	url,
52	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
53	networkRequest: { params },
54	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
55	});
56	} catch (error) {
57	throw this.httpErrorFactory.from(error);	4✔
58	}
59	}
60
61	async clearChains(): Promise<void> {
62	const pattern = CacheRouter.getChainsCachePattern();	4✔
63	const key = CacheRouter.getChainsCacheKey();	4✔
64	await Promise.all([	4✔
65	this.cacheService.deleteByKey(key),
66	this.cacheService.deleteByKeyPattern(pattern),
67	// TODO: call _setInvalidationTimeForKey for each item matching the pattern
68	this._setInvalidationTimeForKey(key),
69	]);
70	}
71
72	async getChain(chainId: string): Promise<Chain> {
73	try {	540✔
74	const url = `${this.baseUri}/api/v1/chains/${chainId}`;	540✔
75	const cacheDir = CacheRouter.getChainCacheDir(chainId);	540✔
76	return await this.dataSource.get({	540✔
77	cacheDir,
78	url,
79	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
80	networkRequest: undefined,
81	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
82	});
83	} catch (error) {
84	throw this.httpErrorFactory.from(error);	40✔
85	}
86	}
87
88	async clearChain(chainId: string): Promise<void> {
NEW 89	const chainCacheKey = CacheRouter.getChainCacheKey(chainId);	×
NEW 90	const chainsCacheKey = CacheRouter.getChainsCacheKey();	×
UNCOV 91	await Promise.all([	×
92	this.cacheService.deleteByKey(chainCacheKey),
93	this.cacheService.deleteByKey(chainsCacheKey),
94	this._setInvalidationTimeForKey(chainCacheKey),
95	this._setInvalidationTimeForKey(chainsCacheKey),
96	]);
97	}
98
99	async getSafeApps(args: {
100	chainId?: string;
101	clientUrl?: string;
102	url?: string;
103	}): Promise<SafeApp[]> {
104	try {	72✔
105	const providerUrl = `${this.baseUri}/api/v1/safe-apps/`;	72✔
106	const params = {	72✔
107	chainId: args.chainId,
108	clientUrl: args.clientUrl,
109	url: args.url,
110	};
111	const cacheDir = CacheRouter.getSafeAppsCacheDir(args);	72✔
112	return await this.dataSource.get({	72✔
113	cacheDir,
114	url: providerUrl,
115	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
116	networkRequest: { params },
117	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
118	});
119	} catch (error) {
120	throw this.httpErrorFactory.from(error);	×
121	}
122	}
123
124	async clearSafeApps(chainId?: string): Promise<void> {
125	if (chainId) {	6✔
126	// if a chain id is provided, delete the safe apps data for that chain id
127	const key = CacheRouter.getSafeAppsKey(chainId);	2✔
128	await this.cacheService.deleteByKey(key);	2✔
129	await this._setInvalidationTimeForKey(key);	2✔
130	} else {
131	// if a chain id is not provided, delete all the safe apps data
132	const pattern = CacheRouter.getSafeAppsCachePattern();	4✔
133	await this.cacheService.deleteByKeyPattern(pattern);	4✔
134	// TODO: call _setInvalidationTimeForKey for each item matching the pattern
135	}
136	}
137
138	private async _setInvalidationTimeForKey(key: string): Promise<void> {
139	await this.cacheService.set(	6✔
140	new CacheDir(`invalidationTimeMs:${key}`, ''),
141	Date.now().toString(),
142	this.configurationService.getOrThrow<number>(
143	'expirationTimeInSeconds.default',
144	),
145	);
146	}
147	}

safe-global / safe-client-gateway / 7298481371

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous