@applicaster/zapp-react-native-utils 15.0.0-rc.94 → 15.0.0-rc.96

package/errorUtils/__tests__/HttpStatusCode.test.ts

@@ -0,0 +1,344 @@
+import { HttpStatusCode, HttpStatusCodeHelper } from "../HttpStatusCode";
+
+describe("HttpStatusCode", () => {
+  describe("enum values", () => {
+    it("should have correct informational status codes", () => {
+      expect(HttpStatusCode.Continue).toBe(100);
+      expect(HttpStatusCode.SwitchingProtocols).toBe(101);
+      expect(HttpStatusCode.Processing).toBe(102);
+      expect(HttpStatusCode.EarlyHints).toBe(103);
+    });
+
+    it("should have correct success status codes", () => {
+      expect(HttpStatusCode.Ok).toBe(200);
+      expect(HttpStatusCode.Created).toBe(201);
+      expect(HttpStatusCode.Accepted).toBe(202);
+      expect(HttpStatusCode.NoContent).toBe(204);
+    });
+
+    it("should have correct redirection status codes", () => {
+      expect(HttpStatusCode.MovedPermanently).toBe(301);
+      expect(HttpStatusCode.Found).toBe(302);
+      expect(HttpStatusCode.SeeOther).toBe(303);
+      expect(HttpStatusCode.NotModified).toBe(304);
+      expect(HttpStatusCode.TemporaryRedirect).toBe(307);
+      expect(HttpStatusCode.PermanentRedirect).toBe(308);
+    });
+
+    it("should have correct client error status codes", () => {
+      expect(HttpStatusCode.BadRequest).toBe(400);
+      expect(HttpStatusCode.Unauthorized).toBe(401);
+      expect(HttpStatusCode.PaymentRequired).toBe(402);
+      expect(HttpStatusCode.Forbidden).toBe(403);
+      expect(HttpStatusCode.NotFound).toBe(404);
+      expect(HttpStatusCode.MethodNotAllowed).toBe(405);
+      expect(HttpStatusCode.RequestTimeout).toBe(408);
+      expect(HttpStatusCode.Conflict).toBe(409);
+      expect(HttpStatusCode.Gone).toBe(410);
+    });
+
+    it("should have correct server error status codes", () => {
+      expect(HttpStatusCode.InternalServerError).toBe(500);
+      expect(HttpStatusCode.NotImplemented).toBe(501);
+      expect(HttpStatusCode.BadGateway).toBe(502);
+      expect(HttpStatusCode.ServiceUnavailable).toBe(503);
+      expect(HttpStatusCode.GatewayTimeout).toBe(504);
+    });
+
+    it("should have special status codes", () => {
+      expect(HttpStatusCode.ImATeapot).toBe(418);
+      expect(HttpStatusCode.TooManyRequests).toBe(429);
+      expect(HttpStatusCode.UnavailableForLegalReasons).toBe(451);
+    });
+  });
+});
+
+describe("HttpStatusCodeHelper", () => {
+  describe("fromStatusCode", () => {
+    it("should return -1 for null status code", () => {
+      expect(HttpStatusCodeHelper.fromStatusCode(null as any)).toBe(-1);
+    });
+
+    it("should return -1 for undefined status code", () => {
+      expect(HttpStatusCodeHelper.fromStatusCode(undefined as any)).toBe(-1);
+    });
+
+    it("should return -1 for 0 status code", () => {
+      expect(HttpStatusCodeHelper.fromStatusCode(0)).toBe(-1);
+    });
+
+    it("should return correct HttpStatusCode for valid status codes", () => {
+      expect(HttpStatusCodeHelper.fromStatusCode(200)).toBe(HttpStatusCode.Ok);
+
+      expect(HttpStatusCodeHelper.fromStatusCode(201)).toBe(
+        HttpStatusCode.Created
+      );
+
+      expect(HttpStatusCodeHelper.fromStatusCode(400)).toBe(
+        HttpStatusCode.BadRequest
+      );
+
+      expect(HttpStatusCodeHelper.fromStatusCode(401)).toBe(
+        HttpStatusCode.Unauthorized
+      );
+
+      expect(HttpStatusCodeHelper.fromStatusCode(404)).toBe(
+        HttpStatusCode.NotFound
+      );
+
+      expect(HttpStatusCodeHelper.fromStatusCode(500)).toBe(
+        HttpStatusCode.InternalServerError
+      );
+    });
+
+    it("should return the status code itself for unknown codes", () => {
+      expect(HttpStatusCodeHelper.fromStatusCode(999)).toBe(999);
+      expect(HttpStatusCodeHelper.fromStatusCode(123)).toBe(123);
+      expect(HttpStatusCodeHelper.fromStatusCode(600)).toBe(600);
+    });
+
+    it("should handle all standard HTTP status codes", () => {
+      const standardCodes = [
+        100, 101, 102, 103, 200, 201, 202, 203, 204, 205, 206, 207, 208, 226,
+        300, 301, 302, 303, 304, 305, 306, 307, 308, 400, 401, 402, 403, 404,
+        405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418,
+        421, 422, 423, 424, 425, 426, 428, 429, 431, 451, 500, 501, 502, 503,
+        504, 505, 506, 507, 508, 510, 511,
+      ];
+
+      standardCodes.forEach((code) => {
+        const result = HttpStatusCodeHelper.fromStatusCode(code);
+        expect(result).toBe(code);
+      });
+    });
+  });
+
+  describe("informational", () => {
+    it("should return true for 1xx status codes", () => {
+      expect(HttpStatusCodeHelper.informational(HttpStatusCode.Continue)).toBe(
+        true
+      );
+
+      expect(
+        HttpStatusCodeHelper.informational(HttpStatusCode.SwitchingProtocols)
+      ).toBe(true);
+
+      expect(
+        HttpStatusCodeHelper.informational(HttpStatusCode.Processing)
+      ).toBe(true);
+
+      expect(
+        HttpStatusCodeHelper.informational(HttpStatusCode.EarlyHints)
+      ).toBe(true);
+    });
+
+    it("should return false for non-1xx status codes", () => {
+      expect(HttpStatusCodeHelper.informational(HttpStatusCode.Ok)).toBe(false);
+
+      expect(
+        HttpStatusCodeHelper.informational(HttpStatusCode.MovedPermanently)
+      ).toBe(false);
+
+      expect(
+        HttpStatusCodeHelper.informational(HttpStatusCode.BadRequest)
+      ).toBe(false);
+
+      expect(
+        HttpStatusCodeHelper.informational(HttpStatusCode.InternalServerError)
+      ).toBe(false);
+    });
+  });
+
+  describe("successful", () => {
+    it("should return true for 2xx status codes", () => {
+      expect(HttpStatusCodeHelper.successful(HttpStatusCode.Ok)).toBe(true);
+
+      expect(HttpStatusCodeHelper.successful(HttpStatusCode.Created)).toBe(
+        true
+      );
+
+      expect(HttpStatusCodeHelper.successful(HttpStatusCode.Accepted)).toBe(
+        true
+      );
+
+      expect(HttpStatusCodeHelper.successful(HttpStatusCode.NoContent)).toBe(
+        true
+      );
+    });
+
+    it("should return false for non-2xx status codes", () => {
+      expect(HttpStatusCodeHelper.successful(HttpStatusCode.Continue)).toBe(
+        false
+      );
+
+      expect(
+        HttpStatusCodeHelper.successful(HttpStatusCode.MovedPermanently)
+      ).toBe(false);
+
+      expect(HttpStatusCodeHelper.successful(HttpStatusCode.BadRequest)).toBe(
+        false
+      );
+
+      expect(
+        HttpStatusCodeHelper.successful(HttpStatusCode.InternalServerError)
+      ).toBe(false);
+    });
+  });
+
+  describe("redirection", () => {
+    it("should return true for 3xx status codes", () => {
+      expect(
+        HttpStatusCodeHelper.redirection(HttpStatusCode.MovedPermanently)
+      ).toBe(true);
+
+      expect(HttpStatusCodeHelper.redirection(HttpStatusCode.Found)).toBe(true);
+
+      expect(HttpStatusCodeHelper.redirection(HttpStatusCode.SeeOther)).toBe(
+        true
+      );
+
+      expect(HttpStatusCodeHelper.redirection(HttpStatusCode.NotModified)).toBe(
+        true
+      );
+
+      expect(
+        HttpStatusCodeHelper.redirection(HttpStatusCode.TemporaryRedirect)
+      ).toBe(true);
+
+      expect(
+        HttpStatusCodeHelper.redirection(HttpStatusCode.PermanentRedirect)
+      ).toBe(true);
+    });
+
+    it("should return false for non-3xx status codes", () => {
+      expect(HttpStatusCodeHelper.redirection(HttpStatusCode.Ok)).toBe(false);
+
+      expect(HttpStatusCodeHelper.redirection(HttpStatusCode.BadRequest)).toBe(
+        false
+      );
+
+      expect(
+        HttpStatusCodeHelper.redirection(HttpStatusCode.InternalServerError)
+      ).toBe(false);
+    });
+  });
+
+  describe("clientError", () => {
+    it("should return true for 4xx status codes", () => {
+      expect(HttpStatusCodeHelper.clientError(HttpStatusCode.BadRequest)).toBe(
+        true
+      );
+
+      expect(
+        HttpStatusCodeHelper.clientError(HttpStatusCode.Unauthorized)
+      ).toBe(true);
+
+      expect(HttpStatusCodeHelper.clientError(HttpStatusCode.Forbidden)).toBe(
+        true
+      );
+
+      expect(HttpStatusCodeHelper.clientError(HttpStatusCode.NotFound)).toBe(
+        true
+      );
+
+      expect(
+        HttpStatusCodeHelper.clientError(HttpStatusCode.TooManyRequests)
+      ).toBe(true);
+    });
+
+    it("should return false for non-4xx status codes", () => {
+      expect(HttpStatusCodeHelper.clientError(HttpStatusCode.Ok)).toBe(false);
+
+      expect(
+        HttpStatusCodeHelper.clientError(HttpStatusCode.MovedPermanently)
+      ).toBe(false);
+
+      expect(
+        HttpStatusCodeHelper.clientError(HttpStatusCode.InternalServerError)
+      ).toBe(false);
+    });
+  });
+
+  describe("serverError", () => {
+    it("should return true for 5xx status codes", () => {
+      expect(
+        HttpStatusCodeHelper.serverError(HttpStatusCode.InternalServerError)
+      ).toBe(true);
+
+      expect(
+        HttpStatusCodeHelper.serverError(HttpStatusCode.NotImplemented)
+      ).toBe(true);
+
+      expect(HttpStatusCodeHelper.serverError(HttpStatusCode.BadGateway)).toBe(
+        true
+      );
+
+      expect(
+        HttpStatusCodeHelper.serverError(HttpStatusCode.ServiceUnavailable)
+      ).toBe(true);
+
+      expect(
+        HttpStatusCodeHelper.serverError(HttpStatusCode.GatewayTimeout)
+      ).toBe(true);
+    });
+
+    it("should return false for non-5xx status codes", () => {
+      expect(HttpStatusCodeHelper.serverError(HttpStatusCode.Ok)).toBe(false);
+
+      expect(
+        HttpStatusCodeHelper.serverError(HttpStatusCode.MovedPermanently)
+      ).toBe(false);
+
+      expect(HttpStatusCodeHelper.serverError(HttpStatusCode.BadRequest)).toBe(
+        false
+      );
+    });
+  });
+
+  describe("category helpers edge cases", () => {
+    it("should handle boundaries correctly", () => {
+      // 100 is the first informational code
+      expect(HttpStatusCodeHelper.informational(100 as HttpStatusCode)).toBe(
+        true
+      );
+
+      expect(HttpStatusCodeHelper.informational(99 as HttpStatusCode)).toBe(
+        false
+      );
+
+      // 200 is the first successful code
+      expect(HttpStatusCodeHelper.successful(200 as HttpStatusCode)).toBe(true);
+
+      expect(HttpStatusCodeHelper.successful(199 as HttpStatusCode)).toBe(
+        false
+      );
+
+      // 300 is the first redirection code
+      expect(HttpStatusCodeHelper.redirection(300 as HttpStatusCode)).toBe(
+        true
+      );
+
+      expect(HttpStatusCodeHelper.redirection(299 as HttpStatusCode)).toBe(
+        false
+      );
+
+      // 400 is the first client error code
+      expect(HttpStatusCodeHelper.clientError(400 as HttpStatusCode)).toBe(
+        true
+      );
+
+      expect(HttpStatusCodeHelper.clientError(399 as HttpStatusCode)).toBe(
+        false
+      );
+
+      // 500 is the first server error code
+      expect(HttpStatusCodeHelper.serverError(500 as HttpStatusCode)).toBe(
+        true
+      );
+
+      expect(HttpStatusCodeHelper.serverError(499 as HttpStatusCode)).toBe(
+        false
+      );
+    });
+  });
+});

