// `weft test tests/stripe.test.weft`: what needs no server. packages/integration/stripe runs the rest against stripe-mock. import { assert, assertEq } from "std/testing" import { encodeComponent, encodeForm } from "../lib/form" import { constantTimeEqual, hmacSha256, sha256 } from "../lib/sha256" import { client, errorMessage, failureFrom, idOf, metadata } from "../stripe" import { signature, verify } from "../webhooks" import type { WebhookError } from "../webhooks" import { parse } from "std/json" fn hex(s: string): Bytes { return try Bytes.fromHex(s) else Bytes.of([]) } // ---- SHA-256 and HMAC: FIPS 180-4's and RFC 4231's own vectors ---- test "sha256 vectors" { assertEq( sha256(Bytes.fromUtf8("")).toHex(), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", ) assertEq( sha256(Bytes.fromUtf8("abc")).toHex(), "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", ) assertEq( sha256(Bytes.fromUtf8("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")).toHex(), "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1", ) assertEq( sha256(Bytes.fromUtf8("a".repeat(1000))).toHex(), "41edece42d63e8d9bf515a9ba6932e1c20cbc9f5a5d134645adb5db1b9737ea3", ) } test "padding at every block boundary" { // Lengths around 55, 56 and 64 are where the padding spills into another block. assertEq( sha256(Bytes.fromUtf8("a".repeat(55))).toHex(), "9f4390f8d30c2dd92ec9f095b65e2b9ae9b0a925a5258e241c9f1e910f734318", ) assertEq( sha256(Bytes.fromUtf8("a".repeat(56))).toHex(), "b35439a4ac6f0948b6d6f9e3c6af0f5f590ce20f1bde7090ef7970686ec6738a", ) assertEq( sha256(Bytes.fromUtf8("a".repeat(64))).toHex(), "ffe054fe7ae0cb6dc65c3af9b61d5209f439851db43d0ba5997337df154668eb", ) } test "hmac vectors (RFC 4231)" { assertEq( hmacSha256(hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"), Bytes.fromUtf8("Hi There")).toHex(), "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7", ) assertEq( hmacSha256(Bytes.fromUtf8("Jefe"), Bytes.fromUtf8("what do ya want for nothing?")).toHex(), "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843", ) let longKey = Bytes.of(Array131()) assertEq( hmacSha256( longKey, Bytes.fromUtf8("Test Using Larger Than Block-Size Key - Hash Key First"), ).toHex(), "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54", ) } fn Array131(): int[] { let mut out: int[] = [] for i of 0..131 { out.push(0xaa) } return out } test "constant-time comparison" { assert(constantTimeEqual(Bytes.fromUtf8("abc"), Bytes.fromUtf8("abc"))) assert(!constantTimeEqual(Bytes.fromUtf8("abc"), Bytes.fromUtf8("abd"))) assert(!constantTimeEqual(Bytes.fromUtf8("abc"), Bytes.fromUtf8("abcd"))) } // ---- the form encoding ---- test "form encoding nests in brackets and leaves null out" { let params: json = { mode: "payment", amount: 1999, confirm: true, skipped: null, metadata: Map([["sale id", "a&b=c"]]), line_items: [ { quantity: 2, price_data: { currency: "eur", product_data: { name: "Vstopnica č" } } }, ], } assertEq( encodeForm(params), "mode=payment&amount=1999&confirm=true&metadata[sale%20id]=a%26b%3Dc&line_items[0][quantity]=2&line_items[0][price_data][currency]=eur&line_items[0][price_data][product_data][name]=Vstopnica%20%C4%8D", ) } test "form encoding: strings with quotes and escapes, empty strings, extra" { let params: json = { a: "say \"hi\"\n", cleared: "", extra: { beta: "on", nested: { x: 1 } } } assertEq(encodeForm(params), "a=say%20%22hi%22%0A&cleared=&beta=on&nested[x]=1") assertEq(encodeForm(null), "") assertEq(encodeComponent("a b/č~"), "a%20b%2F%C4%8D~") } // ---- webhooks ---- let SECRET = "whsec_test" let EVENT = "{\"id\":\"evt_1\",\"type\":\"checkout.session.completed\",\"created\":1700000000,\"account\":\"acct_1\",\"data\":{\"object\":{\"id\":\"cs_1\",\"metadata\":{\"saleId\":\"s1\"}}}}" let NOW = 1700000100 test "a signed event is verified and read" { let event = try verify(EVENT, signature(EVENT, SECRET, NOW - 10), SECRET, { now: NOW }) assertEq(event.id, "evt_1") assertEq(event.type, "checkout.session.completed") assertEq(event.account, "acct_1") assertEq(metadata(event.data.object.metadata, "saleId"), "s1") // The same from the body's bytes, as a route gets it. let again = try verify( Bytes.fromUtf8(EVENT), signature(EVENT, SECRET, NOW - 10), SECRET, { now: NOW }, ) assertEq(again.id, "evt_1") } test "a signature made by Node's crypto verifies" { // c.createHmac("sha256", "whsec_test").update("1700000090." + EVENT).digest("hex") let header = "t=1700000090,v1=55712e82ccc665fe735ce74716bdbb865294afa0148576756a34f43b7534a5bb" assertEq(signature(EVENT, SECRET, 1700000090), header) assert((try verify(EVENT, header, SECRET, { now: NOW }) else null) != null) } test "any of several signatures may match, as during a secret's rotation" { let good = signature(EVENT, SECRET, NOW).split(",")[1] let header = `t=${NOW},v1=${"0".repeat(64)},${good},v0=ignored` assert((try verify(EVENT, header, SECRET, { now: NOW }) else null) != null) } test "what isn't Stripe's is refused" { let header = signature(EVENT, SECRET, NOW) let _, tampered = try verify(EVENT + " ", header, SECRET, { now: NOW }) assertEq(tampered, SignatureMismatch) let _, wrongKey = try verify(EVENT, header, "whsec_other", { now: NOW }) assertEq(wrongKey, SignatureMismatch) let _, missing = try verify(EVENT, "", SECRET, { now: NOW }) assertEq(missing, MissingSignature) let _, malformed = try verify(EVENT, "garbage", SECRET, { now: NOW }) assertEq(malformed, MalformedSignature { header: "garbage" }) let _, noV1 = try verify(EVENT, `t=${NOW},v0=abc`, SECRET, { now: NOW }) assertEq(noV1, MalformedSignature { header: `t=${NOW},v0=abc` }) let _, badHex = try verify(EVENT, `t=${NOW},v1=zz`, SECRET, { now: NOW }) assertEq(badHex, MalformedSignature { header: `t=${NOW},v1=zz` }) } test "an old event is refused as a replay, unless the check is off" { let header = signature(EVENT, SECRET, NOW - 301) let _, old = try verify(EVENT, header, SECRET, { now: NOW }) assertEq(old, TimestampOutOfTolerance { age: 301 }) assert((try verify(EVENT, header, SECRET, { now: NOW, tolerance: 0 }) else null) != null) assert((try verify(EVENT, header, SECRET, { now: NOW, tolerance: 600 }) else null) != null) } test "a signed payload that isn't an event is refused" { let payload = "{\"id\":1}" let _, err = try verify(payload, signature(payload, SECRET, NOW), SECRET, { now: NOW }) match err { MalformedPayload { message } => assert(message.includes("isn't")), _ => assert(false, "a malformed payload"), } } // ---- errors ---- fn body(s: string): json { return try parse(s) else null } test "errors map to their types" { let card = failureFrom( 402, body( "{\"error\":{\"type\":\"card_error\",\"code\":\"card_declined\",\"decline_code\":\"insufficient_funds\",\"message\":\"Declined\",\"param\":\"number\"}}", ), "req_1", ) match card { CardError { failure } => { assertEq(failure.decline_code, "insufficient_funds") assertEq(failure.request_id, "req_1") }, _ => assert(false, "a card error"), } assertEq(errorMessage(card), "Declined") assertEq(failureFrom(401, null, null).kind, "AuthenticationFailed") assertEq(failureFrom(403, null, null).kind, "PermissionDenied") assertEq(failureFrom(404, null, null).kind, "InvalidRequest") assertEq(failureFrom(400, null, null).kind, "InvalidRequest") assertEq(failureFrom(429, null, null).kind, "RateLimited") assertEq(failureFrom(500, null, null).kind, "ApiFailure") assertEq( failureFrom(400, body("{\"error\":{\"type\":\"idempotency_error\"}}"), null).kind, "IdempotencyConflict", ) assertEq(errorMessage(failureFrom(500, null, null)), "Stripe answered 500") } test "expandable fields" { assertEq(idOf("cus_1"), "cus_1") assertEq(idOf(body("{\"id\":\"cus_2\",\"email\":\"a@b.c\"}")), "cus_2") assertEq(idOf(null), null) } test "a client's defaults" { let c = client("sk_test") assertEq(c.baseUrl, "https://api.stripe.com") assertEq(c.maxRetries, 2) assertEq(client("sk_test", { maxRetries: 0, stripeAccount: "acct_1" }).stripeAccount, "acct_1") }