Merge pull request #358 from NEMStudios/task/g350_appy_openapi_codes

Apply OpenAPI client code changes for F2

Author: rg911

e2e/infrastructure/AccountHttp.spec.ts

@@ -14,11 +14,13 @@
  * limitations under the License.
  */
 
-import {deepEqual} from 'assert';
 import {assert, expect} from 'chai';
 import {AccountHttp} from '../../src/infrastructure/AccountHttp';
-import { Listener, TransactionHttp } from '../../src/infrastructure/infrastructure';
-import { RestrictionHttp } from '../../src/infrastructure/RestrictionHttp';
+import { Listener } from '../../src/infrastructure/Listener';
+import { MultisigHttp } from '../../src/infrastructure/MultisigHttp';
+import { NamespaceHttp } from '../../src/infrastructure/NamespaceHttp';
+import { RestrictionAccountHttp } from '../../src/infrastructure/RestrictionAccountHttp';
+import { TransactionHttp } from '../../src/infrastructure/TransactionHttp';
 import { Account } from '../../src/model/account/Account';
 import {Address} from '../../src/model/account/Address';
 import {PublicAccount} from '../../src/model/account/PublicAccount';
@@ -27,16 +29,10 @@ import { PlainMessage } from '../../src/model/message/PlainMessage';
 import { NetworkCurrencyMosaic } from '../../src/model/mosaic/NetworkCurrencyMosaic';
 import { AliasAction } from '../../src/model/namespace/AliasAction';
 import { NamespaceId } from '../../src/model/namespace/NamespaceId';
-import { AccountRestrictionModificationAction } from '../../src/model/restriction/AccountRestrictionModificationAction';
-import { AccountRestrictionFlags } from '../../src/model/restriction/AccountRestrictionType';
-import { AccountRestrictionModification } from '../../src/model/transaction/AccountRestrictionModification';
-import { AccountRestrictionTransaction } from '../../src/model/transaction/AccountRestrictionTransaction';
 import { AddressAliasTransaction } from '../../src/model/transaction/AddressAliasTransaction';
 import { AggregateTransaction } from '../../src/model/transaction/AggregateTransaction';
-import { CosignatoryModificationAction } from '../../src/model/transaction/CosignatoryModificationAction';
 import { Deadline } from '../../src/model/transaction/Deadline';
 import { MultisigAccountModificationTransaction } from '../../src/model/transaction/MultisigAccountModificationTransaction';
-import { MultisigCosignatoryModification } from '../../src/model/transaction/MultisigCosignatoryModification';
 import { NamespaceRegistrationTransaction } from '../../src/model/transaction/NamespaceRegistrationTransaction';
 import { TransferTransaction } from '../../src/model/transaction/TransferTransaction';
 import { UInt64 } from '../../src/model/UInt64';
@@ -53,7 +49,9 @@ describe('AccountHttp', () => {
     let accountPublicKey: string;
     let publicAccount: PublicAccount;
     let accountHttp: AccountHttp;
-    let restrictionHttp: RestrictionHttp;
+    let multisigHttp: MultisigHttp;
+    let namespaceHttp: NamespaceHttp;
+    let restrictionHttp: RestrictionAccountHttp;
     let transactionHttp: TransactionHttp;
     let namespaceId: NamespaceId;
     let generationHash: string;
@@ -80,7 +78,9 @@ describe('AccountHttp', () => {
             generationHash = json.generationHash;
             accountHttp = new AccountHttp(json.apiUrl);
             transactionHttp = new TransactionHttp(json.apiUrl);
-            restrictionHttp = new RestrictionHttp(json.apiUrl);
+            restrictionHttp = new RestrictionAccountHttp(json.apiUrl);
+            multisigHttp = new MultisigHttp(json.apiUrl);
+            namespaceHttp = new NamespaceHttp(json.apiUrl);
             done();
         });
     });
