@oneuptime/common 1.0.0

package/Tests/Types/Database/EqualToOrNull.test.ts

@@ -0,0 +1,70 @@
+import EqualToOrNull from '../../../Types/BaseDatabase/EqualToOrNull';
+import BadDataException from '../../../Types/Exception/BadDataException';
+import { JSONObject } from '../../../Types/JSON';
+
+describe('EqualToOrNull', () => {
+    it('should create an EqualToOrNull object with a valid value', () => {
+        const value: string = 'oneuptime';
+        const equalObj: EqualToOrNull = new EqualToOrNull(value);
+        expect(equalObj.value).toBe(value);
+    });
+
+    it('should get the value property of an EqualToOrNull object', () => {
+        const value: string = 'oneuptime';
+        const equalObj: EqualToOrNull = new EqualToOrNull(value);
+        expect(equalObj.value).toBe(value);
+    });
+
+    it('should set the value property of an EqualToOrNull object', () => {
+        const equalObj: EqualToOrNull = new EqualToOrNull('oldValue');
+        equalObj.value = 'newValue';
+        expect(equalObj.value).toBe('newValue');
+    });
+
+    it('should return the correct string representation using toString method', () => {
+        const equalObj: EqualToOrNull = new EqualToOrNull('oneuptime');
+        expect(equalObj.toString()).toBe('oneuptime');
+    });
+
+    it('should generate the correct JSON representation using toJSON method', () => {
+        const equalObj: EqualToOrNull = new EqualToOrNull('oneuptime');
+        const expectedJSON: JSONObject = {
+            _type: 'EqualToOrNull',
+            value: 'oneuptime',
+        };
+        expect(equalObj.toJSON()).toEqual(expectedJSON);
+    });
+
+    it('should create an EqualToOrNull object from valid JSON input', () => {
+        const jsonInput: JSONObject = {
+            _type: 'EqualToOrNull',
+            value: 'oneuptime',
+        };
+        const equalObj: EqualToOrNull = EqualToOrNull.fromJSON(jsonInput);
+        expect(equalObj.value).toBe('oneuptime');
+    });
+
+    it('should throw a BadDataException when using invalid JSON input', () => {
+        const jsonInput: JSONObject = {
+            _type: 'InvalidType',
+            value: 'oneuptime',
+        };
+        expect(() => {
+            return EqualToOrNull.fromJSON(jsonInput);
+        }).toThrow(BadDataException);
+    });
+
+    it('should be a type of EqualToOrNull', () => {
+        const equalObj: EqualToOrNull = new EqualToOrNull('oneuptime');
+        expect(equalObj).toBeInstanceOf(EqualToOrNull);
+    });
+
+    it('should handle null value when using fromJSON method', () => {
+        const jsonInput: JSONObject = {
+            _type: 'EqualToOrNull',
+            value: null,
+        };
+        const equalObj: EqualToOrNull = EqualToOrNull.fromJSON(jsonInput);
+        expect(equalObj.value).toBeNull();
+    });
+});

package/Tests/Types/Database/InBetween.test.ts

