@api-client/core 0.20.10 → 0.21.1

package/tests/unit/runtime/http-engine/timeout.spec.ts

@@ -1,33 +0,0 @@
-import { test } from '@japa/runner'
-import sinon from 'sinon'
-import { createLogger, CoreEngine, HttpEngineOptions } from '../../../../src/index.js'
-import { IHttpRequest, IErrorResponse, ISerializedError } from '../../../../src/models/index.js'
-
-const logger = createLogger()
-
-test.group('Timeout test', (group) => {
-  let opts: HttpEngineOptions
-
-  group.each.setup(() => {
-    opts = {
-      timeout: 60,
-      followRedirects: false,
-      logger,
-    }
-  })
-
-  test('timeouts the request', async ({ assert, httpConfig }) => {
-    const request: IHttpRequest = {
-      url: `http://localhost:${httpConfig.httpPort}/v1/delay/1000`,
-      method: 'GET',
-    }
-    const engine = new CoreEngine(request, opts)
-    const spy = sinon.spy()
-    engine.on('loadend', spy)
-    const info = await engine.send()
-    assert.isFalse(spy.called, 'loadend was not called')
-    const response = info.response as IErrorResponse
-    assert.equal(response.status, 0, 'status is 0')
-    assert.equal((response.error as ISerializedError).message, 'Connection timeout after 60ms')
-  })
-})

package/tests/unit/runtime/http-engine/timings.spec.ts

@@ -1,50 +0,0 @@
-import { test } from '@japa/runner'
-import { createLogger, CoreEngine } from '../../../../src/index.js'
-import { IResponse, IRequestTime } from '../../../../src/models/index.js'
-
-const logger = createLogger()
-
-test.group('Timings tests', () => {
-  test('has the stats object', async ({ assert, httpConfig }) => {
-    const engine = new CoreEngine(
-      {
-        url: `http://localhost:${httpConfig.httpPort}/v1/get`,
-        method: 'GET',
-      },
-      { logger }
-    )
-    const info = await engine.send()
-    const response = info.response as IResponse
-    const timing = response.timings as IRequestTime
-    assert.typeOf(timing, 'object')
-  })
-  ;(['connect', 'receive', 'send', 'wait', 'dns', 'ssl'] as (keyof IRequestTime)[]).forEach((prop) => {
-    test(`has the ${prop} value`, async ({ assert, httpConfig }) => {
-      const engine = new CoreEngine(
-        {
-          url: `http://localhost:${httpConfig.httpPort}/v1/get`,
-          method: 'GET',
-        },
-        { logger }
-      )
-      const info = await engine.send()
-      const response = info.response as IResponse
-      const timing = response.timings as IRequestTime
-      assert.typeOf(timing[prop], 'number')
-    })
-  })
-
-  test('has the stats time for ssl', async ({ assert }) => {
-    const engine = new CoreEngine(
-      {
-        url: 'https://www.google.com/',
-        method: 'GET',
-      },
-      { logger }
-    )
-    const info = await engine.send()
-    const response = info.response as IResponse
-    const timing = response.timings as IRequestTime
-    assert.isAbove(timing.ssl as number, -1)
-  })
-})

package/tests/unit/runtime/proxy/HttpProjectProxy.spec.ts

