Skip to content

Tests

Expected results are not observations

Nothing here has run against LS Login. Against LS Login, every expectation is what the LS Login team's answers of 2026-11-03 or the standards suggest. If you see something else, that's a result: record it. On the mock, the tb> lines were executed, except for wait-expiry, and some only up to a refusal or usage error: see Testbed limits.

The tests

Test What it shows Mock LS Login
T1 Delegated call chain One sign-in, then one token per hop, all the way to the node Commands only: aud and client_id come from our config The result
T2 Refused requests What must fail, who refuses it, and how Exchanges: refused by our own rules. Services: real checks The result
T3 Groups and entitlements Who gets which entitlement, and whether people outside a group are locked out Commands only: no entitlements per client The result
T4 Token lifetime and refresh What lifetimes mean, and how long-running work gets tokens Commands only: lifetimes come from our config, and no refresh token from an exchange The result
T5 Attribution across hops What a node can tell about a request's path, and how a request can be followed Same claims on both paths; hop limit and tracing are real The result

Order for a live session

Prepare, as early as possible:

  1. Accounts, clients and group release: see Client registration. We don't know whether registrations need approval. Plan a slot of about 10 minutes for account B in T3: B logs in on the machine that runs the session, not on their own, as the login returns to localhost there.
  2. lslogin.env: see Configuration.
  3. The automated run against the mock must pass.
  4. Try T1 up to the second hop once beforehand, so that the session isn't spent on registration mistakes.
  5. At least an hour before you need the result, start the expiry part of T4, as it takes as long as tokens live. It runs in its own terminal, and goes first: the login callback only listens during a login, for up to 5 minutes, and two sessions can't log in at the same time. Start the expiry session, run its first three lines (login exp, exchange exp-gw, lifetimes), start wait-expiry exp-gw, and only then open the main session.
  6. T4 also needs a pause of at least 10 minutes in the main session, for idle or absolute. Count it next to the hour of the expiry part.

Terminal 1, the services. Their logs show decoded claims only. Build first: the mock stack builds the image under the same tag, and an image from before a git pull would otherwise run old code without notice:

docker compose -f compose.lslogin.yaml build
docker compose -f compose.lslogin.yaml up -d --wait services
docker compose -f compose.lslogin.yaml logs -f services

Terminal 2, the session. Tokens live only in this process, so keep it open. Results are appended to results/session.jsonl, as decoded claims:

docker compose -f compose.lslogin.yaml run --rm session --record /results/session.jsonl

Then, all in that one session, as later tests use the tokens of earlier ones: T1, T2, T3, T4, T5. Log in with account A, unless a step says otherwise.

Tokens may expire during the session, as exchanged tokens are expected to live 1 hour (A7). T4 and T5 start with new ones. If an exchange is refused or a call gives 401 with the reason expired, check seconds_left in lifetimes before you record it as a result.

Afterwards, in each session (the main one and the expiry session):

quit
docker compose -f compose.lslogin.yaml down -v

Then delete lslogin.env, and results/ once you've taken what you need: both results/session.jsonl and results/expiry.jsonl hold decoded claims of the accounts used. Fill in the Result column of each test's "What to record", take what you need into Results, and update the "To check" list of proTES #391.

To run the same against the mock, leave out -f compose.lslogin.yaml. Everything works, but see the table above for what it means.

A second client, if a result is in doubt

Optional, and only if an exchange or a refusal looks odd and you want to rule out the testbed's own code. The LS Login team suggested OAuth Tools by Curity for trying exchanges: a web client whose Token Exchange Flow sends one exchange request and shows the answer. It's a comparison, not proof, as it has to use a client of its own. The same answer points away from the testbed's code, but rules can differ per client. A different answer may come from the client's registration.

