@pezkuwi/types-codec 16.5.5

package/src/native/Struct.spec.ts

@@ -0,0 +1,411 @@
+// Copyright 2017-2025 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+/* eslint-disable sort-keys */
+
+import type { Bool, Option } from '@pezkuwi/types-codec';
+import type { CodecTo } from '@pezkuwi/types-codec/types';
+
+import { TypeRegistry } from '@pezkuwi/types';
+import { Enum, Struct, Text, U32, Vec } from '@pezkuwi/types-codec';
+import { stringify } from '@pezkuwi/util';
+
+import { TEST_A } from './Struct.data.js';
+
+describe('Struct', (): void => {
+  const registry = new TypeRegistry();
+
+  describe('decoding', (): void => {
+    const testDecode = (type: string, input: any): void =>
+      it(`can decode from ${type}`, (): void => {
+        const s = new Struct(registry, {
+          foo: Text,
+          bar: U32
+        }, input);
+
+        expect([...s.keys()]).toEqual(['foo', 'bar']);
+        expect(
+          [...s.values()].map((v): string =>
+            v.toString()
+          )
+        ).toEqual(['bazzing', '69']);
+      });
+
+    testDecode('array', ['bazzing', 69]);
+    testDecode('hex', '0x1c62617a7a696e6745000000');
+    testDecode('object', { foo: 'bazzing', bar: 69 });
+    testDecode('Uint8Array', Uint8Array.from([28, 98, 97, 122, 122, 105, 110, 103, 69, 0, 0, 0]));
+    testDecode('Struct.with', new (Struct.with({ foo: 'Text', bar: 'U32' }))(registry, { foo: 'bazzing', bar: 69 }));
+
+    it('decodes null/undefined/empty correctly (& equivalent)', (): void => {
+      const Clazz = Struct.with({
+        txt: Text,
+        u32: U32
+      });
+      const expected = { txt: '', u32: '0' };
+
+      expect(new Clazz(registry, {}).toHuman()).toEqual(expected);
+      expect(new Clazz(registry, null).toHuman()).toEqual(expected);
+      expect(new Clazz(registry, undefined).toHuman()).toEqual(expected);
+    });
+
+    it('decodes with Optionals', (): void => {
+      const Clazz = Struct.with({
+        a: 'Option<Bool>',
+        b: 'Option<Bool>'
+      });
+
+      const c = new Clazz(registry, { a: false }) as unknown as { a: Option<Bool>, b: Option<Bool> };
+
+      expect(c.a.isSome).toEqual(true);
+      expect(c.a.unwrap().isTrue).toEqual(false);
+      expect(c.b.isSome).toEqual(false);
+    });
+
+    it('decodes reusing instantiated inputs', (): void => {
+      const foo = new Text(registry, 'bar');
+
+      expect(
+        (new Struct(
+          registry,
+          { foo: Text },
+          { foo }
+        )).get('foo')
+      ).toBe(foo);
+    });
+
+    it('decodes a more complicated type', (): void => {
+      const s = new Struct(registry, {
+        foo: Vec.with(Struct.with({
+          bar: Text
+        }))
+      }, { foo: [{ bar: 1 }, { bar: 2 }] });
+
+      expect(s.toString()).toBe('{"foo":[{"bar":"1"},{"bar":"2"}]}');
+    });
+
+    it('decodes a previously problematic input', (): void => {
+      let data;
+
+      try {
+        data = new Struct(registry, {
+          a: 'u32',
+          b: 'H256',
+          c: 'H256',
+          swap: Enum.with({
+            A: 'u256',
+            B: 'u256'
+          }),
+          d: Vec.with('u8'),
+          e: 'u8'
+        }, TEST_A);
+      } catch (error) {
+        console.error(error);
+
+        throw error;
+      }
+
+      expect(data.get('d')).toHaveLength(50000);
+    });
+
+    it('decodes from a Map input', (): void => {
+      const s = new Struct(registry, {
+        txt: Text,
+        foo: U32,
+        bar: U32
+      }, new Map<string, unknown>([['a', 42], ['txt', 'fubar']]));
+
+      expect(s.toString()).toEqual('{"txt":"fubar","foo":0,"bar":0}');
+    });
+
+    it('decodes from a snake_case input', (): void => {
+      const input = new Struct(registry, {
+        snakeCaseA: U32,
+        snakeCaseB: Text,
+        other: U32
+      }, { snake_case_a: 42, snake_case_b: 'fubar', other: 69 } as any);
+
+      expect(input.toString()).toEqual('{"snakeCaseA":42,"snakeCaseB":"fubar","other":69}');
+    });
+
+    it('throws when it cannot decode', (): void => {
+      expect(
+        (): Struct<any> => new (
+          Struct.with({
+            txt: Text,
+            u32: U32
+          })
+        )(registry, 'ABC')
+      ).toThrow(/Cannot decode value/);
+    });
+
+    it('throws a sensical error on incorrect array values passed to structs', (): void => {
+      expect(
+        () => new Struct(registry, {
+          _: 'Vec<u32>'
+        }, [123, 456])
+      ).toThrow(/array to object with known keys/);
+    });
+  });
+
+  describe('encoding', (): void => {
+    const testEncode = (to: CodecTo, expected: any): void =>
+      it(`can encode ${to}`, (): void => {
+        const s = new Struct(registry, {
+          foo: Text,
+          bar: U32
+        }, { foo: 'bazzing', bar: 69 });
+
+        expect(s[to]()).toEqual(expected);
+      });
+
+    testEncode('toHex', '0x1c62617a7a696e6745000000');
+    testEncode('toJSON', { foo: 'bazzing', bar: 69 });
+    testEncode('toU8a', Uint8Array.from([28, 98, 97, 122, 122, 105, 110, 103, 69, 0, 0, 0]));
+    testEncode('toString', '{"foo":"bazzing","bar":69}');
+  });
+
+  it('provides a clean toString()', (): void => {
+    expect(
+      new (
+        Struct.with({
+          txt: Text,
+          u32: U32
+        })
+      )(registry, { txt: 'foo', u32: 0x123456 }).toString()
+    ).toEqual('{"txt":"foo","u32":1193046}');
+  });
+
+  it('provides a clean toString() (string types)', (): void => {
+    expect(
+      new (
+        Struct.with({
+          txt: 'Text',
+          num: 'u32',
+          cls: U32
+        })
+      )(registry, { txt: 'foo', num: 0x123456, cls: 123 }).toString()
+    ).toEqual('{"txt":"foo","num":1193046,"cls":123}');
+  });
+
+  it('exposes the properties on the object', (): void => {
+    const struct = new (
+      Struct.with({
+        txt: Text,
+        u32: U32
+      })
+    )(registry, { txt: 'foo', u32: 0x123456 });
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
+    expect((struct as any).txt.toString()).toEqual('foo');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
+    expect((struct as any).u32.toNumber()).toEqual(0x123456);
+  });
+
+  it('correctly encodes length', (): void => {
+    expect(
+      new (
+        Struct.with({
+          txt: Text,
+          u32: U32
+        })
+      )(registry, { foo: 'bazzing', bar: 69 }).encodedLength
+    ).toEqual(5);
+  });
+
+  it('exposes the types', (): void => {
+    expect(
+      new Struct(registry, {
+        foo: Text,
+        bar: Text,
+        baz: U32
+      }, {
+        foo: 'foo',
+        bar: 'bar',
+        baz: 3
+      }).Type
+    ).toEqual({
+      foo: 'Text',
+      bar: 'Text',
+      baz: 'u32'
+    });
+  });
+
+  it('gets the value at a particular index', (): void => {
+    expect(
+      new (
+        Struct.with({
+          txt: Text,
+          u32: U32
+        })
+      )(registry, { txt: 'foo', u32: 1234 })
+        .getAtIndex(1)
+        .toString()
+    ).toEqual('1234');
+  });
+
+  describe('utils', (): void => {
+    it('compares against other objects', (): void => {
+      const test = {
+        foo: 'foo',
+        bar: 'bar',
+        baz: 3
+      };
+
+      expect(
+        new Struct(registry, {
+          foo: Text,
+          bar: Text,
+          baz: U32
+        }, test).eq(test)
+      ).toBe(true);
+    });
+
+    it('has a sane toPrimitive', (): void => {
+      const S = Struct.with({
+        name: 'Text',
+        description: 'Vec<Text>',
+        fooA: 'Bytes',
+        fooB: 'Bytes',
+        fooC: Struct.with({
+          a: 'u32',
+          b: 'u128',
+          c: 'Compact<u128>',
+          d: 'bool'
+        })
+      });
+
+      expect(
+        new S(registry, {
+          name: 'Something',
+          description: ['One line', 'Another line'],
+          fooA: 'hello world!',
+          fooB: '0x123456',
+          fooC: {
+            a: 1234,
+            b: BigInt('1234567890111213141516'),
+            c: 123456,
+            d: true
+          }
+        }).toPrimitive()
+      ).toEqual({
+        name: 'Something',
+        description: ['One line', 'Another line'],
+        fooA: 'hello world!',
+        fooB: '0x123456',
+        fooC: {
+          a: 1234,
+          b: '1234567890111213141516',
+          c: 123456,
+          d: true
+        }
+      });
+    });
+
+    it('generates sane toRawType', (): void => {
+      expect(
+        new Struct(registry, {
+          accountId: 'AccountId',
+          balanceCompact: registry.createClass('Compact<Balance>'),
+          blockNumber: registry.createClass('BlockNumber'),
+          compactNumber: registry.createClass('Compact<BlockNumber>'),
+          optionNumber: registry.createClass('Option<BlockNumber>'),
+          counter: U32,
+          vector: Vec.with('AccountId')
+        }).toRawType()
+      ).toEqual(stringify({
+        accountId: 'AccountId',
+        balanceCompact: 'Compact<Balance>', // Override in Uint
+        blockNumber: 'BlockNumber',
+        compactNumber: 'Compact<BlockNumber>',
+        optionNumber: 'Option<BlockNumber>',
+        counter: 'u32',
+        vector: 'Vec<AccountId>'
+      }));
+    });
+
+    it('generates sane toRawType (via with)', (): void => {
+      const Type = Struct.with({
+        accountId: 'AccountId',
+        balance: registry.createClass('Balance')
+      });
+
+      expect(
+        new Type(registry).toRawType()
+      ).toEqual(stringify({
+        accountId: 'AccountId',
+        balance: 'Balance' // Override in Uint
+      }));
+    });
+  });
+
+  it('allows toString with large numbers', (): void => {
+    // replicate https://github.com/polkadot-js/api/issues/640
+    expect(
+      new Struct(registry, {
+        blockNumber: registry.createClass('Option<BlockNumber>')
+      }, { blockNumber: '0x0000000010abcdef' }).toString()
+    ).toEqual('{"blockNumber":279694831}');
+  });
+
+  describe('toU8a', (): void => {
+    const def: Record<string, any> = {
+      foo: 'Bytes',
+      method: 'Bytes',
+      bar: 'Option<u32>',
+      baz: 'bool'
+    };
+    const val = {
+      foo: '0x4269',
+      method: '0x99',
+      bar: 1,
+      baz: true
+    };
+
+    it('generates toU8a with undefined', (): void => {
+      expect(
+        new Struct(registry, def, val).toU8a()
+      ).toEqual(new Uint8Array([2 << 2, 0x42, 0x69, 1 << 2, 0x99, 1, 1, 0, 0, 0, 1]));
+    });
+
+    it('generates toU8a with true', (): void => {
+      expect(
+        new Struct(registry, def, val).toU8a(true)
+      ).toEqual(new Uint8Array([0x42, 0x69, 0x99, 1, 0, 0, 0, 1]));
+    });
+
+    it('generates toU8a with { method: true }', (): void => {
+      expect(
+        new Struct(registry, def, val).toU8a({ method: true })
+      ).toEqual(new Uint8Array([2 << 2, 0x42, 0x69, 0x99, 1, 1, 0, 0, 0, 1]));
+    });
+
+    it('has a sane inspect', (): void => {
+      expect(
+        new Struct(registry, def, val).inspect()
+      ).toEqual({
+        inner: [
+          {
+            name: 'foo',
+            outer: [new Uint8Array([2 << 2]), new Uint8Array([0x42, 0x69])]
+          },
+          {
+            name: 'method',
+            outer: [new Uint8Array([1 << 2]), new Uint8Array([0x99])]
+          },
+          {
+            inner: undefined,
+            name: 'bar',
+            outer: [new Uint8Array([1]), new Uint8Array([1, 0, 0, 0])]
+          },
+          {
+            name: 'baz',
+            outer: [new Uint8Array([1])]
+          }
+        ]
+      });
+    });
+  });
+});