Migrated Receipt and added receit tests

Author: rg911

e2e/infrastructure/BlockHttp.spec.ts

@@ -14,25 +14,78 @@
  * limitations under the License.
  */
 
-import {expect} from 'chai';
+import {assert, expect} from 'chai';
 import {BlockHttp} from '../../src/infrastructure/BlockHttp';
+import { Listener, 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 { NetworkCurrencyMosaic } from '../../src/model/mosaic/NetworkCurrencyMosaic';
+import { Deadline } from '../../src/model/transaction/Deadline';
+import { PlainMessage } from '../../src/model/transaction/PlainMessage';
+import { Transaction } from '../../src/model/transaction/Transaction';
+import { TransferTransaction } from '../../src/model/transaction/TransferTransaction';
 
 describe('BlockHttp', () => {
+    let account: Account;
+    let account2: Account;
     let blockHttp: BlockHttp;
+    let transactionHttp: TransactionHttp;
     let blockReceiptHash = '';
     let blockTransactionHash = '';
+    let config;
+    let chainHeight;
     before((done) => {
         const path = require('path');
         require('fs').readFile(path.resolve(__dirname, '../conf/network.conf'), (err, data) => {
             if (err) {
                 throw err;
             }
             const json = JSON.parse(data);
+            config = json;
+            account = Account.createFromPrivateKey(json.testAccount.privateKey, NetworkType.MIJIN_TEST);
+            account2 = Account.createFromPrivateKey(json.testAccount2.privateKey, NetworkType.MIJIN_TEST);
             blockHttp = new BlockHttp(json.apiUrl);
+            transactionHttp = new TransactionHttp(json.apiUrl);
             done();
         });
     });
+
+    describe('Setup test data', () => {
+        let listener: Listener;
+        before (() => {
+            listener = new Listener(config.apiUrl);
+            return listener.open();
+        });
+        after(() => {
+            return listener.close();
+        });
+
+        it('standalone', (done) => {
+            const transferTransaction = TransferTransaction.create(
+                Deadline.create(),
+                account2.address,
+                [NetworkCurrencyMosaic.createAbsolute(1)],
+                PlainMessage.create('test-message'),
+                NetworkType.MIJIN_TEST,
+            );
+            const signedTransaction = transferTransaction.signWith(account);
+
+            listener.confirmed(account.address).subscribe((transaction: Transaction) => {
+
+                chainHeight = transaction.transactionInfo!.height.lower;
+                console.log(`Test chain height: ${chainHeight}`);
+                done();
+            });
+            listener.status(account.address).subscribe((error) => {
+                console.log('Error:', error);
+                assert(false);
+                done();
+            });
+            transactionHttp.announce(signedTransaction);
+        });
+    });
+
     describe('getBlockByHeight', () => {
         it('should return block info given height', (done) => {
             blockHttp.getBlockByHeight(1)
@@ -74,7 +127,7 @@ describe('BlockHttp', () => {
 
     describe('getBlocksByHeightWithLimit', () => {
         it('should return block info given height and limit', (done) => {
-            blockHttp.getBlocksByHeightWithLimit(1, 50)
+            blockHttp.getBlocksByHeightWithLimit(chainHeight, 50)
                 .subscribe((blocksInfo) => {
                     expect(blocksInfo.length).to.be.greaterThan(0);
                     done();
@@ -83,7 +136,7 @@ describe('BlockHttp', () => {
     });
     describe('getMerkleReceipts', () => {
         it('should return Merkle Receipts', (done) => {
-            blockHttp.getMerkleReceipts(1, blockReceiptHash)
+            blockHttp.getMerkleReceipts(chainHeight, blockReceiptHash)
                 .subscribe((merkleReceipts) => {
                     expect(merkleReceipts.type).not.to.be.null;
                     expect(merkleReceipts.payload).not.to.be.null;
@@ -93,7 +146,7 @@ describe('BlockHttp', () => {
     });
     describe('getMerkleTransaction', () => {
         it('should return Merkle Transaction', (done) => {
-            blockHttp.getMerkleTransaction(1, blockTransactionHash)
+            blockHttp.getMerkleTransaction(chainHeight, blockTransactionHash)
                 .subscribe((merkleTransactionss) => {
                     expect(merkleTransactionss.type).not.to.be.null;
                     expect(merkleTransactionss.payload).not.to.be.null;
@@ -102,14 +155,15 @@ describe('BlockHttp', () => {
         });
     });
 
-    // describe('getBlockReceipts', () => {
-    //     it('should return block receipts', (done) => {
-    //         blockHttp.(1, '')
-    //             .subscribe((merkleTransactionss) => {
-    //                 expect(merkleTransactionss.type).not.to.be.null;
-    //                 expect(merkleTransactionss.payload).not.to.be.null;
-    //                 done();
-    //             });
-    //     });
-    // });
+    describe('getBlockReceipts', () => {
+        it('should return block receipts', (done) => {
+            blockHttp.getBlockReceipts(chainHeight)
+                .subscribe((statement) => {
+                    console.log(statement);
+                    expect(statement.transactionStatements).not.to.be.null;
+                    expect(statement.transactionStatements.length).to.be.greaterThan(0);
+                    done();
+                });
+        });
+    });
 });

e2e/infrastructure/TransactionHttp.spec.ts

@@ -518,7 +518,7 @@ describe('TransactionHttp', () => {
                 NetworkType.MIJIN_TEST,
             );
             const aggregateTransaction = AggregateTransaction.createComplete(Deadline.create(),
-                [accountLinkTransaction.toAggregate(harvestingAccount.publicAccount)],
+                [accountLinkTransaction.toAggregate(account.publicAccount)],
                 NetworkType.MIJIN_TEST,
                 [],
             );

e2e/service/MosaicService.spec.ts

@@ -1,36 +1,36 @@
-// import { map, mergeMap, toArray } from 'rxjs/operators';
-// import { AccountHttp } from '../../src/infrastructure/AccountHttp';
-// import { MosaicHttp } from '../../src/infrastructure/MosaicHttp';
-// import { Address } from '../../src/model/account/Address';
-// import { MosaicService } from '../../src/service/MosaicService';
+import { map, mergeMap, toArray } from 'rxjs/operators';
+import { AccountHttp } from '../../src/infrastructure/AccountHttp';
+import { MosaicHttp } from '../../src/infrastructure/MosaicHttp';
+import { Address } from '../../src/model/account/Address';
+import { MosaicService } from '../../src/service/MosaicService';
 
-// describe('MosaicService', () => {
-//     let accountAddress: Address;
-//     let accountHttp: AccountHttp;
-//     let mosaicHttp: MosaicHttp;
+describe('MosaicService', () => {
+    let accountAddress: Address;
+    let accountHttp: AccountHttp;
+    let mosaicHttp: MosaicHttp;
 
-//     before((done) => {
-//         const path = require('path');
-//         require('fs').readFile(path.resolve(__dirname, '../conf/network.conf'), (err, data) => {
-//             if (err) {
-//                 throw err;
-//             }
-//             const json = JSON.parse(data);
-//             accountAddress = Address.createFromRawAddress(json.testAccount.address);
-//             accountHttp = new AccountHttp(json.apiUrl);
-//             mosaicHttp = new MosaicHttp(json.apiUrl);
-//             done();
-//         });
-//     });
-//     it('should return the mosaic list skipping the expired mosaics', () => {
-//         const mosaicService = new MosaicService(accountHttp, mosaicHttp);
+    before((done) => {
+        const path = require('path');
+        require('fs').readFile(path.resolve(__dirname, '../conf/network.conf'), (err, data) => {
+            if (err) {
+                throw err;
+            }
+            const json = JSON.parse(data);
+            accountAddress = Address.createFromRawAddress(json.testAccount.address);
+            accountHttp = new AccountHttp(json.apiUrl);
+            mosaicHttp = new MosaicHttp(json.apiUrl);
+            done();
+        });
+    });
+    it('should return the mosaic list skipping the expired mosaics', () => {
+        const mosaicService = new MosaicService(accountHttp, mosaicHttp);
 
-//         const address = accountAddress;
+        const address = accountAddress;
 
-//         return mosaicService.mosaicsAmountViewFromAddress(address).pipe(
-//             mergeMap((_) => _),
-//             map((mosaic) => console.log('You have', mosaic.relativeAmount(), mosaic.fullName())),
-//             toArray(),
-//         ).toPromise();
-//     });
-// });
+        return mosaicService.mosaicsAmountViewFromAddress(address).pipe(
+            mergeMap((_) => _),
+            map((mosaic) => console.log('You have', mosaic.relativeAmount(), mosaic.fullName())),
+            toArray(),
+        ).toPromise();
+    });
+});

src/infrastructure/BlockHttp.ts

@@ -16,18 +16,21 @@
 
 import {BlockRoutesApi} from 'nem2-library';
 import {from as observableFrom, Observable} from 'rxjs';
-import {map} from 'rxjs/operators';
+import {map, mergeMap} from 'rxjs/operators';
 import {PublicAccount} from '../model/account/PublicAccount';
 import {BlockInfo} from '../model/blockchain/BlockInfo';
 import { MerklePathItem } from '../model/blockchain/MerklePathItem';
 import { MerkleProofInfo } from '../model/blockchain/MerkleProofInfo';
 import { MerkleProofInfoPayload } from '../model/blockchain/MerkleProofInfoPayload';
+import { Statement } from '../model/receipt/Statement';
 import {Transaction} from '../model/transaction/Transaction';
 import {UInt64} from '../model/UInt64';
 import {BlockRepository} from './BlockRepository';
 import {Http} from './Http';
 import {QueryParams} from './QueryParams';
+import { CreateStatementFromDTO } from './receipt/CreateReceiptFromDTO';
 import {CreateTransactionFromDTO, extractBeneficiary} from './transaction/CreateTransactionFromDTO';
+import { NetworkHttp } from './NetworkHttp';
 
 /**
  * Blockchain http repository.
@@ -45,8 +48,9 @@ export class BlockHttp extends Http implements BlockRepository {
      * Constructor
      * @param url
      */
-    constructor(url: string) {
-        super(url);
+    constructor(url: string, networkHttp?: NetworkHttp) {
+        networkHttp = networkHttp == null ? new NetworkHttp(url) : networkHttp;
+        super(url, networkHttp);
         this.blockRoutesApi = new BlockRoutesApi(this.apiClient);
     }
 
@@ -173,4 +177,22 @@ export class BlockHttp extends Http implements BlockRepository {
                 );
         }));
     }
+
+    /**
+     * Gets an array receipts for a block height.
+     * @param height - Block height from which will be the first block in the array
+     * @param queryParams - (Optional) Query params
+     * @returns Observable<Statement>
+     */
+    public getBlockReceipts(height: number): Observable<Statement> {
+        return this.getNetworkTypeObservable().pipe(
+            mergeMap((networkType) => observableFrom(
+                this.blockRoutesApi.getBlockReceipts(height)).pipe(
+                    map((receiptDTO) => {
+                        return CreateStatementFromDTO(receiptDTO, networkType);
+                    }),
+                ),
+            ),
+        );
+    }
 }

src/infrastructure/BlockRepository.ts

@@ -17,6 +17,7 @@
 import {Observable} from 'rxjs';
 import {BlockInfo} from '../model/blockchain/BlockInfo';
 import { MerkleProofInfo } from '../model/blockchain/MerkleProofInfo';
+import { Statement } from '../model/receipt/Statement';
 import {Transaction} from '../model/transaction/Transaction';
 import {QueryParams} from './QueryParams';
 
@@ -76,6 +77,11 @@ export interface BlockRepository {
      */
     getMerkleTransaction(height: number, hash: string): Observable<MerkleProofInfo>;
 
-    // TODO:
-    // getBlockReceipts(height: number): Observable<any>;
+    /**
+     * Get receipts from a block
+     * Returns the receipts linked to a block.
+     * @param {Number} height The height of the block.
+     * @return Observable<Statement>
+     */
+    getBlockReceipts(height: number): Observable<Statement>;
 }