@oneuptime/common 1.0.0

package/Tests/Types/Billing/SubscriptionPlan.test.ts

@@ -0,0 +1,298 @@
+import SubscriptionPlan, {
+    PlanSelect,
+} from '../../../Types/Billing/SubscriptionPlan';
+import { JSONObject } from '../../../Types/JSON';
+import BadDataException from '../../../Types/Exception/BadDataException';
+
+describe('SubscriptionPlan', () => {
+    const monthlyPlanId: string = 'monthly_plan_id';
+    const yearlyPlanId: string = 'yearly_plan_id';
+    const name: string = 'Test Plan';
+    const monthlySubscriptionAmountInUSD: number = 0;
+    const yearlySubscriptionAmountInUSD: number = 0;
+    const order: number = 1;
+    const trialPeriodInDays: number = 30;
+    const env: JSONObject = {
+        SUBSCRIPTION_PLAN_1: 'Free,monthly_plan_id,yearly_plan_id,0,0,1,7',
+        SUBSCRIPTION_PLAN_2:
+            'Growth,growth_monthly_plan_id,growth_yearly_plan_id,9,99,2,14',
+    };
+
+    describe('constructor', () => {
+        it('should create a new SubscriptionPlan object', () => {
+            const plan: SubscriptionPlan = new SubscriptionPlan(
+                monthlyPlanId,
+                yearlyPlanId,
+                name,
+                monthlySubscriptionAmountInUSD,
+                yearlySubscriptionAmountInUSD,
+                order,
+                trialPeriodInDays
+            );
+            expect(plan.getMonthlyPlanId()).toEqual(monthlyPlanId);
+            expect(plan.getYearlyPlanId()).toEqual(yearlyPlanId);
+            expect(plan.getName()).toEqual(name);
+            expect(plan.getPlanOrder()).toEqual(order);
+            expect(plan.getTrialPeriod()).toEqual(trialPeriodInDays);
+        });
+    });
+
+    describe('getMonthlyPlanId', () => {
+        it('should return the monthly plan ID', () => {
+            const getMonthlyPlanId: string = 'monthly_plan_id';
+            expect(getMonthlyPlanId).toEqual(monthlyPlanId);
+        });
+    });
+
+    describe('getYearlyPlanId', () => {
+        it('should return the yearly plan ID', () => {
+            const getYearlyPlanId: string = 'yearly_plan_id';
+            expect(getYearlyPlanId).toEqual(yearlyPlanId);
+        });
+    });
+
+    describe('getPlanOrder', () => {
+        it('should return the plan order', () => {
+            const getPlanOrder: number = 1;
+            expect(getPlanOrder).toEqual(order);
+        });
+    });
+
+    describe('getTrialPeriod', () => {
+        it('should return the trial period in days', () => {
+            const getTrialPeriod: number = 30;
+            expect(getTrialPeriod).toEqual(trialPeriodInDays);
+        });
+    });
+
+    describe('getName', () => {
+        it('should return the plan name', () => {
+            const getName: string = 'Test Plan';
+            expect(getName).toEqual(name);
+        });
+    });
+
+    describe('isFreePlan', () => {
+        it('should return true if plan is free with monthlyId', () => {
+            const isFreePlan: boolean = SubscriptionPlan.isFreePlan(
+                'monthly_plan_id',
+                env
+            );
+            expect(isFreePlan).toBe(true);
+        });
+        it('should return true if plan is free with yearlyId', () => {
+            const isFreePlan: boolean = SubscriptionPlan.isFreePlan(
+                'yearly_plan_id',
+                env
+            );
+            expect(isFreePlan).toBe(true);
+        });
+    });
+    describe('isCustomPricingPlan', () => {
+        it('should return false if plan is not custom pricing', () => {
+            const isCustomPricingPlan: boolean =
+                SubscriptionPlan.isCustomPricingPlan(monthlyPlanId, env);
+            expect(isCustomPricingPlan).toBe(false);
+        });
+    });
+
+    describe('getSubscriptionPlans', () => {
+        it('should return an array of SubscriptionPlan objects', () => {
+            const subscriptionPlans: SubscriptionPlan[] =
+                SubscriptionPlan.getSubscriptionPlans(env);
+
+            expect(subscriptionPlans.length).toBe(2);
+            expect(subscriptionPlans?.[0]?.getName()).toBe('Free');
+            expect(subscriptionPlans?.[0]?.getYearlyPlanId()).toBe(
+                'yearly_plan_id'
+            );
+        });
+    });
+    describe('isValidPlanId', () => {
+        it('should return true if plan ID is valid', () => {
+            const isValidPlanId: boolean = SubscriptionPlan.isValidPlanId(
+                'growth_monthly_plan_id',
+                env
+            );
+            expect(isValidPlanId).toBe(true);
+        });
+    });
+    describe('getPlanSelect', () => {
+        it('should return the plan name if valid planId is passed', () => {
+            new SubscriptionPlan(
+                monthlyPlanId,
+                'yearly_plan_id',
+                PlanSelect.Free,
+                0,
+                0,
+                2,
+                30
+            );
+            const result: PlanSelect = SubscriptionPlan.getPlanSelect(
+                monthlyPlanId,
+                env
+            );
+            expect(result).toBe(PlanSelect.Free);
+        });
+        it('should throw an error if invalid PlanId is passed', () => {
+            SubscriptionPlan.getSubscriptionPlanById = jest
+                .fn()
+                .mockReturnValue(undefined);
+            expect(() => {
+                SubscriptionPlan.getPlanSelect('invalid-plan-id', env);
+            }).toThrow(BadDataException);
+        });
+    });
+    describe('getYearlySubscriptionAmountInUSD', () => {
+        it('should return the yearly subscription amount', () => {
+            const getYearlySubscriptionAmountInUSD: number = 0;
+            expect(getYearlySubscriptionAmountInUSD).toEqual(
+                yearlySubscriptionAmountInUSD
+            );
+        });
+    });
+    describe('getMonthlySubscriptionAmountInUSD', () => {
+        it('should return the yearly subscription amount', () => {
+            const getMonthlySubscriptionAmountInUSD: number = 0;
+            expect(getMonthlySubscriptionAmountInUSD).toEqual(
+                monthlySubscriptionAmountInUSD
+            );
+        });
+    });
+    describe('isFeatureAccessibleOnCurrentPlan', () => {
+        it('should return false if the feature is not accessible on current plan', () => {
+            const env: JSONObject = {
+                SUBSCRIPTION_PLAN_1:
+                    'Free,monthly_plan_id,yearly_plan_id,0,0,1,7',
+                SUBSCRIPTION_PLAN_2:
+                    'Growth,growth_monthly_plan_id,growth_yearly_plan_id,9,99,2,14',
+            };
+            const featureSubscriptionPlan: SubscriptionPlan =
+                new SubscriptionPlan(
+                    'growth_monthly_plan_id',
+                    'growth_yearly_plan_id',
+                    PlanSelect.Growth,
+                    9,
+                    99,
+                    2,
+                    14
+                );
+            const currentSubscriptionPlan: SubscriptionPlan =
+                new SubscriptionPlan(
+                    'monthly_plan_id',
+                    'yearly_plan_id',
+                    PlanSelect.Free,
+                    0,
+                    0,
+                    1,
+                    7
+                );
+            const result: boolean =
+                SubscriptionPlan.isFeatureAccessibleOnCurrentPlan(
+                    PlanSelect.Growth,
+                    PlanSelect.Free,
+                    env
+                );
+            expect(featureSubscriptionPlan.getPlanOrder()).toBeGreaterThan(
+                currentSubscriptionPlan.getPlanOrder()
+            );
+            expect(result).toBe(false);
+        });
+        it('should return true if the feature is on the current plan', () => {
+            const env: JSONObject = {
+                SUBSCRIPTION_PLAN_1:
+                    'Free,monthly_plan_id,yearly_plan_id,0,0,3,7',
+                SUBSCRIPTION_PLAN_2:
+                    'Growth,growth_monthly_plan_id,growth_yearly_plan_id,9,99,2,14',
+            };
+            const featureSubscriptionPlan: SubscriptionPlan =
+                new SubscriptionPlan(
+                    'growth_monthly_plan_id',
+                    'growth_yearly_plan_id',
+                    PlanSelect.Growth,
+                    9,
+                    99,
+                    2,
+                    14
+                );
+            const currentSubscriptionPlan: SubscriptionPlan =
+                new SubscriptionPlan(
+                    monthlyPlanId,
+                    'yearly_plan_id',
+                    PlanSelect.Free,
+                    0,
+                    0,
+                    3,
+                    7
+                );
+            const result: boolean =
+                SubscriptionPlan.isFeatureAccessibleOnCurrentPlan(
+                    PlanSelect.Growth,
+                    PlanSelect.Free,
+                    env
+                );
+            expect(featureSubscriptionPlan.getPlanOrder()).toBeLessThan(
+                currentSubscriptionPlan.getPlanOrder()
+            );
+            expect(result).toBe(true);
+        });
+    });
+    describe('getSubscriptionPlanFromPlanSelect', () => {
+        it('should return the correct SubscriptionPlan when a valid planSelect is provided', () => {
+            const plan: SubscriptionPlan =
+                SubscriptionPlan.getSubscriptionPlanFromPlanSelect(
+                    PlanSelect.Growth,
+                    env
+                );
+            expect(plan).toEqual(plan);
+            expect(plan.getName()).toEqual(PlanSelect.Growth);
+        });
+        it('should throw a BadDataException when an invalid planSelect is provided', () => {
+            const planSelect: PlanSelect = PlanSelect.Scale;
+            SubscriptionPlan.getSubscriptionPlans = jest
+                .fn()
+                .mockReturnValue([]);
+            expect(() => {
+                SubscriptionPlan.getSubscriptionPlanFromPlanSelect(
+                    planSelect,
+                    env
+                );
+            }).toThrow(BadDataException);
+        });
+    });
+    describe('isYearlyPlan', () => {
+        it('should return true if yearly plan exists', () => {
+            const planId: string = 'growth_yearly_plan_id';
+            const plan: SubscriptionPlan = new SubscriptionPlan(
+                'monthly-plan-id',
+                planId,
+                'Growth',
+                10,
+                100,
+                2,
+                7
+            );
+            SubscriptionPlan.getSubscriptionPlanById(planId, env);
+            expect(plan?.getYearlyPlanId()).toBe(planId);
+        });
+    });
+    describe('isUnpaid', () => {
+        it('should return true if the subscription status is unpaid', () => {
+            const subscriptionStatus: string =
+                'incomplete' ||
+                'incomplete_expired' ||
+                'past_due' ||
+                'canceled' ||
+                'unpaid';
+            const result: boolean =
+                SubscriptionPlan.isUnpaid(subscriptionStatus);
+            expect(result).toBe(true);
+        });
+        it('should return false if the subscription status is active', () => {
+            const subscriptionStatus: string = 'active';
+            const result: boolean =
+                SubscriptionPlan.isUnpaid(subscriptionStatus);
+            expect(result).toBe(false);
+        });
+    });
+});

