@open-xchange/soap-client 0.1.6 → 0.2.1

package/test/soap.test.js

@@ -1,268 +0,0 @@
-/**
- * @copyright Copyright (c) Open-Xchange GmbH, Germany <info@open-xchange.com>
- * @license AGPL-3.0
- */
-
-// soap.js reads PROVISIONING_URL at module load to build the SOAP endpoint URL.
-// We don't exercise that path here; set a stub so the import doesn't crash.
-process.env.PROVISIONING_URL = 'http://soap.test/'
-
-const { describeError, shouldAbortRetry, wrapSoapFault, handleFailedAttempt } = await import('../soap.js')
-
-// Build a SOAP fault object matching the real shape (from soap@1.9.x).
-function soapFault (faultstring, detail = {}) {
-  return {
-    root: { Envelope: { Body: { Fault: { faultstring, faultcode: 'soap:Server', detail } } } },
-    response: { status: 500, statusText: 'Internal Server Error' },
-    body: '<soap:Envelope>...</soap:Envelope>'
-  }
-}
-
-// Build the wrapped shape that crashed the retry log: { error: <Error w/ SOAP fault props> }
-function wrappedFault (faultstring, detail = {}) {
-  const err = new Error(`soap:Server: ${faultstring}`)
-  Object.assign(err, soapFault(faultstring, detail))
-  return { error: err }
-}
-
-describe('describeError', () => {
-  it('returns the message of a plain Error', () => {
-    expect(describeError(new Error('boom'))).toBe('boom')
-  })
-
-  it('unwraps { originalError: <Error> } and returns the inner message', () => {
-    const inner = new Error('inner-msg')
-    expect(describeError({ originalError: inner })).toBe('inner-msg')
-  })
-
-  it('unwraps { error: <Error> } (the shape that produced "(undefined)" in retry logs)', () => {
-    const inner = new Error('inner-msg')
-    expect(describeError({ error: inner })).toBe('inner-msg')
-  })
-
-  it('falls back to the SOAP faultstring when the wrapped Error has none', () => {
-    // Real-world: soap@1.9.x sometimes throws an Error whose .message lives
-    // *inside* the SOAP fault rather than on the Error itself. Verify the
-    // faultstring path kicks in.
-    const fault = soapFault('Could not acquire claim for context 2572225')
-    // strip the message so the .root.Envelope... path is the only signal
-    const e = Object.assign(Object.create(Error.prototype), fault)
-    expect(describeError(e)).toBe('Could not acquire claim for context 2572225')
-  })
-
-  it('falls back to the SOAP faultstring through one level of { error: ... } wrapping', () => {
-    const wrapped = wrappedFault('Context 99 already exists')
-    // Stripping the inner message forces the faultstring fallback.
-    delete wrapped.error.message
-    expect(describeError(wrapped)).toBe('Context 99 already exists')
-  })
-
-  it('returns the error code for timeout-shaped errors (no message, no fault)', () => {
-    const e = { code: 'ETIMEDOUT' }
-    expect(describeError(e)).toBe('ETIMEDOUT')
-  })
-
-  it('returns a stringified preview if nothing else matches', () => {
-    const e = { weird: 'shape', no: 'normal fields' }
-    const out = describeError(e)
-    expect(out).toMatch(/weird/)
-    expect(out.length).toBeLessThanOrEqual(200)
-  })
-
-  it('returns "unknown" rather than the literal string "undefined" for empty input', () => {
-    expect(describeError(undefined)).toBe('unknown')
-    expect(describeError(null)).toBe('unknown')
-  })
-
-  it('handles strings thrown directly', () => {
-    expect(describeError('plain string error')).toBe('plain string error')
-  })
-
-  it('unwraps { original_error: <Error> } (snake_case from PropagatedError chains)', () => {
-    const inner = new Error('inner-msg')
-    expect(describeError({ original_error: inner })).toBe('inner-msg')
-  })
-
-  it('falls back to the SOAP faultstring through one level of { original_error: ... } wrapping', () => {
-    const inner = Object.assign(Object.create(Error.prototype), soapFault('Context 7 already exists'))
-    expect(describeError({ original_error: inner })).toBe('Context 7 already exists')
-  })
-})
-
-describe('shouldAbortRetry', () => {
-  it('does NOT abort on ETIMEDOUT / ECONNRESET / ECONNABORTED — these are retryable', () => {
-    expect(shouldAbortRetry({ code: 'ETIMEDOUT' })).toBe(false)
-    expect(shouldAbortRetry({ code: 'ECONNRESET' })).toBe(false)
-    expect(shouldAbortRetry({ code: 'ECONNABORTED' })).toBe(false)
-  })
-
-  it('does NOT abort on transient SOAP faults (e.g. context-claim conflict) — they retry until the lock frees', () => {
-    // This is the actual fault from the user's report — we *want* the retry
-    // loop to keep trying until the conflicting writer commits.
-    const e = soapFault('Could not acquire claim for context 2572225 due to another conflicting provisioning operation. Please try again later.')
-    expect(shouldAbortRetry(e)).toBe(false)
-  })
-
-  it('aborts on "Context N already exists" — re-running will keep failing', () => {
-    const e = soapFault('Context 4242 already exists')
-    expect(shouldAbortRetry(e)).toBe(true)
-  })
-
-  it('aborts on "Authentication failed"', () => {
-    const e = soapFault('Authentication failed')
-    expect(shouldAbortRetry(e)).toBe(true)
-  })
-
-  it('aborts on blocked exceptions in the fault detail (e.g. ContextExistsException)', () => {
-    const e = soapFault('some message', { ContextExistsException: {} })
-    expect(shouldAbortRetry(e)).toBe(true)
-  })
-
-  it('looks through one level of { error: ... } wrapping when probing the fault', () => {
-    const wrapped = wrappedFault('Context 4242 already exists')
-    expect(shouldAbortRetry(wrapped)).toBe(true)
-  })
-
-  it('looks through { originalError: ... } wrapping too', () => {
-    const inner = new Error('whatever')
-    Object.assign(inner, soapFault('Authentication failed'))
-    expect(shouldAbortRetry({ originalError: inner })).toBe(true)
-  })
-
-  it('looks through { original_error: ... } (snake_case) wrapping too', () => {
-    const inner = new Error('whatever')
-    Object.assign(inner, soapFault('Context 4242 already exists'))
-    expect(shouldAbortRetry({ original_error: inner })).toBe(true)
-  })
-
-  it('does NOT abort on completely unknown error structures — retry and let it sort itself out', () => {
-    expect(shouldAbortRetry({ random: 'object' })).toBe(false)
-    expect(shouldAbortRetry(undefined)).toBe(false)
-    expect(shouldAbortRetry(null)).toBe(false)
-  })
-})
-
-describe('wrapSoapFault', () => {
-  it('returns the input unchanged when no SOAP fault is present', () => {
-    const e = new Error('plain timeout')
-    expect(wrapSoapFault(e)).toBe(e)
-  })
-
-  it('returns the input unchanged for non-SOAP wrapped errors (e.g. axios timeout)', () => {
-    const e = Object.assign(new Error('timeout'), { code: 'ETIMEDOUT' })
-    expect(wrapSoapFault({ error: e })).toEqual({ error: e })
-  })
-
-  it('returns a NEW Error with the fault structure preserved on it', () => {
-    // Real-world: the soap library hands us an Error whose .root/.response/.body
-    // carry the structured fault. The proxy catch used to throw a plain new
-    // Error("SOAP Fault: …"), which DELETED the structured fields and broke
-    // downstream consumers that pattern-match on err.faultstring.
-    const inner = Object.assign(new Error('original'), soapFault('Context 42 already exists', { ContextExistsException: {} }))
-    const out = wrapSoapFault(inner)
-    expect(out).not.toBe(inner) // it's a new Error so the message can be friendly
-    expect(out).toBeInstanceOf(Error)
-    expect(out.message).toBe('SOAP Fault: Context 42 already exists')
-    expect(out.faultstring).toBe('Context 42 already exists')
-    expect(out.faultcode).toBe('soap:Server')
-    expect(out.detail).toEqual({ ContextExistsException: {} })
-    expect(out.root).toBe(inner.root)
-    expect(out.response).toBe(inner.response)
-    expect(out.body).toBe(inner.body)
-  })
-
-  it('unwraps { error: <Error w/ fault> } before extracting the fault', () => {
-    const inner = Object.assign(new Error('original'), soapFault('Authentication failed'))
-    const out = wrapSoapFault({ error: inner })
-    expect(out.faultstring).toBe('Authentication failed')
-    expect(out.message).toBe('SOAP Fault: Authentication failed')
-  })
-
-  it('unwraps { original_error: <Error w/ fault> } (snake_case) before extracting the fault', () => {
-    const inner = Object.assign(new Error('original'), soapFault('No such user'))
-    const out = wrapSoapFault({ original_error: inner })
-    expect(out.faultstring).toBe('No such user')
-  })
-})
-
-// Regression: the exact shape from the original incident report — a transient
-// "Could not acquire claim" fault wrapped in soap@1.9.x's `{ error: <Error> }`
-// envelope, with the StorageException nested in detail. Three concerns checked
-// together so the next person debugging this flow can see the whole pipeline
-// pass against the real symptom in one place.
-describe('real-world: transient "Could not acquire claim" fault wrapped in { error: ... }', () => {
-  const faultstring = 'Could not acquire claim for context 2572225 due to another conflicting provisioning operation. Please try again later.; exceptionId -1132283668-9930'
-  function realWorldThrownValue () {
-    const err = new Error(`soap:Server: ${faultstring}`)
-    Object.assign(err, soapFault(faultstring, { StorageException: { StorageException: null } }))
-    return { error: err }
-  }
-
-  it('describeError produces a useful retry-log line (not "(undefined)")', () => {
-    const out = describeError(realWorldThrownValue())
-    expect(out).toContain('Could not acquire claim for context 2572225')
-    expect(out).not.toBe('undefined')
-    expect(out).not.toBe('unknown')
-  })
-
-  it('shouldAbortRetry returns false — this is transient, keep retrying', () => {
-    // StorageException is NOT in the blockedExceptions list, and the
-    // faultstring doesn't match any blockedFaultStrings regex, so the retry
-    // loop must keep going until the conflicting writer commits.
-    expect(shouldAbortRetry(realWorldThrownValue())).toBe(false)
-  })
-
-  it('wrapSoapFault preserves .faultstring, .detail.StorageException, .root, .response, .body', () => {
-    const out = wrapSoapFault(realWorldThrownValue())
-    expect(out).toBeInstanceOf(Error)
-    expect(out.message).toMatch(/^SOAP Fault: Could not acquire claim for context 2572225/)
-    expect(out.faultstring).toContain('Could not acquire claim for context 2572225')
-    expect(out.faultcode).toBe('soap:Server')
-    expect(out.detail).toEqual({ StorageException: { StorageException: null } })
-    expect(out.root.Envelope.Body.Fault.faultstring).toContain('Could not acquire')
-    expect(out.response.status).toBe(500)
-    expect(out.body).toMatch(/soap:Envelope/)
-  })
-})
-
-describe('handleFailedAttempt (p-retry v8 onFailedAttempt)', () => {
-  // p-retry v8 hands the callback a context object, not the error itself.
-  function attemptContext (faultstring, { retriesLeft = 3 } = {}) {
-    const error = new Error(`soap:Server: ${faultstring}`)
-    Object.assign(error, soapFault(faultstring))
-    return { error, attemptNumber: 1, retriesLeft, retriesConsumed: 0, retryDelay: 0 }
-  }
-
-  it('aborts a blocked fault with a STRING message — the original incident', () => {
-    // Regression: this is the "Mandatory fields in context not set: [id]"
-    // fault that aborts retry. Before the fix, `new AbortError(context)`
-    // stored the context object as `.message`, so downstream
-    // `error.message.includes(...)` threw "includes is not a function".
-    let thrown
-    try {
-      handleFailedAttempt(attemptContext('Mandatory fields in context not set: [id]'), 'create')
-    } catch (e) {
-      thrown = e
-    }
-    expect(thrown).toBeInstanceOf(Error)
-    expect(typeof thrown.message).toBe('string')
-  })
-
-  it('aborts with the inner Error so wrapSoapFault can still recover the fault', () => {
-    let thrown
-    try {
-      handleFailedAttempt(attemptContext('Mandatory fields in context not set: [id]'), 'create')
-    } catch (e) {
-      thrown = e
-    }
-    const recovered = wrapSoapFault(thrown)
-    expect(recovered.message).toContain('Mandatory fields in context not set: [id]')
-    expect(recovered.faultstring).toContain('Mandatory fields in context not set: [id]')
-  })
-
-  it('does not throw for a transient (non-blocked) fault — lets p-retry continue', () => {
-    expect(() =>
-      handleFailedAttempt(attemptContext('Could not acquire claim for context 2572225'), 'create')
-    ).not.toThrow()
-  })
-})

package/vitest.config.js

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    globals: true,
-    include: ['test/**/*.test.*']
-  }
-})