eitri-cli 1.0.2

package/test/cmd/create.test.js

@@ -0,0 +1,252 @@
+/* eslint-disable no-undef */
+const fs = require('fs')
+const path = require('path')
+const childProcess = require('child_process')
+const create = require('../../src/cmd/create')
+const nock = require('nock')
+const inquirer = require('inquirer')
+const {faker} = require('@faker-js/faker')
+const WookCoffee = require('../../src/service/factories/WoodCoffeeFactory')
+const getCreateFactory = require('../../src/util/getCreateFactory')
+const {getTarget} = require('../_fixtures/factory')
+const {workspace} = require('../../src/service/Workspace')
+jest.setTimeout(15000)
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+jest.mock('../../src/util/getCreateFactory', () => jest.fn())
+
+describe('create', () => {
+    xit('cria o mini app no backend ao rodar create', async () => {
+        const env = Object.create(process.env)
+
+        env.NODE_ENV = 'lab'
+        console.log(env.NODE_APP_INSTANCE)
+        childProcess.execSync('rm -rf ./apagar-pasta')
+        child = childProcess.spawn(
+            'node',
+            ['index.js', 'create', 'apagar-pasta'],
+            { env: env }
+        )
+
+        child.stdin.setEncoding('utf8')
+        child.stdout.pipe(process.stdout)
+        await delay(500)
+        child.stdin.write(`Nome-${Date.now()}+1\n`)
+        await delay(500)
+        child.stdin.write(`titulo-${Date.now()}\n`)
+        await delay(500)
+        child.stdin.write(`slug-${Date.now()}\n`)
+        await delay(500)
+        child.stdin.write('empresa\n')
+        await delay(7000)
+        child.stdin.end()
+
+        let content = fs.readFileSync(
+            path.join(__dirname, '../../apagar-pasta/miniapp.conf.js'),
+            'utf8'
+        )
+        expect(content).toMatch(
+            /"public-key": "\w{8}-\w{4}-\w{4}-\w{4}-\w{12}"/
+        )
+    })
+
+    xit('trata nome ja existente', async () => {
+        const env = Object.create(process.env)
+
+        env.NODE_ENV = 'lab'
+        childProcess.execSync('rm -rf ./apagar-pasta')
+        child = childProcess.spawn(
+            'node',
+            ['index.js', 'create', 'apagar-pasta'],
+            { env: env }
+        )
+        child.stdin.setEncoding('utf8')
+        child.stdout.pipe(process.stdout)
+        let allOutput = ''
+        child.stdout.on('data', function (data) {
+            data = data.toString()
+            allOutput += data
+        })
+
+        await delay(500)
+        child.stdin.write('Depositar\n')
+        await delay(500)
+        child.stdin.write(`titulo-${Date.now()}\n`)
+        await delay(500)
+        child.stdin.write(`slug-${Date.now()}\n`)
+        await delay(500)
+        child.stdin.write('empresa\n')
+        await delay(5000)
+        expect(allOutput).toContain('Outro nome')
+        await delay(500)
+        child.stdin.write(`Nome ${Date.now()}\n`)
+        console.log('ok')
+        await delay(5000)
+        child.stdin.end()
+        let content = fs.readFileSync(
+            path.join(__dirname, '../../apagar-pasta/miniapp.conf.js'),
+            'utf8'
+        )
+        expect(content).toMatch(
+            /"public-key": "\w{8}-\w{4}-\w{4}-\w{4}-\w{12}"/
+        )
+    })
+
+    xit('trata slug ja existente', async () => {
+        const env = Object.create(process.env)
+
+        env.NODE_ENV = 'lab'
+        childProcess.execSync('rm -rf ./apagar-pasta')
+        child = childProcess.spawn(
+            'node',
+            ['index.js', 'create', 'apagar-pasta'],
+            { env: env }
+        )
+        child.stdin.setEncoding('utf8')
+        child.stdout.pipe(process.stdout)
+        let allOutput = ''
+        child.stdout.on('data', function (data) {
+            data = data.toString()
+            allOutput += data
+        })
+
+        await delay(500)
+        child.stdin.write(`Nome ${Date.now()}\n`)
+        await delay(500)
+        child.stdin.write(`titulo-${Date.now()}\n`)
+        await delay(500)
+        child.stdin.write('transaction-cashin\n')
+        await delay(500)
+        child.stdin.write('empresa\n')
+        await delay(5000)
+        expect(allOutput).toContain('Outro slug')
+        await delay(500)
+        child.stdin.write(`slug-${Date.now()}\n`)
+        console.log('ok')
+        await delay(5000)
+        child.stdin.end()
+        let content = fs.readFileSync(
+            path.join(__dirname, '../../apagar-pasta/miniapp.conf.js'),
+            'utf8'
+        )
+        expect(content).toMatch(
+            /"public-key": "\w{8}-\w{4}-\w{4}-\w{4}-\w{12}"/
+        )
+    })
+
+    describe('--target', () => {
+        const expectedTarget = getTarget()
+
+        // stub inquirer
+        let backup
+        beforeEach(async () => {
+            backup = inquirer.prompt
+        })
+
+        it('should succesfully show all available targets', async () => {
+
+            const targets = [expectedTarget, {...expectedTarget, name: 'TARGET_WHATEVER_2'}]
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/blind-guardian-api/v1/o/auth')
+                .reply(200, { accessToken: 'xpto' })
+
+            nock('https://dev.eitri.calindra.com.br')
+                .get('/workspace/targets')
+                .matchHeader('Authorization', 'Bearer xpto')
+                .reply(200, targets)
+
+            inquirer.prompt = (questions) => {
+                // Checando se o que foi exibido para o usuario esta correto
+                expect(questions[0].choices).toMatchObject([
+                    'CALINDRA_MOBILE',
+                    'TARGET_WHATEVER_2',
+                    'Dúvidas? Veja documentação no browser',
+                ])
+
+                // Apos a montagem da lista, nao queremos mais que o codigo de negocio restante execute,
+                // pois ja identificamos que a lista foi exibida corretamente, que é o objetivo deste teste.
+                throw 'success'
+            }
+
+            const cmdObjStub = {
+                target: 'TARGET_WHATEVER_2',
+            }
+
+            const pseudoError = await create('my_project', cmdObjStub).catch(
+                (e) => e
+            )
+            expect(pseudoError).toBe('success')
+        })
+
+        // restore
+        afterEach(() => {
+            inquirer.prompt = backup
+        })
+
+        afterAll(async () => {
+            await nock.cleanAll()
+        })
+    })
+
+    describe('--template', () => {
+
+        let projectName
+        let wookCoffee
+        let target
+        class WookCoffeStub extends WookCoffee {
+            // eslint-disable-next-line no-unused-vars
+            verifyFolder(_projectName, _options) {
+                return new Promise(resolve => resolve('/tmp'))
+            }
+
+            // eslint-disable-next-line no-unused-vars
+            create(_projectName, _templateUrl) {
+                return new Promise(resolve => resolve({projectPath: '/tmp'}))
+            }
+        }
+        
+        beforeEach(() => {
+            nock.cleanAll()
+            target = getTarget()
+            jest.spyOn(workspace, 'availableTargets').mockImplementationOnce(new Promise(resolve => resolve([target])))
+            projectName = faker.commerce.product() + Date.now()
+            wookCoffee = new WookCoffeStub()
+        })
+            
+        afterAll(() => {
+            nock.cleanAll()
+        })
+            
+            
+        it('should create miniapp with selected template', async () => {
+            jest.spyOn(inquirer, 'prompt').mockResolvedValueOnce({ accepted: 'CALINDRA_MOBILE' })
+            getCreateFactory.mockImplementation(() => wookCoffee)
+            const factorySpy = jest.spyOn(wookCoffee, 'create')
+            const args = {
+                target: 'CALINDRA_MOBILE',
+                yes: true,
+                template: 'serverless'
+            }
+            await create(projectName, args)
+
+            expect(factorySpy).toHaveBeenCalledWith(projectName, 'https://github.com/Calindra/eitri-mobile-mini-app-template', target)
+        })
+
+        it.skip('should return error on select invalid template', async () => {
+            jest.spyOn(inquirer, 'prompt').mockResolvedValueOnce({ accepted: 'CALINDRA_MOBILE' })
+            getCreateFactory.mockImplementation(() => wookCoffee)
+            const consoleSpy = jest.spyOn(console, 'error')
+            jest.spyOn(process, 'exit')
+                .mockImplementation((number) => {return number})    
+            const args = {
+                target: 'CALINDRA_MOBILE',
+                yes: true,
+                template: 'inexistent template'
+            }
+            await create(projectName, args)
+
+            expect(consoleSpy).toHaveBeenCalledWith('O template [inexistent template] não existe para o target selecionado.')
+        })
+    })
+})

