@oneuptime/common 1.0.0

package/Tests/Types/Typeof.test.ts

@@ -0,0 +1,19 @@
+import Typeof from '../../Types/Typeof';
+
+describe('Typeof', () => {
+    test('String should be string', () => {
+        expect(Typeof.String).toBe('string');
+    });
+
+    test('Boolean should be boolean', () => {
+        expect(Typeof.Boolean).toBe('boolean');
+    });
+
+    test('Number should be number', () => {
+        expect(Typeof.Number).toBe('number');
+    });
+
+    test('Object should be object', () => {
+        expect(Typeof.Object).toBe('object');
+    });
+});

package/Tests/Types/UserType.test.ts

@@ -0,0 +1,16 @@
+import UserType from '../../Types/UserType';
+
+describe('enum UserType', () => {
+    test('UserType.API should be API', () => {
+        expect(UserType.API).toEqual('API');
+    });
+    test('UserType.User should be User', () => {
+        expect(UserType.User).toEqual('User');
+    });
+    test('UserType.MasterAdmin should be MasterAdmin', () => {
+        expect(UserType.MasterAdmin).toEqual('MasterAdmin');
+    });
+    test('UserType.Public should be Public', () => {
+        expect(UserType.Public).toEqual('Public');
+    });
+});

package/Tests/Types/Version.test.ts

@@ -0,0 +1,35 @@
+import BadDataException from '../../Types/Exception/BadDataException';
+import Version from '../../Types/Version';
+
+describe('class Version', () => {
+    test('should create a version if version string is valid', () => {
+        expect(new Version('1.2.1').toString()).toEqual('1.2.1');
+        expect(new Version('1.2.1').version).toEqual('1.2.1');
+    });
+    test('Version.version should be mutatable', () => {
+        const version: Version = new Version('1.2.1');
+        version.version = '1.2.2';
+        expect(version.version).toEqual('1.2.2');
+        expect(version.toString()).toEqual('1.2.2');
+    });
+    test('mutating Version.version with invalid data should throw an BadDataException', () => {
+        const version: Version = new Version('1.0.0');
+        expect(() => {
+            version.version = '1';
+        }).toThrowError(BadDataException);
+        expect(() => {
+            version.version = '1.1';
+        }).toThrow('Version is not in valid format.');
+        expect(() => {
+            version.version = '1.1.0.0';
+        }).toThrowError(BadDataException);
+    });
+    test('creating version new  Version with invalid data should throw an BadDataException', () => {
+        expect(() => {
+            new Version('1');
+        }).toThrowError(BadDataException);
+        expect(() => {
+            new Version('1.1');
+        }).toThrow('Version is not in valid format.');
+    });
+});

package/Tests/Types/XML.test.ts

@@ -0,0 +1,36 @@
+import BadDataException from '../../Types/Exception/BadDataException';
+import XML from '../../Types/XML';
+
+describe('class XML', () => {
+    test('new XML should return valid object if it is valid', () => {
+        const xmlString: string = '<test> <info>Test</info></test>';
+        const xml: XML = new XML(xmlString);
+        expect(xml.toString()).toEqual(xmlString);
+        expect(xml.xml).toEqual(xmlString);
+    });
+    test('XML.xml should be mutable', () => {
+        const xmlNewString: string = '<new> <info>Test</info></new>';
+        const xml: XML = new XML('<test> <info>Test</info></test>');
+        xml.xml = xmlNewString;
+        expect(xml.toString()).toEqual(xmlNewString);
+        expect(xml.xml).toEqual(xmlNewString);
+    });
+    test('mutating XML.xml with empty string should throw BadDataException', () => {
+        const xml: XML = new XML('<test> <info>Test</info></test>');
+        expect(() => {
+            xml.xml = '';
+        }).toThrowError(BadDataException);
+        expect(() => {
+            xml.xml = '';
+        }).toThrow('XML is not in valid format.');
+    });
+
+    test('new should throw BadDataException if empty string is given', () => {
+        expect(() => {
+            new XML('');
+        }).toThrowError(BadDataException);
+        expect(() => {
+            new XML('');
+        }).toThrow('XML is not in valid format.');
+    });
+});

package/Tests/Utils/API.test.ts

