gradido/shared/src/jwt/JWT.test.ts

// import { testEnvironment } from '@test/helpers'
// import { logger } from '@test/testSetup'

import {
  createKeyPair,
  decode,
  decrypt,
  encode,
  encrypt,
  encryptAndSign,
  verify,
  verifyAndDecrypt,
} from './JWT'
import { EncryptedJWEJwtPayloadType } from './payloadtypes/EncryptedJWEJwtPayloadType'
import { OpenConnectionJwtPayloadType } from './payloadtypes/OpenConnectionJwtPayloadType'

// let con: DataSource
// let testEnv: {
//  mutate: ApolloServerTestClient['mutate']
//  query: ApolloServerTestClient['query']
//  con: DataSource
// }
let keypairComA: { publicKey: string; privateKey: string }
let keypairComB: { publicKey: string; privateKey: string }

beforeAll(async () => {
  //  testEnv = await testEnvironment(logger)
  //  con = testEnv.con
  //  await cleanDB()

  keypairComA = await createKeyPair()
  keypairComB = await createKeyPair()
})

afterAll(async () => {
  // await cleanDB()
  // await con.destroy()
})

describe('test JWS creation and verification', () => {
  let jwsComA: string
  let jwsComB: string
  beforeEach(async () => {
    jest.clearAllMocks()
    jwsComA = await encode(
      new OpenConnectionJwtPayloadType('handshakeID', 'http://localhost:5001/api/'),
      keypairComA.privateKey,
    )
    jwsComB = await encode(
      new OpenConnectionJwtPayloadType('handshakeID', 'http://localhost:5002/api/'),
      keypairComB.privateKey,
    )
  })
  it('decode jwsComA', async () => {
    const decodedJwsComA = await decode(jwsComA)
    expect(decodedJwsComA).toEqual({
      expiration: '10m',
      handshakeID: 'handshakeID',
      tokentype: OpenConnectionJwtPayloadType.OPEN_CONNECTION_TYPE,
      url: 'http://localhost:5001/api/',
    })
  })
  it('decode jwsComB', async () => {
    const decodedJwsComB = await decode(jwsComB)
    expect(decodedJwsComB).toEqual({
      expiration: '10m',
      handshakeID: 'handshakeID',
      tokentype: OpenConnectionJwtPayloadType.OPEN_CONNECTION_TYPE,
      url: 'http://localhost:5002/api/',
    })
  })
  it('verify jwsComA', async () => {
    const verifiedJwsComA = await verify('handshakeID', jwsComA, keypairComA.publicKey)
    expect(verifiedJwsComA).toEqual(
      expect.objectContaining({
        payload: expect.objectContaining({
          tokentype: OpenConnectionJwtPayloadType.OPEN_CONNECTION_TYPE,
          url: 'http://localhost:5001/api/',
        }),
      }),
    )
  })
  it('verify jwsComB', async () => {
    const verifiedJwsComB = await verify('handshakeID', jwsComB, keypairComB.publicKey)
    expect(verifiedJwsComB).toEqual(
      expect.objectContaining({
        payload: expect.objectContaining({
          tokentype: OpenConnectionJwtPayloadType.OPEN_CONNECTION_TYPE,
          url: 'http://localhost:5002/api/',
        }),
      }),
    )
  })
})

describe('test JWE encryption and decryption', () => {
  let jweComA: string
  let jweComB: string
  beforeEach(async () => {
    jest.clearAllMocks()
    jweComA = await encrypt(
      new OpenConnectionJwtPayloadType('handshakeID', 'http://localhost:5001/api/'),
      keypairComB.publicKey,
    )
    jweComB = await encrypt(
      new OpenConnectionJwtPayloadType('handshakeID', 'http://localhost:5002/api/'),
      keypairComA.publicKey,
    )
  })
  it('decrypt jweComA', async () => {
    const decryptedAJwT = await decrypt('handshakeID', jweComA, keypairComB.privateKey)
    expect(JSON.parse(decryptedAJwT)).toEqual(
      expect.objectContaining({
        tokentype: OpenConnectionJwtPayloadType.OPEN_CONNECTION_TYPE,
        url: 'http://localhost:5001/api/',
        handshakeID: 'handshakeID',
      }),
    )
  })
  it('decrypt jweComB', async () => {
    const decryptedBJwT = await decrypt('handshakeID', jweComB, keypairComA.privateKey)
    expect(JSON.parse(decryptedBJwT)).toEqual(
      expect.objectContaining({
        tokentype: OpenConnectionJwtPayloadType.OPEN_CONNECTION_TYPE,
        url: 'http://localhost:5002/api/',
        handshakeID: 'handshakeID',
      }),
    )
  })
})

