import { assert } from 'chai';
import { create, has, assign, clear, value } from '../../../lib/core/object';

describe('core.traits', () => {
    describe('create', () => {
        it('should create object-likes', () => {
            const obj = create<any>();
            assert.isTrue(typeof obj === 'object');
            assert.isUndefined(obj.prototype);

            obj.a = 1;
            obj.b = 2;
            obj.c = 3;
            assert.deepEqual(obj, { a: 1, b: 2, c: 3 });
        });
    });

    describe('has', () => {
        it('should test whether key exists', () => {
            const obj = create<any>();
            obj.a = 1;
            obj.b = 2;
            obj.c = 3;
            assert.isTrue(has(obj, 'a'));
            assert.isFalse(has(obj, 'z'));
        });

        it('should coerce number indicies', () => {
            const obj = create<any>();
            obj[1] = 'a';
            obj[2] = 'b';
            obj[3] = 'c';
            assert.isTrue(has(obj, 1));
            assert.isTrue(has(obj, '1'));
        });
    });

    describe('assign', () => {
        it('should assign objects', () => {
            const obj = create<any>();
            assert.isTrue(assign(obj, { a: 1, b: 2, c: 3 }) === obj);
            assert.deepEqual(obj, { a: 1, b: 2, c: 3 });
        });

        it('should assign object-likes', () => {
            const obj = create<any>();
            const obj2 = create<any>();
            obj2.a = 1;
            obj2.b = 2;
            obj2.c = 3;
            assert.isTrue(assign(obj, obj2) === obj);
            assert.deepEqual(obj, { a: 1, b: 2, c: 3 });
        });

        it('should merge objects', () => {
            const obj = create<any>();
            obj.a = 1;
            obj.b = 2;
            obj.c = 3;
            assert.isTrue(assign(obj, { c: -3, d: 4 }) === obj);
            assert.deepEqual(obj, { a: 1, b: 2, c: -3, d: 4 });
        });

        it('should assign multiple sources', () => {
            const obj = create<any>();
            assert.isTrue(assign(obj, { a: 1 }, { b: 2 }, { c: 3 }, { b: -2 }) === obj);
            assert.deepEqual(obj, { a: 1, b: -2, c: 3 });
        });

        it('should ignore null and undefined', () => {
            const obj = create<any>();
            assert.isTrue(assign(obj, undefined, null) === obj);
            assert.deepEqual(obj, {});
        });

        it('should assign arrays', () => {
            const obj = create<any>();
            assert.isTrue(assign(obj, [1, 2, 3]) === obj);
            assert.deepEqual(obj, { '0': 1, '1': 2, '2': 3 });
        });

        it('should assign array-likes', () => {
            const obj = create<any>();
            assert.isTrue(assign(obj, 'abc') === obj);
            assert.deepEqual(obj, { '0': 'a', '1': 'b', '2': 'c' });
        });

        it('should assign primitives', () => {
            const obj = create<any>();
            assert.isTrue(assign(obj, 123) === obj);
            assert.deepEqual(obj, {});
        });

        it('should assign nothing', () => {
            const obj = create<any>();
            assert.isTrue(assign(obj) === obj);
            assert.deepEqual(obj, {});
        });

        it('should assign only own properties of objects', () => {
            const obj = create<any>();
            assert.isTrue(assign(obj, Object.create({ a: 1, b: 2, c: 3 })) === obj);
            assert.deepEqual(obj, {});
        });
    });

    describe('clear', () => {
        it('should clear object-likes', () => {
            const obj = create<any>();
            obj[1] = 'a';
            obj['2'] = 'b';
            obj.c = 3;
            assert.isTrue(clear(obj) === obj);
            assert.deepEqual(obj, {});
        });

        it('should clear objects', () => {
            const obj = { a: 1, b: 2, c: 3 };
            assert.isTrue(clear(obj) === obj);
            assert.deepEqual(obj, {});
        });

        it('should clear empty object-likes', () => {
            const obj = create<any>();
            assert.isTrue(clear(obj) === obj);
            assert.deepEqual(obj, {});
        });

        it('should clear only own properties of objects', () => {
            const obj = Object.create({ a: 1, b: 2, c: 3 });
            obj.z = -1;
            assert.isTrue(clear(obj) === obj);
            assert.deepEqual(obj, { a: 1, b: 2, c: 3 });
        });
    });

    describe('value', () => {
        it('should return value with specified key', () => {
            const obj = create<any>();
            obj.a = 1;
            obj.b = undefined;

            assert.strictEqual(value(obj, 'a'), 1);
        });

        it('should return undefined with specified key', () => {
            const obj = create<any>();
            obj.a = 1;
            obj.b = undefined;

            assert.strictEqual(value(obj, 'b'), undefined);
        });

        it('should throw error when value with specified key not in object', () => {
            const obj = create<any>();
            obj.a = 1;
            obj.b = undefined;

            assert.throws(() => {
                value(obj, 'c');
            });
        });
    });
});