@@ -0,0 +1,425 @@
+import Protocol from '../../Types/API/Protocol';
+import API from '../../Utils/API';
+import Hostname from '../../Types/API/Hostname';
+import HTTPMethod from '../../Types/API/HTTPMethod';
+import URL from '../../Types/API/URL';
+import Route from '../../Types/API/Route';
+import axios, {
+    AxiosResponse,
+    AxiosError,
+    AxiosStatic,
+    AxiosRequestConfig,
+    Method,
+    AxiosHeaders,
+} from 'axios';
+import { expect, jest } from '@jest/globals';
+import HTTPResponse from '../../Types/API/HTTPResponse';
+import HTTPErrorResponse from '../../Types/API/HTTPErrorResponse';
+import APIException from '../../Types/Exception/ApiException';
+import Dictionary from '../../Types/Dictionary';
+import Headers from '../../Types/API/Headers';
+import { JSONObject } from '../../Types/JSON';
+import GenericObject from '../../Types/GenericObject';
+
+const DEFAULT_HEADERS: Headers = {
+    'Access-Control-Allow-Origin': '*',
+    Accept: 'application/json',
+    'Content-Type': 'application/json;charset=UTF-8',
+};
+
+jest.mock('axios', () => {
+    // Use actual axios module exported functions/constants such as axios.isAxiosError()
+    return Object.assign(jest.fn(), jest.requireActual('axios'));
+});
+
+// Mock axios(config) top level function
+// Ignore type error
+// Property 'lastCall' is optional in type MockFunctionState but required in type MockContext
+// @ts-ignore
+const mockedAxios: jest.MockedFunctionDeep<typeof axios> =
+    jest.mocked<AxiosStatic>(axios);
+
+// Spy on calls to HTTPErrorResponse
+jest.mock('../../Types/API/HTTPErrorResponse');
+
+const HTTPErrorResponseMock: jest.MockedClass<typeof HTTPErrorResponse> =
+    HTTPErrorResponse as jest.MockedClass<typeof HTTPErrorResponse>;
+
+/**
+ * Create a fake axios response
+ */
+function createAxiosResponse<T = any, D = any>(
+    {
+        data = [] as T,
+        status = 200,
+        statusText = 'OK',
+        config = {
+            headers: DEFAULT_HEADERS as AxiosHeaders,
+        },
+        headers = DEFAULT_HEADERS,
+    }: Partial<AxiosResponse<T, D>> = {
+        data: [] as T,
+        status: 200,
+        statusText: 'OK',
+        config: {
+            headers: DEFAULT_HEADERS as AxiosHeaders,
+        },
+        headers: DEFAULT_HEADERS,
+    }
+): AxiosResponse<T, D> {
+    return {
+        data,
+        status,
+        statusText,
+        config,
+        headers,
+    };
+}
+
+const mergedHeaders: Headers = {
+    'Access-Control-Allow-Origin': '*',
+    Accept: 'application/json',
+    'Content-Type': 'application/json', // replace default header
+    'X-PoweredBy': 'coffee', // add new header
+};
+
+/**
+ * Create a fake axios error
+ */
+function createAxiosError<T = any, D = any>(
+    {
+        config = {
+            headers: DEFAULT_HEADERS as AxiosHeaders,
+        },
+        isAxiosError = true,
+        toJSON = () => {
+            return {};
+        },
+        name = 'SOME_ERROR_OCCURRED',
+        message = 'Something went wrong',
+        response = createAxiosResponse(),
+    }: Partial<AxiosError<T, D>> = {
+        config: {
+            headers: DEFAULT_HEADERS as AxiosHeaders,
+        },
+        isAxiosError: true,
+        toJSON: () => {
+            return {};
+        },
+        name: '',
+        message: '',
+        response: createAxiosResponse(),
+    }
+): AxiosError {
+    return {
+        config,
+        isAxiosError,
+        toJSON,
+        name,
+        message,
+        response,
+    };
+}
+
+/**
+ * Create fake axios parameters
+ */
+function createAxiosParameters(
+    {
+        method = 'GET',
+        url = 'https://catfact.ninja/fact',
+        headers = { ...mergedHeaders },
+        data = undefined,
+    }: {
+        method?: Method;
+        url?: string;
+        headers?: Dictionary<string>;
+        data?: any;
+    } = {
+        method: 'GET',
+        url: 'https://catfact.ninja/fact',
+        headers: { ...mergedHeaders },
+    }
+): AxiosRequestConfig {
+    return {
+        method,
+        url,
+        headers,
+        data,
+    };
+}
+
+const responseData: JSONObject = {
+    fact: 'Cats have 3 eyelids.',
+    length: 20,
+};
+
+const requestData: any = {
+    breed: 'Siamese',
+};
+
+const requestHeaders: Headers = {
+    'Content-Type': 'application/json',
+    'X-PoweredBy': 'coffee',
+};
+
+afterAll(() => {
+    jest.restoreAllMocks();
+});
+
+describe('API', () => {
+    test('should create an instance', () => {
+        const protocol: string = 'https://';
+        const hostname: string = 'catfact.ninja';
+        const api: API = new API(Protocol.HTTPS, new Hostname(hostname));
+
+        expect(api).toBeInstanceOf(API);
+        expect(api.baseRoute.toString()).toBe('/');
+        expect(api.protocol).toBe(protocol);
+        expect(api.hostname.toString()).toBe(hostname);
+    });
+
+    test('should create an instance with base route', () => {
+        const protocol: string = 'https://';
+        const hostname: string = 'catfact.ninja';
+        const route: string = 'fact';
+
+        const api: API = new API(
+            Protocol.HTTPS,
+            new Hostname(hostname),
+            new Route(route)
+        );
+
+        expect(api).toBeInstanceOf(API);
+        expect(api.baseRoute.toString()).toBe('fact');
+        expect(api.protocol).toBe(protocol);
+        expect(api.hostname.toString()).toBe(hostname);
+    });
+});
+
+describe('getErrorResponse', () => {
+    test('should create an HTTPErrorResponse instance', () => {
+        const data: any = { message: 'Something went wrong' };
+        const status: number = 500;
+        const headers: Headers = { 'X-PoweredBy': 'coffee' };
+
+        const response: AxiosResponse<typeof data, GenericObject> =
+            createAxiosResponse({
+                data,
+                headers,
+                status,
+            });
+        const axiosError: AxiosError<typeof data, GenericObject> =
+            createAxiosError({
+                response,
+            });
+
+        // Use bracket notation property access to access private method
+        const errorResponse: HTTPErrorResponse =
+            API['getErrorResponse'](axiosError);
+
+        expect(errorResponse).toBeInstanceOf(HTTPErrorResponse);
+        expect(HTTPErrorResponseMock).toHaveBeenCalledTimes(1);
+        expect(HTTPErrorResponseMock).toHaveBeenCalledWith(
+            status,
+            data,
+            headers
+        );
+    });
+
+    test('should throw if response error has no response', () => {
+        // NOTE: Passing undefined will initialize the default parameter
+        const axiosError: AxiosError<null, GenericObject> = createAxiosError({
+            response: null!,
+        }) as AxiosError<null, GenericObject>;
+
+        // Use bracket notation property access to access private method
+        expect(() => {
+            API['getErrorResponse'](axiosError);
+        }).toThrowError(APIException);
+    });
+});
+
+describe('fetch', () => {
+    test('should return an HTTPResponse if request is successful', async () => {
+        const status: number = 200;
+        const params: Dictionary<string> = {
+            count: '1',
+        };
+
+        const mockedParsedResponse: HTTPResponse<typeof responseData> =
+            new HTTPResponse(status, responseData, DEFAULT_HEADERS);
+
+        const mockedAxiosResponse: AxiosResponse<
+            typeof responseData,
+            GenericObject
+        > = createAxiosResponse({
+            status,
+            data: responseData,
+        });
+
+        mockedAxios.mockResolvedValueOnce(mockedAxiosResponse);
+
+        const response: HTTPResponse<typeof responseData> = await API.fetch(
+            HTTPMethod.POST,
+            new URL(Protocol.HTTPS, 'catfact.ninja', new Route('fact')),
+            requestData,
+            requestHeaders,
+            params
+        );
+
+        // Check method, url (protocol, hostname, parameters), headers, request data
+        expect(axios).toBeCalledWith({
+            method: 'POST',
+            url: 'https://catfact.ninja/fact?count=1',
+            headers: mergedHeaders,
+            data: requestData,
+        });
+
+        expect(response).toEqual(mockedParsedResponse);
+    });
+
+    test('should return an HTTPErrorResponse if request fails', async () => {
+        const status: number = 404;
+        const statusText: string = 'Not Found';
+        const data: JSONObject = {
+            message: 'Not Found',
+        };
+
+        const mockedAxiosError: AxiosError<undefined, GenericObject> =
+            createAxiosError({
+                response: createAxiosResponse({
+                    status,
+                    statusText,
+                    data,
+                }),
+                message: 'An error occurred',
+            }) as AxiosError<undefined, GenericObject>;
+
+        mockedAxios.mockRejectedValueOnce(mockedAxiosError);
+
+        const httpErrorResponse: HTTPResponse<JSONObject> = await API.fetch(
+            HTTPMethod.GET,
+            new URL(Protocol.HTTPS, 'catfact.ninja', new Route('fact'))
+        );
+
+        expect(axios).toBeCalledWith({
+            method: 'GET',
+            url: 'https://catfact.ninja/fact',
+            headers: DEFAULT_HEADERS,
+            data: undefined,
+        });
+
+        expect(httpErrorResponse).toBeInstanceOf(HTTPErrorResponse);
+    });
+
+    test('should throw an APIException if initializing request fails', async () => {
+        mockedAxios.mockImplementationOnce(() => {
+            throw new Error('Something went wrong');
+        });
+
+        await expect(async () => {
+            await API.fetch(
+                HTTPMethod.GET,
+                new URL(Protocol.HTTPS, 'catfact.ninja', new Route('fact'))
+            );
+        }).rejects.toThrowError(APIException);
+    });
+});
+
+describe('getDefaultHeaders', () => {
+    test('should return default headers', () => {
+        expect(API.getDefaultHeaders()).toEqual(DEFAULT_HEADERS);
+    });
+});
+
+describe('getHeaders', () => {
+    test('should merge headers', () => {
+        // Use bracket notation to access protected member
+        expect(API['getHeaders'](requestHeaders)).toEqual(mergedHeaders);
+    });
+});
+
+interface HTTPMethodType {
+    name: Lowercase<HTTPMethod>; // 'get' | 'post' | 'delete' | 'put'
+    method: HTTPMethod;
+}
+
+// Set up table-driven tests for
+// .get(), .post(), .put(), .delete(), get(), post(), put(), delete()
+const httpMethodTests: Array<HTTPMethodType> = [
+    {
+        name: 'get',
+        method: HTTPMethod.GET,
+    },
+    {
+        name: 'post',
+        method: HTTPMethod.POST,
+    },
+    {
+        name: 'put',
+        method: HTTPMethod.PUT,
+    },
+    {
+        name: 'delete',
+        method: HTTPMethod.DELETE,
+    },
+    {
+        name: 'head',
+        method: HTTPMethod.HEAD,
+    },
+];
+
+describe.each(httpMethodTests)('$name', ({ name, method }: HTTPMethodType) => {
+    test(`should make a ${method} request`, async () => {
+        mockedAxios.mockResolvedValueOnce(createAxiosResponse());
+
+        const url: URL = new URL(
+            Protocol.HTTPS,
+            'catfact.ninja',
+            new Route('fact')
+        );
+        const got: HTTPResponse<JSONObject> = await API[name](
+            url,
+            requestData,
+            requestHeaders
+        );
+
+        // Check method, url, headers, request data
+        expect(axios).toBeCalledWith(
+            createAxiosParameters({
+                method,
+                url: 'https://catfact.ninja/fact',
+                data: requestData,
+                headers: mergedHeaders,
+            })
+        );
+        expect(got).toBeInstanceOf(HTTPResponse);
+    });
+});
+
+describe.each(httpMethodTests)('.$name', ({ name, method }: HTTPMethodType) => {
+    test(`should make a ${method} request`, async () => {
+        const route: string = 'fact';
+        const hostname: string = 'catfact.ninja';
+        const api: API = new API(Protocol.HTTPS, new Hostname(hostname));
+
+        mockedAxios.mockResolvedValueOnce(createAxiosResponse());
+
+        const got: HTTPResponse<JSONObject> = await api[name](
+            new Route(route),
+            requestData,
+            requestHeaders
+        );
+
+        // Check method, url (protocol, hostname, route), headers, request data
+        expect(axios).toBeCalledWith(
+            createAxiosParameters({
+                url: 'https://catfact.ninja/fact',
+                method,
+                data: requestData,
+            })
+        );
+        expect(got).toBeInstanceOf(HTTPResponse);
+    });
+});

