@volley/vwr-loader 1.0.5 → 1.1.0

package/src/getEnvironment.test.ts

@@ -0,0 +1,479 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+
+import { type Environment, getEnvironment } from "./getEnvironment"
+
+describe("getEnvironment", () => {
+    const mockLogger = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    }
+
+    beforeEach(() => {
+        vi.clearAllMocks()
+        mockLogger.info.mockClear()
+        mockLogger.warn.mockClear()
+        mockLogger.error.mockClear()
+        // Clean up window properties
+        delete (window as any).Capacitor
+    })
+
+    afterEach(() => {
+        vi.restoreAllMocks()
+        delete (window as any).Capacitor
+    })
+
+    describe("Fire TV - Native Environment Detection", () => {
+        it("should read environment from native BuildConfig for Fire TV", async () => {
+            // Setup Capacitor plugin mock
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "development",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("native")
+            expect(mockLogger.info).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    'Environment: "dev" (source: native BuildConfig.ENVIRONMENT="development")'
+                )
+            )
+        })
+
+        it("should map 'production' to 'prod'", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "production",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("prod")
+            expect(result.source).toBe("native")
+        })
+
+        it("should map 'staging' to 'staging'", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "staging",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            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,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("staging")
+            expect(result.source).toBe("native")
+        })
+
+        it("should handle native env already in vwr format (dev)", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "dev",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("native")
+        })
+
+        it("should fallback to dev when native returns unknown value", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "unknown-env",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("native")
+        })
+
+        it("should fallback to build-time when native plugin unavailable", async () => {
+            // No Capacitor plugin available
+            const result = await getEnvironment(
+                "FIRE_TV",
+                "staging",
+                mockLogger
+            )
+
+            expect(result.environment).toBe("staging")
+            expect(result.source).toBe("build-time")
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    "Failed to read environment from native, falling back to build-time"
+                )
+            )
+        })
+
+        it("should fallback to build-time when native plugin throws error", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockRejectedValue(
+                                    new Error("Native plugin error")
+                                ),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment("FIRE_TV", "prod", mockLogger)
+
+            expect(result.environment).toBe("prod")
+            expect(result.source).toBe("build-time")
+            expect(mockLogger.error).toHaveBeenCalled()
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                expect.stringContaining("falling back to build-time")
+            )
+        })
+
+        it("should fallback to build-time when native returns empty", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment("FIRE_TV", "dev", mockLogger)
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("build-time")
+            expect(mockLogger.error).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    "DeviceInfo.getNativeShellAppEnvironment returned empty"
+                )
+            )
+        })
+
+        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
+            )
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("default")
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    'Environment: "dev" (source: default fallback'
+                )
+            )
+        })
+
+        it("should be case-insensitive for Fire TV platform", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "production",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result1 = await getEnvironment(
+                "fire_tv",
+                undefined,
+                mockLogger
+            )
+            const result2 = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result1.environment).toBe("prod")
+            expect(result2.environment).toBe("prod")
+        })
+    })
+
+    describe("Non-Fire TV Platforms - Build-time Environment", () => {
+        const platforms = ["SAMSUNG_TV", "LG_TV", "MOBILE", "WEB"]
+
+        platforms.forEach((platform) => {
+            describe(`${platform}`, () => {
+                it("should use build-time environment when provided", async () => {
+                    const result = await getEnvironment(
+                        platform,
+                        "staging",
+                        mockLogger
+                    )
+
+                    expect(result.environment).toBe("staging")
+                    expect(result.source).toBe("build-time")
+                    expect(mockLogger.info).toHaveBeenCalledWith(
+                        expect.stringContaining(
+                            'Environment: "staging" (source: build-time CLI injection)'
+                        )
+                    )
+                })
+
+                it("should use build-time 'prod' environment", async () => {
+                    const result = await getEnvironment(
+                        platform,
+                        "prod",
+                        mockLogger
+                    )
+
+                    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
+                    )
+
+                    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
+                    )
+
+                    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
+                    )
+
+                    expect(result.environment).toBe("dev")
+                    expect(result.source).toBe("default")
+                    expect(mockLogger.warn).toHaveBeenCalledWith(
+                        expect.stringContaining(
+                            'Environment: "dev" (source: default fallback'
+                        )
+                    )
+                })
+
+                it("should fallback to default when build-time is invalid", async () => {
+                    const result = await getEnvironment(
+                        platform,
+                        "invalid-env",
+                        mockLogger
+                    )
+
+                    expect(result.environment).toBe("dev")
+                    expect(result.source).toBe("default")
+                })
+            })
+        })
+    })
+
+    describe("Environment Validation", () => {
+        it("should accept valid environments", async () => {
+            const validEnvs: Environment[] = ["local", "dev", "staging", "prod"]
+
+            for (const env of validEnvs) {
+                const result = await getEnvironment("WEB", env, mockLogger)
+                expect(result.environment).toBe(env)
+                expect(result.source).toBe("build-time")
+            }
+        })
+
+        it("should reject invalid environments", async () => {
+            const invalidEnvs = [
+                "development",
+                "production",
+                "qa",
+                "test",
+                "",
+                "random",
+            ]
+
+            for (const env of invalidEnvs) {
+                const result = await getEnvironment("WEB", env, mockLogger)
+                expect(result.environment).toBe("dev")
+                expect(result.source).toBe("default")
+            }
+        })
+    })
+
+    describe("Logging", () => {
+        it("should log native environment source", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "production",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            await getEnvironment("FIRE_TV", undefined, mockLogger)
+
+            expect(mockLogger.info).toHaveBeenCalledWith(
+                '[Shell] Environment: "prod" (source: native BuildConfig.ENVIRONMENT="production")'
+            )
+        })
+
+        it("should log build-time environment source", async () => {
+            await getEnvironment("SAMSUNG_TV", "staging", mockLogger)
+
+            expect(mockLogger.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)
+
+            expect(mockLogger.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)
+
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                "[Shell] Failed to read environment from native, falling back to build-time"
+            )
+        })
+    })
+})

package/src/getEnvironment.ts

@@ -19,7 +19,7 @@ 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
@@ -48,13 +48,16 @@ export async function getEnvironment(
     }
 
     // Build-time injection (CLI --env flag)
-    if (buildTimeEnv && isValidEnvironment(buildTimeEnv)) {
-        logger.info(
-            `[Shell] Environment: "${buildTimeEnv}" (source: build-time CLI injection)`
-        )
-        return {
-            environment: buildTimeEnv as Environment,
-            source: "build-time",
+    if (buildTimeEnv) {
+        const normalizedBuildTimeEnv = buildTimeEnv.toLowerCase()
+        if (isValidEnvironment(normalizedBuildTimeEnv)) {
+            logger.info(
+                `[Shell] Environment: "${normalizedBuildTimeEnv}" (source: build-time CLI injection)`
+            )
+            return {
+                environment: normalizedBuildTimeEnv as Environment,
+                source: "build-time",
+            }
         }
     }
 
@@ -110,12 +113,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":

package/src/getShellVersion.test.ts

@@ -220,11 +220,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
         })
     })
 
@@ -268,7 +387,7 @@ describe("getShellVersion", () => {
             expect(version).toBe("unknown")
             expect(consoleWarnSpy).toHaveBeenCalledWith(
                 "[Shell] Failed to get shell version:",
-                expect.any(Error)
+                { error: expect.any(Error) }
             )
 
             consoleWarnSpy.mockRestore()