package/Tests/Types/BrandColors.test.ts

@@ -0,0 +1,140 @@
+import Color from '../../Types/Color';
+import {
+    Black,
+    White,
+    slate,
+    Purple,
+    Pink,
+    Red,
+    Orange,
+    Yellow,
+    Green,
+    Teal,
+    Cyan,
+    VeryLightGrey,
+    Grey,
+    LightGrey,
+    Moroon,
+    Blue,
+} from '../../Types/BrandColors';
+
+describe('Color', () => {
+    describe('Verify color hex', () => {
+        it('should create a new instance with the given hex code', () => {
+            const color: Color = new Color('#123456');
+            expect(color).toBe(color);
+        });
+    });
+    describe('Black', () => {
+        it('should be an instance with the hex code of Black', () => {
+            const color: Color = Black;
+            expect(Black).toBe(color);
+            expect(Black.color).toBe('#000000');
+        });
+    });
+    describe('White', () => {
+        it('should be an instance with the hex code of White', () => {
+            const color: Color = White;
+            expect(White).toBe(color);
+            expect(White.color).toBe('#ffffff');
+        });
+    });
+    describe('slate', () => {
+        it('should be an instance with the hex code of slate', () => {
+            const color: Color = slate;
+            expect(slate).toBe(color);
+            expect(slate.color).toBe('#564ab1');
+        });
+    });
+    describe('Purple', () => {
+        it('should be an instance with the hex code of Purple', () => {
+            const color: Color = Purple;
+            expect(Purple).toBe(color);
+            expect(Purple.color).toBe('#6f42c1');
+        });
+    });
+    describe('Pink', () => {
+        it('should be an instance with the hex code of Pink', () => {
+            const color: Color = Pink;
+            expect(Pink).toBe(color);
+            expect(Pink.color).toBe('#e83e8c');
+        });
+    });
+    describe('Red', () => {
+        it('should be an instance with the hex code of Red', () => {
+            const color: Color = Red;
+            expect(Red).toBe(color);
+            expect(Red.color).toBe('#fd625e');
+        });
+    });
+    describe('Orange', () => {
+        it('should be an instance with the hex code of Orange', () => {
+            const color: Color = Orange;
+            expect(Orange).toBe(color);
+            expect(Orange.color).toBe('#f1734f');
+        });
+    });
+    describe('Yellow', () => {
+        it('should be an instance with the hex code of Yellow', () => {
+            const color: Color = Yellow;
+            expect(Yellow).toBe(color);
+            expect(Yellow.color).toBe('#ffbf53');
+        });
+    });
+    describe('Green', () => {
+        it('should be an instance with the hex code of Green', () => {
+            const color: Color = Green;
+            expect(Green).toBe(color);
+            expect(Green.color).toBe('#2ab57d');
+        });
+    });
+    describe('Teal', () => {
+        it('should be an instance with the hex code of Teal', () => {
+            const color: Color = Teal;
+            expect(Teal).toBe(color);
+            expect(Teal.color).toBe('#050505');
+        });
+    });
+    describe('Cyan', () => {
+        it('should be an instance with the hex code of Cyan', () => {
+            const color: Color = Cyan;
+            expect(Cyan).toBe(color);
+            expect(Cyan.color).toBe('#4ba6ef');
+        });
+    });
+    describe('VeryLightGrey', () => {
+        it('should be an instance with the hex code of VeryLightGrey', () => {
+            const color: Color = VeryLightGrey;
+            expect(VeryLightGrey).toBe(color);
+            expect(VeryLightGrey.color).toBe('#c2c2c2');
+        });
+    });
+    describe('Grey', () => {
+        it('should be an instance with the hex code of Grey', () => {
+            const color: Color = Grey;
+            expect(Grey).toBe(color);
+            expect(Grey.color).toBe('#575757');
+        });
+    });
+    describe('LightGrey', () => {
+        it('should be an instance with the hex code of LightGrey', () => {
+            const color: Color = LightGrey;
+            expect(LightGrey).toBe(color);
+            expect(LightGrey.color).toBe('#908B8B');
+        });
+    });
+    describe('Moroon', () => {
+        it('should be an instance with the hex code of Moroon', () => {
+            const color: Color = Moroon;
+            expect(Moroon).toBe(color);
+            expect(Moroon.color).toBe('#b70400');
+        });
+    });
+    describe('Blue', () => {
+        it('should be an instance with the hex code of Blue', () => {
+            const color: Color = Blue;
+            expect(Blue).toBe(color);
+            expect(Blue.color).toBe('#3686be');
+        });
+    });
+});

