@applicaster/zapp-react-native-utils 15.0.0-rc.14 → 15.0.0-rc.140

package/enumUtils/__tests__/getEnumKeyByEnumValue.test.ts

@@ -0,0 +1,207 @@
+import { getEnumKeyByEnumValue } from "../index";
+
+describe("getEnumKeyByEnumValue", () => {
+  enum TestEnum {
+    First = "FIRST",
+    Second = "SECOND",
+    Third = "THIRD",
+  }
+
+  enum NumericEnum {
+    Zero = 0,
+    One = 1,
+    Two = 2,
+    Three = 3,
+  }
+
+  enum MixedEnum {
+    StringValue = "string",
+    NumericValue = 42,
+    BooleanValue = "true",
+  }
+
+  describe("string enums", () => {
+    it("should return key for valid enum value", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, "FIRST")).toBe("First");
+      expect(getEnumKeyByEnumValue(TestEnum, "SECOND")).toBe("Second");
+      expect(getEnumKeyByEnumValue(TestEnum, "THIRD")).toBe("Third");
+    });
+
+    it("should return null for invalid enum value", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, "INVALID")).toBeNull();
+      expect(getEnumKeyByEnumValue(TestEnum, "")).toBeNull();
+      expect(getEnumKeyByEnumValue(TestEnum, "first")).toBeNull();
+    });
+
+    it("should be case-sensitive", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, "first")).toBeNull();
+      expect(getEnumKeyByEnumValue(TestEnum, "FIRST")).toBe("First");
+    });
+  });
+
+  describe("numeric enums", () => {
+    it("should return key for valid numeric enum value", () => {
+      expect(getEnumKeyByEnumValue(NumericEnum, 0)).toBe("Zero");
+      expect(getEnumKeyByEnumValue(NumericEnum, 1)).toBe("One");
+      expect(getEnumKeyByEnumValue(NumericEnum, 2)).toBe("Two");
+      expect(getEnumKeyByEnumValue(NumericEnum, 3)).toBe("Three");
+    });
+
+    it("should return null for invalid numeric value", () => {
+      expect(getEnumKeyByEnumValue(NumericEnum, 4)).toBeNull();
+      expect(getEnumKeyByEnumValue(NumericEnum, -1)).toBeNull();
+      expect(getEnumKeyByEnumValue(NumericEnum, 999)).toBeNull();
+    });
+
+    it("should handle numeric strings", () => {
+      // When passing string "0", it won't match numeric enum value 0
+      expect(getEnumKeyByEnumValue(NumericEnum, "0")).toBeNull();
+    });
+  });
+
+  describe("mixed enums", () => {
+    it("should handle string values in mixed enum", () => {
+      expect(getEnumKeyByEnumValue(MixedEnum, "string")).toBe("StringValue");
+    });
+
+    it("should handle numeric values in mixed enum", () => {
+      expect(getEnumKeyByEnumValue(MixedEnum, 42)).toBe("NumericValue");
+    });
+
+    it("should handle boolean-like string values", () => {
+      expect(getEnumKeyByEnumValue(MixedEnum, "true")).toBe("BooleanValue");
+    });
+
+    it("should not match boolean to string 'true'", () => {
+      expect(getEnumKeyByEnumValue(MixedEnum, true)).toBeNull();
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should return null for null value", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, null)).toBeNull();
+    });
+
+    it("should return null for undefined value", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, undefined)).toBeNull();
+    });
+
+    it("should handle empty enum", () => {
+      const EmptyEnum = {};
+      expect(getEnumKeyByEnumValue(EmptyEnum, "anything")).toBeNull();
+    });
+
+    it("should handle object values", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, {})).toBeNull();
+    });
+
+    it("should handle array values", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, [])).toBeNull();
+    });
+
+    it("should return first matching key if multiple keys have same value", () => {
+      enum DuplicateEnum {
+        First = "SAME",
+        Second = "SAME",
+      }
+
+      const result = getEnumKeyByEnumValue(DuplicateEnum, "SAME");
+      expect(result).toBeTruthy();
+      expect(["First", "Second"]).toContain(result);
+    });
+  });
+
+  describe("type checking", () => {
+    it("should work with const enum-like objects", () => {
+      const ConstLikeEnum = {
+        KEY_ONE: "value1",
+        KEY_TWO: "value2",
+      } as const;
+
+      expect(getEnumKeyByEnumValue(ConstLikeEnum, "value1")).toBe("KEY_ONE");
+      expect(getEnumKeyByEnumValue(ConstLikeEnum, "value2")).toBe("KEY_TWO");
+    });
+
+    it("should work with plain objects", () => {
+      const plainObject = {
+        key1: "val1",
+        key2: "val2",
+        key3: 123,
+      };
+
+      expect(getEnumKeyByEnumValue(plainObject, "val1")).toBe("key1");
+      expect(getEnumKeyByEnumValue(plainObject, 123)).toBe("key3");
+    });
+
+    it("should return correct TypeScript type", () => {
+      const result = getEnumKeyByEnumValue(TestEnum, "FIRST");
+
+      // Result should be keyof TestEnum | null
+      if (result !== null) {
+        expect(typeof result).toBe("string");
+      }
+    });
+  });
+
+  describe("special values", () => {
+    enum SpecialEnum {
+      EmptyString = "",
+      Zero = 0,
+      False = "false",
+      Null = "null",
+    }
+
+    it("should handle empty string value", () => {
+      expect(getEnumKeyByEnumValue(SpecialEnum, "")).toBe("EmptyString");
+    });
+
+    it("should handle zero value", () => {
+      expect(getEnumKeyByEnumValue(SpecialEnum, 0)).toBe("Zero");
+    });
+
+    it("should handle false-like string", () => {
+      expect(getEnumKeyByEnumValue(SpecialEnum, "false")).toBe("False");
+    });
+
+    it("should handle null-like string", () => {
+      expect(getEnumKeyByEnumValue(SpecialEnum, "null")).toBe("Null");
+    });
+  });
+
+  describe("performance", () => {
+    it("should handle large enums efficiently", () => {
+      const largeEnum: Record<string, string> = {};
+
+      for (let i = 0; i < 1000; i++) {
+        largeEnum[`Key${i}`] = `Value${i}`;
+      }
+
+      expect(getEnumKeyByEnumValue(largeEnum, "Value500")).toBe("Key500");
+      expect(getEnumKeyByEnumValue(largeEnum, "Value999")).toBe("Key999");
+      expect(getEnumKeyByEnumValue(largeEnum, "NonExistent")).toBeNull();
+    });
+  });
+
+  describe("reverse lookup", () => {
+    enum ReverseEnum {
+      A = "ValueA",
+      B = "ValueB",
+    }
+
+    it("should provide reverse lookup functionality", () => {
+      // Forward: get value from key
+      expect(ReverseEnum.A).toBe("ValueA");
+
+      // Reverse: get key from value
+      expect(getEnumKeyByEnumValue(ReverseEnum, "ValueA")).toBe("A");
+    });
+
+    it("should be consistent with enum access", () => {
+      const key = getEnumKeyByEnumValue(TestEnum, "SECOND");
+
+      if (key) {
+        expect(TestEnum[key]).toBe("SECOND");
+      }
+    });
+  });
+});