package/Tests/Utils/Analytics.test.ts

@@ -0,0 +1,85 @@
+import Analytics from '../../Utils/Analytics';
+import Email from '../../Types/Email';
+import { JSONObject } from '../../Types/JSON';
+import posthog from 'posthog-js';
+
+jest.mock('posthog-js', () => {
+    return {
+        init: jest.fn(),
+        identify: jest.fn(),
+        reset: jest.fn(),
+        capture: jest.fn(),
+    };
+});
+
+const apiHost: string = 'https://example.com';
+const apiKey: string = 'your-api-key';
+
+describe('Analytics Class', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should initialize the Analytics class', () => {
+        const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+        expect(posthog.init).toHaveBeenCalledWith(apiKey, {
+            api_host: apiHost,
+            autocapture: false,
+        });
+        expect(analytics.isInitialized).toBe(true);
+    });
+
+    it('should not initialize if apiHost and apiKey are not provided', () => {
+        const analytics: Analytics = new Analytics('', '');
+
+        expect(posthog.init).not.toHaveBeenCalled();
+        expect(analytics.isInitialized).toBe(false);
+    });
+
+    it('should authenticate a user', () => {
+        const analytics: Analytics = new Analytics(apiHost, apiKey);
+        const email: Email = new Email('test@example.com');
+
+        analytics.userAuth(email);
+        expect(posthog.identify).toHaveBeenCalledWith(email.toString());
+    });
+
+    it('should not authenticate a user if not initialized', () => {
+        const analytics: Analytics = new Analytics('', '');
+        const email: Email = new Email('test@example.com');
+
+        analytics.userAuth(email);
+        expect(posthog.identify).not.toHaveBeenCalled();
+    });
+
+    it('should reset the user session on logout', () => {
+        const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+        analytics.logout();
+        expect(posthog.reset).toHaveBeenCalled();
+    });
+
+    it('should not reset the user session if not initialized', () => {
+        const analytics: Analytics = new Analytics('', '');
+
+        analytics.logout();
+        expect(posthog.reset).not.toHaveBeenCalled();
+    });
+
+    it('should capture an event with optional data', () => {
+        const analytics: Analytics = new Analytics(apiHost, apiKey);
+        const eventName: string = 'testEvent';
+        const data: JSONObject = { key: 'value' };
+
+        analytics.capture(eventName, data);
+        expect(posthog.capture).toHaveBeenCalledWith(eventName, data);
+    });
+
+    it('should not capture an event if not initialized', () => {
+        const analytics: Analytics = new Analytics('', '');
+
+        analytics.capture('testEvent');
+        expect(posthog.capture).not.toHaveBeenCalled();
+    });
+});