@@ -0,0 +1,80 @@
+import InBetween from '../../../Types/BaseDatabase/InBetween';
+import BadDataException from '../../../Types/Exception/BadDataException';
+import { JSONObject } from '../../../Types/JSON';
+
+describe('InBetween', () => {
+    it('should create an InBetween object with valid start and end values', () => {
+        const startValue: number = 10;
+        const endValue: number = 20;
+        const betweenObj: InBetween = new InBetween(startValue, endValue);
+        expect(betweenObj.startValue).toBe(10);
+        expect(betweenObj.endValue).toBe(20);
+    });
+
+    it('should generate the correct JSON representation using toJSON method', () => {
+        const startValue: number = 10;
+        const endValue: number = 20;
+        const betweenObj: InBetween = new InBetween(startValue, endValue);
+        const expectedJSON: JSONObject = {
+            _type: 'InBetween',
+            startValue: 10,
+            endValue: 20,
+        };
+        expect(betweenObj.toJSON()).toEqual(expectedJSON);
+    });
+
+    it('should create an InBetween object from valid JSON input', () => {
+        const jsonInput: JSONObject = {
+            _type: 'InBetween',
+            startValue: 10,
+            endValue: 20,
+        };
+        const betweenObj: InBetween = InBetween.fromJSON(jsonInput);
+        expect(betweenObj.startValue).toBe(10);
+        expect(betweenObj.endValue).toBe(20);
+    });
+
+    it('should throw a BadDataException when using invalid JSON input', () => {
+        const jsonInput: JSONObject = {
+            _type: 'InvalidType',
+            startValue: 10,
+            endValue: 20,
+        };
+        expect(() => {
+            return InBetween.fromJSON(jsonInput);
+        }).toThrow(BadDataException);
+    });
+
+    it('should return a string with start and end values matching', () => {
+        const startValue: number = 15;
+        const endValue: number = 15;
+        const betweenObj: InBetween = new InBetween(startValue, endValue);
+        expect(betweenObj.toString()).toBe('15');
+    });
+
+    it('should return a string with start and end values different', () => {
+        const startValue: number = 10;
+        const endValue: number = 20;
+        const betweenObj: InBetween = new InBetween(startValue, endValue);
+        expect(betweenObj.toString()).toBe('10 - 20');
+    });
+
+    it('should return the start value as a string', () => {
+        const startValue: number = 10;
+        const endValue: number = 20;
+        const betweenObj: InBetween = new InBetween(startValue, endValue);
+        expect(betweenObj.toStartValueString()).toBe('10');
+    });
+
+    it('should return the end value as a string', () => {
+        const startValue: number = 10;
+        const endValue: number = 20;
+        const betweenObj: InBetween = new InBetween(startValue, endValue);
+        expect(betweenObj.toEndValueString()).toBe('20');
+    });
+
+    it('should be a type of InBetween', () => {
+        const inBetweenObj: InBetween = new InBetween(10, 15);
+        expect(inBetweenObj).toBeInstanceOf(InBetween);
+    });
+});

package/Tests/Types/Database/LimitMax.test.ts

@@ -0,0 +1,20 @@
+import LIMIT_MAX, { LIMIT_PER_PROJECT } from '../../../Types/Database/LimitMax';
+
+describe('LIMIT_MAX', () => {
+    test('it should be number', () => {
+        expect(typeof LIMIT_MAX).toBe('number');
+    });
+});
+
+describe('LIMIT_MAX', () => {
+    test('it be positive', () => {
+        expect(LIMIT_MAX).toBeGreaterThan(0);
+    });
+});
+
+describe('LIMIT_PER_PROJECT', () => {
+    test('should be positive number', () => {
+        expect(typeof LIMIT_PER_PROJECT).toBe('number');
+        expect(LIMIT_PER_PROJECT).toBeGreaterThan(0);
+    });
+});

package/Tests/Types/Database/NotEqual.test.ts

@@ -0,0 +1,18 @@
+import NotEqual from '../../../Types/BaseDatabase/NotEqual';
+
+describe('NotEqual', () => {
+    describe('constructor', () => {
+        it('should set the value property', () => {
+            const value: string = 'test';
+            const notEqual: NotEqual = new NotEqual(value);
+            expect(notEqual.value).toBe(value);
+        });
+    });
+    describe('toString', () => {
+        it('should return the string value', () => {
+            const value: string = 'test';
+            const notEqual: NotEqual = new NotEqual(value);
+            expect(notEqual.toString()).toBe(value);
+        });
+    });
+});

package/Tests/Types/Database/Search.test.ts

@@ -0,0 +1,10 @@
+import Search from '../../../Types/BaseDatabase/Search';
+
+describe('Search', () => {
+    test('new Search() should return a valid object', () => {
+        expect(new Search('Demo').toString()).toBe('Demo');
+    });
+    test('value should return a valid string', () => {
+        expect(new Search('Item1').value).toBe('Item1');
+    });
+});

