biz-a-cli 2.3.57 → 2.3.59

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "biz-a-cli",
   "nameDev": "biz-a-cli-dev",
-  "version": "2.3.57",
+  "version": "2.3.59",
   "versionDev": "0.0.34",
   "description": "",
   "main": "bin/index.js",
@@ -12,9 +12,9 @@
   },
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch a",
-    "test1": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "testOnce": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "dev": "node --watch server.js",
-    "hub": "node --experimental-vm-modules bin/hub.js"
+    "hub": "set NODE_ENV=production && node --experimental-vm-modules bin/hub.js"
   },
   "author": "Imamatek",
   "license": "ISC",
@@ -41,7 +41,7 @@
     "socket.io-client": "^4.7.5",
     "socket.io-stream": "^0.9.1",
     "tar": "^7.4.0",
-    "uglify-js": "^3.17.4",
+    "uglify-js": "^3.19.3",
     "web-push": "^3.6.7",
     "winston": "^3.13.0",
     "yargs": "^17.7.2"
@@ -55,6 +55,9 @@
       "<rootDir>/tests/**",
       "!<rootDir>/tests/mockData",
       "!<rootDir>/tests/mockData/**"
-    ]
+    ],
+    "testPathIgnorePatterns": ["<rootDir>/node_modules", "<rootDir>/tests/mockData"],
+    "watchPathIgnorePatterns": ["<rootDir>/node_modules", "<rootDir>/tests/mockData"],
+    "coveragePathIgnorePatterns": ["<rootDir>/node_modules", "<rootDir>/tests/mockData", "<rootDir>/tests/mockData/**"]
   }
 }

package/tests/app.test.js

