@emiliosp/pi-maestro 0.16.0 → 0.18.0

package/node_modules/undici/lib/mock/mock-call-history.js

@@ -1,248 +0,0 @@
-'use strict'
-
-const { kMockCallHistoryAddLog } = require('./mock-symbols')
-const { InvalidArgumentError } = require('../core/errors')
-
-function handleFilterCallsWithOptions (criteria, options, handler, store, allLogs) {
-  switch (options.operator) {
-    case 'OR':
-      store.push(...handler(criteria, allLogs))
-
-      return store
-    case 'AND':
-      return handler(criteria, store)
-    default:
-      // guard -- should never happens because buildAndValidateFilterCallsOptions is called before
-      throw new InvalidArgumentError('options.operator must to be a case insensitive string equal to \'OR\' or \'AND\'')
-  }
-}
-
-function buildAndValidateFilterCallsOptions (options = {}) {
-  const finalOptions = {}
-
-  if ('operator' in options) {
-    if (typeof options.operator !== 'string' || (options.operator.toUpperCase() !== 'OR' && options.operator.toUpperCase() !== 'AND')) {
-      throw new InvalidArgumentError('options.operator must to be a case insensitive string equal to \'OR\' or \'AND\'')
-    }
-
-    return {
-      ...finalOptions,
-      operator: options.operator.toUpperCase()
-    }
-  }
-
-  return finalOptions
-}
-
-function makeFilterCalls (parameterName) {
-  return (parameterValue, logs = this.logs) => {
-    if (typeof parameterValue === 'string' || parameterValue == null) {
-      return logs.filter((log) => {
-        return log[parameterName] === parameterValue
-      })
-    }
-    if (parameterValue instanceof RegExp) {
-      return logs.filter((log) => {
-        return parameterValue.test(log[parameterName])
-      })
-    }
-
-    throw new InvalidArgumentError(`${parameterName} parameter should be one of string, regexp, undefined or null`)
-  }
-}
-function computeUrlWithMaybeSearchParameters (requestInit) {
-  // path can contains query url parameters
-  // or query can contains query url parameters
-  try {
-    const url = new URL(requestInit.path, requestInit.origin)
-
-    // requestInit.path contains query url parameters
-    // requestInit.query is then undefined
-    if (url.search.length !== 0) {
-      return url
-    }
-
-    // requestInit.query can be populated here
-    url.search = new URLSearchParams(requestInit.query).toString()
-
-    return url
-  } catch (error) {
-    throw new InvalidArgumentError('An error occurred when computing MockCallHistoryLog.url', { cause: error })
-  }
-}
-
-class MockCallHistoryLog {
-  constructor (requestInit = {}) {
-    this.body = requestInit.body
-    this.headers = requestInit.headers
-    this.method = requestInit.method
-
-    const url = computeUrlWithMaybeSearchParameters(requestInit)
-
-    this.fullUrl = url.toString()
-    this.origin = url.origin
-    this.path = url.pathname
-    this.searchParams = Object.fromEntries(url.searchParams)
-    this.protocol = url.protocol
-    this.host = url.host
-    this.port = url.port
-    this.hash = url.hash
-  }
-
-  toMap () {
-    return new Map([
-      ['protocol', this.protocol],
-      ['host', this.host],
-      ['port', this.port],
-      ['origin', this.origin],
-      ['path', this.path],
-      ['hash', this.hash],
-      ['searchParams', this.searchParams],
-      ['fullUrl', this.fullUrl],
-      ['method', this.method],
-      ['body', this.body],
-      ['headers', this.headers]]
-    )
-  }
-
-  toString () {
-    const options = { betweenKeyValueSeparator: '->', betweenPairSeparator: '|' }
-    let result = ''
-
-    this.toMap().forEach((value, key) => {
-      if (typeof value === 'string' || value === undefined || value === null) {
-        result = `${result}${key}${options.betweenKeyValueSeparator}${value}${options.betweenPairSeparator}`
-      }
-      if ((typeof value === 'object' && value !== null) || Array.isArray(value)) {
-        result = `${result}${key}${options.betweenKeyValueSeparator}${JSON.stringify(value)}${options.betweenPairSeparator}`
-      }
-      // maybe miss something for non Record / Array headers and searchParams here
-    })
-
-    // delete last betweenPairSeparator
-    return result.slice(0, -1)
-  }
-}
-
-class MockCallHistory {
-  logs = []
-
-  calls () {
-    return this.logs
-  }
-
-  firstCall () {
-    return this.logs.at(0)
-  }
-
-  lastCall () {
-    return this.logs.at(-1)
-  }
-
-  nthCall (number) {
-    if (typeof number !== 'number') {
-      throw new InvalidArgumentError('nthCall must be called with a number')
-    }
-    if (!Number.isInteger(number)) {
-      throw new InvalidArgumentError('nthCall must be called with an integer')
-    }
-    if (Math.sign(number) !== 1) {
-      throw new InvalidArgumentError('nthCall must be called with a positive value. use firstCall or lastCall instead')
-    }
-
-    // non zero based index. this is more human readable
-    return this.logs.at(number - 1)
-  }
-
-  filterCalls (criteria, options) {
-    // perf
-    if (this.logs.length === 0) {
-      return this.logs
-    }
-    if (typeof criteria === 'function') {
-      return this.logs.filter(criteria)
-    }
-    if (criteria instanceof RegExp) {
-      return this.logs.filter((log) => {
-        return criteria.test(log.toString())
-      })
-    }
-    if (typeof criteria === 'object' && criteria !== null) {
-      // no criteria - returning all logs
-      if (Object.keys(criteria).length === 0) {
-        return this.logs
-      }
-
-      const finalOptions = { operator: 'OR', ...buildAndValidateFilterCallsOptions(options) }
-
-      let maybeDuplicatedLogsFiltered = finalOptions.operator === 'AND' ? this.logs : []
-      if ('protocol' in criteria) {
-        maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.protocol, finalOptions, this.filterCallsByProtocol, maybeDuplicatedLogsFiltered, this.logs)
-      }
-      if ('host' in criteria) {
-        maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.host, finalOptions, this.filterCallsByHost, maybeDuplicatedLogsFiltered, this.logs)
-      }
-      if ('port' in criteria) {
-        maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.port, finalOptions, this.filterCallsByPort, maybeDuplicatedLogsFiltered, this.logs)
-      }
-      if ('origin' in criteria) {
-        maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.origin, finalOptions, this.filterCallsByOrigin, maybeDuplicatedLogsFiltered, this.logs)
-      }
-      if ('path' in criteria) {
-        maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.path, finalOptions, this.filterCallsByPath, maybeDuplicatedLogsFiltered, this.logs)
-      }
-      if ('hash' in criteria) {
-        maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.hash, finalOptions, this.filterCallsByHash, maybeDuplicatedLogsFiltered, this.logs)
-      }
-      if ('fullUrl' in criteria) {
-        maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.fullUrl, finalOptions, this.filterCallsByFullUrl, maybeDuplicatedLogsFiltered, this.logs)
-      }
-      if ('method' in criteria) {
-        maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.method, finalOptions, this.filterCallsByMethod, maybeDuplicatedLogsFiltered, this.logs)
-      }
-
-      const uniqLogsFiltered = [...new Set(maybeDuplicatedLogsFiltered)]
-
-      return uniqLogsFiltered
-    }
-
-    throw new InvalidArgumentError('criteria parameter should be one of function, regexp, or object')
-  }
-
-  filterCallsByProtocol = makeFilterCalls.call(this, 'protocol')
-
-  filterCallsByHost = makeFilterCalls.call(this, 'host')
-
-  filterCallsByPort = makeFilterCalls.call(this, 'port')
-
-  filterCallsByOrigin = makeFilterCalls.call(this, 'origin')
-
-  filterCallsByPath = makeFilterCalls.call(this, 'path')
-
-  filterCallsByHash = makeFilterCalls.call(this, 'hash')
-
-  filterCallsByFullUrl = makeFilterCalls.call(this, 'fullUrl')
-
-  filterCallsByMethod = makeFilterCalls.call(this, 'method')
-
-  clear () {
-    this.logs = []
-  }
-
-  [kMockCallHistoryAddLog] (requestInit) {
-    const log = new MockCallHistoryLog(requestInit)
-
-    this.logs.push(log)
-
-    return log
-  }
-
-  * [Symbol.iterator] () {
-    for (const log of this.calls()) {
-      yield log
-    }
-  }
-}
-
-module.exports.MockCallHistory = MockCallHistory
-module.exports.MockCallHistoryLog = MockCallHistoryLog