package/Tests/Types/DatabaseType.test.ts

@@ -0,0 +1,7 @@
+import DatabaseType from '../../Types/DatabaseType';
+
+describe('enum DatabaseType', () => {
+    test('DatabaseType.Postgres should be Postgres', () => {
+        expect(DatabaseType.Postgres).toEqual('postgres');
+    });
+});

package/Tests/Types/Date.test.ts

@@ -0,0 +1,95 @@
+import moment, { isMoment } from 'moment';
+import OneUptimeDate from '../../Types/Date';
+import PositiveNumber from '../../Types/PositiveNumber';
+
+describe('class OneUptimeDate', () => {
+    test('OneUptimeDate.getCurrentDate should return current date', () => {
+        expect(OneUptimeDate.getCurrentDate().getFullYear()).toEqual(
+            new Date().getFullYear()
+        );
+        expect(OneUptimeDate.getCurrentDate().getDay()).toEqual(
+            new Date().getDay()
+        );
+        expect(OneUptimeDate.getCurrentDate().getDate()).toEqual(
+            new Date().getDate()
+        );
+        expect(OneUptimeDate.getCurrentDate().getHours()).toEqual(
+            new Date().getHours()
+        );
+        expect(isMoment(OneUptimeDate.getCurrentDate())).toBeFalsy();
+    });
+    test('OneUptimeDAte.getCurrentMomentDate() should return moment Date', () => {
+        expect(isMoment(OneUptimeDate.getCurrentMomentDate())).toBeTruthy();
+    });
+    test('OneUptimeDAte.getSomeMinutesAgo should return someMinutes ago Date from current time', () => {
+        expect(
+            OneUptimeDate.getSomeMinutesAgo(new PositiveNumber(4)).getMinutes()
+        ).toEqual(moment().add(-4, 'minutes').toDate().getMinutes());
+    });
+    test('OneUptimeDAte.getOneMinAgo should return one minute age Date from current time', () => {
+        expect(OneUptimeDate.getOneMinAgo().getMinutes()).toEqual(
+            moment().add(-1, 'minute').toDate().getMinutes()
+        );
+    });
+    test('OneUptimeDAte.getOneDayAgo should return oneDate ago Date', () => {
+        expect(OneUptimeDate.getOneDayAgo().getDay()).toEqual(
+            moment().add(-1, 'day').toDate().getDay()
+        );
+    });
+    test('OneUptimeDAte.getSomeHoursAgo should return moment Date', () => {
+        expect(
+            OneUptimeDate.getSomeHoursAgo(new PositiveNumber(4)).getHours()
+        ).toEqual(moment().add(-4, 'hours').toDate().getHours());
+    });
+    test('OneUptimeDAte.getSomeDaysAgo should return moment Date', () => {
+        expect(
+            OneUptimeDate.getSomeDaysAgo(new PositiveNumber(4)).getDay()
+        ).toEqual(moment().add(-4, 'days').toDate().getDay());
+    });
+    test('OneUptimeDAte.getSomeSecondsAgo should return moment Date', () => {
+        expect(
+            OneUptimeDate.getSomeSecondsAgo(new PositiveNumber(4)).getSeconds()
+        ).toEqual(moment().add(-4, 'seconds').toDate().getSeconds());
+    });
+    test('OneUptimeDAte.getOneMinAfter should return moment Date', () => {
+        expect(OneUptimeDate.getOneMinAfter().getMinutes()).toEqual(
+            moment().add(1, 'minute').toDate().getMinutes()
+        );
+    });
+    test('OneUptimeDAte.getOneDayAfter should return moment Date', () => {
+        expect(OneUptimeDate.getOneDayAfter().getDay()).toEqual(
+            moment().add(1, 'day').toDate().getDay()
+        );
+    });
+    test('OneUptimeDAte.getSomeMinutesAfter should return moment Date', () => {
+        expect(
+            OneUptimeDate.getSomeMinutesAfter(
+                new PositiveNumber(4)
+            ).getMinutes()
+        ).toEqual(moment().add(4, 'minutes').toDate().getMinutes());
+    });
+    test('OneUptimeDAte.getSomeHoursAfter should return moment Date', () => {
+        expect(
+            OneUptimeDate.getSomeHoursAfter(new PositiveNumber(4)).getHours()
+        ).toEqual(moment().add(4, 'hours').toDate().getHours());
+    });
+    test('OneUptimeDAte.getSomeDaysAfter should return moment Date', () => {
+        expect(
+            OneUptimeDate.getSomeDaysAfter(new PositiveNumber(4)).getDay()
+        ).toEqual(moment().add(4, 'days').toDate().getDay());
+    });
+    test('OneUptimeDAte.getSomeSecondsAfter should return moment Date', () => {
+        expect(
+            OneUptimeDate.getSomeSecondsAfter(
+                new PositiveNumber(4)
+            ).getSeconds()
+        ).toEqual(moment().add(4, 'seconds').toDate().getSeconds());
+    });
+    test('OneUptimeDAte.getCurrentYear should return the current year', () => {
+        expect(
+            OneUptimeDate.getSomeSecondsAfter(
+                new PositiveNumber(4)
+            ).getSeconds()
+        ).toEqual(moment().add(4, 'seconds').toDate().getSeconds());
+    });
+});

