Removed metadata size validation (#527)

rg911 · web-flow · commit e6562d5552cb · 2020-04-11T13:17:53.000+01:00
* Fixed #526 - Removed metadata size validation * Added unit tests for coverage * added unit tests * improved coverage
diff --git a/src/model/transaction/AccountMetadataTransaction.ts b/src/model/transaction/AccountMetadataTransaction.ts
@@ -106,9 +106,6 @@ export class AccountMetadataTransaction extends Transaction {
                 signer?: PublicAccount,
                 transactionInfo?: TransactionInfo) {
         super(TransactionType.ACCOUNT_METADATA, networkType, version, deadline, maxFee, signature, signer, transactionInfo);
-        if (value.length > 1024) {
-            throw new Error('The maximum value size is 1024');
-        }
     }
 
     /**
diff --git a/src/model/transaction/MosaicMetadataTransaction.ts b/src/model/transaction/MosaicMetadataTransaction.ts
@@ -120,9 +120,6 @@ export class MosaicMetadataTransaction extends Transaction {
                 signer?: PublicAccount,
                 transactionInfo?: TransactionInfo) {
         super(TransactionType.MOSAIC_METADATA, networkType, version, deadline, maxFee, signature, signer, transactionInfo);
-        if (value.length > 1024) {
-            throw new Error('The maximum value size is 1024');
-        }
     }
 
     /**
diff --git a/src/model/transaction/NamespaceMetadataTransaction.ts b/src/model/transaction/NamespaceMetadataTransaction.ts
@@ -116,9 +116,6 @@ export class NamespaceMetadataTransaction extends Transaction {
                 signer?: PublicAccount,
                 transactionInfo?: TransactionInfo) {
         super(TransactionType.NAMESPACE_METADATA, networkType, version, deadline, maxFee, signature, signer, transactionInfo);
-        if (value.length > 1024) {
-            throw new Error('The maximum value size is 1024');
-        }
     }
 
     /**
diff --git a/test/core/utils/TransactionMapping.spec.ts b/test/core/utils/TransactionMapping.spec.ts
@@ -414,9 +414,76 @@ describe('TransactionMapping - createFromPayload', () => {
             NetworkType.MIJIN_TEST,
         );
 
+        const accountLinkTransaction = AccountLinkTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            LinkAction.Link,
+            NetworkType.MIJIN_TEST,
+        );
+        const registerNamespaceTransaction = NamespaceRegistrationTransaction.createRootNamespace(
+            Deadline.create(),
+            'root-test-namespace',
+            UInt64.fromUint(1000),
+            NetworkType.MIJIN_TEST,
+        );
+        const mosaicGlobalRestrictionTransaction = MosaicGlobalRestrictionTransaction.create(
+            Deadline.create(),
+            new MosaicId(UInt64.fromUint(1).toDTO()),
+            UInt64.fromUint(4444),
+            UInt64.fromUint(0),
+            MosaicRestrictionType.NONE,
+            UInt64.fromUint(0),
+            MosaicRestrictionType.GE,
+            NetworkType.MIJIN_TEST,
+        );
+        const mosaicAddressRestrictionTransaction = MosaicAddressRestrictionTransaction.create(
+            Deadline.create(),
+            new NamespaceId('test'),
+            UInt64.fromUint(4444),
+            account.address,
+            UInt64.fromUint(0),
+            NetworkType.MIJIN_TEST,
+            UInt64.fromUint(0),
+        );
+        const accountMetadataTransaction = AccountMetadataTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            UInt64.fromUint(1000),
+            1,
+            Convert.uint8ToUtf8(new Uint8Array(10)),
+            NetworkType.MIJIN_TEST,
+        );
+        const mosaicMetadataTransaction = MosaicMetadataTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            UInt64.fromUint(1000),
+            new MosaicId([2262289484, 3405110546]),
+            1,
+            Convert.uint8ToUtf8(new Uint8Array(10)),
+            NetworkType.MIJIN_TEST,
+        );
+        const namespaceMetadataTransaction = NamespaceMetadataTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            UInt64.fromUint(1000),
+            new NamespaceId([2262289484, 3405110546]),
+            1,
+            Convert.uint8ToUtf8(new Uint8Array(10)),
+            NetworkType.MIJIN_TEST,
+        );
+
         const aggregateTransaction = AggregateTransaction.createComplete(
             Deadline.create(),
-            [transferTransaction.toAggregate(account.publicAccount)],
+            [
+                transferTransaction.toAggregate(account.publicAccount),
+                accountLinkTransaction.toAggregate(account.publicAccount),
+                registerNamespaceTransaction.toAggregate(account.publicAccount),
+                mosaicGlobalRestrictionTransaction.toAggregate(account.publicAccount),
+                mosaicAddressRestrictionTransaction.toAggregate(account.publicAccount),
+                mosaicMetadataTransaction.toAggregate(account.publicAccount),
+                namespaceMetadataTransaction.toAggregate(account.publicAccount),
+                accountMetadataTransaction.toAggregate(account.publicAccount),
+            ],
             NetworkType.MIJIN_TEST,
             []);
 
@@ -426,6 +493,7 @@ describe('TransactionMapping - createFromPayload', () => {
 
         expect(transaction.type).to.be.equal(TransactionType.AGGREGATE_COMPLETE);
         expect(transaction.innerTransactions[0].type).to.be.equal(TransactionType.TRANSFER);
+        expect(transaction.innerTransactions.length).to.be.equal(8);
     });
 
     it('should create AggregatedTransaction - Bonded', () => {
diff --git a/test/model/mosaic/MosaicNames.spec.ts b/test/model/mosaic/MosaicNames.spec.ts
@@ -0,0 +1,40 @@
+/*
+ * 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 {MosaicId} from '../../../src/model/mosaic/MosaicId';
+import { MosaicNames } from '../../../src/model/mosaic/MosaicNames';
+import { NamespaceName } from '../../../src/model/namespace/NamespaceName';
+import { NamespaceId } from '../../../src/model/namespace/NamespaceId';
+
+describe('MosaicNames', () => {
+
+    let namespaceName: NamespaceName[];
+    let mosaicId: MosaicId;
+
+    before(() => {
+        namespaceName = [new NamespaceName(new NamespaceId('test'), 'test')];
+        mosaicId = new MosaicId('85BBEA6CC462B244');
+    });
+
+    it('should createComplete a Mosaic name', () => {
+        const mosaicNames = new MosaicNames(mosaicId, namespaceName);
+        expect(mosaicNames.mosaicId.toHex()).to.be.equal('85BBEA6CC462B244');
+        expect(mosaicNames.names[0].name).to.be.equal('test');
+        expect(mosaicNames.names[0].parentId).to.be.undefined;
+        expect(mosaicNames.names[0].namespaceId.fullName).to.be.equal('test');
+    });
+});
diff --git a/test/model/transaction/AccountMetadataTransaction.spec.ts b/test/model/transaction/AccountMetadataTransaction.spec.ts
@@ -22,6 +22,9 @@ import { AccountMetadataTransaction } from '../../../src/model/transaction/Accou
 import { Deadline } from '../../../src/model/transaction/Deadline';
 import { UInt64 } from '../../../src/model/UInt64';
 import { TestingAccount } from '../../conf/conf.spec';
+import { EmbeddedTransactionBuilder } from 'catbuffer-typescript/builders/EmbeddedTransactionBuilder';
+import { TransactionType } from '../../../src/model/transaction/TransactionType';
+import { deepEqual } from 'assert';
 
 describe('AccountMetadataTransaction', () => {
     let account: Account;
@@ -77,19 +80,6 @@ describe('AccountMetadataTransaction', () => {
         )).to.be.equal('9801508C58666C746F471538E43002B85B1CD542F9874B2861183919BA8787B6E80300000000000001000A0000000000000000000000');
     });
 
-    it('should throw error if value size is bigger than 1024', () => {
-        expect(() => {
-            AccountMetadataTransaction.create(
-                Deadline.create(),
-                account.publicKey,
-                UInt64.fromUint(1000),
-                1,
-                Convert.uint8ToUtf8(new Uint8Array(1025)),
-                NetworkType.MIJIN_TEST,
-            );
-        }).to.throw(Error, 'The maximum value size is 1024');
-    });
-
     describe('size', () => {
         it('should return 182 for AccountMetadataTransaction byte size', () => {
             const accountMetadataTransaction = AccountMetadataTransaction.create(
@@ -108,4 +98,39 @@ describe('AccountMetadataTransaction', () => {
             expect(signedTransaction.hash).not.to.be.undefined;
         });
     });
+
+    it('should create EmbeddedTransactionBuilder', () => {
+        const accountMetadataTransaction = AccountMetadataTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            UInt64.fromUint(1000),
+            1,
+            Convert.uint8ToUtf8(new Uint8Array(10)),
+            NetworkType.MIJIN_TEST,
+        );
+
+        Object.assign(accountMetadataTransaction, {signer: account.publicAccount});
+
+        const embedded = accountMetadataTransaction.toEmbeddedTransaction();
+
+        expect(embedded).to.be.instanceOf(EmbeddedTransactionBuilder);
+        expect(Convert.uint8ToHex(embedded.signerPublicKey.key)).to.be.equal(account.publicKey);
+        expect(embedded.type.valueOf()).to.be.equal(TransactionType.ACCOUNT_METADATA.valueOf());
+    });
+
+    it('should resolve alias', () => {
+        const accountMetadataTransaction = AccountMetadataTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            UInt64.fromUint(1000),
+            1,
+            Convert.uint8ToUtf8(new Uint8Array(10)),
+            NetworkType.MIJIN_TEST,
+        );
+
+        const resolved = accountMetadataTransaction.resolveAliases();
+
+        expect(resolved).to.be.instanceOf(AccountMetadataTransaction);
+        deepEqual(accountMetadataTransaction, resolved);
+    });
 });
diff --git a/test/model/transaction/MosaicMetadataTransaction.spec.ts b/test/model/transaction/MosaicMetadataTransaction.spec.ts
@@ -30,6 +30,8 @@ import { MosaicMetadataTransaction } from '../../../src/model/transaction/Mosaic
 import { TransactionInfo } from '../../../src/model/transaction/TransactionInfo';
 import { UInt64 } from '../../../src/model/UInt64';
 import { TestingAccount } from '../../conf/conf.spec';
+import { EmbeddedTransactionBuilder } from 'catbuffer-typescript';
+import { TransactionType } from '../../../src/model/model';
 
 describe('MosaicMetadataTransaction', () => {
     let account: Account;
@@ -97,20 +99,6 @@ describe('MosaicMetadataTransaction', () => {
                        '787B6E8030000000000004CCCD78612DDF5CA01000A0000000000000000000000');
     });
 
-    it('should throw error if value size is bigger than 1024', () => {
-        expect(() => {
-            MosaicMetadataTransaction.create(
-                Deadline.create(),
-                account.publicKey,
-                UInt64.fromUint(1000),
-                new MosaicId([2262289484, 3405110546]),
-                1,
-                Convert.uint8ToUtf8(new Uint8Array(1025)),
-                NetworkType.MIJIN_TEST,
-            );
-        }).to.throw(Error, 'The maximum value size is 1024');
-    });
-
     it('should create and sign an MosaicMetadataTransaction object using alias', () => {
         const namespacId = NamespaceId.createFromEncoded('9550CA3FC9B41FC5');
         const mosaicMetadataTransaction = MosaicMetadataTransaction.create(
@@ -187,4 +175,24 @@ describe('MosaicMetadataTransaction', () => {
         const signedTransaction = mosaicMetadataTransaction.signWith(account, generationHash);
         expect(signedTransaction.hash).not.to.be.undefined;
     });
+
+    it('should create EmbeddedTransactionBuilder', () => {
+        const mosaicMetadataTransaction = MosaicMetadataTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            UInt64.fromUint(1000),
+            new MosaicId([2262289484, 3405110546]),
+            1,
+            Convert.uint8ToUtf8(new Uint8Array(10)),
+            NetworkType.MIJIN_TEST,
+        );
+
+        Object.assign(mosaicMetadataTransaction, {signer: account.publicAccount});
+
+        const embedded = mosaicMetadataTransaction.toEmbeddedTransaction();
+
+        expect(embedded).to.be.instanceOf(EmbeddedTransactionBuilder);
+        expect(Convert.uint8ToHex(embedded.signerPublicKey.key)).to.be.equal(account.publicKey);
+        expect(embedded.type.valueOf()).to.be.equal(TransactionType.MOSAIC_METADATA.valueOf());
+    });
 });
diff --git a/test/model/transaction/NamespaceMetadataTransaction.spec.ts b/test/model/transaction/NamespaceMetadataTransaction.spec.ts
@@ -23,6 +23,9 @@ import { Deadline } from '../../../src/model/transaction/Deadline';
 import { NamespaceMetadataTransaction } from '../../../src/model/transaction/NamespaceMetadataTransaction';
 import { UInt64 } from '../../../src/model/UInt64';
 import { TestingAccount } from '../../conf/conf.spec';
+import { EmbeddedTransactionBuilder } from 'catbuffer-typescript/builders/EmbeddedTransactionBuilder';
+import { TransactionType } from '../../../src/model/transaction/TransactionType';
+import { deepEqual } from 'assert';
 
 describe('NamespaceMetadataTransaction', () => {
     let account: Account;
@@ -82,20 +85,6 @@ describe('NamespaceMetadataTransaction', () => {
                        'A8787B6E8030000000000004CCCD78612DDF5CA01000A0000000000000000000000');
     });
 
-    it('should throw error if value size is bigger than 1024', () => {
-        expect(() => {
-            NamespaceMetadataTransaction.create(
-                Deadline.create(),
-                account.publicKey,
-                UInt64.fromUint(1000),
-                new NamespaceId([2262289484, 3405110546]),
-                1,
-                Convert.uint8ToUtf8(new Uint8Array(1025)),
-                NetworkType.MIJIN_TEST,
-            );
-        }).to.throw(Error, 'The maximum value size is 1024');
-    });
-
     describe('size', () => {
         it('should return 190 for NamespaceMetadataTransaction byte size', () => {
             const namespaceMetadataTransaction = NamespaceMetadataTransaction.create(
@@ -128,4 +117,40 @@ describe('NamespaceMetadataTransaction', () => {
         const signedTransaction = namespaceMetadataTransaction.signWith(account, generationHash);
         expect(signedTransaction.hash).not.to.be.undefined;
     });
+
+    it('should create EmbeddedTransactionBuilder', () => {
+        const namespaceMetadataTransaction = NamespaceMetadataTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            UInt64.fromUint(1000),
+            new NamespaceId([2262289484, 3405110546]),
+            1,
+            Convert.uint8ToUtf8(new Uint8Array(10)),
+            NetworkType.MIJIN_TEST,
+        );
+
+        Object.assign(namespaceMetadataTransaction, {signer: account.publicAccount});
+
+        const embedded = namespaceMetadataTransaction.toEmbeddedTransaction();
+
+        expect(embedded).to.be.instanceOf(EmbeddedTransactionBuilder);
+        expect(Convert.uint8ToHex(embedded.signerPublicKey.key)).to.be.equal(account.publicKey);
+        expect(embedded.type.valueOf()).to.be.equal(TransactionType.NAMESPACE_METADATA.valueOf());
+    });
+
+    it('should resolve alias', () => {
+        const namespaceMetadataTransaction = NamespaceMetadataTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            UInt64.fromUint(1000),
+            new NamespaceId([2262289484, 3405110546]),
+            1,
+            Convert.uint8ToUtf8(new Uint8Array(10)),
+            NetworkType.MIJIN_TEST,
+        );
+        const resolved = namespaceMetadataTransaction.resolveAliases();
+
+        expect(resolved).to.be.instanceOf(NamespaceMetadataTransaction);
+        deepEqual(namespaceMetadataTransaction, resolved);
+    });
 });

Original file line number	Diff line number	Diff line change
`@@ -106,9 +106,6 @@ export class AccountMetadataTransaction extends Transaction {`
`106`	`106`	`signer?: PublicAccount,`
`107`	`107`	`transactionInfo?: TransactionInfo) {`
`108`	`108`	`super(TransactionType.ACCOUNT_METADATA, networkType, version, deadline, maxFee, signature, signer, transactionInfo);`
`109`		`- if (value.length > 1024) {`
`110`		`- throw new Error('The maximum value size is 1024');`
`111`		`- }`
`112`	`109`	`}`
`113`	`110`
`114`	`111`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -120,9 +120,6 @@ export class MosaicMetadataTransaction extends Transaction {`
`120`	`120`	`signer?: PublicAccount,`
`121`	`121`	`transactionInfo?: TransactionInfo) {`
`122`	`122`	`super(TransactionType.MOSAIC_METADATA, networkType, version, deadline, maxFee, signature, signer, transactionInfo);`
`123`		`- if (value.length > 1024) {`
`124`		`- throw new Error('The maximum value size is 1024');`
`125`		`- }`
`126`	`123`	`}`
`127`	`124`
`128`	`125`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -116,9 +116,6 @@ export class NamespaceMetadataTransaction extends Transaction {`
`116`	`116`	`signer?: PublicAccount,`
`117`	`117`	`transactionInfo?: TransactionInfo) {`
`118`	`118`	`super(TransactionType.NAMESPACE_METADATA, networkType, version, deadline, maxFee, signature, signer, transactionInfo);`
`119`		`- if (value.length > 1024) {`
`120`		`- throw new Error('The maximum value size is 1024');`
`121`		`- }`
`122`	`119`	`}`
`123`	`120`
`124`	`121`	`/**`