eitri-cli 1.0.2

package/test/service/Http.test.js

@@ -0,0 +1,312 @@
+/* eslint-disable no-undef */
+
+const nock = require('nock')
+const Http = require('../../src/service/Http')
+const BlindGuardian = require('../../src/service/BlindGuardian')
+const FormData = require('form-data')
+
+describe('Http', () => {
+    let blindGuardian, tokenCount
+
+    beforeEach(() => {
+        tokenCount = 1
+        blindGuardian = new BlindGuardian()
+        blindGuardian.getToken = async () => {
+            let accessToken = `xpto ${tokenCount++}`
+            return { accessToken }
+        }
+    })
+
+    afterEach(() => {
+        nock.cleanAll()
+    })
+
+    describe('.postForm(url, formData)', () => {
+        it('envia o token no header', async () => {
+            let bodyReceived
+            nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 1/)
+                .post('/somepath', (body) => {
+                    bodyReceived = body
+                    return true
+                })
+                .reply(200, { ok: true })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            const formData = new FormData()
+            formData.append('test', '123')
+
+            await http.postForm('http://myhost/somepath', formData)
+            expect(bodyReceived).toBeDefined()
+        })
+
+        it('tenta novamente com um novo token quando o servidor retorna 401 ', async () => {
+            nock('http://myhost').post('/somepath').reply(401, { error: '' })
+            let bodyReceived
+            nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 2/)
+                .post('/somepath', (body) => {
+                    bodyReceived = body
+                    return true
+                })
+                .reply(200, { ok: true, statusCode: 200 })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            const formData = new FormData()
+            formData.append('test', '123')
+
+            const response = await http.postForm(
+                'http://myhost/somepath',
+                formData
+            )
+            expect(bodyReceived).toBeDefined()
+            expect(response.ok).toBeTruthy()
+            expect(response.statusCode).toStrictEqual(200)
+        })
+
+        it('tenta somente 3x com um novo token quando o servidor retorna 401', async () => {
+            nock('http://myhost')
+                .post(/\/somepath.*/)
+                .reply(401, { error: '' })
+            nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 2/)
+                .post(/\/somepath.*/)
+                .reply(401, { ok: true })
+            let scope = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 3/)
+                .post(/\/somepath.*/)
+                .reply(401, { ok: true })
+            let scope2 = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 4/)
+                .post(/\/somepath.*/)
+                .reply(200, { ok: true })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            const formData = new FormData()
+            formData.append('test', '123')
+            try {
+                await http.postForm('http://myhost/somepath', formData)
+            } catch (e) {
+                expect(e.response.status).toBe(401)
+            }
+            expect(scope.isDone()).toBe(true)
+            expect(scope2.isDone()).toBe(false)
+        })
+
+        it('mostra um erro educadamente', async (done) => {
+            nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 1/)
+                .post('/somepath', (body) => {
+                    bodyReceived = body
+                    return true
+                })
+                .reply(422, { error: 'Mensagem de erro' })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            const formData = new FormData()
+            formData.append('test', '123')
+            try {
+                await http.postForm('http://myhost/somepath', formData)
+                done('nao deveria chegar aqui')
+            } catch (e) {
+                expect(e.message).toContain('Mensagem de erro')
+                done()
+            }
+        })
+    })
+
+    it('exibe erro 500', async (done) => {
+        nock('http://myhost')
+            .post('/somepath')
+            .reply(500, { error: 'Meu Erro' })
+        let http = new Http(null)
+        http.setTokenFactory(blindGuardian)
+        let formData = { test: '123' }
+        try {
+            await http.postForm('http://myhost/somepath', formData)
+            done('Nao deveria passar aqui')
+        } catch (e) {
+            done()
+        }
+    })
+
+    describe('.delete(url, options)', () => {
+        it('envia o token no header', async () => {
+            let scope = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 1/)
+                .delete(/\/somepath.*/)
+                .reply(200, { ok: true, statusCode: 200 })
+
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+
+            let params = { filepath: 'myfile' }
+            const response = await http.delete('http://myhost/somepath', {
+                params,
+            })
+            expect(scope.isDone()).toBeTruthy()
+            expect(response.ok).toBeTruthy()
+            expect(response.statusCode).toStrictEqual(200)
+        })
+
+        it('tenta novamente com um novo token quando o servidor retorna 401 ', async () => {
+            nock('http://myhost')
+                .delete(/\/somepath.*/)
+                .reply(401, { error: '' })
+            let scope = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 2/)
+                .delete(/\/somepath.*/)
+                .reply(200, { ok: true })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+
+            let params = { filepath: 'myfile' }
+            await http.delete('http://myhost/somepath', { params })
+            expect(scope.isDone()).toBe(true)
+        })
+    })
+
+    describe('.get(url, options)', () => {
+        it('envia o token no header', async () => {
+            let scope = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 1/)
+                .get(/\/somepath.*/)
+                .reply(200, { ok: true })
+
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            await http.get('http://myhost/somepath')
+            expect(scope.isDone()).toBe(true)
+        })
+
+        it('tenta novamente com um novo token quando o servidor retorna 401 ', async () => {
+            nock('http://myhost')
+                .get(/\/somepath.*/)
+                .reply(401, { error: '' })
+            let scope = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 2/)
+                .get(/\/somepath.*/)
+                .reply(200, { ok: true })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            let result = await http.get('http://myhost/somepath')
+            expect(result.ok).toBe(true)
+            expect(scope.isDone()).toBe(true)
+        })
+
+        it('tenta somente 3x com um novo token quando o servidor retorna 401', async () => {
+            nock('http://myhost')
+                .get(/\/somepath.*/)
+                .reply(401, { error: '' })
+            nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 2/)
+                .get(/\/somepath.*/)
+                .reply(401, { ok: true })
+            let scope = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 3/)
+                .get(/\/somepath.*/)
+                .reply(401, { ok: true })
+            let scope2 = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 4/)
+                .get(/\/somepath.*/)
+                .reply(200, { ok: true })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            try {
+                await http.get('http://myhost/somepath')
+            } catch (e) {
+                expect(e.response.status).toBe(401)
+            }
+            expect(scope.isDone()).toBe(true)
+            expect(scope2.isDone()).toBe(false)
+        })
+    })
+
+    describe('.put(url, data)', () => {
+        it('envia o token no header', async () => {
+            let scope = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 1/)
+                .put(/\/somepath.*/)
+                .reply(200, { ok: true })
+
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            await http.put('http://myhost/somepath', { foo: 'bar' })
+            expect(scope.isDone()).toBe(true)
+        })
+
+        it('tenta novamente com um novo token quando o servidor retorna 401 ', async () => {
+            nock('http://myhost')
+                .get(/\/somepath.*/)
+                .reply(401, { error: '' })
+            let scope = nock('http://myhost')
+                .matchHeader('authorization', /Bearer xpto 2/)
+                .get(/\/somepath.*/)
+                .reply(200, { ok: true })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            let result = await http.get('http://myhost/somepath')
+            expect(result.ok).toBe(true)
+            expect(scope.isDone()).toBe(true)
+        })
+    })
+
+    describe('Interceptor', () => {
+        it('deve retornar o objeto de warning message', async () => {
+            nock('https://dev.eitri.calindra.com.br')
+                .get('/workspace/health')
+                .reply(200, { 
+                    'warning': {
+                        'message': 'Tem breaking changes, atualize a cli.',
+                        'status': 'VALID'
+                    } 
+                })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            let result = await http.get('https://dev.eitri.calindra.com.br/workspace/health')
+            expect(result.warning).toBeDefined()
+            expect(result.warning.message).toEqual('Tem breaking changes, atualize a cli.')
+            expect(result.warning.status).toEqual('VALID')
+        })
+        it('deve retornar o objeto de greeting message', async () => {
+            nock('https://dev.eitri.calindra.com.br')
+                .get('/workspace/health')
+                .reply(200, { 
+                    'greeting': {
+                        'message': 'FELIZ NATAL!',
+                        'status': 'VALID'
+                    } 
+                })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            let result = await http.get('https://dev.eitri.calindra.com.br/workspace/health')
+            expect(result.greeting).toBeDefined()
+            expect(result.greeting.message).toEqual('FELIZ NATAL!')
+            expect(result.greeting.status).toEqual('VALID')
+        })
+
+        it('deve retornar o objeto de greeting e waring message', async () => {
+            nock('https://dev.eitri.calindra.com.br')
+                .get('/workspace/health')
+                .reply(200, { 
+                    'greeting': {
+                        'message': 'FELIZ NATAL!',
+                        'status': 'VALID'
+                    },
+                    'warning': {
+                        'message': 'Tem breaking changes, atualize a cli.',
+                        'status': 'VALID'
+                    } 
+                })
+            let http = new Http(null)
+            http.setTokenFactory(blindGuardian)
+            let result = await http.get('https://dev.eitri.calindra.com.br/workspace/health')
+            expect(result.greeting).toBeDefined()
+            expect(result.greeting.message).toEqual('FELIZ NATAL!')
+            expect(result.greeting.status).toEqual('VALID')
+            expect(result.warning).toBeDefined()
+            expect(result.warning.message).toEqual('Tem breaking changes, atualize a cli.')
+            expect(result.warning.status).toEqual('VALID')
+        })
+    })
+})