package/test/cmd/credentials.test.js

@@ -0,0 +1,159 @@
+/* eslint-disable no-undef */
+const path = require('path')
+const {workspace} = require('../../src/service/Workspace')
+const { panicCheckEnvList, environmentVariable, buildEnvFile, sendEnvfile } = require('../../src/util/manage-env')
+const config = require('config')
+const CONFIG_WORKSPACE = config.get('workspace')
+const nock = require('nock')
+const ManageEnvService = require('../../src/service/ManageEnvService')
+const manageEnvService = new ManageEnvService()
+
+describe('manage-env', () => {
+    const MOCK = true
+    const blindGuardian = workspace.blindGuardian
+
+    beforeEach(() => {
+        nock.cleanAll()
+    })
+
+    afterEach(() => {
+        nock.cleanAll()
+    })
+
+    it('should fail when envList is empty', async () => {
+        expect.assertions(2)
+        try {
+            panicCheckEnvList([])
+        } catch (e) {
+            expect(e).toBeDefined()
+            expect(e.message).toBe('Nenhuma variavel de ambiente foi fornecida.')
+        }
+    })
+
+    it('should fail with wrong key', async () => {
+        expect.assertions(2)
+        try {
+            const envList = ['0FOO=bar']
+            environmentVariable(envList)
+        } catch (e) {
+            expect(e).toBeDefined()
+            expect(e.message).toEqual('A chave 0FOO é inválida')
+        }
+
+    })
+
+    it('should return a object', async () => {
+        const envList = ['FOO=bar', 'DEV=back-end']
+        const envVariable = environmentVariable(envList)
+        expect(envVariable).toEqual({ FOO: 'bar', DEV: 'back-end' })
+    })
+
+    it('should fail if there is no fileNames', () => {
+        expect.assertions(2)
+        try {
+            buildEnvFile('dev', [], { FOO: 'bar', DEV: 'back-end' }, 'miniapp-foo', '0.1.0')
+        } catch (e) {
+            expect(e).toBeDefined()
+            expect(e.message).toEqual('Não existe aquivo na pasta server.')
+        }
+    })
+
+    it('should send envFile to /colossus-api/v1', async () => {
+        let bodySentToServer, bodySentToCreateLambda
+        if (MOCK) {
+            nock(CONFIG_WORKSPACE.colossus.url, { allowUnmocked: true })
+                .post('/env', body => {
+                    bodySentToServer = body
+                    return true
+                })
+                .reply(200, { ok: true })
+            nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+                .post('/workspace/server', body => {
+                    bodySentToCreateLambda = body
+                    return true
+                })
+                .reply(200, { ok: true })
+        }
+        const folder2watch = path.resolve(__dirname, '..', '_fixtures', 'src')
+        workspace.setFolder2Watch(folder2watch)
+        blindGuardian.readConf()
+
+        workspace.setServerUrl(CONFIG_WORKSPACE.url)
+        await workspace.init()
+        try {
+            await workspace.postLambda(path.resolve(folder2watch, 'server', 'foo.js'), '/server/foo.js')
+        } catch (e) {
+            console.error(e)
+            throw e
+        }
+        let miniConf = workspace.getMiniConf()
+        const fileNames = await workspace.getFileNames('server')
+
+        const envFile = {
+            envCode: 'ws',
+            fileNames,
+            envVars: { FOO: 'bar', DEV: 'back-end' },
+            slug: miniConf.slug,
+            miniAppVersion: miniConf.version
+        }
+
+        const url = `${CONFIG_WORKSPACE.colossus.url}`
+        const resp = await sendEnvfile(workspace, url, envFile).catch(e => e)
+        expect(resp.constructor.name).not.toBe('Error')
+        expect(resp.data).toMatchObject({ ok: true })
+        if (MOCK) {
+            expect(bodySentToServer).toMatchObject({
+                envCode: 'ws',
+                fileNames,
+                envVars: { FOO: 'bar', DEV: 'back-end' },
+                slug: miniConf.slug,
+                miniAppVersion: miniConf.version
+            })
+            expect(bodySentToCreateLambda).toMatchObject({
+                'envCode': 'ws',
+                'miniAppVersion': '0.1.0',
+                'name': 'foo.js',
+                'publishing': false,
+                'slug': 'mini-app-colossus',
+            })
+        }
+    }, 60000)
+
+    it('should find environment variables', async () => {
+        const url = `${CONFIG_WORKSPACE.colossus.url}`
+        const query = {
+            env: 'ws',
+            slug: 'mini-app-colossus',
+            miniAppVersion: '0.1.0',
+            fileName: 'backend.js',
+            email: 'fabio.oshiro@gmail'
+        }
+        console.log('rota', CONFIG_WORKSPACE.colossus.url)
+        // https://dev.eitri.calindra.com.br/workspace/server?env=ws&slug=mini-app-colossus&miniAppVersion=0.1.0&fileName=backend.js&user=fabio.oshiro@gmail
+        nock('https://dev.eitri.calindra.com.br/workspace/server', { allowUnmocked: false })
+            .get('/env')
+            .query(query)
+            .reply(200, { FOO: 'BAR', BAR: 'FOO' })
+
+        const folder2watch = path.resolve(__dirname, '..', '_fixtures', 'src')
+        workspace.setFolder2Watch(folder2watch)
+        blindGuardian.readConf()
+
+        workspace.setServerUrl(CONFIG_WORKSPACE.url)
+        await workspace.init()
+        // await miniLog.connect(workspace.userEmail)
+        let miniConf = workspace.getMiniConf()
+        let envVariables
+
+        try {
+            envVariables = await manageEnvService.getEnvVariables(workspace, url, miniConf, 'ws', 'fabio.oshiro@gmail', 'backend.js')
+        } catch (e) {
+            console.error(e)
+            throw e
+        }
+
+        console.log('envVariables', envVariables)
+
+        expect(envVariables).toMatchObject({ FOO: 'BAR', BAR: 'FOO' })
+    })
+})

