Assetize

Learning Lab

Level 9 · 15 levels · Builder · about 85 minutes

Level 9 — Testing you can trust: unit, UI, stubs, mocks and failure on purpose

By the end: Pick the right kind of test for a Maximo change, test a script and an integration without a server, rehearse the bad day (429s, timeouts, expired sessions, lost answers) and tell a flaky test from a real failure.

Many fast unit tests at the base, fewer integration tests in the middle, a few slow UI tests at the top. Watch the speed meter drop as you climb.

A pyramid with many fast unit tests at the base, fewer integration tests in the middle and a few slow UI tests at the top. A speed meter beside each layer.

Lesson 1

What a test is, and the six kinds you will meet

A test is a small program that runs your code and checks one thing about the result. It answers yes or no. You write tests so that a change you make on Tuesday cannot quietly break something you built in March. In a Maximo team the stakes are concrete. A broken completion script stops technicians closing their work. A broken integration stops invoices reaching finance. A broken screen stops a planner on Monday morning.

A good test has three habits. It checks one thing. Its name is a sentence that says what that thing is, for example "a completed work order without a failure code is refused". And it fails for one reason only, so when it goes red you know where to look without reading a log.

Kind of testWhat it provesHow fastA Maximo example
UnitOne small piece of code works on its ownMillisecondsThe function that turns WAPPR into "Waiting on approval" returns the right words
IntegrationPieces work together across a boundarySecondsYour code reads work orders from /maximo/api/os/mxapiwodetail and maps every field
UI / end-to-endA real user journey works in a real browserSeconds to minutesA planner creates a work order in Work Order Tracking, approves it and sees APPR
SmokeThe system is alive right after a deploySecondswhoami answers with the expected user, and the login page loads
RegressionSomething that used to work still worksAnyThe bug fixed last month has a test, so it cannot come back unnoticed
Golden baselineThe output still matches a saved known-good copySeconds per screenEvery screen a change touched still opens with the same tabs and toolbar
A pull request up close. Every tick on a pull request is a test someone wrote. Watch the checks turn from running to passed before the reviewer approves.

A pull request card: the title, a diff with red removed lines and green added lines, checks turning from running to passed, and a reviewer approving.

Tests run in a pipeline, one stage after another. The fast ones run first, so a mistake stops the change in seconds instead of after an hour of slow browser tests. You will build pipelines in Level 10. For now, notice that every stage is a test, and every red stage is a door that stays shut.

A pipeline with gates. Watch the change stop at the unit tests. Nothing reaches DEV, so nobody else is disturbed.

A change flows through build, unit tests, deploy to DEV, integration and UI tests, approval, deploy to TEST then PROD and a smoke test. Each stage turns green in turn.

The mistake: Writing one huge test that logs in, creates a work order, approves it, completes it, checks the report and calls the whole thing "the test". Do this instead: Write many small tests that each check one thing. When one fails, its name tells you what broke.

Remember: A test that has never failed is not yet protecting you. Break the code on purpose once, watch the test go red, then put the code back.

Lesson 2

The test pyramid, and UI tests with Playwright

The test pyramid is a picture of how many tests of each kind to write. Martin Fowler's summary has two rules of thumb: "Write tests with different granularity", and "The more high-level you get the fewer tests you should have." Granularity means size: a unit test checks a tiny piece, a UI test checks a whole journey.

The test pyramid. The top layer is lit. UI tests are the most realistic and the slowest. Keep them for the journeys that matter most.

A pyramid with many fast unit tests at the base, fewer integration tests in the middle and a few slow UI tests at the top. A speed meter beside each layer.

Why so few UI tests? Fowler writes that end-to-end tests "are notoriously flaky and often fail for unexpected and unforeseeable reasons", and that "Quite often their failure is a false positive." The causes he lists are browser quirks, timing, animations and pop-up dialogs. A Maximo screen has all four. So you test the logic underneath with unit tests, and keep a small set of UI journeys that prove the screens still work end to end.

Playwright is the open-source browser testing framework the Assetize team uses. It drives Chromium, WebKit and Firefox on Windows, Linux and macOS. You start a project with npm init playwright@latest, run every test with npx playwright test, and open the report with npx playwright show-report. The same tool also has a request fixture for API tests, which run in milliseconds and need no browser at all.

tests/api/approved.spec.ts

import { test, expect } from '@playwright/test';

