eitri-cli 1.0.2

package/test/service/TrackingService.test.js

@@ -0,0 +1,105 @@
+/* eslint-disable no-undef */
+const nock = require('nock')
+const path = require('path')
+const TrackingService = require('../../src/service/TrackingService')
+const { v4: uuidv4 } = require('uuid')
+
+describe('TrackingService', () => {
+    let workspace, blindGuardian, trackingService
+
+    beforeEach(() => {
+        nock.cleanAll()
+        folder2watch = path.resolve(__dirname, '..', '_fixtures')
+
+        workspace = require('../../src/service/Workspace').workspace
+        // workspace.setFolder2Watch(folder2watch)
+        workspace.setServerUrl('https://dev.eitri.calindra.com.br')
+
+        blindGuardian = workspace.blindGuardian
+        blindGuardian.getToken = async () => {
+            return { accessToken: 'xpto' }
+        }
+        trackingService = new TrackingService(blindGuardian)
+    })
+
+    it('testa envio de error', async () => {
+        let params = []
+        nock('https://www.google-analytics.com')
+            .get('/collect')
+            .query(q => {
+                params.push(q)
+                return true
+            })
+            .reply(200, '')
+            .persist()
+        await trackingService.sendError(new Error('Meu erro'))
+        expect(params[0].v).toBe('1')
+        expect(params[0].exd).toContain('Meu erro')
+        expect(params[0].exd).toContain(path.basename(__filename))
+    })
+
+    it('testa envio de save', async () => {
+        let params = []
+        nock('https://www.google-analytics.com')
+            .get('/collect')
+            .query(q => {
+                params.push(q)
+                return true
+            })
+            .reply(200, '')
+            .persist()
+        let event = {
+            superClientVersion: '1.2.2',
+            componentsVersion: '1.4.5',
+            miniAppSlug: 'algum-slug',
+            miniAppVersion: '0.1.0',
+            timeMs: 3000,
+        }
+        await trackingService.sendSave(event)
+        expect(params[0].v).toBe('1')
+    })
+
+    it('testa envio de publish', async () => {
+        let params = []
+        nock('https://www.google-analytics.com')
+            .get('/collect')
+            .query(q => {
+                params.push(q)
+                return true
+            })
+            .reply(200, '')
+            .persist()
+        trackingService._clientId = uuidv4()
+        let event = {
+            superClientVersion: '1.2.2',
+            componentsVersion: '1.4.5',
+            miniAppSlug: 'algum-slug',
+            miniAppVersion: '0.1.0',
+            timeMs: 3000,
+        }
+        await trackingService.sendPublish(event)
+        expect(params[0].v).toBe('1')
+    })
+
+    it('testa envio de build', async () => {
+        let params = []
+        nock('https://www.google-analytics.com')
+            .get('/collect')
+            .query(q => {
+                params.push(q)
+                return true
+            })
+            .reply(200, '')
+            .persist()
+        trackingService._clientId = uuidv4()
+        let event = {
+            superClientVersion: '1.2.2',
+            componentsVersion: '1.4.5',
+            miniAppSlug: 'algum-slug',
+            miniAppVersion: '0.1.0',
+            timeMs: 3000,
+        }
+        await trackingService.sendBuild(event)
+        expect(params[0].v).toBe('1')
+    })
+})

package/test/service/UserAmeConf.test.js

@@ -0,0 +1,47 @@
+/* eslint-disable no-undef */
+
+
+const BlindGuardian = require('../../src/service/BlindGuardian')
+
+describe('UserAmeConf', () => {
+    let blindGuardian
+
+    beforeEach(() => {
+        blindGuardian = new BlindGuardian()
+    })
+
+    it('deve ler arquivo de configuracao do [env].conf na versão antiga', () => {
+        blindGuardian.readConf = () => {
+            return {
+                devUser: 'foo',
+                devKey: 'bar',
+            }
+        }
+
+        let credential = blindGuardian.readClientCredentials()
+        expect(credential.client_id).toEqual('foo')
+        expect(credential.client_secret).toEqual('bar')
+    })
+
+    it('deve ler arquivo de configuracao do [env].conf com configuracões distintas para diversos ambientes', () => {
+
+        blindGuardian.readConf = () => {
+            return {
+                'test': {
+                    'devUser': 'foo-test',
+                    'devKey': 'bar-test'
+                },
+                'local': {
+                    'devUser': 'foo-local',
+                    'devKey': 'bar-local'
+                }
+            }
+        }
+
+        let credential = blindGuardian.readClientCredentials()
+        expect(credential.client_id).toEqual('foo-test')
+        expect(credential.client_secret).toEqual('bar-test')
+    })
+
+
+})

