add test for multiple scenarios

Signed-off-by: rockito10 <[email protected]>

Author: rockito10

config/core/helpers/url-helpers.ts

@@ -51,7 +51,7 @@ function _isEmail(input: string | undefined): boolean {
 }
 
 function _isMultipleURL(input: string | undefined): boolean {
-  return input.split(',').every((url) => _isURL(url.trim()) || _isLocalhost(url.trim()));
+  return input?.split(',').every((url) => _isURL(url.trim()) || _isLocalhost(url.trim()));
 }
 
 function _isPostgresURL(input: string | undefined): boolean {

config/test/config.spec.ts

@@ -5,18 +5,322 @@ dotenv.config({
   path: './config/test/.env'
 });
 
-test('Protocol Success', () => {
+// --- PROTOCOL ---
+
+test('Protocol Success http', () => {
+  const mockSchema = v.schema({
+    PROTOCOL_TEST_1: v.str().protocol()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+test('Protocol Success https', () => {
   const mockSchema = v.schema({
-    API_GATEWAY_PROTOCOL: v.str().protocol()
+    PROTOCOL_TEST_3: v.str().protocol()
   });
 
   expect(mockSchema.safeParse(process.env).success).toBeTruthy();
 });
 
 test('Protocol Error', () => {
   const mockSchema = v.schema({
-    API_GATEWAY_PROTOCOL_SECURE: v.str().protocol()
+    PROTOCOL_TEST_2: v.str().protocol()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+// --- HOST ---
+
+test('Host Success', () => {
+  const mockSchema = v.schema({
+    TEST_HOST_4: v.str().host()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+test('Host Error exceeds value of valid IP', () => {
+  const mockSchema = v.schema({
+    TEST_HOST_1: v.str().protocol()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Host Error contains letters', () => {
+  const mockSchema = v.schema({
+    TEST_HOST_2: v.str().protocol()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Host Error contains letters', () => {
+  const mockSchema = v.schema({
+    TEST_HOST_3: v.str().protocol()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+// --- URL ---
+
+test('URL Success', () => {
+  const mockSchema = v.schema({
+    TEST_URL_1: v.str().url()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+test('URL Error invalid protocol', () => {
+  const mockSchema = v.schema({
+    TEST_URL_2: v.str().url()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('URL Success with Localhost', () => {
+  const mockSchema = v.schema({
+    TEST_URL_3: v.str().url()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+test('URL Error invalid format', () => {
+  const mockSchema = v.schema({
+    TEST_URL_4: v.str().url()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('URL Success without protocol', () => {
+  const mockSchema = v.schema({
+    TEST_URL_5: v.str().url()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+// --- MULTIPLE URL ---
+
+test('Multiple URL error with no valid URL', () => {
+  const mockSchema = v.schema({
+    TEST_MULTIPLE_URL_1: v.str().multipleUrl()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Multiple URL error with valid URLs, but one not valid', () => {
+  const mockSchema = v.schema({
+    TEST_MULTIPLE_URL_2: v.str().multipleUrl()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Multiple URL with one URL', () => {
+  const mockSchema = v.schema({
+    TEST_MULTIPLE_URL_3: v.str().multipleUrl()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+test('Multiple URL with more than one URL', () => {
+  const mockSchema = v.schema({
+    TEST_MULTIPLE_URL_4: v.str().multipleUrl()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+// --- PORT ---
+
+test('Port error with well-known port', () => {
+  const mockSchema = v.schema({
+    TEST_PORT_1: v.str().port()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Port error with out-of-range port', () => {
+  const mockSchema = v.schema({
+    TEST_PORT_2: v.str().port()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+// --- ENDPOINT ---
+
+test('Endpoint error, not an endpoint', () => {
+  const mockSchema = v.schema({
+    TEST_ENDPOINT_1: v.str().endpoint()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Endpoint error, wrong format (has protocol)', () => {
+  const mockSchema = v.schema({
+    TEST_ENDPOINT_2: v.str().endpoint()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Endpoint success with valid endpoint', () => {
+  const mockSchema = v.schema({
+    TEST_ENDPOINT_3: v.str().endpoint()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+// --- OPTIONAL ---
+
+test('Optional success with no value', () => {
+  const mockSchema = v.schema({
+    TEST_OPTIONAL_1: v.str().optional()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+test('Optional success with value', () => {
+  const mockSchema = v.schema({
+    TEST_OPTIONAL_2: v.str().optional()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+// --- NOT EMPTY ---
+
+test('Not empty failure with no value', () => {
+  const mockSchema = v.schema({
+    TEST_NOT_EMPTY_1: v.str().notEmpty()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Not empty success with value', () => {
+  const mockSchema = v.schema({
+    TEST_NOT_EMPTY_2: v.str().notEmpty()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+// --- EMAIL ---
+
+test('Email error with invalid mail format', () => {
+  const mockSchema = v.schema({
+    TEST_EMAIL_1: v.str().email()
   });
 
   expect(mockSchema.safeParse(process.env).success).toBeFalsy();
 });
+
+test('Email error with invalid mail format (lacks ".something")', () => {
+  const mockSchema = v.schema({
+    TEST_EMAIL_2: v.str().email()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Email error with invalid mail format (lacks "@")', () => {
+  const mockSchema = v.schema({
+    TEST_EMAIL_3: v.str().email()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Email success with valid email', () => {
+  const mockSchema = v.schema({
+    TEST_EMAIL_4: v.str().email()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+// --- BOOLEAN ---
+
+test('Boolean failure, is not true or false.', () => {
+  const mockSchema = v.schema({
+    TEST_BOOLEAN_1: v.str().boolean()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Boolean failure, is not true or false.', () => {
+  const mockSchema = v.schema({
+    TEST_BOOLEAN_2: v.str().boolean()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Boolean error, is uppercase true.', () => {
+  const mockSchema = v.schema({
+    TEST_BOOLEAN_3: v.str().boolean()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Boolean success, is uppercase false.', () => {
+  const mockSchema = v.schema({
+    TEST_BOOLEAN_4: v.str().boolean()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Boolean success, is true.', () => {
+  const mockSchema = v.schema({
+    TEST_BOOLEAN_5: v.str().boolean()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+test('Boolean success, is false.', () => {
+  const mockSchema = v.schema({
+    TEST_BOOLEAN_6: v.str().boolean()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+// --- NUMBER ---
+
+test('Boolean error, is not a valid number.', () => {
+  const mockSchema = v.schema({
+    TEST_NUMBER_1: v.str().number()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeFalsy();
+});
+
+test('Boolean success, is a valid number.', () => {
+  const mockSchema = v.schema({
+    TEST_NUMBER_2: v.str().number()
+  });
+
+  expect(mockSchema.safeParse(process.env).success).toBeTruthy();
+});
+
+// TODO undefined cases