package/Tests/Types/Dictionary.test.ts

@@ -0,0 +1,25 @@
+import Dictionary from '../../Types/Dictionary';
+describe('Dictionary', () => {
+    test('should allow basic types   compile', () => {
+        const dictionary: Dictionary<string> = {
+            property: 'string',
+        };
+        const numberDictionary: Dictionary<number> = {
+            property: 1,
+        };
+
+        expect(dictionary['property']).toEqual('string');
+        expect(numberDictionary['property']).toEqual(1);
+    });
+    test('should allow the complex type', () => {
+        const nestedDictionary: Dictionary<{ nested: string }> = {
+            property: { nested: 'stringValue' },
+        };
+        const nestedArrayDictionary: Dictionary<{ nested: Array<string> }> = {
+            property: { nested: ['stringValue'] },
+        };
+
+        expect(nestedDictionary['property']?.nested).toEqual('stringValue');
+        expect(nestedArrayDictionary['property']?.nested.length).toEqual(1);
+    });
+});

package/Tests/Types/Domain.test.ts

@@ -0,0 +1,39 @@
+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);
+
+        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

@@ -0,0 +1,69 @@
+import Email from '../../../Types/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 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 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('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('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 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 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

@@ -0,0 +1,49 @@
+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);
+    });
+
+    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

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

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

@@ -0,0 +1,16 @@
+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');
+    });
+
+    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

@@ -0,0 +1,15 @@
+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');
+    });
+
+    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

@@ -0,0 +1,16 @@
+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');
+    });
+
+    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

@@ -0,0 +1,15 @@
+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');
+    });
+
+    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

@@ -0,0 +1,13 @@
+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'
+        );
+    });
+
+    test('should return 3 as the code for DatabaseNotConnectedException', () => {
+        expect(new DatabaseNotConnectedException().code).toBe(3);
+    });
+});

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

@@ -0,0 +1,21 @@
+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');
+    });
+
+    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
+        );
+    });
+});

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

@@ -0,0 +1,13 @@
+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');
+    });
+
+    test('should return 0 as the code for NotImplementedException', () => {
+        expect(new NotImplementedException().code).toBe(0);
+    });
+});

package/Tests/Types/File.test.ts

@@ -0,0 +1,22 @@
+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');
+    });
+});

package/Tests/Types/HashedString.test.ts

@@ -0,0 +1,20 @@
+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();
+    });
+
+    // 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'
+        );
+    });
+});