package/test/service/WoodCoffeeFactory.test.js

@@ -0,0 +1,148 @@
+/* eslint-disable no-undef */
+const fs = require('fs')
+const path = require('path')
+
+const WoodCoffeeFactory = require('../../src/service/factories/WoodCoffeeFactory')
+const { after } = require('../../node_modules/cheerio/lib/api/manipulation')
+const { getTarget } = require('../_fixtures/factory')
+const child_process = require('child_process')
+
+describe('WoodCoffeeFactory', () => {
+    let woodCoffeeFactory
+    beforeEach(() => {
+        woodCoffeeFactory = new WoodCoffeeFactory()
+    })
+    describe('.validateFileName(projectName)', () => {
+        it('valida o nome do projeto contra caracteres estranhos', async () => {
+            let valid = woodCoffeeFactory.validateFileName('../lalala')
+            expect(valid).toBe(false)
+        })
+        it('valida pasta aux da morte do windows', async () => {
+            let valid = woodCoffeeFactory.validateFileName('aux')
+            expect(valid).toBe(false)
+        })
+        it('valida um nome ok', async () => {
+            let valid = woodCoffeeFactory.validateFileName('meu-projeto')
+            expect(valid).toBe(true)
+        })
+    })
+    describe('.writeAmeConf(project, conf, libsName)', () => {
+        it('valida se o miniapp.conf.js foi criado corretamente', async () => {
+            let conf = {}
+            conf['version'] = '0.1.0'
+
+            let project = {}
+            project['projectPath'] = path.resolve(__dirname, '..', '_fixtures', 'woodcoffee')
+
+            jest.spyOn(woodCoffeeFactory, '_getLatestLibVersion').mockReturnValueOnce('0.0.1')
+
+            let libsName = ['test_lib_1']
+            await woodCoffeeFactory.writeAmeConf(project, conf, libsName)
+
+            let expectedConf = {
+                version: '0.1.0'
+            }
+
+            let expected = `module.exports = ${JSON.stringify(expectedConf, null, 4)}`
+
+            const data = fs.readFileSync(path.join(project.projectPath, 'miniapp.conf.js'), {
+                encoding: 'utf-8',
+                flag: 'r'
+            })
+
+            expect(data).toBe(expected)
+        })
+    })
+
+    describe('.template(projectName, templateUrl, projectPath)', () => {
+        const COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER = '###COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER###'
+        const SUPER_APP_CLIENT_VERSION_HIGHLIGHTER = '###SUPER_APP_CLIENT_VERSION_HIGHLIGHTER###'
+        const templateFileName = 'AboutTemplate.jsx'
+        const aboutTemplatePath = path.join(path.dirname(__dirname), '_fixtures', 'src', 'views', templateFileName)
+        const destinyFolder = path.join(path.dirname(__dirname), '_fixtures', 'src', 'views', 'About.jsx')
+        let target;
+        beforeEach(() => {
+            target = getTarget()
+            fs.copyFile(aboutTemplatePath, destinyFolder, (error) => {
+
+                if (error) {
+                    console.error(`O arquivo [${templateFileName}] não foi copiado para a pasta de destino [${destinyFolder}] \n`, error)
+                    return
+                }
+            })
+        })
+
+        afterEach(() => {
+            fs.unlink(destinyFolder, (error) => {
+                if (error) {
+                    console.error(`O arquivo [${templateFileName}] não foi deletado do destino [${destinyFolder}] \n`, error)
+                    return
+                }
+            })
+        })
+
+        it('deve verificar se as versões das bibliotecas foram atualizadas', async () => {
+            const file = await getFile()
+            expect(file.includes(COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER) && file.includes(SUPER_APP_CLIENT_VERSION_HIGHLIGHTER)).toBeTruthy()
+            const newConf = {
+                'eitri-app-client': '2.26.0',
+                'eitri-app-components': '2.26.0'
+            }
+            await woodCoffeeFactory.updateAboutJSXFile(destinyFolder, newConf)
+
+            const updatedFile = await getFile()
+            expect(updatedFile.includes('2.26.0') && updatedFile.includes('2.26.0')).toBeTruthy()
+        })
+        
+        it('deve lançar um erro quando o About.jsx for baixado sem os marcadores', async () => {
+            await updateFile()
+            try {
+                const result = await woodCoffeeFactory.checkAboutJsx(destinyFolder)
+                expect(result).toBe('Caiu aqui tá errado!')
+            } catch (error) {
+                expect(error.message).toBe('Faltam placeholders para exibicao da versao do components e client')
+
+            }
+        })
+
+        it('deve usar o arquivo de template ao invés do baixado no github', async () => {
+            await updateFile()
+            jest.spyOn(woodCoffeeFactory, 'downloadFromGithub').mockResolvedValueOnce(new Promise(resolve => resolve()))
+            jest.spyOn(woodCoffeeFactory, '_getLatestLibVersion').mockReturnValueOnce(() => '2.26.0')
+            jest.spyOn(child_process, 'execSync').mockReturnValue("2.26.0")
+            const projectPath = path.join(path.dirname(__dirname), '_fixtures')
+            await woodCoffeeFactory.template('woodcoffee', 'https://template-url', projectPath, target)
+            const updatedFile = await getFile()
+            expect(updatedFile.includes('2.26.0') && updatedFile.includes('2.26.0')).toBeTruthy()
+        })
+
+        async function updateFile() {
+            const contents = await getFile()
+            return new Promise((resolve, reject) => {
+                const replaced = contents
+                    .replace(COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER, '2.0.0')
+                    .replace(SUPER_APP_CLIENT_VERSION_HIGHLIGHTER, '2.8.1')
+                fs.writeFile(destinyFolder, replaced, 'utf-8', function (err) {
+                    if (err) {
+                        console.log(err)
+                        reject()
+                    }
+                    resolve()
+                })
+            })
+        }
+
+        function getFile() {
+            return new Promise((resolve, reject) => {
+                fs.readFile(destinyFolder, 'utf-8', function (err, contents) {
+                    if (err) {
+                        console.log(err)
+                        reject(err)
+                    }
+                    resolve(contents)
+                })
+
+            })
+        }
+    })
+})