package/errorUtils/__tests__/MissingPluginError.test.ts

@@ -0,0 +1,113 @@
+import { MissingPluginError } from "../MissingPluginError";
+import * as ERROR_CODES from "../errorCodes";
+
+describe("MissingPluginError", () => {
+  it("should create error with plugin identifier", () => {
+    const identifier = "com.example.myplugin";
+    const error = new MissingPluginError(identifier);
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error).toBeInstanceOf(MissingPluginError);
+    expect(error.message).toContain(identifier);
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should include error code in message", () => {
+    const identifier = "video-player";
+    const error = new MissingPluginError(identifier);
+
+    expect(error.message).toContain(ERROR_CODES.MISSING_PLUGIN);
+    expect(error.message).toContain("Error code:");
+  });
+
+  it("should include descriptive message", () => {
+    const identifier = "analytics-plugin";
+    const error = new MissingPluginError(identifier);
+
+    expect(error.message).toContain("Cannot find");
+    expect(error.message).toContain("plugin");
+
+    expect(error.message).toContain(
+      "Please make sure the plugin is properly added"
+    );
+  });
+
+  it("should have correct error code property", () => {
+    const error = new MissingPluginError("test-plugin");
+
+    expect(error.code).toBe("MISSING_PLUGIN");
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should be throwable and catchable", () => {
+    const identifier = "missing-plugin";
+
+    expect(() => {
+      throw new MissingPluginError(identifier);
+    }).toThrow(MissingPluginError);
+
+    try {
+      throw new MissingPluginError(identifier);
+    } catch (error) {
+      expect(error).toBeInstanceOf(MissingPluginError);
+
+      expect((error as MissingPluginError).code).toBe(
+        ERROR_CODES.MISSING_PLUGIN
+      );
+    }
+  });
+
+  it("should handle various identifier formats", () => {
+    const identifiers = [
+      "com.applicaster.plugin",
+      "my-plugin-123",
+      "plugin_name",
+      "Plugin Name With Spaces",
+      "123",
+    ];
+
+    identifiers.forEach((identifier) => {
+      const error = new MissingPluginError(identifier);
+      expect(error.message).toContain(identifier);
+      expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+    });
+  });
+
+  it("should maintain stack trace", () => {
+    const error = new MissingPluginError("stack-test-plugin");
+
+    expect(error.stack).toBeDefined();
+    expect(error.stack).toContain("stack-test-plugin");
+  });
+
+  it("should handle null identifier", () => {
+    const error = new MissingPluginError(null as any);
+
+    expect(error.message).toContain("null");
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should handle undefined identifier", () => {
+    const error = new MissingPluginError(undefined as any);
+
+    expect(error.message).toContain("undefined");
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should handle empty string identifier", () => {
+    const error = new MissingPluginError("");
+
+    expect(error.message).toBeDefined();
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should be distinguishable from other errors", () => {
+    const missingPluginError = new MissingPluginError("test");
+    const regularError = new Error("test");
+    const customError = { code: "MISSING_PLUGIN", message: "test" };
+
+    expect(missingPluginError).toBeInstanceOf(MissingPluginError);
+    expect(regularError).not.toBeInstanceOf(MissingPluginError);
+    expect(customError).not.toBeInstanceOf(MissingPluginError);
+  });
+});