package/test/cmd/list.test.js

@@ -0,0 +1,74 @@
+/* eslint-disable no-undef */
+// eslint-disable-next-line no-unused-vars
+const inquirer = require('inquirer')
+const process = require('process')
+const list = require('../../src/cmd/list')
+const { workspace } = require('../../src/service/Workspace')
+const { getTarget } = require('../_fixtures/factory')
+const nock = require('nock')
+
+jest.mock('inquirer', () => ({
+    prompt: jest.fn(() => {
+        return new Promise(resolve => resolve({selected: 'AME_DIGITAL_MOBILE'}))
+    })
+}))
+
+describe.skip('List command test', () => {
+    let fakeTarget
+    beforeEach(() => {
+        nock.cleanAll()
+        workspace.setServerUrl('https://dev.eitri.calindra.com.br')
+        fakeTarget = getTarget()
+    })
+    it('should print all miniapp templates of selected target', async () => {
+        const args = {
+            template: true
+        }
+
+        jest.spyOn(workspace, 'availableTargets').mockResolvedValueOnce([fakeTarget])
+        const consoleSpy = jest.spyOn(console, 'log')
+        await list(args)
+        expect(consoleSpy).toHaveBeenCalledTimes(1)    
+        expect(consoleSpy).toHaveBeenCalledWith('serverless: Para uso de miniapp com serverless \n')
+    })
+
+    it('should return error if target dont have templates', async () => {
+        const args = {
+            template: true
+        }
+        fakeTarget.miniAppBoilerplateList = null
+
+        jest.spyOn(process, 'exit')
+            .mockImplementation((number) => {return number})
+
+        jest.spyOn(workspace, 'availableTargets').mockResolvedValueOnce([fakeTarget])
+        
+        const consoleSpy = jest.spyOn(console, 'error')
+        await list(args)
+        expect(consoleSpy).toHaveBeenCalledTimes(1)    
+        expect(consoleSpy).toHaveBeenCalledWith('O Target AME_DIGITAL_MOBILE não possui boilerplates disponíveis.')
+        consoleSpy.mockClear()
+    })
+
+    it('should return error if doesnt have target', async () => {
+        const args = {
+            template: true
+        }
+
+        nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+            .get('/workspace/targets')
+            .reply(400, {message: 'xpto'})
+        
+        const consoleSpy = jest.spyOn(console, 'error')
+
+        await list(args)
+
+        jest.spyOn(process, 'exit')
+            .mockImplementation((number) => {return number})
+
+        expect(consoleSpy).toHaveBeenCalledTimes(1)
+        expect(consoleSpy).toHaveBeenLastCalledWith('Houve um erro ao listar os targets.')
+
+    })
+
+})

