mock-jwks

A tool to mock a JWKS authentication service for development of microservices
CONSUMING authentication and authorization jwts.

Background

If you use jwts for authentication and authorization of your users against your
microservices, you want to automatically unit test the authentication in your
microservice for security. Happy and unhappy paths. Doing this while actually
using a running JWKS deployment (like the auth0 backend) is slow and annoying,
so e.g. auth0 suggest you mock their api. This turns out to be somewhat
difficult, especially in the case of using RSA for signing of the tokens and not
wanting to heavily dependency inject the middleware for authentication in your
koa or express app. This is why I made this tool, which requires less changes to
your code.

Usage

Consider a basic express app (works also with koa, hapi or graphql):

``js
// api.js
import express from 'express'
import { expressjwt } from 'express-jwt'
import jwksRsa from 'jwks-rsa'
export const createApp = ({ jwksUri }) =>
express()
.use(
// We set up the jwksRsa client as usual (with production host)
expressjwt({
secret: jwksRsa.expressJwtSecret({
cache: false, // We switch off caching to show how things work in ours tests.
jwksUri,
}),
audience: 'private',
issuer: 'master',
algorithms: ['RS256'],
})
)
.get('/', (_, res) => res.send('Authenticated'))
`

You can test this app like so:

`js
// authentication.test.js
// @ts-check
import { createJWKSMock } from 'mock-jwks'
import { createApp } from './api.js'
import supertest from 'supertest'
import { describe, expect, test, onTestFinished } from 'vitest'

// This creates the local PKI
const jwksMock = createJWKSMock('https://levino.eu.auth0.com')
// We start our app.
const app = createApp({
jwksUri: 'https://levino.eu.auth0.com/.well-known/jwks.json',
})

describe('Some tests for authentication for our api', () => {
test('should not get access without correct token', async () => {
// We start intercepting queries (see below)
onTestFinished(jwksMock.start())
const { status } = await supertest(app).get('/')
expect(status).toEqual(401)
})

test('should get access with mock token when jwksMock is running', async () => {
// Again we start intercepting queries
onTestFinished(jwksMock.start())
const access_token = jwksMock.token({
aud: 'private',
iss: 'master',
})
const { status } = await supertest(app)
.get('/')
.set('Authorization', Bearer ${access_token})
expect(status).toEqual(200)
})
test('should not get access with mock token when jwksMock is not running', async () => {
// Now we do not intercept queries. The queries of the middleware for the JKWS will
// go to the production server and the local key will be invalid.
const access_token = jwksMock.token({
aud: 'private',
iss: 'master',
})
const { status } = await supertest(app)
.get('/')
.set('Authorization', Bearer ${access_token})
expect(status).toEqual(500)
})
})
test('Another example with a non-auth0-style jkwsUri', async () => {
const jwksMock = createJWKSMock(
'https://keycloak.somedomain.com',
'/auth/realm/application/protocol/openid-connect/certs'
)
// We start our app.
const app = createApp({
jwksUri:
'https://keycloak.somedomain.com/auth/realm/application/protocol/openid-connect/certs',
})
const request = supertest(app)
onTestFinished(jwksMock.start())
const access_token = jwksMock.token({
aud: 'private',
iss: 'master',
})
const { status } = await request
.get('/')
.set('Authorization', Bearer ${access_token})
expect(status).toEqual(200)
})
`

You can also find this example in the repo.

$3

Internally this library uses Mock Server Worker (MSW) to create network mocks
for the JWKS keyset. Instead of letting mock-jwks run its own msw instance,
you can add the required handlers to your running instance.

In this case, instead of calling start()/stop(), provide the mswHandler to
to your existing server instance:

`js
// @ts-check
/**
* @typedef
*/
import createJWKSMock from 'mock-jwks'
import { createApp } from './api.js'
import supertest from 'supertest'
import { beforeAll, beforeEach, describe, expect, test } from 'vitest'
import { setupServer } from 'msw/node'

const jwksMock = createJWKSMock('https://levino.eu.auth0.com')
const app = createApp({
jwksUri: 'https://levino.eu.auth0.com/.well-known/jwks.json',
})

describe('Some tests for authentication for our api', () => {
/* @type {import('msw/node').SetupServerApi} /
let mswServer
beforeAll(() => {
mswServer = setupServer()
mswServer.listen({
onUnhandledRequest: 'bypass', // We silence the warnings of msw for unhandled requests. Not necessary for things to work.
})
return () => mswServer.close()
})

beforeEach(() => {
mswServer.resetHandlers()
})

test('Can get access with mock token when handler is attached to msw', async () => {
// arrange
mswServer.use(jwksMock.mswHandler)
const access_token = jwksMock.token({
aud: 'private',
iss: 'master',
})

// act
const { status } = await supertest(app)
.get('/')
.set('Authorization', Bearer ${access_token})

// assert
expect(status).toEqual(200)
})
test('Cannot get access with mock token when handler is not attached to msw', async () => {
// Now we do not intercept queries. The queries of the middleware for the JKWS will
// go to the production server and the local key will be invalid.
// arrange
const access_token = jwksMock.token({
aud: 'private',
iss: 'master',
})

// act
const { status } = await supertest(app)
.get('/')
.set('Authorization', Bearer ${access_token})

// assert
expect(status).toEqual(500)
})
})
`

You can also find this example in the repo.

Under the hood

createJWKSMock will create a local PKI and generate a working JWKS.json.
Calling jwksMock.start() will use msw to intercept all
calls to

`typescript
;${jwksBase}${jwksPath ?? '/.well-known/jwks.json'}
`

. So when the jwks-rsa` middleware gets a token to validate it will fetch the
key to verify against from our local PKI instead of the production one and as
such, the token is valid when signed with the local private key.

Contributing

You found a bug or want to improve the software? Thank you for your support!
Before you open a PR I kindly invite you to read about
best practices
and subject your contribution to them.