// An API test: no browser, one request, one clear check.
test('the approved filter only returns APPR work orders', async ({ request }) => {
  const res = await request.get('/maximo/api/os/mxapiwodetail', {
    headers: { apikey: process.env.MAXIMO_APIKEY! },
    params: { 'oslc.where': 'status="APPR"', 'oslc.select': 'wonum,status', 'oslc.pageSize': '5' },
  });
  expect(res.status()).toBe(200);
  const body = await res.json();
  for (const wo of body.member) expect(wo.status).toBe('APPR');
});

In a browser test you find things on the page with locators. The Playwright docs say "Locators are the central piece of Playwright's auto-waiting and retry-ability", and recommend "prioritizing user-facing attributes": getByRole for a button by its name, getByLabel for a field by its label, getByText for visible words. Auto-waiting means Playwright waits until the button is there and ready before it clicks, so you never write "sleep five seconds".

Maximo classic screens add their own rules, learned the hard way in mxR's UI journeys. Manage draws classic applications inside a shell frame, so the test works inside that frame. Log in once through the suite login and reuse the session for every test. Wait for the screen to be idle (mxR counts the outstanding background requests and watches the busy indicator), or for the title bar to appear, never for the whole network to go quiet. Seed test data through the API on a test organisation and site, then cancel or close it afterwards rather than delete it.

Unit testUI test
  • Runs in milliseconds
  • Needs no server, no browser, no data
  • Fails for one reason, named in the test
  • Hundreds of them is normal
  • Runs in seconds or minutes
  • Needs a browser, a login and test data
  • Can fail for timing reasons outside your code
  • A handful per application, for the journeys that matter

The mistake: page.waitForTimeout(5000) "to give Maximo time to load". Do this instead: Wait for something the user would see, such as the title bar or the field you are about to fill. Fixed sleeps are slow when Maximo is fast and still too short when it is slow.

Lesson 3

Stubs, mocks and fakes: testing without a real Maximo

A real Maximo is a poor place to run most tests. It takes days to get one. It is shared, so another team's test can change the record yours depends on. It holds data you must not change. And it runs one release, which may not be the release your customer runs. So most tests talk to a stand-in instead. The general name for a stand-in is a test double, after the stunt double in a film.

Test doubleWhat it is (Gerard Meszaros, quoted by Martin Fowler)A Maximo example
Dummy"passed around but never actually used. Usually they are just used to fill parameter lists."A placeholder user object your function needs but never reads
FakeHas "working implementations" but takes "some shortcut which makes them not suitable for production"An in-memory list standing in for the WORKORDER table
Stub"provide canned answers to calls made during the test"A server that always answers GET mxapiasset with the same two pumps
Spy"stubs that also record some information based on how they were called"A stub that remembers every request so you can read the journal later
Mock"pre-programmed with expectations which form a specification of the calls they are expected to receive"A mocked MboSet that fails the test unless save() was called exactly once
Stub, mock and the real thing. The stub is lit: it hands back a canned answer and asks no questions. Compare it with the mock beside it, which also checks how it was called.

A test talks to three stand-ins. The stub returns a canned answer. The mock returns an answer and also checks it was called once with the right values. The real Maximo is slow, shared and full of data you must not change.

The Assetize Maximo test stub is a version-aware stand-in for Maximo at the HTTP boundary, the point where your code sends a request. It ships with a base Maximo (object structures, domains and a small set of sample records), reads one client overlay file for anything site-specific, and serves REST, OSLC, Integration Framework XML and SOAP. It journals every request, simulates a bad network on demand, and has zero dependencies. It runs in Node and in a browser: the Maximo sim in this lab is that stub.

Start the stub on the MAS 9.2 lens

node bin/maximo-stub.mjs start --lens mas92 --overlay overlay.json

Maximo test stub v0.1.0 · lens MAS 9.2 · 16 object structures · 60 records
REST     http://127.0.0.1:7001/maximo/api/os/mxapiwodetail   (header apikey: <any>)
OSLC     http://127.0.0.1:7001/maximo/oslc/os/mxwodetail?lean=1
MIF      http://127.0.0.1:7001/meaweb/os/MXWODETAIL   SOAP http://127.0.0.1:7001/meaweb/services/MXWODETAIL?wsdl
Console  http://127.0.0.1:7001/_stub

A lens is the release line the stub answers as: 761 (Maximo 7.6.1), mas811, mas90, mas91 or mas92. The lens changes real behaviour. The MAS lenses accept an apikey header only and reject maxauth. The 761 lens also accepts maxauth, HTTP Basic, _lid and _lpwd, and a session cookie. So a test that passes on mas92 proves nothing about 7.6.1 until you run it on the 761 lens too.

