examples Scripts and checks
rts/rts_all_features.http
RestermScript expressions, modules, the standard library, @when, @skip-if, @for-each, and pre-request and test blocks.
runs as-is
resterm run --all _examples/rts/rts_all_features.httpRun this from the root of a clone of the Resterm repository.
Editor
RestermScript docs# @global base_url https://httpbin.org
# @global api.token demo-token
# @global env_hint demo
# @use ./helpers.rts as helpers
# @use ./loops.rts as loops
# @use ./apply_patch.rts as apply
# @use ./pre_request.rts as pre
### RTS Core Expressions + Standard Library
# @name RTS_Core
# @description Exercises expressions, operators, rts stdlib, and module calls.
# @assert response.statusCode in [200, 201, 204]
# @assert response.statusCode not in [400, 404, 500]
# @assert response.json("args.mode") == helpers.mode(env)
# @assert response.json("args.tag") == loops.sampleTag
# @assert response.json("headers.X-Encoded") == base64.encode("hello")
# @assert match("^https?://", response.json("url"))
# @assert contains(response.text(), "\"url\"")
# @assert headers.get(headers.normalize({"X-Test":"ok"}), "x-test") == "ok"
# @assert len(headers.merge({"a":"1"}, {"a": null})) == 0
# @assert query.fromURL(query.merge("https://example.com?p=1&q=2", {q: null})).p == "1"
# Assertions can span comment lines while a group is open.
# @assert (
# response.statusCode == 200
# and contains(response.text(), "args")
# ) => "echo endpoint did not return the query arguments"
# @assert json.parse("{\"a\":1}").a == 1
# @assert base64.decode(base64.encode("hi")) == "hi"
# @assert url.decode(url.encode("a b")) == "a b"
# @assert len(time.format("2006-01-02")) == 10
# @assert len(uuid()) == 36
# @assert (try missing_name).ok == false
# @assert (null ?? "fallback") == "fallback"
# @assert (vars.get("missing") ?? "fallback") == "fallback"
# @assert (true and not false) == true
# @assert (true && !false) == true
# @assert helpers.shouldSkip("", false) == true
# @assert [1,2,3][1] == 2
# @assert ({a: 1, "b": 2}.a + {a: 1, "b": 2}["b"]) == 3
# @assert vars.get("env_hint") == "demo"
GET {{base_url}}/get?mode={{= helpers["mode"](env) }}&tag={{= loops.sampleTag }}&uuid={{= uuid() }}
User-Agent: resterm-rts-examples
X-Encoded: {{= base64.encode("hello") }}
X-Url: {{= url.encode("a b") }}
X-Time: {{= time.nowISO() }}
X-Trace-Id: {{= helpers.traceId() }}
### RTS Time Helpers
# @name RTS_TimeHelpers
# @description Shows duration parsing and timestamp math.
# @assert response.json("json.offset_seconds") == 5400
# @assert match("^\\d{4}-\\d{2}-\\d{2}T", response.json("json.expires_iso"))
POST {{base_url}}/anything/time
Content-Type: application/json
{
"offset_seconds": {{= time.duration("1h30m") }},
"expires_iso": "{{= time.formatUnix(time.addUnix(time.nowUnix(), '6d'), '2006-01-02T15:04:05Z07:00') }}"
}
### RTS Pre-request Mutation
# @name RTS_PreRequest
# @description Mutates request, vars, and globals in pre-request.
# @rts pre-request
> pre.mutate(request, vars, env)
# @assert response.json("method") == "POST"
# @assert request.method == "POST"
# @assert response.json("args.mode") == helpers.mode(env)
# @assert response.json("args.mutated") == "true"
# @assert response.json("headers.X-Mode") == helpers.mode(env)
# @assert vars.get("pre_request_mode") == helpers.mode(env)
POST {{base_url}}/anything
X-Remove-Me: true
### RTS Test Blocks
# @name RTS_Tests
# @description Checks the echoed orders with @rts test blocks and a module.
# @use ./validators.rts as validators
# @assert response.statusCode == 200
# @rts test "orders are valid"
> {%
# one message for each bad order
let orders = response.json("json.orders")
if typeof(orders) != "list" {
t.fatal("response has no orders list")
}
for let _, msg range validators.orders(orders) {
t.error(msg)
}
%}
# @rts test customer
> let want = {id: 7, name: "Ada", tier: "gold"}
> for let _, d range json.diff(response.json("json.customer"), want) {
> t.error(d)
> }
POST {{base_url}}/anything/orders
Content-Type: application/json
{
"customer": {"id": 7, "name": "Ada", "tier": "gold"},
"orders": [
{"id": "A-1", "total": 25.5, "items": [{"sku": "pen", "qty": 2}]},
{"id": "A-2", "total": 12, "items": [{"sku": "ink", "qty": 1}, {"sku": "pad", "qty": 3}]}
]
}
### RTS Apply Patch
# @name RTS_Apply
# @description Applies a dict patch to method/url/headers/query/body/vars.
# @apply apply.patch(request, vars)
# @assert response.json("method") == "PUT"
# @assert request.method == "PUT"
# @assert request.query.from == "apply"
# @assert response.json("args.from") == "apply"
# @assert response.json("args.applied") == "1"
# @assert response.json("headers.X-Apply") == "true"
# @assert vars.get("apply_note") == "patched"
GET {{base_url}}/anything?debug=0
### RTS @when
# @name RTS_When
# @description Runs only when api.token exists.
# @when vars.has("api.token")
# @assert response.statusCode == 200
GET {{base_url}}/bearer
Authorization: {{= helpers.authHeader(vars.get("api.token")) }}
### RTS @skip-if
# @name RTS_SkipIf
# @description Skips only when env_hint == "skip".
# @skip-if vars.get("env_hint") == "skip"
# @assert response.statusCode == 204
GET {{base_url}}/status/204
### RTS Loops + Switch + Labels + Const + Try
# @name RTS_Loops
# @description Exercises for/range/switch/labels/break/continue/const/try in modules.
# @assert loops.sampleTag == "rts-examples"
# @assert loops.sumClassic(6) == 8
# @assert loops.rangeList() == "0a1b2c"
# @assert loops.rangeDict() == "ab"
# @assert loops.rangeString() == "0g1o"
# @assert loops.countdown(3) == "321"
# @assert loops.statusLabel(201, null) == "success"
# @assert loops.statusLabel(403, null) == "denied"
# @assert loops.statusLabel(500, null) == "unexpected"
# @assert loops.statusLabel(500, "forced") == "forced"
# @assert loops.grade(95) == "A"
# @assert loops.grade(85) == "B"
# @assert loops.grade(10) == "C"
# @assert loops.switchBreakScope(["a", "skip", "mark"]) == "a!mark"
# @assert loops.firstDenied([200, 403, 401]) == 403
# @assert loops.firstDenied([200, 201]) == -1
# @assert loops.fullRows([[1, 2], [3, null], [4, 5]]) == "02"
# @assert loops.constLabel(7) == "user-7"
# @assert loops.dictAccess() == 3
# @assert loops.tryFail() == false
GET {{base_url}}/get?tag={{= loops.sampleTag }}
### RTS @for-each with json.file
# @name RTS_ForEach
# @description Iterates a local JSON file and posts each user.
# @use ./users.rts as users
# @for-each json.file("users.json") as user
# @assert response.json("json.id") == user.id
# @assert response.json("headers.X-User") == users.headerTag(user)
POST {{base_url}}/post
Content-Type: application/json
X-User: {{= users.headerTag(user) }}
{{= users.payload(user) }}
### RTS Trace
# @name RTS_Trace
# @description Captures trace timings and budgets.
# @trace dns<=200ms connect<=400ms ttfb<=600ms total<=1000ms tolerance=100ms
# @assert trace.enabled() == true
# @assert trace.budgets().enabled == true
# @assert trace.durationMs() >= 0
GET {{base_url}}/delay/0.1
Accept: application/json
### RTS Stream (SSE)
# @name RTS_SSE
# @description SSE request to populate stream.summary/events.
# @sse duration=5s idle=2s max-events=3
# @assert stream.enabled() == true
# @assert stream.kind() == "sse"
# @assert stream.summary().eventCount >= 0
GET https://stream.wikimedia.org/v2/stream/recentchange
Accept: text/event-stream
User-Agent: resterm-examples (https://github.com/unkn0wn-root/resterm)export fn mode(env) {
if env.meta.name == "prod" {
return "strict"
}
return "debug"
}
export fn envLabel(env) {
return env.meta.name ? env.meta.name : "default"
}
export fn authHeader(token) {
return token ? "Bearer " + token : ""
}
export fn coalesce(a, b) {
return a ?? b
}
export fn shouldSkip(token, offline) {
return !token || offline
}
export fn traceId() {
return "trace-" + uuid()
}
export fn safeTag(tag) {
let cleaned = tag ?? "rts"
return match("^[a-z0-9-]+$", cleaned) ? cleaned : "rts"
}export const sampleTag = "rts-examples"
export fn sumClassic(n) {
let total = 0
for let i = 0; i < n; i = i + 1 {
if i == 2 {
continue
}
if i == 5 {
break
}
total = total + i
}
return total
}
export fn rangeList() {
let out = ""
for let i, v range ["a", "b", "c"] {
out = out + str(i) + v
}
return out
}
export fn rangeDict() {
let out = ""
for let k, v range {b: 2, a: 1} {
out = out + k
}
return out
}
export fn rangeString() {
let out = ""
for let i, ch range "go" {
out = out + str(i) + ch
}
return out
}
export fn countdown(n) {
let out = ""
for n > 0 {
out = out + str(n)
n = n - 1
}
return out
}
export fn statusLabel(code, override) {
let label = ""
switch code {
case 200, 201:
label = "success"
case 401, 403:
label = "denied"
default:
label = "unexpected"
}
return override ?? label
}
export fn grade(score) {
switch {
case score >= 90:
return "A"
case score >= 80:
return "B"
default:
return "C"
}
}
# a plain break would only leave the switch, so the label is what stops the loop
export fn firstDenied(codes) {
let found = -1
outer: for let i, code range codes {
switch code {
case 401, 403:
found = code
break outer
}
}
return found
}
# continue outer abandons the current row as soon as a hole shows up
export fn fullRows(rows) {
let out = ""
outer: for let i, row range rows {
for let j, value range row {
switch value {
case null:
continue outer
}
}
out = out + str(i)
}
return out
}
# break leaves the switch and the loop keeps going, while continue skips to the
# next iteration of the loop
export fn switchBreakScope(items) {
let out = ""
for let i, v range items {
switch v {
case "skip":
continue
case "mark":
out = out + "!"
break
}
out = out + v
}
return out
}
export fn constLabel(id) {
const prefix = "user-"
return prefix + str(id)
}
export fn dictAccess() {
let d = {a: 1, "b": 2}
return d.a + d["b"]
}
export fn tryFail() {
let res = try fail("boom")
return res.ok
}export fn patch(request, vars) {
let hdrs = headers.merge(
headers.normalize({"X-Apply": "true", "Content-Type": "application/json", "X-Remove-Me": "gone"}),
{"X-Remove-Me": null, "X-Multi": ["a", "b"]}
)
let mergedURL = query.merge(request.url, {applied: "1"})
let body = {
applied: true,
note: vars.get("pre_request_mode") ?? "none",
method: request.method
}
return {
method: "PUT",
url: mergedURL,
headers: hdrs,
query: {from: "apply", remove: null},
body: body,
vars: {apply_note: "patched"}
}
}export fn mutate(request, vars, env) {
let mode = env.meta.name == "prod" ? "strict" : "debug"
let trace = "trace-" + uuid()
request.setMethod("POST")
request.setURL(query.merge(request.url, {mode: mode, pre: "1"}))
request.setHeader("Content-Type", "application/json")
request.setHeader("X-Mode", mode)
request.addHeader("X-Trace-Id", trace)
request.removeHeader("X-Remove-Me")
request.setQueryParam("mutated", "true")
let body = {
mode: mode,
trace: trace,
token: vars.get("api.token") ?? "none"
}
request.setBody(json.stringify(body, 2))
vars.set("pre_request_mode", mode)
vars.global.set("pre_request_token", trace, true)
if vars.global.has("stale.value") {
vars.global.delete("stale.value")
}
}module validators
export fn orders(list) {
let msgs = []
for let i, o range list {
let msg = order(o)
if msg != null {
msgs = append(msgs, "order " + str(i) + ": " + msg)
}
}
return msgs
}
fn order(o) {
if o.id == null {
return "missing id"
}
if typeof(o.total) != "number" {
return "total is " + typeof(o.total) + ", want number"
}
if o.total < 0 {
return "total " + str(o.total) + " is negative"
}
if not o.items {
return "no items"
}
for let _, item range o.items {
if typeof(item.qty) != "number" {
return "item " + item.sku + " has no quantity"
}
if item.qty < 1 {
return "item " + item.sku + " has quantity " + str(item.qty)
}
}
return null
}export fn headerTag(user) {
return "user-" + str(user.id)
}
export fn role(user) {
return user["role"] ?? "viewer"
}
export fn payload(user) {
return {
id: user.id,
name: user.name,
role: role(user),
label: user.name + "-" + str(user.id)
}
}[
{"id": 1, "name": "Ada", "role": "admin"},
{"id": 2, "name": "Ken"}
]