6085223733

Committed 05 Sep 2023 01:24PM UTC coverage: 92.061% (-0.4%) from 92.5%

Build Type

github

Committed by Usame Algan

Commit Message

fix: Use class instances, remove try catch and fix test

Pull Request Pull Request #671: feat: Human readable v2

Run Details

1185 of 1411 branches covered (0.0%)

Branch coverage included in aggregate %.

69 of 78 new or added lines in 11 files covered. (88.46%)

6 existing lines in 3 files now uncovered.

4555 of 4824 relevant lines covered (94.42%)

151.12 hits per line

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

97.26

/src/routes/transactions/mappers/queued-items/queued-items.mapper.ts

import { Injectable } from '@nestjs/common';
import { flatten, groupBy } from 'lodash';
import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
import { Safe } from '@/domain/safe/entities/safe.entity';
import { Page } from '../../../common/entities/page.entity';
import { ConflictType } from '../../entities/conflict-type.entity';
import { QueuedItem } from '../../entities/queued-item.entity';
import { ConflictHeaderQueuedItem } from '../../entities/queued-items/conflict-header-queued-item.entity';
import {
  LabelItem,
  LabelQueuedItem,
} from '../../entities/queued-items/label-queued-item.entity';
import { TransactionQueuedItem } from '../../entities/queued-items/transaction-queued-item.entity';
import { MultisigTransactionMapper } from '../multisig-transactions/multisig-transaction.mapper';

class TransactionGroup {
  nonce: number;
  transactions: MultisigTransaction[];
}

@Injectable()
export class QueuedItemsMapper {
  constructor(private readonly mapper: MultisigTransactionMapper) {}

  async getQueuedItems(
    transactions: Page<MultisigTransaction>,
    safe: Safe,
    chainId: string,
    previousPageLastNonce: number | null,
    nextPageFirstNonce: number | null,
  ): Promise<QueuedItem[]> {
    const transactionGroups = this.groupByNonce(transactions.results);
    let lastProcessedNonce = previousPageLastNonce ?? -1;

    return flatten(
      await Promise.all(
        transactionGroups.map(async (transactionGroup) => {
          const transactionGroupItems: QueuedItem[] = [];
          const { nonce } = transactionGroup;
          if (lastProcessedNonce < safe.nonce && nonce === safe.nonce) {
            transactionGroupItems.push(new LabelQueuedItem(LabelItem.Next));
          } else if (lastProcessedNonce <= safe.nonce && nonce > safe.nonce) {
            transactionGroupItems.push(new LabelQueuedItem(LabelItem.Queued));
          }
          lastProcessedNonce = nonce;

          const isEdgeGroup = nonce === nextPageFirstNonce;
          const isSingleItemGroup = transactionGroup.transactions.length === 1;
          const conflictFromPreviousPage = nonce === previousPageLastNonce;
          const hasConflicts = !isSingleItemGroup || isEdgeGroup;
          if (hasConflicts && !conflictFromPreviousPage) {
            transactionGroupItems.push(new ConflictHeaderQueuedItem(nonce));
          }

          const mappedTransactionItems = await this.getMappedTransactionGroup(
            chainId,
            safe,
            hasConflicts,
            conflictFromPreviousPage,
            isEdgeGroup,
            transactionGroup,
          );

          transactionGroupItems.push(...mappedTransactionItems);
          return transactionGroupItems;
        }),
      ),
    );
  }

  private async getMappedTransactionGroup(
    chainId: string,
    safe: Safe,
    hasConflicts: boolean,
    conflictFromPreviousPage: boolean,
    isEdgeGroup: boolean,
    transactionGroup: TransactionGroup,
  ): Promise<TransactionQueuedItem[]> {
    return Promise.all(
      transactionGroup.transactions.map(async (transaction, idx) => {
        const isFirstInGroup = idx === 0;
        const isLastInGroup = idx === transactionGroup.transactions.length - 1;
        return new TransactionQueuedItem(
          await this.mapper.mapTransaction(chainId, transaction, safe),
          this.getConflictType(
            isFirstInGroup,
            isLastInGroup,
            hasConflicts,
            conflictFromPreviousPage,
            isEdgeGroup,
          ),
        );
      }),
    );
  }

  private getConflictType(
    isFirstInGroup: boolean,
    isLastInGroup: boolean,
    hasConflicts: boolean,
    conflictFromPreviousPage: boolean,
    isEdgeGroup: boolean,
  ): ConflictType {
    if (isFirstInGroup) {
      if (hasConflicts) {
        return ConflictType.HasNext;
      } else if (conflictFromPreviousPage) {
        return ConflictType.End;
      } else {
        return ConflictType.None;
      }
    }
    return !isLastInGroup || isEdgeGroup
      ? ConflictType.HasNext
      : ConflictType.End;
  }

  /**
   * Divides an array of transactions in groups with the same nonce.
   * Each TransactionGroup will contain at least one transaction.
   * @param transactions transactions with potentially different nonces.
   * @returns Array<TransactionGroup> in which each group of transactions has a different nonce.
   */
  private groupByNonce(
    transactions: MultisigTransaction[],
  ): TransactionGroup[] {
    return Object.entries(groupBy(transactions, 'nonce')).map(
      ([nonce, transactions]) =>
        <TransactionGroup>{
          nonce: Number(nonce),
          transactions: transactions,
        },
    );
  }
}

