@oneuptime/common 7.0.2525 → 7.0.2550

package/Tests/Types/API/Protocal.test.ts

@@ -1,19 +1,19 @@
-import Protocol from '../../../Types/API/Protocol';
+import Protocol from "../../../Types/API/Protocol";
 
-describe('Protocol', () => {
-    test('Protocol.HTTPS should be https://', () => {
-        expect(Protocol.HTTPS).toBe('https://');
-    });
-    test('Protocol.HTTP should be https://', () => {
-        expect(Protocol.HTTP).toBe('http://');
-    });
-    test('Protocol.WS should be ws://', () => {
-        expect(Protocol.WS).toBe('ws://');
-    });
-    test('Protocol.WSS should be ws://', () => {
-        expect(Protocol.WSS).toBe('wss://');
-    });
-    test('Protocol.MONGO_DB should be mongodb://', () => {
-        expect(Protocol.MONGO_DB).toBe('mongodb://');
-    });
+describe("Protocol", () => {
+  test("Protocol.HTTPS should be https://", () => {
+    expect(Protocol.HTTPS).toBe("https://");
+  });
+  test("Protocol.HTTP should be https://", () => {
+    expect(Protocol.HTTP).toBe("http://");
+  });
+  test("Protocol.WS should be ws://", () => {
+    expect(Protocol.WS).toBe("ws://");
+  });
+  test("Protocol.WSS should be ws://", () => {
+    expect(Protocol.WSS).toBe("wss://");
+  });
+  test("Protocol.MONGO_DB should be mongodb://", () => {
+    expect(Protocol.MONGO_DB).toBe("mongodb://");
+  });
 });

package/Tests/Types/API/Response.test.ts

@@ -1,21 +1,21 @@
-import Response from '../../../Types/API/HTTPResponse';
-import { JSONObject } from '../../../Types/JSON';
+import Response from "../../../Types/API/HTTPResponse";
+import { JSONObject } from "../../../Types/JSON";
 
-describe('Response()', () => {
-    test('should return a valid response object', () => {
-        const responseObject: Response<JSONObject> = new Response(
-            200,
-            {
-                welcome: 'here',
-            },
-            {}
-        );
-        expect(responseObject.statusCode).toBe(200);
-        expect(responseObject.data).toEqual({ welcome: 'here' });
-        const responseObjectArray: Response<Array<JSONObject>> = new Response<
-            Array<JSONObject>
-        >(200, [{ welcome: 'here' }], {});
-        expect(responseObjectArray.statusCode).toBe(200);
-        expect(responseObjectArray.data).toEqual([{ welcome: 'here' }]);
-    });
+describe("Response()", () => {
+  test("should return a valid response object", () => {
+    const responseObject: Response<JSONObject> = new Response(
+      200,
+      {
+        welcome: "here",
+      },
+      {},
+    );
+    expect(responseObject.statusCode).toBe(200);
+    expect(responseObject.data).toEqual({ welcome: "here" });
+    const responseObjectArray: Response<Array<JSONObject>> = new Response<
+      Array<JSONObject>
+    >(200, [{ welcome: "here" }], {});
+    expect(responseObjectArray.statusCode).toBe(200);
+    expect(responseObjectArray.data).toEqual([{ welcome: "here" }]);
+  });
 });

package/Tests/Types/API/ResponseType.test.ts

@@ -1,13 +1,13 @@
-import ResponseType from '../../../Types/API/ResponseType';
+import ResponseType from "../../../Types/API/ResponseType";
 
-describe('ResponseType', () => {
-    test('ResponseType.CSV to be csv', () => {
-        expect(ResponseType.CSV).toBe('csv');
-    });
-    test('ResponseType.HTML to be json', () => {
-        expect(ResponseType.HTML).toBe('html');
-    });
-    test('ResponseType.HTML to be', () => {
-        expect(ResponseType.JSON).toBe('json');
-    });
+describe("ResponseType", () => {
+  test("ResponseType.CSV to be csv", () => {
+    expect(ResponseType.CSV).toBe("csv");
+  });
+  test("ResponseType.HTML to be json", () => {
+    expect(ResponseType.HTML).toBe("html");
+  });
+  test("ResponseType.HTML to be", () => {
+    expect(ResponseType.JSON).toBe("json");
+  });
 });

package/Tests/Types/API/Route.test.ts

@@ -1,30 +1,30 @@
-import Route from '../../../Types/API/Route';
-import BadDataException from '../../../Types/Exception/BadDataException';
+import Route from "../../../Types/API/Route";
+import BadDataException from "../../../Types/Exception/BadDataException";
 
-describe('Route', () => {
-    test('new Route() should throw an error if invalid route is passed', () => {
-        expect(() => {
-            return new Route('api test');
-        }).toThrowError(BadDataException);
-        expect(() => {
-            return new Route('api\test');
-        }).toThrowError(BadDataException);
-        expect(() => {
-            return new Route('api`test');
-        }).toThrowError(BadDataException);
-        expect(() => {
-            return new Route('/api|test');
-        }).toThrowError(BadDataException);
-    });
-    test('new Route() should throw an error if invalid route is passed', () => {
-        const route: Route = new Route('/api/test');
-        expect(() => {
-            route.route = 'api`test';
-        }).toThrowError(BadDataException);
-    });
-    test('Route.toString() should return valid string', () => {
-        expect(new Route('/api/test').toString()).toBe('/api/test');
-        expect(new Route('/api#test').toString()).toBe('/api#test');
-        expect(new Route('/api-test').toString()).toBe('/api-test');
-    });
+describe("Route", () => {
+  test("new Route() should throw an error if invalid route is passed", () => {
+    expect(() => {
+      return new Route("api test");
+    }).toThrowError(BadDataException);
+    expect(() => {
+      return new Route("api\test");
+    }).toThrowError(BadDataException);
+    expect(() => {
+      return new Route("api`test");
+    }).toThrowError(BadDataException);
+    expect(() => {
+      return new Route("/api|test");
+    }).toThrowError(BadDataException);
+  });
+  test("new Route() should throw an error if invalid route is passed", () => {
+    const route: Route = new Route("/api/test");
+    expect(() => {
+      route.route = "api`test";
+    }).toThrowError(BadDataException);
+  });
+  test("Route.toString() should return valid string", () => {
+    expect(new Route("/api/test").toString()).toBe("/api/test");
+    expect(new Route("/api#test").toString()).toBe("/api#test");
+    expect(new Route("/api-test").toString()).toBe("/api-test");
+  });
 });

package/Tests/Types/API/StatusCode.test.ts

@@ -1,26 +1,26 @@
-import StatusCode from '../../../Types/API/StatusCode';
-import BadDataException from '../../../Types/Exception/BadDataException';
+import StatusCode from "../../../Types/API/StatusCode";
+import BadDataException from "../../../Types/Exception/BadDataException";
 
-describe('Route', () => {
-    test('new StatusCode should throw if number is not passed', () => {
-        expect(() => {
-            return new StatusCode('invalid');
-        }).toThrowError(BadDataException);
-        expect(() => {
-            return new StatusCode(-400);
-        }).toThrowError(BadDataException);
-        expect(() => {
-            return new StatusCode('-400');
-        }).toThrowError(BadDataException);
-    });
-    test('Route.toString() should return valid  statuscode string', () => {
-        expect(new StatusCode('200').toString()).toEqual('200');
-        expect(new StatusCode('100').toString()).toEqual('100');
-        expect(new StatusCode(400).toString()).toEqual('400');
-    });
-    test('Route.toNumber() should return valid  statuscode number', () => {
-        expect(new StatusCode('200').toNumber()).toEqual(200);
-        expect(new StatusCode('100').toNumber()).toEqual(100);
-        expect(new StatusCode('500').toNumber()).toEqual(500);
-    });
+describe("Route", () => {
+  test("new StatusCode should throw if number is not passed", () => {
+    expect(() => {
+      return new StatusCode("invalid");
+    }).toThrowError(BadDataException);
+    expect(() => {
+      return new StatusCode(-400);
+    }).toThrowError(BadDataException);
+    expect(() => {
+      return new StatusCode("-400");
+    }).toThrowError(BadDataException);
+  });
+  test("Route.toString() should return valid  statuscode string", () => {
+    expect(new StatusCode("200").toString()).toEqual("200");
+    expect(new StatusCode("100").toString()).toEqual("100");
+    expect(new StatusCode(400).toString()).toEqual("400");
+  });
+  test("Route.toNumber() should return valid  statuscode number", () => {
+    expect(new StatusCode("200").toNumber()).toEqual(200);
+    expect(new StatusCode("100").toNumber()).toEqual(100);
+    expect(new StatusCode("500").toNumber()).toEqual(500);
+  });
 });

package/Tests/Types/API/URL.test.ts

@@ -1,42 +1,42 @@
-import Hostname from '../../../Types/API/Hostname';
-import Protocol from '../../../Types/API/Protocol';
-import Route from '../../../Types/API/Route';
-import URL from '../../../Types/API/URL';
+import Hostname from "../../../Types/API/Hostname";
+import Protocol from "../../../Types/API/Protocol";
+import Route from "../../../Types/API/Route";
+import URL from "../../../Types/API/URL";
 
-describe('URL', () => {
-    test('new URL() should return a valid object', () => {
-        const url: URL = new URL(
-            Protocol.HTTPS,
-            new Hostname('localhost:5000'),
-            new Route('/api/test')
-        );
-        expect(url.hostname).toBeInstanceOf(Hostname);
-        expect(url.protocol).toBe('https://');
-        expect(url.route).toBeInstanceOf(Route);
-        expect(url.isHttps()).toBe(true);
-        expect(url.toString).toBeTruthy();
-    });
-    test('URL.fromString should create URL object', () => {
-        let url: URL = URL.fromString('https://localhost:5000/api/test');
-        expect(url).toBeInstanceOf(URL);
-        expect(url.protocol).toBe('https://');
-        url = URL.fromString('mongodb://localhost:27017/test');
-        expect(url).toBeInstanceOf(URL);
-        expect(url.protocol).toBe('mongodb://');
-        url = URL.fromString('ws://localhost:5000/api/test');
-        expect(url).toBeInstanceOf(URL);
-        expect(url.protocol).toBe('ws://');
-        url = URL.fromString('wss://localhost:5000/api/test');
-        expect(url).toBeInstanceOf(URL);
-        expect(url.protocol).toBe('wss://');
-    });
+describe("URL", () => {
+  test("new URL() should return a valid object", () => {
+    const url: URL = new URL(
+      Protocol.HTTPS,
+      new Hostname("localhost:5000"),
+      new Route("/api/test"),
+    );
+    expect(url.hostname).toBeInstanceOf(Hostname);
+    expect(url.protocol).toBe("https://");
+    expect(url.route).toBeInstanceOf(Route);
+    expect(url.isHttps()).toBe(true);
+    expect(url.toString).toBeTruthy();
+  });
+  test("URL.fromString should create URL object", () => {
+    let url: URL = URL.fromString("https://localhost:5000/api/test");
+    expect(url).toBeInstanceOf(URL);
+    expect(url.protocol).toBe("https://");
+    url = URL.fromString("mongodb://localhost:27017/test");
+    expect(url).toBeInstanceOf(URL);
+    expect(url.protocol).toBe("mongodb://");
+    url = URL.fromString("ws://localhost:5000/api/test");
+    expect(url).toBeInstanceOf(URL);
+    expect(url.protocol).toBe("ws://");
+    url = URL.fromString("wss://localhost:5000/api/test");
+    expect(url).toBeInstanceOf(URL);
+    expect(url.protocol).toBe("wss://");
+  });
 
-    test('URL.toString should return a valid URL', () => {
-        const url: URL = new URL(
-            Protocol.HTTPS,
-            new Hostname('localhost:5000'),
-            new Route('/api/test')
-        );
-        expect(url.toString()).toBe('https://localhost:5000/api/test');
-    });
+  test("URL.toString should return a valid URL", () => {
+    const url: URL = new URL(
+      Protocol.HTTPS,
+      new Hostname("localhost:5000"),
+      new Route("/api/test"),
+    );
+    expect(url.toString()).toBe("https://localhost:5000/api/test");
+  });
 });

package/Tests/Types/Alerts/AlertEventType.test.ts

@@ -1,49 +1,49 @@
-import AlertEventType from '../../../Types/Alerts/AlertEventType';
+import AlertEventType from "../../../Types/Alerts/AlertEventType";
 
-describe('AlertEventType', () => {
-    test('AlertEventType.Identified to be Identified', () => {
-        expect(AlertEventType.Identified).toBe('Identified');
-    });
-    test('AlertEventType.Acknowledged to Acknowledged', () => {
-        expect(AlertEventType.Acknowledged).toBe('Acknowledged');
-    });
-    test('AlertEventType.Resolved to Resolved', () => {
-        expect(AlertEventType.Resolved).toBe('Resolved');
-    });
-    test('AlertEventType.InvestigationNoteCreated to Investigation note created', () => {
-        expect(AlertEventType.InvestigationNoteCreated).toBe(
-            'Investigation note created'
-        );
-    });
-    test('AlertEventType.InvestigationNoteUpdated to Investigation note updated', () => {
-        expect(AlertEventType.InvestigationNoteUpdated).toBe(
-            'Investigation note updated'
-        );
-    });
-    test('AlertEventType.ScheduledMaintenanceCreated to Scheduled maintenance created', () => {
-        expect(AlertEventType.ScheduledMaintenanceCreated).toBe(
-            'Scheduled maintenance created'
-        );
-    });
-    test('AlertEventType.ScheduledMaintenanceNoteCreated to Scheduled maintenance note Created', () => {
-        expect(AlertEventType.ScheduledMaintenanceNoteCreated).toBe(
-            'Scheduled maintenance note created'
-        );
-    });
+describe("AlertEventType", () => {
+  test("AlertEventType.Identified to be Identified", () => {
+    expect(AlertEventType.Identified).toBe("Identified");
+  });
+  test("AlertEventType.Acknowledged to Acknowledged", () => {
+    expect(AlertEventType.Acknowledged).toBe("Acknowledged");
+  });
+  test("AlertEventType.Resolved to Resolved", () => {
+    expect(AlertEventType.Resolved).toBe("Resolved");
+  });
+  test("AlertEventType.InvestigationNoteCreated to Investigation note created", () => {
+    expect(AlertEventType.InvestigationNoteCreated).toBe(
+      "Investigation note created",
+    );
+  });
+  test("AlertEventType.InvestigationNoteUpdated to Investigation note updated", () => {
+    expect(AlertEventType.InvestigationNoteUpdated).toBe(
+      "Investigation note updated",
+    );
+  });
+  test("AlertEventType.ScheduledMaintenanceCreated to Scheduled maintenance created", () => {
+    expect(AlertEventType.ScheduledMaintenanceCreated).toBe(
+      "Scheduled maintenance created",
+    );
+  });
+  test("AlertEventType.ScheduledMaintenanceNoteCreated to Scheduled maintenance note Created", () => {
+    expect(AlertEventType.ScheduledMaintenanceNoteCreated).toBe(
+      "Scheduled maintenance note created",
+    );
+  });
 
-    test('AlertEventType.ScheduledMaintenanceResolved to scheduled maintenance resolved', () => {
-        expect(AlertEventType.ScheduledMaintenanceResolved).toBe(
-            'Scheduled maintenance resolved'
-        );
-    });
-    test('AlertEventType.Acknowledged to Scheduled maintenance cancelled', () => {
-        expect(AlertEventType.ScheduledMaintenanceCancelled).toBe(
-            'Scheduled maintenance cancelled'
-        );
-    });
-    test('AlertEventType.AnnouncementNotificationCreated to Announcement notification created', () => {
-        expect(AlertEventType.AnnouncementNotificationCreated).toBe(
-            'Announcement notification created'
-        );
-    });
+  test("AlertEventType.ScheduledMaintenanceResolved to scheduled maintenance resolved", () => {
+    expect(AlertEventType.ScheduledMaintenanceResolved).toBe(
+      "Scheduled maintenance resolved",
+    );
+  });
+  test("AlertEventType.Acknowledged to Scheduled maintenance cancelled", () => {
+    expect(AlertEventType.ScheduledMaintenanceCancelled).toBe(
+      "Scheduled maintenance cancelled",
+    );
+  });
+  test("AlertEventType.AnnouncementNotificationCreated to Announcement notification created", () => {
+    expect(AlertEventType.AnnouncementNotificationCreated).toBe(
+      "Announcement notification created",
+    );
+  });
 });

package/Tests/Types/Alerts/AlertType.test.ts

@@ -1,19 +1,19 @@
-import AlertType from '../../../Types/Alerts/AlertType';
+import AlertType from "../../../Types/Alerts/AlertType";
 
-describe('AlertType', () => {
-    test('AlertType.Email to be Email', () => {
-        expect(AlertType.Webhook).toBe('Webhook');
-    });
-    test('AlertType.Acknowledged to Acknowledged', () => {
-        expect(AlertType.Email).toBe('Email');
-    });
-    test('AlertType.SMS to SMS', () => {
-        expect(AlertType.SMS).toBe('SMS');
-    });
-    test('AlertType.Call to Call', () => {
-        expect(AlertType.Call).toBe('Call');
-    });
-    test('AlertType.PushNotification to PushNotification', () => {
-        expect(AlertType.PushNotification).toBe('PushNotification');
-    });
+describe("AlertType", () => {
+  test("AlertType.Email to be Email", () => {
+    expect(AlertType.Webhook).toBe("Webhook");
+  });
+  test("AlertType.Acknowledged to Acknowledged", () => {
+    expect(AlertType.Email).toBe("Email");
+  });
+  test("AlertType.SMS to SMS", () => {
+    expect(AlertType.SMS).toBe("SMS");
+  });
+  test("AlertType.Call to Call", () => {
+    expect(AlertType.Call).toBe("Call");
+  });
+  test("AlertType.PushNotification to PushNotification", () => {
+    expect(AlertType.PushNotification).toBe("PushNotification");
+  });
 });

package/Tests/Types/AppEnvironment.test.ts

@@ -1,13 +1,13 @@
-import AppEnvironment from '../../Types/AppEnvironment';
+import AppEnvironment from "../../Types/AppEnvironment";
 
-describe('AppEnvironment', () => {
-    test('AppEnvironment.Production should be production', () => {
-        expect(AppEnvironment.Production).toEqual('production');
-    });
-    test('AppEnvironment.Development should be production', () => {
-        expect(AppEnvironment.Development).toEqual('development');
-    });
-    test('AppEnvironment.Test should be test', () => {
-        expect(AppEnvironment.Test).toEqual('test');
-    });
+describe("AppEnvironment", () => {
+  test("AppEnvironment.Production should be production", () => {
+    expect(AppEnvironment.Production).toEqual("production");
+  });
+  test("AppEnvironment.Development should be production", () => {
+    expect(AppEnvironment.Development).toEqual("development");
+  });
+  test("AppEnvironment.Test should be test", () => {
+    expect(AppEnvironment.Test).toEqual("test");
+  });
 });

package/Tests/Types/ApplicationLog/ApplicationLogType.test.ts

@@ -1,13 +1,13 @@
-import ApplicationLogType from '../../../Types/ApplicationLog/ApplicationLogType';
+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');
-    });
+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");
+  });
 });