9805766275

Committed 04 Jul 2024 10:22PM UTC coverage: 48.431% (-0.09%) from 48.517%

Build # 9805766275

Build Type

Pull #1715

github

Committed by

hectorgomezv

Commit Message

Add unit tests

Pull Request Pull Request #1715: Implement /v1/accounts/:address/data-settings

Run Details

412 of 2552 branches covered (16.14%)

Branch coverage included in aggregate %.

20 of 49 new or added lines in 8 files covered. (40.82%)

2 existing lines in 1 file now uncovered.

4234 of 7041 relevant lines covered (60.13%)

13.11 hits per line

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

11.63

/src/datasources/accounts/accounts.datasource.ts

import { AccountDataSetting } from '@/domain/accounts/entities/account-data-setting.entity';
import { AccountDataType } from '@/domain/accounts/entities/account-data-type.entity';
import { Account } from '@/domain/accounts/entities/account.entity';
import { UpsertAccountDataSettingsDto } from '@/domain/accounts/entities/upsert-account-data-settings.dto.entity';
import { IAccountsDatasource } from '@/domain/interfaces/accounts.datasource.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { asError } from '@/logging/utils';
import {
  Inject,
  Injectable,
  NotFoundException,
  UnprocessableEntityException,
} from '@nestjs/common';
import postgres from 'postgres';