package/test/service/InviteService.test.js

@@ -0,0 +1,117 @@
+/* eslint-disable no-undef */
+
+const path = require('path')
+const nock = require('nock')
+const InviteService = require('../../src/service/InviteService')
+
+describe('InviteService', () => {
+
+    let workspace, folder2watch, inviteService, invite
+
+    beforeEach(() => {
+        nock.cleanAll()
+        invite = {
+            id: 18,
+            email: 'dev@calindra.com.br',
+            miniAppName: 'Nome do miniapp',
+            slug: 'miniapp-slug',
+            status: 'ACTIVE',
+            token: 'RandwYNDBvsebQpR721',
+            inviterEmail: 'revisor@calindra.com.br',
+        }
+        folder2watch = path.resolve(__dirname, '..', '_fixtures')
+
+        workspace = require('../../src/service/Workspace').workspace
+        workspace.setFolder2Watch(folder2watch)
+        workspace.setServerUrl('https://dev.eitri.calindra.com.br')
+
+        // para pegar um token de verdade basta comentar o codigo abaixo
+        workspace.blindGuardian.getToken = async () => {
+            return { accessToken: 'xpto' }
+        }
+
+
+        inviteService = new InviteService(workspace)
+    })
+
+    afterEach(() => {
+        nock.cleanAll()
+    })
+
+    const mockReadInvitesEndPoint = () => {
+        nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+            .get('/miniapp-manager-api/p/myInvites')
+            .reply(200, [invite])
+    }
+
+    const mockFindInvitesBySlugEndPoint = () => {
+        nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+            .get(/\/miniapp-manager-api\/p\/invites\/s\/.*/)
+            .reply(200, [invite])
+    }
+
+    it('lista os convites do desenvolvedor', async () => {
+        mockReadInvitesEndPoint()
+        let invites = await inviteService.findAllPending()
+        expect(invites[0].email).toBeDefined()
+        expect(invites[0].miniAppName).toBeDefined()
+        expect(invites[0].slug).toBeDefined()
+        expect(invites[0].status).toBeDefined()
+        expect(invites[0].token).toBeDefined()
+        expect(invites[0].inviterEmail).toBeDefined()
+    })
+
+    it('aceita um convite', async () => {
+        let bodySentToApi
+        mockReadInvitesEndPoint()
+        nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+            .put(`/miniapp-manager-api/p/invites/accept`, body => {
+                bodySentToApi = body
+                return true
+            })
+            .reply(200, {})
+        let invites = await inviteService.findAllPending()
+        await inviteService.accept(invites[0])
+        expect(bodySentToApi).toBeDefined()
+    })
+
+    it('envia um convite', async () => {
+        let bodySentToApi
+        nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+            .post('/miniapp-manager-api/p/invites', body => {
+                bodySentToApi = body
+                return true
+            })
+            .reply(200, {})
+        await inviteService.sendInvite('teste-convite-dev', 'fabio.oshiro@calindra.com.br')
+        expect(bodySentToApi.email).toBe('fabio.oshiro@calindra.com.br')
+        expect(bodySentToApi.slug).toBe('teste-convite-dev')
+    })
+
+    it('lista os convites de um miniapp', async () => {
+        mockFindInvitesBySlugEndPoint()
+        let invites = await inviteService.findAllBySlug('teste-convite-dev')
+        expect(invites[0]).toBeDefined()
+        expect(invites[0].email).toBeDefined()
+        expect(invites[0].token).toBeDefined()
+        expect(invites[0].slug).toBeDefined()
+    })
+
+    it('remove um convite', async () => {
+        let bodySentToApi
+        mockFindInvitesBySlugEndPoint()
+        nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+            .delete(`/miniapp-manager-api/p/invites/${invite.token}`, body => {
+                bodySentToApi = body
+                return true
+            })
+            .reply(200, {})
+
+        // somente para testar a vera
+        // await inviteService.sendInvite('teste-convite-dev', 'fabio.oshiro@calindra.com.br')
+
+        let invites = await inviteService.findAllBySlug('teste-convite-dev')
+        await inviteService.remove(invites.find(inv => inv.status !== 'CANCELLED'))
+        expect(bodySentToApi).toBeDefined()
+    })
+})