@@ -47,14 +47,12 @@ describe('Biz-A Apps CLI', ()=>{
 
     describe('Add App', ()=>{
         const mockDataFolder = './tests/mockData/'
-        const appName = 'mockApp'
-        const appFolderName = mockDataFolder + appName+ '/';
 
-        function mockValidTemplates(scriptList){
-            fs.rmSync(appFolderName, {force: true, recursive: true})
-            fs.mkdirSync(appFolderName, {recursive: true})
+        function mockValidTemplates(appName, scriptList){
+            fs.rmSync(mockDataFolder+'/'+appName, {force: true, recursive: true})
+            fs.mkdirSync(mockDataFolder+'/'+appName, {recursive: true})
             for (const [key, value] of Object.entries(scriptList)){
-                fs.writeFileSync(appFolderName+key, value.act)
+                fs.writeFileSync(mockDataFolder+'/'+appName + '/' + key, value.act)
             }
         }
 
@@ -70,7 +68,7 @@ describe('Biz-A Apps CLI', ()=>{
             axios.post.mockResolvedValue({data: {success: true}, status: 200})
         }
 
-        beforeEach(()=>{
+        beforeAll(()=>{
             fs.rmSync(mockDataFolder, {recursive: true, force: true})
         })
 
@@ -79,7 +77,7 @@ describe('Biz-A Apps CLI', ()=>{
         })
 
         const stressTestCount = 10;
-        it.each(Array(stressTestCount).fill().map((v,i)=>i+1))(`shall compress and encrypt app scripts (stress test %p of ${stressTestCount})`, async ()=>{
+        it.each(Array(stressTestCount).fill().map((v,i)=>i+1))(`shall compress and encrypt app scripts (stress test %p of ${stressTestCount})`, async (testNo)=>{
             const mockScripts = {
                 'a.js' : {
                     act: 'get = function () {return {modelA: {}}}',
@@ -154,11 +152,12 @@ describe('Biz-A Apps CLI', ()=>{
                 }
             }
 
-            mockValidTemplates(mockScripts)
+            const appName = 'compressStressTest' + testNo
+            mockValidTemplates(appName, mockScripts)
             mockIssuerKeyResponse()
             const mockAESKey = Buffer.from('hAnHadaJXJaq/9fCFMNmjkrB61CBPXJid6vbtXgG8Ug=', 'base64')
 
-            await runCommand('add', '-s', 'https://a.b.c', '-p', '1205', '-i', '2', '-d', appFolderName)
+            await runCommand('add', '-s', 'https://a.b.c', '-p', '1205', '-i', '2', '-d', mockDataFolder + '/' + appName)
 
             expect(axios.get.mock.calls).toHaveLength(1)
             const getArgs = axios.get.mock.calls[0]
@@ -233,6 +232,8 @@ describe('Biz-A Apps CLI', ()=>{
 
             expect(logSpy.mock.calls[0][0]).toContain(`Finished packing ${Object.keys(mockScripts).length} files into "./upload/${appName.toLowerCase()}.tgz"`)
             expect(logSpy.mock.calls[1][0]).toContain(`Finished uploading "./upload/${appName.toLocaleLowerCase()}.tgz"`)
+
+            // fs.rmSync(mockDataFolder + '/' + appName, {recursive: true, force: true})
         })
 
 /*        it('Invalid script syntax', async ()=>{
@@ -290,57 +291,61 @@ describe('Biz-A Apps CLI', ()=>{
                 'Invalid script syntax',
                 {act: 'get = function () {return {modelA: {}}'}, // missing close closure at the end',
                 ()=>{
-                    expect(logSpy.mock.calls.length).toBe(1)
+                    expect(logSpy.mock.calls.length).toBe(5)
                     expect(logSpy.mock.calls[0][0]).toBe('===================\nA.JS\n===================')
+                    expect(logSpy.mock.calls[1][0]).toBe('Running script with VM') // node sandbox (VN) error as console.log
+                    expect(logSpy.mock.calls[2][0]).toStrictEqual('a.js:1:38: SyntaxError: Unexpected token: eof, expected: punc «}»')
+                    expect(logSpy.mock.calls[3][0]).toStrictEqual('Running script with Import function')
+                    expect(logSpy.mock.calls[4][0]).toStrictEqual('===================\nEOF A.JS\n===================')
 
                     expect(errorSpy.mock.calls.length).toBe(1)
-                    // expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js:1:38: SyntaxError: Unexpected token: eof, expected: punc «}»'})
-                    expect(errorSpy.mock.calls[0][0]).toStrictEqual('a.js:1:38: SyntaxError: Unexpected token: eof, expected: punc «}»')
+                    expect(errorSpy.mock.calls[0][0]).toBe('a.js : SyntaxError: Unexpected end of input')
                 }
             ],
             [
                 'Failed to compile script with node sandbox and ES6 Import',
                 {act: 'get = function () {return {modelA: {}}}\n modul.expor = get;\n'}, // wrong "module.export"
                 ()=>{
-                    expect(logSpy.mock.calls.length).toBe(5)
+                    expect(logSpy.mock.calls.length).toBe(6)
                     expect(logSpy.mock.calls[0][0]).toBe('===================\nA.JS\n===================')
-                    expect(logSpy.mock.calls[1][0]).toBe('Minify : \nget=function(){return{modelA:{}}};modul.expor=get;')
-                    expect(logSpy.mock.calls[2][0]).toBe('Running script with VM') // node sandbox (VN) error as console.log
+                    expect(logSpy.mock.calls[1][0]).toBe('Running script with VM') // node sandbox (VN) error as console.log
+                    expect(logSpy.mock.calls[2][0]).toBe('Minify : \nget=function(){return{modelA:{}}};modul.expor=get;')
                     expect(logSpy.mock.calls[3][0]).toBe("a.js : ReferenceError: modul is not defined")
                     expect(logSpy.mock.calls[4][0]).toBe('Running script with Import function')
+                    expect(logSpy.mock.calls[5][0]).toStrictEqual('===================\nEOF A.JS\n===================')
 
                     expect(errorSpy.mock.calls.length).toBe(1)
-                    // expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js : ReferenceError: modul is not defined'}) // ES6 import error
-                    expect(errorSpy.mock.calls[0][0]).toStrictEqual('a.js : ReferenceError: modul is not defined')// ES6 import error
+                    expect(errorSpy.mock.calls[0][0]).toStrictEqual('a.js : Error: Invalid data URI')// ES6 import error
                 }
             ],
             [
                 'Shall not allow empty script',
                 {act: 'get = function () {}'}, // empty script
                 ()=>{
-                    expect(logSpy.mock.calls.length).toBe(4)
+                    expect(logSpy.mock.calls.length).toBe(5)
                     expect(logSpy.mock.calls[0][0]).toBe('===================\nA.JS\n===================')
-                    expect(logSpy.mock.calls[1][0]).toBe('Minify : \nget=function(){};')
-                    expect(logSpy.mock.calls[2][0]).toBe('Running script with VM') // node sandbox (VN) error as console.log
+                    expect(logSpy.mock.calls[1][0]).toBe('Running script with VM') // node sandbox (VN) error as console.log
+                    expect(logSpy.mock.calls[2][0]).toBe('Minify : \nget=function(){};')
                     expect(logSpy.mock.calls[3][0]).toBe('Running script with Import function')
+                    expect(logSpy.mock.calls[4][0]).toStrictEqual('===================\nEOF A.JS\n===================')
 
                     expect(errorSpy.mock.calls.length).toBe(1)
-                    // expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js : Failed to compile template script.\nPlease make sure the script is correct and not returning empty result'})
                     expect(errorSpy.mock.calls[0][0]).toStrictEqual('a.js : Failed to compile template script.\nPlease make sure the script is correct and not returning empty result')
                 }
             ],
         ]
         it.each(errorHandlingTestCases)('%p', async (name, scripts, expectedFn)=>{
-            mockValidTemplates({'a.js' : scripts})
+            const appName = 'errorHandlingTest' + errorHandlingTestCases.findIndex(testCase => testCase[0] === name)
+            mockValidTemplates(appName, {'a.js' : scripts})
             mockIssuerKeyResponse()
-            await runCommand('add', '-s', 'https://a.b.c', '-p', '1205', '-i', '2', '-d', appFolderName, "-v")
+            await runCommand('add', '-s', 'https://a.b.c', '-p', '1205', '-i', '2', '-d', mockDataFolder + '/' + appName, "-v")
             expectedFn()
         })
 
-        it('Shall not allow empty app', async ()=>{
-            mockValidTemplates({})
+        it('Shall not allow app without script template', async ()=>{
+            mockValidTemplates(expect.getState().currentTestName, {})
             mockIssuerKeyResponse()
-            await runCommand('add', '-s', 'https://a.b.c', '-p', '1205', '-i', '2', '-d', appFolderName, "-v")
+            await runCommand('add', '-s', 'https://a.b.c', '-p', '1205', '-i', '2', '-d', mockDataFolder + '/' + expect.getState().currentTestName, "-v")
 
             expect(logSpy.mock.calls.length).toBe(0)
 
@@ -350,7 +355,7 @@ describe('Biz-A Apps CLI', ()=>{
 
         it('Shall recommend command', async ()=>{
             const exitSpy = jest.spyOn(process, 'exit').mockImplementation(()=>{})
-            await runCommand('Add', '-s', 'https://a.b.c', '-p', '1205', '-i', '2', '-d', appFolderName, "-v")
+            await runCommand('Add', '-s', 'https://a.b.c', '-p', '1205', '-i', '2', '-d', mockDataFolder + '/NotExistFolder', "-v")
             expect(logSpy.mock.calls.length).toBe(0)
             expect(exitSpy).toHaveBeenCalledWith(1) // exit code = 1
             expect(errorSpy.mock.calls[errorSpy.mock.calls.length-1][0]).toBe('Did you mean add?')
@@ -419,4 +424,63 @@ describe('Biz-A Apps CLI', ()=>{
         })
     })
 
+    it('Shall have options', async ()=>{
+        jest.spyOn(process, 'exit').mockImplementation()
+        const appModule = await import('../bin/app.js')
+        expect(appModule.options).toStrictEqual({
+            "s" : {
+                alias: "server",
+                describe: `API or Server URL (ex: ${env.BIZA_SERVER_LINK} or http://192.168.1.1 or https://finaapi.imamatek.com)`,
+                type: "string",
+                demandOption: true,
+                default: 'http://localhost'
+            },
+            "i" : {
+                alias: "dbIndex",
+                default: 2,
+                describe: "database index",
+                type: "number",
+                demandOption: false
+            },
+            "sub": {
+                alias: "subdomain",
+                describe: "Subdomain",
+                type: "string",
+                demandOption: false
+            },
+            "p": {
+                alias: "apiPort",
+                default : 212,
+                describe: "FINA API Port",
+                type: "number",
+                demandOption: false,
+            }
+        })
+        expect(appModule.addCommandOptions).toStrictEqual({
+            'd': {
+                alias: "workingDir",
+                describe: "Path to templates directory",
+                type: "string",
+                demandOption: false,
+                default: process.cwd(),
+            },
+            'v': {
+                alias: "verbose",
+                describe: "Print info to console",
+                type: "boolean",
+                demandOption: false,
+                default: false,
+            }
+        })
+        expect(appModule.removeCommandOptions).toStrictEqual({
+            'n': {
+                alias: "appName",
+                describe: "Application name",
+                type: "string",
+                demandOption: true,
+                default: ""
+            }
+        })
+    })
+
 })

package/tests/debug.log

@@ -0,0 +1,4 @@
+[0605/214850.720:ERROR:registration_protocol_win.cc(108)] CreateFile: The system cannot find the file specified. (0x2)
+[0605/214852.995:ERROR:registration_protocol_win.cc(108)] CreateFile: The system cannot find the file specified. (0x2)
+[0605/220241.422:ERROR:registration_protocol_win.cc(108)] CreateFile: The system cannot find the file specified. (0x2)
+[0605/220243.465:ERROR:registration_protocol_win.cc(108)] CreateFile: The system cannot find the file specified. (0x2)

package/tests/deployment.test.js

@@ -0,0 +1,351 @@
+import { Server as ioServer } from 'socket.io';
+import { getAppData, onScriptChangeFromVsCode, onScriptChangeFromHubServer} from '../bin/deployEvent.js'
+import { io as ioClient, Socket, Manager } from "socket.io-client";
+import { expect, jest } from '@jest/globals';
+import axios from "axios";
+import { directHubEvent, getSocketCORSOrigin, CLIENT_ROOM } from '../bin/directHubEvent.js'
+import { createDecipheriv } from 'node:crypto'
+import { hubEvent } from '../bin/hubEvent.js';
+
+describe('Deployment', () => {
+
+    const hostname = '127.0.0.1'
+    const port = 7778
+    const dbindex = 2
+    const subdomain = 'deploy'
+
+    const toPromise = (cb) => new Promise((resolve, reject) => {
+        cb(resolve)
+        setTimeout(() => reject(new Error('timeout')), 1000)
+    })
+
+    function freeSocketClient(sock){
+        if (sock) {
+            if (sock.connected) {
+                sock.off()
+                sock.disconnect()
+            }
+            sock.destroy()
+            sock = undefined
+        }
+    }
+
+    beforeEach(()=>{
+        jest.restoreAllMocks()
+    })
+
+    afterEach(()=>{
+        jest.restoreAllMocks()
+    })
+
+    it('shall allow origins', ()=>{
+        expect(getSocketCORSOrigin(hostname)).toStrictEqual([
+            'https://biz-a.id',
+            'https://test.biz-a.id',
+            /\.biz-a\.id$/,
+            'vscode-file://vscode-app',
+            /\.vscode-cdn\.net$/,
+            `http://${hostname}:4200`,
+            'http://localhost:4200'
+        ])
+    })
+
+    it('shall get app list from database', async ()=>{
+        // Failed : check for error message
+        const requestSpy = jest.spyOn(axios, 'request').mockResolvedValueOnce({
+            status: 200,
+            statusText: 'Success',
+            data: {"recordsTotal": 2}
+        })
+        let result = await getAppData({hostname, port, dbindex, secure: true})
+        expect(requestSpy).toHaveBeenCalledWith({
+            timeout: 30*1000,
+            baseURL: `https://${hostname}:${port}`,
+            url: 'fina/rest/TOrmMethod/%22list%22',
+            method: "POST",
+            "data" : {"dbIndex":2, "object":{"columns":[
+                {"title":"app","data":"SYS$APPS.APPNAME"},
+                {"title":"metadata","data":"SYS$APPS.METADATA"}
+            ]}}
+        })
+
+        expect(result.error).toBe('"undefined" is not valid JSON')
+        expect(result.apps).toStrictEqual([])
+
+        // Success : check for apps data
+        const expectedAppData = [
+            {'SYS$APPS.APPNAME': 'firstApp', "SYS$APPS.METADATA": {acquirer: {data: '', signature: ''}, menu: ''}},
+            {'SYS$APPS.APPNAME': 'secondApp', "SYS$APPS.METADATA": {acquirer: {data: '', signature: ''}, menu: ''}},
+        ]
+
+        requestSpy.mockResolvedValueOnce({
+            status: 200,
+            statusText: 'Success',
+            data: {
+                "recordsTotal": 2,
+                data: JSON.stringify(expectedAppData)
+            }
+        })
+        result = await getAppData({hostname, port, dbindex})
+        expect(result.error).toBe(null)
+        expect(result.apps).toStrictEqual(expectedAppData)
+    })
+
+    it('shall log connect and disconnect', async ()=>{
+        const logSpy = jest.spyOn(console, 'log').mockImplementation()
+        let vsCodeToCLISock
+        let serverSideSock
+        const socketServer = new ioServer(1234)// mocking of CLI socket server
+        directHubEvent(socketServer, {subdomain, hostname, port: 1234, secure: false, dbindex, server: 'mockServer'})
+        try {
+            vsCodeToCLISock = await toPromise((resolve)=>{
+                const sock = ioClient(`http://${hostname}:${1234}`, {reconnection: false, query: {isDeploy: true}}).on('connect', async ()=>{
+                    serverSideSock = (await socketServer.fetchSockets()).find(s=>s.id==sock.id)
+                    resolve(sock)
+                })
+            })
+            expect(logSpy).toHaveBeenCalledTimes(1)
+            expect(logSpy).toHaveBeenCalledWith('<Deployer> ' + vsCodeToCLISock.id, 'connected')
+
+            logSpy.mockReset()
+            serverSideSock.disconnect()
+            expect(logSpy).toHaveBeenCalledTimes(1)
+            expect(logSpy).toHaveBeenCalledWith('<Deployer> ' + vsCodeToCLISock.id, 'disconnected. Reason : server namespace disconnect')
+        }
+        finally {
+            socketServer.close()
+            freeSocketClient(vsCodeToCLISock)
+            logSpy.mockRestore()
+        }
+    })
+
+    describe('from vs code', ()=>{
+
+        let cliSocketServer // mocking of CLI socket server
+
+        beforeAll(()=>{
+            cliSocketServer = new ioServer(port)// mocking of CLI socket server
+            directHubEvent(cliSocketServer, {subdomain, hostname, port, secure: false, dbindex, server: 'mockServer'})
+        })
+
+        afterAll(async ()=>{
+            if (cliSocketServer) {
+                (await cliSocketServer.of('').sockets).forEach((sock)=>{sock.removeAllListeners()})
+                await cliSocketServer.close()
+            }
+        })
+
+        it('shall have "appList" listener', async ()=>{
+            let vsCodeToCLISock
+            try {
+                jest.spyOn(console, 'log').mockImplementation()
+                jest.spyOn(axios, 'request').mockResolvedValueOnce({
+                    status: 200,
+                    statusText: 'Success',
+                    data: {
+                        "recordsTotal": 2,
+                        data: JSON.stringify([
+                            {'SYS$APPS.APPNAME': 'firstApp', "SYS$APPS.METADATA": {acquirer: {data: '', signature: ''}, menu: ''}},
+                            {'SYS$APPS.APPNAME': 'secondApp', "SYS$APPS.METADATA": {acquirer: {data: '', signature: ''}, menu: ''}},
+                        ])
+                    }
+                })
+
+                vsCodeToCLISock = await toPromise((resolve)=>{
+                    const sock = ioClient(`http://${hostname}:${port}`, {query: {isDeploy:true}}).on('connect', ()=>{resolve(sock)})
+                })
+
+                const [error, apps] = await toPromise(resolve => {vsCodeToCLISock.emit('appList', {}, (err, data)=>{resolve([err, data])})});
+                expect(error).toBe(null);
+                expect(apps).toStrictEqual(['firstApp', 'secondApp']);
+            }
+            finally {
+                freeSocketClient(vsCodeToCLISock)
+            }
+        })
+
+        it('shall prepare deploy script', async ()=>{
+            let vsCodeToCLISock
+            let serverSideSock
+            let emitSpy
+            let broadcastSpy
+            let result
+            try {
+                jest.spyOn(console, 'log').mockImplementation()
+
+                vsCodeToCLISock = await toPromise((resolve)=>{
+                    const sock = ioClient(`http://${hostname}:${port}`).on('connect', async ()=>{
+                        serverSideSock = (await cliSocketServer.fetchSockets()).find((s)=>s.id==sock.id)
+
+                        // if using socket.broadcast.emit()
+                        // const mockedBroadcast = serverSideSock.newBroadcastOperator()
+                        // broadcastSpy = jest.fn().mockReturnValue(mockedBroadcast) // mock it to return same broadcast object
+                        // serverSideSock.newBroadcastOperator = broadcastSpy
+
+                        // if using socket.to(roomName).emit()
+                        const mockedBroadcast = serverSideSock.to(CLIENT_ROOM)
+                        broadcastSpy = jest.spyOn(serverSideSock, 'to').mockReturnValue(mockedBroadcast) // mock it to return same broadcast object
+
+                        emitSpy = jest.spyOn(mockedBroadcast, 'emit').mockImplementation()
+
+                        resolve(sock)
+                    })
+                })
+                const mockAESKey = Buffer.from('hAnHadaJXJaq/9fCFMNmjkrB61CBPXJid6vbtXgG8Ug=', 'base64')
+                const requestSpy = jest.spyOn(axios, 'request').mockResolvedValue({status: 200, statusText: 'Success', data: mockAESKey})
+                const deployData = {appName: 'app', fileName: 'filename.js', script: "put script here for testing"}
+
+                // Failed of empty script
+                emitSpy.mockReset()
+                result = await onScriptChangeFromVsCode(
+                    serverSideSock,
+                    'https://mock.server.com',
+                    [{'SYS$APPS.APPNAME': 'app', "SYS$APPS.METADATA": JSON.stringify({acquirer: {data: '', signature: ''}, menu: ''})}],
+                    {...deployData, ...{script: ""}}
+                )
+                expect(result.error).toBe("filename.js : Failed to compile template script.\nPlease make sure the script is correct and not returning empty result")
+                expect(result.script).toBeUndefined()
+                expect(requestSpy).not.toHaveBeenCalled()
+                expect(emitSpy).not.toHaveBeenCalled()
+
+
+                // Failed of invalid script syntax
+                emitSpy.mockReset()
+                result = await onScriptChangeFromVsCode(
+                    serverSideSock,
+                    'https://mock.server.com',
+                    [{'SYS$APPS.APPNAME': 'app', "SYS$APPS.METADATA": JSON.stringify({acquirer: {data: '', signature: ''}, menu: ''})}],
+                    {...deployData, ...{script: "invalidScript"}}
+                )
+                expect(result.error).toBe("filename.js : ReferenceError: invalidScript is not defined")
+                expect(result.script).toBeUndefined()
+                expect(requestSpy).not.toHaveBeenCalled()
+                expect(emitSpy).not.toHaveBeenCalled()
+
+
+                // Success : prepare script for BizA Client
+                emitSpy.mockReset()
+                const validScript = "get = function () {return {tableName: ''}}"
+                result = await onScriptChangeFromVsCode(
+                    serverSideSock,
+                    'https://mock.server.com',
+                    [{'SYS$APPS.APPNAME': 'app', "SYS$APPS.METADATA": JSON.stringify({acquirer: {data: '', signature: ''}, menu: ''})}],
+                    {...deployData, ...{script: validScript}}
+                )
+                expect(requestSpy).toHaveBeenCalledWith({
+                    timeout: 30*1000,
+                    baseURL: 'https://mock.server.com',
+                    url: 'api/acquirerKey',
+                    method: "POST",
+                    data : {"metadata": JSON.stringify({data: '', signature: ''})}
+                })
+                expect(result.error).toBe(null)
+
+                const cipherText = Buffer.from(result.script, 'base64')
+                const decipher = createDecipheriv('aes-256-cbc', mockAESKey, cipherText.subarray(0, 16))
+                const decryptedScript = Buffer.concat([decipher.update(cipherText.subarray(16)), decipher.final()]).toString()
+                expect(decryptedScript).toBe('{"tableName":""}')
+
+                expect(emitSpy).toHaveBeenCalledTimes(1)
+                expect(emitSpy).toHaveBeenCalledWith('scriptDeploy', {appName: 'app', fileName: 'filename.js', script: result.script})
+            }
+            finally {
+                freeSocketClient(vsCodeToCLISock)
+                if (broadcastSpy) broadcastSpy.mockRestore()
+            }
+        })
+
+        it('shall have "scriptChange" listener', async ()=>{
+            let vsCodeToCLISock;
+            try {
+                jest.spyOn(console, 'log').mockImplementation()
+                vsCodeToCLISock = await toPromise((resolve)=>{
+                    const sock = ioClient(`http://${hostname}:${port}`, {query: {isDeploy:true}}).on('connect', ()=>{resolve(sock)})
+                });
+
+                const requestSpy = jest.spyOn(axios, 'request');
+                requestSpy.mockResolvedValueOnce({
+                    status: 200,
+                    statusText: 'Success',
+                    data: {
+                        "recordsTotal": 2,
+                        data: JSON.stringify([
+                            {'SYS$APPS.APPNAME': 'firstApp', "SYS$APPS.METADATA": {acquirer: {data: '', signature: ''}, menu: ''}},
+                            {'SYS$APPS.APPNAME': 'secondApp', "SYS$APPS.METADATA": {acquirer: {data: '', signature: ''}, menu: ''}},
+                        ])
+                    }
+                });
+
+                const [error, script] = await toPromise(resolve => {vsCodeToCLISock.emit('scriptChange', {appName: 'firstApp', fileName: 'filename.js', script: ""}, (err, data)=>{resolve([err, data])})});
+                expect(error).toBe("filename.js : Failed to compile template script.\nPlease make sure the script is correct and not returning empty result");
+                expect(script).toBeNull();
+            }
+            finally {
+                freeSocketClient(vsCodeToCLISock);
+            };
+        });
+
+    });
+
+    describe('from Hub Server', ()=>{
+
+        it('shall prepare deploy script', async ()=>{
+            let result;
+
+            const mockAESKey = Buffer.from('hAnHadaJXJaq/9fCFMNmjkrB61CBPXJid6vbtXgG8Ug=', 'base64')
+            const requestSpy = jest.spyOn(axios, 'request').mockResolvedValue({status: 200, statusText: 'Success', data: mockAESKey})
+            const deployData = {appName: 'app', fileName: 'filename.js', script: "put script here for testing"}
+
+            // Failed of empty script
+            result = await onScriptChangeFromHubServer(
+                'https://mock.server.com',
+                [{'SYS$APPS.APPNAME': 'app', "SYS$APPS.METADATA": JSON.stringify({acquirer: {data: '', signature: ''}, menu: ''})}],
+                {...deployData, ...{script: ""}}
+            )
+            expect(result.error).toBe("filename.js : Failed to compile template script.\nPlease make sure the script is correct and not returning empty result")
+            expect(result.script).toBeUndefined()
+            expect(requestSpy).not.toHaveBeenCalled()
+
+
+            // Failed of invalid script syntax
+            result = await onScriptChangeFromHubServer(
+                'https://mock.server.com',
+                [{'SYS$APPS.APPNAME': 'app', "SYS$APPS.METADATA": JSON.stringify({acquirer: {data: '', signature: ''}, menu: ''})}],
+                {...deployData, ...{script: "invalidScript"}}
+            )
+            expect(result.error).toBe("filename.js : ReferenceError: invalidScript is not defined")
+            expect(result.script).toBeUndefined()
+            expect(requestSpy).not.toHaveBeenCalled()
+
+
+            // Success : prepare script for BizA Client
+            const validScript = "get = function () {return {tableName: ''}}"
+            result = await onScriptChangeFromHubServer(
+                'https://mock.server.com',
+                [{'SYS$APPS.APPNAME': 'app', "SYS$APPS.METADATA": JSON.stringify({acquirer: {data: '', signature: ''}, menu: ''})}],
+                {...deployData, ...{script: validScript}}
+            )
+            expect(requestSpy).toHaveBeenCalledWith({
+                timeout: 30*1000,
+                baseURL: 'https://mock.server.com',
+                url: 'api/acquirerKey',
+                method: "POST",
+                data : {"metadata": JSON.stringify({data: '', signature: ''})}
+            })
+            expect(result.error).toBe(null)
+
+            const cipherText = Buffer.from(result.script, 'base64')
+            const decipher = createDecipheriv('aes-256-cbc', mockAESKey, cipherText.subarray(0, 16))
+            const decryptedScript = Buffer.concat([decipher.update(cipherText.subarray(16)), decipher.final()]).toString()
+            expect(decryptedScript).toBe('{"tableName":""}')
+        });
+
+        it('shall have "scriptChange Listener"', ()=>{
+            const sock = new Socket(new Manager('', {autoConnect: false}), '');
+            hubEvent(sock, {subdomain, hostname, port, secure: false, dbindex, server: 'mockServer'}, ()=>{});
+            expect(sock.listeners('scriptChange').length).toBe(1);
+        });
+
+    });
+
+})

package/tests/hub.test.js

@@ -236,13 +236,14 @@ describe('Hub event tests', () => {
             cliSocketServer = new ioServer(9999)// mocking of CLI socket server
             directHubEvent(cliSocketServer, {subdomain, hostname: apiAddress, port, secure: false})
 
-            clientToCliSocket = ioClient('http://localhost:9999')
+            clientToCliSocket = ioClient('http://localhost:9999', {query: {isClient:true}})
         })
 
-        afterAll(()=>{
+        afterAll(async ()=>{
             freeSocketClient(clientToCliSocket)
             if (cliSocketServer) {
-                cliSocketServer.close()
+                await cliSocketServer.of('').sockets.forEach((sock)=>sock.removeAllListeners())
+                await cliSocketServer.close()
             }
         })
 
@@ -259,7 +260,7 @@ describe('Hub event tests', () => {
                 clientToCliSocket.emit(
                     'apiRequest'
                     , {subDomain: subdomain, method: 'POST', path: '/test', headers: {'req-header': 'aa'}, body: 'body of request', responseType: 'json'}
-                    , (res, err)=>{resolve([res, err])}
+                    , (err, res)=>{resolve([err, res])}
                 )
             })
 
@@ -300,7 +301,7 @@ describe('Hub event tests', () => {
                 clientToCliSocket.emit(
                     'apiRequest'
                     , {subDomain: subdomain, method: 'POST', path: '/test', headers: {'req-header': 'aa'}, body: 'body of request', responseType: 'arraybuffer'}
-                    , (res, err)=>{resolve([res, err])}
+                    , (err, res)=>{resolve([err, res])}
                 )
             })
 
@@ -326,7 +327,7 @@ describe('Hub event tests', () => {
                 clientToCliSocket.emit(
                     'apiRequest'
                     , {subDomain: 'wrong subdomain', method: 'POST', path: '/test', headers: {'req-header': 'aa'}, body: 'body of request'}
-                    , (res, err)=>{resolve([res, err])}
+                    , (err, res)=>{resolve([err, res])}
                 )
             })
 
@@ -376,7 +377,7 @@ describe('Hub event tests', () => {
                     hubToCLISocket.emit(
                         'apiRequest'
                         , {subDomain: subdomain, method: 'POST', path: '/test', headers: {'req-header': 'aa'}, body: reqData, responseType: 'json'}
-                        , (res, err)=>{resolve([res, err])}
+                        , (err, res)=>{resolve([err, res])}
                     )
                 })
                 return {error, response}