EgaLabs / node-ejsception

"use strict";

// :: DEPENDENCIES

const path = require("path");

const root = path.dirname(path.dirname(__dirname));

module.exports = (hierarchy) => {

    // check parameters

    if (!Array.isArray(hierarchy)) {

        throw new Error("hierarchy must be an array");

    }

    // load dependencies

    let deps      = hierarchy.map(value => require(path.join(root, value + ".js")));

    let klassName = hierarchy.pop();

    let Klass     = deps.pop();

    const first   = (hierarchy.length === 0);

    const third   = (hierarchy.length >= 3);

    // :: TESTING

    // test the last class in the hierarchy tree

    describe(klassName, () => {

        // :: INHERITED PROTOTYPE

        // all inherit from Object

        it("should inherit from 'Object'", () => {

            expect(new Klass()).toEqual(jasmine.any(Object));

        });

        // check the hierarchy tree

        for (let i = 0; i < hierarchy.length; i += 1) {

            it("should inherit from '" + hierarchy[i] + "'", () => {

                expect(new Klass()).toEqual(jasmine.any(deps[i]));

            });

        }

        // check inherited properties

        if (!first) {

            it("should have a prototype property named 'name'", () => {

                expect(Klass.prototype).toHaveString("name");

            });

            it("should have a prototype property named 'message'", () => {

                expect(Klass.prototype).toHaveString("message");

            });

            it("should have a prototype property named 'code'", () => {

                expect(Klass.prototype).toHaveMember("code");

            });

        }

        // check Object methods

        it("should have a prototype method named 'toString()'", () => {

            expect(Klass.prototype).toHaveMethod("toString");

        });

        // check inherited methods

        if (!first) {

            it("should have a prototype method named 'native()'", () => {

                expect(Klass.prototype).toHaveMethod("native");

            });

        }

        // :: EXTENDED PROTOTYPE

        // check extended properties

        if (first) {

            it("should have a prototype property named 'name'", () => {

                expect(Klass.prototype).toHaveString("name");

            });

            it("should have a prototype property named 'message'", () => {

                expect(Klass.prototype).toHaveString("message");

            });

            it("should have a prototype property named 'code'", () => {

                expect(Klass.prototype).toHaveMember("code");

            });

            it("should have a prototype method named 'native()'", () => {

                expect(Klass.prototype).toHaveMethod("native");

            });

        }

        // :: PROTOTYPE VALUES

        it("should have the 'class' name in the prototype property named 'name'", () => {

            expect(Klass.prototype.name).toEqual(klassName);

        });

        it("should have a dummy default value as message", () => {

            expect(Klass.prototype.message).toEqual("thrown");

        });

        it("should have a null default value as code", () => {

            expect(Klass.prototype.code).toBeNull();

        });

        // :: CONSTRUCTOR

        it("should instantiate without parameters", () => {

            let arg1, arg2, arg3, test;

            if (third) {

                test = (() => new Klass(arg1, arg2));

            } else {

                test = (() => new Klass(arg1, arg2, arg3));

            }

            for (let i = 0; i < 2; i += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);

                for (let j = 0; j < 2; j += 1) {

                    arg2 = (j % 2 === 0 ? undefined : null);

                    if (third) {

                        expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                        expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                        expect(test).not.toThrowError("parameter 'code' must be a 'number'");

                    } else {

                        for (let e = 0; e < 2; e += 1) {

                            arg3 = (e % 2 === 0 ? undefined : null);

                            expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                            expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                            expect(test).not.toThrowError("parameter 'code' must be a 'number'");

                        }

                    }

                }

            }

            test = (() => new Klass());

            expect(test).not.toThrowError("parameter 'name' must be a 'string'");

            expect(test).not.toThrowError("parameter 'message' must be a 'string'");

            expect(test).not.toThrowError("parameter 'code' must be a 'number'");

        });

        it("should instantiate with parameters", () => {

            let arg1, arg2, arg3, test1, test2, test3, args1, args2, args3;

            test1 = (() => new Klass(arg1));

            test2 = (() => new Klass(arg1, arg2));

            test3 = (() => {

            });

            if (!third) {

                test3 = (() => new Klass(arg1, arg2, arg3));

                args1 = [undefined, null, Klass.prototype.name];

                args2 = [undefined, null, Klass.prototype.message];

                args3 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

            } else {

                args1 = [undefined, null, Klass.prototype.message];

                args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

                args3 = [];

            }

            for (let i = 0; i < args1.length; i += 1) {

                arg1 = args1[i];

                expect(test1).not.toThrowError("parameter 'name' must be a 'string'");

                expect(test1).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test1).not.toThrowError("parameter 'code' must be a 'number'");

                for (let j = 0; j < args2.length; j += 1) {

                    arg2 = args2[j];

                    expect(test2).not.toThrowError("parameter 'name' must be a 'string'");

                    expect(test2).not.toThrowError("parameter 'message' must be a 'string'");

                    expect(test2).not.toThrowError("parameter 'code' must be a 'number'");

                    if (!third) {

                        for (let e = 0; e < args3.length; e += 1) {

                            arg3 = args3[e];

                            expect(test3).not.toThrowError("parameter 'name' must be a 'string'");

                            expect(test3).not.toThrowError("parameter 'message' must be a 'string'");

                            expect(test3).not.toThrowError("parameter 'code' must be a 'number'");

                        }

                    }

                }

            }

        });

        it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

            let arg1, arg2, arg3, test31, test32, test33, test21, test22, test11;

            const noStr   = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

            const noNmb   = [{}, true, false, '', "qwerty", () => null];

            const noStrSz = noStr.length;

            const noNmbSz = noNmb.length;

            if (!third) {

                test33 = (() => new Klass(arg1, arg2, arg3));

                test32 = (() => new Klass(null, arg2, arg3));

                test31 = (() => new Klass(null, null, arg3));

            } else {

                test33 = (() => null);

                test32 = (() => null);

                test31 = (() => null);

            }

            test22 = (() => new Klass(arg1, arg2));

            test21 = (() => new Klass(null, arg2));

            test11 = (() => new Klass(arg1));

            if (typeof Symbol === "function") {

                noStr.push(Symbol("symbol"));

                noNmb.push(Symbol("symbol"));

            }

            for (let i = 0; i < noStrSz; i += 1) {

                arg1 = noStr[i];

                expect(test11).toThrowError("parameter '" + (third ? "message" : "name") + "' must be a 'string'");

                for (let j = 0; j < (third ? noNmbSz : noStrSz); j += 1) {

                    if (third) {

                        arg2 = noNmb[j];

                        expect(test22).toThrowError("parameter 'message' must be a 'string'");

                        expect(test21).toThrowError("parameter 'code' must be a 'number'");

                    } else {

                        arg2 = noStr[j];

                        expect(test22).toThrowError("parameter 'name' must be a 'string'");

                        expect(test21).toThrowError("parameter 'message' must be a 'string'");

                        for (let e = 0; e < noNmb.length; e += 1) {

                            arg3 = noNmb[e];

                            expect(test33).toThrowError("parameter 'name' must be a 'string'");

                            expect(test32).toThrowError("parameter 'message' must be a 'string'");

                            expect(test31).toThrowError("parameter 'code' must be a 'number'");

                        }

                    }

                }

            }

        });

        // :: MEMBER PROPERTIES

        const name    = (third ? null : "qwerty");

        const message = "asdf";

        const code    = Math.round(Math.random() * 0xFFFFFFFF);

        it("should have all correct properties once instantiated", () => {

            instanceDefinedOrNull(Klass, name, message, code, (instance, even) => {

                if (even) {

                    if (third) {

                        expect(instance.name).toEqual(Klass.prototype.name);

                        expect(instance.message).toEqual(message);

                    } else {

                        expect(instance.name).toEqual(name);

                        expect(instance.message).toEqual(Klass.prototype.message);

                    }

                } else {

                    expect(instance.name).toEqual(Klass.prototype.name);

                    expect(instance.message).toEqual(Klass.prototype.message);

                }

                expect(instance.code).toBeNull();

            }, (instance, even1, even2) => {

                if (third) {

                    expect(instance.name).toEqual(Klass.prototype.name);

                    expect(instance.message).toEqual(even1 ? message : Klass.prototype.message);

                    expect(instance.code).toEqual(even2 ? code : null);

                } else {

                    expect(instance.name).toEqual(even1 ? name : Klass.prototype.name);

                    expect(instance.message).toEqual(even2 ? message : Klass.prototype.message);

                    expect(instance.code).toBeNull();

                }

            }, (instance, even1, even2, even3) => {

                expect(instance.name).toEqual(even1 ? name : Klass.prototype.name);

                expect(instance.message).toEqual(even2 ? message : Klass.prototype.message);

                expect(instance.code).toEqual(even3 ? code : null);

            }, third);

        });

        // :: MEMBER METHODS

        it("#toString()", () => {

            for (let i = 0; i < 2; i += 1) {

                let exp1;

                const even1   = (i % 2 === 0);

                const arg1    = (even1 ? (third ? message : name) : null);

                const source1 = new Klass(arg1);

                if (even1) {

                    exp1 = (third ? Klass.prototype.name : name);

                    exp1 += ": ";

                    exp1 += (third ? message : Klass.prototype.message);

                    exp1 += '.';

                } else {

                    exp1 = Klass.prototype.name + ": " + Klass.prototype.message + '.';

                }

                expect(source1.toString()).toEqual(exp1);

                for (let j = 0; j < 2; j += 1) {

                    let exp2;

                    const even2   = (j % 2 === 0);

                    const arg2    = (even2 ? (third ? code : message) : null);

                    const source2 = new Klass(arg1, arg2);

                    if (third) {

                        exp2 = Klass.prototype.name;

                        exp2 += (even2 ? " (0x" + code.toString(16) + "):" : ':' ) + ' ';

                        exp2 += (even1 ? message : Klass.prototype.message) + '.';

                    } else {

                        exp2 = (even1 ? name : Klass.prototype.name) + ':';

                        exp2 += ' ' + (even2 ? message : Klass.prototype.message) + '.';

                    }

                    expect(source2.toString()).toEqual(exp2);

                    if (!third) {

                        for (let e = 0; e < 2; e += 1) {

                            let exp3;

                            const even3   = (e % 2 === 0);

                            const arg3    = (even3 ? code : null);

                            const source3 = new Klass(arg1, arg2, arg3);

                            exp3  = (even1 ? name : Klass.prototype.name);

                            exp3 += (even3 ? " (0x" + code.toString(16) + "):" : ':') + ' ';

                            exp3 += (even2 ? message : Klass.prototype.message) + '.';

                            expect(source3.toString()).toEqual(exp3);

                        }

                    }

                }

            }

        });

        it("#native()", () => {

            instanceDefinedOrNull(Klass, name, message, code, (instance, even) => {

                    const exp1 = (even && third ? message : Klass.prototype.message);

                    expect(instance.native()).toEqual(new Error(exp1));

                }, (instance, even1, even2) => {

                    const even = (third ? even1 : even2);

                    const exp  = (even ? message : Klass.prototype.message);

                    expect(instance.native()).toEqual(new Error(exp));

                }, (instance, even1, even2) => {

                    const exp = (even2 ? message : Klass.prototype.message);

                    expect(instance.native()).toEqual(new Error(exp));

                }, third);

        });

    });

};

// Does a loop for each argument of the Klass constructor.

// If the iteration is even, the parameter is defined.

// If the iteration is odd, the parameter is null.

function instanceDefinedOrNull(Klass, name, message, code, fn1, fn2, fn3, third) {

    for (let i = 0; i < 2; i += 1) {

        const even1   = (i % 2 === 0);

        const arg1    = (even1 ? (third ? message : name) : null);

        const source1 = new Klass(arg1);

        fn1(source1, even1);

        for (let j = 0; j < 2; j += 1) {

            const even2   = (j % 2 === 0);

            const arg2    = (even2 ? (third ? code : message) : null);

            const source2 = new Klass(arg1, arg2);

            fn2(source2, even1, even2);

            if (!third) {

                for (let e = 0; e < 2; e += 1) {

                    const even3   = (e % 2 === 0);

                    const arg3    = (even3 ? code : null);

                    const source3 = new Klass(arg1, arg2, arg3);

                    fn3(source3, even1, even2, even3);

                }

            }

        }

    }

}