package/test/service/MiniWebAppFactory.test.js

@@ -0,0 +1,40 @@
+/* eslint-disable no-undef */
+
+const fs = require('fs')
+const path = require('path')
+
+const MiniWebAppFactory = require('../../src/service/factories/MiniWebAppFactory')
+
+describe('MiniWebAppFactory', () => {
+    let miniWebAppFactory
+    beforeEach(() => {
+        miniWebAppFactory = new MiniWebAppFactory()
+    })
+
+    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', 'miniWebApp')
+
+            let libsName = ['eitri-mini-app-sdk-support']
+            await miniWebAppFactory.writeAmeConf(project, conf, libsName)
+
+            let expectedConf = {
+                'version': '0.1.0',
+                'eitri-mini-app-sdk-support': '2.0.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)
+        })
+    })
+})

package/test/service/TagTree.test.js

@@ -0,0 +1,81 @@
+/* eslint-disable no-undef */
+
+const path = require('path')
+const TagTree = require('../../src/service/TagTree')
+const componentsPath = path.resolve(
+    __dirname,
+    '..',
+    '_fixtures',
+    'src',
+    'components'
+)
+describe('TagTree', () => {
+    describe('.tagsFilesSorted(tagsPath)', () => {
+        it('ordena os arquivos de acordo com a sua dependencia', async () => {
+            let expected = ['TagC.jsx', 'TagB.jsx', 'TagA.jsx', 'TagD.jsx']
+            let filesSorted = await new TagTree().tagsFilesSorted(
+                componentsPath
+            )
+            expect(filesSorted).toEqual(expected)
+        })
+    })
+    describe('.extractTagsFromContent(markup)', () => {
+        it('encontra as tags dentro de um jsx', () => {
+            let markup = '<View><MyTag>Content</MyTag></View>'
+            let tags = new TagTree().extractTagsFromContent(markup)
+            expect(tags).toContain('View')
+            expect(tags).toContain('MyTag')
+        })
+    })
+    describe('.buildTagMap(tagsPath)', () => {
+        it('gera uma estrutura das tags em um diretorio', async () => {
+            let expected = {
+                TagA: {
+                    name: 'TagA',
+                    fileName: 'TagA.jsx',
+                    children: [
+                        {
+                            name: 'TagB',
+                            fileName: 'TagB.jsx',
+                            children: [
+                                {
+                                    name: 'TagC',
+                                    fileName: 'TagC.jsx',
+                                    children: [],
+                                },
+                            ],
+                        },
+                        {
+                            name: 'TagC',
+                            fileName: 'TagC.jsx',
+                            children: [],
+                        },
+                    ],
+                },
+                TagB: {
+                    name: 'TagB',
+                    fileName: 'TagB.jsx',
+                    children: [
+                        {
+                            name: 'TagC',
+                            fileName: 'TagC.jsx',
+                            children: [],
+                        },
+                    ],
+                },
+                TagC: {
+                    name: 'TagC',
+                    fileName: 'TagC.jsx',
+                    children: [],
+                },
+                TagD: {
+                    name: 'TagD',
+                    fileName: 'TagD.jsx',
+                    children: [],
+                },
+            }
+            let tree = await new TagTree().buildTagMap(componentsPath)
+            expect(tree).toEqual(expected)
+        })
+    })
+})

