@neuraiproject/neurai-assets 1.0.0

package/tests/unit/validators/amountValidator.test.js

@@ -0,0 +1,143 @@
+/**
+ * Tests for AmountValidator
+ */
+
+const { expect } = require('chai');
+const AmountValidator = require('../../../src/validators/amountValidator');
+const { InvalidAmountError, InvalidUnitsError } = require('../../../src/errors');
+
+describe('AmountValidator', () => {
+  describe('validate', () => {
+    it('should validate correct amounts', () => {
+      expect(AmountValidator.validate(100, 0)).to.be.true;
+      expect(AmountValidator.validate(1.5, 2)).to.be.true;
+      expect(AmountValidator.validate(1000000, 8)).to.be.true;
+      expect(AmountValidator.validate(1, 0)).to.be.true;
+      expect(AmountValidator.validate(1.00000001, 8)).to.be.true;
+    });
+
+    it('should reject non-numeric amounts', () => {
+      expect(() => AmountValidator.validate('100', 0))
+        .to.throw(InvalidAmountError, 'must be a valid number');
+
+      expect(() => AmountValidator.validate(NaN, 0))
+        .to.throw(InvalidAmountError, 'must be a valid number');
+    });
+
+    it('should reject zero or negative amounts', () => {
+      expect(() => AmountValidator.validate(0, 0))
+        .to.throw(InvalidAmountError, 'must be greater than 0');
+
+      expect(() => AmountValidator.validate(-100, 0))
+        .to.throw(InvalidAmountError, 'must be greater than 0');
+    });
+
+    it('should reject amounts that are too large', () => {
+      expect(() => AmountValidator.validate(22000000000, 0))
+        .to.throw(InvalidAmountError, 'cannot exceed');
+    });
+
+    it('should reject amounts with more decimals than units allow', () => {
+      expect(() => AmountValidator.validate(1.123, 2))
+        .to.throw(InvalidAmountError, 'decimal places but units is');
+    });
+
+    it('should reject invalid units', () => {
+      expect(() => AmountValidator.validate(100, -1))
+        .to.throw(InvalidUnitsError);
+
+      expect(() => AmountValidator.validate(100, 9))
+        .to.throw(InvalidUnitsError);
+
+      expect(() => AmountValidator.validate(100, 1.5))
+        .to.throw(InvalidUnitsError, 'must be an integer');
+    });
+  });
+
+  describe('validateUnits', () => {
+    it('should validate correct units', () => {
+      expect(AmountValidator.validateUnits(0)).to.be.true;
+      expect(AmountValidator.validateUnits(4)).to.be.true;
+      expect(AmountValidator.validateUnits(8)).to.be.true;
+    });
+
+    it('should reject units outside range', () => {
+      expect(() => AmountValidator.validateUnits(-1))
+        .to.throw(InvalidUnitsError, 'must be between');
+
+      expect(() => AmountValidator.validateUnits(9))
+        .to.throw(InvalidUnitsError, 'must be between');
+    });
+
+    it('should reject non-integer units', () => {
+      expect(() => AmountValidator.validateUnits(2.5))
+        .to.throw(InvalidUnitsError, 'must be an integer');
+    });
+
+    it('should reject non-numeric units', () => {
+      expect(() => AmountValidator.validateUnits('4'))
+        .to.throw(InvalidUnitsError, 'must be a valid number');
+    });
+  });
+
+  describe('validateQualifierQuantity', () => {
+    it('should validate correct qualifier quantities', () => {
+      expect(AmountValidator.validateQualifierQuantity(1)).to.be.true;
+      expect(AmountValidator.validateQualifierQuantity(5)).to.be.true;
+      expect(AmountValidator.validateQualifierQuantity(10)).to.be.true;
+    });
+
+    it('should reject quantities outside 1-10 range', () => {
+      expect(() => AmountValidator.validateQualifierQuantity(0))
+        .to.throw(InvalidAmountError, 'must be between');
+
+      expect(() => AmountValidator.validateQualifierQuantity(11))
+        .to.throw(InvalidAmountError, 'must be between');
+    });
+
+    it('should reject non-integer quantities', () => {
+      expect(() => AmountValidator.validateQualifierQuantity(5.5))
+        .to.throw(InvalidAmountError, 'must be an integer');
+    });
+  });
+
+  describe('validateOwnerTokenQuantity', () => {
+    it('should validate owner token quantity of 1', () => {
+      expect(AmountValidator.validateOwnerTokenQuantity(1)).to.be.true;
+    });
+
+    it('should reject any quantity other than 1', () => {
+      expect(() => AmountValidator.validateOwnerTokenQuantity(0))
+        .to.throw(InvalidAmountError, 'must be exactly 1');
+
+      expect(() => AmountValidator.validateOwnerTokenQuantity(2))
+        .to.throw(InvalidAmountError, 'must be exactly 1');
+    });
+  });
+
+  describe('getDecimalPlaces', () => {
+    it('should correctly count decimal places', () => {
+      expect(AmountValidator.getDecimalPlaces(100)).to.equal(0);
+      expect(AmountValidator.getDecimalPlaces(1.5)).to.equal(1);
+      expect(AmountValidator.getDecimalPlaces(1.25)).to.equal(2);
+      expect(AmountValidator.getDecimalPlaces(0.00000001)).to.equal(8);
+    });
+
+    it('should handle scientific notation', () => {
+      expect(AmountValidator.getDecimalPlaces(1e-8)).to.equal(8);
+      expect(AmountValidator.getDecimalPlaces(1.5e2)).to.equal(0);
+    });
+  });
+
+  describe('validateSum', () => {
+    it('should validate sums within limits', () => {
+      expect(AmountValidator.validateSum(1000, 2000)).to.be.true;
+      expect(AmountValidator.validateSum(10000000000, 10000000000)).to.be.true;
+    });
+
+    it('should reject sums that exceed maximum', () => {
+      expect(() => AmountValidator.validateSum(20000000000, 5000000000))
+        .to.throw(InvalidAmountError, 'exceeds maximum');
+    });
+  });
+});