package/Tests/Types/Char.test.ts

@@ -0,0 +1,83 @@
+import Char from '../../Types/Char';
+import Dictionary from '../../Types/Dictionary';
+
+describe('type Char', () => {
+    test('Char can used be type', () => {
+        let char: Char;
+        expect((char = 'a')).toBe('a');
+        expect((char = 'b')).toBe('b');
+        expect((char = 'c')).toBe('c');
+        expect((char = 'd')).toEqual('d');
+        expect((char = 'e')).toEqual('e');
+        expect((char = 'f')).toEqual('f');
+        expect((char = 'g')).toEqual('g');
+        expect((char = 'h')).toEqual('h');
+        expect((char = 'i')).toEqual('i');
+        expect((char = 'j')).toEqual('j');
+        expect((char = 'k')).toEqual('k');
+        expect((char = 'l')).toEqual('l');
+        expect((char = 'm')).toEqual('m');
+        expect((char = 'n')).toEqual('n');
+        expect((char = 'o')).toEqual('o');
+        expect((char = 'p')).toEqual('p');
+        expect((char = 'q')).toEqual('q');
+        expect((char = 'r')).toEqual('r');
+        expect((char = 's')).toEqual('s');
+        expect((char = 't')).toEqual('t');
+        expect((char = 'u')).toEqual('u');
+        expect((char = 'v')).toEqual('v');
+        expect((char = 'w')).toEqual('w');
+        expect((char = 'x')).toEqual('x');
+        expect((char = 'y')).toEqual('y');
+        expect((char = 'z')).toEqual('z');
+        expect((char = 'A')).toEqual('A');
+        expect((char = 'B')).toEqual('B');
+        expect((char = 'C')).toEqual('C');
+        expect((char = 'D')).toEqual('D');
+        expect((char = 'E')).toEqual('E');
+        expect((char = 'F')).toEqual('F');
+        expect((char = 'G')).toEqual('G');
+        expect((char = 'H')).toEqual('H');
+        expect((char = 'I')).toEqual('I');
+        expect((char = 'J')).toEqual('J');
+        expect((char = 'K')).toEqual('K');
+        expect((char = 'L')).toEqual('L');
+        expect((char = 'M')).toEqual('M');
+        expect((char = 'N')).toEqual('N');
+        expect((char = 'O')).toEqual('O');
+        expect((char = 'P')).toEqual('P');
+        expect((char = 'Q')).toEqual('Q');
+        expect((char = 'R')).toEqual('R');
+        expect((char = 'S')).toEqual('S');
+        expect((char = 'T')).toEqual('T');
+        expect((char = 'U')).toEqual('U');
+        expect((char = 'V')).toEqual('V');
+        expect((char = 'W')).toEqual('W');
+        expect((char = 'X')).toEqual('X');
+        expect((char = 'Y')).toEqual('Y');
+        expect((char = 'Z')).toEqual('Z');
+        expect((char = '0')).toEqual('0');
+        expect((char = '1')).toEqual('1');
+        expect((char = '2')).toEqual('2');
+        expect((char = '3')).toEqual('3');
+        expect((char = '4')).toEqual('4');
+        expect((char = '5')).toEqual('5');
+        expect((char = '6')).toEqual('6');
+        expect((char = '7')).toEqual('7');
+        expect((char = '8')).toEqual('8');
+        expect((char = '9')).toEqual('9');
+        expect(char).toEqual('9');
+    });
+    test('type Char can be used in array', () => {
+        const characters: Array<Char> = ['a', 'A', '1'];
+        expect(characters).toBeDefined();
+        expect(characters).toEqual(['a', 'A', '1']);
+    });
+    test('type Char to be used in dictionary', () => {
+        const characterDictionary: Dictionary<Char> = {
+            a: 'a',
+            A: 'A',
+        };
+        expect(characterDictionary['a']).toEqual('a');
+    });
+});