package/node_modules/undici/lib/mock/mock-client.js

@@ -1,68 +0,0 @@
-'use strict'
-
-const { promisify } = require('node:util')
-const Client = require('../dispatcher/client')
-const { buildMockDispatch } = require('./mock-utils')
-const {
-  kDispatches,
-  kMockAgent,
-  kClose,
-  kOriginalClose,
-  kOrigin,
-  kOriginalDispatch,
-  kConnected,
-  kIgnoreTrailingSlash
-} = require('./mock-symbols')
-const { MockInterceptor } = require('./mock-interceptor')
-const Symbols = require('../core/symbols')
-const { InvalidArgumentError } = require('../core/errors')
-
-/**
- * MockClient provides an API that extends the Client to influence the mockDispatches.
- */
-class MockClient extends Client {
-  constructor (origin, opts) {
-    if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') {
-      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
-    }
-
-    super(origin, opts)
-
-    this[kMockAgent] = opts.agent
-    this[kOrigin] = origin
-    this[kIgnoreTrailingSlash] = opts.ignoreTrailingSlash ?? false
-    this[kDispatches] = []
-    this[kConnected] = 1
-    this[kOriginalDispatch] = this.dispatch
-    this[kOriginalClose] = this.close.bind(this)
-
-    this.dispatch = buildMockDispatch.call(this)
-    this.close = this[kClose]
-  }
-
-  get [Symbols.kConnected] () {
-    return this[kConnected]
-  }
-
-  /**
-   * Sets up the base interceptor for mocking replies from undici.
-   */
-  intercept (opts) {
-    return new MockInterceptor(
-      opts && { ignoreTrailingSlash: this[kIgnoreTrailingSlash], ...opts },
-      this[kDispatches]
-    )
-  }
-
-  cleanMocks () {
-    this[kDispatches] = []
-  }
-
-  async [kClose] () {
-    await promisify(this[kOriginalClose])()
-    this[kConnected] = 0
-    this[kMockAgent][Symbols.kClients].delete(this[kOrigin])
-  }
-}
-
-module.exports = MockClient

