@itentialopensource/adapter-metaswitch 1.2.2 → 1.2.4

package/CHANGELOG.md

@@ -1,4 +1,20 @@
 
+## 1.2.4 [07-01-2026]
+
+* Changes made at 2026.07.01_14:17PM
+
+See merge request itentialopensource/adapters/adapter-metaswitch!51
+
+---
+
+## 1.2.3 [06-17-2026]
+
+* fix: Add namespace prefix detection for OriginHost element
+
+See merge request itentialopensource/adapters/adapter-metaswitch!48
+
+---
+
 ## 1.2.2 [06-16-2026]
 
 * Changes made at 2026.06.16_11:41AM

package/adapter.js

@@ -100,6 +100,7 @@ class Metaswitch extends AdapterBaseCl {
     // Exclude SOAP utility methods from workflow functions
     myIgnore.push('wrapBodyInSoapEnvelope');
     myIgnore.push('getSoapNamespaces');
+    myIgnore.push('collectNamespaceDeclarations');
     myIgnore.push('buildOriginHost');
     myIgnore.push('injectOriginHost');
     myIgnore.push('escapeXml');
@@ -683,7 +684,7 @@ class Metaswitch extends AdapterBaseCl {
       }
 
       // Build OriginHost with credentials from adapter properties
-      const originHostResult = this.buildOriginHost();
+      const originHostResult = this.buildOriginHost(body);
       if (originHostResult.error) {
         return { error: originHostResult.error };
       }
@@ -691,8 +692,9 @@ class Metaswitch extends AdapterBaseCl {
       // Inject OriginHost into the body XML (append before any closing tags)
       const bodyWithOriginHost = this.injectOriginHost(body, originHostResult.originHost);
 
-      // Determine namespace based on API type
-      const namespaces = this.getSoapNamespaces(apiType);
+      // Collect all namespace declarations needed, scanning the body for every
+      // prefix in use so nothing is silently dropped from the final envelope
+      const namespaces = this.collectNamespaceDeclarations(bodyWithOriginHost, apiType);
 
       // Construct SOAP envelope with minimal header (Metaswitch pattern)
       const soapEnvelope = `<soapenv:Envelope ${namespaces}>
@@ -729,46 +731,213 @@ class Metaswitch extends AdapterBaseCl {
     return `${commonNamespaces} ${apiNamespaces[apiType] || apiNamespaces.EAS}`;
   }
 
+  /**
+   * @function collectNamespaceDeclarations
+   * @summary Scans an XML body for every namespace prefix in use and returns the
+   *          complete set of xmlns declarations needed on the SOAP envelope.
+   *
+   *          Resolution order for each prefix:
+   *            1. Inline declaration already present in the body (xmlns:prefix="uri")
+   *            2. API-type-aware mapping for the sh: prefix
+   *            3. Known fallback table for common XML prefixes (xsd, xsi, wsa, …)
+   *          The soapenv prefix is always included regardless of body content.
+   *
+   * @param {string} body    - XML body content to scan
+   * @param {string} apiType - API type (EAS, NSeries, Metaview, NWSAP)
+   * @returns {string} Space-separated xmlns declaration string
+   */
+  // eslint-disable-next-line class-methods-use-this
+  collectNamespaceDeclarations(body, apiType = 'EAS') {
+    // -----------------------------------------------------------------------
+    // Metaswitch API-type-specific namespace table.
+    // EAS URIs are sourced from ~/Desktop/EAS_WebServices documentation
+    // (ShService.wsdl, userData.xsd, serviceData.xsd, Documentation.xsd).
+    // NSeries / Metaview / NWSAP follow the same sub-path convention.
+    //
+    // Prefix legend (all map to one of the four Metaswitch URI families):
+    //   sh, impl, intf, tns1, m  → base SOAP service namespace
+    //   user, u                  → userdata sub-namespace (userData.xsd)
+    //   ser,  s                  → servicedata sub-namespace (serviceData.xsd)
+    //   doc,  d                  → documentation sub-namespace (Documentation.xsd)
+    // -----------------------------------------------------------------------
+    const apiNamespaces = {
+      EAS: {
+        sh: 'http://www.metaswitch.com/sdp/soap/sh',
+        impl: 'http://www.metaswitch.com/sdp/soap/sh',
+        intf: 'http://www.metaswitch.com/sdp/soap/sh',
+        tns1: 'http://www.metaswitch.com/sdp/soap/sh',
+        m: 'http://www.metaswitch.com/sdp/soap/sh',
+        user: 'http://www.metaswitch.com/sdp/soap/sh/userdata',
+        u: 'http://www.metaswitch.com/sdp/soap/sh/userdata',
+        ser: 'http://www.metaswitch.com/sdp/soap/sh/servicedata',
+        s: 'http://www.metaswitch.com/sdp/soap/sh/servicedata',
+        doc: 'http://www.metaswitch.com/sdp/soap/sh/documentation',
+        d: 'http://www.metaswitch.com/sdp/soap/sh/documentation'
+      },
+      NSeries: {
+        sh: 'http://www.metaswitch.com/nsrs/soap/sh',
+        impl: 'http://www.metaswitch.com/nsrs/soap/sh',
+        intf: 'http://www.metaswitch.com/nsrs/soap/sh',
+        tns1: 'http://www.metaswitch.com/nsrs/soap/sh',
+        m: 'http://www.metaswitch.com/nsrs/soap/sh',
+        user: 'http://www.metaswitch.com/nsrs/soap/sh/userdata',
+        u: 'http://www.metaswitch.com/nsrs/soap/sh/userdata',
+        ser: 'http://www.metaswitch.com/nsrs/soap/sh/servicedata',
+        s: 'http://www.metaswitch.com/nsrs/soap/sh/servicedata',
+        doc: 'http://www.metaswitch.com/nsrs/soap/sh/documentation',
+        d: 'http://www.metaswitch.com/nsrs/soap/sh/documentation'
+      },
+      Metaview: {
+        sh: 'http://www.metaswitch.com/ems/soap/sh',
+        impl: 'http://www.metaswitch.com/ems/soap/sh',
+        intf: 'http://www.metaswitch.com/ems/soap/sh',
+        tns1: 'http://www.metaswitch.com/ems/soap/sh',
+        m: 'http://www.metaswitch.com/ems/soap/sh',
+        user: 'http://www.metaswitch.com/ems/soap/sh/userdata',
+        u: 'http://www.metaswitch.com/ems/soap/sh/userdata',
+        ser: 'http://www.metaswitch.com/ems/soap/sh/servicedata',
+        s: 'http://www.metaswitch.com/ems/soap/sh/servicedata',
+        doc: 'http://www.metaswitch.com/ems/soap/sh/documentation',
+        d: 'http://www.metaswitch.com/ems/soap/sh/documentation'
+      },
+      NWSAP: {
+        sh: 'http://www.metaswitch.com/srb/soap/sh',
+        impl: 'http://www.metaswitch.com/srb/soap/sh',
+        intf: 'http://www.metaswitch.com/srb/soap/sh',
+        tns1: 'http://www.metaswitch.com/srb/soap/sh',
+        m: 'http://www.metaswitch.com/srb/soap/sh',
+        user: 'http://www.metaswitch.com/srb/soap/sh/userdata',
+        u: 'http://www.metaswitch.com/srb/soap/sh/userdata',
+        ser: 'http://www.metaswitch.com/srb/soap/sh/servicedata',
+        s: 'http://www.metaswitch.com/srb/soap/sh/servicedata',
+        doc: 'http://www.metaswitch.com/srb/soap/sh/documentation',
+        d: 'http://www.metaswitch.com/srb/soap/sh/documentation'
+      }
+    };
+
+    // -----------------------------------------------------------------------
+    // Standard W3C / SOAP namespaces — identical for all API types.
+    // Sources: W3C specifications, OASIS WSS, Apache SOAP.
+    // -----------------------------------------------------------------------
+    const standardNamespaces = {
+      // XML MIME types (W3C) — also always emitted on the envelope because
+      // Metaswitch declares it even when no element uses the prefix directly
+      xm: 'http://www.w3.org/2005/05/xmlmime',
+      xmime: 'http://www.w3.org/2005/05/xmlmime',
+      // XML Schema (W3C)
+      xsd: 'http://www.w3.org/2001/XMLSchema',
+      xs: 'http://www.w3.org/2001/XMLSchema',
+      // XML Schema instance (W3C)
+      xsi: 'http://www.w3.org/2001/XMLSchema-instance',
+      // WS-Addressing (W3C)
+      wsa: 'http://www.w3.org/2005/08/addressing',
+      // WS-Security utility (OASIS)
+      wsu: 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd',
+      // WSDL / SOAP binding
+      wsdl: 'http://schemas.xmlsoap.org/wsdl/',
+      wsdlsoap: 'http://schemas.xmlsoap.org/wsdl/soap/',
+      apachesoap: 'http://xml.apache.org/xml-soap'
+    };
+
+    // Step 1: harvest any URIs already declared inline in the body.
+    // Inline declarations are authoritative and override every table entry.
+    const declaredInBody = {};
+    (body.match(/xmlns:(\w+)="([^"]+)"/g) || []).forEach((decl) => {
+      const [, prefix, uri] = decl.match(/xmlns:(\w+)="([^"]+)"/) || [];
+      if (prefix) {
+        declaredInBody[prefix] = uri;
+      }
+    });
+
+    // Step 2: collect every prefix used in element names.
+    const usedPrefixes = {};
+    (body.match(/<\/?(\w+):[A-Za-z]/g) || []).forEach((token) => {
+      const [, prefix] = token.match(/(\w+):/) || [];
+      if (prefix) {
+        usedPrefixes[prefix] = true;
+      }
+    });
+
+    // Resolves a prefix: inline body first, then API table, then standard table.
+    const apiNs = apiNamespaces[apiType] || apiNamespaces.EAS;
+    const resolveUri = (prefix) => declaredInBody[prefix] || apiNs[prefix] || standardNamespaces[prefix];
+
+    // Step 3: build the declaration list; emit() deduplicates.
+    const emitted = {};
+    const declarations = [];
+    const emit = (prefix) => {
+      const uri = resolveUri(prefix);
+      if (!emitted[prefix] && uri) {
+        declarations.push(`xmlns:${prefix}="${uri}"`);
+        emitted[prefix] = true;
+      }
+    };
+
+    // Always-present: soapenv (structural envelope requirement).
+    declarations.push('xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"');
+    emitted.soapenv = true;
+
+    // Emit every prefix the body actually uses (element names + inline declarations).
+    const allBodyPrefixes = { ...usedPrefixes };
+    Object.keys(declaredInBody).forEach((p) => {
+      allBodyPrefixes[p] = true;
+    });
+    Object.keys(allBodyPrefixes).forEach(emit);
+
+    // Always-present: xm — Metaswitch includes it on every envelope even when
+    // no element in the body uses the prefix directly (e.g. for attachment MIME types).
+    emit('xm');
+
+    return declarations.join(' ');
+  }
+
   /**
    * @function buildOriginHost
    * @summary Builds OriginHost XML element with credentials from adapter properties
-   *          Following Metaswitch pattern: server@domain?clientVersion=X.X&adminName=XXX&password=YYY
+   *          Following Metaswitch pattern: host?clientVersion=X.X&adminName=XXX&password=YYY
    *
+   * @param {string} body - The XML body to detect namespace prefix from
    * @returns {object} Object containing the OriginHost XML or error
    * @returns {string} returns.originHost - The OriginHost XML element
    * @returns {Error} returns.error - Error object if credentials are missing
    */
-  buildOriginHost() {
+  buildOriginHost(body) {
     const meth = 'adapter-buildOriginHost';
     const origin = `${this.id}-${meth}`;
     log.trace(origin);
 
     try {
       // Get credentials and connection info from adapter properties
+      // Properties are at top level: this.allProps.host, this.allProps.domain, etc.
       const auth = this.allProps.authentication || {};
-      const conn = this.allProps.properties || {};
 
       // Validate required credentials
       if (!auth.username || !auth.password) {
+        log.error(`${origin}: Missing authentication credentials - username: ${!!auth.username}, password: ${!!auth.password}`);
         return { error: new Error('Missing username or password in adapter authentication configuration') };
       }
 
-      // Build OriginHost value following Metaswitch sample pattern
-      // Format: server@domain?clientVersion=X.X&adminName=XXX&password=YYY&ignoreSequenceNumber=true
-      const server = conn.host || 'server';
-      const domain = conn.domain || 'domain';
-      const clientVersion = conn.clientVersion || '1.0';
+      // Build OriginHost value following working Metaswitch pattern
+      // Format: host?clientVersion=X.X&adminName=XXX&password=YYY&ignoreSequenceNumber=true
+      const host = this.allProps.host || 'server';
+      const clientVersion = this.allProps.clientVersion || '1.0';
+
+      log.debug(`${origin}: Using host=${host}, clientVersion=${clientVersion}, username=${auth.username}`);
 
       // URL-encode credentials to handle special characters
       const adminName = encodeURIComponent(auth.username);
       const password = encodeURIComponent(auth.password);
 
-      const originHostValue = `${server}@${domain}?clientVersion=${clientVersion}&adminName=${adminName}&password=${password}&ignoreSequenceNumber=true`;
+      const originHostValue = `${host}?clientVersion=${clientVersion}&adminName=${adminName}&password=${password}&ignoreSequenceNumber=true`;
+
+      // Detect namespace prefix from body (e.g., sh:ShPull -> use sh:OriginHost)
+      const nsMatch = body.match(/<(\w+):(ShPull|ShUpdate|ShSubs|ShNotif)/);
+      const nsPrefix = nsMatch ? `${nsMatch[1]}:` : '';
 
-      // Return as XML element (will be inserted into SOAP body)
-      const originHostXml = `<OriginHost>${this.escapeXml(originHostValue)}</OriginHost>`;
+      // Return as XML element with matching namespace prefix
+      const originHostXml = `<${nsPrefix}OriginHost>${this.escapeXml(originHostValue)}</${nsPrefix}OriginHost>`;
 
-      log.debug(`${origin}: Built OriginHost for ${server}@${domain} with user ${auth.username}`);
+      log.debug(`${origin}: Built OriginHost for ${host} with user ${auth.username} (namespace: ${nsPrefix || 'none'})`);
 
       return { originHost: originHostXml };
     } catch (ex) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itentialopensource/adapter-metaswitch",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "This adapter integrates with system described as: Metaswitch.",
   "main": "adapter.js",
   "wizardVersion": "3.12.1",
@@ -46,14 +46,14 @@
   "author": "Itential",
   "homepage": "https://gitlab.com/itentialopensource/adapters/adapter-metaswitch#readme",
   "dependencies": {
-    "@itentialopensource/adapter-utils": "6.1.22",
+    "@itentialopensource/adapter-utils": "6.1.23",
     "acorn": "8.16.0",
     "ajv": "8.20.0",
-    "axios": "1.16.0",
+    "axios": "1.18.1",
     "commander": "11.1.0",
-    "fs-extra": "11.3.5",
+    "fs-extra": "11.3.6",
     "json-query": "2.2.2",
-    "mocha": "12.0.0-beta-10",
+    "mocha": "12.0.0-rc.1",
     "mocha-param": "2.0.1",
     "mongodb": "4.17.2",
     "ping": "0.4.4",

package/report/adapterInfo.json

@@ -1,10 +1,10 @@
 {
-  "version": "1.2.0",
+  "version": "1.2.1",
   "configLines": 4722,
   "scriptLines": 2523,
-  "codeLines": 2750,
-  "testLines": 4416,
-  "testCases": 200,
-  "totalCodeLines": 9689,
+  "codeLines": 2919,
+  "testLines": 4606,
+  "testCases": 211,
+  "totalCodeLines": 10048,
   "wfTasks": 29
 }

package/test/unit/CLAUDE.md

@@ -0,0 +1,30 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+### Jun 4, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #2327 | 12:06 PM | 🔵 | Entity Method Implementation Locations Identified | ~619 |
+
+### Jun 11, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #2411 | 9:53 AM | ✅ | Replaced WS-Security Tests with OriginHost Builder and Injector Tests | ~614 |
+| #2410 | " | 🔄 | Updated getSoapNamespaces Test to Verify WS-Security Removal | ~403 |
+| #2409 | " | ✅ | Updated Unit Tests for OriginHost Authentication Pattern | ~535 |
+| #2408 | 9:52 AM | 🔄 | Updated Unit Test for OriginHost Authentication Pattern | ~176 |
+
+### Jun 15, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #2447 | 11:17 AM | 🔴 | OriginHost format corrected to match working implementation | ~334 |
+| #2443 | 10:57 AM | 🟣 | Authentication Refactoring Work Completed with All Tests Passing | ~341 |
+| #2440 | 10:22 AM | 🔴 | Property access and namespace detection fixes complete | ~306 |
+| #2437 | 10:21 AM | 🔴 | Updated Test Assertion to Match Namespaced OriginHost Element | ~334 |
+| #2429 | 10:10 AM | 🟣 | Added Namespace Prefix Detection to buildOriginHost Method | ~384 |
+</claude-mem-context>

package/test/unit/adapterTestUnit.js

@@ -280,10 +280,10 @@ describe('[unit] Metaswitch Adapter Test', () => {
           assert.notEqual(null, packageDotJson.dependencies);
           assert.notEqual('', packageDotJson.dependencies);
           assert.equal('8.20.0', packageDotJson.dependencies.ajv);
-          assert.equal('1.16.0', packageDotJson.dependencies.axios);
+          assert.equal('1.18.1', packageDotJson.dependencies.axios);
           assert.equal('11.1.0', packageDotJson.dependencies.commander);
-          assert.equal('11.3.5', packageDotJson.dependencies['fs-extra']);
-          assert.equal('12.0.0-beta-10', packageDotJson.dependencies.mocha);
+          assert.equal('11.3.6', packageDotJson.dependencies['fs-extra']);
+          assert.equal('12.0.0-rc.1', packageDotJson.dependencies.mocha);
           assert.equal('2.0.1', packageDotJson.dependencies['mocha-param']);
           assert.equal('0.4.4', packageDotJson.dependencies.ping);
           assert.equal('1.4.10', packageDotJson.dependencies['readline-sync']);
@@ -1496,7 +1496,7 @@ describe('[unit] Metaswitch Adapter Test', () => {
             assert.equal(result.payload.includes('<soapenv:Envelope'), true);
             assert.equal(result.payload.includes('<soapenv:Header/>'), true);
             assert.equal(result.payload.includes('<soapenv:Body>'), true);
-            assert.equal(result.payload.includes('<OriginHost>'), true);
+            assert.equal(result.payload.includes('<sh:OriginHost>'), true);
             assert.equal(result.payload.includes('adminName='), true);
             assert.equal(result.payload.includes('password='), true);
             assert.equal(result.payload.includes('clientVersion='), true);
@@ -1612,8 +1612,31 @@ describe('[unit] Metaswitch Adapter Test', () => {
             assert.equal(result.payload.includes('<wsse:Security'), false);
             assert.equal(result.payload.includes('<wsse:UsernameToken>'), false);
 
-            // Should have OriginHost with credentials instead
-            assert.equal(result.payload.includes('<OriginHost>'), true);
+            // Should have OriginHost with credentials and matching namespace prefix
+            assert.equal(result.payload.includes('<sh:OriginHost>'), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should include all namespace declarations from a multi-namespace payload', (done) => {
+          try {
+            // Payload that uses xsi and xsd prefixes in addition to sh
+            const xmlPayload = '<sh:ShPull xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><UserIdentity xsi:type="xsd:string">12345</UserIdentity></sh:ShPull>';
+            const result = a.wrapBodyInSoapEnvelope(xmlPayload, 'EAS');
+
+            assert.equal(result.error, undefined);
+            assert.notEqual(result.payload, undefined);
+            // Core envelope structure
+            assert.equal(result.payload.includes('<soapenv:Envelope'), true);
+            assert.equal(result.payload.includes('xmlns:soapenv='), true);
+            // sh: namespace pulled from apiType
+            assert.equal(result.payload.includes('xmlns:sh="http://www.metaswitch.com/sdp/soap/sh"'), true);
+            // Additional namespaces from the payload must survive into the envelope
+            assert.equal(result.payload.includes('xmlns:xsi='), true);
+            assert.equal(result.payload.includes('xmlns:xsd='), true);
             done();
           } catch (error) {
             log.error(`Test Failure: ${error}`);
@@ -1681,6 +1704,147 @@ describe('[unit] Metaswitch Adapter Test', () => {
         }).timeout(attemptTimeout);
       });
 
+      describe('#collectNamespaceDeclarations', () => {
+        it('should have a collectNamespaceDeclarations function', (done) => {
+          try {
+            assert.equal(true, typeof a.collectNamespaceDeclarations === 'function');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should always include soapenv declaration', (done) => {
+          try {
+            const body = '<sh:ShPull><UserIdentity>test</UserIdentity></sh:ShPull>';
+            const result = a.collectNamespaceDeclarations(body, 'EAS');
+
+            assert.equal(result.includes('xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"'), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should resolve sh: namespace per apiType when used in body', (done) => {
+          try {
+            const body = '<sh:ShPull><UserIdentity>test</UserIdentity></sh:ShPull>';
+            const apiTypes = [
+              { type: 'EAS', base: 'http://www.metaswitch.com/sdp/soap/sh' },
+              { type: 'NSeries', base: 'http://www.metaswitch.com/nsrs/soap/sh' },
+              { type: 'Metaview', base: 'http://www.metaswitch.com/ems/soap/sh' },
+              { type: 'NWSAP', base: 'http://www.metaswitch.com/srb/soap/sh' }
+            ];
+
+            apiTypes.forEach(({ type, base }) => {
+              const result = a.collectNamespaceDeclarations(body, type);
+              assert.equal(result.includes(`xmlns:sh="${base}"`), true);
+            });
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should resolve user and ser from static table when detected in body', (done) => {
+          try {
+            // Body that uses user: and ser: element prefixes
+            const body = '<sh:ShUpdate><user:Sh-Data><ser:MetaSphereData/></user:Sh-Data></sh:ShUpdate>';
+            const apiTypes = [
+              { type: 'EAS', base: 'http://www.metaswitch.com/sdp/soap/sh' },
+              { type: 'NSeries', base: 'http://www.metaswitch.com/nsrs/soap/sh' },
+              { type: 'Metaview', base: 'http://www.metaswitch.com/ems/soap/sh' },
+              { type: 'NWSAP', base: 'http://www.metaswitch.com/srb/soap/sh' }
+            ];
+
+            apiTypes.forEach(({ type, base }) => {
+              const result = a.collectNamespaceDeclarations(body, type);
+              assert.equal(result.includes(`xmlns:user="${base}/userdata"`), true);
+              assert.equal(result.includes(`xmlns:ser="${base}/servicedata"`), true);
+            });
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should NOT include user or ser when absent from body', (done) => {
+          try {
+            // Minimal body with only sh: elements
+            const body = '<sh:ShPull><UserIdentity>test</UserIdentity></sh:ShPull>';
+            const result = a.collectNamespaceDeclarations(body, 'EAS');
+
+            assert.equal(result.includes('xmlns:user='), false);
+            assert.equal(result.includes('xmlns:ser='), false);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should always include xm even when absent from body', (done) => {
+          try {
+            // Minimal body — xm: never appears as an element prefix
+            const body = '<sh:ShPull><UserIdentity>test</UserIdentity></sh:ShPull>';
+            const result = a.collectNamespaceDeclarations(body, 'EAS');
+
+            assert.equal(result.includes('xmlns:xm="http://www.w3.org/2005/05/xmlmime"'), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should include xsi and xsd declarations when used in body', (done) => {
+          try {
+            const body = '<sh:ShPull xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><UserIdentity xsi:type="xsd:string">test</UserIdentity></sh:ShPull>';
+            const result = a.collectNamespaceDeclarations(body, 'EAS');
+
+            assert.equal(result.includes('xmlns:xsi='), true);
+            assert.equal(result.includes('xmlns:xsd='), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should prefer inline body declarations over fallback table', (done) => {
+          try {
+            // Body declares xsi with a custom URI — that should win over the known fallback
+            const customUri = 'http://custom.example.com/schema-instance';
+            const body = `<sh:ShPull xmlns:xsi="${customUri}"><UserIdentity xsi:type="string">test</UserIdentity></sh:ShPull>`;
+            const result = a.collectNamespaceDeclarations(body, 'EAS');
+
+            assert.equal(result.includes(`xmlns:xsi="${customUri}"`), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should not add declarations for unrecognised prefixes', (done) => {
+          try {
+            // zz: is not in the known fallback table and not declared inline
+            const body = '<sh:ShPull><zz:Unknown>test</zz:Unknown></sh:ShPull>';
+            const result = a.collectNamespaceDeclarations(body, 'EAS');
+
+            assert.equal(result.includes('xmlns:zz='), false);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+      });
+
       describe('#buildOriginHost', () => {
         it('should have a buildOriginHost function', (done) => {
           try {
@@ -1694,12 +1858,13 @@ describe('[unit] Metaswitch Adapter Test', () => {
 
         it('should create OriginHost with credentials from adapter properties', (done) => {
           try {
-            const result = a.buildOriginHost();
+            const body = '<sh:ShPull><UserIdentity>test</UserIdentity></sh:ShPull>';
+            const result = a.buildOriginHost(body);
 
             assert.equal(result.error, undefined);
             assert.notEqual(result.originHost, undefined);
-            assert.equal(result.originHost.includes('<OriginHost>'), true);
-            assert.equal(result.originHost.includes('</OriginHost>'), true);
+            assert.equal(result.originHost.includes('<sh:OriginHost>'), true);
+            assert.equal(result.originHost.includes('</sh:OriginHost>'), true);
             assert.equal(result.originHost.includes('adminName='), true);
             assert.equal(result.originHost.includes('password='), true);
             assert.equal(result.originHost.includes('clientVersion='), true);
@@ -1713,7 +1878,8 @@ describe('[unit] Metaswitch Adapter Test', () => {
 
         it('should URL-encode credentials with special characters', (done) => {
           try {
-            const result = a.buildOriginHost();
+            const body = '<sh:ShPull><UserIdentity>test</UserIdentity></sh:ShPull>';
+            const result = a.buildOriginHost(body);
 
             // If password contains &, it should be URL-encoded as %26
             // This test validates URL encoding is applied
@@ -1727,6 +1893,30 @@ describe('[unit] Metaswitch Adapter Test', () => {
             done(error);
           }
         }).timeout(attemptTimeout);
+
+        it('should detect and use namespace prefix from body', (done) => {
+          try {
+            const bodyWithNs = '<sh:ShPull><UserIdentity>test</UserIdentity></sh:ShPull>';
+            const bodyWithoutNs = '<ShUpdate><UserIdentity>test</UserIdentity></ShUpdate>';
+
+            const resultWithNs = a.buildOriginHost(bodyWithNs);
+            const resultWithoutNs = a.buildOriginHost(bodyWithoutNs);
+
+            // With namespace prefix
+            assert.equal(resultWithNs.originHost.includes('<sh:OriginHost>'), true);
+            assert.equal(resultWithNs.originHost.includes('</sh:OriginHost>'), true);
+
+            // Without namespace prefix
+            assert.equal(resultWithoutNs.originHost.includes('<OriginHost>'), true);
+            assert.equal(resultWithoutNs.originHost.includes('</OriginHost>'), true);
+            assert.equal(resultWithoutNs.originHost.includes('<sh:OriginHost>'), false);
+
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
       });
 
       describe('#injectOriginHost', () => {