@api-client/core 0.18.11 → 0.18.13

package/tests/unit/modeling/domain_model_entities.spec.ts

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { DataDomain, DomainEntity, DomainEntityKind } from '../../../src/index.js'
+import { DataDomain, DomainEntity, DomainEntityKind, DomainModel } from '../../../src/index.js'
 
 test.group('DomainModel.addEntity()', () => {
   test('adds an entity to the model', ({ assert }) => {
@@ -406,3 +406,308 @@ test.group('DomainModel.hasEntities()', () => {
     assert.isFalse(model.hasEntities())
   })
 })
+
+test.group('DomainModel.attachEntity() - Race Condition Tests', () => {
+  test('simulate multiple entities moved to same target simultaneously', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel1 = dataDomain.addModel({ key: 'source1' })
+    const sourceModel2 = dataDomain.addModel({ key: 'source2' })
+    const targetModel = dataDomain.addModel({ key: 'target' })
+
+    const entity1 = sourceModel1.addEntity({ key: 'entity1' })
+    const entity2 = sourceModel2.addEntity({ key: 'entity2' })
+
+    // Move multiple entities to the same target
+    targetModel.attachEntity(entity1.key)
+    targetModel.attachEntity(entity2.key)
+
+    // Verify no duplication in fields array
+    const entityFields = targetModel.fields.filter((f) => f.type === 'entity')
+    const entityKeys = entityFields.map((f) => f.key)
+    const uniqueKeys = [...new Set(entityKeys)]
+    assert.equal(entityFields.length, uniqueKeys.length, 'No duplicate entities in fields array')
+    assert.lengthOf(entityFields, 2, 'Should have exactly 2 entities')
+    assert.include(entityKeys, entity1.key, 'Should contain entity1')
+    assert.include(entityKeys, entity2.key, 'Should contain entity2')
+
+    // Verify graph consistency
+    assert.equal(dataDomain.graph.parent(entity1.key), targetModel.key, 'Entity1 parent should be target model')
+    assert.equal(dataDomain.graph.parent(entity2.key), targetModel.key, 'Entity2 parent should be target model')
+
+    // Verify entities removed from source models
+    assert.lengthOf(sourceModel1.fields, 0, 'Source1 should have no entities')
+    assert.lengthOf(sourceModel2.fields, 0, 'Source2 should have no entities')
+  })
+
+  test('simulate entity moved between models multiple times rapidly', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+    const model3 = dataDomain.addModel({ key: 'model3' })
+
+    const entity = model1.addEntity({ key: 'entity' })
+
+    // Simulate rapid moves
+    model2.attachEntity(entity.key)
+    model3.attachEntity(entity.key)
+    model1.attachEntity(entity.key)
+    model2.attachEntity(entity.key)
+
+    // Final state verification
+    assert.lengthOf(model2.fields, 1, 'Model2 should have 1 entity')
+    assert.lengthOf(model1.fields, 0, 'Model1 should have no entities')
+    assert.lengthOf(model3.fields, 0, 'Model3 should have no entities')
+    assert.equal(dataDomain.graph.parent(entity.key), model2.key, 'Entity parent should be model2')
+  })
+
+  test('simulate concurrent attachment of same entity to different targets', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel = dataDomain.addModel({ key: 'source' })
+    const targetModel1 = dataDomain.addModel({ key: 'target1' })
+    const targetModel2 = dataDomain.addModel({ key: 'target2' })
+
+    const entity = sourceModel.addEntity({ key: 'entity' })
+
+    // First move should succeed
+    targetModel1.attachEntity(entity.key)
+    assert.equal(dataDomain.graph.parent(entity.key), targetModel1.key, 'Entity should be in target1')
+    assert.lengthOf(targetModel1.fields, 1, 'Target1 should have the entity')
+    assert.lengthOf(sourceModel.fields, 0, 'Source should be empty')
+
+    // Second move should move from target1 to target2
+    targetModel2.attachEntity(entity.key)
+    assert.equal(dataDomain.graph.parent(entity.key), targetModel2.key, 'Entity should be in target2')
+    assert.lengthOf(targetModel2.fields, 1, 'Target2 should have the entity')
+    assert.lengthOf(targetModel1.fields, 0, 'Target1 should be empty')
+    assert.lengthOf(sourceModel.fields, 0, 'Source should still be empty')
+  })
+
+  test('verify entity is not duplicated when moved from model with multiple entities', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel = dataDomain.addModel({ key: 'source' })
+    const targetModel = dataDomain.addModel({ key: 'target' })
+
+    const entity1 = sourceModel.addEntity({ key: 'entity1' })
+    const entity2 = sourceModel.addEntity({ key: 'entity2' })
+    const entity3 = sourceModel.addEntity({ key: 'entity3' })
+
+    // Move middle entity
+    targetModel.attachEntity(entity2.key)
+
+    // Verify source model has 2 entities remaining
+    assert.lengthOf(sourceModel.fields, 2, 'Source should have 2 entities remaining')
+    const sourceKeys = sourceModel.fields.map((f) => f.key)
+    assert.include(sourceKeys, entity1.key, 'Should contain entity1')
+    assert.include(sourceKeys, entity3.key, 'Should contain entity3')
+    assert.notInclude(sourceKeys, entity2.key, 'Should not contain moved entity2')
+
+    // Verify target model has 1 entity
+    assert.lengthOf(targetModel.fields, 1, 'Target should have 1 entity')
+    assert.equal(targetModel.fields[0].key, entity2.key, 'Target should have entity2')
+
+    // Verify graph consistency
+    assert.equal(dataDomain.graph.parent(entity1.key), sourceModel.key, 'Entity1 parent should be source')
+    assert.equal(dataDomain.graph.parent(entity2.key), targetModel.key, 'Entity2 parent should be target')
+    assert.equal(dataDomain.graph.parent(entity3.key), sourceModel.key, 'Entity3 parent should be source')
+  })
+
+  test('verify field consistency when moving entities with properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel = dataDomain.addModel({ key: 'source' })
+    const targetModel = dataDomain.addModel({ key: 'target' })
+
+    const entity = sourceModel.addEntity({ key: 'entity' })
+    entity.addProperty({ key: 'prop1', type: 'string' })
+    entity.addProperty({ key: 'prop2', type: 'number' })
+
+    // Verify initial state
+    assert.lengthOf(entity.fields, 2, 'Entity should have 2 properties')
+
+    // Move entity
+    targetModel.attachEntity(entity.key)
+
+    // Verify entity fields are preserved
+    assert.lengthOf(entity.fields, 2, 'Entity should still have 2 properties after move')
+    assert.equal(dataDomain.graph.parent(entity.key), targetModel.key, 'Entity parent should be target')
+
+    // Verify model fields
+    assert.lengthOf(sourceModel.fields, 0, 'Source model should be empty')
+    assert.lengthOf(targetModel.fields, 1, 'Target model should have 1 entity')
+  })
+
+  test('stress test - multiple entities moved in sequence to verify no field array corruption', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModels = []
+    const targetModel = dataDomain.addModel({ key: 'target' })
+    const entities = []
+
+    // Create 10 source models with 1 entity each
+    for (let i = 0; i < 10; i++) {
+      const sourceModel = dataDomain.addModel({ key: `source${i}` })
+      sourceModels.push(sourceModel)
+      const entity = sourceModel.addEntity({ key: `entity${i}` })
+      entities.push(entity)
+    }
+
+    // Move all entities to target model
+    for (const entity of entities) {
+      targetModel.attachEntity(entity.key)
+    }
+
+    // Verify target model state
+    assert.lengthOf(targetModel.fields, 10, 'Target should have 10 entities')
+    const targetKeys = targetModel.fields.map((f) => f.key).sort()
+    const expectedKeys = entities.map((e) => e.key).sort()
+    assert.deepEqual(targetKeys, expectedKeys, 'Target should have all expected entities')
+
+    // Verify no duplicates
+    const uniqueKeys = [...new Set(targetKeys)]
+    assert.equal(targetKeys.length, uniqueKeys.length, 'No duplicate keys in target')
+
+    // Verify source models are empty
+    for (const sourceModel of sourceModels) {
+      assert.lengthOf(sourceModel.fields, 0, `Source model ${sourceModel.key} should be empty`)
+    }
+
+    // Verify graph consistency
+    for (const entity of entities) {
+      assert.equal(dataDomain.graph.parent(entity.key), targetModel.key, `Entity ${entity.key} parent should be target`)
+    }
+  })
+
+  test('verify detach-attach sequence atomicity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+
+    const entity = model1.addEntity({ key: 'entity' })
+
+    // Spy on the detachEntity method to verify it's called
+    let detachCalled = false
+    const originalDetach = model1.detachEntity
+    model1.detachEntity = function (key: string) {
+      detachCalled = true
+      return originalDetach.call(this, key)
+    }
+
+    model2.attachEntity(entity.key)
+
+    // Verify detach was called during attach
+    assert.isTrue(detachCalled, 'detachEntity should have been called on the source model')
+
+    // Verify final state
+    assert.lengthOf(model1.fields, 0, 'Model1 should be empty')
+    assert.lengthOf(model2.fields, 1, 'Model2 should have the entity')
+    assert.equal(dataDomain.graph.parent(entity.key), model2.key, 'Graph parent should be model2')
+  })
+
+  test('verify graph parent is updated before fields array check', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+
+    const entity = model1.addEntity({ key: 'entity' })
+
+    // Override setParent to track when it's called
+    const parentSetCalls: { nodeKey: string; parentKey?: string; timestamp: number }[] = []
+    const originalSetParent = dataDomain.graph.setParent
+    dataDomain.graph.setParent = function (nodeKey: string, parentKey?: string) {
+      parentSetCalls.push({ nodeKey, parentKey, timestamp: Date.now() })
+      return originalSetParent.call(this, nodeKey, parentKey)
+    }
+
+    // Override fields.push to track when it's called
+    const fieldsPushCalls: { items: unknown[]; timestamp: number }[] = []
+    const originalPush = model2.fields.push
+    model2.fields.push = function (...items) {
+      fieldsPushCalls.push({ items: [...items], timestamp: Date.now() })
+      return originalPush.call(this, ...items)
+    }
+
+    model2.attachEntity(entity.key)
+
+    // Verify the sequence - setParent should be called twice (detach + attach)
+    assert.lengthOf(parentSetCalls, 2, 'setParent should be called twice (detach + attach)')
+    assert.lengthOf(fieldsPushCalls, 1, 'fields.push should be called once')
+
+    // First call should clear the parent (detach)
+    assert.equal(parentSetCalls[0].nodeKey, entity.key, 'First call should be for entity key')
+    assert.isUndefined(parentSetCalls[0].parentKey, 'First call should clear parent')
+
+    // Second call should set the new parent (attach)
+    assert.equal(parentSetCalls[1].parentKey, model2.key, 'Second call should set parent to model2')
+    assert.equal(parentSetCalls[1].nodeKey, entity.key, 'Second call should be for entity key')
+  })
+
+  test('detect inconsistent graph parent - entity in fields but wrong graph parent', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel = dataDomain.addModel({ key: 'source' })
+    const targetModel = dataDomain.addModel({ key: 'target' })
+
+    const entity = sourceModel.addEntity({ key: 'entity' })
+
+    // Simulate race condition where graph parent is not updated during attach
+    const originalSetParent = dataDomain.graph.setParent
+    let setParentCallCount = 0
+    dataDomain.graph.setParent = function (nodeKey: string, parentKey?: string) {
+      setParentCallCount++
+      // Skip the second setParent call (the attach operation)
+      if (setParentCallCount === 2) {
+        return this // Don't actually set the parent
+      }
+      return originalSetParent.call(this, nodeKey, parentKey)
+    }
+
+    assert.throws(() => {
+      targetModel.attachEntity(entity.key)
+    })
+
+    // Restore original method
+    dataDomain.graph.setParent = originalSetParent
+  })
+
+  test('verify consistency during rapid sequential moves', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const models: DomainModel[] = []
+
+    // Create multiple models
+    for (let i = 0; i < 5; i++) {
+      models.push(dataDomain.addModel({ key: `model${i}` }))
+    }
+
+    const entity = models[0].addEntity({ key: 'entity' })
+
+    // Perform rapid moves between models
+    for (let iteration = 0; iteration < 20; iteration++) {
+      const targetIndex = (iteration + 1) % models.length
+      models[targetIndex].attachEntity(entity.key)
+
+      // Verify consistency after each move
+      let entityCount = 0
+      let modelWithEntity = null
+
+      for (const model of models) {
+        const hasEntity = model.fields.some((f) => f.type === 'entity' && f.key === entity.key)
+        if (hasEntity) {
+          entityCount++
+          modelWithEntity = model
+        }
+      }
+
+      // Entity should exist in exactly one model
+      assert.equal(
+        entityCount,
+        1,
+        `Iteration ${iteration}: Entity should exist in exactly one model, found in ${entityCount} models`
+      )
+
+      // Graph parent should match the model that has the entity
+      const graphParent = dataDomain.graph.parent(entity.key)
+      assert.equal(
+        graphParent,
+        modelWithEntity?.key,
+        `Iteration ${iteration}: Graph parent should match model with entity`
+      )
+    }
+  })
+})

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

