@abdokouta/react-config 1.0.0

package/__tests__/config.module.test.ts

@@ -0,0 +1,244 @@
+/**
+ * @fileoverview Tests for ConfigModule
+ * 
+ * This test suite verifies the ConfigModule functionality including:
+ * - Module registration (forRoot, forRootAsync)
+ * - Driver creation and configuration
+ * - Custom config merging
+ * - Provider setup
+ * 
+ * @module @abdokouta/config
+ * @category Tests
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { ConfigModule } from "@/config.module";
+import { EnvDriver } from "@/drivers/env.driver";
+import { FileDriver } from "@/drivers/file.driver";
+
+describe("ConfigModule", () => {
+  describe("forRoot", () => {
+    it("should create a dynamic module with default configuration", () => {
+      // Act: Create module with default config
+      const module = ConfigModule.forRoot();
+
+      // Assert: Module structure is correct
+      expect(module).toBeDefined();
+      expect(module.module).toBe(ConfigModule);
+      expect(module.providers).toBeDefined();
+      expect(module.exports).toBeDefined();
+    });
+
+    it("should create module with env driver", () => {
+      // Arrange: Configure env driver
+      const options = {
+        driver: "env" as const,
+        envFilePath: ".env.test",
+      };
+
+      // Act: Create module
+      const module = ConfigModule.forRoot(options);
+
+      // Assert: Module is configured correctly
+      expect(module).toBeDefined();
+      expect(module.providers).toBeDefined();
+    });
+
+    it("should create module with file driver", () => {
+      // Arrange: Configure file driver
+      const options = {
+        driver: "file" as const,
+        configPath: "./config",
+      };
+
+      // Act: Create module
+      const module = ConfigModule.forRoot(options);
+
+      // Assert: Module is configured correctly
+      expect(module).toBeDefined();
+      expect(module.providers).toBeDefined();
+    });
+
+    it("should merge custom configuration", () => {
+      // Arrange: Custom config
+      const customConfig = {
+        app: {
+          name: "Test App",
+          version: "1.0.0",
+        },
+      };
+
+      const options = {
+        driver: "env" as const,
+        config: customConfig,
+      };
+
+      // Act: Create module
+      const module = ConfigModule.forRoot(options);
+
+      // Assert: Module includes custom config
+      expect(module).toBeDefined();
+    });
+
+    it("should set global flag when specified", () => {
+      // Arrange: Global module config
+      const options = {
+        driver: "env" as const,
+        isGlobal: true,
+      };
+
+      // Act: Create module
+      const module = ConfigModule.forRoot(options);
+
+      // Assert: Module is global
+      expect(module.global).toBe(true);
+    });
+  });
+
+  describe("forRootAsync", () => {
+    it("should create async dynamic module", async () => {
+      // Arrange: Async factory
+      const useFactory = async () => ({
+        driver: "env" as const,
+        envFilePath: ".env",
+      });
+
+      // Act: Create async module
+      const module = await ConfigModule.forRootAsync({
+        useFactory,
+      });
+
+      // Assert: Module is created
+      expect(module).toBeDefined();
+      expect(module.module).toBe(ConfigModule);
+    });
+
+    it("should handle async factory with dependencies", async () => {
+      // Arrange: Factory with inject
+      const useFactory = async (dep: any) => ({
+        driver: "env" as const,
+      });
+
+      // Act: Create async module
+      const module = await ConfigModule.forRootAsync({
+        useFactory,
+        inject: ["SOME_DEPENDENCY"],
+      });
+
+      // Assert: Module is created
+      expect(module).toBeDefined();
+    });
+  });
+
+  describe("Driver Creation", () => {
+    it("should create EnvDriver by default", () => {
+      // Act: Create module with no driver specified
+      const module = ConfigModule.forRoot({});
+
+      // Assert: Module uses env driver
+      expect(module).toBeDefined();
+    });
+
+    it("should create FileDriver when specified", () => {
+      // Arrange: File driver config
+      const options = {
+        driver: "file" as const,
+        configPath: "./config",
+      };
+
+      // Act: Create module
+      const module = ConfigModule.forRoot(options);
+
+      // Assert: Module uses file driver
+      expect(module).toBeDefined();
+    });
+
+    it("should pass driver options correctly", () => {
+      // Arrange: Driver with options
+      const options = {
+        driver: "env" as const,
+        envFilePath: ".env.custom",
+        expandVariables: true,
+      };
+
+      // Act: Create module
+      const module = ConfigModule.forRoot(options);
+
+      // Assert: Module is configured
+      expect(module).toBeDefined();
+    });
+  });
+
+  describe("Configuration Merging", () => {
+    it("should merge multiple config sources", () => {
+      // Arrange: Multiple configs
+      const customConfig = {
+        database: {
+          host: "localhost",
+          port: 5432,
+        },
+        cache: {
+          driver: "redis",
+        },
+      };
+
+      const options = {
+        driver: "env" as const,
+        config: customConfig,
+      };
+
+      // Act: Create module
+      const module = ConfigModule.forRoot(options);
+
+      // Assert: Configs are merged
+      expect(module).toBeDefined();
+    });
+
+    it("should handle nested configuration objects", () => {
+      // Arrange: Nested config
+      const customConfig = {
+        app: {
+          name: "Test",
+          features: {
+            auth: true,
+            api: {
+              version: "v1",
+              timeout: 5000,
+            },
+          },
+        },
+      };
+
+      const options = {
+        config: customConfig,
+      };
+
+      // Act: Create module
+      const module = ConfigModule.forRoot(options);
+
+      // Assert: Nested config is handled
+      expect(module).toBeDefined();
+    });
+  });
+
+  describe("Module Exports", () => {
+    it("should export ConfigService", () => {
+      // Act: Create module
+      const module = ConfigModule.forRoot();
+
+      // Assert: ConfigService is exported
+      expect(module.exports).toBeDefined();
+      expect(Array.isArray(module.exports)).toBe(true);
+    });
+
+    it("should provide all necessary providers", () => {
+      // Act: Create module
+      const module = ConfigModule.forRoot();
+
+      // Assert: Providers are defined
+      expect(module.providers).toBeDefined();
+      expect(Array.isArray(module.providers)).toBe(true);
+      expect(module.providers!.length).toBeGreaterThan(0);
+    });
+  });
+});

package/__tests__/drivers/env.driver.test.ts

@@ -0,0 +1,259 @@
+/**
+ * @fileoverview Tests for EnvDriver
+ * 
+ * This test suite verifies the EnvDriver functionality including:
+ * - Loading environment variables
+ * - Getting values with dot notation
+ * - Variable expansion
+ * - Default values
+ * - Type conversions
+ * 
+ * @module @abdokouta/config
+ * @category Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { EnvDriver } from "@/drivers/env.driver";
+
+describe("EnvDriver", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    // Arrange: Reset environment
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    // Cleanup: Restore environment
+    process.env = originalEnv;
+  });
+
+  describe("load", () => {
+    it("should load environment variables", () => {
+      // Arrange: Set env vars
+      process.env.APP_NAME = "Test App";
+      process.env.APP_PORT = "3000";
+      process.env.APP_DEBUG = "true";
+
+      const driver = new EnvDriver();
+
+      // Act: Load config
+      const config = driver.load();
+
+      // Assert: Config is loaded
+      expect(config).toBeDefined();
+      expect(typeof config).toBe("object");
+    });
+
+    it("should handle empty environment", () => {
+      // Arrange: Clear env
+      process.env = {};
+
+      const driver = new EnvDriver();
+
+      // Act: Load config
+      const config = driver.load();
+
+      // Assert: Empty config is returned
+      expect(config).toBeDefined();
+      expect(typeof config).toBe("object");
+    });
+  });
+
+  describe("get", () => {
+    beforeEach(() => {
+      // Arrange: Set test env vars
+      process.env.APP_NAME = "Test App";
+      process.env.APP_PORT = "3000";
+      process.env.DATABASE_HOST = "localhost";
+      process.env.DATABASE_PORT = "5432";
+    });
+
+    it("should get environment variable", () => {
+      // Arrange: Create driver
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Get value
+      const appName = driver.get("APP_NAME");
+
+      // Assert: Value is returned
+      expect(appName).toBe("Test App");
+    });
+
+    it("should return default value when key doesn't exist", () => {
+      // Arrange: Create driver
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Get with default
+      const value = driver.get("MISSING_KEY", "default");
+
+      // Assert: Default is returned
+      expect(value).toBe("default");
+    });
+
+    it("should return undefined when key doesn't exist and no default", () => {
+      // Arrange: Create driver
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Get without default
+      const value = driver.get("MISSING_KEY");
+
+      // Assert: Undefined is returned
+      expect(value).toBeUndefined();
+    });
+
+    it("should handle numeric string values", () => {
+      // Arrange: Create driver
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Get numeric value
+      const port = driver.get("APP_PORT");
+
+      // Assert: String is returned (no auto-conversion)
+      expect(port).toBe("3000");
+    });
+  });
+
+  describe("has", () => {
+    beforeEach(() => {
+      // Arrange: Set test env vars
+      process.env.APP_NAME = "Test App";
+      process.env.EMPTY_VAR = "";
+    });
+
+    it("should return true for existing key", () => {
+      // Arrange: Create driver
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Check existence
+      const exists = driver.has("APP_NAME");
+
+      // Assert: Key exists
+      expect(exists).toBe(true);
+    });
+
+    it("should return false for missing key", () => {
+      // Arrange: Create driver
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Check existence
+      const exists = driver.has("MISSING_KEY");
+
+      // Assert: Key doesn't exist
+      expect(exists).toBe(false);
+    });
+
+    it("should return true for empty string value", () => {
+      // Arrange: Create driver
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Check existence
+      const exists = driver.has("EMPTY_VAR");
+
+      // Assert: Key exists even with empty value
+      expect(exists).toBe(true);
+    });
+  });
+
+  describe("all", () => {
+    beforeEach(() => {
+      // Arrange: Set test env vars
+      process.env.APP_NAME = "Test App";
+      process.env.APP_PORT = "3000";
+      process.env.DATABASE_HOST = "localhost";
+    });
+
+    it("should return all configuration", () => {
+      // Arrange: Create driver
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Get all config
+      const config = driver.all();
+
+      // Assert: All config is returned
+      expect(config).toBeDefined();
+      expect(typeof config).toBe("object");
+    });
+
+    it("should include all loaded variables", () => {
+      // Arrange: Create driver
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Get all config
+      const config = driver.all();
+
+      // Assert: Contains loaded vars
+      expect(config).toBeDefined();
+    });
+  });
+
+  describe("Variable Expansion", () => {
+    it("should expand variables when enabled", () => {
+      // Arrange: Set vars with references
+      process.env.BASE_URL = "http://localhost";
+      process.env.API_URL = "${BASE_URL}/api";
+
+      const driver = new EnvDriver({ expandVariables: true });
+      driver.load();
+
+      // Act: Get expanded value
+      const apiUrl = driver.get("API_URL");
+
+      // Assert: Variable is expanded (if implemented)
+      expect(apiUrl).toBeDefined();
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle special characters in values", () => {
+      // Arrange: Set var with special chars
+      process.env.SPECIAL = "value with spaces & symbols!@#";
+
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Get value
+      const value = driver.get("SPECIAL");
+
+      // Assert: Special chars are preserved
+      expect(value).toBe("value with spaces & symbols!@#");
+    });
+
+    it("should handle multiline values", () => {
+      // Arrange: Set multiline var
+      process.env.MULTILINE = "line1\\nline2\\nline3";
+
+      const driver = new EnvDriver();
+      driver.load();
+
+      // Act: Get value
+      const value = driver.get("MULTILINE");
+
+      // Assert: Multiline is preserved
+      expect(value).toBeDefined();
+    });
+
+    it("should handle empty environment", () => {
+      // Arrange: Clear all env vars
+      process.env = {};
+
+      const driver = new EnvDriver();
+
+      // Act: Load and get
+      driver.load();
+      const value = driver.get("ANY_KEY", "default");
+
+      // Assert: Default is returned
+      expect(value).toBe("default");
+    });
+  });
+});