package/node_modules/undici/lib/mock/mock-errors.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const { UndiciError } = require('../core/errors')
-
-const kMockNotMatchedError = Symbol.for('undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED')
-
-/**
- * The request does not match any registered mock dispatches.
- */
-class MockNotMatchedError extends UndiciError {
-  constructor (message) {
-    super(message)
-    this.name = 'MockNotMatchedError'
-    this.message = message || 'The request does not match any registered mock dispatches'
-    this.code = 'UND_MOCK_ERR_MOCK_NOT_MATCHED'
-  }
-
-  static [Symbol.hasInstance] (instance) {
-    return instance && instance[kMockNotMatchedError] === true
-  }
-
-  get [kMockNotMatchedError] () {
-    return true
-  }
-}
-
-module.exports = {
-  MockNotMatchedError
-}

package/node_modules/undici/lib/mock/mock-interceptor.js

@@ -1,227 +0,0 @@
-'use strict'
-
-const { getResponseData, buildKey, addMockDispatch } = require('./mock-utils')
-const {
-  kDispatches,
-  kDispatchKey,
-  kDefaultHeaders,
-  kDefaultTrailers,
-  kContentLength,
-  kMockDispatch,
-  kIgnoreTrailingSlash
-} = require('./mock-symbols')
-const { InvalidArgumentError } = require('../core/errors')
-const { serializePathWithQuery } = require('../core/util')
-const {
-  types: {
-    isPromise
-  }
-} = require('node:util')
-
-/**
- * Defines the scope API for an interceptor reply
- */
-class MockScope {
-  constructor (mockDispatch) {
-    this[kMockDispatch] = mockDispatch
-  }
-
-  /**
-   * Delay a reply by a set amount in ms.
-   */
-  delay (waitInMs) {
-    if (typeof waitInMs !== 'number' || !Number.isInteger(waitInMs) || waitInMs <= 0) {
-      throw new InvalidArgumentError('waitInMs must be a valid integer > 0')
-    }
-
-    this[kMockDispatch].delay = waitInMs
-    return this
-  }
-
-  /**
-   * For a defined reply, never mark as consumed.
-   */
-  persist () {
-    this[kMockDispatch].persist = true
-    return this
-  }
-
-  /**
-   * Allow one to define a reply for a set amount of matching requests.
-   */
-  times (repeatTimes) {
-    if (typeof repeatTimes !== 'number' || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
-      throw new InvalidArgumentError('repeatTimes must be a valid integer > 0')
-    }
-
-    this[kMockDispatch].times = repeatTimes
-    return this
-  }
-}
-
-/**
- * Defines an interceptor for a Mock
- */
-class MockInterceptor {
-  constructor (opts, mockDispatches) {
-    if (typeof opts !== 'object') {
-      throw new InvalidArgumentError('opts must be an object')
-    }
-    if (typeof opts.path === 'undefined') {
-      throw new InvalidArgumentError('opts.path must be defined')
-    }
-    if (typeof opts.method === 'undefined') {
-      opts.method = 'GET'
-    }
-    // See https://github.com/nodejs/undici/issues/1245
-    // As per RFC 3986, clients are not supposed to send URI
-    // fragments to servers when they retrieve a document,
-    if (typeof opts.path === 'string') {
-      if (opts.query) {
-        opts.path = serializePathWithQuery(opts.path, opts.query)
-      } else {
-        // Matches https://github.com/nodejs/undici/blob/main/lib/web/fetch/index.js#L1811
-        const parsedURL = new URL(opts.path, 'data://')
-        opts.path = parsedURL.pathname + parsedURL.search
-      }
-    }
-    if (typeof opts.method === 'string') {
-      opts.method = opts.method.toUpperCase()
-    }
-
-    this[kDispatchKey] = buildKey(opts)
-    this[kDispatches] = mockDispatches
-    this[kIgnoreTrailingSlash] = opts.ignoreTrailingSlash ?? false
-    this[kDefaultHeaders] = {}
-    this[kDefaultTrailers] = {}
-    this[kContentLength] = false
-  }
-
-  createMockScopeDispatchData ({ statusCode, data, responseOptions }) {
-    const responseData = getResponseData(data)
-    const contentLength = this[kContentLength] ? { 'content-length': responseData.length } : {}
-    const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }
-    const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers }
-
-    return { statusCode, data, headers, trailers }
-  }
-
-  validateReplyParameters (replyParameters) {
-    if (typeof replyParameters.statusCode === 'undefined') {
-      throw new InvalidArgumentError('statusCode must be defined')
-    }
-    if (typeof replyParameters.responseOptions !== 'object' || replyParameters.responseOptions === null) {
-      throw new InvalidArgumentError('responseOptions must be an object')
-    }
-  }
-
-  /**
-   * Mock an undici request with a defined reply.
-   */
-  reply (replyOptionsCallbackOrStatusCode) {
-    // Values of reply aren't available right now as they
-    // can only be available when the reply callback is invoked.
-    if (typeof replyOptionsCallbackOrStatusCode === 'function') {
-      // Resolves the data returned by a reply options callback into
-      // dispatch data, validating its format along the way.
-      const resolveReplyCallbackData = (resolvedData) => {
-        // Check if it is in the right format
-        if (typeof resolvedData !== 'object' || resolvedData === null) {
-          throw new InvalidArgumentError('reply options callback must return an object')
-        }
-
-        const replyParameters = { data: '', responseOptions: {}, ...resolvedData }
-        this.validateReplyParameters(replyParameters)
-        // Since the values can be obtained immediately we return them
-        // from this higher order function that will be resolved later.
-        return {
-          ...this.createMockScopeDispatchData(replyParameters)
-        }
-      }
-
-      // We'll first wrap the provided callback in another function,
-      // this function will properly resolve the data from the callback
-      // when invoked.
-      const wrappedDefaultsCallback = (opts) => {
-        // Our reply options callback contains the parameter for statusCode, data and options.
-        const resolvedData = replyOptionsCallbackOrStatusCode(opts)
-
-        // An asynchronous reply options callback resolves to the reply
-        // parameters, so the dispatch data can only be resolved once the
-        // returned promise settles.
-        if (isPromise(resolvedData)) {
-          return resolvedData.then(resolveReplyCallbackData)
-        }
-
-        return resolveReplyCallbackData(resolvedData)
-      }
-
-      // Add usual dispatch data, but this time set the data parameter to function that will eventually provide data.
-      const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback, { ignoreTrailingSlash: this[kIgnoreTrailingSlash] })
-      return new MockScope(newMockDispatch)
-    }
-
-    // We can have either one or three parameters, if we get here,
-    // we should have 1-3 parameters. So we spread the arguments of
-    // this function to obtain the parameters, since replyData will always
-    // just be the statusCode.
-    const replyParameters = {
-      statusCode: replyOptionsCallbackOrStatusCode,
-      data: arguments[1] === undefined ? '' : arguments[1],
-      responseOptions: arguments[2] === undefined ? {} : arguments[2]
-    }
-    this.validateReplyParameters(replyParameters)
-
-    // Send in-already provided data like usual
-    const dispatchData = this.createMockScopeDispatchData(replyParameters)
-    const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData, { ignoreTrailingSlash: this[kIgnoreTrailingSlash] })
-    return new MockScope(newMockDispatch)
-  }
-
-  /**
-   * Mock an undici request with a defined error.
-   */
-  replyWithError (error) {
-    if (typeof error === 'undefined') {
-      throw new InvalidArgumentError('error must be defined')
-    }
-
-    const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error }, { ignoreTrailingSlash: this[kIgnoreTrailingSlash] })
-    return new MockScope(newMockDispatch)
-  }
-
-  /**
-   * Set default reply headers on the interceptor for subsequent replies
-   */
-  defaultReplyHeaders (headers) {
-    if (typeof headers === 'undefined') {
-      throw new InvalidArgumentError('headers must be defined')
-    }
-
-    this[kDefaultHeaders] = headers
-    return this
-  }
-
-  /**
-   * Set default reply trailers on the interceptor for subsequent replies
-   */
-  defaultReplyTrailers (trailers) {
-    if (typeof trailers === 'undefined') {
-      throw new InvalidArgumentError('trailers must be defined')
-    }
-
-    this[kDefaultTrailers] = trailers
-    return this
-  }
-
-  /**
-   * Set reply content length header for replies on the interceptor
-   */
-  replyContentLength () {
-    this[kContentLength] = true
-    return this
-  }
-}
-
-module.exports.MockInterceptor = MockInterceptor
-module.exports.MockScope = MockScope

