Added e2e test for SecretLockTx with mosaicAlias

Author: rg911

e2e/infrastructure/MosaicHttp.spec.ts

@@ -13,21 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {expect, assert} from 'chai';
+import {assert, expect} from 'chai';
 import { Listener, TransactionHttp } from '../../src/infrastructure/infrastructure';
 import {MosaicHttp} from '../../src/infrastructure/MosaicHttp';
 import { Account } from '../../src/model/account/Account';
 import { NetworkType } from '../../src/model/blockchain/NetworkType';
 import {MosaicId} from '../../src/model/mosaic/MosaicId';
 import { MosaicNonce } from '../../src/model/mosaic/MosaicNonce';
 import { MosaicProperties } from '../../src/model/mosaic/MosaicProperties';
+import { AliasActionType } from '../../src/model/namespace/AliasActionType';
 import {NamespaceId} from '../../src/model/namespace/NamespaceId';
 import { Deadline } from '../../src/model/transaction/Deadline';
+import { MosaicAliasTransaction } from '../../src/model/transaction/MosaicAliasTransaction';
 import { MosaicDefinitionTransaction } from '../../src/model/transaction/MosaicDefinitionTransaction';
 import { RegisterNamespaceTransaction } from '../../src/model/transaction/RegisterNamespaceTransaction';
 import { UInt64 } from '../../src/model/UInt64';
-import { MosaicAliasTransaction } from '../../src/model/transaction/MosaicAliasTransaction';
-import { AliasActionType } from '../../src/model/namespace/AliasActionType';
 
 describe('MosaicHttp', () => {
     let mosaicId: MosaicId;

e2e/infrastructure/TransactionHttp.spec.ts

@@ -661,7 +661,8 @@ describe('TransactionHttp', () => {
             transactionHttp.announce(signedTransaction);
         });
     });