The stub fails closed. Precedence is fixtures, then the overlay, then the base. An overlay can say which lenses an attribute is evidenced on, and anywhere else the stub answers STUB-NO-EVIDENCE instead of guessing. Every answer carries X-Stub-Lens, X-Stub-Tier (base, overlay, fixture, chaos or stub) and, for object structures, X-Stub-Evidence with where the dictionary came from. Try stub explain GET /maximo/api/os/mxapiwodetail in the explain mission to see which layer answered.

The mistake: A stub that answers every request with something plausible, whatever the release. Do this instead: A stub that refuses what it has no evidence for. A silent wrong answer from another release line is a production incident waiting to happen. An honest refusal costs you five minutes.

Remember: The stub's own test plan runs 96 cases across MAS 9.2 and 7.6.1. Stand-ins need tests too.

Lesson 4

Inside Maximo: Mockito for Java, and testing a script without a server

An HTTP stub tests the conversations other systems have with Maximo. It never sees code that runs inside Maximo: Java customisations, MBO extensions and automation scripts. An MBO (Maximo Business Object) is the Java object behind one record, with its rules. For code at that level you mock the business objects themselves.

Mockito is the standard mocking library for Java. You create a mock, tell it what to answer, run your code, then verify how the mock was called. The Mockito docs show the three moves: mock(List.class) to create, when(mockedList.get(0)).thenReturn("first") to set an answer, and verify(mockedList, times(2)).add("twice") to check the calls.

Stub, mock and the real thing. The mock is lit. It answers like a stub, and it also checks that it was called once, with the right values.

A test talks to three stand-ins. The stub returns a canned answer. The mock returns an answer and also checks it was called once with the right values. The real Maximo is slow, shared and full of data you must not change.

For Maximo the classes you mock are psdi.mbo.MboRemote (one record), MboSetRemote (a set of records), MboValue, the static MXServer.getMXServer() entry point and the MXException family. The Assetize Mockito kit wraps these in builders, on JUnit 5 and Mockito 5. Raw Mockito returns a default value for an attribute that does not exist. The kit checks every attribute against the dictionary of the release you test, so asking a 9.1 mock for a 9.2-only field throws the same "attribute does not exist" error a real 9.1 Mbo would.

The Assetize Mockito kit: builders and evidence per release

MboSetRemote woSet = MockMboSet.of("MXAPIWODETAIL", Lens.MAS_92)
    .row(r -> r.attr("WONUM", "1001").attr("STATUS", "WAPPR"))
    .row(r -> r.attr("WONUM", "1002").attr("STATUS", "APPR"))
    .build();

@EvidencedOn({"9.1", "9.2"})
@Test
void statusChangeClearsSchedDate() { ... }

// run once per release:  mvn verify -P mas91   and   mvn verify -P mas92

IBM does not publish the Manage JARs to Maven Central. They ship inside every Manage deployment, so you copy them from the admin pod of the release they represent, record the build string, and keep them out of any public repository.

For automation scripts there is a faster path: the Assetize Script Test Harness at /test-stubs/automation-scripts. Paste a launch point script, pick the release, and run it against a mocked Mbo in your browser. The harness binds mbo, mboset and service the way Manage does for the launch point the script declares: Object, Attribute, Action and Sig Option, Cron task and escalation. You get a verdict for each release: passes, breaks, or skipped where that release lacks an attribute the script reads. The same engine runs on your machine and in CI, so all three give the same verdict.

A completion gate in action. A technician sets COMP with no failure code. The save fires the script, the script raises an error, and the save stops with a message. This is exactly what a harness test checks.

A technician sets a work order to COMP with no failure code. The save triggers the automation script, the script raises an error, and the save is stopped with a message. With a failure code filled in, the save goes through.

The Script Test Harness from a terminal

node bin/asz-harness.mjs script.js --lens mas92                       # before you commit
node bin/asz-harness.mjs script.js --lens 761,mas811,mas90,mas91,mas92  # in CI, as a gate

IBM also gives you a Test button in the Automation Scripts application. It prepares test data and runs the script from a dialog, and prints the log to the Process Log area when the script logs through the service variable. For a script that needs a record, the Object Path field loads one, for example ASSET[assetnum='SPFN0001']. IBM notes the tool makes a best effort not to commit the record but cannot always avoid it, so use it on a test system.

Automation scripts, drawn

