@yousolution/node-red-contrib-you-sap-service-layer 0.0.3 → 0.0.6

package/test/manipulateEntitySap.spec.js

@@ -0,0 +1,191 @@
+const should = require('should');
+const helper = require('node-red-node-test-helper');
+const manipulateEntitySap = require('../nodes/manipulateEntitySap');
+const Context = require('../node_modules/./@node-red/runtime/lib/nodes/context/index');
+const sinon = require('sinon');
+const Support = require('../nodes/support');
+
+helper.init(require.resolve('node-red'));
+
+describe('manipulateEntitySap Node', () => {
+  beforeEach((done) => {
+    helper.startServer(done);
+  });
+
+  function initContext(done) {
+    Context.init({
+      contextStorage: {
+        memory0: {
+          module: 'memory',
+        },
+        memory1: {
+          module: 'memory',
+        },
+      },
+    });
+    Context.load().then(function () {
+      done();
+    });
+  }
+
+  afterEach((done) => {
+    helper
+      .unload()
+      .then(function () {
+        return Context.clean({ allNodes: {} });
+      })
+      .then(function () {
+        return Context.close();
+      })
+      .then(function () {
+        helper.stopServer(done);
+      });
+
+    // Restore the default sandbox here
+    sinon.restore();
+
+    // helper.unload();
+    // helper.stopServer(done);
+  });
+
+  it('should be loaded', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'manipulateEntitySap',
+        name: 'manipulateEntitySap',
+        wires: [['n2']],
+        z: 'flow',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+    ];
+
+    helper.load(manipulateEntitySap, flow, () => {
+      initContext(function () {
+        const n1 = helper.getNode('n1');
+
+        // console.log(helper.log().args);
+
+        // n1.context().flow.set('A', 1, 'memory1', function (error) {
+        //   console.log(error);
+        // });
+
+        // console.log(n1.context().flow.get('A', 'memory1'));
+        // console.log('- - - B- - - -');
+
+        // n1.id
+        // flow.push({
+        //   [`_YOU_SapServiceLayer_${n1.id}.headers`]:
+        // })
+
+        try {
+          // n1.status.calledWith({ fill: 'gray', shape: 'ring', text: 'Set credentials1' });
+          // should.equal(n1.status.calledWith({ fill: 'gray', shape: 'ring', text: 'Missing credentials' }), true);
+          n1.should.have.property('name', 'manipulateEntitySap');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should have correct request with data', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'manipulateEntitySap',
+        name: 'manipulateEntitySap',
+        entity: 'PickLists',
+        manipulateMethod: 'GetReleasedAllocation',
+        entityId: '123',
+        wires: [['n2']],
+        z: 'flow',
+        bodyData: 'data',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+      { id: 'n2', type: 'helper' },
+    ];
+    helper.load(manipulateEntitySap, flow, () => {
+      const n2 = helper.getNode('n2');
+      const n1 = helper.getNode('n1');
+
+      sinon.stub(Support, 'sendRequest').resolves({ data: 'ok', status: 200 });
+
+      n1.receive({ data: { cardCode: '00000001', cardName: '0000001' } });
+
+      n2.on('input', (msg) => {
+        try {
+          msg.should.have.property('_msgid');
+          msg.should.have.property('payload', 'ok');
+          msg.should.have.property('statusCode', 200);
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should have request without data', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'manipulateEntitySap',
+        name: 'manipulateEntitySap',
+        wires: [['n2']],
+        z: 'flow',
+        bodyPost: 'data',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+      { id: 'n2', type: 'helper' },
+    ];
+    helper.load(manipulateEntitySap, flow, () => {
+      const n2 = helper.getNode('n2');
+      const n1 = helper.getNode('n1');
+
+      sinon.stub(Support, 'sendRequest').resolves({ data: 'ok', status: 200 });
+      n1.receive({});
+
+      n2.on('input', (msg) => {
+        try {
+          msg.should.have.property('_msgid');
+          msg.should.have.property('payload', 'ok');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should handle the error', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'manipulateEntitySap',
+        name: 'manipulateEntitySap',
+        wires: [['n2']],
+        z: 'flow',
+        bodyPatch: 'data',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+      { id: 'n2', type: 'helper' },
+    ];
+    helper.load(manipulateEntitySap, flow, () => {
+      const n2 = helper.getNode('n2');
+      const n1 = helper.getNode('n1');
+
+      const expected = new Error('Custom error');
+
+      sinon.stub(Support, 'sendRequest').rejects(expected);
+
+      n1.receive({ data: { cardCode: '00000001', cardName: '0000001' } });
+
+      n1.on('call:error', (error) => {
+        should.deepEqual(error.args[0], expected);
+        done();
+      });
+    });
+  });
+});

package/test/serviceSap.spec.js

@@ -0,0 +1,170 @@
+const should = require('should');
+const helper = require('node-red-node-test-helper');
+const serviceSap = require('../nodes/serviceSap');
+const Context = require('../node_modules/./@node-red/runtime/lib/nodes/context/index');
+const sinon = require('sinon');
+const Support = require('../nodes/support');
+
+helper.init(require.resolve('node-red'));
+
+describe('serviceSap Node', () => {
+  beforeEach((done) => {
+    helper.startServer(done);
+  });
+
+  function initContext(done) {
+    Context.init({
+      contextStorage: {
+        memory0: {
+          module: 'memory',
+        },
+        memory1: {
+          module: 'memory',
+        },
+      },
+    });
+    Context.load().then(function () {
+      done();
+    });
+  }
+
+  afterEach((done) => {
+    helper
+      .unload()
+      .then(function () {
+        return Context.clean({ allNodes: {} });
+      })
+      .then(function () {
+        return Context.close();
+      })
+      .then(function () {
+        helper.stopServer(done);
+      });
+
+    // Restore the default sandbox here
+    sinon.restore();
+
+    // helper.unload();
+    // helper.stopServer(done);
+  });
+
+  it('should be loaded', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'serviceSap',
+        name: 'serviceSap',
+        wires: [['n2']],
+        z: 'flow',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+    ];
+
+    helper.load(serviceSap, flow, () => {
+      initContext(function () {
+        const n1 = helper.getNode('n1');
+        try {
+          n1.should.have.property('name', 'serviceSap');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should have correct request with data', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'serviceSap',
+        name: 'serviceSap',
+        wires: [['n2']],
+        z: 'flow',
+        bodyPost: 'data',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+      { id: 'n2', type: 'helper' },
+    ];
+    helper.load(serviceSap, flow, () => {
+      const n2 = helper.getNode('n2');
+      const n1 = helper.getNode('n1');
+
+      sinon.stub(Support, 'sendRequest').resolves('ok');
+
+      n1.receive({ data: { cardCode: '00000001', cardName: '0000001' } });
+
+      n2.on('input', (msg) => {
+        try {
+          msg.should.have.property('_msgid');
+          msg.should.have.property('payload', 'ok');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should have request without data', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'serviceSap',
+        name: 'serviceSap',
+        wires: [['n2']],
+        z: 'flow',
+        bodyPost: 'data',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+      { id: 'n2', type: 'helper' },
+    ];
+    helper.load(serviceSap, flow, () => {
+      const n2 = helper.getNode('n2');
+      const n1 = helper.getNode('n1');
+
+      sinon.stub(Support, 'sendRequest').resolves('ok');
+      n1.receive({});
+
+      n2.on('input', (msg) => {
+        try {
+          msg.should.have.property('_msgid');
+          msg.should.have.property('payload', 'ok');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should handle the error', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'serviceSap',
+        name: 'serviceSap',
+        wires: [['n2']],
+        z: 'flow',
+        bodyPost: 'data',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+      { id: 'n2', type: 'helper' },
+    ];
+    helper.load(serviceSap, flow, () => {
+      const n2 = helper.getNode('n2');
+      const n1 = helper.getNode('n1');
+
+      const expected = new Error('Custom error');
+
+      sinon.stub(Support, 'sendRequest').rejects(expected);
+
+      n1.receive({ data: { cardCode: '00000001', cardName: '0000001' } });
+
+      n1.on('call:error', (error) => {
+        should.deepEqual(error.args[0], expected);
+        done();
+      });
+    });
+  });
+});

package/test/support.spec.js

@@ -555,6 +555,286 @@ describe('support library', () => {
       should.deepEqual(Support.generateRequest(node, msg, config, options), expectedValue);
     });
 
+    it('should generate a correct request with Services', () => {
+      const node = {
+        context: () => {
+          return {
+            flow: {
+              get: (param) => {
+                if (param == '_YOU_SapServiceLayer_1.host') {
+                  return 'host';
+                }
+                if (param == '_YOU_SapServiceLayer_1.port') {
+                  return 'port';
+                }
+                if (param == '_YOU_SapServiceLayer_1.version') {
+                  return 'version';
+                }
+                if (param == '_YOU_SapServiceLayer_1.headers') {
+                  return ['header:1', 'header:2'];
+                }
+              },
+            },
+          };
+        },
+      };
+
+      const msg = {
+        _YOU_SapServiceLayer: {
+          idAuth: 1,
+        },
+        DocEntry: 1,
+      };
+      let config = {
+        service: 'ApprovalTemplatesService_GetApprovalTemplateList',
+      };
+      const options = { method: 'POST', hasRawQuery: false, hasEntityId: false, isService: true };
+      const expectedValue = {
+        axiosOptions: {
+          headers: {
+            Cookie: 'header:1;header:2',
+          },
+          method: 'POST',
+          rejectUnauthorized: false,
+          url: 'https://host:port/b1s/version/ApprovalTemplatesService_GetApprovalTemplateList',
+          withCredentials: true,
+        },
+        idAuthNode: 1,
+      };
+
+      should.deepEqual(Support.generateRequest(node, msg, config, options), expectedValue);
+    });
+
+    it('should generate a error request with Services missing service', () => {
+      const node = {
+        context: () => {
+          return {
+            flow: {
+              get: (param) => {
+                if (param == '_YOU_SapServiceLayer_1.host') {
+                  return 'host';
+                }
+                if (param == '_YOU_SapServiceLayer_1.port') {
+                  return 'port';
+                }
+                if (param == '_YOU_SapServiceLayer_1.version') {
+                  return 'version';
+                }
+                if (param == '_YOU_SapServiceLayer_1.headers') {
+                  return ['header:1', 'header:2'];
+                }
+              },
+            },
+          };
+        },
+      };
+
+      const msg = {
+        _YOU_SapServiceLayer: {
+          idAuth: 1,
+        },
+        DocEntry: 1,
+      };
+      let config = {
+        //  service: 'ApprovalTemplatesService_GetApprovalTemplateList',
+      };
+      const options = { method: 'POST', hasRawQuery: false, hasEntityId: false, isService: true };
+      const expectedValue = {
+        axiosOptions: {
+          headers: {
+            Cookie: 'header:1;header:2',
+          },
+          method: 'POST',
+          rejectUnauthorized: false,
+          url: 'https://host:port/b1s/version/ApprovalTemplatesService_GetApprovalTemplateList',
+          withCredentials: true,
+        },
+        idAuthNode: 1,
+      };
+
+      expect(() => {
+        Support.generateRequest(node, msg, config, options);
+      }).to.throw('Missing service');
+    });
+
+    it('should generate a correct request with Manipulate Entity', () => {
+      const node = {
+        context: () => {
+          return {
+            flow: {
+              get: (param) => {
+                if (param == '_YOU_SapServiceLayer_1.host') {
+                  return 'host';
+                }
+                if (param == '_YOU_SapServiceLayer_1.port') {
+                  return 'port';
+                }
+                if (param == '_YOU_SapServiceLayer_1.version') {
+                  return 'version';
+                }
+                if (param == '_YOU_SapServiceLayer_1.headers') {
+                  return ['header:1', 'header:2'];
+                }
+              },
+            },
+          };
+        },
+      };
+
+      const msg = {
+        _YOU_SapServiceLayer: {
+          idAuth: 1,
+        },
+        entityId: 3,
+      };
+      let config = {
+        entity: 'PickLists',
+        entityId: 'entityId',
+        manipulateMethod: 'GetReleasedAllocation',
+      };
+      const options = { method: 'POST', hasRawQuery: false, hasEntityId: true, isManipulate: true };
+      const expectedValue = {
+        axiosOptions: {
+          headers: {
+            Cookie: 'header:1;header:2',
+          },
+          method: 'POST',
+          rejectUnauthorized: false,
+          url: 'https://host:port/b1s/version/PickLists(3)/GetReleasedAllocation',
+          withCredentials: true,
+        },
+        idAuthNode: 1,
+      };
+
+      should.deepEqual(Support.generateRequest(node, msg, config, options), expectedValue);
+    });
+
+    it('should generate an error request with Manipulate Entity missing entity', () => {
+      const node = {
+        context: () => {
+          return {
+            flow: {
+              get: (param) => {
+                if (param == '_YOU_SapServiceLayer_1.host') {
+                  return 'host';
+                }
+                if (param == '_YOU_SapServiceLayer_1.port') {
+                  return 'port';
+                }
+                if (param == '_YOU_SapServiceLayer_1.version') {
+                  return 'version';
+                }
+                if (param == '_YOU_SapServiceLayer_1.headers') {
+                  return ['header:1', 'header:2'];
+                }
+              },
+            },
+          };
+        },
+      };
+
+      const msg = {
+        _YOU_SapServiceLayer: {
+          idAuth: 1,
+        },
+        entityId: 3,
+      };
+      let config = {
+        // entity: 'PickLists',
+        entityId: 'entityId',
+        manipulateMethod: 'GetReleasedAllocation',
+      };
+      const options = { method: 'POST', hasRawQuery: false, hasEntityId: true, isManipulate: true };
+
+      expect(() => {
+        Support.generateRequest(node, msg, config, options);
+      }).to.throw('Missing entity');
+    });
+
+    it('should generate an error request with Manipulate Entity missing entity id', () => {
+      const node = {
+        context: () => {
+          return {
+            flow: {
+              get: (param) => {
+                if (param == '_YOU_SapServiceLayer_1.host') {
+                  return 'host';
+                }
+                if (param == '_YOU_SapServiceLayer_1.port') {
+                  return 'port';
+                }
+                if (param == '_YOU_SapServiceLayer_1.version') {
+                  return 'version';
+                }
+                if (param == '_YOU_SapServiceLayer_1.headers') {
+                  return ['header:1', 'header:2'];
+                }
+              },
+            },
+          };
+        },
+      };
+
+      const msg = {
+        _YOU_SapServiceLayer: {
+          idAuth: 1,
+        },
+        entityId: 3,
+      };
+      let config = {
+        entity: 'PickLists',
+        // entityId: 'entityId',
+        manipulateMethod: 'GetReleasedAllocation',
+      };
+      const options = { method: 'POST', hasRawQuery: false, hasEntityId: true, isManipulate: true };
+
+      expect(() => {
+        Support.generateRequest(node, msg, config, options);
+      }).to.throw('Missing entityId');
+    });
+
+    it('should generate an error request with Manipulate Entity missing method', () => {
+      const node = {
+        context: () => {
+          return {
+            flow: {
+              get: (param) => {
+                if (param == '_YOU_SapServiceLayer_1.host') {
+                  return 'host';
+                }
+                if (param == '_YOU_SapServiceLayer_1.port') {
+                  return 'port';
+                }
+                if (param == '_YOU_SapServiceLayer_1.version') {
+                  return 'version';
+                }
+                if (param == '_YOU_SapServiceLayer_1.headers') {
+                  return ['header:1', 'header:2'];
+                }
+              },
+            },
+          };
+        },
+      };
+
+      const msg = {
+        _YOU_SapServiceLayer: {
+          idAuth: 1,
+        },
+        entityId: 3,
+      };
+      let config = {
+        entity: 'PickLists',
+        entityId: 'entityId',
+        // manipulateMethod: 'GetReleasedAllocation',
+      };
+      const options = { method: 'POST', hasRawQuery: false, hasEntityId: true, isManipulate: true };
+
+      expect(() => {
+        Support.generateRequest(node, msg, config, options);
+      }).to.throw('Missing method');
+    });
+
     it('should have error missing object', () => {
       const node = {
         context: () => {