@Injectable()
export class AccountsDatasource implements IAccountsDatasource {
  constructor(
    @Inject('DB_INSTANCE') private readonly sql: postgres.Sql,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {}

  async createAccount(address: `0x${string}`): Promise<Account> {
    const [account] = await this.sql<
      [Account]
    >`INSERT INTO accounts (address) VALUES (${address}) RETURNING *`.catch(
      (e) => {
        this.loggingService.warn(
          `Error creating account: ${asError(e).message}`,
        );
        return [];
      },
    );

    if (!account) {
      throw new UnprocessableEntityException('Error creating account.');
    }

    return account;
  }

  async getAccount(address: `0x${string}`): Promise<Account> {
    const [account] = await this.sql<
      [Account]
    >`SELECT * FROM accounts WHERE address = ${address}`.catch((e) => {
      this.loggingService.info(`Error getting account: ${asError(e).message}`);
      return [];
    });

    if (!account) {
      throw new NotFoundException('Error getting account.');
    }

    return account;
  }

  async deleteAccount(address: `0x${string}`): Promise<void> {
    const { count } = await this
      .sql`DELETE FROM accounts WHERE address = ${address}`;

    if (count === 0) {
      this.loggingService.debug(`Error deleting account ${address}: not found`);
    }
  }

  async getDataTypes(): Promise<AccountDataType[]> {
    return this.sql<[AccountDataType]>`SELECT * FROM account_data_types`;
  }

  async upsertAccountDataSettings(
    address: `0x${string}`,
    upsertAccountDataSettings: UpsertAccountDataSettingsDto,
  ): Promise<AccountDataSetting[]> {
    const account = await this.getAccount(address);
    const dataTypes = await this.getDataTypes();
    const { accountDataSettings } = upsertAccountDataSettings;

    const result = [];
    for (const ads of accountDataSettings) {
      const dataType = dataTypes.find((dt) => dt.name === ads.dataTypeName);
      if (!dataType) {
        throw new UnprocessableEntityException('Invalid data type.');
      }
      const [inserted] = await this.sql<[AccountDataSetting]>`
        INSERT INTO account_data_settings (account_id, account_data_type_id, enabled)
        VALUES (${account.id}, ${dataType.id}, ${ads.enabled})
        ON CONFLICT (account_id, account_data_type_id) DO UPDATE SET enabled = EXCLUDED.enabled
        RETURNING *
      `.catch((e) => {
        throw new UnprocessableEntityException(
          `Error updating data settings: ${asError(e).message}`,
        );
      });
      result.push(inserted);
    }

    return result;
  }
}

1	import { AccountDataSetting } from '@/domain/accounts/entities/account-data-setting.entity';
2	import { AccountDataType } from '@/domain/accounts/entities/account-data-type.entity';
3	import { Account } from '@/domain/accounts/entities/account.entity';
4	import { UpsertAccountDataSettingsDto } from '@/domain/accounts/entities/upsert-account-data-settings.dto.entity';
5	import { IAccountsDatasource } from '@/domain/interfaces/accounts.datasource.interface';
6	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
7	import { asError } from '@/logging/utils';	16✔
8	import {	16✔
9	Inject,
10	Injectable,
11	NotFoundException,
12	UnprocessableEntityException,
13	} from '@nestjs/common';
14	import postgres from 'postgres';	16✔
15
16	@Injectable()
17	export class AccountsDatasource implements IAccountsDatasource {	16✔
18	constructor(
19	@Inject('DB_INSTANCE') private readonly sql: postgres.Sql,	×
20	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
21	) {}
22
23	async createAccount(address: `0x${string}`): Promise<Account> {
24	const [account] = await this.sql<	×
25	[Account]
26	>`INSERT INTO accounts (address) VALUES (${address}) RETURNING *`.catch(
27	(e) => {
28	this.loggingService.warn(	×
29	`Error creating account: ${asError(e).message}`,
30	);
31	return [];	×
32	},
33	);
34
35	if (!account) {	×
36	throw new UnprocessableEntityException('Error creating account.');	×
37	}
38
39	return account;	×
40	}
41
42	async getAccount(address: `0x${string}`): Promise<Account> {
43	const [account] = await this.sql<	×
44	[Account]
45	>`SELECT * FROM accounts WHERE address = ${address}`.catch((e) => {
46	this.loggingService.info(`Error getting account: ${asError(e).message}`);	×
47	return [];	×
48	});
49
50	if (!account) {	×
51	throw new NotFoundException('Error getting account.');	×
52	}
53
54	return account;	×
55	}
56
57	async deleteAccount(address: `0x${string}`): Promise<void> {
58	const { count } = await this	×
59	.sql`DELETE FROM accounts WHERE address = ${address}`;
60
61	if (count === 0) {	×
62	this.loggingService.debug(`Error deleting account ${address}: not found`);	×
63	}
64	}
65
66	async getDataTypes(): Promise<AccountDataType[]> {
67	return this.sql<[AccountDataType]>`SELECT * FROM account_data_types`;	×
68	}
69
70	async upsertAccountDataSettings(
71	address: `0x${string}`,
72	upsertAccountDataSettings: UpsertAccountDataSettingsDto,
73	): Promise<AccountDataSetting[]> {
NEW 74	const account = await this.getAccount(address);	×
NEW 75	const dataTypes = await this.getDataTypes();	×
NEW 76	const { accountDataSettings } = upsertAccountDataSettings;	×
77
NEW 78	const result = [];	×
NEW 79	for (const ads of accountDataSettings) {	×
NEW 80	const dataType = dataTypes.find((dt) => dt.name === ads.dataTypeName);	×
NEW 81	if (!dataType) {	×
NEW 82	throw new UnprocessableEntityException('Invalid data type.');	×
83	}
NEW 84	const [inserted] = await this.sql<[AccountDataSetting]>`	×
85	INSERT INTO account_data_settings (account_id, account_data_type_id, enabled)
86	VALUES (${account.id}, ${dataType.id}, ${ads.enabled})
87	ON CONFLICT (account_id, account_data_type_id) DO UPDATE SET enabled = EXCLUDED.enabled
88	RETURNING *
89	`.catch((e) => {
NEW 90	throw new UnprocessableEntityException(	×
91	`Error updating data settings: ${asError(e).message}`,
92	);
93	});
NEW 94	result.push(inserted);	×
95	}
96
NEW 97	return result;	×
98	}
99	}

safe-global / safe-client-gateway / 9805766275

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