@@ -0,0 +1,337 @@
+import { test } from '@japa/runner'
+import { createLogger } from '../../../../src/index.js'
+import {
+  HttpResponseParser,
+  RequestState,
+  type ParserCallbacks,
+} from '../../../../src/runtime/http-engine/parsers/HttpResponseParser.js'
+
+const logger = createLogger()
+
+test.group('HttpResponseParser', (group) => {
+  let parser: HttpResponseParser
+  let callbacks: ParserCallbacks
+  let statusParsed = false
+  let headersParsed = false
+  let bodyComplete = false
+  let errorOccurred = false
+  let aborted = false
+  let emittedEvents: { event: string; detail?: unknown }[] = []
+
+  group.each.setup(() => {
+    statusParsed = false
+    headersParsed = false
+    bodyComplete = false
+    errorOccurred = false
+    aborted = false
+    emittedEvents = []
+
+    callbacks = {
+      onStatusParsed: () => {
+        statusParsed = true
+      },
+      onHeadersParsed: () => {
+        headersParsed = true
+      },
+      onBodyComplete: () => {
+        bodyComplete = true
+      },
+      onError: () => {
+        errorOccurred = true
+      },
+      onAbort: () => {
+        aborted = true
+      },
+      emit: (event: string, detail?: unknown) => {
+        emittedEvents.push({ event, detail })
+      },
+    }
+
+    parser = new HttpResponseParser(logger, callbacks)
+  })
+
+  test('parses status line correctly', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    parser.processData(statusData)
+
+    assert.isTrue(statusParsed)
+    assert.equal(parser.getState(), RequestState.Headers)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles incomplete status line', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200')
+    parser.processData(statusData)
+
+    assert.isFalse(statusParsed)
+    assert.equal(parser.getState(), RequestState.Status)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles malformed status line', ({ assert }) => {
+    const statusData = Buffer.from('Invalid Status Line\r\n')
+    parser.processData(statusData)
+
+    // StatusParser doesn't throw errors, it just returns invalid status codes
+    assert.isTrue(statusParsed)
+    assert.equal(parser.getState(), RequestState.Headers)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('parses headers correctly', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    const headersData = Buffer.from('Content-Type: application/json\r\nContent-Length: 114\r\n\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+
+    assert.isTrue(statusParsed)
+    assert.isTrue(headersParsed)
+    assert.equal(parser.getState(), RequestState.Body)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles partial headers', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    const partialHeaders = Buffer.from('Content-Type: application/json\r\n')
+
+    parser.processData(statusData)
+    parser.processData(partialHeaders)
+
+    assert.isTrue(statusParsed)
+    assert.isFalse(headersParsed)
+    assert.equal(parser.getState(), RequestState.Headers)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('extracts content length from headers', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    const headersData = Buffer.from('Content-Length: 114\r\n\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+
+    const responseInfo = parser.getResponseInfo()
+    assert.equal(responseInfo.contentLength, 114)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('detects chunked transfer encoding', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    const headersData = Buffer.from('Transfer-Encoding: chunked\r\n\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+
+    const responseInfo = parser.getResponseInfo()
+    assert.isTrue(responseInfo.chunked)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('emits headersreceived event', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    const headersData = Buffer.from('Content-Type: application/json\r\n\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+
+    const headersEvent = emittedEvents.find((e) => e.event === 'headersreceived')
+    assert.isDefined(headersEvent)
+    assert.isDefined(headersEvent?.detail)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles content-length body', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    const headersData = Buffer.from('Content-Length: 4\r\n\r\n')
+    const bodyData = Buffer.from('test')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+    parser.processData(bodyData)
+
+    assert.isTrue(bodyComplete)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles chunked body', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    const headersData = Buffer.from('Transfer-Encoding: chunked\r\n\r\n')
+    const chunkedBody = Buffer.from('4\r\ntest\r\n0\r\n\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+    parser.processData(chunkedBody)
+
+    assert.isTrue(bodyComplete)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles multiple chunks', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    const headersData = Buffer.from('Transfer-Encoding: chunked\r\n\r\n')
+    const chunkedBody = Buffer.from('6\r\ntest\r\n\r\n8\r\ntest1234\r\n0\r\n\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+    parser.processData(chunkedBody)
+
+    assert.isTrue(bodyComplete)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles partial chunks', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    const headersData = Buffer.from('Transfer-Encoding: chunked\r\n\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+
+    // Send partial chunk
+    parser.processData(Buffer.from('6\r\nte'))
+    parser.processData(Buffer.from('st\r\n\r\n'))
+    parser.processData(Buffer.from('8\r\ntest'))
+    parser.processData(Buffer.from('1234\r\n0\r\n\r\n'))
+
+    assert.isTrue(bodyComplete)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles 204 No Content without body', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 204 No Content\r\n')
+    const headersData = Buffer.from('\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+
+    assert.isTrue(bodyComplete)
+    assert.equal(parser.getState(), RequestState.Done)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles 304 Not Modified without body', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 304 Not Modified\r\n')
+    const headersData = Buffer.from('\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+
+    assert.isTrue(bodyComplete)
+    assert.equal(parser.getState(), RequestState.Done)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles informational responses without body', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 100 Continue\r\n')
+    const headersData = Buffer.from('\r\n')
+
+    parser.processData(statusData)
+    parser.processData(headersData)
+
+    assert.isTrue(bodyComplete)
+    assert.equal(parser.getState(), RequestState.Done)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('aborts parser correctly', ({ assert }) => {
+    parser.abort()
+
+    assert.isTrue(aborted)
+    assert.equal(parser.getState(), RequestState.Done)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('ignores data after abort', ({ assert }) => {
+    parser.abort()
+
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    parser.processData(statusData)
+
+    assert.isFalse(statusParsed)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('resets parser state correctly', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    parser.processData(statusData)
+
+    parser.reset()
+
+    assert.equal(parser.getState(), RequestState.Status)
+    assert.isFalse(parser.getResponseInfo().chunked)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('can process new response after reset', ({ assert }) => {
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    parser.processData(statusData)
+
+    parser.reset()
+
+    parser.processData(statusData)
+    assert.isTrue(statusParsed)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  const parts = [
+    Buffer.from([
+      72, 84, 84, 80, 47, 49, 46, 48, 32, 50, 48, 48, 32, 79, 75, 13, 10, 67, 111, 110, 116, 101, 110, 116, 45, 84, 121,
+      112, 101, 58, 32, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 106, 115, 111, 110, 13, 10, 67, 111,
+      110, 116, 101, 110, 116, 45, 76, 101, 110, 103, 116, 104, 58, 32, 49, 49, 52, 13, 10,
+    ]),
+    Buffer.from([
+      83, 101, 114, 118, 101, 114, 58, 32, 87, 101, 114, 107, 122, 101, 117, 103, 47, 48, 46, 49, 52, 46, 49, 32, 80,
+      121, 116, 104, 111, 110, 47, 50, 46, 55, 46, 49, 52, 13, 10, 68, 97, 116, 101, 58, 32, 84, 104, 117, 44, 32, 50,
+      49, 32, 74, 117, 110, 32, 50, 48, 49, 56, 32, 49, 56, 58, 51, 48, 58, 53, 49, 32, 71, 77, 84, 13, 10, 13, 10, 123,
+      34, 105, 110, 115, 116, 114, 117, 109, 101, 110, 116, 95, 105, 100, 34, 58, 32, 50, 52, 49, 56, 54, 44, 32, 34,
+      117, 115, 101, 114, 95, 105, 100, 34, 58, 32, 53, 57, 44, 32, 34, 112, 114, 111, 100, 117, 99, 116, 95, 105, 100,
+      34, 58, 32, 51, 50, 54, 57, 44, 32, 34, 112, 114, 105, 99, 101, 34, 58, 32, 50, 46, 48, 44, 32, 34, 115, 105, 100,
+      101, 34, 58, 32, 34, 83, 101, 108, 108, 34, 44, 32, 34, 105, 100, 34, 58, 32, 50, 44, 32, 34, 113, 117, 97, 110,
+      116, 105, 116, 121, 34, 58, 32, 48, 125, 10,
+    ]),
+  ]
+
+  test('processes complete response in multiple parts', ({ assert }) => {
+    parser.processData(parts[0])
+    parser.processData(parts[1])
+
+    assert.isTrue(statusParsed)
+    assert.isTrue(headersParsed)
+    assert.isTrue(bodyComplete)
+    assert.equal(parser.getState(), RequestState.Done)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('extracts correct response information', ({ assert }) => {
+    parser.processData(parts[0])
+    parser.processData(parts[1])
+
+    const responseInfo = parser.getResponseInfo()
+    assert.equal(responseInfo.status, 200)
+    assert.equal(responseInfo.contentLength, 114)
+    assert.isFalse(responseInfo.chunked)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('handles parsing errors gracefully', ({ assert }) => {
+    const invalidData = Buffer.from('Invalid HTTP Response Data')
+    parser.processData(invalidData)
+
+    // StatusParser doesn't throw errors for invalid data
+    assert.isFalse(errorOccurred)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('continues processing after error', ({ assert }) => {
+    const invalidData = Buffer.from('Invalid Data')
+    parser.processData(invalidData)
+
+    const validData = Buffer.from('HTTP/1.1 200 OK\r\n\r\n')
+    parser.processData(validData)
+
+    // StatusParser doesn't throw errors for invalid data
+    assert.isFalse(errorOccurred)
+    assert.isTrue(statusParsed)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('tracks state correctly through parsing stages', ({ assert }) => {
+    assert.equal(parser.getState(), RequestState.Status)
+
+    const statusData = Buffer.from('HTTP/1.1 200 OK\r\n')
+    parser.processData(statusData)
+    assert.equal(parser.getState(), RequestState.Headers)
+
+    const headersData = Buffer.from('Content-Length: 4\r\n\r\n')
+    parser.processData(headersData)
+    assert.equal(parser.getState(), RequestState.Body)
+
+    const bodyData = Buffer.from('test')
+    parser.processData(bodyData)
+    assert.equal(parser.getState(), RequestState.Done)
+  }).tags(['@http-engine', '@response', '@parser'])
+
+  test('returns correct response info', ({ assert }) => {
+    const responseInfo = parser.getResponseInfo()
+    assert.isFalse(responseInfo.chunked)
+    assert.isUndefined(responseInfo.status)
+    assert.isUndefined(responseInfo.contentLength)
+  }).tags(['@http-engine', '@response', '@parser'])
+})

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

@@ -1,7 +1,7 @@
 import { test } from '@japa/runner'
 import net from 'net'
 import {
-  DummyLogger,
+  createLogger,
   CoreEngine,
   IHttpRequest,
   HttpEngineOptions,
@@ -9,7 +9,7 @@ import {
   ISerializedError,
 } from '../../../../src/index.js'
 
-const logger = new DummyLogger()
+const logger = createLogger()
 
 test.group('Aborting the request', (group) => {
   let request: IHttpRequest
@@ -70,11 +70,10 @@ test.group('Aborting the request', (group) => {
     assert.isUndefined(result)
   }).tags(['@http-engine', '@abort'])
 
-  test('_createResponse() results to undefined', async ({ assert }) => {
+  test('_createResponse() throws an error', async ({ assert }) => {
     const base = new CoreEngine(request, opts)
     base.abort()
-    const result = await base._createResponse()
-    assert.isUndefined(result)
+    await assert.rejects(() => base._createResponse(), 'Request aborted.')
   }).tags(['@http-engine', '@abort'])
 
   test('aborts the request with a signal', async ({ assert }) => {