@oneuptime/common 7.0.2513 → 7.0.2550

package/Tests/Types/Phone.test.ts

@@ -1,40 +1,40 @@
-import BadDataException from '../../Types/Exception/BadDataException';
-import Phone from '../../Types/Phone';
+import BadDataException from "../../Types/Exception/BadDataException";
+import Phone from "../../Types/Phone";
 
-describe('Testing Class Phone', () => {
-    test('Should create a phone if the phone is valid phone number', () => {
-        expect(new Phone('+251912974103').toString()).toEqual('+251912974103');
-        expect(new Phone('961-770-7727').phone).toEqual('961-770-7727');
-        expect(new Phone('943-627-0355').phone).toEqual('943-627-0355');
-        expect(new Phone('282.652.3201').phone).toEqual('282.652.3201');
-    });
+describe("Testing Class Phone", () => {
+  test("Should create a phone if the phone is valid phone number", () => {
+    expect(new Phone("+251912974103").toString()).toEqual("+251912974103");
+    expect(new Phone("961-770-7727").phone).toEqual("961-770-7727");
+    expect(new Phone("943-627-0355").phone).toEqual("943-627-0355");
+    expect(new Phone("282.652.3201").phone).toEqual("282.652.3201");
+  });
 
-    test('Phone.phone should be mutatable', () => {
-        const value: Phone = new Phone('+251912974103');
-        value.phone = '+251925974121';
-        expect(value.phone).toEqual('+251925974121');
-        expect(value.toString()).toEqual('+251925974121');
-    });
+  test("Phone.phone should be mutatable", () => {
+    const value: Phone = new Phone("+251912974103");
+    value.phone = "+251925974121";
+    expect(value.phone).toEqual("+251925974121");
+    expect(value.toString()).toEqual("+251925974121");
+  });
 
-    test('Creating phone number with invalid format should throw BadDataException', () => {
-        expect(() => {
-            new Phone('25192599879079074121');
-        }).toThrowError(BadDataException);
-    });
+  test("Creating phone number with invalid format should throw BadDataException", () => {
+    expect(() => {
+      new Phone("25192599879079074121");
+    }).toThrowError(BadDataException);
+  });
 
-    test('try to mutating Phone.phone with invalid value should throw a BadDataException', () => {
-        const valid: string = '+251912974103';
-        const invalid: string = '278@$90> ';
-        const value: Phone = new Phone(valid);
-        expect(() => {
-            value.phone = invalid;
-        }).toThrowError(BadDataException);
-        expect(() => {
-            value.phone = '278@$90> ';
-        }).toThrow('Phone is not in valid format: 278@$90>');
-        expect(value.phone).toBe(valid);
-        expect(() => {
-            value.phone = 'hgjuit879';
-        }).toThrowError(BadDataException);
-    });
+  test("try to mutating Phone.phone with invalid value should throw a BadDataException", () => {
+    const valid: string = "+251912974103";
+    const invalid: string = "278@$90> ";
+    const value: Phone = new Phone(valid);
+    expect(() => {
+      value.phone = invalid;
+    }).toThrowError(BadDataException);
+    expect(() => {
+      value.phone = "278@$90> ";
+    }).toThrow("Phone is not in valid format: 278@$90>");
+    expect(value.phone).toBe(valid);
+    expect(() => {
+      value.phone = "hgjuit879";
+    }).toThrowError(BadDataException);
+  });
 });

package/Tests/Types/Port.test.ts

@@ -1,39 +1,39 @@
-import BadDataException from '../../Types/Exception/BadDataException';
-import Port from '../../Types/Port';
-import PositiveNumber from '../../Types/PositiveNumber';
+import BadDataException from "../../Types/Exception/BadDataException";
+import Port from "../../Types/Port";
+import PositiveNumber from "../../Types/PositiveNumber";
 
-describe('Testing class port', () => {
-    test('should return a posetive number', () => {
-        const value: Port = new Port(3000);
-        expect(value.port.positiveNumber).toBeGreaterThanOrEqual(0);
-        expect(new Port('6000').port.positiveNumber).toEqual(6000);
-    });
+describe("Testing class port", () => {
+  test("should return a posetive number", () => {
+    const value: Port = new Port(3000);
+    expect(value.port.positiveNumber).toBeGreaterThanOrEqual(0);
+    expect(new Port("6000").port.positiveNumber).toEqual(6000);
+  });
 
-    test('should throw exception "Port is not in valid format."', () => {
-        expect(() => {
-            new Port(67000);
-        }).toThrow('Port is not in valid format.');
-    });
+  test('should throw exception "Port is not in valid format."', () => {
+    expect(() => {
+      new Port(67000);
+    }).toThrow("Port is not in valid format.");
+  });
 
-    test('Port.port should be mutatable', () => {
-        const value: Port = new Port(5000);
-        value.port = new PositiveNumber(7000);
-        expect(value.port.positiveNumber).toEqual(7000);
-        expect(value.port.toNumber()).toEqual(7000);
-    });
+  test("Port.port should be mutatable", () => {
+    const value: Port = new Port(5000);
+    value.port = new PositiveNumber(7000);
+    expect(value.port.positiveNumber).toEqual(7000);
+    expect(value.port.toNumber()).toEqual(7000);
+  });
 
-    test('try to mutating Port.port with invalid value should throw an BadDataException', () => {
-        const value: Port = new Port(3000);
-        expect(() => {
-            value.port = new PositiveNumber('hj567');
-        }).toThrowError(BadDataException);
-        expect(() => {
-            value.port = new PositiveNumber(-6000);
-        }).toThrow(BadDataException);
-    });
+  test("try to mutating Port.port with invalid value should throw an BadDataException", () => {
+    const value: Port = new Port(3000);
+    expect(() => {
+      value.port = new PositiveNumber("hj567");
+    }).toThrowError(BadDataException);
+    expect(() => {
+      value.port = new PositiveNumber(-6000);
+    }).toThrow(BadDataException);
+  });
 
-    test('If the supplied port is string type, is should convert it to number before creating port', () => {
-        const value: Port = new Port('6000');
-        expect(typeof value.port.positiveNumber).toBe('number');
-    });
+  test("If the supplied port is string type, is should convert it to number before creating port", () => {
+    const value: Port = new Port("6000");
+    expect(typeof value.port.positiveNumber).toBe("number");
+  });
 });

package/Tests/Types/PositiveNumber.test.ts

@@ -1,142 +1,142 @@
-import BadDataException from '../../Types/Exception/BadDataException';
-import PositiveNumber from '../../Types/PositiveNumber';
-
-describe('PositiveNumber constructor', () => {
-    test('should create PositiveNumber', () => {
-        const value: number = 42;
-        const n: PositiveNumber = new PositiveNumber(value);
-
-        expect(n).toBeInstanceOf(PositiveNumber);
-        expect(n.positiveNumber).toBe(value);
-    });
-
-    const validNumbers: Array<[number | string, number]> = [
-        [0, 0],
-        [1, 1],
-        [Infinity, Infinity],
-        [NaN, NaN],
-        ['255.0', 255],
-    ];
-
-    test.each(validNumbers)(
-        '(new PositiveNumber(%p)).positiveNumber == %p',
-        (value: number | string, expected: number) => {
-            const n: PositiveNumber = new PositiveNumber(value);
-
-            expect(n).toBeInstanceOf(PositiveNumber);
-            expect(n.positiveNumber).toBe(expected);
-        }
-    );
-
-    const invalidNumbers: Array<number | string> = ['', 'hello', -1, 'NaN'];
-
-    test.each(invalidNumbers)(
-        'should throw error for new PositiveNumber(%p)',
-        (value: number | string) => {
-            expect(() => {
-                new PositiveNumber(value);
-            }).toThrowError(BadDataException);
-        }
-    );
+import BadDataException from "../../Types/Exception/BadDataException";
+import PositiveNumber from "../../Types/PositiveNumber";
+
+describe("PositiveNumber constructor", () => {
+  test("should create PositiveNumber", () => {
+    const value: number = 42;
+    const n: PositiveNumber = new PositiveNumber(value);
+
+    expect(n).toBeInstanceOf(PositiveNumber);
+    expect(n.positiveNumber).toBe(value);
+  });
+
+  const validNumbers: Array<[number | string, number]> = [
+    [0, 0],
+    [1, 1],
+    [Infinity, Infinity],
+    [NaN, NaN],
+    ["255.0", 255],
+  ];
+
+  test.each(validNumbers)(
+    "(new PositiveNumber(%p)).positiveNumber == %p",
+    (value: number | string, expected: number) => {
+      const n: PositiveNumber = new PositiveNumber(value);
+
+      expect(n).toBeInstanceOf(PositiveNumber);
+      expect(n.positiveNumber).toBe(expected);
+    },
+  );
+
+  const invalidNumbers: Array<number | string> = ["", "hello", -1, "NaN"];
+
+  test.each(invalidNumbers)(
+    "should throw error for new PositiveNumber(%p)",
+    (value: number | string) => {
+      expect(() => {
+        new PositiveNumber(value);
+      }).toThrowError(BadDataException);
+    },
+  );
 });
 
 interface TestCase {
-    value: number | string;
-    stringValue: string;
-    numberValue: number;
-    isZero: boolean;
-    isOne: boolean;
+  value: number | string;
+  stringValue: string;
+  numberValue: number;
+  isZero: boolean;
+  isOne: boolean;
 }
 
 const tests: Array<TestCase> = [
-    {
-        value: 0,
-        stringValue: '0',
-        numberValue: 0,
-        isZero: true,
-        isOne: false,
-    },
-    {
-        value: 1,
-        stringValue: '1',
-        numberValue: 1,
-        isZero: false,
-        isOne: true,
-    },
-    {
-        value: 42,
-        stringValue: '42',
-        numberValue: 42,
-        isZero: false,
-        isOne: false,
-    },
-    {
-        value: Infinity,
-        stringValue: 'Infinity',
-        numberValue: Infinity,
-        isZero: false,
-        isOne: false,
-    },
-    {
-        value: NaN,
-        stringValue: 'NaN',
-        numberValue: NaN,
-        isZero: false,
-        isOne: false,
-    },
-    {
-        value: '255.0',
-        stringValue: '255',
-        numberValue: 255,
-        isZero: false,
-        isOne: false,
-    },
+  {
+    value: 0,
+    stringValue: "0",
+    numberValue: 0,
+    isZero: true,
+    isOne: false,
+  },
+  {
+    value: 1,
+    stringValue: "1",
+    numberValue: 1,
+    isZero: false,
+    isOne: true,
+  },
+  {
+    value: 42,
+    stringValue: "42",
+    numberValue: 42,
+    isZero: false,
+    isOne: false,
+  },
+  {
+    value: Infinity,
+    stringValue: "Infinity",
+    numberValue: Infinity,
+    isZero: false,
+    isOne: false,
+  },
+  {
+    value: NaN,
+    stringValue: "NaN",
+    numberValue: NaN,
+    isZero: false,
+    isOne: false,
+  },
+  {
+    value: "255.0",
+    stringValue: "255",
+    numberValue: 255,
+    isZero: false,
+    isOne: false,
+  },
 ];
 
-describe('PositiveNumber.toString', () => {
-    test.each(tests)(
-        `(new PositiveNumber($value)).toString() == $stringValue`,
-        ({ value, stringValue }: TestCase) => {
-            const n: PositiveNumber = new PositiveNumber(value);
+describe("PositiveNumber.toString", () => {
+  test.each(tests)(
+    `(new PositiveNumber($value)).toString() == $stringValue`,
+    ({ value, stringValue }: TestCase) => {
+      const n: PositiveNumber = new PositiveNumber(value);
 
-            expect(n).toBeInstanceOf(PositiveNumber);
-            expect(n.toString()).toBe(stringValue);
-        }
-    );
+      expect(n).toBeInstanceOf(PositiveNumber);
+      expect(n.toString()).toBe(stringValue);
+    },
+  );
 });
 
-describe('PositiveNumber.isZero', () => {
-    test.each(tests)(
-        `(new PositiveNumber($value)).isZero() == $isZero`,
-        ({ value, isZero }: TestCase) => {
-            const n: PositiveNumber = new PositiveNumber(value);
+describe("PositiveNumber.isZero", () => {
+  test.each(tests)(
+    `(new PositiveNumber($value)).isZero() == $isZero`,
+    ({ value, isZero }: TestCase) => {
+      const n: PositiveNumber = new PositiveNumber(value);
 
-            expect(n).toBeInstanceOf(PositiveNumber);
-            expect(n.isZero()).toBe(isZero);
-        }
-    );
+      expect(n).toBeInstanceOf(PositiveNumber);
+      expect(n.isZero()).toBe(isZero);
+    },
+  );
 });
 
-describe('PositiveNumber.isOne', () => {
-    test.each(tests)(
-        `(new PositiveNumber($value)).isOne() == $isOne`,
-        ({ value, isOne }: TestCase) => {
-            const n: PositiveNumber = new PositiveNumber(value);
+describe("PositiveNumber.isOne", () => {
+  test.each(tests)(
+    `(new PositiveNumber($value)).isOne() == $isOne`,
+    ({ value, isOne }: TestCase) => {
+      const n: PositiveNumber = new PositiveNumber(value);
 
-            expect(n).toBeInstanceOf(PositiveNumber);
-            expect(n.isOne()).toBe(isOne);
-        }
-    );
+      expect(n).toBeInstanceOf(PositiveNumber);
+      expect(n.isOne()).toBe(isOne);
+    },
+  );
 });
 
-describe('PositiveNumber.toNumber', () => {
-    test.each(tests)(
-        `(new PositiveNumber($value)).toNumber() == $numberValue`,
-        ({ value, numberValue }: TestCase) => {
-            const n: PositiveNumber = new PositiveNumber(value);
+describe("PositiveNumber.toNumber", () => {
+  test.each(tests)(
+    `(new PositiveNumber($value)).toNumber() == $numberValue`,
+    ({ value, numberValue }: TestCase) => {
+      const n: PositiveNumber = new PositiveNumber(value);
 
-            expect(n).toBeInstanceOf(PositiveNumber);
-            expect(n.toNumber()).toBe(numberValue);
-        }
-    );
+      expect(n).toBeInstanceOf(PositiveNumber);
+      expect(n.toNumber()).toBe(numberValue);
+    },
+  );
 });

package/Tests/Types/SecuritySeverity.test.ts

@@ -1,16 +1,16 @@
-import SecuritySeverity from '../../Types/SecuritySeverity';
+import SecuritySeverity from "../../Types/SecuritySeverity";
 
-describe('enum SecuritySeverity', () => {
-    test('SecuritySeverity.Critical should be Critical', () => {
-        expect(SecuritySeverity.Critical).toEqual('Critical');
-    });
-    test('SecuritySeverity.High should be High', () => {
-        expect(SecuritySeverity.High).toEqual('High');
-    });
-    test('SecuritySeverity.Medium should be Medium', () => {
-        expect(SecuritySeverity.Medium).toEqual('Medium');
-    });
-    test('SecuritySeverity.Low should be Low', () => {
-        expect(SecuritySeverity.Low).toEqual('Low');
-    });
+describe("enum SecuritySeverity", () => {
+  test("SecuritySeverity.Critical should be Critical", () => {
+    expect(SecuritySeverity.Critical).toEqual("Critical");
+  });
+  test("SecuritySeverity.High should be High", () => {
+    expect(SecuritySeverity.High).toEqual("High");
+  });
+  test("SecuritySeverity.Medium should be Medium", () => {
+    expect(SecuritySeverity.Medium).toEqual("Medium");
+  });
+  test("SecuritySeverity.Low should be Low", () => {
+    expect(SecuritySeverity.Low).toEqual("Low");
+  });
 });

package/Tests/Types/SerializableObject.test.ts

@@ -1,44 +1,43 @@
-import NotImplementedException from '../../Types/Exception/NotImplementedException';
-import { JSONObject } from '../../Types/JSON';
-import SerializableObject from '../../Types/SerializableObject';
+import NotImplementedException from "../../Types/Exception/NotImplementedException";
+import { JSONObject } from "../../Types/JSON";
+import SerializableObject from "../../Types/SerializableObject";
 
-describe('SerializableObject Class', () => {
-    let serializableObject: SerializableObject;
+describe("SerializableObject Class", () => {
+  let serializableObject: SerializableObject;
 
-    beforeEach(() => {
-        serializableObject = new SerializableObject();
-    });
+  beforeEach(() => {
+    serializableObject = new SerializableObject();
+  });
 
-    test('Constructor initializes an instance of SerializableObject', () => {
-        expect(serializableObject).toBeInstanceOf(SerializableObject);
-    });
+  test("Constructor initializes an instance of SerializableObject", () => {
+    expect(serializableObject).toBeInstanceOf(SerializableObject);
+  });
 
-    describe('toJSON Method', () => {
-        test('Throws NotImplementedException when called', () => {
-            expect(() => {
-                return serializableObject.toJSON();
-            }).toThrow(NotImplementedException);
-        });
+  describe("toJSON Method", () => {
+    test("Throws NotImplementedException when called", () => {
+      expect(() => {
+        return serializableObject.toJSON();
+      }).toThrow(NotImplementedException);
     });
+  });
 
-    describe('fromJSON Method', () => {
-        test('Throws NotImplementedException when called', () => {
-            expect(() => {
-                return SerializableObject.fromJSON({});
-            }).toThrow(NotImplementedException);
-        });
+  describe("fromJSON Method", () => {
+    test("Throws NotImplementedException when called", () => {
+      expect(() => {
+        return SerializableObject.fromJSON({});
+      }).toThrow(NotImplementedException);
     });
+  });
 
-    describe('fromJSON Instance Method', () => {
-        test('Returns the result from the static fromJSON method', () => {
-            const json: JSONObject = { key: 'value' };
-            const expectedResult: SerializableObject = new SerializableObject();
-            jest.spyOn(SerializableObject, 'fromJSON').mockReturnValue(
-                expectedResult
-            );
-            const result: SerializableObject =
-                serializableObject.fromJSON(json);
-            expect(result).toBe(expectedResult);
-        });
+  describe("fromJSON Instance Method", () => {
+    test("Returns the result from the static fromJSON method", () => {
+      const json: JSONObject = { key: "value" };
+      const expectedResult: SerializableObject = new SerializableObject();
+      jest
+        .spyOn(SerializableObject, "fromJSON")
+        .mockReturnValue(expectedResult);
+      const result: SerializableObject = serializableObject.fromJSON(json);
+      expect(result).toBe(expectedResult);
     });
+  });
 });

package/Tests/Types/Sleep.test.ts

@@ -1,25 +1,22 @@
-import Sleep from '../../Types/Sleep';
+import Sleep from "../../Types/Sleep";
 
-describe('Sleep.sleep', () => {
-    test('should delay by given duration', async () => {
-        jest.useFakeTimers();
-        jest.spyOn(global, 'setTimeout');
+describe("Sleep.sleep", () => {
+  test("should delay by given duration", async () => {
+    jest.useFakeTimers();
+    jest.spyOn(global, "setTimeout");
 
-        const delay: number = 100;
+    const delay: number = 100;
 
-        // See - https://stackoverflow.com/a/51132058
-        Promise.resolve()
-            .then(() => {
-                jest.advanceTimersByTime(delay);
-            })
-            .catch(() => {});
+    // See - https://stackoverflow.com/a/51132058
+    Promise.resolve()
+      .then(() => {
+        jest.advanceTimersByTime(delay);
+      })
+      .catch(() => {});
 
-        await Sleep.sleep(delay);
+    await Sleep.sleep(delay);
 
-        expect(setTimeout).toHaveBeenCalledTimes(1);
-        expect(setTimeout).toHaveBeenLastCalledWith(
-            expect.any(Function),
-            delay
-        );
-    });
+    expect(setTimeout).toHaveBeenCalledTimes(1);
+    expect(setTimeout).toHaveBeenLastCalledWith(expect.any(Function), delay);
+  });
 });

package/Tests/Types/Text.test.ts

@@ -1,10 +1,8 @@
-import Text from '../../Types/Text';
+import Text from "../../Types/Text";
 
-describe('class Text', () => {
-    test('Text.uppercaseFirstLetter should make string first letter Uppercase', () => {
-        expect(Text.uppercaseFirstLetter('text')).toEqual('Text');
-        expect(Text.uppercaseFirstLetter('another test')).toEqual(
-            'Another test'
-        );
-    });
+describe("class Text", () => {
+  test("Text.uppercaseFirstLetter should make string first letter Uppercase", () => {
+    expect(Text.uppercaseFirstLetter("text")).toEqual("Text");
+    expect(Text.uppercaseFirstLetter("another test")).toEqual("Another test");
+  });
 });