reporting-comparisonreporting-comparison

ava.js

import test from 'ava';
import {Bar, Foo, monkeyPatched, objWithPrototype, simpleObj} from './tested.js';

test(`native custom type(date)`, (t) => {
    t.deepEqual(
        {prop: new Date('2222-01-01T00:00:00.000Z')},
        {prop: '2222-01-01T00:00:00.000Z'}
    );
});

test(`prototypal chain (with constructor)`, (t) => {
    t.deepEqual(
        {prop:new Foo()},
        {prop:new Bar()}
    );
});

test(`prototypal chains`, (t) => {
    t.deepEqual(
        simpleObj,
        objWithPrototype
    );
});

test(`configured properties`, (t) => {
    t.deepEqual(
        simpleObj,
        monkeyPatched
    );
});

jest.spec.js

class Foo {
    constructor() {
        this.prop = 'value';
    }
}

class Bar {
    constructor() {
        this.prop = 'value';
    }
}

const simpleObj = Object.defineProperties({}, {
    prop: {value: 'value'}
});

const monkeyPatched = Object.defineProperties({}, {
    prop: {value: 'value', enumerable: true}
});


test(`native custom type(date)`, () => {
    expect({prop: new Date('2222-01-01T00:00:00.000Z')})
        .toEqual({prop: '2222-01-01T00:00:00.000Z'});
});

test(`prototypal chain (with constructor)`, () => {
    expect(new Foo()).toEqual(new Bar());
});

test(`prototypal chain`, () => {
    expect(simpleObj).toEqual(monkeyPatched);
});

mocha.js

import {deepStrictEqual} from 'assert';
import {Bar, Foo, monkeyPatched, objWithPrototype, simpleObj} from './tested.js';

describe('weird similar but different objects', () => {
    it(`native custom type(date)`, () => {
        deepStrictEqual(
            {prop: new Date('2222-01-01T00:00:00.000Z')},
            {prop: '2222-01-01T00:00:00.000Z'}
        );
    });
    
    it(`prototypal chain (with constructor)`, () => {
        // deepStrictEqual(
        //     new Foo(),
        //     new Bar()
        // );
        deepStrictEqual(
            {prop:new Foo()},
            {prop:new Bar()}
        );
    
    });
    
    it(`prototypal chain`, () => {
        deepStrictEqual(
            simpleObj,
            objWithPrototype
        );
    });
    
    it(`configured props`, () => {
        deepStrictEqual(
            simpleObj,
            monkeyPatched
        );
    });
});

package.json

{
  "name": "test-diff-comp",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "test:zora": "pta pta.js",
    "test:ava": "ava",
    "test:jest": "jest jest",
    "test:mocha": "mocha mocha.js"
  },
  "ava": {
    "files": ["ava.js"]
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "ava": "~3.15.0",
    "jest": "~27.3.1",
    "mocha": "~9.1.3",
    "pta": "~1.0.0"
  }
}

pta.js

import {test} from 'zora';
import {Bar, Foo, monkeyPatched, objWithPrototype, simpleObj} from './tested.js';

test(`native custom type(date)`, (t) => {
    t.eq(
        {prop: new Date('2222-01-01T00:00:00.000Z')},
        {prop: '2222-01-01T00:00:00.000Z'}
    );
});

test(`prototypal chain (with constructor)`, (t) => {
    t.eq(
        new Foo(),
        new Bar()
    );
});

test(`prototypal chain`, (t) => {
    t.eq(
        simpleObj,
        objWithPrototype
    );
});

test(`configured props`, (t) => {
    t.eq(
        simpleObj,
        monkeyPatched
    );
});

tested.js

export class Foo {
    constructor() {
        this.prop = 'value';
    }
}

export class Bar {
    constructor() {
        this.prop = 'value';
    }
}

export const simpleObj = Object.defineProperties({}, {
    prop: {value: 'value'}
});

export const objWithPrototype = Object.create({
    behaviorMethod(){}
},{
    prop: {value: 'value'}
    
})

export const monkeyPatched = Object.defineProperties({}, {
        prop: {value: 'value', enumerable: true}
    })
;