fixed failing tests

Signed-off-by: Simeon Nakov <[email protected]>

Author: simzzz

packages/relay/tests/lib/errors/SDKClientError.spec.ts

@@ -325,7 +325,7 @@ describe('SDKClientError', () => {
 
     const error = new SDKClientError(errorWithNullMessage, customMessage);
 
-    expect(error.message).to.equal(null); // Should use e.message (null) since status._code is truthy
+    expect(error.message).to.equal('null');
     expect(error.isValidNetworkError()).to.be.true;
   });
 
@@ -335,7 +335,7 @@ describe('SDKClientError', () => {
 
     const error = new SDKClientError(errorWithUndefinedMessage, customMessage);
 
-    expect(error.message).to.equal(undefined); // Should use e.message (undefined) since status._code is truthy
+    expect(error.message).to.equal('');
     expect(error.isValidNetworkError()).to.be.true;
   });
 

packages/relay/tests/lib/formatters.spec.ts

@@ -992,5 +992,153 @@ describe('Formatters', () => {
       expect(formatRequestIdMessage('')).to.eq('');
       expect(formatRequestIdMessage(null as any)).to.eq('');
     });
+
+    it('should test hashNumber function indirectly through various number inputs', () => {
+      // Test hashNumber with different types of numbers to ensure full coverage
+      expect(numberTo0x(BigInt('18446744073709551615'))).to.equal('0xffffffffffffffff'); // Max 64-bit
+      expect(numberTo0x(1)).to.equal('0x1');
+      expect(numberTo0x(256)).to.equal('0x100');
+    });
+
+    it('should test weibarHexToTinyBarInt with empty hex value', () => {
+      // This should hit the specific condition: if (value === '0x') return 0;
+      expect(weibarHexToTinyBarInt('0x')).to.eq(0);
+    });
+
+    it('should test weibarHexToTinyBarInt with fractional weibar that rounds to 1', () => {
+      // Test the condition: if (tinybarValue === BigInt(0) && weiBigInt > BigInt(0)) return 1;
+      expect(weibarHexToTinyBarInt('0x5')).to.eq(1); // 5 weibar should round to 1 tinybar
+      expect(weibarHexToTinyBarInt('0x9')).to.eq(1); // 9 weibar should round to 1 tinybar
+    });
+
+    it('should test mapKeysAndValues with no mapping functions', () => {
+      // Test when mapFn.key and mapFn.value are undefined
+      const target = { a: '1', b: '2' };
+      const result = mapKeysAndValues(target, {} as any);
+      expect(result).to.deep.equal({ a: '1', b: '2' });
+    });
+
+    it('should test mapKeysAndValues with only key mapping', () => {
+      // Test when mapFn.value is undefined
+      const target = { a: '1', b: '2' };
+      const result = mapKeysAndValues(target, { key: (k) => k.toUpperCase() } as any);
+      expect(result).to.deep.equal({ A: '1', B: '2' });
+    });
+
+    it('should test mapKeysAndValues with only value mapping', () => {
+      // Test when mapFn.key is undefined
+      const target = { a: '1', b: '2' };
+      const result = mapKeysAndValues(target, { value: (v) => parseInt(v) } as any);
+      expect(result).to.deep.equal({ a: 1, b: 2 });
+    });
+
+    it('should test nullableNumberTo0x with null input', () => {
+      // Test the specific condition: return input == null ? null : numberTo0x(input);
+      expect(nullableNumberTo0x(null)).to.equal(null);
+      expect(nullableNumberTo0x(undefined as any)).to.equal(null);
+    });
+
+    it('should test toNullableBigNumber with string input', () => {
+      // Test the specific condition: if (typeof value === 'string') { return new BN(value).toString(); }
+      expect(toNullableBigNumber('0x1a')).to.equal('26');
+      expect(toNullableBigNumber('100')).to.equal('100');
+    });
+
+    it('should test toNullableBigNumber with non-string input', () => {
+      // Test the fallback condition: return null;
+      expect(toNullableBigNumber(123 as any)).to.equal(null);
+      expect(toNullableBigNumber(true as any)).to.equal(null);
+      expect(toNullableBigNumber([] as any)).to.equal(null);
+    });
+
+    it('should test toNullIfEmptyHex with empty hex', () => {
+      // Test the specific condition: return value === EMPTY_HEX ? null : value;
+      expect(toNullIfEmptyHex('0x')).to.equal(null);
+    });
+
+    it('should test toNullIfEmptyHex with non-empty value', () => {
+      // Test the else condition
+      expect(toNullIfEmptyHex('0x123')).to.equal('0x123');
+      expect(toNullIfEmptyHex('test')).to.equal('test');
+    });
+
+    it('should test toHexString with various byte arrays', () => {
+      // Test the Buffer.from conversion
+      expect(toHexString(new Uint8Array([0x01, 0x02, 0x03]))).to.eq('010203');
+      expect(toHexString(new Uint8Array([0x00]))).to.eq('00');
+      expect(toHexString(new Uint8Array([0xaa, 0xbb, 0xcc]))).to.eq('aabbcc');
+    });
+
+    it('should test isValidEthereumAddress with various edge cases', () => {
+      // Test specific return false conditions
+      expect(isValidEthereumAddress('')).to.equal(false);
+      expect(isValidEthereumAddress('0x')).to.equal(false);
+      expect(isValidEthereumAddress('0x123')).to.equal(false); // too short
+      expect(isValidEthereumAddress('0x123456789012345678901234567890123456789g')).to.equal(false); // invalid char
+    });
+
+    it('should test getFunctionSelector with various inputs', () => {
+      // Test the remove0x and remove0 functions
+      expect(getFunctionSelector('0x1234567890')).to.eq('12345678');
+      expect(getFunctionSelector('1234567890')).to.eq('12345678');
+      expect(getFunctionSelector('0x12345678')).to.eq('12345678');
+      expect(getFunctionSelector('12345678')).to.eq('12345678');
+      expect(getFunctionSelector('0x123')).to.eq('123');
+      expect(getFunctionSelector('123')).to.eq('123');
+    });
+
+    it('should test tinybarsToWeibars with negative values and allowNegativeValues true', () => {
+      // Test the condition: if (allowNegativeValues) return value;
+      expect(tinybarsToWeibars(-5, true)).to.equal(-5);
+      expect(tinybarsToWeibars(-100, true)).to.equal(-100);
+    });
+
+    it('should test tinybarsToWeibars with excessive values', () => {
+      // Test the condition: if (value && value > constants.TOTAL_SUPPLY_TINYBARS)
+      const excessiveValue = constants.TOTAL_SUPPLY_TINYBARS + 1000000000;
+      expect(() => tinybarsToWeibars(excessiveValue, false)).to.throw(
+        Error,
+        'Value cannot be more than the total supply of tinybars in the blockchain',
+      );
+      expect(() => tinybarsToWeibars(excessiveValue, true)).to.throw(
+        Error,
+        'Value cannot be more than the total supply of tinybars in the blockchain',
+      );
+    });
+
+    it('should test tinybarsToWeibars with null and undefined', () => {
+      // Test the condition: return value == null ? null : value * constants.TINYBAR_TO_WEIBAR_COEF;
+      expect(tinybarsToWeibars(null, false)).to.equal(null);
+      expect(tinybarsToWeibars(undefined as any, false)).to.equal(null);
+    });
+
+    it('should test parseNumericEnvVar with specific constant fallback', () => {
+      // Test the specific condition where constants[fallbackConstantKey] is accessed
+      expect(() => parseNumericEnvVar('NONEXISTENT_VAR', 'TOTALLY_INVALID_CONSTANT')).to.throw(
+        Error,
+        "Unable to parse numeric env var: 'NONEXISTENT_VAR', constant: 'TOTALLY_INVALID_CONSTANT'",
+      );
+    });
+
+    it('should test formatTransactionId with edge cases', () => {
+      // Test the specific TRANSACTION_ID_REGEX condition
+      expect(formatTransactionId('0.0.2@')).to.eq(null);
+      expect(formatTransactionId('0.0.2')).to.eq(null);
+      expect(formatTransactionId('@1234567890.123456789')).to.eq(null);
+      expect(formatTransactionId('invalid')).to.eq(null);
+    });
+
+    it('should test formatTransactionIdWithoutQueryParams with null formatTransactionId', () => {
+      // Test the condition: if (!formattedTransactionIdWithQueryParams) { return null; }
+      expect(formatTransactionIdWithoutQueryParams('invalid?nonce=1')).to.eq(null);
+      expect(formatTransactionIdWithoutQueryParams('@invalid?nonce=1')).to.eq(null);
+    });
+
+    it('should test decodeErrorMessage with various edge cases', () => {
+      // Test non-hex messages
+      expect(decodeErrorMessage('not hex')).to.equal('not hex');
+      expect(decodeErrorMessage('0xmalformed')).to.equal('');
+      expect(decodeErrorMessage('0x123')).to.equal('');
+    });
   });
 });