package/test/service/Workspace.test.js

@@ -0,0 +1,364 @@
+/* eslint-disable no-undef */
+
+const nock = require('nock')
+const path = require('path')
+const url = require('url')
+
+describe('Workspace', () => {
+    let workspace, folder2watch
+    beforeEach(() => {
+        nock.cleanAll()
+        folder2watch = path.resolve(__dirname, '..', '_fixtures')
+
+        workspace = require('../../src/service/Workspace').workspace
+        workspace.setFolder2Watch(folder2watch)
+        workspace.setServerUrl('https://dev.eitri.calindra.com.br')
+        workspace.setMiniConf({ version: '0.1.0' })
+        workspace.blindGuardian.getToken = async () => {
+            return { accessToken: 'xpto' }
+        }
+    })
+
+    afterEach(() => {
+        nock.cleanAll()
+    })
+
+    describe('.upsert(filePath)', () => {
+        it('envia o nome do arquivo para o servidor relativo a pasta do projeto local', (done) => {
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/workspace/fileupload', (body) => {
+                    let m = body.match(/\s+\/src\/Home\.js/)
+                    expect(m).not.toBeNull()
+                    done()
+                    return true
+                })
+                .reply(200, {})
+            let filePath = path.resolve(folder2watch, 'src', 'Home.js')
+            workspace.upsert(filePath)
+        })
+        it('envia o arquivo para o servidor', (done) => {
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/workspace/fileupload', (body) => {
+                    let m = body.match(/name="file"; filename="Home\.js"/)
+                    expect(m).not.toBeNull()
+                    done()
+                    return true
+                })
+                .reply(200, {})
+            let filePath = path.resolve(folder2watch, 'src', 'Home.js')
+            workspace.upsert(filePath)
+        })
+        it('envia em sequencia', (done) => {
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/workspace/fileupload')
+                .delayBody(1000)
+                .reply(200, { request: 1 })
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/workspace/fileupload')
+                .delayBody(100)
+                .reply(200, { request: 2 })
+            let filePath = path.resolve(folder2watch, 'src', 'Home.js')
+            let a = workspace.upsert(filePath)
+            let filePath2 = path.resolve(folder2watch, 'src', 'Home2.js')
+            let b = workspace.upsert(filePath2)
+            Promise.all([a, b])
+                .then(() => {
+                    done()
+                })
+                .catch(done)
+        })
+
+        it('deve enviar de forma concorrente', async (done) => {
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/workspace/fileupload')
+                .delayBody(1000)
+                .reply(200, { request: 1 })
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/workspace/fileupload')
+                .delayBody(100)
+                .reply(200, { request: 2 })
+            let filePath = path.resolve(folder2watch, 'src', 'Home.js')
+            let filePath2 = path.resolve(folder2watch, 'src', 'Home2.js')
+            const data = await workspace.upsert([filePath, filePath2], {}, true)
+            
+            data.forEach(result => {
+                expect(result.time).toBeTruthy()
+                expect(result.filePath).toBeTruthy()
+                expect(result.relativePath).toBeTruthy()
+            })
+            done()
+        })
+
+        it('deve retornar error se o fileName conter carácteres inválidos quando o arquivo for enviado sequencialmente', async () => {
+            let filePath = path.resolve(folder2watch, 'src', 'Homé.js')
+            const data = await  workspace.upsert(filePath, {})
+            expect(data.message).toBe(' - No nome do arquivo possui um ou mais caracteres não permitidos: Homé.js')
+        })
+
+        it('deve retornar error se o fileName conter carácteres inválidos quando o arquivo for enviado concorrentemente', async () => {
+            let filePath = path.resolve(folder2watch, 'src', 'Homé.js')
+            const data = await  workspace.upsert([filePath], {}, true)
+            expect(data.message).toBe(' - No nome do arquivo possui um ou mais caracteres não permitidos: Homé.js')
+        })
+    }, 10000)
+
+    describe('.delete(filePath)', () => {
+        it('pede para o servidor apagar o arquivo', async () => {
+            let scope = nock('https://dev.eitri.calindra.com.br')
+                .delete(/\/workspace\/fileupload.*/)
+                .reply(200, {})
+            let filePath = path.resolve(folder2watch, 'src', 'Home.js')
+            await workspace.delete(filePath)
+            expect(scope.isDone()).toBe(true)
+        })
+    })
+
+    describe('.listFilesInCorrectOrder()', () => {
+        it('concatena os componentes', async () => {
+            workspace.folder2watch = path.resolve(
+                __dirname,
+                '..',
+                '_fixtures',
+                'src'
+            )
+            let files = await workspace.listFilesInCorrectOrder()
+            let names = files.map((fileName) => path.basename(fileName))
+            expect(names.slice(0, 4)).toEqual([
+                'TagC.jsx',
+                'TagB.jsx',
+                'TagA.jsx',
+                'TagD.jsx',
+            ])
+        })
+    })
+
+    describe('.getWorkspaceURL()', () => {
+        beforeEach(() => {
+            workspace.userEmail = 'dev@calindra.com.br'
+            workspace.target = {
+                bootstrapBaseUrl: 'http://minhaconta.base.url'
+            }
+            workspace.folder2watch = path.resolve(
+                __dirname,
+                '..',
+                '_fixtures',
+                'src'
+            )
+        })
+
+        it('retorna a url do workspace do usuario apontando para index.html', async () => {
+            let url = await workspace.getWorkspaceURL('', {bootstrapBaseUrl: 'http://minhaconta.base.url'})
+            expect(url).toContain('/index.html?')
+        })
+
+        it('Deve retornar queries string ', async () => {
+            let args = {
+                initializationParams: {
+                    foo: 'bar'
+                }
+            }
+            let urlValue = await workspace.getWorkspaceURL(args,  {bootstrapBaseUrl: 'http://minhaconta.base.url'})
+            console.log(urlValue)
+            let query = url.parse(urlValue, true).query
+            let dataString = Buffer.from(query.data, 'base64').toString()
+            let data = JSON.parse(dataString)
+            expect(data.initializationParams).toMatchObject(args.initializationParams)
+        })
+
+        it('retorna a url do workspace do usuario apontando para OrderDetails.html', async () => {
+            let url = await workspace.getWorkspaceURL({ view: 'OrderDetails' },  {bootstrapBaseUrl: 'http://minhaconta.base.url'})
+            expect(url).toContain('/OrderDetails.html?')
+        })
+
+        it('retorna a url do workspace do usuario com o parametro order id', async () => {
+            let url = await workspace.getWorkspaceURL({
+                view: 'OrderDetails',
+                orderId: 'e08a2547-b8d6-4437-91a7-0bc67987689d',
+            },  {bootstrapBaseUrl: 'http://minhaconta.base.url'})
+            expect(url).toContain(
+                'orderId=e08a2547-b8d6-4437-91a7-0bc67987689d'
+            )
+        })
+    })
+
+    describe('.postLambda()', () => {
+        const filePath = path.resolve(__dirname, '..', '_fixtures', 'src', 'server', 'foo.js')
+        const relativePath = '../_fixtures/src/server/foo.js'
+
+        beforeEach(() => {
+            nock.cleanAll()
+            workspace.setWebhooks([])
+        })
+        it('should on invoke postLambda set webhooks if return hookData', async () => {
+            const fakeHookData = {FunctionUrl: 'FakeUrl.com', fileName: 'fakeFileName'}
+            nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+                .post('/workspace/server', () => {
+                    return true
+                })
+                .reply(200, { ok: true, hookData: fakeHookData })
+            await workspace.postLambda(filePath, relativePath)
+            const webhooks = workspace.getWebhooks()
+            expect(webhooks).toContainEqual(fakeHookData)
+        })
+
+        it('should on invoke postLambda ignore set webhooks if no return', async () => {
+            nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+                .post('/workspace/server', () => {
+                    return true
+                })
+                .reply(200, { ok: true })
+            await workspace.postLambda(filePath, relativePath)
+            const webhooks = workspace.getWebhooks()
+            expect(webhooks).toEqual([])
+        })
+    })
+
+    describe('.getTargetConfig() & .getAllTargetConfigs()', () => {
+        const target = 'CALINDRA_MOBILE'
+        const res = [
+            {
+                id: 7,
+                name: 'CALINDRA_MOBILE',
+                minimumCliVersion: '1.16.5',
+                boilerplateUrl: 'https://github.com/Calindra/servless-backend-template.git',
+                superAppClientLibName: 'eitri-app-client',
+                componentsLibName: 'eitri-app-components',
+                description: 'CALINDRA_MOBILE',
+                status: 'ACTIVE',
+                platform: 'mobile',
+                targetConfig: [
+                    {
+                        id: 'default',
+                        libUrl: 'https://www.npmjs.com/package/eitri-app-client',
+                        runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
+                        bootstrapBaseUrl: 'https://dev.eitri.calindra.com.br',
+                        askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/o/mini-apps/:slug/token'
+                    },
+                    {
+                        id: 'ws',
+                        libUrl: 'https://www.npmjs.com/package/eitri-app-client',
+                        runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
+                        bootstrapBaseUrl: 'http://localhost:3333',
+                        askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/p/mini-apps/:slug/token/workspace'
+                    }
+                ],
+                default: true
+            }
+        ]
+
+        beforeEach(() => {
+            nock.cleanAll()
+            nock('https://dev.eitri.calindra.com.br')
+            .get(`/workspace/targets?name=${target}`).reply(200, res)
+        })
+
+        it('deve receber a configuração correta', async () => {
+            const config = await workspace.getTargetConfig('default', target)
+            expect(config[0]).toStrictEqual({
+                id: 'default',
+                libUrl: 'https://www.npmjs.com/package/eitri-app-client',
+                runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
+                bootstrapBaseUrl: 'https://dev.eitri.calindra.com.br',
+                askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/o/mini-apps/:slug/token'
+            })
+
+        }
+        )
+        it('deve retornar todos os configs', async () => {
+            const config = await workspace.getAllTargetConfigs(target)
+            expect(config).toMatchObject([
+                {
+                    id: 'default',
+                    libUrl: 'https://www.npmjs.com/package/eitri-app-client',
+                    runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
+                    bootstrapBaseUrl: 'https://dev.eitri.calindra.com.br',
+                    askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/o/mini-apps/:slug/token'
+                },
+                {
+                    id: 'ws',
+                    libUrl: 'https://www.npmjs.com/package/eitri-app-client',
+                    runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
+                    bootstrapBaseUrl: 'http://localhost:3333',
+                    askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/p/mini-apps/:slug/token/workspace'
+                }
+            ])
+        })  
+    })
+    
+    describe('.availableTargets()', () => {
+
+        const expectedTarget ={
+            'id': 7,
+            'name': 'CALINDRA_MOBILE',
+            'minimumCliVersion': '1.16.5',
+            'boilerplateUrl': 'https://github.com/Calindra/servless-backend-template',
+            'superAppClientLibName': 'eitri-app-client',
+            'componentsLibName': 'eitri-app-components',
+            'description': 'CALINDRA_MOBILE',
+            'status': 'ACTIVE',
+            'platform': 'mobile',
+            'targetConfig': [
+                {
+                    'id': 'default',
+                    'libUrl': 'https://www.npmjs.com/package/eitri-app-client',
+                    'runnerUrl': 'https://dev.eitri.calindra.com.br/app/',
+                    'bootstrapBaseUrl': 'http://localhost:3333',
+                    'askUserDataApiUrl': 'https://dev.eitri.calindra.com.br/miniapp-manager-api/o/mini-apps/:slug/token'
+                },
+                {
+                    'id': 'ws',
+                    'libUrl': 'https://www.npmjs.com/package/eitri-app-client',
+                    'runnerUrl': 'https://dev.eitri.calindra.com.br/app/',
+                    'bootstrapBaseUrl': 'http://localhost:3333',
+                    'askUserDataApiUrl': 'https://dev.eitri.calindra.com.br/miniapp-manager-api/p/mini-apps/:slug/token/workspace'
+                }
+            ],
+            'default': false
+        }
+        
+        it('should return targets', async () => {
+            nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+                .get('/workspace/targets')
+                .reply(200, [expectedTarget])
+            const result = await workspace.availableTargets()
+            expect(result).toBeDefined()
+            expect(result).toContainEqual(expectedTarget)
+        })
+    })
+
+    describe('.postFile()', () => {
+        afterEach(() => {
+            nock.cleanAll()
+        })
+        it('deve invocar o postLambda quando o relativePath incluir a pasta server', async () => {
+        
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/workspace/server')
+                .delayBody(1000)
+                .reply(200, { request: 1 })
+            
+            const filePath = path.resolve(folder2watch, 'server', 'HelloWorldBackend.js')
+
+            const spiedPostLambda = jest.spyOn(workspace, 'postLambda')
+            await workspace.postFile(filePath, false, {})
+
+            expect(spiedPostLambda).toHaveBeenCalled()
+            expect(spiedPostLambda).toHaveBeenCalledTimes(1)
+        })
+
+        it('deve invocar o postFormData quando o relativePath incluir o watchDir do miniapp', async () => {
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/workspace/fileupload')
+                .delayBody(1000)
+                .reply(200, { request: 1 })
+            
+            const filePath = path.resolve(folder2watch, 'src', 'Home.js')
+
+            const spiedPostFormData = jest.spyOn(workspace, 'postFormData')
+            await workspace.postFile(filePath, false, {})
+
+            expect(spiedPostFormData).toHaveBeenCalled()
+            expect(spiedPostFormData).toHaveBeenCalledTimes(1)
+        })
+    })
+})