package/test/service/TargetService.test.js

@@ -0,0 +1,48 @@
+/* eslint-disable no-undef */
+const TargetService = require('../../src/service/TargetService')
+const {workspace} = require('../../src/service/Workspace')
+const nock = require('nock')
+describe('TargetService Tests', () => {
+    /**
+     * @type {TargetService}
+     */
+    let service, targets
+    beforeEach(() => {
+        workspace.setServerUrl('https://dev.eitri.calindra.com.br')
+        service = new TargetService(workspace)
+        targets = [
+            {
+                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: 'AME_DIGITAL_MOBILE',
+                status: 'ACTIVE',
+                platform: 'mobile',
+                targetConfig: [],
+                bodyClass: 'eitri-mobile',
+                sdkSupport: 'eitri-mini-app-sdk-support',
+                default: true,
+                miniAppBoilerplate: [
+                    {
+                        name: 'serverless',
+                        boilerplateUrl: 'https://github.com/Calindra/servless-backend-template.git',
+                        description: 'Para uso de miniapp com serverless'
+                    }
+                ]
+            }
+        ]
+
+        nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+            .get('/workspace/targets')
+            .reply(200, targets)
+    })
+
+    it('should return all targets', async () => {
+        const response = await service.getTargets()
+        expect(response.length).toBeGreaterThan(0)
+        expect(response).toEqual(targets)
+    })
+})