package/Tests/Types/Code/CodeType.test.ts

@@ -0,0 +1,13 @@
+import ApplicationLogType from '../../../Types/ApplicationLog/ApplicationLogType';
+
+describe('ApplicationLogType', () => {
+    test('ApplicationLogType.Info to be Info', () => {
+        expect(ApplicationLogType.Info).toBe('Info');
+    });
+    test('ApplicationLogType.Error to Error', () => {
+        expect(ApplicationLogType.Error).toBe('Error');
+    });
+    test('ApplicationLogType.Warning to Warning', () => {
+        expect(ApplicationLogType.Warning).toBe('Warning');
+    });
+});

package/Tests/Types/Color.test.ts

@@ -0,0 +1,44 @@
+import Color, { RGB } from '../../Types/Color';
+import BadDataException from '../../Types/Exception/BadDataException';
+
+describe('Color', () => {
+    test('should return the color string', () => {
+        const color: Color = new Color('#807149');
+        expect(color.toString()).toBe('#807149');
+    });
+    test('should return the string value of color  ', () => {
+        const color: Color = new Color('#807149');
+        expect(Color.toDatabase(color)).toBe('#807149');
+    });
+    test('should return instance of Color', () => {
+        expect(Color.fromDatabase('#807149')).toBeInstanceOf(Color);
+    });
+    test('should return null', () => {
+        expect(Color.fromDatabase('')).toBeNull();
+    });
+    test('should return object of type RGB', () => {
+        const color: Color = new Color('#807149');
+        const rgb: RGB = Color.colorToRgb(color);
+        expect(typeof rgb.red).toEqual('number');
+        expect(typeof rgb.green).toEqual('number');
+        expect(typeof rgb.blue).toEqual('number');
+    });
+    test('should return correct RGB values ', () => {
+        const color: Color = new Color('#807149');
+        const rgb: RGB = Color.colorToRgb(color);
+        expect(rgb.red).toEqual(128);
+        expect(rgb.green).toEqual(113);
+        expect(rgb.blue).toEqual(73);
+    });
+    test('should throw exception', () => {
+        const color: Color = new Color('-1');
+        expect(() => {
+            Color.colorToRgb(color);
+        }).toThrow(BadDataException);
+    });
+    test('should return instance of Color', () => {
+        const color: Color = new Color('#807149');
+        const rgb: RGB = Color.colorToRgb(color);
+        expect(Color.rgbToColor(rgb)).toBeInstanceOf(Color);
+    });
+});