package/node_modules/undici/lib/mock/mock-pool.js

@@ -1,68 +0,0 @@
-'use strict'
-
-const { promisify } = require('node:util')
-const Pool = require('../dispatcher/pool')
-const { buildMockDispatch } = require('./mock-utils')
-const {
-  kDispatches,
-  kMockAgent,
-  kClose,
-  kOriginalClose,
-  kOrigin,
-  kOriginalDispatch,
-  kConnected,
-  kIgnoreTrailingSlash
-} = require('./mock-symbols')
-const { MockInterceptor } = require('./mock-interceptor')
-const Symbols = require('../core/symbols')
-const { InvalidArgumentError } = require('../core/errors')
-
-/**
- * MockPool provides an API that extends the Pool to influence the mockDispatches.
- */
-class MockPool extends Pool {
-  constructor (origin, opts) {
-    if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') {
-      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
-    }
-
-    super(origin, opts)
-
-    this[kMockAgent] = opts.agent
-    this[kOrigin] = origin
-    this[kIgnoreTrailingSlash] = opts.ignoreTrailingSlash ?? false
-    this[kDispatches] = []
-    this[kConnected] = 1
-    this[kOriginalDispatch] = this.dispatch
-    this[kOriginalClose] = this.close.bind(this)
-
-    this.dispatch = buildMockDispatch.call(this)
-    this.close = this[kClose]
-  }
-
-  get [Symbols.kConnected] () {
-    return this[kConnected]
-  }
-
-  /**
-   * Sets up the base interceptor for mocking replies from undici.
-   */
-  intercept (opts) {
-    return new MockInterceptor(
-      opts && { ignoreTrailingSlash: this[kIgnoreTrailingSlash], ...opts },
-      this[kDispatches]
-    )
-  }
-
-  cleanMocks () {
-    this[kDispatches] = []
-  }
-
-  async [kClose] () {
-    await promisify(this[kOriginalClose])()
-    this[kConnected] = 0
-    this[kMockAgent][Symbols.kClients].delete(this[kOrigin])
-  }
-}
-
-module.exports = MockPool

