updated block chain routes and added e2e

Author: rg911

e2e/infrastructure/AccountHttp.spec.ts

@@ -34,6 +34,7 @@ import { MultisigCosignatoryModification } from '../../src/model/transaction/Mul
 import { MultisigCosignatoryModificationType } from '../../src/model/transaction/MultisigCosignatoryModificationType';
 import { PlainMessage } from '../../src/model/transaction/PlainMessage';
 import { TransferTransaction } from '../../src/model/transaction/TransferTransaction';
+import { AggregateTransaction } from '../../src/model/transaction/AggregateTransaction';
 
 describe('AccountHttp', () => {
     let account: Account;
@@ -236,7 +237,14 @@ describe('AccountHttp', () => {
                 ],
                 NetworkType.MIJIN_TEST,
             );
-            const signedTransaction = multisigAccount.sign(modifyMultisigAccountTransaction);
+
+            const aggregateTransaction = AggregateTransaction.createComplete(Deadline.create(),
+                [modifyMultisigAccountTransaction.toAggregate(multisigAccount.publicAccount)],
+                NetworkType.MIJIN_TEST,
+                []);
+            const signedTransaction = aggregateTransaction
+                .signTransactionWithCosignatories(multisigAccount, [cosignAccount1, cosignAccount2, cosignAccount3]);
+
             listener.confirmed(multisigAccount.address).subscribe((transaction) => {
                 done();
             });
@@ -247,6 +255,7 @@ describe('AccountHttp', () => {
             transactionHttp.announce(signedTransaction);
         });
     });
+
     describe('getMultisigAccountGraphInfo', () => {
         it('should call getMultisigAccountGraphInfo successfully', (done) => {
             setTimeout(() => {

e2e/infrastructure/BlockHttp.spec.ts

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2018 NEM
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {expect} from 'chai';
+import {BlockHttp} from '../../src/infrastructure/BlockHttp';
+import {QueryParams} from '../../src/infrastructure/QueryParams';
+
+describe('BlockHttp', () => {
+    let blockHttp: BlockHttp;
+    let blockReceiptHash = '';
+    let blockTransactionHash = '';
+    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);
+            blockHttp = new BlockHttp(json.apiUrl);
+            done();
+        });
+    });
+    describe('getBlockByHeight', () => {
+        it('should return block info given height', (done) => {
+            blockHttp.getBlockByHeight(1)
+                .subscribe((blockInfo) => {
+                    blockReceiptHash = blockInfo.blockReceiptsHash;
+                    blockTransactionHash = blockInfo.blockTransactionsHash;
+                    expect(blockInfo.height.lower).to.be.equal(1);
+                    expect(blockInfo.height.higher).to.be.equal(0);
+                    expect(blockInfo.timestamp.lower).to.be.equal(0);
+                    expect(blockInfo.timestamp.higher).to.be.equal(0);
+                    done();
+                });
+        });
+    });
+
+    describe('getBlockTransactions', () => {
+        let nextId: string;
+        let firstId: string;
+
+        it('should return block transactions data given height', (done) => {
+            blockHttp.getBlockTransactions(1)
+                .subscribe((transactions) => {
+                    nextId = transactions[0].transactionInfo!.id;
+                    firstId = transactions[1].transactionInfo!.id;
+                    expect(transactions.length).to.be.greaterThan(0);
+                    done();
+                });
+        });
+
+        it('should return block transactions data given height with paginated transactionId', (done) => {
+            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);
+                    done();
+                });
+        });
+    });
+
+    describe('getBlocksByHeightWithLimit', () => {
+        it('should return block info given height and limit', (done) => {
+            blockHttp.getBlocksByHeightWithLimit(1, 50)
+                .subscribe((blocksInfo) => {
+                    expect(blocksInfo.length).to.be.greaterThan(0);
+                    done();
+                });
+        });
+    });
+    describe('getMerkleReceipts', () => {
+        it('should return Merkle Receipts', (done) => {
+            blockHttp.getMerkleReceipts(1, blockReceiptHash)
+                .subscribe((merkleReceipts) => {
+                    expect(merkleReceipts.type).not.to.be.null;
+                    expect(merkleReceipts.payload).not.to.be.null;
+                    done();
+                });
+        });
+    });
+    describe('getMerkleTransaction', () => {
+        it('should return Merkle Transaction', (done) => {
+            blockHttp.getMerkleTransaction(1, blockTransactionHash)
+                .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.(1, '')
+    //             .subscribe((merkleTransactionss) => {
+    //                 expect(merkleTransactionss.type).not.to.be.null;
+    //                 expect(merkleTransactionss.payload).not.to.be.null;
+    //                 done();
+    //             });
+    //     });
+    // });
+});

e2e/infrastructure/BlockchainHttp.spec.ts

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2019 NEM
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {expect} from 'chai';
+import {ChainHttp} from '../../src/infrastructure/ChainHttp';
+import {QueryParams} from '../../src/infrastructure/QueryParams';
+describe('ChainHttp', () => {
+    let chainHttp: ChainHttp;
+    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);
+            chainHttp = new ChainHttp(json.apiUrl);
+            done();
+        });
+    });
+
+    describe('getBlockchainHeight', () => {
+        it('should return blockchain height', (done) => {
+            chainHttp.getBlockchainHeight()
+                .subscribe((height) => {
+                    expect(height.lower).to.be.greaterThan(0);
+                    done();
+                });
+        });
+    });
+
+    describe('getBlockchainScore', () => {
+        it('should return blockchain score', (done) => {
+            chainHttp.getBlockchainScore()
+                .subscribe((blockchainScore) => {
+                    expect(blockchainScore.scoreLow).to.not.be.equal(undefined);
+                    expect(blockchainScore.scoreHigh.lower).to.be.equal(0);
+                    expect(blockchainScore.scoreHigh.higher).to.be.equal(0);
+                    done();
+                });
+        });
+    });
+});

e2e/infrastructure/ChainHttp.spec.ts

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2019 NEM
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {expect} from 'chai';
+import {DiagnosticHttp} from '../../src/infrastructure/DiagnosticHttp';
+describe('DiagnosticHttp', () => {
+    let diagnosticHttp: DiagnosticHttp;
+    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);
+            diagnosticHttp = new DiagnosticHttp(json.apiUrl);
+            done();
+        });
+    });
+
+    describe('getDiagnosticStorage', () => {
+        it('should return diagnostic storage', (done) => {
+            diagnosticHttp.getDiagnosticStorage()
+                .subscribe((blockchainStorageInfo) => {
+                    expect(blockchainStorageInfo.numBlocks).to.be.greaterThan(0);
+                    expect(blockchainStorageInfo.numTransactions).to.be.greaterThan(0);
+                    expect(blockchainStorageInfo.numAccounts).to.be.greaterThan(0);
+                    done();
+                });
+        });
+    });
+
+    describe('getServerInfo', () => {
+        it('should return diagnostic storage', (done) => {
+            diagnosticHttp.getServerInfo()
+                .subscribe((serverInfo) => {
+                    expect(serverInfo.restVersion).not.to.be.null;
+                    expect(serverInfo.sdkVersion).not.to.be.null;
+                    done();
+                });
+        });
+    });
+});