Reference
Glossary, A to Z
Every term from the lessons — APIs, testing and load testing — in a sentence or two, with a link to where it's explained.
A
- API — how one program asks another for something: a request goes in, a response comes back. What an API is
- API key — a long secret string that identifies an application, sent with each request. Signing in
- Apdex — a 0-to-1 score of how many answers were satisfyingly fast, or at least tolerable. Reading results
- Assertion — another word for a check.
- Authentication / authorization — who are you (fails with 401) / may you do this (fails with 403). Signing in
B
- Base URL — the server part of an address (
https://api.example.com); the paths go after it. Requests - Baseline — a trusted run that later runs are compared with, to catch regressions. Goals and regressions
- Basic auth — a username and password, encoded (not encrypted) in the
Authorizationheader. Signing in - Bearer token — a token sent as
Authorization: Bearer …; whoever bears it is let in. Signing in - Body — the data a request or response carries. Headers, query parameters and bodies
- Bottleneck — the part that runs out first under load and decides how fast everything goes. Finding the bottleneck
C
- Capacity — the most load an API can take while meeting its goals. Why test performance
- CDN — a network of servers in front of a site or API that caches and protects it; often rate limits. Testing safely
- Chaining — passing values (a token, an id) from one request's answer to the next. Chaining
- Check — a rule a correct answer must follow: a status, a value, a type, a time. Checks
- CI / pipeline — automatic steps that build and test code on every change. API tests in a pipeline
- Client / server — the program that asks / the one that answers. What an API is
- Collection — a set of saved requests that belong together, often run in order.
- Concurrency limit — how many requests may run at the same time; going over it gives 429 straight away. NetSuite limits an account this way. NetSuite
- Content-Type — the header that says what format a body is in (
application/json). Headers - Contract — what an API promises about its requests and answers; checked by contract tests. Contracts and schemas
- Cookie — a value a server asks the client to send back on later requests, often a sign-in session. Signing in
D – E
- Data-driven test — the same test run with many rows of inputs. Test data
- Effective dating — keeping every version of a record, each valid from one date to another, and answering with today's unless you ask for another day (
asOfDate). SuccessFactors - Endpoint — one address (path + method) of an API, like
GET /orders. - Environment — one place an API runs (DEV, UAT, production), with its own values for variables. Environments
- Error rate — the share of requests that failed (no answer, or status 400+). Reading results
- Exit code — the number a command ends with: 0 passed, non-zero failed; pipelines read it. API tests in a pipeline
F – G
- Flaky test — a test that fails sometimes for no real reason; erodes trust. API tests in a pipeline
- GET / POST / PUT / PATCH / DELETE — the methods: read / create / replace / change / remove. Requests
- GraphQL — an API style with one address where you ask for exactly the fields you want; errors arrive with status 200. Kinds of APIs
- gRPC — fast binary messages between services, described by
.protofiles. Kinds of APIs
H – I
- Header — a
Name: valuenote sent with a request or response. Headers - HTTP / HTTPS — the language of the web; HTTPS is the encrypted version. What an API is
- Idempotent — the same effect whether sent once or many times (GET, PUT, DELETE — not POST). Requests
J
- JSON — the text format most APIs use for data: objects, arrays, strings, numbers, booleans, null. JSON
- JSON path — a way to point at one value in a JSON answer, like
items[0].id. JSON - JSON Schema — a description of valid JSON (fields, types, required), used to check an answer's shape. Contracts and schemas
- JWT — a readable, signed token made of three dot-separated parts. Signing in
L
- Latency / response time — how long one request took. Reading results
- Load test — many simulated users or requests at once, measuring speed and failures. Why test performance
M – N
- Median (p50) — the middle response time: half were faster. Reading results
- Method — what a request asks to do: GET, POST, PUT, PATCH, DELETE… Requests
- Mock — a pretend API that answers with prepared examples. Mocks
- Multipart form (multipart/form-data) — a body split into parts by a boundary, each a text field or a file; how files are uploaded. Headers, query parameters and bodies
- mTLS / client certificate — the client proves who it is with a certificate during the encrypted connection. Signing in
- N+1 queries — one query for a list, then one more per item; a very common cause of slowness. Finding the bottleneck
- Negative test — a test that sends a bad request and expects a clear refusal. What API testing is
O
- OData — a REST style used by business systems (SAP, SuccessFactors, Dynamics): a service root, entity sets like tables, a
$metadatafile describing them, and query options like$filterand$selectin the URL. OData - OAuth 2.0 — a standard way to get a token from an authorization server, with limited permissions (scopes). Signing in
- OpenAPI / Swagger — a file describing an API's paths, parameters and answers — its contract, written down. Contracts and schemas
P
- p95 / p99 — 95% / 99% of requests were faster than this; the usual basis for performance goals. Reading results
- Path — the part of the URL after the server:
/orders/A-1001. Requests - Percentile — the value at a position in sorted response times (p50, p95, p99). Reading results
Q – R
- Query parameter — an option in the address after
?:?page=2. Headers, query parameters and bodies - Ramp-up — raising load gradually instead of all at once. Users and requests per second
- Rate limit — a cap on requests per period; exceeding it gives 429. Status codes · Testing safely
- Regression — something that worked (or was fast) and now doesn't (or isn't), after a change. Goals and regressions
- Request / response — the question a client sends / the answer it gets. What an API is
- Requests per second (RPS) / throughput — answers per second; also a way to drive load at a fixed rate. Users and requests per second
- REST — the common style: resources at addresses, methods, status codes, usually JSON. Kinds of APIs
S
- Safe method — one that only reads and changes nothing (GET, HEAD). Requests
- Sandbox — a copy of a business system for testing, with its own data and limits: test there, not in production. Salesforce · NetSuite
- Server-sent events (SSE) — a one-way stream of events over an ordinary request. Kinds of APIs
- SLI / SLO / SLA — what you measure / the target / the contract with a customer. Goals and regressions
- Smoke / load / stress / spike / soak test — tiny check / a normal day / beyond normal / a sudden burst / hours long. Why test performance
- SOAP — an older style using XML envelopes, described by WSDL. Kinds of APIs
- SOQL / SuiteQL — the query languages of Salesforce and NetSuite: SQL-like
SELECT … FROM … WHERE …, sent to the API to read records. Salesforce · NetSuite - Status code — the three-digit first word of an answer: 2xx worked, 4xx your request was wrong, 5xx the server failed. Status codes
T
- Test data — the inputs a test uses; varied on purpose. Test data
- Think time — the pause between a simulated user's requests, like a person reading. Users and requests per second
- Threshold — a goal turned into a pass/fail limit for a load test. Goals and regressions
- Token — a value proving you signed in, sent with each request; usually expires. Signing in
- TTFB (time to first byte) — from sending until the first byte of the answer: mostly the server working. Reading results
U – W
- URL — the full address: scheme, host, port, path, query. Requests
- Variable — a name like
{{baseUrl}}that stands for a value, filled in when the request is sent. Environments - Virtual user (VU) / simulated user — one pretend user in a load test, sending requests one after another. Users and requests per second
- WAF — a web application firewall: blocks suspicious traffic, including heavy load. Testing safely
- WebSocket — a connection that stays open for two-way messages. Kinds of APIs