package/test/cmd/manage-env.test.js

@@ -0,0 +1,168 @@
+/* eslint-disable no-undef */
+const path = require('path')
+const {workspace} = require('../../src/service/Workspace')
+const { panicCheckEnvList, environmentVariable, buildEnvFile, sendEnvfile } = require('../../src/util/manage-env')
+const config = require('config')
+const CONFIG_WORKSPACE = config.get('workspace')
+const nock = require('nock')
+const ManageEnvService = require('../../src/service/ManageEnvService')
+const manageEnvService = new ManageEnvService()
+
+describe('manage-env', () => {
+    const MOCK = true
+    const blindGuardian = workspace.blindGuardian
+
+    beforeEach(() => {
+        nock.cleanAll()
+    })
+
+    afterEach(() => {
+        nock.cleanAll()
+    })
+
+    it('should fail when envList is empty', async () => {
+        expect.assertions(2)
+        try {
+            panicCheckEnvList([])
+        } catch (e) {
+            expect(e).toBeDefined()
+            expect(e.message).toBe('Nenhuma variavel de ambiente foi fornecida.')
+        }
+    })
+
+    it('should fail with wrong key', async () => {
+        expect.assertions(2)
+        try {
+            const envList = ['0FOO=bar']
+            environmentVariable(envList)
+        } catch (e) {
+            expect(e).toBeDefined()
+            expect(e.message).toEqual('A chave 0FOO é inválida')
+        }
+
+    })
+
+    it('should return a object', async () => {
+        const envList = ['FOO=bar', 'DEV=back-end']
+        const envVariable = environmentVariable(envList)
+        expect(envVariable).toEqual({ FOO: 'bar', DEV: 'back-end' })
+    })
+
+    it('should fail if there is no fileNames', () => {
+        expect.assertions(2)
+        try {
+            buildEnvFile('dev', [], { FOO: 'bar', DEV: 'back-end' }, 'miniapp-foo', '0.1.0')
+        } catch (e) {
+            expect(e).toBeDefined()
+            expect(e.message).toEqual('Não existe aquivo na pasta server.')
+        }
+    })
+
+    it('should send envFile to /colossus-api/v1', async () => {
+        let bodySentToServer, bodySentToCreateLambda
+        if (MOCK) {
+
+            nock('https://dev.eitri.calindra.com.br')
+                .post('/blind-guardian-api/v1/o/auth')
+                .reply(200, { accessToken: 'xpto' })
+
+            nock(CONFIG_WORKSPACE.colossus.url, { allowUnmocked: true })
+                .post('/env', body => {
+                    bodySentToServer = body
+                    return true
+                })
+                .reply(200, { ok: true })
+            nock('https://dev.eitri.calindra.com.br', { allowUnmocked: true })
+                .post('/workspace/server', body => {
+                    bodySentToCreateLambda = body
+                    return true
+                })
+                .reply(200, { ok: true })
+        }
+        const folder2watch = path.resolve(__dirname, '..', '_fixtures', 'src')
+        workspace.setFolder2Watch(folder2watch)
+        blindGuardian.readConf()
+
+        workspace.setServerUrl(CONFIG_WORKSPACE.url)
+        await workspace.init()
+        try {
+            await workspace.postLambda(path.resolve(folder2watch, 'server', 'foo.js'), '/server/foo.js')
+        } catch (e) {
+            console.error(e)
+            throw e
+        }
+        let miniConf = workspace.getMiniConf()
+        const fileNames = await workspace.getFileNames('server')
+
+        const envFile = {
+            envCode: 'ws',
+            fileNames,
+            envVars: { FOO: 'bar', DEV: 'back-end' },
+            slug: miniConf.slug,
+            miniAppVersion: miniConf.version
+        }
+
+        const url = `${CONFIG_WORKSPACE.colossus.url}`
+        const resp = await sendEnvfile(workspace, url, envFile).catch(e => e)
+        expect(resp.constructor.name).not.toBe('Error')
+        expect(resp.data).toMatchObject({ ok: true })
+        if (MOCK) {
+            expect(bodySentToServer).toMatchObject({
+                envCode: 'ws',
+                fileNames,
+                envVars: { FOO: 'bar', DEV: 'back-end' },
+                slug: miniConf.slug,
+                miniAppVersion: miniConf.version
+            })
+            expect(bodySentToCreateLambda).toMatchObject({
+                'envCode': 'ws',
+                'miniAppVersion': '0.1.0',
+                'name': 'foo.js',
+                'publishing': false,
+                'slug': 'mini-app-colossus',
+            })
+        }
+    }, 60000)
+
+    it('should find environment variables', async () => {
+        const url = `${CONFIG_WORKSPACE.colossus.url}`
+        const query = {
+            env: 'ws',
+            slug: 'mini-app-colossus',
+            miniAppVersion: '0.1.0',
+            fileName: 'backend.js',
+            email: 'fabio.oshiro@gmail'
+        }
+        console.log('rota', CONFIG_WORKSPACE.colossus.url)
+
+        nock('https://dev.eitri.calindra.com.br')
+            .post('/blind-guardian-api/v1/o/auth')
+            .reply(200, { accessToken: 'xpto' })
+
+        nock('https://dev.eitri.calindra.com.br/workspace/server', { allowUnmocked: false })
+            .get('/env')
+            .query(query)
+            .reply(200, { FOO: 'BAR', BAR: 'FOO' })
+
+        const folder2watch = path.resolve(__dirname, '..', '_fixtures', 'src')
+        workspace.setFolder2Watch(folder2watch)
+        blindGuardian.readConf()
+
+        workspace.setServerUrl(CONFIG_WORKSPACE.url)
+        await workspace.init()
+        // await miniLog.connect(workspace.userEmail)
+        let miniConf = workspace.getMiniConf()
+        let envVariables
+
+        try {
+            envVariables = await manageEnvService.getEnvVariables(workspace, url, miniConf, 'ws', 'fabio.oshiro@gmail', 'backend.js')
+        } catch (e) {
+            console.error(e)
+            throw e
+        }
+
+        console.log('envVariables', envVariables)
+
+        expect(envVariables).toMatchObject({ FOO: 'BAR', BAR: 'FOO' })
+    })
+})

package/test/cmd/signup.test.js

@@ -0,0 +1,20 @@
+/* eslint-disable no-undef */
+
+const signup = require('../../src/cmd/signup')
+const nock = require('nock')
+
+jest.setTimeout(15000)
+
+
+describe('signup', () => {
+
+    it('Should succesfully create an user', () => {
+
+        nock('https://dev.eitri.calindra.com.br')
+            .post('/blind-guardian-api/v1/user')
+            .reply(200, { id: 'xpto', scopes: [ 'foo', 'bar' ] })
+
+
+    })
+    
+})

package/test/cmd/start.test.js

@@ -0,0 +1,5 @@
+/* eslint-disable no-undef */
+
+describe('start', () => {
+    it('sincroniza os arquivos com o servidor', () => {})
+})

package/test/miniapp.conf.js

@@ -0,0 +1,3 @@
+module.exports = {
+    "version": "0.1.0"
+}