package/Tests/Utils/CronTime.test.ts

@@ -0,0 +1,34 @@
+import {
+    EVERY_MINUTE,
+    EVERY_DAY,
+    EVERY_HOUR,
+    EVERY_FIVE_MINUTE,
+    EVERY_FIVE_SECONDS,
+    EVERY_WEEK,
+} from '../../Utils/CronTime';
+
+describe('CronTime', () => {
+    test('should return every minute', () => {
+        expect(EVERY_MINUTE).toEqual('* * * * *');
+    });
+
+    test('should return every day', () => {
+        expect(EVERY_DAY).toEqual('0 8 * * *');
+    });
+
+    test('should return every hour', () => {
+        expect(EVERY_HOUR).toEqual('1 * * * *');
+    });
+
+    test('should return every five minute', () => {
+        expect(EVERY_FIVE_MINUTE).toEqual('*/5 * * * *');
+    });
+
+    test('should return every five seconds', () => {
+        expect(EVERY_FIVE_SECONDS).toEqual('*/5 * * * * *');
+    });
+
+    test('should return every week', () => {
+        expect(EVERY_WEEK).toEqual('0 0 * * 0');
+    });
+});

package/Tests/Utils/Faker.test.ts

@@ -0,0 +1,38 @@
+import Faker from '../../Utils/Faker';
+import Email from '../../Types/Email';
+import Name from '../../Types/Name';
+import Phone from '../../Types/Phone';
+
+describe('Faker Class', () => {
+    it('should generate a random name with alphanumeric characters', () => {
+        expect(Faker.generateName()).toMatch(/^[a-zA-Z0-9]{10}$/);
+    });
+
+    it('should generate a random company name', () => {
+        expect(Faker.generateCompanyName()).toBeTruthy();
+    });
+
+    it('should generate a string of random numbers of specified length', () => {
+        expect(Faker.randomNumbers(8)).toMatch(/^\d{8}$/);
+    });
+
+    it('should generate a user full name', () => {
+        const userFullName: Name = Faker.generateUserFullName();
+        expect(userFullName).toHaveProperty('name');
+        expect(userFullName.name).toBeTruthy();
+    });
+
+    it('should generate a valid email address', () => {
+        const email: Email = Faker.generateEmail();
+        expect(email.email).toMatch(
+            /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,9}$/i
+        );
+    });
+
+    it('should generate a valid phone number', () => {
+        const phone: Phone = Faker.generatePhone();
+        expect(phone.phone).toMatch(
+            /^[+]?[(]?[0-9]{3}[)]?[-\s.]?[0-9]{3}[-\s.]?[0-9]{4,7}$/
+        );
+    });
+});