@planet-matrix/mobius-model 0.4.0 → 0.6.0

package/tests/unit/environment/feature.spec.ts

@@ -0,0 +1,388 @@
+import { afterEach, expect, test, vi } from "vitest"
+import {
+  ensureCSS,
+  ensureClipboard,
+  ensureDocument,
+  ensureNavigator,
+  ensurePermissions,
+  ensureProcess,
+  getCSS,
+  getClipboard,
+  getDocument,
+  getFeatureFlags,
+  getFeatureRegistryItem,
+  getNavigator,
+  getPermissions,
+  getProcess,
+  isFeatureRegistered,
+  isSatisfiesFeature,
+  isSatisfiesFeatures,
+  listFeatures,
+  registerFeature,
+  supportCSS,
+  supportClipboard,
+  supportDocument,
+  supportNavigator,
+  supportPermissions,
+  supportProcess,
+  unregisterFeature,
+  useCSS,
+  useClipboard,
+  useDocument,
+  useNavigator,
+  usePermissions,
+  useProcess,
+} from "#Source/environment/feature.ts"
+
+const internalBuiltInFeatures = ["process", "navigator", "clipboard", "permissions", "document", "css"]
+
+afterEach(() => {
+  for (const featureName of listFeatures()) {
+    if (internalBuiltInFeatures.includes(featureName) === false) {
+      unregisterFeature(featureName)
+    }
+  }
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+test("isFeatureRegistered detects existing and missing feature", () => {
+  expect(isFeatureRegistered("process")).toBe(true)
+  expect(isFeatureRegistered("custom-feature")).toBe(false)
+})
+
+test("registerFeature stores custom feature detector", () => {
+  registerFeature({
+    feature: "custom-register",
+    detect: () => true,
+  })
+
+  expect(isFeatureRegistered("custom-register")).toBe(true)
+})
+
+test("unregisterFeature removes previously registered feature", () => {
+  registerFeature({
+    feature: "custom-remove",
+    detect: () => true,
+  })
+  unregisterFeature("custom-remove")
+
+  expect(isFeatureRegistered("custom-remove")).toBe(false)
+})
+
+test("listFeatures returns all registered feature keys", () => {
+  registerFeature({
+    feature: "custom-list",
+    detect: () => true,
+  })
+  const result = listFeatures()
+
+  expect(result).toContain("process")
+  expect(result).toContain("custom-list")
+})
+
+test("getFeatureRegistryItem returns registry item by key", () => {
+  registerFeature({
+    feature: "custom-item",
+    detect: () => false,
+  })
+
+  const found = getFeatureRegistryItem("custom-item")
+  const missing = getFeatureRegistryItem("custom-missing")
+
+  expect(found?.feature).toBe("custom-item")
+  expect(found?.detect()).toBe(false)
+  expect(missing).toBeUndefined()
+})
+
+test("getFeatureFlags resolves detector outputs", () => {
+  registerFeature({
+    feature: "custom-flags",
+    detect: () => true,
+  })
+  const flags = getFeatureFlags()
+
+  expect(flags.process).toBe(true)
+  expect(flags["custom-flags"]).toBe(true)
+})
+
+test("isSatisfiesFeature checks single feature and throws for missing", () => {
+  expect(isSatisfiesFeature("process")).toBe(true)
+  expect(() => isSatisfiesFeature("feature-not-found")).toThrow(
+    "is not registered",
+  )
+})
+
+test("isSatisfiesFeatures checks multi-feature conditions and throws for missing", () => {
+  expect(isSatisfiesFeatures({ process: true })).toBe(true)
+  expect(isSatisfiesFeatures({ process: false })).toBe(false)
+  expect(() => isSatisfiesFeatures({ "feature-not-found": true })).toThrow(
+    "is not registered",
+  )
+})
+
+test("supportProcess reflects process availability", () => {
+  expect(supportProcess()).toBe(true)
+  vi.stubGlobal("process", undefined)
+  expect(supportProcess()).toBe(false)
+})
+
+test("getProcess returns the global process object", () => {
+  expect(getProcess()).toBe(globalThis.process)
+})
+
+test("ensureProcess returns process or throws", () => {
+  expect(ensureProcess()).toBe(globalThis.process)
+
+  vi.stubGlobal("process", undefined)
+
+  expect(() => ensureProcess()).toThrow(
+    "The process object is not supported in the current environment.",
+  )
+})
+
+test("useProcess chooses process or fallback branch", () => {
+  const withProcess = useProcess(
+    (processObject) => typeof processObject.env,
+    () => "fallback",
+  )
+  vi.stubGlobal("process", undefined)
+  const withoutProcess = useProcess(
+    (processObject) => typeof processObject.env,
+    () => "fallback",
+  )
+
+  expect(withProcess).toBe("object")
+  expect(withoutProcess).toBe("fallback")
+})
+
+test("supportNavigator reflects navigator availability", () => {
+  vi.stubGlobal("navigator", { language: "en-US" })
+  expect(supportNavigator()).toBe(true)
+
+  vi.stubGlobal("navigator", undefined)
+  expect(supportNavigator()).toBe(false)
+})
+
+test("getNavigator returns the global navigator object", () => {
+  const navigatorObject = { language: "en-US" }
+  vi.stubGlobal("navigator", navigatorObject)
+
+  expect(getNavigator()).toBe(navigatorObject)
+})
+
+test("ensureNavigator returns navigator or throws", () => {
+  const navigatorObject = { language: "en-US" }
+  vi.stubGlobal("navigator", navigatorObject)
+
+  expect(ensureNavigator()).toBe(navigatorObject)
+
+  vi.stubGlobal("navigator", undefined)
+
+  expect(() => ensureNavigator()).toThrow(
+    "The navigator object is not supported in the current environment.",
+  )
+})
+
+test("useNavigator chooses navigator or fallback branch", () => {
+  vi.stubGlobal("navigator", { language: "en-US", languages: ["en-US"] })
+  const withNavigator = useNavigator(
+    (navigatorObject) => navigatorObject.language,
+    () => "fallback",
+  )
+
+  vi.stubGlobal("navigator", undefined)
+  const withoutNavigator = useNavigator(
+    (navigatorObject) => navigatorObject.language,
+    () => "fallback",
+  )
+
+  expect(withNavigator).toBe("en-US")
+  expect(withoutNavigator).toBe("fallback")
+})
+
+test("supportClipboard reflects navigator.clipboard availability", () => {
+  vi.stubGlobal("navigator", { clipboard: { writeText: vi.fn() } })
+  expect(supportClipboard()).toBe(true)
+
+  vi.stubGlobal("navigator", { language: "en-US" })
+  expect(supportClipboard()).toBe(false)
+
+  vi.stubGlobal("navigator", undefined)
+  expect(supportClipboard()).toBe(false)
+})
+
+test("getClipboard returns the navigator clipboard object", () => {
+  const clipboardObject = { writeText: vi.fn() }
+  vi.stubGlobal("navigator", { clipboard: clipboardObject })
+
+  expect(getClipboard()).toBe(clipboardObject)
+})
+
+test("ensureClipboard returns clipboard or throws", () => {
+  const clipboardObject = { writeText: vi.fn() }
+  vi.stubGlobal("navigator", { clipboard: clipboardObject })
+
+  expect(ensureClipboard()).toBe(clipboardObject)
+
+  vi.stubGlobal("navigator", { language: "en-US" })
+
+  expect(() => ensureClipboard()).toThrow(
+    "The clipboard API is not supported in the current environment.",
+  )
+})
+
+test("useClipboard chooses clipboard or fallback branch", () => {
+  vi.stubGlobal("navigator", { clipboard: { writeText: vi.fn() } })
+  const withClipboard = useClipboard(
+    (clipboardObject) => typeof clipboardObject.writeText === "function",
+    () => false,
+  )
+
+  vi.stubGlobal("navigator", { language: "en-US" })
+  const withoutClipboard = useClipboard(
+    (clipboardObject) => typeof clipboardObject.writeText === "function",
+    () => false,
+  )
+
+  expect(withClipboard).toBe(true)
+  expect(withoutClipboard).toBe(false)
+})
+
+test("supportPermissions reflects navigator.permissions availability", () => {
+  vi.stubGlobal("navigator", { permissions: { query: vi.fn() } })
+  expect(supportPermissions()).toBe(true)
+
+  vi.stubGlobal("navigator", { language: "en-US" })
+  expect(supportPermissions()).toBe(false)
+
+  vi.stubGlobal("navigator", undefined)
+  expect(supportPermissions()).toBe(false)
+})
+
+test("getPermissions returns the navigator permissions object", () => {
+  const permissionsObject = { query: vi.fn() }
+  vi.stubGlobal("navigator", { permissions: permissionsObject })
+
+  expect(getPermissions()).toBe(permissionsObject)
+})
+
+test("ensurePermissions returns permissions or throws", () => {
+  const permissionsObject = { query: vi.fn() }
+  vi.stubGlobal("navigator", { permissions: permissionsObject })
+
+  expect(ensurePermissions()).toBe(permissionsObject)
+
+  vi.stubGlobal("navigator", { language: "en-US" })
+
+  expect(() => ensurePermissions()).toThrow(
+    "The permissions API is not supported in the current environment.",
+  )
+})
+
+test("usePermissions chooses permissions or fallback branch", () => {
+  vi.stubGlobal("navigator", { permissions: { query: vi.fn() } })
+  const withPermissions = usePermissions(
+    (permissionsObject) => typeof permissionsObject.query === "function",
+    () => false,
+  )
+
+  vi.stubGlobal("navigator", { language: "en-US" })
+  const withoutPermissions = usePermissions(
+    (permissionsObject) => typeof permissionsObject.query === "function",
+    () => false,
+  )
+
+  expect(withPermissions).toBe(true)
+  expect(withoutPermissions).toBe(false)
+})
+
+test("supportDocument reflects document availability", () => {
+  vi.stubGlobal("document", { title: "doc" })
+  expect(supportDocument()).toBe(true)
+
+  vi.stubGlobal("document", undefined)
+  expect(supportDocument()).toBe(false)
+})
+
+test("getDocument returns the global document object", () => {
+  const documentObject = { title: "mobius" }
+  vi.stubGlobal("document", documentObject)
+
+  expect(getDocument()).toBe(documentObject)
+})
+
+test("ensureDocument returns document or throws", () => {
+  const documentObject = { title: "mobius" }
+  vi.stubGlobal("document", documentObject)
+
+  expect(ensureDocument()).toBe(documentObject)
+
+  vi.stubGlobal("document", undefined)
+
+  expect(() => ensureDocument()).toThrow(
+    "The document object is not supported in the current environment.",
+  )
+})
+
+test("useDocument chooses document or fallback branch", () => {
+  vi.stubGlobal("document", { title: "mobius" })
+  const withDocument = useDocument(
+    (documentObject) => documentObject.title,
+    () => "fallback",
+  )
+
+  vi.stubGlobal("document", undefined)
+  const withoutDocument = useDocument(
+    (documentObject) => documentObject.title,
+    () => "fallback",
+  )
+
+  expect(withDocument).toBe("mobius")
+  expect(withoutDocument).toBe("fallback")
+})
+
+test("supportCSS reflects CSS availability", () => {
+  vi.stubGlobal("CSS", { supports: () => true })
+  expect(supportCSS()).toBe(true)
+
+  vi.stubGlobal("CSS", undefined)
+  expect(supportCSS()).toBe(false)
+})
+
+test("getCSS returns the global CSS object", () => {
+  const cssObject = { supports: vi.fn(() => true) }
+  vi.stubGlobal("CSS", cssObject)
+
+  expect(getCSS()).toBe(cssObject)
+})
+
+test("ensureCSS returns CSS or throws", () => {
+  const cssObject = { supports: vi.fn(() => true) }
+  vi.stubGlobal("CSS", cssObject)
+
+  expect(ensureCSS()).toBe(cssObject)
+
+  vi.stubGlobal("CSS", undefined)
+
+  expect(() => ensureCSS()).toThrow(
+    "The CSS object is not supported in the current environment.",
+  )
+})
+
+test("useCSS chooses CSS or fallback branch", () => {
+  vi.stubGlobal("CSS", { supports: () => true })
+  const withCSS = useCSS(
+    (cssObject) => cssObject.supports("display", "grid"),
+    () => false,
+  )
+
+  vi.stubGlobal("CSS", undefined)
+  const withoutCSS = useCSS(
+    (cssObject) => cssObject.supports("display", "grid"),
+    () => false,
+  )
+
+  expect(withCSS).toBe(true)
+  expect(withoutCSS).toBe(false)
+})

package/tests/unit/environment/geo.spec.ts

@@ -0,0 +1,111 @@
+import { expect, test, vi } from "vitest"
+
+import {
+  getGeoInfo,
+  getGeoInfoFromCloudflare,
+  getGeoInfoFromIpapi,
+  getGeoInfoFromIpify,
+} from "#Source/environment/geo.ts"
+
+test("getGeoInfoFromCloudflare parses key-value trace response", async () => {
+  const mockFetch = async (): Promise<{ text: () => Promise<string> }> => {
+    const response = await Promise.resolve({
+      text: async (): Promise<string> => {
+        return await Promise.resolve("ip=1.2.3.4\nloc=US\nhttp=http/2\n")
+      }
+    })
+    return response
+  }
+  vi.stubGlobal("fetch", vi.fn(mockFetch))
+
+  const geo = await getGeoInfoFromCloudflare()
+
+  expect(geo.ip).toBe("1.2.3.4")
+  expect(geo.loc).toBe("US")
+  expect(geo.http).toBe("http/2")
+
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+test("getGeoInfoFromIpapi returns parsed JSON payload", async () => {
+  const mockFetch = async (): Promise<{ json: () => Promise<{ ip: string; country: string }> }> => {
+    const response = await Promise.resolve({
+      json: async (): Promise<{ ip: string; country: string }> => {
+        return await Promise.resolve({ ip: "5.6.7.8", country: "US" })
+      }
+    })
+    return response
+  }
+  vi.stubGlobal("fetch", vi.fn(mockFetch))
+
+  const geo = await getGeoInfoFromIpapi()
+
+  expect(geo.ip).toBe("5.6.7.8")
+  expect(geo.country).toBe("US")
+
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+test("getGeoInfoFromIpify returns public IP payload", async () => {
+  const mockFetch = async (): Promise<{ json: () => Promise<{ ip: string }> }> => {
+    const response = await Promise.resolve({
+      json: async (): Promise<{ ip: string }> => {
+        return await Promise.resolve({ ip: "9.9.9.9" })
+      }
+    })
+    return response
+  }
+  vi.stubGlobal("fetch", vi.fn(mockFetch))
+
+  const geo = await getGeoInfoFromIpify()
+
+  expect(geo.ip).toBe("9.9.9.9")
+
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+test("getGeoInfo aggregates results from all providers", async () => {
+  // oxlint-disable-next-line require-await explicit-function-return-type
+  const mockFetch = async (input: URL | RequestInfo) => {
+    let url: string
+    if (input instanceof URL) {
+      url = input.toString()
+    } else if (typeof input === "string") {
+      url = input
+    } else {
+      url = input.url
+    }
+    if (url.includes("cloudflare")) {
+      return {
+        text: async (): Promise<string> => {
+          return await Promise.resolve("ip=1.1.1.1\nloc=US\n")
+        }
+      }
+    }
+    if (url.includes("ipapi")) {
+      return {
+        json: async (): Promise<{ ip: string; country: string }> => {
+          return await Promise.resolve({ ip: "2.2.2.2", country: "US" })
+        }
+      }
+    }
+    return {
+      json: async (): Promise<{ ip: string }> => {
+        return await Promise.resolve({ ip: "3.3.3.3" })
+      }
+    }
+  }
+  vi.stubGlobal("fetch", vi.fn(mockFetch))
+
+  const geo = await getGeoInfo()
+
+  expect(geo.cloudflare.ip).toBe("1.1.1.1")
+  expect(geo.ipapi.ip).toBe("2.2.2.2")
+  expect(geo.ipify.ip).toBe("3.3.3.3")
+
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})