Debug Simulator

debugSimulator.ts

import { IRefundRequest, ISaleRequest, IVoidRequest } from '../payment/paymentRequest'
import { IRefundResult, ISaleResult, IVoidResult } from '../payment/paymentResult'
import {
  DebugSimulatedRefundRequest,
  DebugSimulatedSaleRequest,
  DebugSimulatedVoidRequest,
} from './debugSimulatedRequest'

export type debugSimulatedRequest =
  | DebugSimulatedSaleRequest
  | DebugSimulatedRefundRequest
  | DebugSimulatedVoidRequest

export type transactionType = 'sale' | 'refund' | 'void'

export class DebugSimulator {
  public static sharedInstance = new DebugSimulator()
  private simulatedRequest: debugSimulatedRequest | undefined

  private callbacks = {
    refundRequestStarted: [] as Array<(request: DebugSimulatedRefundRequest) => void>,
    saleRequestStarted: [] as Array<(request: DebugSimulatedSaleRequest) => void>,
    voidRequestStarted: [] as Array<(request: DebugSimulatedVoidRequest) => void>,
  }
      
  public registerCallback(key: transactionType, callback: (request: debugSimulatedRequest) => void) {
    switch (key) {
      case 'sale':
        this.callbacks.saleRequestStarted.push(callback)
        return () => {
          this.callbacks.saleRequestStarted = this.callbacks.saleRequestStarted.filter(
            cb => cb !== callback,
          )
        }
      case 'refund':
        this.callbacks.refundRequestStarted.push(callback)
        return () => {
          this.callbacks.refundRequestStarted = this.callbacks.refundRequestStarted.filter(
            cb => cb !== callback,
          )
        }
      case 'void':
        this.callbacks.voidRequestStarted.push(callback)
        return () => {
          this.callbacks.voidRequestStarted = this.callbacks.voidRequestStarted.filter(
            cb => cb !== callback,
          )
        }
      default:
        throw new Error('Unknown request')
    }
  }

  public triggerCallbacks(key: transactionType) {
    switch (key) {
      case 'sale':
        this.callbacks.saleRequestStarted.forEach(callback =>
          callback(this.simulatedRequest as DebugSimulatedSaleRequest),
        )

      case 'refund':
        this.callbacks.refundRequestStarted.forEach(callback =>
          callback(this.simulatedRequest as DebugSimulatedRefundRequest),
        )
      
      case 'void':
        this.callbacks.voidRequestStarted.forEach(callback =>
          callback(this.simulatedRequest as DebugSimulatedVoidRequest),
        )
      
      default:
        throw new Error('Unknown request')
    }
  }
      
  public sale = (request: ISaleRequest): Promise<ISaleResult> => {
    this.simulatedRequest = new DebugSimulatedSaleRequest(request)
    this.triggerCallbacks('sale')
    return this.simulatedRequest.resultPromise!
  }

  public refund = (_: IRefundRequest): Promise<IRefundResult> => {
    this.simulatedRequest = new DebugSimulatedRefundRequest()
    this.triggerCallbacks('refund')
    return this.simulatedRequest.resultPromise!
  }

  public void = (_: IVoidRequest): Promise<IVoidResult> => {
    this.simulatedRequest = new DebugSimulatedVoidRequest()
    this.triggerCallbacks('void')
    return this.simulatedRequest.resultPromise as Promise<IVoidResult>
  }
}

const debugSimulator = DebugSimulator.sharedInstance

export default debugSimulator
      
      
 /*
      USAGE:
    
    Before:
    
      const remove = DebugSimulator.onSaleRequestStarted(request => {
        request.simulateResponse(failureResponse)
        remove()
      })
      
    After: 
    
    const remove = DebugSimulator.registerCallback('sale', (request => {
      const req = request as DebugSimulatedSaleRequest
      req.simulateResponse(successResponse)
      remove()
    }) as (request: debugSimulatedRequest) => void)
      
      
 */