smartjson/test/test.both.ts

import { tap, expect } from '@git.zone/tstest/tapbundle';

import * as smartjson from '../ts/index.js';

class SomeClass extends smartjson.Smartjson {
  @smartjson.foldDec() thisis: string = 'test';
  constructor() {
    super();
    console.log(this.saveableProperties);
  }
}

let mySomeClass: SomeClass;

tap.test('should create a Foldable extended instance', async () => {
  mySomeClass = new SomeClass();
  expect(mySomeClass).toBeInstanceOf(SomeClass);
  expect(mySomeClass).toBeInstanceOf(smartjson.Smartjson);
});

tap.test('should create a folded object', async () => {
  let foldedObject = mySomeClass.foldToObject();
  expect(foldedObject).property('thisis').toEqual('test');
});

tap.test('should enfold from object', async () => {
  const mySomeClass2 = SomeClass.enfoldFromObject({ thisis: 'test2' });
  expect(mySomeClass2).property('thisis').toEqual('test2');
});

tap.test('should products stable jsons', async () => {
  const jsonString = smartjson.stringify({
    a: 1,
    f: 6,
    b: 3,
    c: 3,
    e: 5,
    d: 4,
  });
  console.log(jsonString);
});

tap.test('should work with base64', async () => {
  const someObject = {
    hi: 'there',
    thisIs: 'awesome',
  };

  const base64Json = smartjson.stringifyBase64(someObject);
  console.log(base64Json);
  const decodedObject = smartjson.parseBase64(base64Json);
  expect(decodedObject).toEqual(someObject);
});

tap.test('stringify should handle plain string', async () => {
  const stringifiedString = smartjson.stringify('hello');
  console.log(stringifiedString);
  expect(stringifiedString).toEqual('"hello"');
  expect(smartjson.parse(stringifiedString)).toEqual('hello');
});

tap.test('should work with buffers', async () => {
  const someObject = {
    myBuffer: new TextEncoder().encode('hello')
  };
  console.log(someObject.myBuffer);
  const stringified = smartjson.stringify(someObject);
  console.log(stringified);
  const decoded = smartjson.parse(stringified);
  console.log(decoded.myBuffer);
  let text = new TextDecoder().decode(decoded.myBuffer);
  expect(text).toEqual('hello');
});

tap.test('should handle empty buffers', async () => {
  const someObject = { empty: new Uint8Array([]) };
  const json = smartjson.stringify(someObject);
  const parsed = smartjson.parse(json);
  expect(parsed.empty).toBeInstanceOf(Uint8Array);
  expect(parsed.empty.length).toEqual(0);
});

tap.test('should parse and stringify JSONL', async () => {
  const items = [
    { id: 1, name: 'a' },
    { id: 2, name: 'b' }
  ];
  const jsonl = smartjson.stringifyJsonL(items);
  const parsed = smartjson.parseJsonL(jsonl);
  expect(parsed).toEqual(items);
});

tap.test('should deep-compare JSONL strings', async () => {
  const a = '{"id":2,"name":"b"}\n{"id":1,"name":"a"}';
  const b = '{"id":2,"name":"b"}\n{"id":1,"name":"a"}';
  expect(smartjson.deepEqualJsonLStrings(a, b)).toEqual(true);
});

tap.test('should respect simpleOrderArray comparator', async () => {
  const obj = { c: 3, a: 1, b: 2 };
  const ordered = smartjson.stringify(obj, ['b', 'a']);
  // ensure keys b, a come before c
  expect(ordered.indexOf('"b"')).toBeLessThan(ordered.indexOf('"a"'));
  expect(ordered.indexOf('"a"')).toBeLessThan(ordered.indexOf('"c"'));
});

tap.test('stableOneWayStringify should handle circular references without throwing', async () => {
  const a: any = { name: 'x' };
  a.self = a;
  const b: any = { name: 'x' };
  b.self = b;
  const s1 = smartjson.stableOneWayStringify(a);
  const s2 = smartjson.stableOneWayStringify(b);
  expect(typeof s1).toEqual('string');
  expect(s1).toEqual(s2);
});

tap.start();