budibase/packages/core/test/common.spec.js

import common, { isOneOf } from "../src/common";
import _ from "lodash";

const lessThan = (than) => (compare) => compare < than

describe("common > switchCase", () => {

    test("should return on first matching case", () => {

        const result = common.switchCase(
            [lessThan(1), _.constant("first")],
            [lessThan(2), _.constant("second")],
            [lessThan(3), _.constant("third")]
        )(1);

        expect(result).toBe("second");

    });

    test("should return undefined if case not matched", () => {

        const result = common.switchCase(
            [lessThan(1), _.constant("first")],
            [lessThan(2), _.constant("second")],
            [lessThan(3), _.constant("third")]
        )(10);

        expect(_.isUndefined(result)).toBeTruthy();

    });

});

describe("common > allTrue", () => {

    test("should only return true when all conditions are met", () => {

        const result1 = common.allTrue(
            lessThan(3), lessThan(5), lessThan(10)
        )(1);

        expect(result1).toBeTruthy();

        const result2 = common.allTrue(
            lessThan(3), lessThan(5), lessThan(10)
        )(7);

        expect(result2).toBeFalsy();

    });

});

describe("common > anyTrue", () => {

    test("should return true when one or more condition is met", () => {
        const result1 = common.anyTrue(
            lessThan(3), lessThan(5), lessThan(10)
        )(5);

        expect(result1).toBeTruthy();

        const result2 = common.anyTrue(
            lessThan(3), lessThan(5), lessThan(10)
        )(4);

        expect(result2).toBeTruthy();
    });

    test("should return false when no conditions are met", () => {
        const result1 = common.anyTrue(
            lessThan(3), lessThan(5), lessThan(10)
        )(15);

        expect(result1).toBeFalsy();

    });

});

const s = common.keySep;

describe("common > getDirFromKey", () => {
    test("should drop the final part of the path", () => {
        const key = `${s}one${s}two${s}three${s}last`;
        const expectedDIr = `${s}one${s}two${s}three`;
        const result = common.getDirFomKey(key);
        expect(result).toBe(expectedDIr);
    });

    test("should add leading /", () => {
        const key = `one${s}two${s}three${s}last`;
        const expectedDIr = `${s}one${s}two${s}three`;
        const result = common.getDirFomKey(key);
        expect(result).toBe(expectedDIr);
    });
});

describe("common > getFileFromKey", () => {
    test("should get the final part of the path", () => {
        const key = `one${s}two${s}three${s}last`;
        const expectedFile = "last";
        const result = common.getFileFromKey(key);
        expect(result).toBe(expectedFile);
    });
});

describe("common > getIndexKeyFromFileKey", () => {
    test("should get the index key of the file's directory", () => {
        const key = `one${s}two${s}three${s}file`;
        const expectedFile = common.dirIndex(`one${s}two${s}three`);
        const result = common.getIndexKeyFromFileKey(key);
        expect(result).toBe(expectedFile);
    });
});

describe("common > somethingOrDefault", () => {
    test("should use value if value is something", () => {
        const result = common.somethingOrDefault(
            "something", "default"
        );
        expect(result).toBe("something");
    });
    test("should use value if value is empty sting", () => {
        const result = common.somethingOrDefault(
            "", "default"
        );
        expect(result).toBe("");
    });
    test("should use value if value is empty array", () => {
        const result = common.somethingOrDefault(
            [], ["default"]
        );
        expect(result.length).toBe(0);
    });
    test("should use default if value is null", () => {
        const result = common.somethingOrDefault(
            null, "default"
        );
        expect(result).toBe("default");
    });
    test("should use default if value is undefined", () => {
        const result = common.somethingOrDefault(
            {}.notDefined, "default"
        );
        expect(result).toBe("default");
    });
});

describe("common > dirIndex", () => {
    it("should match /config/dir/<path>/dir.idx to path", () => {
        var result = common.dirIndex("some/path");
        expect(result).toBe(`${s}.config${s}dir${s}some${s}path${s}dir.idx`);
    });
});


describe("common > joinKey", () => {
    it("should join an array with the key separator and leading separator", () => {
        var result = common.joinKey("this", "is", "a", "path");
        expect(result).toBe(`${s}this${s}is${s}a${s}path`);
    });
})

describe("common > combinator ($$)", () => {
    it("combines single params functions and returns a func", () => {
        const f1 = str => str + " hello";
        const f2 = str => str + " there";
        const combined = common.$$(f1, f2);
        const result = combined("mike says");
        expect(result).toBe("mike says hello there");
    })
})

describe("common > pipe ($)", () => {
    it("combines single params functions and executes with given param", () => {
        const f1 = str => str + " hello";
        const f2 = str => str + " there";
        const result = common.$("mike says", [f1, f2]);
        expect(result).toBe("mike says hello there");
    })
})

describe("common > IsOneOf", () => {

    it("should return true when supplied value is in list of given vals", () => {
        expect(
            common.isOneOf("odo", "make")("odo")
        ).toBe(true);

        expect(
            common.isOneOf(1, 33, 9)(9)
        ).toBe(true);

        expect(
            common.isOneOf(true, false, "")(true)
        ).toBe(true);
    });

    it("should return false when supplied value is not in list of given vals", () => {
        expect(
            common.isOneOf("odo", "make")("bob")
        ).toBe(false);

        expect(
            common.isOneOf(1, 33, 9)(999)
        ).toBe(false);

        expect(
            common.isOneOf(1, false, "")(true)
        ).toBe(false);
    });

});

describe("defineError", () => {

    it("should prefix and exception with message, and rethrow", () => {

        expect(() =>
            common.defineError(() => {
                throw new Error("there")
            }, "hello"))
            .toThrowError("hello : there");
    });

    it("should return function value when no exception", () => {
        const result = common.defineError(() => 1, "no error");
        expect(result).toBe(1);
    });
});

describe("retry", () => {

    let counter = 0;

    it("should retry once", async () => {
        var result = await common.retry(async () => 1, 3, 50);
        expect(result).toBe(1);
    });

    it("should retry twice", async () => {
        var result = await common.retry(async () => {
            counter++;
            if (counter < 2) throw 'error';
            return counter;
        }, 3, 50);
        expect(result).toBe(2);
    });

    it("throws error after 3 retries", async () => {
        expect(
            common.retry(async () => { counter++; throw counter; }, 3, 50)
        ).rejects.toThrowError(4);
    });

});