@knpkv/atlassian-common 0.4.0 → 1.0.0

package/test/OAuthEndpoints.test.ts

@@ -1,25 +1,30 @@
+import * as NodeCrypto from "@effect/platform-node/NodeCrypto"
 import { it as effectIt } from "@effect/vitest"
 import * as Effect from "effect/Effect"
 import { describe, expect, it } from "vitest"
 import { AUTH_URL, buildAuthUrl, computeCodeChallenge, generateCodeVerifier } from "../src/auth/OAuthEndpoints.js"
 
+const withCrypto = <A, E, R>(effect: Effect.Effect<A, E, R>) => effect.pipe(Effect.provide(NodeCrypto.layer))
+
 describe("OAuthEndpoints", () => {
   // ---- PKCE ----
 
   describe("generateCodeVerifier", () => {
     // 32 random bytes base64url-encoded = 43 chars; verifies output shape for RFC 7636 compliance
-    it("returns a base64url string of 43 characters (32 random bytes)", () => {
-      const verifier = generateCodeVerifier()
-      expect(verifier).toHaveLength(43)
-      expect(verifier).toMatch(/^[A-Za-z0-9_-]+$/)
-    })
+    effectIt.effect("returns a base64url string of 43 characters (32 random bytes)", () =>
+      Effect.gen(function*() {
+        const verifier = yield* generateCodeVerifier()
+        expect(verifier).toHaveLength(43)
+        expect(verifier).toMatch(/^[A-Za-z0-9_-]+$/)
+      }).pipe(withCrypto))
 
     // PKCE verifiers must be unique per auth request — reuse enables replay attacks
-    it("produces unique values", () => {
-      const a = generateCodeVerifier()
-      const b = generateCodeVerifier()
-      expect(a).not.toBe(b)
-    })
+    effectIt.effect("produces unique values", () =>
+      Effect.gen(function*() {
+        const a = yield* generateCodeVerifier()
+        const b = yield* generateCodeVerifier()
+        expect(a).not.toBe(b)
+      }).pipe(withCrypto))
   })
 
   describe("computeCodeChallenge", () => {
@@ -30,23 +35,23 @@ describe("OAuthEndpoints", () => {
         const expected = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM"
         const challenge = yield* computeCodeChallenge(verifier)
         expect(challenge).toBe(expected)
-      }))
+      }).pipe(withCrypto))
 
     // Same verifier must always produce same challenge — server verifies this on token exchange
     effectIt.effect("is deterministic", () =>
       Effect.gen(function*() {
-        const v = generateCodeVerifier()
+        const v = yield* generateCodeVerifier()
         const a = yield* computeCodeChallenge(v)
         const b = yield* computeCodeChallenge(v)
         expect(a).toBe(b)
-      }))
+      }).pipe(withCrypto))
 
     // base64url must not contain +, /, = — these break URL query params
     effectIt.effect("produces base64url output (no +, /, =)", () =>
       Effect.gen(function*() {
         const challenge = yield* computeCodeChallenge("test-verifier-string")
         expect(challenge).toMatch(/^[A-Za-z0-9_-]+$/)
-      }))
+      }).pipe(withCrypto))
   })
 
   // ---- buildAuthUrl ----
@@ -103,7 +108,7 @@ describe("OAuthEndpoints", () => {
           const parsed = new URL(url)
           expect(parsed.searchParams.get("code_challenge")).toBe(challenge)
           expect(parsed.searchParams.get("code_challenge_method")).toBe("S256")
-        })
+        }).pipe(withCrypto)
     )
   })
 })

package/test/OAuthOperations.test.ts

@@ -1,6 +1,7 @@
 import { describe, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import { TestClock } from "effect/testing"
 import type { HttpClientRequest } from "effect/unstable/http"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { expect } from "vitest"
@@ -58,6 +59,8 @@ const oauthConfig: OAuthConfig = {
   clientSecret: "csecret"
 }
 
+const TEST_NOW = Date.parse("2026-01-01T00:00:00.000Z")
+
 const oauthToken: OAuthToken = {
   access_token: "old-access",
   refresh_token: "old-refresh",
@@ -221,6 +224,7 @@ describe("OAuthOperations", () => {
     // Verifies grant_type=refresh_token is sent and returned token preserves cloud_id/site_url from original
     it.effect("sends refresh_token and returns updated OAuthToken", () =>
       Effect.gen(function*() {
+        yield* TestClock.setTime(TEST_NOW)
         const { capturedRequests, mockClient } = createMockHttpClient([
           { status: 200, body: { ...validTokenBody, access_token: "new-access", refresh_token: "new-refresh" } }
         ])
@@ -232,7 +236,7 @@ describe("OAuthOperations", () => {
         // preserves existing fields
         expect(result.cloud_id).toBe("cloud-1")
         expect(result.site_url).toBe("https://site.atlassian.net")
-        expect(result.expires_at).toBeGreaterThan(Date.now())
+        expect(result.expires_at).toBe(TEST_NOW + validTokenBody.expires_in * 1000)
 
         const req = capturedRequests[0]!
         const body = yield* req.body._tag === "Uint8Array"