@@ -256,7 +256,7 @@ describe('AccountHttp', () => {
     describe('getMultisigAccountGraphInfo', () => {
         it('should call getMultisigAccountGraphInfo successfully', (done) => {
             setTimeout(() => {
-                accountHttp.getMultisigAccountGraphInfo(multisigAccount.publicAccount.address).subscribe((multisigAccountGraphInfo) => {
+                multisigHttp.getMultisigAccountGraphInfo(multisigAccount.publicAccount.address).subscribe((multisigAccountGraphInfo) => {
                     expect(multisigAccountGraphInfo.multisigAccounts.get(0)![0].
                         account.publicKey).to.be.equal(multisigAccount.publicKey);
                     done();
@@ -267,7 +267,7 @@ describe('AccountHttp', () => {
     describe('getMultisigAccountInfo', () => {
         it('should call getMultisigAccountInfo successfully', (done) => {
             setTimeout(() => {
-                accountHttp.getMultisigAccountInfo(multisigAccount.publicAccount.address).subscribe((multisigAccountInfo) => {
+                multisigHttp.getMultisigAccountInfo(multisigAccount.publicAccount.address).subscribe((multisigAccountInfo) => {
                     expect(multisigAccountInfo.account.publicKey).to.be.equal(multisigAccount.publicKey);
                     done();
                 });
@@ -277,7 +277,7 @@ describe('AccountHttp', () => {
 
     describe('outgoingTransactions', () => {
         it('should call outgoingTransactions successfully', (done) => {
-            accountHttp.outgoingTransactions(publicAccount.address).subscribe((transactions) => {
+            accountHttp.getAccountOutgoingTransactions(publicAccount.address).subscribe((transactions) => {
                 expect(transactions.length).to.be.greaterThan(0);
                 done();
             });
@@ -286,7 +286,7 @@ describe('AccountHttp', () => {
 
     describe('aggregateBondedTransactions', () => {
         it('should call aggregateBondedTransactions successfully', (done) => {
-            accountHttp.aggregateBondedTransactions(publicAccount.address).subscribe(() => {
+            accountHttp.getAccountPartialTransactions(publicAccount.address).subscribe(() => {
                 done();
             }, (error) => {
                 console.log('Error:', error);
@@ -297,7 +297,7 @@ describe('AccountHttp', () => {
 
     describe('transactions', () => {
         it('should call transactions successfully', (done) => {
-            accountHttp.transactions(publicAccount.address).subscribe((transactions) => {
+            accountHttp.getAccountTransactions(publicAccount.address).subscribe((transactions) => {
                 expect(transactions.length).to.be.greaterThan(0);
                 done();
             });
@@ -306,7 +306,7 @@ describe('AccountHttp', () => {
 
     describe('unconfirmedTransactions', () => {
         it('should call unconfirmedTransactions successfully', (done) => {
-            accountHttp.unconfirmedTransactions(publicAccount.address).subscribe((transactions) => {
+            accountHttp.getAccountUnconfirmedTransactions(publicAccount.address).subscribe((transactions) => {
                 expect(transactions.length).to.be.equal(0);
                 done();
             });
@@ -315,7 +315,7 @@ describe('AccountHttp', () => {
 
     describe('getAddressNames', () => {
         it('should call getAddressNames successfully', (done) => {
-            accountHttp.getAccountsNames([accountAddress]).subscribe((addressNames) => {
+            namespaceHttp.getAccountsNames([accountAddress]).subscribe((addressNames) => {
                 expect(addressNames.length).to.be.greaterThan(0);
                 done();
             });

e2e/infrastructure/BlockHttp.spec.ts

@@ -15,21 +15,24 @@
  */
 
 import {assert, expect} from 'chai';
+import { mergeMap } from 'rxjs/operators';
 import {BlockHttp} from '../../src/infrastructure/BlockHttp';
-import { Listener, TransactionHttp } from '../../src/infrastructure/infrastructure';
+import { Listener, ReceiptHttp, TransactionHttp } from '../../src/infrastructure/infrastructure';
 import {QueryParams} from '../../src/infrastructure/QueryParams';
 import { Account } from '../../src/model/account/Account';
 import { NetworkType } from '../../src/model/blockchain/NetworkType';
 import { PlainMessage } from '../../src/model/message/PlainMessage';
 import { NetworkCurrencyMosaic } from '../../src/model/mosaic/NetworkCurrencyMosaic';
 import { Deadline } from '../../src/model/transaction/Deadline';
 import { Transaction } from '../../src/model/transaction/Transaction';
+import { TransactionInfo } from '../../src/model/transaction/TransactionInfo';
 import { TransferTransaction } from '../../src/model/transaction/TransferTransaction';
 
 describe('BlockHttp', () => {
     let account: Account;
     let account2: Account;
     let blockHttp: BlockHttp;
+    let receiptHttp: ReceiptHttp;
     let transactionHttp: TransactionHttp;
     let blockReceiptHash = '';
     let blockTransactionHash = '';
@@ -48,6 +51,7 @@ describe('BlockHttp', () => {
             account2 = Account.createFromPrivateKey(json.testAccount2.privateKey, NetworkType.MIJIN_TEST);
             blockHttp = new BlockHttp(json.apiUrl);
             transactionHttp = new TransactionHttp(json.apiUrl);
+            receiptHttp = new ReceiptHttp(json.apiUrl);
             generationHash = json.generationHash;
             done();
         });
@@ -80,8 +84,7 @@ describe('BlockHttp', () => {
             const signedTransaction = transferTransaction.signWith(account, generationHash);
 
             listener.confirmed(account.address).subscribe((transaction: Transaction) => {
-
-                chainHeight = transaction.transactionInfo!.height.lower;
+                chainHeight = transaction.transactionInfo!.height.toString();
                 done();
             });
             listener.status(account.address).subscribe((error) => {
@@ -95,7 +98,7 @@ describe('BlockHttp', () => {
 
     describe('getBlockByHeight', () => {
         it('should return block info given height', (done) => {
-            blockHttp.getBlockByHeight(1)
+            blockHttp.getBlockByHeight('1')
                 .subscribe((blockInfo) => {
                     blockReceiptHash = blockInfo.blockReceiptsHash;
                     blockTransactionHash = blockInfo.blockTransactionsHash;
@@ -113,7 +116,7 @@ describe('BlockHttp', () => {
         let firstId: string;
 
         it('should return block transactions data given height', (done) => {
-            blockHttp.getBlockTransactions(1)
+            blockHttp.getBlockTransactions('1')
                 .subscribe((transactions) => {
                     nextId = transactions[0].transactionInfo!.id;
                     firstId = transactions[1].transactionInfo!.id;
@@ -123,7 +126,7 @@ describe('BlockHttp', () => {
         });
 
         it('should return block transactions data given height with paginated transactionId', (done) => {
-            blockHttp.getBlockTransactions(1, new QueryParams(10, nextId))
+            blockHttp.getBlockTransactions('1', new QueryParams(10, nextId))
                 .subscribe((transactions) => {
                     expect(transactions[0].transactionInfo!.id).to.be.equal(firstId);
                     expect(transactions.length).to.be.greaterThan(0);
@@ -143,17 +146,28 @@ describe('BlockHttp', () => {
     });
     describe('getMerkleReceipts', () => {
         it('should return Merkle Receipts', (done) => {
-            blockHttp.getMerkleReceipts(chainHeight, blockReceiptHash)
-                .subscribe((merkleReceipts) => {
-                    expect(merkleReceipts.merklePath).not.to.be.null;
-                    done();
-                });
+            receiptHttp.getBlockReceipts(chainHeight).pipe(
+                mergeMap((_) => {
+                    return receiptHttp.getMerkleReceipts(chainHeight, _.transactionStatements[0].generateHash());
+                }))
+            .subscribe((merkleReceipts) => {
+                expect(merkleReceipts.merklePath).not.to.be.null;
+                done();
+            });
         });
     });
     describe('getMerkleTransaction', () => {
         it('should return Merkle Transaction', (done) => {
-            blockHttp.getMerkleTransaction(chainHeight, blockTransactionHash)
-                .subscribe((merkleTransactionss) => {
+            blockHttp.getBlockTransactions(chainHeight).pipe(
+                mergeMap((_) => {
+                    const hash = (_[0].transactionInfo as TransactionInfo).hash;
+                    if (hash) {
+                        return blockHttp.getMerkleTransaction(chainHeight, hash);
+                    }
+                    // If reaching this line, something is not right
+                    throw new Error('Tansacation hash is undefined');
+                }))
+            .subscribe((merkleTransactionss) => {
                     expect(merkleTransactionss.merklePath).not.to.be.null;
                     done();
                 });
@@ -162,7 +176,7 @@ describe('BlockHttp', () => {
 
     describe('getBlockReceipts', () => {
         it('should return block receipts', (done) => {
-            blockHttp.getBlockReceipts(chainHeight)
+            receiptHttp.getBlockReceipts(chainHeight)
                 .subscribe((statement) => {
                     expect(statement.transactionStatements).not.to.be.null;
                     expect(statement.transactionStatements.length).to.be.greaterThan(0);

e2e/infrastructure/Listener.spec.ts

@@ -286,7 +286,7 @@ describe('Listener', () => {
                     done();
                 });
                 listener.aggregateBondedAdded(cosignAccount1.address).subscribe(() => {
-                    accountHttp.aggregateBondedTransactions(cosignAccount1.publicAccount.address).subscribe((transactions) => {
+                    accountHttp.getAccountPartialTransactions(cosignAccount1.publicAccount.address).subscribe((transactions) => {
                         const transactionToCosign = transactions[0];
                         TransactionUtils.cosignTransaction(transactionToCosign, cosignAccount2, transactionHttp);
                     });
@@ -326,7 +326,7 @@ describe('Listener', () => {
                 done();
             });
             listener.aggregateBondedAdded(cosignAccount1.address).subscribe(() => {
-                accountHttp.aggregateBondedTransactions(cosignAccount1.publicAccount.address).subscribe((transactions) => {
+                accountHttp.getAccountPartialTransactions(cosignAccount1.publicAccount.address).subscribe((transactions) => {
                     const transactionToCosign = transactions[0];
                     TransactionUtils.cosignTransaction(transactionToCosign, cosignAccount2, transactionHttp);
                 });

e2e/infrastructure/MetadataHttp.spec.ts

@@ -278,7 +278,7 @@ describe('MetadataHttp', () => {
                     expect(metadata[0].metadataEntry.targetPublicKey).to.be.equal(account.publicKey);
                     expect(metadata[0].metadataEntry.targetId).to.be.undefined;
                     expect(metadata[0].metadataEntry.value).to.be.equal('Test account meta value');
-                    expect(metadata[0].metadataEntry.valueSize).to.be.equal(23);
+                    expect(metadata[0].metadataEntry.value.length).to.be.equal(23);
                     done();
                 });
         });
@@ -294,7 +294,7 @@ describe('MetadataHttp', () => {
                     expect(metadata[0].metadataEntry.targetPublicKey).to.be.equal(account.publicKey);
                     expect(metadata[0].metadataEntry.targetId).to.be.undefined;
                     expect(metadata[0].metadataEntry.value).to.be.equal('Test account meta value');
-                    expect(metadata[0].metadataEntry.valueSize).to.be.equal(23);
+                    expect(metadata[0].metadataEntry.value.length).to.be.equal(23);
                     done();
                 });
         });
@@ -309,7 +309,7 @@ describe('MetadataHttp', () => {
                     expect(metadata.metadataEntry.targetPublicKey).to.be.equal(account.publicKey);
                     expect(metadata.metadataEntry.targetId).to.be.undefined;
                     expect(metadata.metadataEntry.value).to.be.equal('Test account meta value');
-                    expect(metadata.metadataEntry.valueSize).to.be.equal(23);
+                    expect(metadata.metadataEntry.value.length).to.be.equal(23);
                     done();
                 });
         });
@@ -325,7 +325,7 @@ describe('MetadataHttp', () => {
                     expect(metadata[0].metadataEntry.targetPublicKey).to.be.equal(account.publicKey);
                     expect((metadata[0].metadataEntry.targetId as MosaicId).toHex()).to.be.equal(mosaicId.toHex());
                     expect(metadata[0].metadataEntry.value).to.be.equal('Test mosaic meta value');
-                    expect(metadata[0].metadataEntry.valueSize).to.be.equal(22);
+                    expect(metadata[0].metadataEntry.value.length).to.be.equal(22);
                     done();
                 });
         });
@@ -341,7 +341,7 @@ describe('MetadataHttp', () => {
                     expect(metadata[0].metadataEntry.targetPublicKey).to.be.equal(account.publicKey);
                     expect((metadata[0].metadataEntry.targetId as MosaicId).toHex()).to.be.equal(mosaicId.toHex());
                     expect(metadata[0].metadataEntry.value).to.be.equal('Test mosaic meta value');
-                    expect(metadata[0].metadataEntry.valueSize).to.be.equal(22);
+                    expect(metadata[0].metadataEntry.value.length).to.be.equal(22);
                     done();
                 });
         });
@@ -356,7 +356,7 @@ describe('MetadataHttp', () => {
                     expect(metadata.metadataEntry.targetPublicKey).to.be.equal(account.publicKey);
                     expect((metadata.metadataEntry.targetId as MosaicId).toHex()).to.be.equal(mosaicId.toHex());
                     expect(metadata.metadataEntry.value).to.be.equal('Test mosaic meta value');
-                    expect(metadata.metadataEntry.valueSize).to.be.equal(22);
+                    expect(metadata.metadataEntry.value.length).to.be.equal(22);
                     done();
                 });
         });
@@ -372,7 +372,7 @@ describe('MetadataHttp', () => {
                     expect(metadata[0].metadataEntry.targetPublicKey).to.be.equal(account.publicKey);
                     expect((metadata[0].metadataEntry.targetId as NamespaceId).toHex()).to.be.equal(namespaceId.toHex());
                     expect(metadata[0].metadataEntry.value).to.be.equal('Test namespace meta value');
-                    expect(metadata[0].metadataEntry.valueSize).to.be.equal(25);
+                    expect(metadata[0].metadataEntry.value.length).to.be.equal(25);
                     done();
                 });
         });
@@ -388,7 +388,7 @@ describe('MetadataHttp', () => {
                     expect(metadata[0].metadataEntry.targetPublicKey).to.be.equal(account.publicKey);
                     expect((metadata[0].metadataEntry.targetId as NamespaceId).toHex()).to.be.equal(namespaceId.toHex());
                     expect(metadata[0].metadataEntry.value).to.be.equal('Test namespace meta value');
-                    expect(metadata[0].metadataEntry.valueSize).to.be.equal(25);
+                    expect(metadata[0].metadataEntry.value.length).to.be.equal(25);
                     done();
                 });
         });
@@ -403,7 +403,7 @@ describe('MetadataHttp', () => {
                     expect(metadata.metadataEntry.targetPublicKey).to.be.equal(account.publicKey);
                     expect((metadata.metadataEntry.targetId as NamespaceId).toHex()).to.be.equal(namespaceId.toHex());
                     expect(metadata.metadataEntry.value).to.be.equal('Test namespace meta value');
-                    expect(metadata.metadataEntry.valueSize).to.be.equal(25);
+                    expect(metadata.metadataEntry.value.length).to.be.equal(25);
                     done();
                 });
         });