@volley/vwr-loader 1.0.6 → 1.2.0

package/src/getEnvironment.test.ts

@@ -1,19 +1,21 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 
 import { type Environment, getEnvironment } from "./getEnvironment"
+import { logger } from "./logger"
 
-describe("getEnvironment", () => {
-    const mockLogger = {
+vi.mock("./logger", () => ({
+    logger: {
         info: vi.fn(),
         warn: vi.fn(),
         error: vi.fn(),
-    }
+        debug: vi.fn(),
+        child: vi.fn(),
+    },
+}))
 
+describe("getEnvironment", () => {
     beforeEach(() => {
         vi.clearAllMocks()
-        mockLogger.info.mockClear()
-        mockLogger.warn.mockClear()
-        mockLogger.error.mockClear()
         // Clean up window properties
         delete (window as any).Capacitor
     })
@@ -42,15 +44,11 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("native")
-            expect(mockLogger.info).toHaveBeenCalledWith(
+            expect(logger.info).toHaveBeenCalledWith(
                 expect.stringContaining(
                     'Environment: "dev" (source: native BuildConfig.ENVIRONMENT="development")'
                 )
@@ -74,11 +72,7 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("prod")
             expect(result.source).toBe("native")
@@ -101,11 +95,30 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
+
+            expect(result.environment).toBe("staging")
+            expect(result.source).toBe("native")
+        })
+
+        it("should map legacy 'qa' to 'staging'", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "qa",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("staging")
             expect(result.source).toBe("native")
@@ -128,11 +141,7 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("native")
@@ -155,11 +164,7 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("native")
@@ -167,15 +172,11 @@ describe("getEnvironment", () => {
 
         it("should fallback to build-time when native plugin unavailable", async () => {
             // No Capacitor plugin available
-            const result = await getEnvironment(
-                "FIRE_TV",
-                "staging",
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", "staging")
 
             expect(result.environment).toBe("staging")
             expect(result.source).toBe("build-time")
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 expect.stringContaining(
                     "Failed to read environment from native, falling back to build-time"
                 )
@@ -199,12 +200,12 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment("FIRE_TV", "prod", mockLogger)
+            const result = await getEnvironment("FIRE_TV", "prod")
 
             expect(result.environment).toBe("prod")
             expect(result.source).toBe("build-time")
-            expect(mockLogger.error).toHaveBeenCalled()
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalled()
+            expect(logger.warn).toHaveBeenCalledWith(
                 expect.stringContaining("falling back to build-time")
             )
         })
@@ -226,11 +227,11 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment("FIRE_TV", "dev", mockLogger)
+            const result = await getEnvironment("FIRE_TV", "dev")
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("build-time")
-            expect(mockLogger.error).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalledWith(
                 expect.stringContaining(
                     "DeviceInfo.getNativeShellAppEnvironment returned empty"
                 )
@@ -239,15 +240,11 @@ describe("getEnvironment", () => {
 
         it("should fallback to default when both native and build-time fail", async () => {
             // No Capacitor plugin, no build-time env
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("default")
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 expect.stringContaining(
                     'Environment: "dev" (source: default fallback'
                 )
@@ -271,16 +268,8 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result1 = await getEnvironment(
-                "fire_tv",
-                undefined,
-                mockLogger
-            )
-            const result2 = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result1 = await getEnvironment("fire_tv", undefined)
+            const result2 = await getEnvironment("FIRE_TV", undefined)
 
             expect(result1.environment).toBe("prod")
             expect(result2.environment).toBe("prod")
@@ -293,15 +282,11 @@ describe("getEnvironment", () => {
         platforms.forEach((platform) => {
             describe(`${platform}`, () => {
                 it("should use build-time environment when provided", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "staging",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "staging")
 
                     expect(result.environment).toBe("staging")
                     expect(result.source).toBe("build-time")
-                    expect(mockLogger.info).toHaveBeenCalledWith(
+                    expect(logger.info).toHaveBeenCalledWith(
                         expect.stringContaining(
                             'Environment: "staging" (source: build-time CLI injection)'
                         )
@@ -309,48 +294,32 @@ describe("getEnvironment", () => {
                 })
 
                 it("should use build-time 'prod' environment", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "prod",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "prod")
 
                     expect(result.environment).toBe("prod")
                     expect(result.source).toBe("build-time")
                 })
 
                 it("should use build-time 'dev' environment", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "dev",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "dev")
 
                     expect(result.environment).toBe("dev")
                     expect(result.source).toBe("build-time")
                 })
 
                 it("should use build-time 'local' environment", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "local",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "local")
 
                     expect(result.environment).toBe("local")
                     expect(result.source).toBe("build-time")
                 })
 
                 it("should fallback to default when build-time not provided", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        undefined,
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, undefined)
 
                     expect(result.environment).toBe("dev")
                     expect(result.source).toBe("default")
-                    expect(mockLogger.warn).toHaveBeenCalledWith(
+                    expect(logger.warn).toHaveBeenCalledWith(
                         expect.stringContaining(
                             'Environment: "dev" (source: default fallback'
                         )
@@ -358,11 +327,7 @@ describe("getEnvironment", () => {
                 })
 
                 it("should fallback to default when build-time is invalid", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "invalid-env",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "invalid-env")
 
                     expect(result.environment).toBe("dev")
                     expect(result.source).toBe("default")
@@ -373,16 +338,10 @@ describe("getEnvironment", () => {
 
     describe("Environment Validation", () => {
         it("should accept valid environments", async () => {
-            const validEnvs: Environment[] = [
-                "local",
-                "dev",
-                "qa",
-                "staging",
-                "prod",
-            ]
+            const validEnvs: Environment[] = ["local", "dev", "staging", "prod"]
 
             for (const env of validEnvs) {
-                const result = await getEnvironment("WEB", env, mockLogger)
+                const result = await getEnvironment("WEB", env)
                 expect(result.environment).toBe(env)
                 expect(result.source).toBe("build-time")
             }
@@ -392,13 +351,14 @@ describe("getEnvironment", () => {
             const invalidEnvs = [
                 "development",
                 "production",
+                "qa",
                 "test",
                 "",
                 "random",
             ]
 
             for (const env of invalidEnvs) {
-                const result = await getEnvironment("WEB", env, mockLogger)
+                const result = await getEnvironment("WEB", env)
                 expect(result.environment).toBe("dev")
                 expect(result.source).toBe("default")
             }
@@ -423,33 +383,33 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            await getEnvironment("FIRE_TV", undefined, mockLogger)
+            await getEnvironment("FIRE_TV", undefined)
 
-            expect(mockLogger.info).toHaveBeenCalledWith(
+            expect(logger.info).toHaveBeenCalledWith(
                 '[Shell] Environment: "prod" (source: native BuildConfig.ENVIRONMENT="production")'
             )
         })
 
         it("should log build-time environment source", async () => {
-            await getEnvironment("SAMSUNG_TV", "staging", mockLogger)
+            await getEnvironment("SAMSUNG_TV", "staging")
 
-            expect(mockLogger.info).toHaveBeenCalledWith(
+            expect(logger.info).toHaveBeenCalledWith(
                 '[Shell] Environment: "staging" (source: build-time CLI injection)'
             )
         })
 
         it("should warn when falling back to default", async () => {
-            await getEnvironment("LG_TV", undefined, mockLogger)
+            await getEnvironment("LG_TV", undefined)
 
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 '[Shell] Environment: "dev" (source: default fallback - no native or build-time env found)'
             )
         })
 
         it("should warn when native fails and falls back", async () => {
-            await getEnvironment("FIRE_TV", "prod", mockLogger)
+            await getEnvironment("FIRE_TV", "prod")
 
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 "[Shell] Failed to read environment from native, falling back to build-time"
             )
         })

package/src/getEnvironment.ts

@@ -1,6 +1,6 @@
-import { defaultLogger, type Logger } from "./logger"
+import { logger } from "./logger"
 
-export type Environment = "local" | "dev" | "qa" | "staging" | "prod"
+export type Environment = "local" | "dev" | "staging" | "prod"
 export type EnvironmentSource = "native" | "build-time" | "default"
 
 export interface EnvironmentResult {
@@ -19,21 +19,20 @@ export interface EnvironmentResult {
  * This ensures production APKs cannot accidentally run dev VWR,
  * since the native Android build variant determines the environment.
  *
- * @param platform - Platform identifier ('FIRE_TV', 'SAMSUNG_TV', 'LG_TV', 'MOBILE', 'WEB')
+ * @param platform - Platform identifier ('FIRE_TV', 'SAMSUNG_TV', 'LG_TV', 'ANDROID_MOBILE', 'IOS_MOBILE', 'WEB')
  * @param buildTimeEnv - Optional build-time injected environment (from CLI)
  * @param logger - Optional logger for reporting
  * @returns Environment result with source information for logging
  */
 export async function getEnvironment(
     platform: string,
-    buildTimeEnv: string | undefined,
-    logger: Logger = defaultLogger
+    buildTimeEnv: string | undefined
 ): Promise<EnvironmentResult> {
     const normalizedPlatform = platform.toUpperCase()
 
     // For Fire TV, try to read from native first (safest - prevents env mismatch)
     if (normalizedPlatform === "FIRE_TV") {
-        const nativeEnv = await getFireTVEnvironment(logger)
+        const nativeEnv = await getFireTVEnvironment()
         if (nativeEnv) {
             const mapped = mapNativeEnvironment(nativeEnv)
             logger.info(
@@ -72,7 +71,7 @@ export async function getEnvironment(
 /**
  * Read environment from Fire TV native shell via Capacitor plugin.
  */
-async function getFireTVEnvironment(logger: Logger): Promise<string | null> {
+async function getFireTVEnvironment(): Promise<string | null> {
     try {
         if (
             !window.Capacitor?.Plugins?.DeviceInfo?.getNativeShellAppEnvironment
@@ -113,12 +112,17 @@ async function getFireTVEnvironment(logger: Logger): Promise<string | null> {
  * - "dev"
  * - "staging"
  * - "prod"
+ *
+ * Note: Legacy "qa" values are mapped to "staging".
  */
 function mapNativeEnvironment(nativeEnv: string): Environment {
     const normalized = nativeEnv.toLowerCase()
     switch (normalized) {
         case "development":
             return "dev"
+        case "qa":
+            // Legacy: map qa to staging
+            return "staging"
         case "staging":
             return "staging"
         case "production":
@@ -133,7 +137,7 @@ function mapNativeEnvironment(nativeEnv: string): Environment {
 }
 
 function isValidEnvironment(env: string): boolean {
-    return ["local", "dev", "qa", "staging", "prod"].includes(env)
+    return ["local", "dev", "staging", "prod"].includes(env)
 }
 
 // Note: Window.Capacitor type is declared in getDeviceId.ts

package/src/getShellVersion.test.ts

@@ -1,6 +1,17 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 
 import { getShellVersion } from "./getShellVersion"
+import { logger } from "./logger"
+
+vi.mock("./logger", () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+        child: vi.fn(),
+    },
+}))
 
 describe("getShellVersion", () => {
     const originalLocation = window.location
@@ -220,11 +231,130 @@ describe("getShellVersion", () => {
         })
     })
 
-    describe("Mobile", () => {
-        it("returns unknown (not yet implemented)", async () => {
-            const version = await getShellVersion("MOBILE")
+    describe("Mobile (iOS)", () => {
+        afterEach(() => {
+            delete (window as any).iosAppContext
+        })
+
+        it("returns version from iosAppContext.appVersion", async () => {
+            ;(window as any).iosAppContext = {
+                appVersion: "2.1.0",
+            }
+
+            const version = await getShellVersion("IOS_MOBILE")
+
+            expect(version).toBe("2.1.0")
+        })
+
+        it("returns unknown when iosAppContext is not available", async () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => {})
+
+            const version = await getShellVersion("IOS_MOBILE")
 
             expect(version).toBe("unknown")
+
+            consoleWarnSpy.mockRestore()
+        })
+
+        it("returns unknown when appVersion is empty", async () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => {})
+
+            ;(window as any).iosAppContext = {
+                appVersion: "   ",
+            }
+
+            const version = await getShellVersion("IOS_MOBILE")
+
+            expect(version).toBe("unknown")
+
+            consoleWarnSpy.mockRestore()
+        })
+
+        it("is case insensitive", async () => {
+            ;(window as any).iosAppContext = {
+                appVersion: "2.2.0",
+            }
+
+            const version = await getShellVersion("ios_mobile")
+
+            expect(version).toBe("2.2.0")
+        })
+    })
+
+    describe("Mobile (Android)", () => {
+        afterEach(() => {
+            delete (window as any).androidAppContext
+        })
+
+        it("returns version from androidAppContext.appVersion", async () => {
+            ;(window as any).androidAppContext = {
+                appVersion: "3.1.0",
+            }
+
+            const version = await getShellVersion("ANDROID_MOBILE")
+
+            expect(version).toBe("3.1.0")
+        })
+
+        it("returns unknown when androidAppContext is not available", async () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => {})
+
+            const version = await getShellVersion("ANDROID_MOBILE")
+
+            expect(version).toBe("unknown")
+
+            consoleWarnSpy.mockRestore()
+        })
+
+        it("returns unknown when appVersion is empty", async () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => {})
+
+            ;(window as any).androidAppContext = {
+                appVersion: "",
+            }
+
+            const version = await getShellVersion("ANDROID_MOBILE")
+
+            expect(version).toBe("unknown")
+
+            consoleWarnSpy.mockRestore()
+        })
+
+        it("is case insensitive", async () => {
+            ;(window as any).androidAppContext = {
+                appVersion: "3.2.0",
+            }
+
+            const version = await getShellVersion("android_mobile")
+
+            expect(version).toBe("3.2.0")
+        })
+
+        it("prefers iOS context when both are available", async () => {
+            ;(window as any).iosAppContext = {
+                appVersion: "1.0.0-ios",
+            }
+            ;(window as any).androidAppContext = {
+                appVersion: "1.0.0-android",
+            }
+
+            // When calling with IOS_MOBILE, should get iOS version
+            const iosVersion = await getShellVersion("IOS_MOBILE")
+            expect(iosVersion).toBe("1.0.0-ios")
+
+            // When calling with ANDROID_MOBILE, should still check iOS first (matching SDK behavior)
+            const androidVersion = await getShellVersion("ANDROID_MOBILE")
+            expect(androidVersion).toBe("1.0.0-ios")
+
+            delete (window as any).iosAppContext
         })
     })
 
@@ -250,10 +380,6 @@ describe("getShellVersion", () => {
 
     describe("Error Handling", () => {
         it("returns unknown and logs warning on error", async () => {
-            const consoleWarnSpy = vi
-                .spyOn(console, "warn")
-                .mockImplementation(() => {})
-
             // Force an error by making tizen.application.getAppInfo throw
             ;(window as any).tizen = {
                 application: {
@@ -266,12 +392,11 @@ describe("getShellVersion", () => {
             const version = await getShellVersion("SAMSUNG_TV")
 
             expect(version).toBe("unknown")
-            expect(consoleWarnSpy).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 "[Shell] Failed to get shell version:",
                 { error: expect.any(Error) }
             )
 
-            consoleWarnSpy.mockRestore()
             delete (window as any).tizen
         })
     })