The mistake: Testing a script only by saving it on the shared DEV system and clicking around Work Order Tracking. Do this instead: Run it in the harness first on every release you support, then use IBM's Test button on a test system, then let the pipeline's script tests prove it after deploy.

Lesson 5

Test the bad day: timeouts, 429s, expired sessions and safe retries

Production fails in boring, predictable ways. A busy server says "slow down". A router restarts. A session expires halfway through a long read. The network drops the answer to a write you sent. Code that only ever met the happy path falls over the first time one of these happens, usually at 2 a.m. So you rehearse each one on purpose, against a stand-in, before it happens for real.

What goes wrongWhat your code seesWhat good code doesRehearse it in the stub
Rate limit429 Too Many Requests, often with a Retry-After headerWaits, backs off with jitter, gives up after a set number of triesstub chaos storm (60% of reads under /api/os answer 429, Retry-After 2)
Router outage503 with an HTML page instead of JSONTreats it as retryable and never parses the HTML as datastub chaos router
Slow networkAnswers take seconds instead of millisecondsSets a timeout on every call so nothing hangs foreverstub chaos slow (p50 400 ms, p95 1800 ms)
Session expiry401 in the middle of a runSigns in again once, retries that request, and stops if the second try failsstub chaos expire (the session ends every 3 requests)
Connection reset on a writeNo answer at allMakes the write idempotent, so sending it again is safestub chaos reset (half the POSTs drop the connection)

MDN defines 429 as the status that "indicates the client has sent too many requests in a given amount of time", a mechanism "commonly called rate limiting". It adds: "A Retry-After header may be included to this response to indicate how long a client should wait before making the request again." Read that header first. If it is there, wait at least that long.

Back off and retry. Watch the good client wait a little longer after each 429, with a dash of randomness, until it gets a 200.

A client gets 429 Too Many Requests and waits before trying again, waiting longer each time with a little randomness, until it gets 200. Beside it, a client that retries instantly makes the storm worse.

Backoff means waiting longer after each failure: one second, then two, then four. Jitter means adding randomness to the wait. Without jitter, a hundred clients that failed together all retry together, and the storm comes back. AWS studied this and wrote: "The solution isn't to remove backoff. It's to add jitter." Their conclusion is that jittered backoff "should be considered a standard approach for remote clients."

Backoff with full jitter, honouring Retry-After

async function withBackoff<T>(call: () => Promise<Response>, tries = 5): Promise<Response> {
  const base = 500, cap = 30_000; // milliseconds
  for (let attempt = 0; ; attempt++) {
    const res = await call();                       // call() sets its own timeout
    if (res.status !== 429 && res.status !== 503) return res;
    if (attempt + 1 >= tries) return res;           // give up: report it, never loop forever
    const retryAfter = Number(res.headers.get('retry-after')) * 1000 || 0;
    const ceiling = Math.min(cap, base * 2 ** attempt);
    const wait = Math.max(retryAfter, Math.random() * ceiling); // "full jitter"
    await new Promise((r) => setTimeout(r, wait));
  }
}
Safe to press twice. With an idempotent request, the retry after a lost answer still leaves one record.

A request is sent, the network drops the answer, and it is sent again. On the left, without protection, two records are created. On the right, with an idempotent request, there is still one record.

Idempotent means "doing it twice has the same effect as doing it once". Reads are idempotent. Creates usually are not. Maximo's REST API gives you an idempotent write called SYNC: a POST to the collection with the header x-method-override: SYNC. Maximo matches the record by its primary keys, updates it when it exists and creates it when it does not. The opposite case is real too. In an Assetize lab capture on Manage 9.2.197, posting the same work order twice to a JSON enterprise service returned HTTP 400 with BMXAA4211E (database error -803) on the second post, because that service inserts and does not sync.

The last step is the one people skip: prove the recovery. After the failure, switch the bad weather off and show a healthy answer again. That is the recover mission on this level. Spotting a failure is half the job. Showing the system is well again is the other half.

The mistake: Retrying every failure instantly in a tight loop, including POSTs that create records. Do this instead: Retry only what is safe to retry, wait longer each time with jitter, cap the number of tries, and make writes idempotent first.

Lesson 6

Flaky tests, regression and golden baselines

A flaky test passes and fails on the same code. Playwright names it precisely. After retries it sorts every test into three groups: "passed" for tests that passed on the first run, "flaky" for tests that "failed on the first run, but passed when retried", and "failed" for tests that "failed on the first run and failed all retries". You switch retries on with npx playwright test --retries=3, or retries: 3 in the config.