describe('test encrypted and signed JWT', () => {
  let jweComA: string
  let jwsComA: string
  let jweComB: string
  let jwsComB: string
  beforeEach(async () => {
    jest.clearAllMocks()
    jweComA = await encrypt(
      new OpenConnectionJwtPayloadType('handshakeID', 'http://localhost:5001/api/'),
      keypairComB.publicKey,
    )
    jwsComA = await encode(
      new EncryptedJWEJwtPayloadType('handshakeID', jweComA),
      keypairComA.privateKey,
    )
    jweComB = await encrypt(
      new OpenConnectionJwtPayloadType('handshakeID', 'http://localhost:5002/api/'),
      keypairComA.publicKey,
    )
    jwsComB = await encode(
      new EncryptedJWEJwtPayloadType('handshakeID', jweComB),
      keypairComB.privateKey,
    )
  })
  it('verify jwsComA', async () => {
    const verifiedJwsComA = await verify('handshakeID', jwsComA, keypairComA.publicKey)
    expect(verifiedJwsComA).toEqual(
      expect.objectContaining({
        payload: expect.objectContaining({
          jwe: jweComA,
          tokentype: EncryptedJWEJwtPayloadType.ENCRYPTED_JWE_TYPE,
          handshakeID: 'handshakeID',
        }),
      }),
    )
  })
  it('verify jwsComB', async () => {
    const verifiedJwsComB = await verify('handshakeID', jwsComB, keypairComB.publicKey)
    expect(verifiedJwsComB).toEqual(
      expect.objectContaining({
        payload: expect.objectContaining({
          jwe: jweComB,
          tokentype: EncryptedJWEJwtPayloadType.ENCRYPTED_JWE_TYPE,
          handshakeID: 'handshakeID',
        }),
      }),
    )
  })
  it('decrypt jweComA', async () => {
    expect(JSON.parse(await decrypt('handshakeID', jweComA, keypairComB.privateKey))).toEqual(
      expect.objectContaining({
        tokentype: OpenConnectionJwtPayloadType.OPEN_CONNECTION_TYPE,
        url: 'http://localhost:5001/api/',
        handshakeID: 'handshakeID',
      }),
    )
  })
  it('decrypt jweComB', async () => {
    expect(JSON.parse(await decrypt('handshakeID', jweComB, keypairComA.privateKey))).toEqual(
      expect.objectContaining({
        tokentype: OpenConnectionJwtPayloadType.OPEN_CONNECTION_TYPE,
        url: 'http://localhost:5002/api/',
        handshakeID: 'handshakeID',
      }),
    )
  })
})

describe('test encryptAndSign and verifyAndDecrypt', () => {
  let jwtComA: string
  beforeEach(async () => {
    jest.clearAllMocks()
    jwtComA = await encryptAndSign(
      new OpenConnectionJwtPayloadType('handshakeID', 'http://localhost:5001/api/'),
      keypairComA.privateKey,
      keypairComB.publicKey,
    )
  })
  it('verifyAndDecrypt jwtComA', async () => {
    const verifiedAndDecryptedPayload = await verifyAndDecrypt(
      'handshakeID',
      jwtComA,
      keypairComB.privateKey,
      keypairComA.publicKey,
    )
    expect(verifiedAndDecryptedPayload).toEqual(
      expect.objectContaining({
        tokentype: OpenConnectionJwtPayloadType.OPEN_CONNECTION_TYPE,
        url: 'http://localhost:5001/api/',
        handshakeID: 'handshakeID',
      }),
    )
  })
})