@oneuptime/common 7.0.2513 → 7.0.2550

package/Tests/Types/Domain.test.ts

@@ -1,39 +1,39 @@
-import Domain from '../../Types/Domain';
-import BadDataException from '../../Types/Exception/BadDataException';
+import Domain from "../../Types/Domain";
+import BadDataException from "../../Types/Exception/BadDataException";
 
-describe('class Domain', () => {
-    test('new Domain() should return a valid object if domain is valid', () => {
-        expect(new Domain('example.com')).toBeInstanceOf(Domain);
-        expect(new Domain('example.com').toString()).toBe('example.com');
-        expect(new Domain('example.com.ac')).toBeInstanceOf(Domain);
-        expect(new Domain('example.com.ac').toString()).toBe('example.com.ac');
-        expect(new Domain('example.com.ac').domain).toBe('example.com.ac');
-        expect(new Domain('example.ac')).toBeInstanceOf(Domain);
-        expect(new Domain('example.ac').toString()).toBe('example.ac');
-        expect(new Domain('example.ac').domain).toBe('example.ac');
-    });
-    test('new Domain() should throw the BadDataException if domain is invalid', () => {
-        expect(() => {
-            return new Domain('example');
-        }).toThrowError(BadDataException);
-        expect(() => {
-            new Domain('example');
-        }).toThrowError(BadDataException);
-        expect(() => {
-            new Domain('example@com');
-        }).toThrowError(BadDataException);
+describe("class Domain", () => {
+  test("new Domain() should return a valid object if domain is valid", () => {
+    expect(new Domain("example.com")).toBeInstanceOf(Domain);
+    expect(new Domain("example.com").toString()).toBe("example.com");
+    expect(new Domain("example.com.ac")).toBeInstanceOf(Domain);
+    expect(new Domain("example.com.ac").toString()).toBe("example.com.ac");
+    expect(new Domain("example.com.ac").domain).toBe("example.com.ac");
+    expect(new Domain("example.ac")).toBeInstanceOf(Domain);
+    expect(new Domain("example.ac").toString()).toBe("example.ac");
+    expect(new Domain("example.ac").domain).toBe("example.ac");
+  });
+  test("new Domain() should throw the BadDataException if domain is invalid", () => {
+    expect(() => {
+      return new Domain("example");
+    }).toThrowError(BadDataException);
+    expect(() => {
+      new Domain("example");
+    }).toThrowError(BadDataException);
+    expect(() => {
+      new Domain("example@com");
+    }).toThrowError(BadDataException);
 
-        expect(() => {
-            new Domain('example.invalid');
-        }).toThrowError(BadDataException);
-        expect(() => {
-            const validDomain: Domain = new Domain('example.valid');
-            validDomain.domain = 'example.invalid';
-        }).toThrowError(BadDataException);
-    });
-    test('Domain.domain should be mutable', () => {
-        const domain: Domain = new Domain('example.com');
-        domain.domain = 'example.io';
-        expect(domain.domain).toEqual('example.io');
-    });
+    expect(() => {
+      new Domain("example.invalid");
+    }).toThrowError(BadDataException);
+    expect(() => {
+      const validDomain: Domain = new Domain("example.valid");
+      validDomain.domain = "example.invalid";
+    }).toThrowError(BadDataException);
+  });
+  test("Domain.domain should be mutable", () => {
+    const domain: Domain = new Domain("example.com");
+    domain.domain = "example.io";
+    expect(domain.domain).toEqual("example.io");
+  });
 });

package/Tests/Types/Email/Email.test.ts

@@ -1,69 +1,69 @@
-import Email from '../../../Types/Email';
+import Email from "../../../Types/Email";
 
-describe('Email()', () => {
-    test('should create an email instance', () => {
-        expect(new Email('test@test.com')).toBeInstanceOf(Email);
-    });
+describe("Email()", () => {
+  test("should create an email instance", () => {
+    expect(new Email("test@test.com")).toBeInstanceOf(Email);
+  });
 
-    test('should not create an email with invalid credentials', () => {
-        const invalidEmail: string = 'invalid email address';
-        expect(() => {
-            new Email(invalidEmail);
-        }).toThrow(`Email ${invalidEmail} is not in valid format.`);
-    });
+  test("should not create an email with invalid credentials", () => {
+    const invalidEmail: string = "invalid email address";
+    expect(() => {
+      new Email(invalidEmail);
+    }).toThrow(`Email ${invalidEmail} is not in valid format.`);
+  });
 
-    test('should be a business email', () => {
-        const email: Email = new Email('dev@oneuptime.com');
-        expect(email.isBusinessEmail()).toBeTruthy();
-    });
+  test("should be a business email", () => {
+    const email: Email = new Email("dev@oneuptime.com");
+    expect(email.isBusinessEmail()).toBeTruthy();
+  });
 
-    test('should not be a business email', () => {
-        const email: Email = new Email('dev@yahoo.co.uk');
-        expect(email.isBusinessEmail()).toBeFalsy();
-    });
+  test("should not be a business email", () => {
+    const email: Email = new Email("dev@yahoo.co.uk");
+    expect(email.isBusinessEmail()).toBeFalsy();
+  });
 
-    test('should return the domain of the email address', () => {
-        expect(new Email('hello@oneuptime.com').getEmailDomain().hostname).toBe(
-            'oneuptime.com'
-        );
-    });
+  test("should return the domain of the email address", () => {
+    expect(new Email("hello@oneuptime.com").getEmailDomain().hostname).toBe(
+      "oneuptime.com",
+    );
+  });
 
-    test('value of email instance should be mutable', () => {
-        const email: Email = new Email('test@test.com');
-        email.email = 'new@test.com';
-        expect(email.toString()).toBe('new@test.com');
-    });
+  test("value of email instance should be mutable", () => {
+    const email: Email = new Email("test@test.com");
+    email.email = "new@test.com";
+    expect(email.toString()).toBe("new@test.com");
+  });
 
-    test('should read the value of email instance', () => {
-        expect(new Email('test@test.com').email).toBe('test@test.com');
-    });
+  test("should read the value of email instance", () => {
+    expect(new Email("test@test.com").email).toBe("test@test.com");
+  });
 
-    test('value of email instance should of type string', () => {
-        expect(typeof new Email('test@test.com').email).toBe('string');
-    });
+  test("value of email instance should of type string", () => {
+    expect(typeof new Email("test@test.com").email).toBe("string");
+  });
 
-    test('should return a string', () => {
-        const email: Email = new Email('test@test.com');
-        expect(Email.toDatabase(email)).toBe('test@test.com');
-    });
+  test("should return a string", () => {
+    const email: Email = new Email("test@test.com");
+    expect(Email.toDatabase(email)).toBe("test@test.com");
+  });
 
-    test('should be an instance Email', () => {
-        expect(Email.fromDatabase('test@gmail.com')).toBeInstanceOf(Email);
-    });
+  test("should be an instance Email", () => {
+    expect(Email.fromDatabase("test@gmail.com")).toBeInstanceOf(Email);
+  });
 
-    test('should not create an instance of Email', () => {
-        expect(Email.fromDatabase('')).toBeNull();
-    });
+  test("should not create an instance of Email", () => {
+    expect(Email.fromDatabase("")).toBeNull();
+  });
 
-    test('should return a string from the transformers to function', () => {
-        expect(Email.getDatabaseTransformer().to('test@gmail.com')).toBe(
-            'test@gmail.com'
-        );
-    });
+  test("should return a string from the transformers to function", () => {
+    expect(Email.getDatabaseTransformer().to("test@gmail.com")).toBe(
+      "test@gmail.com",
+    );
+  });
 
-    test('should create an instance of Email through the transformer', () => {
-        expect(
-            Email.getDatabaseTransformer().from(new Email('test@test.com'))
-        ).toBeInstanceOf(Email);
-    });
+  test("should create an instance of Email through the transformer", () => {
+    expect(
+      Email.getDatabaseTransformer().from(new Email("test@test.com")),
+    ).toBeInstanceOf(Email);
+  });
 });

package/Tests/Types/EmailWithName.test.ts

@@ -1,49 +1,49 @@
-import Email from '../../Types/Email';
-import EmailWithName from '../../Types/EmailWithName';
-import BadDataException from '../../Types/Exception/BadDataException';
-import Faker from '../../Utils/Faker';
+import Email from "../../Types/Email";
+import EmailWithName from "../../Types/EmailWithName";
+import BadDataException from "../../Types/Exception/BadDataException";
+import Faker from "../../Utils/Faker";
 
-describe('class EmailWithName', () => {
-    test('new EmailWithName() should return valid object if valid name and email is given', () => {
-        const name: string = Faker.generateName();
-        const email: Email = Faker.generateEmail();
-        expect(new EmailWithName(name, email).name).toEqual(name);
-        expect(new EmailWithName(name, email).email).toEqual(email);
-    });
-    test('EmailWithName.name should be mutable', () => {
-        const newName: string = Faker.generateName();
-        const emailWithName: EmailWithName = new EmailWithName(
-            Faker.generateName(),
-            Faker.generateEmail().toString()
-        );
-        emailWithName.name = newName;
-        expect(emailWithName.name).toEqual(newName);
-    });
-    test('EmailWithName.email should be mutable', () => {
-        const newEmail: Email = Faker.generateEmail();
-        const emailWithName: EmailWithName = new EmailWithName(
-            Faker.generateName(),
-            Faker.generateEmail()
-        );
-        emailWithName.email = newEmail;
-        expect(emailWithName.email).toEqual(newEmail);
-    });
-    test('mutating EmailWithName.email with invalid email should throw BadDataException', () => {
-        const emailWithName: EmailWithName = new EmailWithName(
-            Faker.generateName(),
-            Faker.generateEmail()
-        );
-        emailWithName.email = 'janedoe@example.com';
-        expect(() => {
-            emailWithName.email = 'Invalid email';
-        }).toThrowError(BadDataException);
-    });
+describe("class EmailWithName", () => {
+  test("new EmailWithName() should return valid object if valid name and email is given", () => {
+    const name: string = Faker.generateName();
+    const email: Email = Faker.generateEmail();
+    expect(new EmailWithName(name, email).name).toEqual(name);
+    expect(new EmailWithName(name, email).email).toEqual(email);
+  });
+  test("EmailWithName.name should be mutable", () => {
+    const newName: string = Faker.generateName();
+    const emailWithName: EmailWithName = new EmailWithName(
+      Faker.generateName(),
+      Faker.generateEmail().toString(),
+    );
+    emailWithName.name = newName;
+    expect(emailWithName.name).toEqual(newName);
+  });
+  test("EmailWithName.email should be mutable", () => {
+    const newEmail: Email = Faker.generateEmail();
+    const emailWithName: EmailWithName = new EmailWithName(
+      Faker.generateName(),
+      Faker.generateEmail(),
+    );
+    emailWithName.email = newEmail;
+    expect(emailWithName.email).toEqual(newEmail);
+  });
+  test("mutating EmailWithName.email with invalid email should throw BadDataException", () => {
+    const emailWithName: EmailWithName = new EmailWithName(
+      Faker.generateName(),
+      Faker.generateEmail(),
+    );
+    emailWithName.email = "janedoe@example.com";
+    expect(() => {
+      emailWithName.email = "Invalid email";
+    }).toThrowError(BadDataException);
+  });
 
-    test('EmailWithName.toString() should return the name with email', () => {
-        const name: string = Faker.generateName();
-        const email: Email = Faker.generateEmail();
-        expect(new EmailWithName(name, email).toString()).toEqual(
-            `"${name}" <${email}>`
-        );
-    });
+  test("EmailWithName.toString() should return the name with email", () => {
+    const name: string = Faker.generateName();
+    const email: Email = Faker.generateEmail();
+    expect(new EmailWithName(name, email).toString()).toEqual(
+      `"${name}" <${email}>`,
+    );
+  });
 });

package/Tests/Types/EncryptionAlgorithm.test.ts

@@ -1,7 +1,7 @@
-import EncryptionAlgorithm from '../../Types/EncryptionAlgorithm';
+import EncryptionAlgorithm from "../../Types/EncryptionAlgorithm";
 
-describe('enum EncryptionAlgorithm', () => {
-    test('EncryptionAlgorithm.SHA256 should be SHA-256', () => {
-        expect(EncryptionAlgorithm.SHA256).toEqual('SHA-256');
-    });
+describe("enum EncryptionAlgorithm", () => {
+  test("EncryptionAlgorithm.SHA256 should be SHA-256", () => {
+    expect(EncryptionAlgorithm.SHA256).toEqual("SHA-256");
+  });
 });

package/Tests/Types/Exception/ApiException.test.ts

@@ -1,16 +1,15 @@
-import APIException from '../../../Types/Exception/ApiException';
+import APIException from "../../../Types/Exception/ApiException";
 
-describe('ApiException', () => {
-    test('should return error message from ApiException', () => {
-        expect(
-            new APIException('Server responded with a status code of 5000')
-                .message
-        ).toBe('Server responded with a status code of 5000');
-    });
+describe("ApiException", () => {
+  test("should return error message from ApiException", () => {
+    expect(
+      new APIException("Server responded with a status code of 5000").message,
+    ).toBe("Server responded with a status code of 5000");
+  });
 
-    test('should return 2 as the code for ApiException', () => {
-        expect(
-            new APIException('Server responded with a status code of 5000').code
-        ).toBe(2);
-    });
+  test("should return 2 as the code for ApiException", () => {
+    expect(
+      new APIException("Server responded with a status code of 5000").code,
+    ).toBe(2);
+  });
 });

package/Tests/Types/Exception/BadDataException.test.ts

@@ -1,15 +1,15 @@
-import BadDataException from '../../../Types/Exception/BadDataException';
+import BadDataException from "../../../Types/Exception/BadDataException";
 
-describe('BadDataException', () => {
-    test('should throw a not bad data exception', () => {
-        expect(() => {
-            throw new BadDataException('This is not a valid IPv4 address');
-        }).toThrow('This is not a valid IPv4 address');
-    });
+describe("BadDataException", () => {
+  test("should throw a not bad data exception", () => {
+    expect(() => {
+      throw new BadDataException("This is not a valid IPv4 address");
+    }).toThrow("This is not a valid IPv4 address");
+  });
 
-    test('should return 400 as the code for BadDataException', () => {
-        expect(
-            new BadDataException('This is not a valid IPv4 address').code
-        ).toBe(400);
-    });
+  test("should return 400 as the code for BadDataException", () => {
+    expect(new BadDataException("This is not a valid IPv4 address").code).toBe(
+      400,
+    );
+  });
 });

package/Tests/Types/Exception/BadOperationException.test.ts

@@ -1,16 +1,15 @@
-import BadOperationException from '../../../Types/Exception/BadOperationException';
+import BadOperationException from "../../../Types/Exception/BadOperationException";
 
-describe('BadOperationException', () => {
-    test('should return error message from BadOperationException', () => {
-        expect(
-            new BadOperationException('Cannot await a non-thenable code')
-                .message
-        ).toBe('Cannot await a non-thenable code');
-    });
+describe("BadOperationException", () => {
+  test("should return error message from BadOperationException", () => {
+    expect(
+      new BadOperationException("Cannot await a non-thenable code").message,
+    ).toBe("Cannot await a non-thenable code");
+  });
 
-    test('should return 5 as the code for BadOperationException', () => {
-        expect(
-            new BadOperationException('Cannot await a non-thenable code').code
-        ).toBe(5);
-    });
+  test("should return 5 as the code for BadOperationException", () => {
+    expect(
+      new BadOperationException("Cannot await a non-thenable code").code,
+    ).toBe(5);
+  });
 });

package/Tests/Types/Exception/BadRequestException.test.ts

@@ -1,15 +1,15 @@
-import BadRequestException from '../../../Types/Exception/BadRequestException';
+import BadRequestException from "../../../Types/Exception/BadRequestException";
 
-describe('BadRequestException', () => {
-    test('should throw a bad request exception', () => {
-        expect(() => {
-            throw new BadRequestException('Forbidden. A token is needed');
-        }).toThrow('Forbidden. A token is needed');
-    });
+describe("BadRequestException", () => {
+  test("should throw a bad request exception", () => {
+    expect(() => {
+      throw new BadRequestException("Forbidden. A token is needed");
+    }).toThrow("Forbidden. A token is needed");
+  });
 
-    test('should return 400 as the code for BadRequestException', () => {
-        expect(
-            new BadRequestException('Forbidden. A token is needed').code
-        ).toBe(400);
-    });
+  test("should return 400 as the code for BadRequestException", () => {
+    expect(new BadRequestException("Forbidden. A token is needed").code).toBe(
+      400,
+    );
+  });
 });

package/Tests/Types/Exception/DatabaseNotConnectedException.test.ts

@@ -1,13 +1,13 @@
-import DatabaseNotConnectedException from '../../../Types/Exception/DatabaseNotConnectedException';
+import DatabaseNotConnectedException from "../../../Types/Exception/DatabaseNotConnectedException";
 
-describe('DatabaseNotConnectedException', () => {
-    test('should return the error message set in database exception', () => {
-        expect(new DatabaseNotConnectedException().message).toBe(
-            'Database not connected'
-        );
-    });
+describe("DatabaseNotConnectedException", () => {
+  test("should return the error message set in database exception", () => {
+    expect(new DatabaseNotConnectedException().message).toBe(
+      "Database not connected",
+    );
+  });
 
-    test('should return 3 as the code for DatabaseNotConnectedException', () => {
-        expect(new DatabaseNotConnectedException().code).toBe(500);
-    });
+  test("should return 3 as the code for DatabaseNotConnectedException", () => {
+    expect(new DatabaseNotConnectedException().code).toBe(500);
+  });
 });

package/Tests/Types/Exception/Exception.test.ts

@@ -1,21 +1,19 @@
-import Exception from '../../../Types/Exception/Exception';
+import Exception from "../../../Types/Exception/Exception";
 
-describe('Exception', () => {
-    test('should throw an exception from exception class', () => {
-        expect(() => {
-            throw new Exception(1, 'General exception error message');
-        }).toThrow('General exception error message');
-    });
+describe("Exception", () => {
+  test("should throw an exception from exception class", () => {
+    expect(() => {
+      throw new Exception(1, "General exception error message");
+    }).toThrow("General exception error message");
+  });
 
-    test('should return error message', () => {
-        expect(
-            new Exception(0, 'This code has not been implemented').message
-        ).toBe('This code has not been implemented');
-    });
+  test("should return error message", () => {
+    expect(new Exception(0, "This code has not been implemented").message).toBe(
+      "This code has not been implemented",
+    );
+  });
 
-    test('should return 1 as the code for Exception', () => {
-        expect(new Exception(1, 'This is not a valid IPv4 address').code).toBe(
-            1
-        );
-    });
+  test("should return 1 as the code for Exception", () => {
+    expect(new Exception(1, "This is not a valid IPv4 address").code).toBe(1);
+  });
 });

package/Tests/Types/Exception/NotImplementedException.test.ts

@@ -1,13 +1,13 @@
-import NotImplementedException from '../../../Types/Exception/NotImplementedException';
+import NotImplementedException from "../../../Types/Exception/NotImplementedException";
 
-describe('NotImplementedException', () => {
-    test('should throw a not implemented exception', () => {
-        expect(() => {
-            throw new NotImplementedException();
-        }).toThrow('This code is not implemented');
-    });
+describe("NotImplementedException", () => {
+  test("should throw a not implemented exception", () => {
+    expect(() => {
+      throw new NotImplementedException();
+    }).toThrow("This code is not implemented");
+  });
 
-    test('should return 0 as the code for NotImplementedException', () => {
-        expect(new NotImplementedException().code).toBe(0);
-    });
+  test("should return 0 as the code for NotImplementedException", () => {
+    expect(new NotImplementedException().code).toBe(0);
+  });
 });

package/Tests/Types/File.test.ts

@@ -1,22 +1,22 @@
-import { File } from '../../Types/File';
+import { File } from "../../Types/File";
 
-describe('interface File', () => {
-    test('should have name and contentType property', () => {
-        const file: File = {
-            name: 'file',
-            contentType: 'text/html',
-        };
-        expect(file.name).toEqual('file');
-        expect(file.contentType).toEqual('text/html');
-    });
-    test('name and contentType property should be mutable', () => {
-        const file: File = {
-            name: 'file',
-            contentType: 'text/html',
-        };
-        file.name = 'updatedFile';
-        file.contentType = 'Text/html';
-        expect(file.name).toEqual('updatedFile');
-        expect(file.contentType).toEqual('Text/html');
-    });
+describe("interface File", () => {
+  test("should have name and contentType property", () => {
+    const file: File = {
+      name: "file",
+      contentType: "text/html",
+    };
+    expect(file.name).toEqual("file");
+    expect(file.contentType).toEqual("text/html");
+  });
+  test("name and contentType property should be mutable", () => {
+    const file: File = {
+      name: "file",
+      contentType: "text/html",
+    };
+    file.name = "updatedFile";
+    file.contentType = "Text/html";
+    expect(file.name).toEqual("updatedFile");
+    expect(file.contentType).toEqual("Text/html");
+  });
 });

package/Tests/Types/HashedString.test.ts

@@ -1,21 +1,21 @@
-import HashedString from '../../Types/HashedString';
-import ObjectID from '../../Types/ObjectID';
+import HashedString from "../../Types/HashedString";
+import ObjectID from "../../Types/ObjectID";
 
-describe('class HashedString', () => {
-    test('HashedString.constructor() should return valid hashedString', () => {
-        const hashedString: HashedString = new HashedString('stringToHash');
-        expect(hashedString).toBeInstanceOf(HashedString);
-        expect(hashedString.isValueHashed()).toBe(false);
-        expect(hashedString.hashValue(ObjectID.generate())).toBeTruthy();
-    });
+describe("class HashedString", () => {
+  test("HashedString.constructor() should return valid hashedString", () => {
+    const hashedString: HashedString = new HashedString("stringToHash");
+    expect(hashedString).toBeInstanceOf(HashedString);
+    expect(hashedString.isValueHashed()).toBe(false);
+    expect(hashedString.hashValue(ObjectID.generate())).toBeTruthy();
+  });
 
-    // TODO: Make this test pass.
-    test.skip('should SHA256 hash', () => {
-        const hashedString: HashedString = new HashedString('stringToHash');
-        expect(hashedString).toBeInstanceOf(HashedString);
-        expect(hashedString.isValueHashed()).toBe(false);
-        expect(hashedString.hashValue(null)).toBe(
-            'd3cd003df301cb1adf26fd3af623a0d372403f71b23bd099511cee06e7029b37'
-        );
-    });
+  // TODO: Make this test pass.
+  test.skip("should SHA256 hash", () => {
+    const hashedString: HashedString = new HashedString("stringToHash");
+    expect(hashedString).toBeInstanceOf(HashedString);
+    expect(hashedString.isValueHashed()).toBe(false);
+    expect(hashedString.hashValue(null)).toBe(
+      "d3cd003df301cb1adf26fd3af623a0d372403f71b23bd099511cee06e7029b37",
+    );
+  });
 });

package/Tests/Types/Html.test.ts

@@ -1,8 +1,8 @@
-import HTML from '../../Types/Html';
+import HTML from "../../Types/Html";
 
-describe('class HTML', () => {
-    test('new HTML should return a valid html object a valid html is given', () => {
-        const html: HTML = new HTML('<!DOCTYPE><head><title></head>');
-        expect(html.html).toBe('<!DOCTYPE><head><title></head>');
-    });
+describe("class HTML", () => {
+  test("new HTML should return a valid html object a valid html is given", () => {
+    const html: HTML = new HTML("<!DOCTYPE><head><title></head>");
+    expect(html.html).toBe("<!DOCTYPE><head><title></head>");
+  });
 });