package/Tests/Types/Company/CompanySize.test.ts

@@ -0,0 +1,21 @@
+import CompanySize from '../../../Types/Company/CompanySize';
+
+export default CompanySize;
+
+describe('CompanySize', () => {
+    test('should be in range of 1 to 10', () => {
+        expect(CompanySize.OneToTen).toBe('1 to 10');
+    });
+    test('should be in range of 11 to 50', () => {
+        expect(CompanySize.ElevenToFifty).toBe('11 to 50');
+    });
+    test('should be in range of 51 to 200', () => {
+        expect(CompanySize.FiftyToTwoHundred).toBe('51 to 200');
+    });
+    test('should be in range of 201 to 500', () => {
+        expect(CompanySize.TwoHundredToFiveHundred).toBe('201 to 500');
+    });
+    test('should be greater than 500', () => {
+        expect(CompanySize.FiveHundredAndMore).toBe('500+');
+    });
+});

package/Tests/Types/Company/JobRole.test.ts

@@ -0,0 +1,22 @@
+import JobRole from '../../../Types/Company/JobRole';
+
+describe('JobRole', () => {
+    test('should have a role of CEO', () => {
+        expect(JobRole.CEO).toBe('CEO');
+    });
+    test('should have a role of CEO', () => {
+        expect(JobRole.CTO).toBe('CTO');
+    });
+    test('should have a role of CEO', () => {
+        expect(JobRole.CIO).toBe('CIO');
+    });
+    test('should have a role of executive', () => {
+        expect(JobRole.Executive).toBe('Executive');
+    });
+    test('should have a role of developer', () => {
+        expect(JobRole.Developer).toBe('Developer');
+    });
+    test('should have a role of engineering manager', () => {
+        expect(JobRole.EngineeringManager).toBe('Engineering Manager');
+    });
+});