package/tests/unit/validators/assetNameValidator.test.js

@@ -0,0 +1,228 @@
+/**
+ * Tests for AssetNameValidator
+ */
+
+const { expect } = require('chai');
+const AssetNameValidator = require('../../../src/validators/assetNameValidator');
+const { InvalidAssetNameError } = require('../../../src/errors');
+
+describe('AssetNameValidator', () => {
+  describe('validateRoot', () => {
+    it('should validate correct ROOT asset names', () => {
+      expect(AssetNameValidator.validateRoot('MYTOKEN')).to.be.true;
+      expect(AssetNameValidator.validateRoot('TEST')).to.be.true;
+      expect(AssetNameValidator.validateRoot('MY_TOKEN')).to.be.true;
+      expect(AssetNameValidator.validateRoot('MY.TOKEN')).to.be.true;
+      expect(AssetNameValidator.validateRoot('TOKEN123')).to.be.true;
+    });
+
+    it('should reject names that are too short', () => {
+      expect(() => AssetNameValidator.validateRoot('AB'))
+        .to.throw(InvalidAssetNameError, 'ROOT asset name must be');
+    });
+
+    it('should reject names that are too long', () => {
+      expect(() => AssetNameValidator.validateRoot('A'.repeat(31)))
+        .to.throw(InvalidAssetNameError, 'ROOT asset name must be');
+    });
+
+    it('should reject lowercase names', () => {
+      expect(() => AssetNameValidator.validateRoot('mytoken'))
+        .to.throw(InvalidAssetNameError, 'must be uppercase');
+    });
+
+    it('should reject names starting with restricted characters', () => {
+      expect(() => AssetNameValidator.validateRoot('ATOKEN'))
+        .to.throw(InvalidAssetNameError, 'cannot start with');
+
+      expect(() => AssetNameValidator.validateRoot('ZTOKEN'))
+        .to.throw(InvalidAssetNameError, 'cannot start with');
+
+      expect(() => AssetNameValidator.validateRoot('.TOKEN'))
+        .to.throw(InvalidAssetNameError, 'cannot start with');
+    });
+
+    it('should reject names with invalid characters', () => {
+      expect(() => AssetNameValidator.validateRoot('MY-TOKEN'))
+        .to.throw(InvalidAssetNameError, 'can only contain');
+
+      expect(() => AssetNameValidator.validateRoot('MY TOKEN'))
+        .to.throw(InvalidAssetNameError, 'can only contain');
+
+      expect(() => AssetNameValidator.validateRoot('MY@TOKEN'))
+        .to.throw(InvalidAssetNameError, 'can only contain');
+    });
+
+    it('should reject reserved names', () => {
+      expect(() => AssetNameValidator.validateRoot('XNA'))
+        .to.throw(InvalidAssetNameError, 'reserved asset name');
+    });
+
+    it('should reject non-string inputs', () => {
+      expect(() => AssetNameValidator.validateRoot(null))
+        .to.throw(InvalidAssetNameError, 'must be a non-empty string');
+
+      expect(() => AssetNameValidator.validateRoot(123))
+        .to.throw(InvalidAssetNameError, 'must be a non-empty string');
+
+      expect(() => AssetNameValidator.validateRoot(''))
+        .to.throw(InvalidAssetNameError, 'must be a non-empty string');
+    });
+  });
+
+  describe('validateSub', () => {
+    it('should validate correct SUB asset names', () => {
+      expect(AssetNameValidator.validateSub('MYTOKEN/SUB')).to.be.true;
+      expect(AssetNameValidator.validateSub('TEST/ALPHA')).to.be.true;
+      expect(AssetNameValidator.validateSub('TOKEN/SUB_1')).to.be.true;
+    });
+
+    it('should reject names without separator', () => {
+      expect(() => AssetNameValidator.validateSub('MYTOKEN'))
+        .to.throw(InvalidAssetNameError, 'must be in');
+    });
+
+    it('should reject names with multiple separators', () => {
+      expect(() => AssetNameValidator.validateSub('MY/TOKEN/SUB'))
+        .to.throw(InvalidAssetNameError, 'must be in');
+    });
+
+    it('should reject invalid root parts', () => {
+      expect(() => AssetNameValidator.validateSub('AB/SUB'))
+        .to.throw(InvalidAssetNameError);
+    });
+
+    it('should reject invalid sub parts', () => {
+      expect(() => AssetNameValidator.validateSub('MYTOKEN/ab'))
+        .to.throw(InvalidAssetNameError, 'must be uppercase');
+    });
+  });
+
+  describe('validateUnique', () => {
+    it('should validate correct UNIQUE asset names', () => {
+      expect(AssetNameValidator.validateUnique('MYTOKEN#NFT1')).to.be.true;
+      expect(AssetNameValidator.validateUnique('TEST#ALPHA')).to.be.true;
+      expect(AssetNameValidator.validateUnique('TOKEN#123')).to.be.true;
+    });
+
+    it('should reject names without # separator', () => {
+      expect(() => AssetNameValidator.validateUnique('MYTOKEN'))
+        .to.throw(InvalidAssetNameError, 'must be in ROOT#TAG format');
+    });
+
+    it('should reject names with multiple # separators', () => {
+      expect(() => AssetNameValidator.validateUnique('MY#TOKEN#TAG'))
+        .to.throw(InvalidAssetNameError);
+    });
+
+    it('should reject invalid root parts', () => {
+      expect(() => AssetNameValidator.validateUnique('AB#TAG'))
+        .to.throw(InvalidAssetNameError);
+    });
+
+    it('should reject invalid tag parts', () => {
+      expect(() => AssetNameValidator.validateUnique('MYTOKEN#ab'))
+        .to.throw(InvalidAssetNameError, 'must be uppercase');
+    });
+  });
+
+  describe('validateQualifier', () => {
+    it('should validate correct QUALIFIER names', () => {
+      expect(AssetNameValidator.validateQualifier('#KYC')).to.be.true;
+      expect(AssetNameValidator.validateQualifier('#ACCREDITED')).to.be.true;
+      expect(AssetNameValidator.validateQualifier('#TEST_1')).to.be.true;
+    });
+
+    it('should validate correct SUB_QUALIFIER names', () => {
+      expect(AssetNameValidator.validateQualifier('#KYC/TIER1')).to.be.true;
+      expect(AssetNameValidator.validateQualifier('#TEST/ALPHA')).to.be.true;
+    });
+
+    it('should reject names without # prefix', () => {
+      expect(() => AssetNameValidator.validateQualifier('KYC'))
+        .to.throw(InvalidAssetNameError, 'must start with #');
+    });
+
+    it('should reject lowercase qualifier names', () => {
+      expect(() => AssetNameValidator.validateQualifier('#kyc'))
+        .to.throw(InvalidAssetNameError, 'must be uppercase');
+    });
+
+    it('should reject qualifiers with invalid characters', () => {
+      expect(() => AssetNameValidator.validateQualifier('#KYC.TEST'))
+        .to.throw(InvalidAssetNameError, 'can only contain');
+    });
+  });
+
+  describe('validateRestricted', () => {
+    it('should validate correct RESTRICTED asset names', () => {
+      expect(AssetNameValidator.validateRestricted('$SECURITY')).to.be.true;
+      expect(AssetNameValidator.validateRestricted('$TOKEN')).to.be.true;
+      expect(AssetNameValidator.validateRestricted('$MY_TOKEN')).to.be.true;
+    });
+
+    it('should reject names without $ prefix', () => {
+      expect(() => AssetNameValidator.validateRestricted('SECURITY'))
+        .to.throw(InvalidAssetNameError, 'must start with $');
+    });
+
+    it('should reject invalid base names', () => {
+      expect(() => AssetNameValidator.validateRestricted('$ab'))
+        .to.throw(InvalidAssetNameError);
+    });
+  });
+
+  describe('validateOwnerToken', () => {
+    it('should validate correct owner token names', () => {
+      expect(AssetNameValidator.validateOwnerToken('MYTOKEN!')).to.be.true;
+      expect(AssetNameValidator.validateOwnerToken('$SECURITY!')).to.be.true;
+    });
+
+    it('should reject names without ! suffix', () => {
+      expect(() => AssetNameValidator.validateOwnerToken('MYTOKEN'))
+        .to.throw(InvalidAssetNameError, 'must end with !');
+    });
+
+    it('should reject invalid base names', () => {
+      expect(() => AssetNameValidator.validateOwnerToken('ab!'))
+        .to.throw(InvalidAssetNameError);
+    });
+  });
+
+  describe('validateAndDetectType', () => {
+    it('should detect and validate ROOT assets', () => {
+      const type = AssetNameValidator.validateAndDetectType('MYTOKEN');
+      expect(type).to.equal('ROOT');
+    });
+
+    it('should detect and validate SUB assets', () => {
+      const type = AssetNameValidator.validateAndDetectType('MYTOKEN/SUB');
+      expect(type).to.equal('SUB');
+    });
+
+    it('should detect and validate UNIQUE assets', () => {
+      const type = AssetNameValidator.validateAndDetectType('MYTOKEN#NFT1');
+      expect(type).to.equal('UNIQUE');
+    });
+
+    it('should detect and validate QUALIFIER assets', () => {
+      const type = AssetNameValidator.validateAndDetectType('#KYC');
+      expect(type).to.equal('QUALIFIER');
+    });
+
+    it('should detect and validate SUB_QUALIFIER assets', () => {
+      const type = AssetNameValidator.validateAndDetectType('#KYC/TIER1');
+      expect(type).to.equal('SUB_QUALIFIER');
+    });
+
+    it('should detect and validate RESTRICTED assets', () => {
+      const type = AssetNameValidator.validateAndDetectType('$SECURITY');
+      expect(type).to.equal('RESTRICTED');
+    });
+
+    it('should detect and validate OWNER tokens', () => {
+      const type = AssetNameValidator.validateAndDetectType('MYTOKEN!');
+      expect(type).to.equal('OWNER');
+    });
+  });
+});