package/node_modules/undici/lib/mock/mock-symbols.js

@@ -1,32 +0,0 @@
-'use strict'
-
-module.exports = {
-  kAgent: Symbol('agent'),
-  kOptions: Symbol('options'),
-  kFactory: Symbol('factory'),
-  kDispatches: Symbol('dispatches'),
-  kDispatchKey: Symbol('dispatch key'),
-  kDefaultHeaders: Symbol('default headers'),
-  kDefaultTrailers: Symbol('default trailers'),
-  kContentLength: Symbol('content length'),
-  kMockAgent: Symbol('mock agent'),
-  kMockAgentSet: Symbol('mock agent set'),
-  kMockAgentGet: Symbol('mock agent get'),
-  kMockDispatch: Symbol('mock dispatch'),
-  kClose: Symbol('close'),
-  kOriginalClose: Symbol('original agent close'),
-  kOriginalDispatch: Symbol('original dispatch'),
-  kOrigin: Symbol('origin'),
-  kIsMockActive: Symbol('is mock active'),
-  kNetConnect: Symbol('net connect'),
-  kGetNetConnect: Symbol('get net connect'),
-  kConnected: Symbol('connected'),
-  kIgnoreTrailingSlash: Symbol('ignore trailing slash'),
-  kMockAgentMockCallHistoryInstance: Symbol('mock agent mock call history name'),
-  kMockAgentRegisterCallHistory: Symbol('mock agent register mock call history'),
-  kMockAgentAddCallHistoryLog: Symbol('mock agent add call history log'),
-  kMockAgentIsCallHistoryEnabled: Symbol('mock agent is call history enabled'),
-  kMockAgentAcceptsNonStandardSearchParameters: Symbol('mock agent accepts non standard search parameters'),
-  kMockCallHistoryAddLog: Symbol('mock call history add log'),
-  kTotalDispatchCount: Symbol('total dispatch count')
-}