Here is the rule to carry with you: "flake" is a symptom, not a root cause. Something real made the test fail once. Your job is to name it, because the same cause can hurt a real user.

What actually happenedHow it shows upThe fix
Timing: the test waited a fixed time, or clicked before the screen was idleFails more on a busy machineWait for something the user sees; use locators that auto-wait
Shared data: two tests changed the same work orderFails only when tests run in parallelEach test seeds its own record on the test site
Order: one test relied on another running firstFails when run alone or in a new orderMake every test set up what it needs
Environment: a different browser, operating system or screen sizeFails on CI, passes on your laptopRun tests where the baseline was made
A real intermittent bug in the code, such as a raceFails now and then everywhereFix the code. The test was right
A pipeline with gates. The integration stage turned red. Rerunning until it goes green hides the reason, and the reason is still there.

A change flows through build, unit tests, deploy to DEV, integration and UI tests, approval, deploy to TEST then PROD and a smoke test. Each stage turns green in turn.

mxR (Level 10) takes a firm line here. A UI journey that passed only on its one retry is recorded as flaky, never as green, with its own failure code, TEST/UI-FLAKY. The run report keeps the trace, so someone can find the cause.

A regression is something that used to work and now does not. A golden baseline is a saved known-good copy that later runs are compared against. Playwright's toHaveScreenshot works this way. On the first run there is no reference image, so it writes one. Playwright keeps baselines in a folder next to the test, named after the test file with -snapshots on the end. When a page changes on purpose you regenerate them with npx playwright test --update-snapshots, then commit and review the new images. The docs warn that rendering differs between machines: "For consistent screenshots, run tests in the same environment where the baseline screenshots were generated."

The job plan board. The golden task is lit. It opens every screen a change touched and compares it with the baseline captured on your own site.

A board of task cards in order: lint, DBC, Migration Manager preview, deploy, smoke, API, script tests, cron, MIF, UI journeys, golden screens and drift. Each card has On, Gate and Test switches. Dragging a card into a site column adds it.

mxR's golden screens compare structure, not pixels: each screen's title, control types, toolbar actions, tabs and Select Action entries, saved in tests/golden/<SITE>.json. Structure does not change when a font renders one pixel wider, so the test stays steady. On a Maximo for Aviation lab, 286 screens were captured at about 1.6 seconds each, and all 286 were checked in 8 minutes 15 seconds. To show the test catches real change, the team ran it against a baseline that expected things the People screen does not have. Exactly three tests failed, each naming what was missing:

A golden test that bites (mxR docs, golden-broken run)

Error: Select Action entries gone: Approve Payroll
Error: the search dialog reads "More Search Fields" (the baseline recorded "Advanced Person Search")
Error: tabs gone: Payroll
  3 failed

The mistake: A golden test goes red, so you run --update-snapshots and commit the new baseline without looking. Do this instead: Read the difference first. If the change was intended, update the baseline in its own reviewed commit. If it was not, you just found a regression.

Remember: Never switch a test off to get past it. Fix the cause, or change the test in a commit that says why.

Level 9 missions in the Maximo sim

  1. Meet a 429. Turn on a rate-limit storm, then read assets until Maximo says "too many requests".
  2. Prove the recovery. After you have seen a 429, switch the storm off and show a clean 200 again.
  3. Ask who answered. Ask the sim which layer answered a work order read, and from what evidence.

Check yourself: the Level 9 quiz