-    describe('MosaicAliasTransaction', () => {
+
+    describe('MosaicSupplyChangeTransaction', () => {
         let listener: Listener;
         before (() => {
             listener = new Listener(config.apiUrl);
@@ -670,29 +671,27 @@ describe('TransactionHttp', () => {
         after(() => {
             return listener.close();
         });
-
         it('standalone', (done) => {
-            const mosaicAliasTransaction = MosaicAliasTransaction.create(
+            const mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.create(
                 Deadline.create(),
-                AliasActionType.Link,
-                namespaceId,
                 mosaicId,
+                MosaicSupplyType.Increase,
+                UInt64.fromUint(10),
                 NetworkType.MIJIN_TEST,
             );
-            const signedTransaction = mosaicAliasTransaction.signWith(account);
-
+            const signedTransaction = mosaicSupplyChangeTransaction.signWith(account);
             listener.confirmed(account.address).subscribe((transaction: Transaction) => {
                 done();
             });
-            listener.status(account.address).subscribe((error) => {
+            listener.status(account3.address).subscribe((error) => {
                 console.log('Error:', error);
                 assert(false);
                 done();
             });
             transactionHttp.announce(signedTransaction);
         });
     });
-    describe('MosaicAliasTransaction', () => {
+    describe('MosaicSupplyChangeTransaction', () => {
         let listener: Listener;
         before (() => {
             listener = new Listener(config.apiUrl);
@@ -702,23 +701,22 @@ describe('TransactionHttp', () => {
             return listener.close();
         });
         it('aggregate', (done) => {
-            const mosaicAliasTransaction = MosaicAliasTransaction.create(
+            const mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.create(
                 Deadline.create(),
-                AliasActionType.Unlink,
-                namespaceId,
                 mosaicId,
+                MosaicSupplyType.Increase,
+                UInt64.fromUint(10),
                 NetworkType.MIJIN_TEST,
             );
             const aggregateTransaction = AggregateTransaction.createComplete(Deadline.create(),
-                [mosaicAliasTransaction.toAggregate(account.publicAccount)],
+                [mosaicSupplyChangeTransaction.toAggregate(account.publicAccount)],
                 NetworkType.MIJIN_TEST,
-                [],
-            );
+                []);
             const signedTransaction = aggregateTransaction.signWith(account);
             listener.confirmed(account.address).subscribe((transaction: Transaction) => {
                 done();
             });
-            listener.status(account.address).subscribe((error) => {
+            listener.status(account3.address).subscribe((error) => {
                 console.log('Error:', error);
                 assert(false);
                 done();
@@ -727,7 +725,7 @@ describe('TransactionHttp', () => {
         });
     });
 
-    describe('MosaicSupplyChangeTransaction', () => {
+    describe('MosaicAliasTransaction', () => {
         let listener: Listener;
         before (() => {
             listener = new Listener(config.apiUrl);
@@ -736,27 +734,61 @@ describe('TransactionHttp', () => {
         after(() => {
             return listener.close();
         });
+
         it('standalone', (done) => {
-            const mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.create(
+            const mosaicAliasTransaction = MosaicAliasTransaction.create(
                 Deadline.create(),
+                AliasActionType.Link,
+                namespaceId,
                 mosaicId,
-                MosaicSupplyType.Increase,
-                UInt64.fromUint(10),
                 NetworkType.MIJIN_TEST,
             );
-            const signedTransaction = mosaicSupplyChangeTransaction.signWith(account);
+            const signedTransaction = mosaicAliasTransaction.signWith(account);
+
             listener.confirmed(account.address).subscribe((transaction: Transaction) => {
                 done();
             });
-            listener.status(account3.address).subscribe((error) => {
+            listener.status(account.address).subscribe((error) => {
                 console.log('Error:', error);
                 assert(false);
                 done();
             });
             transactionHttp.announce(signedTransaction);
         });
     });
-    describe('MosaicSupplyChangeTransaction', () => {
+
+    describe('SecretLockTransaction - MosaicAlias', () => {
+        let listener: Listener;
+        before (() => {
+            listener = new Listener(config.apiUrl);
+            return listener.open();
+        });
+        after(() => {
+            return listener.close();
+        });
+        it('standalone', (done) => {
+            const secretLockTransaction = SecretLockTransaction.create(
+                Deadline.create(),
+                new Mosaic(namespaceId, UInt64.fromUint(10 * Math.pow(10, NetworkCurrencyMosaic.DIVISIBILITY))),
+                UInt64.fromUint(100),
+                HashType.Op_Sha3_256,
+                sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(),
+                account2.address,
+                NetworkType.MIJIN_TEST,
+            );
+            listener.confirmed(account.address).subscribe((transaction: Transaction) => {
+                done();
+            });
+            listener.status(account.address).subscribe((error) => {
+                console.log('Error:', error);
+                assert(false);
+                done();
+            });
+            transactionHttp.announce(secretLockTransaction.signWith(account));
+        });
+    });
+
+    describe('MosaicAliasTransaction', () => {
         let listener: Listener;
         before (() => {
             listener = new Listener(config.apiUrl);
@@ -766,22 +798,23 @@ describe('TransactionHttp', () => {
             return listener.close();
         });
         it('aggregate', (done) => {
-            const mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.create(
+            const mosaicAliasTransaction = MosaicAliasTransaction.create(
                 Deadline.create(),
+                AliasActionType.Unlink,
+                namespaceId,
                 mosaicId,
-                MosaicSupplyType.Increase,
-                UInt64.fromUint(10),
                 NetworkType.MIJIN_TEST,
             );
             const aggregateTransaction = AggregateTransaction.createComplete(Deadline.create(),
-                [mosaicSupplyChangeTransaction.toAggregate(account.publicAccount)],
+                [mosaicAliasTransaction.toAggregate(account.publicAccount)],
                 NetworkType.MIJIN_TEST,
-                []);
+                [],
+            );
             const signedTransaction = aggregateTransaction.signWith(account);
             listener.confirmed(account.address).subscribe((transaction: Transaction) => {
                 done();
             });
-            listener.status(account3.address).subscribe((error) => {
+            listener.status(account.address).subscribe((error) => {
                 console.log('Error:', error);
                 assert(false);
                 done();