@itentialopensource/adapter-metaswitch 1.0.3 → 1.2.1

package/test/unit/adapterTestUnit.js

@@ -1474,6 +1474,415 @@ describe('[unit] Metaswitch Adapter Test', () => {
     -----------------------------------------------------------------------
     */
 
+    describe('#SOAP Wrapper Utility Methods', () => {
+      describe('#wrapBodyInSoapEnvelope', () => {
+        it('should have a wrapBodyInSoapEnvelope function', (done) => {
+          try {
+            assert.equal(true, typeof a.wrapBodyInSoapEnvelope === 'function');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should wrap XML payload with SOAP envelope and inject OriginHost', (done) => {
+          try {
+            const xmlPayload = '<sh:ShPull><UserIdentity>12345</UserIdentity></sh:ShPull>';
+            const result = a.wrapBodyInSoapEnvelope(xmlPayload, 'EAS');
+
+            assert.equal(result.error, undefined);
+            assert.notEqual(result.payload, undefined);
+            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('adminName='), true);
+            assert.equal(result.payload.includes('password='), true);
+            assert.equal(result.payload.includes('clientVersion='), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should return error for empty body', (done) => {
+          try {
+            const result = a.wrapBodyInSoapEnvelope('', 'EAS');
+
+            assert.notEqual(result.error, undefined);
+            assert.equal(result.error.message, 'Empty payload body provided');
+            assert.equal(result.payload, undefined);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should return error for null body', (done) => {
+          try {
+            const result = a.wrapBodyInSoapEnvelope(null, 'EAS');
+
+            assert.notEqual(result.error, undefined);
+            assert.equal(result.error.message, 'Empty payload body provided');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should detect existing SOAP envelope with soapenv prefix', (done) => {
+          try {
+            const soapPayload = '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"><soapenv:Body><TestRequest/></soapenv:Body></soapenv:Envelope>';
+            const result = a.wrapBodyInSoapEnvelope(soapPayload, 'EAS');
+
+            assert.equal(result.error, undefined);
+            assert.equal(result.payload, soapPayload);
+            assert.equal(result.alreadyWrapped, true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should detect existing SOAP envelope with soap prefix', (done) => {
+          try {
+            const soapPayload = '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><TestRequest/></soap:Body></soap:Envelope>';
+            const result = a.wrapBodyInSoapEnvelope(soapPayload, 'EAS');
+
+            assert.equal(result.error, undefined);
+            assert.equal(result.payload, soapPayload);
+            assert.equal(result.alreadyWrapped, true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should detect existing SOAP envelope with SOAP-ENV prefix', (done) => {
+          try {
+            const soapPayload = '<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"><SOAP-ENV:Body><TestRequest/></SOAP-ENV:Body></SOAP-ENV:Envelope>';
+            const result = a.wrapBodyInSoapEnvelope(soapPayload, 'EAS');
+
+            assert.equal(result.error, undefined);
+            assert.equal(result.payload, soapPayload);
+            assert.equal(result.alreadyWrapped, true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should use correct namespaces for different API types', (done) => {
+          try {
+            const xmlPayload = '<sh:ShPull><UserIdentity>test</UserIdentity></sh:ShPull>';
+
+            const easResult = a.wrapBodyInSoapEnvelope(xmlPayload, 'EAS');
+            assert.equal(easResult.payload.includes('xmlns:sh="http://www.metaswitch.com/sdp/soap/sh"'), true);
+
+            const nseriesResult = a.wrapBodyInSoapEnvelope(xmlPayload, 'NSeries');
+            assert.equal(nseriesResult.payload.includes('xmlns:sh="http://www.metaswitch.com/nsrs/soap/sh"'), true);
+
+            const metaviewResult = a.wrapBodyInSoapEnvelope(xmlPayload, 'Metaview');
+            assert.equal(metaviewResult.payload.includes('xmlns:sh="http://www.metaswitch.com/ems/soap/sh"'), true);
+
+            const nwsapResult = a.wrapBodyInSoapEnvelope(xmlPayload, 'NWSAP');
+            assert.equal(nwsapResult.payload.includes('xmlns:sh="http://www.metaswitch.com/srb/soap/sh"'), true);
+
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should NOT include WS-Security headers (Metaswitch uses OriginHost)', (done) => {
+          try {
+            const xmlPayload = '<sh:ShPull><UserIdentity>test</UserIdentity></sh:ShPull>';
+            const result = a.wrapBodyInSoapEnvelope(xmlPayload, 'EAS');
+
+            // Should have empty header, not WS-Security
+            assert.equal(result.payload.includes('<soapenv:Header/>'), true);
+            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);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+      });
+
+      describe('#getSoapNamespaces', () => {
+        it('should have a getSoapNamespaces function', (done) => {
+          try {
+            assert.equal(true, typeof a.getSoapNamespaces === 'function');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should return namespaces for EAS API', (done) => {
+          try {
+            const namespaces = a.getSoapNamespaces('EAS');
+
+            assert.equal(namespaces.includes('xmlns:soapenv='), true);
+            assert.equal(namespaces.includes('xmlns:sh='), true);
+            assert.equal(namespaces.includes('http://www.metaswitch.com/sdp/soap/sh'), true);
+            // Should NOT include WS-Security namespaces (Metaswitch uses OriginHost)
+            assert.equal(namespaces.includes('xmlns:wsse='), false);
+            assert.equal(namespaces.includes('xmlns:wsu='), false);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should return namespaces for all API types', (done) => {
+          try {
+            const apiTypes = ['EAS', 'NSeries', 'Metaview', 'NWSAP'];
+
+            apiTypes.forEach((apiType) => {
+              const namespaces = a.getSoapNamespaces(apiType);
+              assert.notEqual(namespaces, undefined);
+              assert.equal(namespaces.length > 0, true);
+            });
+
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should return default namespaces for unknown API type', (done) => {
+          try {
+            const namespaces = a.getSoapNamespaces('UnknownAPI');
+
+            assert.equal(namespaces.includes('xmlns:soapenv='), true);
+            assert.equal(namespaces.includes('xmlns:sh='), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+      });
+
+      describe('#buildOriginHost', () => {
+        it('should have a buildOriginHost function', (done) => {
+          try {
+            assert.equal(true, typeof a.buildOriginHost === 'function');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should create OriginHost with credentials from adapter properties', (done) => {
+          try {
+            const result = a.buildOriginHost();
+
+            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('adminName='), true);
+            assert.equal(result.originHost.includes('password='), true);
+            assert.equal(result.originHost.includes('clientVersion='), true);
+            assert.equal(result.originHost.includes('ignoreSequenceNumber=true'), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should URL-encode credentials with special characters', (done) => {
+          try {
+            const result = a.buildOriginHost();
+
+            // If password contains &, it should be URL-encoded as %26
+            // This test validates URL encoding is applied
+            assert.equal(result.error, undefined);
+            assert.notEqual(result.originHost, undefined);
+            // The OriginHost value should be XML-escaped (& becomes &amp;)
+            assert.equal(result.originHost.includes('&amp;adminName='), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+      });
+
+      describe('#injectOriginHost', () => {
+        it('should have an injectOriginHost function', (done) => {
+          try {
+            assert.equal(true, typeof a.injectOriginHost === 'function');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should inject OriginHost before closing ShPull tag', (done) => {
+          try {
+            const body = '<sh:ShPull><UserIdentity>12345</UserIdentity></sh:ShPull>';
+            const originHost = '<OriginHost>server@domain?adminName=test&amp;password=test</OriginHost>';
+            const result = a.injectOriginHost(body, originHost);
+
+            assert.equal(result.includes(originHost), true);
+            assert.equal(result.indexOf(originHost) < result.indexOf('</sh:ShPull>'), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should inject OriginHost before closing ShUpdate tag', (done) => {
+          try {
+            const body = '<sh:ShUpdate><UserIdentity>12345</UserIdentity></sh:ShUpdate>';
+            const originHost = '<OriginHost>server@domain?adminName=test&amp;password=test</OriginHost>';
+            const result = a.injectOriginHost(body, originHost);
+
+            assert.equal(result.includes(originHost), true);
+            assert.equal(result.indexOf(originHost) < result.indexOf('</sh:ShUpdate>'), true);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+      });
+
+      describe('#escapeXml', () => {
+        it('should have an escapeXml function', (done) => {
+          try {
+            assert.equal(true, typeof a.escapeXml === 'function');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should escape ampersand', (done) => {
+          try {
+            const result = a.escapeXml('test & value');
+            assert.equal(result, 'test &amp; value');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should escape less than', (done) => {
+          try {
+            const result = a.escapeXml('test < value');
+            assert.equal(result, 'test &lt; value');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should escape greater than', (done) => {
+          try {
+            const result = a.escapeXml('test > value');
+            assert.equal(result, 'test &gt; value');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should escape double quote', (done) => {
+          try {
+            const result = a.escapeXml('test "value"');
+            assert.equal(result, 'test &quot;value&quot;');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should escape single quote', (done) => {
+          try {
+            const result = a.escapeXml("test 'value'");
+            assert.equal(result, 'test &apos;value&apos;');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should escape all special characters together', (done) => {
+          try {
+            const result = a.escapeXml('<tag attr="value" other=\'test\'>content & more</tag>');
+            assert.equal(result, '&lt;tag attr=&quot;value&quot; other=&apos;test&apos;&gt;content &amp; more&lt;/tag&gt;');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should return empty string for null input', (done) => {
+          try {
+            const result = a.escapeXml(null);
+            assert.equal(result, '');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should return empty string for undefined input', (done) => {
+          try {
+            const result = a.escapeXml(undefined);
+            assert.equal(result, '');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+
+        it('should not modify strings without special characters', (done) => {
+          try {
+            const result = a.escapeXml('normaltext123');
+            assert.equal(result, 'normaltext123');
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        }).timeout(attemptTimeout);
+      });
+    });
+
     describe('#postMetaSphereEAS - errors', () => {
       it('should have a postMetaSphereEAS function', (done) => {
         try {