1	import { Injectable } from '@nestjs/common';	60✔
2	import { flatten, groupBy } from 'lodash';	60✔
3	import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
4	import { Safe } from '@/domain/safe/entities/safe.entity';
5	import { Page } from '../../../common/entities/page.entity';
6	import { ConflictType } from '../../entities/conflict-type.entity';	60✔
7	import { QueuedItem } from '../../entities/queued-item.entity';
8	import { ConflictHeaderQueuedItem } from '../../entities/queued-items/conflict-header-queued-item.entity';	60✔
9	import {	60✔
10	LabelItem,
11	LabelQueuedItem,
12	} from '../../entities/queued-items/label-queued-item.entity';
13	import { TransactionQueuedItem } from '../../entities/queued-items/transaction-queued-item.entity';	60✔
14	import { MultisigTransactionMapper } from '../multisig-transactions/multisig-transaction.mapper';	60✔
15
16	class TransactionGroup {
17	nonce: number;
18	transactions: MultisigTransaction[];
19	}
20
21	@Injectable()
22	export class QueuedItemsMapper {	60✔
23	constructor(private readonly mapper: MultisigTransactionMapper) {}	428✔
24
25	async getQueuedItems(
26	transactions: Page<MultisigTransaction>,
27	safe: Safe,
28	chainId: string,
29	previousPageLastNonce: number \| null,
30	nextPageFirstNonce: number \| null,
31	): Promise<QueuedItem[]> {
32	const transactionGroups = this.groupByNonce(transactions.results);	6✔
33	let lastProcessedNonce = previousPageLastNonce ?? -1;	6✔
34
35	return flatten(	6✔
36	await Promise.all(
37	transactionGroups.map(async (transactionGroup) => {
38	const transactionGroupItems: QueuedItem[] = [];	18✔
39	const { nonce } = transactionGroup;	18✔
40	if (lastProcessedNonce < safe.nonce && nonce === safe.nonce) {	18✔
41	transactionGroupItems.push(new LabelQueuedItem(LabelItem.Next));	4✔
42	} else if (lastProcessedNonce <= safe.nonce && nonce > safe.nonce) {	14✔
43	transactionGroupItems.push(new LabelQueuedItem(LabelItem.Queued));	6✔
44	}
45	lastProcessedNonce = nonce;	18✔
46
47	const isEdgeGroup = nonce === nextPageFirstNonce;	18✔
48	const isSingleItemGroup = transactionGroup.transactions.length === 1;	18✔
49	const conflictFromPreviousPage = nonce === previousPageLastNonce;	18✔
50	const hasConflicts = !isSingleItemGroup \|\| isEdgeGroup;	18✔
51	if (hasConflicts && !conflictFromPreviousPage) {	18✔
52	transactionGroupItems.push(new ConflictHeaderQueuedItem(nonce));	8✔
53	}
54
55	const mappedTransactionItems = await this.getMappedTransactionGroup(	18✔
56	chainId,
57	safe,
58	hasConflicts,
59	conflictFromPreviousPage,
60	isEdgeGroup,
61	transactionGroup,
62	);
63
64	transactionGroupItems.push(...mappedTransactionItems);	18✔
65	return transactionGroupItems;	18✔
66	}),
67	),
68	);
69	}
70
71	private async getMappedTransactionGroup(
72	chainId: string,
73	safe: Safe,
74	hasConflicts: boolean,
75	conflictFromPreviousPage: boolean,
76	isEdgeGroup: boolean,
77	transactionGroup: TransactionGroup,
78	): Promise<TransactionQueuedItem[]> {
79	return Promise.all(	18✔
80	transactionGroup.transactions.map(async (transaction, idx) => {
81	const isFirstInGroup = idx === 0;	30✔
82	const isLastInGroup = idx === transactionGroup.transactions.length - 1;	30✔
83	return new TransactionQueuedItem(	30✔
84	await this.mapper.mapTransaction(chainId, transaction, safe),
85	this.getConflictType(
86	isFirstInGroup,
87	isLastInGroup,
88	hasConflicts,
89	conflictFromPreviousPage,
90	isEdgeGroup,
91	),
92	);
93	}),
94	);
95	}
96
97	private getConflictType(
98	isFirstInGroup: boolean,
99	isLastInGroup: boolean,
100	hasConflicts: boolean,
101	conflictFromPreviousPage: boolean,
102	isEdgeGroup: boolean,
103	): ConflictType {
104	if (isFirstInGroup) {	30✔
105	if (hasConflicts) {	18✔
106	return ConflictType.HasNext;	10✔
107	} else if (conflictFromPreviousPage) {	8!
UNCOV 108	return ConflictType.End;	×
109	} else {
110	return ConflictType.None;	8✔
111	}
112	}
113	return !isLastInGroup \|\| isEdgeGroup	12✔
114	? ConflictType.HasNext
115	: ConflictType.End;
116	}
117
118	/**
119	* Divides an array of transactions in groups with the same nonce.
120	* Each TransactionGroup will contain at least one transaction.
121	* @param transactions transactions with potentially different nonces.
122	* @returns Array<TransactionGroup> in which each group of transactions has a different nonce.
123	*/
124	private groupByNonce(
125	transactions: MultisigTransaction[],
126	): TransactionGroup[] {
127	return Object.entries(groupBy(transactions, 'nonce')).map(	6✔
128	([nonce, transactions]) =>
129	<TransactionGroup>{	18✔
130	nonce: Number(nonce),
131	transactions: transactions,
132	},
133	);
134	}
135	}

safe-global / safe-client-gateway / 6085223733

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