package/errorUtils/__tests__/GeneralError.test.ts

@@ -0,0 +1,97 @@
+import { GeneralError } from "../GeneralError";
+
+describe("GeneralError", () => {
+  it("should create error with message only", () => {
+    const message = "Something went wrong";
+    const error = new GeneralError(message);
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error).toBeInstanceOf(GeneralError);
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBeNull();
+    expect(error.localizationKey).toBeNull();
+  });
+
+  it("should create error with message and status code", () => {
+    const message = "Not found";
+    const statusCode = 404;
+    const error = new GeneralError(message, statusCode);
+
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBe(statusCode);
+    expect(error.localizationKey).toBeNull();
+  });
+
+  it("should create error with all parameters", () => {
+    const message = "Forbidden";
+    const statusCode = 403;
+    const localizationKey = "error.forbidden";
+    const error = new GeneralError(message, statusCode, localizationKey);
+
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBe(statusCode);
+    expect(error.localizationKey).toBe(localizationKey);
+  });
+
+  it("should create error with null status code explicitly", () => {
+    const message = "Error without status";
+    const error = new GeneralError(message, null, "error.general");
+
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBeNull();
+    expect(error.localizationKey).toBe("error.general");
+  });
+
+  it("should create error with null localization key explicitly", () => {
+    const message = "Server error";
+    const statusCode = 500;
+    const error = new GeneralError(message, statusCode, null);
+
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBe(statusCode);
+    expect(error.localizationKey).toBeNull();
+  });
+
+  it("should have error name", () => {
+    const error = new GeneralError("Test error");
+
+    expect(error.name).toBe("Error");
+  });
+
+  it("should be throwable and catchable", () => {
+    const message = "Test throw";
+    const statusCode = 400;
+
+    expect(() => {
+      throw new GeneralError(message, statusCode);
+    }).toThrow(GeneralError);
+
+    try {
+      throw new GeneralError(message, statusCode);
+    } catch (error) {
+      expect(error).toBeInstanceOf(GeneralError);
+      expect((error as GeneralError).message).toBe(message);
+      expect((error as GeneralError).statusCode).toBe(statusCode);
+    }
+  });
+
+  it("should maintain error stack trace", () => {
+    const error = new GeneralError("Stack trace test");
+
+    expect(error.stack).toBeDefined();
+    expect(error.stack).toContain("Stack trace test");
+  });
+
+  it("should allow status code to be 0", () => {
+    const error = new GeneralError("Zero status", 0);
+
+    expect(error.statusCode).toBe(0);
+  });
+
+  it("should allow empty string message", () => {
+    const error = new GeneralError("");
+
+    expect(error.message).toBe("");
+    expect(error.statusCode).toBeNull();
+  });
+});

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
+      );
+    });
+  });
+});