smartexpect/test/test.both.ts

import { tap } from '@push.rocks/tapbundle';
import * as smartexpect from '../ts/index.js';

tap.test('basic type assertions', async () => {
  // String type checks
  smartexpect.expect('hello').toBeTypeofString();
  smartexpect.expect(1).not.toBeTypeofString();
  
  // Boolean type checks
  smartexpect.expect(true).toBeTypeofBoolean();
  smartexpect.expect(false).toBeTypeofBoolean();
  smartexpect.expect(1).not.toBeTypeofBoolean();
  
  // Number type checks
  smartexpect.expect(42).toBeTypeofNumber();
  smartexpect.expect(true).not.toBeTypeofNumber();
  
  // Generic type checks with new method
  smartexpect.expect(() => {}).toBeTypeOf('function');
  smartexpect.expect(class Test {}).toBeTypeOf('function');
  smartexpect.expect({}).toBeTypeOf('object');
  smartexpect.expect(Symbol('test')).toBeTypeOf('symbol');
});

tap.test('async tests', async (toolsArg) => {
  const deferred = toolsArg.defer();
  toolsArg.delayFor(1000).then(() => {
    deferred.resolve('hello');
  });
  await smartexpect.expectAsync(deferred.promise).timeout(2000).toBeTypeofString();
  await smartexpect.expectAsync(deferred.promise).not.toBeTypeofBoolean();
  
  // Test async timeout handling
  const longOperation = toolsArg.defer();
  toolsArg.delayFor(3000).then(() => {
    longOperation.resolve('completed');
  });
  try {
    await smartexpect.expectAsync(longOperation.promise).timeout(1000).toBeDefined();
    throw new Error('Should have timed out');
  } catch (err) {
    // Expected timeout error
    console.log('Successfully caught timeout:', err.message);
  }
});

tap.test('equality and matching assertions', async () => {
  // Basic equality
  smartexpect.expect('hithere').toEqual('hithere');
  smartexpect.expect('hithere').not.toEqual('hithere2');
  
  // Object equality
  const obj1 = { a: 1, b: { c: true } };
  const obj2 = { a: 1, b: { c: true } };
  const obj3 = { a: 1, b: { c: false } };
  smartexpect.expect(obj1).toEqual(obj2);
  smartexpect.expect(obj1).not.toEqual(obj3);
  
  // RegExp matching
  smartexpect.expect('hithere').toMatch(/hi/);
  smartexpect.expect('hithere').toMatch(/^hithere$/);
  smartexpect.expect('hithere').not.toMatch(/ho/);
  
  // String inclusion
  smartexpect.expect('hithere').toInclude('hit');
  smartexpect.expect('hithere').not.toInclude('missing');
  
  // String start/end
  smartexpect.expect('hithere').toStartWith('hi');
  smartexpect.expect('hithere').toEndWith('ere');
});

tap.test('object property assertions', async () => {
  const testObject = {
    topLevel: 'hello',
    nested: {
      prop: 42,
      deeplyNested: {
        array: [1, 2, 3]
      }
    }
  };

  // Basic property checks
  smartexpect.expect(testObject).toHaveProperty('topLevel');
  smartexpect.expect(testObject).toHaveProperty('topLevel', 'hello');
  smartexpect.expect(testObject).not.toHaveProperty('missing');
  
  // Drill-down property navigation
  smartexpect.expect(testObject).property('nested').toHaveProperty('prop', 42);
  smartexpect.expect(testObject).property('nested').property('deeplyNested').property('array').toBeArray();
  
  // Deep property checks
  smartexpect.expect(testObject).toHaveDeepProperty(['nested', 'deeplyNested', 'array']);
  
  // Array item navigation
  smartexpect.expect(testObject).property('nested').property('deeplyNested').property('array').arrayItem(0).toEqual(1);
});

tap.test('numeric comparison assertions', async () => {
  // Greater/less than
  smartexpect.expect(4).toBeGreaterThan(3);
  smartexpect.expect(4).toBeLessThan(5);
  smartexpect.expect(4).toBeGreaterThanOrEqual(4);
  smartexpect.expect(4).toBeLessThanOrEqual(4);
  
  // Approximate equality
  smartexpect.expect(0.1 + 0.2).toBeCloseTo(0.3, 10);
});

tap.test('array assertions', async () => {
  const obj1 = { id: 1 };
  const obj2 = { id: 2 };
  const testArray = [1, 'two', obj1, true];
  
  // Basic array checks
  smartexpect.expect(testArray).toBeArray();
  smartexpect.expect(testArray).toHaveLength(4);
  
  // Content checks
  smartexpect.expect(testArray).toContain('two');
  smartexpect.expect(testArray).toContain(obj1);
  smartexpect.expect(testArray).not.toContain(obj2);
  
  // Array with equal items (not same reference)
  smartexpect.expect([{ a: 1 }, { b: 2 }]).toContainEqual({ a: 1 });
  
  // Multiple values
  smartexpect.expect(testArray).toContainAll([1, 'two']);
  smartexpect.expect(testArray).toExclude('missing');
  
  // Empty array
  smartexpect.expect([]).toBeEmptyArray();
  
  // Length comparisons
  smartexpect.expect(testArray).toHaveLengthGreaterThan(3);
  smartexpect.expect(testArray).toHaveLengthLessThan(5);
});

tap.test('boolean assertions', async () => {
  // True/False
  smartexpect.expect(true).toBeTrue();
  smartexpect.expect(false).toBeFalse();
  
  // Truthy/Falsy
  smartexpect.expect('something').toBeTruthy();
  smartexpect.expect(0).toBeFalsy();
  
  // Null/Undefined
  smartexpect.expect(null).toBeNull();
  smartexpect.expect(undefined).toBeUndefined();
  smartexpect.expect(null).toBeNullOrUndefined();
  smartexpect.expect(undefined).toBeNullOrUndefined();
});

tap.test('function assertions', async () => {
  // Function that throws
  const throwingFn = () => { throw new Error('test error'); };
  smartexpect.expect(throwingFn).toThrow();
  smartexpect.expect(throwingFn).toThrow(Error);
  
  // Function that doesn't throw
  const nonThrowingFn = () => 'safe';
  smartexpect.expect(nonThrowingFn).not.toThrow();
});

tap.test('date assertions', async () => {
  const now = new Date();
  const past = new Date(Date.now() - 10000);
  const future = new Date(Date.now() + 10000);
  
  smartexpect.expect(now).toBeDate();
  smartexpect.expect(now).toBeAfterDate(past);
  smartexpect.expect(now).toBeBeforeDate(future);
});

tap.test('custom assertions', async () => {
  // Custom validation logic
  smartexpect.expect(42).customAssertion(
    value => value % 2 === 0, 
    'Expected number to be even'
  );
  
  // With fail message
  smartexpect.expect('test')
    .setFailMessage('Custom fail message for assertion')
    .toHaveLength(4);
});

tap.test('logging and debugging', async () => {
  // Using log() for debugging
  const complexObject = {
    level1: {
      level2: {
        value: 'nested value'
      }
    }
  };
  
  // This logs the current value in the chain for debugging
  smartexpect.expect(complexObject).property('level1').property('level2').log().property('value').toEqual('nested value');
});

export default tap.start();