18 questions. Pass mark 70%.

  1. Which kind of test checks one small piece of code on its own, in milliseconds?
    • A UI test
    • A unit test
    • A smoke test
    • A golden baseline
  2. Look at the highlighted layer. Why should it hold the fewest tests? (picture: The test pyramid)
    • It is the slowest layer, and its tests can fail for reasons outside your code
    • It is the least realistic layer
    • Playwright allows only ten tests at that layer
    • Maximo screens cannot be tested at that layer
  3. Which picture lights the layer that should hold the most tests?
    • Bottom layer lit
    • Middle layer lit
    • Top layer lit
  4. Look at the lit stand-in. What does it do that a plain stub does not? (picture: Stub, mock and the real thing)
    • It runs a real Maximo in a container
    • It also checks it was called, how often and with which values
    • It answers faster than a stub
    • It writes to the real database
  5. Look at the lit stand-in. Why do teams avoid running most tests against it? (picture: Stub, mock and the real thing)
    • It is slow to get, shared with others, and holds data you must not change
    • It cannot answer REST calls
    • It only runs at night
    • It answers in XML only
  6. Which test double has a working implementation with a shortcut, such as an in-memory table in place of the database?
    • Dummy
    • Fake
    • Spy
    • Mock
  7. Your test asks the stub, on the 761 lens, for an attribute that the overlay has evidence for on mas92 only. What does the stub answer?
    • A made-up value of the right type
    • An empty string
    • A refusal: STUB-NO-EVIDENCE
    • The mas92 value
  8. The stub runs the mas92 lens. Your client sends only a maxauth header. Which door does it meet, and what happens? (picture: The login change)
    • The MAS door: it bounces with 401, because MAS lenses accept an API key only
    • The 7.6.1 door: it gets in with 200
    • The stub ignores auth headers
    • The stub converts maxauth to an API key
  9. The technician sets COMP with no failure code. Where does the save end? (picture: A completion gate in action)
    • It saves, and the script logs a warning
    • It is stopped: the script raises an error and the user sees a message
    • Maximo fills in a failure code
    • The work order moves to CLOSE
  10. What does the Script Test Harness give you for each release you pick?
    • A screenshot of Work Order Tracking
    • A verdict: passes, breaks, or skipped where the release lacks an attribute the script reads
    • A bill for the test run
    • A copy of the production database
  11. What is wrong with this client? (picture: Back off and retry)
    • Nothing, it is the fastest way to recover
    • It retries instantly after every 429, so it adds to the storm it is caught in
    • It waits too long between tries
    • It sends the wrong API key
  12. The storm mission answers with the enlarged code. What should your code do first? (picture: Status code families)
    • Crash, so someone notices
    • Read Retry-After if it is there, wait at least that long, then retry with backoff
    • Send the same request ten times at once
    • Switch to a different API key
  13. Why add a random part (jitter) to the backoff wait?
    • To make tests slower
    • So that many clients that failed together do not all retry at the same instant
    • Because Maximo requires it
    • To hide errors from the log
  14. Why are there two records? (picture: Safe to press twice)
    • The server made a mistake
    • The first create worked, its answer was lost, and the retry created a second record
    • Maximo always creates two
    • The test ran twice by design
  15. Which Maximo REST header turns a POST to the collection into an upsert matched on the primary keys?
    • x-method-override: SYNC
    • x-method-override: DELETE
    • Retry-After: 2
    • maxauth
  16. Halfway through a long data read, Maximo answers 401. What does a well-built client do?
    • Loops forever until it works
    • Signs in again once, retries that request, and stops with a clear error if the second try also fails
    • Skips the record and carries on silently
    • Deletes its saved session file and exits with success
  17. A UI journey failed on its first run and passed on its retry. How does Playwright classify it?
    • passed
    • flaky
    • failed
    • skipped
  18. One check on this pull request failed. What happens next? (picture: A pull request up close)
    • Merge anyway, the reviewer approved
    • The merge stays blocked: read the failure, fix the cause, push again
    • Delete the failing test
    • Switch the check off for this pull request

Remember it as a picture

  • Unit test: One small piece of code, checked on its own in milliseconds. Most of your tests live in this wide base.
  • UI / end-to-end test: A real browser walks a user journey. Realistic and slow, so keep a few for the journeys that matter.
  • Stub: Gives "canned answers to calls made during the test", and asks no questions back.
  • Mock: Answers like a stub and also verifies the calls: was save() called once, with these values?
  • Why not the real Maximo?: Slow to get, shared with other teams, full of data you must not change, and on one release only.
  • Lens: The release line a stub answers as: 761, mas811, mas90, mas91 or mas92. MAS lenses take an API key only.
  • Script Test Harness: Runs a launch point script against a mocked Mbo per release: passes, breaks, or skipped. No server needed.
  • Backoff with jitter: After each failure, wait longer, with a little randomness, and stop after a set number of tries.
  • 429 Too Many Requests: Rate limiting: slow down. Read Retry-After if it is there, then back off.
  • Idempotent write: Doing it twice has the same effect as once. In Maximo REST, x-method-override: SYNC is an upsert.
  • Flaky is a symptom: A test that passes only on retry has a real cause: timing, shared data, order, environment or a real bug.
  • Golden baseline: A saved known-good copy. Later runs are compared with it, and any difference is named.
  • A red check is a shut door: The merge stays blocked until the cause is fixed. Never switch a gate off to get past it.

Where these facts come from

Try it on the real tools

How did Level 9 go?

Rate the level and say what worked, what did not, what you liked and what you did not. Send it now, or with your full report.