It doesn't replace any test. It has no documented API or command line, so it can't be scripted or be part of the automated run. It sends one audience and one resource per request, and it knows nothing of our services, the hops behind them or the record. It shouldn't reach the mock either, as localhost would mean Curity's server, not your machine (we didn't try).

Everything you send passes through Curity's server

The web version doesn't call the identity provider from your browser. It sends each request to its own server, oauth.tools/api/client/proxy, which passes it on. That includes the client secret, the authorization code, the subject token and the tokens that come back. Curity says that no data is stored on the server. We can't check that, so treat anything you enter as disclosed.

  • Never enter the secret of one of the five testbed clients, or of any client that you can't delete afterwards.
  • Never use a real person's account, or enter or paste their tokens. Use test accounts only.
  • Don't use "Share link". It stores an encrypted copy of the configuration on Curity's server.

We saw this on 2026-11-04, in the page's code and by capturing its requests with made-up values before they left the browser. The site can change, so check again before you enter anything.

What to do, never tried against LS Login. We've only seen that its server fetches LS Login's public discovery document:

  1. Ask the LS Login team whether they're fine with a test client's secret and a test account's tokens passing through a third party.
  2. Register a sixth client just for this, in the same way as tx-test-client, as confidential, with the redirect URI https://oauth.tools/callback/code. Give it the same resource indicators and group release, or its claims will differ for that reason alone.
  3. In OAuth Tools, create a workspace from the issuer https://login.aai.lifescience-ri.eu/oidc/.
  4. Log in with account A in a Code Flow. The session never shows its tokens, so the subject token has to come from this login.
  5. In a Token Exchange Flow, send the request that was in doubt, with the same parameters as in the session. Compare the status, the error and the claims with what the session showed.
  6. Afterwards, delete the client and the workspace. Tokens that were already issued stay valid until they expire.

Questions the tests answer

Each one is explained on its test's page, with what its outcome changes.

Question Test
Are bare client IDs accepted as resource indicators? T1
Can a token with only a URL in aud be exchanged again? T1
Which parameter names the target: audience, resource or both? T1
What's in client_id after an exchange? T1
Do exchanged tokens have the same typ, alg and keys as login tokens? T1
Can public clients exchange? T1
What are the error codes of refusals? T2
Does LS Login check the subject token's signature and expiry? T2
Which group release does a node see, and per which client? T3
How can a group be released without locking out users outside it? T3
Which role is needed to assign groups to a resource? Answered: T3
Group entitlements or resource capabilities? T3
What is the exact entitlement value? T3
What does "1 hour" cover, and is it capped by the subject token? T4
Can an exchange return a refresh token, limited to the next hop? T4
Is the 31 days idle or absolute, and do refresh tokens rotate? T4
Are refresh tokens bound to the client, and is reuse detected? T4
Is act coming? T5

Questions outside the tests

No command answers these. They're for the LS Login team.

What does the new proxy stack change, and when?

The LS Login team named the aud rule, act, lifetimes and refresh token lifetimes as possibly changing (2026-11-03).

  • The timeline decides whether FOCA reads act as optional from the start.
  • proTES #391 and FOCA keep these configurable either way.
  • Is there a test instance, so that we can check our chain before the switch?

Is /cas/oidc the new proxy stack?

A page of the operator names that issuer for another node, and the discovery documents differ: see What we've seen.

  • If it is: do the rules we were told apply to it already? The testbed can be pointed to it with TESTBED_ISSUER.
  • Which issuer should new test clients use? Tokens of one aren't accepted by services that trust the other, so all services of a chain have to move together.

Can users see and revoke what a service holds?

For delegated access, a user should be able to see that Conquest may act for them, and withdraw that at LS Login. The LS Login team answered on 2026-11-19 (A20, A21): users probably can't review the grants they gave a service; they can revoke their tokens themselves; consent can only be revoked through a support request; and refresh tokens probably stay valid when the user logs out. The operator's privacy page, on the other hand, describes a "Revoke consent" button per service in the profile (C12). Still open:

  • Revoking a user's own tokens, revoking consent and revoking a service's refresh tokens are three different things. Where do users revoke their tokens, and does that, or revoking consent, end the refresh tokens that the service holds? And the access tokens issued with them?
  • Logout: the answer is "probably not", and nobody has checked it.
  • If neither ends them: only the service itself can stop further refreshes, by revoking at /oidc/revoke, and Conquest's docs have to say so to users. Either way, access tokens already issued stay usable until they expire, as services validate them offline (Delegated access).

Checking it by hand ends the refresh tokens of both sessions, as both log in account A with tx-test-client. So do it last, if at all, after the expiry session's binding and reuse lines have run: see Revoking consent, at the end of T5.

Can registration be automated?

Is there an API for clients' resource indicators? proTES #391 says that targets are listed by hand for now, later through the Cloud Registry.

  • No API: this stays manual, and the registry's plans leave it out.
  • API: the Cloud Registry's plans can include it, with whoever holds the credentials for it.