@@ -1,241 +0,0 @@
-import { test } from '@japa/runner'
-import sinon from 'sinon'
-import { nanoid } from '../../../../src/nanoid.js'
-import { IHttpProjectStoreProxyInit, IHttpProjectProxyInit, ProxyService } from '../../../../src/index.js'
-import { Exception } from '../../../../src/exceptions/index.js'
-import { HttpNode } from '../../../../src/sdk/HttpNode.js'
-import { HttpProject, HttpProjectKind } from '../../../../src/models/index.js'
-import { Headers } from '../../../../src/lib/headers/Headers.js'
-
-test.group('net-store project', (group) => {
-  let project: HttpProject
-  const token = 'token-test'
-  const storeHostname = 'http://localhost:1234'
-  const storeUri = `${storeHostname}/`
-  let sandbox: sinon.SinonSandbox
-
-  group.setup(async () => {
-    sandbox = sinon.createSandbox()
-  })
-
-  group.teardown(async () => {
-    sandbox.restore()
-  })
-
-  group.each.setup(({ context }) => {
-    project = HttpProject.fromName('p1')
-    project.addRequest(`http://localhost:${context.httpConfig.httpPort}/v1/get`)
-
-    // Reset the sandbox before each test
-    sandbox.restore()
-    sandbox = sinon.createSandbox()
-  })
-
-  test('returns an error when no pid', async ({ assert }) => {
-    const message: IHttpProjectStoreProxyInit = {
-      kind: HttpProjectKind,
-      organization: nanoid(),
-      pid: '',
-      options: {},
-    }
-    const service = new ProxyService()
-    let error: Exception
-    try {
-      await service.proxyHttpProject(message, token, storeUri)
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.equal(error.status, 400, 'has the error code')
-    assert.equal(error.message, 'Invalid request', 'has the message')
-    assert.equal(error.help, 'The "pid" parameter is required.', 'has the detail')
-  })
-
-  test('returns an error when no options', async ({ assert }) => {
-    // @ts-expect-error Used in testing
-    const message: IHttpProjectStoreProxyInit = {
-      kind: HttpProjectKind,
-      pid: project.key,
-      organization: nanoid(),
-    }
-    const service = new ProxyService()
-    let error: Exception
-    try {
-      await service.proxyHttpProject(message, token, storeUri)
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.equal(error.status, 400, 'has the error code')
-    assert.equal(error.message, 'Invalid request', 'has the message')
-    assert.equal(error.help, 'The "options" parameter is required.', 'has the detail')
-  })
-
-  test('returns an error when no token', async ({ assert }) => {
-    const message: IHttpProjectStoreProxyInit = {
-      kind: HttpProjectKind,
-      pid: project.key,
-      options: {},
-      organization: nanoid(),
-    }
-    const service = new ProxyService()
-    let error: Exception
-    try {
-      await service.proxyHttpProject(message, '', storeUri)
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.equal(error.message, 'Invalid request', 'has the message')
-    assert.equal(error.help, 'Set the authentication credentials.', 'has the detail')
-  })
-
-  test('returns an error when no store URI', async ({ assert }) => {
-    const message: IHttpProjectStoreProxyInit = {
-      kind: HttpProjectKind,
-      pid: project.key,
-      options: {},
-      organization: nanoid(),
-    }
-    const service = new ProxyService()
-    let error: Exception
-    try {
-      await service.proxyHttpProject(message, token, '')
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.equal(error.status, 400, 'has the error code')
-    assert.equal(error.message, 'Invalid request', 'has the message')
-    assert.equal(error.help, 'The store uri is missing.', 'has the detail')
-  })
-
-  test('returns an error when invalid store URI', async ({ assert }) => {
-    const message: IHttpProjectStoreProxyInit = {
-      kind: HttpProjectKind,
-      pid: project.key,
-      options: {},
-      organization: nanoid(),
-    }
-    const service = new ProxyService()
-    let error: Exception
-    try {
-      await service.proxyHttpProject(message, token, 'test')
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.equal(error.status, 400, 'has the error code')
-    assert.equal(error.message, 'Invalid request', 'has the message')
-    assert.equal(error.help, 'The store uri is invalid.', 'has the detail')
-  })
-
-  test('returns an error when no project', async ({ assert }) => {
-    const message: IHttpProjectStoreProxyInit = {
-      kind: HttpProjectKind,
-      pid: project.key,
-      options: {},
-      organization: nanoid(),
-    }
-
-    // Mock the HttpNode.get method to return a 404 error
-    const httpNodeStub = sandbox.stub(HttpNode.prototype, 'get').rejects(new Exception('Not found', { status: 404 }))
-
-    const service = new ProxyService()
-    let error: Exception
-    try {
-      await service.proxyHttpProject(message, token, storeUri)
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.equal(error.status, 400, 'has the error code')
-    assert.equal(error.message, 'Not found', 'has the message')
-    assert.isTrue(httpNodeStub.calledOnce, 'HTTP request was made')
-  })
-
-  test('proxies the project requests', async ({ assert }) => {
-    const message: IHttpProjectStoreProxyInit = {
-      kind: HttpProjectKind,
-      pid: project.key,
-      options: {},
-      organization: nanoid(),
-    }
-
-    // Mock the HttpNode.get method to return a successful response
-    const mockHeaders = new Headers()
-    mockHeaders.set('x-version', '1')
-    const httpNodeStub = sandbox.stub(HttpNode.prototype, 'get').resolves({
-      status: 200,
-      headers: mockHeaders,
-      body: JSON.stringify({ data: project.toJSON() }),
-    })
-
-    const service = new ProxyService()
-    const response = await service.proxyHttpProject(message, token, storeUri)
-    const exe = response.result
-    assert.typeOf(exe.started, 'number', 'has the response.started')
-    assert.typeOf(exe.ended, 'number', 'has the response.ended')
-    assert.typeOf(exe.iterations, 'array', 'has the response.iterations')
-    assert.isTrue(httpNodeStub.calledOnce, 'HTTP request was made')
-  })
-})
-
-test.group('local project', (group) => {
-  let project: HttpProject
-
-  group.each.setup(({ context }) => {
-    project = HttpProject.fromName('p1')
-    project.addRequest(`http://localhost:${context.httpConfig.httpPort}/v1/get`)
-  })
-
-  test('proxies the project requests', async ({ assert }) => {
-    const message: IHttpProjectProxyInit = {
-      kind: HttpProjectKind,
-      project: project.toJSON(),
-      options: {},
-    }
-    const service = new ProxyService()
-    const response = await service.proxyHttpProject(message)
-    const exe = response.result
-    assert.typeOf(exe.started, 'number', 'has the response.started')
-    assert.typeOf(exe.ended, 'number', 'has the response.ended')
-    assert.typeOf(exe.iterations, 'array', 'has the response.iterations')
-  })
-
-  test('returns an error when no options', async ({ assert }) => {
-    const message: IHttpProjectProxyInit = {
-      kind: HttpProjectKind,
-      project: project.toJSON(),
-    } as IHttpProjectProxyInit
-    const service = new ProxyService()
-    let error: Exception
-    try {
-      await service.proxyHttpProject(message)
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.equal(error.status, 400, 'has the error code')
-    assert.equal(error.message, 'Invalid request', 'has the message')
-    assert.equal(error.help, 'The "options" parameter is required.', 'has the detail')
-  })
-
-  test('returns an error when no project', async ({ assert }) => {
-    const message: IHttpProjectProxyInit = {
-      kind: HttpProjectKind,
-      options: {},
-    } as IHttpProjectProxyInit
-    const service = new ProxyService()
-    let error: Exception
-    try {
-      await service.proxyHttpProject(message)
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.equal(error.status, 400, 'has the error code')
-    assert.equal(error.message, 'Invalid request', 'has the message')
-    assert.equal(error.help, 'The "project" parameter is required.', 'has the detail')
-  })
-})

package/tests/unit/runtime/proxy/RequestProxy.spec.ts

@@ -1,130 +0,0 @@
-import { test } from '@japa/runner'
-import { IRequestProxyInit, ProxyService } from '../../../../src/index.js'
-import { Exception } from '../../../../src/exceptions/index.js'
-import {
-  RequestLog,
-  HttpRequestKind,
-  SetVariableStep,
-  SetDataStep,
-  IBasicAuthorization,
-} from '../../../../src/models/index.js'
-
-test.group('RequestProxy', (group) => {
-  let message: IRequestProxyInit
-
-  group.each.setup(({ context }) => {
-    message = {
-      kind: HttpRequestKind,
-      request: {
-        url: `http://localhost:${context.httpConfig.httpPort}/v1/get`,
-        method: 'GET',
-      },
-      authorization: [],
-    }
-  })
-
-  test('throws an error when no request', async ({ assert }) => {
-    // @ts-expect-error Used in testing
-    delete message.request
-    const service = new ProxyService()
-    let error: Exception
-    try {
-      await service.proxyRequest(message)
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.ok(error, 'has the error')
-    assert.equal(error.status, 400, 'has the error code')
-    assert.equal(error.message, 'Invalid request', 'has the message')
-    assert.equal(error.help, 'The "request" parameter is required.')
-  })
-
-  test('returns an error when the request has no URL', async ({ assert }) => {
-    // @ts-expect-error Used in testing
-    delete message.request.url
-    let error: Exception
-    const service = new ProxyService()
-    try {
-      await service.proxyRequest(message)
-      error = new Exception('Not thrown', { status: 0 })
-    } catch (e) {
-      error = e as Exception
-    }
-    assert.ok(error, 'has the error')
-    assert.equal(error.status, 400, 'has the error code')
-    assert.equal(error.message, 'Invalid request', 'has the message')
-    assert.equal(error.help, 'The "request.url" parameter is required.')
-  })
-
-  test('proxies a GET request', async ({ assert }) => {
-    message.request.headers = 'x-test: true\nauthorization: xyz'
-    message.request.url += '?a=b#c'
-    const service = new ProxyService()
-    const response = await service.proxyRequest(message)
-    const data = new RequestLog(response.result)
-    const echo = JSON.parse((await data.response?.readPayloadAsString()) as string)
-    assert.equal(echo.headers['x-test'], 'true')
-    assert.equal(echo.url, '/?a=b')
-  })
-
-  test('adds the authorization data', async ({ assert }) => {
-    message.authorization = [
-      {
-        kind: 'Core#RequestAuthorization',
-        enabled: true,
-        type: 'basic',
-        valid: true,
-        config: {
-          username: 'a',
-          password: 'b',
-        } as IBasicAuthorization,
-      },
-    ]
-    const service = new ProxyService()
-    const response = await service.proxyRequest(message)
-    const data = new RequestLog(response.result)
-    const echo = JSON.parse((await data.response?.readPayloadAsString()) as string)
-    assert.equal(echo.headers['authorization'], 'Basic YTpi')
-  })
-
-  test('adds the variables', async ({ assert, httpConfig }) => {
-    message.variables = {
-      httpPort: String(httpConfig.httpPort),
-    }
-    message.request.url = 'http://localhost:{httpPort}/v1/get'
-    const service = new ProxyService()
-    const response = await service.proxyRequest(message)
-    const data = new RequestLog(response.result)
-    const echo = JSON.parse((await data.response?.readPayloadAsString()) as string)
-    assert.equal(echo.baseUrl, '/v1/get')
-  })
-
-  test('adds the request flows', async ({ assert }) => {
-    message.flows = [
-      {
-        trigger: 'request',
-        actions: [
-          {
-            steps: [new SetDataStep('val1').toJSON(), new SetVariableStep('var1').toJSON()],
-          },
-        ],
-      },
-    ]
-    const service = new ProxyService()
-    const response = await service.proxyRequest(message)
-    const vars = response.variables as Record<string, string>
-    assert.equal(vars.var1, 'val1')
-  })
-
-  test('proxies a body', async ({ assert }) => {
-    message.request.method = 'POST'
-    message.request.headers = `content-type: application/json`
-    message.request.payload = '{"test":true}'
-    const service = new ProxyService()
-    const response = await service.proxyRequest(message)
-    const data = new RequestLog(response.result)
-    const echo = JSON.parse((await data.response?.readPayloadAsString()) as string)
-    assert.equal(echo.body, '{"test":true}')
-  })
-})

package/tests/unit/runtime/reporters/project_run_cli_reporter.spec.ts

@@ -1,62 +0,0 @@
-import { test } from '@japa/runner'
-import { ProjectRunCliReporter, TestCliHelper, ProjectMock } from '../../../../src/index.js'
-import { IProjectExecutionLog, IProjectExecutionIteration } from '../../../../src/models/index.js'
-
-test.group('ProjectRunCliReporter', () => {
-  const mock = new ProjectMock()
-
-  function wrapIterations(iterations: IProjectExecutionIteration[] = []): IProjectExecutionLog {
-    const now = Date.now()
-    const info: IProjectExecutionLog = {
-      started: now - 1000,
-      ended: now,
-      iterations,
-    }
-    return info
-  }
-
-  function wrapIteration(iteration: IProjectExecutionIteration): IProjectExecutionLog {
-    return wrapIterations([iteration])
-  }
-
-  test('prints the info table', async ({ assert }) => {
-    const opts = { response: { statusGroup: 2 } }
-    const info = wrapIteration({
-      index: 0,
-      executed: [
-        await mock.projectRequest.log(opts),
-        await mock.projectRequest.log(opts),
-        await mock.projectRequest.log(opts),
-      ],
-      variables: {},
-    })
-    const out = await TestCliHelper.grabOutput(async () => {
-      const reporter = new ProjectRunCliReporter(info)
-      await reporter.generate()
-    })
-    const lines = TestCliHelper.splitLines(TestCliHelper.cleanTerminalOutput(out))
-    const [summaryTitle, summaryColumns, iterations, requests] = lines
-    assert.include(summaryTitle, 'Project execution summary')
-    assert.include(summaryColumns, 'Succeeded')
-    assert.include(iterations, 'Iterations')
-    assert.include(iterations, '1')
-    assert.include(requests, 'Requests')
-    assert.include(requests, '3')
-  })
-
-  test('prints an error when an iteration error', async ({ assert }) => {
-    const info = wrapIteration({
-      index: 0,
-      executed: [],
-      error: 'This is anm error',
-      variables: {},
-    })
-    const out = await TestCliHelper.grabOutput(async () => {
-      const reporter = new ProjectRunCliReporter(info)
-      await reporter.generate()
-    })
-    const lines = TestCliHelper.splitLines(TestCliHelper.cleanTerminalOutput(out))
-    const last = lines.pop()
-    assert.include(last, 'Iteration 1 failed: This is anm error')
-  })
-})