account-lookup-service 17.7.1 → 17.8.0-snapshot.7

package/src/domain/parties/services/PutPartiesService.js

@@ -32,64 +32,82 @@ const BasePartiesService = require('./BasePartiesService')
 const { RestMethods } = BasePartiesService.enums()
 
 class PutPartiesService extends BasePartiesService {
-  // async handleRequest () {
-  //   // todo: add impl.
-  // }
-
-  async validateSourceParticipant ({ source, proxy }) {
-    this.deps.stepState.inProgress('validateSourceParticipant-1')
-    const requesterParticipant = await super.validateParticipant(source)
-
-    if (!requesterParticipant) {
-      if (!this.proxyEnabled || !proxy) {
-        const errMessage = ERROR_MESSAGES.sourceFspNotFound
-        this.log.warn(`${errMessage} and no proxy`, { source })
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+  async handleRequest () {
+    const { destination, source, proxy } = this.state
+    this.log.info('handleRequest start', { destination, source, proxy })
+
+    await this.validateSourceParticipant()
+    if (proxy) {
+      await this.checkProxySuccessResponse()
+    }
+    await this.identifyDestinationForSuccessCallback()
+    await this.sendSuccessCallback()
+  }
+
+  async validateSourceParticipant () {
+    const { source, proxy, proxyEnabled } = this.state
+    const log = this.log.child({ source, proxy, method: 'validateSourceParticipant' })
+    this.stepInProgress('validateSourceParticipant-1')
+
+    const schemeParticipant = await super.validateParticipant(source)
+    if (!schemeParticipant) {
+      if (!proxyEnabled || !proxy) {
+        throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.sourceFspNotFound, log)
       }
+
       const isCached = await this.deps.proxyCache.addDfspIdToProxyMapping(source, proxy)
       if (!isCached) {
-        const errMessage = 'failed to addDfspIdToProxyMapping'
-        this.log.warn(errMessage, { source, proxy })
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+        throw super.createFspiopIdNotFoundError('failed to addDfspIdToProxyMapping', log)
       }
 
-      this.log.info('addDfspIdToProxyMapping is done', { source, proxy })
+      log.info('addDfspIdToProxyMapping is done', { source, proxy })
     }
   }
 
-  async checkProxySuccessResponse ({ destination, source, headers, params }) {
-    if (this.proxyEnabled) {
-      this.deps.stepState.inProgress('checkProxySuccessResponse-2')
+  async checkProxySuccessResponse () {
+    if (this.state.proxyEnabled) {
+      this.stepInProgress('checkProxySuccessResponse')
+      const { headers, params } = this.inputs
+      const { destination, source } = this.state
       const alsReq = this.deps.partiesUtils.alsRequestDto(destination, params)
 
       const isExists = await this.deps.proxyCache.receivedSuccessResponse(alsReq)
-      if (isExists) {
-        await this.#updateOracleWithParticipantMapping({ source, headers, params })
+      if (!isExists) {
+        this.log.verbose('NOT inter-scheme receivedSuccessResponse case')
+        await this.removeProxyGetPartiesTimeoutCache(alsReq)
         return
       }
-      this.log.warn('destination is NOT in scheme, and no cached sendToProxiesList', { destination, alsReq })
-      // todo: think, if we need to throw an error here
+
+      const schemeParticipant = await super.validateParticipant(destination)
+      if (schemeParticipant) {
+        await this.#updateOracleWithParticipantMapping({ source, headers, params })
+      }
     }
   }
 
-  async identifyDestinationForSuccessCallback (destination) {
-    this.deps.stepState.inProgress('validateDestinationParticipant-4')
+  async identifyDestinationForSuccessCallback () {
+    const { destination } = this.state
+    this.stepInProgress('identifyDestinationForSuccessCallback')
     const destinationParticipant = await super.validateParticipant(destination)
     if (destinationParticipant) {
-      return destinationParticipant.name
+      this.state.requester = destinationParticipant.name
+      return
     }
 
-    const proxyName = this.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
+    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
     if (!proxyName) {
       const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
       this.log.warn(`${errMessage} and no proxy`, { destination })
       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
     }
-    return proxyName
+
+    this.state.requester = proxyName
   }
 
-  async sendSuccessCallback ({ sendTo, headers, params, dataUri }) {
-    this.deps.stepState.inProgress('#sendSuccessCallback-6')
+  async sendSuccessCallback () {
+    const { headers, params, dataUri } = this.inputs
+    const sendTo = this.state.requester
+    this.stepInProgress('sendSuccessCallback')
     const payload = PutPartiesService.decodeDataUriPayload(dataUri)
     const callbackEndpointType = this.deps.partiesUtils.putPartyCbType(params.SubId)
     const options = this.deps.partiesUtils.partiesRequestOptionsDto(params)
@@ -97,11 +115,11 @@ class PutPartiesService extends BasePartiesService {
     await this.deps.participant.sendRequest(
       headers, sendTo, callbackEndpointType, RestMethods.PUT, payload, options
     )
-    this.log.verbose('sendSuccessCallback is done', { sendTo, payload })
+    this.log.verbose('sendSuccessCallback is sent', { sendTo, payload })
   }
 
   async #updateOracleWithParticipantMapping ({ source, headers, params }) {
-    this.deps.stepState.inProgress('#updateOracleWithParticipantMapping-3')
+    this.stepInProgress('#updateOracleWithParticipantMapping-3')
     const mappingPayload = {
       fspId: source
     }

package/src/domain/parties/services/TimeoutPartiesService.js

@@ -0,0 +1,84 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const { AuditEventAction } = require('@mojaloop/event-sdk')
+const createSpan = require('../../timeout/createSpan') // todo: think, how to avoid this external deps
+const PutPartiesErrorService = require('./PutPartiesErrorService')
+
+class TimeoutPartiesService extends PutPartiesErrorService {
+  /**
+   *  Should be used to get TimeoutPartiesService instance
+   *
+   * @param deps {PartiesDeps}
+   * @param cacheKey {string}
+   * @param spanName {string}
+   * @returns {TimeoutPartiesService}
+   */
+  static createInstance (deps, cacheKey, spanName) {
+    const { destination, partyType, partyId } = TimeoutPartiesService.parseExpiredKey(cacheKey)
+    const headers = TimeoutPartiesService.createHubErrorCallbackHeaders(deps.config.HUB_NAME, destination)
+    const params = { Type: partyType, ID: partyId } // todo: think, if we need to handle party SubId
+    const childSpan = createSpan(spanName, headers, params)
+
+    return new TimeoutPartiesService({ ...deps, childSpan }, { headers, params })
+  }
+
+  async handleExpiredKey () {
+    const { errorInfo, headers, params } = await this.prepareErrorInformation()
+    this.#spanAuditStart(errorInfo)
+
+    await this.identifyDestinationForErrorCallback()
+    return super.sendErrorCallback({ errorInfo, headers, params })
+  }
+
+  async prepareErrorInformation () {
+    const { headers, params } = this.inputs
+    const error = TimeoutPartiesService.createFSPIOPExpiredError()
+    const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(
+      this.deps.config, error, headers, params
+    )
+    this.log.verbose('prepareErrorInformation is done', { errorInfo, headers, params })
+    return { errorInfo, headers, params }
+  }
+
+  #spanAuditStart (errorInformation) {
+    const { headers } = this.inputs
+    this.deps.childSpan?.audit({ errorInformation, headers }, AuditEventAction.start)
+  }
+
+  static parseExpiredKey (cacheKey) {
+    const [destination, partyType, partyId] = cacheKey.split(':').slice(-3)
+    return { destination, partyType, partyId }
+  }
+
+  static createFSPIOPExpiredError () {
+    return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.EXPIRED_ERROR)
+  }
+}
+
+module.exports = TimeoutPartiesService

package/src/domain/parties/services/index.js

@@ -28,9 +28,11 @@
 const GetPartiesService = require('./GetPartiesService')
 const PutPartiesService = require('./PutPartiesService')
 const PutPartiesErrorService = require('./PutPartiesErrorService')
+const TimeoutPartiesService = require('./TimeoutPartiesService')
 
 module.exports = {
   GetPartiesService,
   PutPartiesService,
-  PutPartiesErrorService
+  PutPartiesErrorService,
+  TimeoutPartiesService
 }

package/src/domain/timeout/createSpan.js

@@ -0,0 +1,55 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const {
+  Events: { Event },
+  Tags: { QueryTags }
+} = require('@mojaloop/central-services-shared').Enum
+const { Tracer } = require('@mojaloop/event-sdk')
+const EventFrameworkUtil = require('@mojaloop/central-services-shared').Util.EventFramework
+
+const { getSpanTags } = require('../../lib/util')
+
+const createSpan = (spanName, headers, params) => {
+  const span = Tracer.createSpan(spanName, { headers })
+  const spanTags = getSpanTags({ headers }, Event.Type.PARTY, Event.Action.PUT)
+  span.setTags(spanTags)
+  const queryTags = EventFrameworkUtil.Tags.getQueryTags(
+    QueryTags.serviceName.accountLookupService,
+    QueryTags.auditType.transactionFlow,
+    QueryTags.contentType.httpRequest,
+    QueryTags.operation.timeoutInterschemePartiesLookups,
+    {
+      partyIdType: params.Type,
+      partyIdentifier: params.ID
+    }
+  )
+  span.setTags(queryTags)
+  return span
+}
+
+module.exports = createSpan

package/src/domain/timeout/index.js

@@ -31,66 +31,56 @@
  ******/
 'use strict'
 
-const {
-  Factory: { createFSPIOPError, reformatFSPIOPError },
-  Enums: { FSPIOPErrorCodes }
-} = require('@mojaloop/central-services-error-handling')
-const {
-  EventStateMetadata,
-  EventStatusType,
-  AuditEventAction
-} = require('@mojaloop/event-sdk')
+const { Factory: { reformatFSPIOPError } } = require('@mojaloop/central-services-error-handling')
+const { EventStateMetadata, EventStatusType } = require('@mojaloop/event-sdk')
 const Metrics = require('@mojaloop/central-services-metrics')
 
-const Participant = require('../../models/participantEndpoint/facade')
-const { ERROR_MESSAGES } = require('../../constants')
-const { timeoutCallbackDto } = require('./dto')
 const { logger } = require('../../lib')
-const util = require('../../lib/util')
+const { countFspiopError } = require('../../lib/util')
+const { createDeps } = require('../parties/deps')
+const { TimeoutPartiesService } = require('../parties/services')
 
 const timeoutInterschemePartiesLookups = async ({ proxyCache, batchSize }) => {
-  return proxyCache.processExpiredAlsKeys(sendTimeoutCallback, batchSize)
+  const operation = timeoutInterschemePartiesLookups.name
+  logger.info(`${operation} start...`, { batchSize })
+  return proxyCache.processExpiredAlsKeys(
+    (key) => sendTimeoutCallback(key, proxyCache, operation), batchSize
+  )
 }
 
-const sendTimeoutCallback = async (cacheKey) => {
+const timeoutProxyGetPartiesLookups = async ({ proxyCache, batchSize }) => {
+  const operation = timeoutProxyGetPartiesLookups.name
+  logger.info(`${operation} start...`, { batchSize })
+  return proxyCache.processExpiredProxyGetPartiesKeys(
+    (key) => sendTimeoutCallback(key, proxyCache, operation), batchSize
+  )
+}
+
+const sendTimeoutCallback = async (cacheKey, proxyCache, operation) => {
   const histTimerEnd = Metrics.getHistogram(
     'eg_timeoutInterschemePartiesLookups',
     'Egress - Interscheme parties lookup timeout callback',
     ['success']
   ).startTimer()
-  let step
-  const [, destination, partyType, partyId] = cacheKey.split(':')
-  const { errorInformation, params, headers, endpointType, span } = await timeoutCallbackDto({ destination, partyId, partyType })
-  logger.debug('sendTimeoutCallback details:', { destination, partyType, partyId, cacheKey })
+  const log = logger.child({ cacheKey, operation })
+  const deps = createDeps({ proxyCache, log })
+  const service = TimeoutPartiesService.createInstance(deps, cacheKey, operation)
+  const span = service.deps.childSpan
 
   try {
-    step = 'validateParticipant-1'
-    await validateParticipant(destination)
-    await span.audit({ headers, errorInformation }, AuditEventAction.start)
-    step = 'sendErrorToParticipant-2'
-    await Participant.sendErrorToParticipant(destination, endpointType, errorInformation, headers, params, undefined, span)
+    await service.handleExpiredKey()
     histTimerEnd({ success: true })
   } catch (err) {
-    logger.warn('error in sendTimeoutCallback: ', err)
+    log.warn('error in sendTimeoutCallback: ', err)
     histTimerEnd({ success: false })
     const fspiopError = reformatFSPIOPError(err)
-    util.countFspiopError(fspiopError, { operation: 'sendTimeoutCallback', step })
+    countFspiopError(fspiopError, { operation, step: service?.currenStep })
 
     await finishSpan(span, fspiopError)
     throw fspiopError
   }
 }
 
-const validateParticipant = async (fspId) => {
-  const participant = await Participant.validateParticipant(fspId)
-  if (!participant) {
-    const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-    logger.error(`error in validateParticipant: ${errMessage}`)
-    throw createFSPIOPError(FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
-  }
-  return participant
-}
-
 const finishSpan = async (span, err) => {
   if (!span.isFinished) {
     const state = new EventStateMetadata(
@@ -105,5 +95,6 @@ const finishSpan = async (span, err) => {
 
 module.exports = {
   timeoutInterschemePartiesLookups,
+  timeoutProxyGetPartiesLookups,
   sendTimeoutCallback // Exposed for testing
 }

package/src/handlers/TimeoutHandler.js

@@ -41,13 +41,13 @@ let isRunning
 
 const timeout = async (options) => {
   if (isRunning) return
-
   const { logger } = options
 
   try {
     isRunning = true
-    logger.debug('Timeout handler triggered')
     await TimeoutService.timeoutInterschemePartiesLookups(options)
+    await TimeoutService.timeoutProxyGetPartiesLookups(options)
+    logger.verbose('ALS timeout handler is done')
   } catch (err) {
     logger.error('error in timeout: ', err)
   } finally {

package/src/lib/util.js

@@ -29,10 +29,11 @@ const util = require('node:util')
 const Path = require('node:path')
 const EventSdk = require('@mojaloop/event-sdk')
 const Enum = require('@mojaloop/central-services-shared').Enum
-const { HeaderValidation, Hapi } = require('@mojaloop/central-services-shared').Util
+const { HeaderValidation } = require('@mojaloop/central-services-shared').Util
 const rethrow = require('@mojaloop/central-services-shared').Util.rethrow.with('ALS')
 
 const Config = require('../lib/config')
+const { API_TYPES } = require('../constants')
 const { logger } = require('./index')
 
 const getSpanTags = ({ headers }, transactionType, transactionAction) => {
@@ -69,7 +70,7 @@ const pathForInterface = ({ isAdmin, isMockInterface }) => {
     if (isMockInterface) {
       apiFile = 'api_swagger.json'
     } else {
-      apiFile = Config.API_TYPE === Hapi.API_TYPES.iso20022
+      apiFile = Config.API_TYPE === API_TYPES.iso20022
         ? 'api-swagger-iso20022-parties.yaml'
         : 'api-swagger.yaml'
     }
@@ -100,7 +101,14 @@ const countFspiopError = (error, options) => {
   rethrow.countFspiopError(error, options)
 }
 
-// todo: think better name
+/**
+ *  An immutable object representing the step state
+ * @typedef {Object} StepState
+ * @property {string} step - The current step value (read-only getter property)
+ * @property {(string) => void} inProgress - Method to update the current step
+ */
+
+/** @returns {StepState} */
 const initStepState = (initStep = 'start') => {
   let step = initStep
   return Object.freeze({

package/test/fixtures/index.js

@@ -1,3 +1,30 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
 const { randomUUID } = require('node:crypto')
 const { Enum } = require('@mojaloop/central-services-shared')
 const isoFixtures = require('./iso')
@@ -20,6 +47,16 @@ const headersDto = ({
   'content-type': contentType || accept
 })
 
+const partiesParamsDto = ({
+  Type = 'MSISDN',
+  ID = String(Date.now()),
+  SubId
+} = {}) => ({
+  Type,
+  ID,
+  ...(SubId && { SubId })
+})
+
 const protocolVersionsDto = () => ({
   CONTENT: {
     DEFAULT: '2.1',
@@ -126,6 +163,13 @@ const mockAlsRequestDto = (sourceId, type, partyId) => ({
   partyId
 })
 
+const expiredCacheKeyDto = ({
+  sourceId = 'sourceId',
+  type = 'MSISDN',
+  partyId = 'partyId-123',
+  prefix = 'prefix'
+} = {}) => `${prefix}:${sourceId}:${type}:${partyId}`
+
 const mockHapiRequestDto = ({ // https://hapi.dev/api/?v=21.3.3#request-properties
   method = 'GET',
   traceid = randomUUID(),
@@ -142,11 +186,13 @@ const mockHapiRequestDto = ({ // https://hapi.dev/api/?v=21.3.3#request-properti
 module.exports = {
   ...isoFixtures,
   partiesCallHeadersDto,
+  partiesParamsDto,
   participantsCallHeadersDto,
   oracleRequestResponseDto,
   putPartiesSuccessResponseDto,
   postParticipantsPayloadDto,
   errorCallbackResponseDto,
+  expiredCacheKeyDto,
   mockAlsRequestDto,
   protocolVersionsDto,
   mockHapiRequestDto,

package/test/integration/domain/timeout/index.test.js

@@ -1,18 +1,50 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
 const { createProxyCache } = require('@mojaloop/inter-scheme-proxy-cache-lib')
-const { PAYER_DFSP, PARTY_ID_TYPE, PROXY_NAME } = require('../../constants')
+const { RedisProxyCache } = require('@mojaloop/inter-scheme-proxy-cache-lib/dist/lib/storages/RedisProxyCache')
+const config = require('#src/lib/config')
 const fixtures = require('../../../fixtures')
 const { ProxyApiClient } = require('../../../util')
-const config = require('../../../../src/lib/config')
+const { PAYER_DFSP, PARTY_ID_TYPE, PROXY_NAME } = require('../../constants')
 
 const wait = (sec) => new Promise(resolve => setTimeout(resolve, sec * 1000))
 
 const CRON_TIMEOUT_SEC = 15 // see TIMEXP
 
+jest.setTimeout(60_000)
+
 describe('Timeout Handler', () => {
   const { type, proxyConfig } = config.PROXY_CACHE_CONFIG
   const proxyCache = createProxyCache(type, proxyConfig)
   const proxyClient = new ProxyApiClient()
 
+  const checkKeysExistence = async (keys) => Promise.all(keys.map(key => proxyCache.redisClient.exists(key)))
+
   beforeAll(async () => {
     await proxyCache.connect()
     const redisClient = proxyCache.redisClient
@@ -22,6 +54,11 @@ describe('Timeout Handler', () => {
     }))
   })
 
+  beforeEach(async () => {
+    const history = await proxyClient.deleteHistory()
+    expect(history).toEqual([])
+  })
+
   afterAll(async () => {
     return Promise.all([
       proxyClient.deleteHistory(),
@@ -29,47 +66,65 @@ describe('Timeout Handler', () => {
     ])
   })
 
-  it('test', async () => {
-    let history = await proxyClient.deleteHistory()
-    expect(history).toEqual([])
-
-    // send a couple of keys to redis
-    const partyIds = ['1234567', '7654321']
-    const keys = [
-      `'als:${PAYER_DFSP}:${PARTY_ID_TYPE}:${partyIds[0]}:expiresAt'`,
-      `'als:${PAYER_DFSP}:${PARTY_ID_TYPE}:${partyIds[1]}:expiresAt'`
-    ]
+  it('should pass timeoutInterschemePartiesLookups flow', async () => {
+    const partyIds = [`isp1-${Date.now()}`, `isp2-${Date.now()}`]
     const proxies = [PROXY_NAME]
     const alsReq1 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyIds[0])
     const alsReq2 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyIds[1])
+    const keys = [
+      RedisProxyCache.formatAlsCacheExpiryKey(alsReq1),
+      RedisProxyCache.formatAlsCacheExpiryKey(alsReq2)
+    ]
+    // send a couple of keys to redis
     const results = await Promise.all([
       proxyCache.setSendToProxiesList(alsReq1, proxies, CRON_TIMEOUT_SEC),
       proxyCache.setSendToProxiesList(alsReq2, proxies, CRON_TIMEOUT_SEC)
     ])
-    expect(results.includes(false)).toBe(false)
+    expect(results).toEqual([true, true])
+    expect(await checkKeysExistence(keys)).toEqual([1, 1])
 
     // wait for the timeout handler to process the keys
     await wait(CRON_TIMEOUT_SEC * 1.5)
+    const history = await proxyClient.waitForNHistoryCalls(2)
 
     // check that the keys are no longer in redis
-    const exists = await Promise.all(keys.map(key => proxyCache.redisClient.exists(key)))
-    expect(exists.includes(1)).toBe(false)
-
-    // check that the callbacks are sent and received at the FSP
-    // for test resilience, we will retry the history check a few times
-    const retryMaxCount = 20
-    const retryIntervalSec = 2
-    let retryCount = 0
-
-    while (history.length < 2 && retryCount < retryMaxCount) {
-      await wait(retryIntervalSec)
-      history = await proxyClient.getHistory()
-      retryCount++
-    }
+    expect(await checkKeysExistence(keys)).toEqual([0, 0])
+
     expect(history.length).toBe(2)
     const path0 = history.find(h => h.path.includes(partyIds[0])).path
     const path1 = history.find(h => h.path.includes(partyIds[1])).path
     expect(path0).toBe(`/parties/${PARTY_ID_TYPE}/${partyIds[0]}/error`)
     expect(path1).toBe(`/parties/${PARTY_ID_TYPE}/${partyIds[1]}/error`)
-  }, 60_000)
+  })
+
+  it('should pass timeoutProxyGetPartiesLookups flow', async () => {
+    const partyId1 = `pgp1-${Date.now()}`
+    const partyId2 = `pgp2-${Date.now()}`
+    const alsReq1 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyId1)
+    const alsReq2 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyId2)
+    const keys = [
+      RedisProxyCache.formatProxyGetPartiesExpiryKey(alsReq1, PROXY_NAME),
+      RedisProxyCache.formatProxyGetPartiesExpiryKey(alsReq2, PROXY_NAME)
+    ]
+    // send a couple of keys to redis
+    const results = await Promise.all([
+      proxyCache.setProxyGetPartiesTimeout(alsReq1, PROXY_NAME, CRON_TIMEOUT_SEC),
+      proxyCache.setProxyGetPartiesTimeout(alsReq2, PROXY_NAME, CRON_TIMEOUT_SEC)
+    ])
+    expect(results).toEqual([true, true])
+    expect(await checkKeysExistence(keys)).toEqual([1, 1])
+
+    // wait for the timeout handler to process the keys
+    await wait(CRON_TIMEOUT_SEC * 1.5)
+    const history = await proxyClient.waitForNHistoryCalls(2)
+
+    // check that the keys are no longer in redis
+    expect(await checkKeysExistence(keys)).toEqual([0, 0])
+
+    expect(history.length).toBe(2)
+    const path1 = history.find(h => h.path.includes(partyId1)).path
+    const path2 = history.find(h => h.path.includes(partyId2)).path
+    expect(path1).toBe(`/parties/${PARTY_ID_TYPE}/${partyId1}/error`)
+    expect(path2).toBe(`/parties/${PARTY_ID_TYPE}/${partyId2}/error`)
+  })
 })