Watch
1
0
Fork
You've already forked packages
0
packages/stripe/tests/stripe.test.weft
Weft packages 306b143104 packages/ at markup-kit dd1e6eb5270e
A snapshot of packages/ in the Weft repository; the official packages are published from these commits.

Markup-Kit-Commit: dd1e6eb5270e62e0c8b6c202b3d01f0da6e00ddc
2026-11-19 20:43:26 +00:00

220 lines
8.2 KiB
Text

// `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<string, string>([["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")
}