Return distinct cosignature count in aggregateTransactionService (#552)

* Fixed #551

* improved coverage

* added test in account service

Author: rg911

src/service/AggregateTransactionService.ts

@@ -27,6 +27,7 @@ import { TransactionType } from '../model/transaction/TransactionType';
 import { Address } from '../model/account/Address';
 import { RepositoryFactory } from '../infrastructure/RepositoryFactory';
 import { NetworkRepository } from '../infrastructure/NetworkRepository';
+import { MultisigAccountInfo } from '../model/account/MultisigAccountInfo';
 
 /**
  * Aggregated Transaction service
@@ -90,13 +91,10 @@ export class AggregateTransactionService {
     public getMaxCosignatures(address: Address): Observable<number> {
         return this.multisigRepository.getMultisigAccountGraphInfo(address).pipe(
             map((graph) => {
-                let count = 0;
-                graph.multisigAccounts.forEach((multisigInfo) => {
-                    multisigInfo.map((multisig) => {
-                        count += multisig.cosignatories.length;
-                    });
-                });
-                return count;
+                const cosignatures = ([] as MultisigAccountInfo[])
+                    .concat(...Array.from(graph.multisigAccounts.values()))
+                    .map((info) => info.cosignatories.map((cosig) => cosig.publicKey));
+                return new Set(([] as string[]).concat(...cosignatures)).size;
             }),
         );
     }

test/model/mosaic/MosaicAmountView.spec.ts

@@ -56,4 +56,25 @@ describe('MosaicAmountView', () => {
         expect(mosaicAmountView.mosaicInfo).to.be.an.instanceof(MosaicInfo);
         expect(mosaicAmountView.amount.compact()).to.be.equal(100);
     });
+
+    it('should createComplete a Mosaic Amount View get correct amount divisibility 0', () => {
+        const mosaicInfoZero = new MosaicInfo(
+            new MosaicId([3294802500, 2243684972]), // mosaicId
+            new UInt64([3403414400, 2095475]), // supply
+            new UInt64([1, 0]), // height
+            PublicAccount.createFromPublicKey('B4F12E7C9F6946091E2CB8B6D3A12B50D17CCBBF646386EA27CE2946A7423DCF', NetworkType.MIJIN_TEST),
+            1, // revision
+            MosaicFlags.create(true, true, true),
+            0,
+            UInt64.fromUint(1000),
+        );
+        const mosaicAmountView = new MosaicAmountView(mosaicInfoZero, UInt64.fromUint(100));
+        expect(mosaicAmountView.relativeAmount()).to.be.equal(100);
+        expect(mosaicAmountView.mosaicInfo).to.be.an.instanceof(MosaicInfo);
+    });
+
+    it('should return full name', () => {
+        const mosaicAmountView = new MosaicAmountView(mosaicInfo, UInt64.fromUint(100));
+        expect(mosaicAmountView.fullName()).to.be.equal(new MosaicId([3294802500, 2243684972]).toHex());
+    });
 });

test/service/AccountService.spec.ts

@@ -42,13 +42,11 @@ describe('AccountService', () => {
     let account: Account;
     let account2: Account;
 
-    function mockAccountInfo(withMosaic = false): AccountInfo[] {
+    function mockAccountInfo(withMosaic = false, noNamespace = false): AccountInfo[] {
         const mosaic = new Mosaic(new MosaicId('941299B2B7E1291C'), UInt64.fromUint(1));
-        const mosaics = [
-            NetworkCurrencyLocal.createAbsolute(1),
-            NetworkCurrencyPublic.createAbsolute(1),
-            NetworkHarvestLocal.createAbsolute(1),
-        ];
+        const mosaics = noNamespace
+            ? []
+            : [NetworkCurrencyLocal.createAbsolute(1), NetworkCurrencyPublic.createAbsolute(1), NetworkHarvestLocal.createAbsolute(1)];
         if (withMosaic) {
             mosaics.push(mosaic);
         }
@@ -116,15 +114,16 @@ describe('AccountService', () => {
         return new NamespaceName(id, name);
     }
 
+    let mockAccountRepository: AccountRepository;
     before(() => {
         account = TestingAccount;
         account2 = MultisigAccount;
-        const mockAccountRepository = mock<AccountRepository>();
+        mockAccountRepository = mock<AccountRepository>();
         const mockNamespaceRepository = mock<NamespaceRepository>();
         const mockRepoFactory = mock<RepositoryFactory>();
 
         when(mockAccountRepository.getAccountsInfo(deepEqual([account.address]))).thenReturn(observableOf(mockAccountInfo()));
-        when(mockAccountRepository.getAccountsInfo(deepEqual([account2.address]))).thenReturn(observableOf(mockAccountInfo(true)));
+
         when(mockNamespaceRepository.getNamespacesFromAccounts(deepEqual([account.address]))).thenReturn(observableOf(mockNamespaceInfo()));
         when(mockNamespaceRepository.getNamespacesFromAccounts(deepEqual([account2.address]))).thenReturn(
             observableOf(mockNamespaceInfo()),
@@ -170,6 +169,7 @@ describe('AccountService', () => {
     });
 
     it('should return accountInfo with mosaicId', async () => {
+        when(mockAccountRepository.getAccountsInfo(deepEqual([account2.address]))).thenReturn(observableOf(mockAccountInfo(true)));
         const result = await accountService.accountInfoWithResolvedMosaic([account2.address]).toPromise();
         expect(result[0].resolvedMosaics).to.not.be.undefined;
         expect(result[0].resolvedMosaics![0].namespaceName?.name).to.be.equal('catapult.currency');
@@ -187,4 +187,13 @@ describe('AccountService', () => {
         expect(result![1].namespaceName).to.be.equal('symbol.xym');
         expect(result![2].namespaceName).to.be.equal('catapult.harvest');
     });
+
+    it('should return empty resolved namespaceInfo', async () => {
+        when(mockAccountRepository.getAccountsInfo(deepEqual([account2.address]))).thenReturn(observableOf(mockAccountInfo(true, true)));
+        const result = await accountService.accountInfoWithResolvedMosaic([account2.address]).toPromise();
+        console.log(result[0].resolvedMosaics);
+        expect(result).to.not.be.undefined;
+        expect(result.length).to.be.greaterThan(0);
+        expect(result![0].resolvedMosaics?.length).to.be.equal(1);
+    });
 });

test/service/AggregateTransactionService.spec.ts

@@ -127,6 +127,21 @@ describe('AggregateTransactionService', () => {
         return new MultisigAccountGraphInfo(map);
     }
 
+    function givenMultisig2AccountGraphInfoDuplicated(): MultisigAccountGraphInfo {
+        const map = new Map<number, MultisigAccountInfo[]>();
+        map.set(0, [new MultisigAccountInfo(multisig2.publicAccount, 2, 1, [multisig1.publicAccount, account1.publicAccount], [])]).set(1, [
+            new MultisigAccountInfo(
+                multisig1.publicAccount,
+                1,
+                1,
+                [account1.publicAccount, account2.publicAccount, account3.publicAccount],
+                [multisig2.publicAccount],
+            ),
+        ]);
+
+        return new MultisigAccountGraphInfo(map);
+    }
+
     function givenMultisig3AccountGraphInfo(): MultisigAccountGraphInfo {
         const map = new Map<number, MultisigAccountInfo[]>();
         map.set(0, [new MultisigAccountInfo(multisig3.publicAccount, 2, 2, [account2.publicAccount, account3.publicAccount], [])]);
@@ -144,10 +159,11 @@ describe('AggregateTransactionService', () => {
     }
 
     let mockNetworkRepository: NetworkRepository;
+    let mockedAccountRepository: MultisigRepository;
     before(() => {
         mockNetworkRepository = mock<NetworkRepository>();
         const mockRepoFactory = mock<RepositoryFactory>();
-        const mockedAccountRepository: MultisigRepository = mock<MultisigRepository>();
+        mockedAccountRepository = mock<MultisigRepository>();
 
         when(mockedAccountRepository.getMultisigAccountInfo(deepEqual(account1.address))).thenReturn(observableOf(givenAccount1Info()));
         when(mockedAccountRepository.getMultisigAccountInfo(deepEqual(account4.address))).thenReturn(observableOf(givenAccount4Info()));
@@ -626,4 +642,12 @@ describe('AggregateTransactionService', () => {
         const max = await aggregateTransactionService.getMaxCosignatures(multisig2.address).toPromise();
         expect(max).to.be.equal(4);
     });
+
+    it('should call getMaxCosignatures and returns distinct count', async () => {
+        when(mockedAccountRepository.getMultisigAccountGraphInfo(deepEqual(multisig2.address))).thenReturn(
+            observableOf(givenMultisig2AccountGraphInfoDuplicated()),
+        );
+        const max = await aggregateTransactionService.getMaxCosignatures(multisig2.address).toPromise();
+        expect(max).to.be.equal(4);
+    });
 });