package/errorUtils/__tests__/NetworkError.test.ts

@@ -0,0 +1,202 @@
+import { NetworkError } from "../NetworkError";
+import { HttpStatusCode } from "../HttpStatusCode";
+
+describe("NetworkError", () => {
+  describe("constructor", () => {
+    it("should create network error with message and status code", () => {
+      const message = "Request failed";
+      const statusCode = 404;
+      const error = new NetworkError(message, statusCode);
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(NetworkError);
+      expect(error.originalMessage).toBe(message);
+      expect(error.statusCode).toBe(statusCode);
+      expect(error.message).toContain("404");
+      expect(error.message).toContain(message);
+    });
+
+    it("should format readable log message", () => {
+      const message = "Not found";
+      const statusCode = 404;
+      const error = new NetworkError(message, statusCode);
+
+      expect(error.message).toContain("statusCode:");
+      expect(error.message).toContain("message:");
+      expect(error.message).toContain("readableStatus:");
+    });
+
+    it("should handle null message", () => {
+      const error = new NetworkError(null as any, 500);
+
+      expect(error.originalMessage).toBeNull();
+      expect(error.message).toContain("No error message available");
+    });
+
+    it("should handle undefined message", () => {
+      const error = new NetworkError(undefined as any, 500);
+
+      expect(error.originalMessage).toBeUndefined();
+      expect(error.message).toContain("No error message available");
+    });
+
+    it("should handle custom status codes", () => {
+      const message = "Custom error";
+      const statusCode = 999;
+      const error = new NetworkError(message, statusCode);
+
+      expect(error.statusCode).toBe(statusCode);
+      expect(error.message).toContain("999");
+    });
+  });
+
+  describe("isNetworkError static method", () => {
+    it("should return true for NetworkError instance", () => {
+      const error = new NetworkError("Test", 500);
+
+      expect(NetworkError.isNetworkError(error)).toBe(true);
+    });
+
+    it("should return false for regular Error", () => {
+      const error = new Error("Regular error");
+
+      expect(NetworkError.isNetworkError(error)).toBe(false);
+    });
+
+    it("should return false for other error types", () => {
+      class CustomError extends Error {}
+      const error = new CustomError("Custom");
+
+      expect(NetworkError.isNetworkError(error)).toBe(false);
+    });
+  });
+
+  describe("httpStatusCode getter", () => {
+    it("should return correct HttpStatusCode for 401", () => {
+      const error = new NetworkError("Unauthorized", 401);
+
+      expect(error.httpStatusCode).toBe(HttpStatusCode.Unauthorized);
+    });
+
+    it("should return correct HttpStatusCode for 403", () => {
+      const error = new NetworkError("Forbidden", 403);
+
+      expect(error.httpStatusCode).toBe(HttpStatusCode.Forbidden);
+    });
+
+    it("should return correct HttpStatusCode for 402", () => {
+      const error = new NetworkError("Payment Required", 402);
+
+      expect(error.httpStatusCode).toBe(HttpStatusCode.PaymentRequired);
+    });
+
+    it("should return correct HttpStatusCode for 500", () => {
+      const error = new NetworkError("Server Error", 500);
+
+      expect(error.httpStatusCode).toBe(HttpStatusCode.InternalServerError);
+    });
+
+    it("should handle unknown status codes", () => {
+      const error = new NetworkError("Unknown", 999);
+
+      expect(error.httpStatusCode).toBe(999);
+    });
+  });
+
+  describe("isTokenExpired", () => {
+    it("should return true for 401 status code", () => {
+      const error = new NetworkError("Unauthorized", 401);
+
+      expect(error.isTokenExpired()).toBe(true);
+    });
+
+    it("should return false for non-401 status codes", () => {
+      expect(new NetworkError("Forbidden", 403).isTokenExpired()).toBe(false);
+      expect(new NetworkError("Not Found", 404).isTokenExpired()).toBe(false);
+
+      expect(new NetworkError("Server Error", 500).isTokenExpired()).toBe(
+        false
+      );
+    });
+  });
+
+  describe("isNoAccess", () => {
+    it("should return true for 403 status code", () => {
+      const error = new NetworkError("Forbidden", 403);
+
+      expect(error.isNoAccess()).toBe(true);
+    });
+
+    it("should return false for non-403 status codes", () => {
+      expect(new NetworkError("Unauthorized", 401).isNoAccess()).toBe(false);
+      expect(new NetworkError("Not Found", 404).isNoAccess()).toBe(false);
+      expect(new NetworkError("Server Error", 500).isNoAccess()).toBe(false);
+    });
+  });
+
+  describe("isPaymentRequired", () => {
+    it("should return true for 402 status code", () => {
+      const error = new NetworkError("Payment Required", 402);
+
+      expect(error.isPaymentRequired()).toBe(true);
+    });
+
+    it("should return false for non-402 status codes", () => {
+      expect(new NetworkError("Unauthorized", 401).isPaymentRequired()).toBe(
+        false
+      );
+
+      expect(new NetworkError("Forbidden", 403).isPaymentRequired()).toBe(
+        false
+      );
+
+      expect(new NetworkError("Not Found", 404).isPaymentRequired()).toBe(
+        false
+      );
+    });
+  });
+
+  describe("error handling scenarios", () => {
+    it("should be throwable and catchable", () => {
+      const message = "Test throw";
+      const statusCode = 500;
+
+      expect(() => {
+        throw new NetworkError(message, statusCode);
+      }).toThrow(NetworkError);
+
+      try {
+        throw new NetworkError(message, statusCode);
+      } catch (error) {
+        expect(error).toBeInstanceOf(NetworkError);
+        expect((error as NetworkError).originalMessage).toBe(message);
+        expect((error as NetworkError).statusCode).toBe(statusCode);
+      }
+    });
+
+    it("should maintain stack trace", () => {
+      const error = new NetworkError("Stack test", 500);
+
+      expect(error.stack).toBeDefined();
+      expect(error.stack).toContain("Error data:");
+    });
+
+    it("should handle multiple error scenarios", () => {
+      const unauthorizedError = new NetworkError("Token expired", 401);
+      const forbiddenError = new NetworkError("Access denied", 403);
+      const paymentError = new NetworkError("Subscription required", 402);
+
+      expect(unauthorizedError.isTokenExpired()).toBe(true);
+      expect(unauthorizedError.isNoAccess()).toBe(false);
+      expect(unauthorizedError.isPaymentRequired()).toBe(false);
+
+      expect(forbiddenError.isTokenExpired()).toBe(false);
+      expect(forbiddenError.isNoAccess()).toBe(true);
+      expect(forbiddenError.isPaymentRequired()).toBe(false);
+
+      expect(paymentError.isTokenExpired()).toBe(false);
+      expect(paymentError.isNoAccess()).toBe(false);
+      expect(paymentError.isPaymentRequired()).toBe(true);
+    });
+  });
+});