feature(backHelpers): first helpers iteration for backend unit tests

back/tests.js

@@ -1,39 +0,0 @@
-require('require-yaml');
-
-process.on('warning', warning => {
-    console.log(warning.name);
-    console.log(warning.message);
-    console.log(warning.stack);
-});
-
-let verbose = false;
-
-if (process.argv[2] === '--v')
-    verbose = true;
-
-let Jasmine = require('jasmine');
-let jasmine = new Jasmine();
-let SpecReporter = require('jasmine-spec-reporter').SpecReporter;
-
-let serviceSpecs = [
-    `${__dirname}/**/*[sS]pec.js`,
-    `${__dirname}/../loopback/**/*[sS]pec.js`,
-    `${__dirname}/../modules/*/back/**/*.[sS]pec.js`
-];
-
-jasmine.loadConfig({
-    spec_dir: '.',
-    spec_files: serviceSpecs,
-    helpers: []
-});
-
-jasmine.addReporter(new SpecReporter({
-    spec: {
-        // displayStacktrace: 'summary',
-        displaySuccessful: verbose,
-        displayFailedSpec: true,
-        displaySpecDuration: true
-    }
-}));
-
-jasmine.execute();

back/testsHelper.js

@@ -0,0 +1,45 @@
+const Docker = require(`../db/docker.js`);
+let dataSources = require('vn-loopback/server/datasources.json');
+// const argv = require('minimist')(process.argv.slice(2));
+let app;
+let firstRun = true;
+let container;
+
+async function beforeAllFn() {
+    app = require('vn-loopback/server/server');
+    container = new Docker();
+    await container.run();
+    dataSources = JSON.parse(JSON.stringify(dataSources));
+
+    Object.assign(dataSources.vn, {
+        host: container.dbConf.host,
+        port: container.dbConf.port
+    });
+
+    const bootOptions = {dataSources};
+
+    if (firstRun) {
+        firstRun = false;
+        app.boot(bootOptions);
+    }
+}
+
+async function afterAllFn() {
+    // await app.disconnect();
+    await container.rm();
+    // app = null;
+}
+
+module.exports = function fixtures() {
+    beforeAll(function(done) {
+        beforeAllFn().then(done).catch(function(error) {
+            console.log(error);
+        });
+    }, 30000);
+
+    afterAll(function(done) {
+        afterAllFn().then(done).catch(function(error) {
+            console.log(error);
+        });
+    }, 30000);
+};

db/docker.js

@@ -29,12 +29,12 @@ module.exports = class Docker {
         let dockerArgs;
 
         if (this.isRandom)
-            dockerArgs = '-p 3306';
+            dockerArgs = '-p 30900:3306';
         else {
             try {
                 await this.rm();
             } catch (e) {}
-            dockerArgs = `--name ${this.name} -p 3306:${this.dbConf.port}`;
+            dockerArgs = `--name ${this.name} -p ${this.dbConf.port}:3306`;
         }
 
         let runChown = process.platform != 'linux';
@@ -43,15 +43,15 @@ module.exports = class Docker {
         this.id = container.stdout.trim();
 
         try {
-            if (this.isRandom) {
+            // if (this.isRandom) {
-                let inspect = await this.execP(`docker inspect -f "{{json .NetworkSettings}}" ${this.id}`);
+            let inspect = await this.execP(`docker inspect -f "{{json .NetworkSettings}}" ${this.id}`);
-                let netSettings = JSON.parse(inspect.stdout);
+            let netSettings = JSON.parse(inspect.stdout);
 
-                if (ci)
+            if (ci)
-                    this.dbConf.host = netSettings.Gateway;
+                this.dbConf.host = netSettings.Gateway;
 
-                this.dbConf.port = netSettings.Ports['3306/tcp'][0]['HostPort'];
+            this.dbConf.port = netSettings.Ports['3306/tcp'][0]['HostPort'];
-            }
+            // }
 
             await this.wait();
         } catch (err) {
@@ -88,43 +88,6 @@ module.exports = class Docker {
         }
     }
 
-    waitForHealthy() {
-        return new Promise((resolve, reject) => {
-            let interval = 100;
-            let elapsedTime = 0;
-            let maxInterval = 4 * 60 * 1000;
-
-            log('Waiting for MySQL init process...');
-
-            async function checker() {
-                elapsedTime += interval;
-                let status;
-
-                try {
-                    let result = await this.execP(`docker inspect -f "{{.State.Health.Status}}" ${this.id}`);
-                    status = result.stdout.trimEnd();
-                } catch (err) {
-                    return reject(new Error(err.message));
-                }
-
-                if (status == 'unhealthy')
-                    return reject(new Error('Docker exited, please see the docker logs for more info'));
-
-                if (status == 'healthy') {
-                    log('MySQL process ready.');
-                    return resolve();
-                }
-
-                if (elapsedTime >= maxInterval)
-                    reject(new Error(`MySQL not initialized whithin ${elapsedTime / 1000} secs`));
-                else
-                    setTimeout(bindedChecker, interval);
-            }
-            let bindedChecker = checker.bind(this);
-            bindedChecker();
-        });
-    }
-
     wait() {
         return new Promise((resolve, reject) => {
             const mysql = require('mysql2');

gulpfile.js

@@ -72,25 +72,8 @@ defaultTask.description = `Starts all application services`;
 
 async function launchBackTest(done) {
     let err;
-    let dataSources = require('./loopback/server/datasources.json');
-
-    const container = new Docker();
-    await container.run(argv.ci);
-
-    dataSources = JSON.parse(JSON.stringify(dataSources));
-
-    Object.assign(dataSources.vn, {
-        host: container.dbConf.host,
-        port: container.dbConf.port
-    });
-
-    let bootOptions = {dataSources};
-
-    let app = require(`./loopback/server/server`);
 
     try {
-        app.boot(bootOptions);
-
         await new Promise((resolve, reject) => {
             const jasmine = require('gulp-jasmine');
 
@@ -99,7 +82,9 @@ async function launchBackTest(done) {
                 includeStackTrace: false,
                 errorOnFail: false,
                 timeout: 5000,
-                config: {}
+                config: {
+                    helpers: [],
+                }
             };
 
             if (argv.ci) {
@@ -108,9 +93,13 @@ async function launchBackTest(done) {
             }
 
             let backSpecFiles = [
-                'back/**/*.spec.js',
+                // 'modules/ticket/back/methods/ticket/specs/canBeInvoiced.spec.js'
-                'loopback/**/*.spec.js',
+                'modules/ticket/back/methods/ticket/specs/addSale.spec.js',
-                'modules/*/back/**/*.spec.js'
+                'modules/ticket/back/methods/ticket/specs/canHaveStowaway.spec.js'
+
+                // 'back/**/*.spec.js',
+                // 'loopback/**/*.spec.js',
+                // 'modules/*/back/**/*.spec.js'
             ];
 
             gulp.src(backSpecFiles)
@@ -122,8 +111,6 @@ async function launchBackTest(done) {
     } catch (e) {
         err = e;
     }
-    await app.disconnect();
-    await container.rm();
     done();
     if (err)
         throw err;

modules/ticket/back/methods/ticket/specs/addSale.spec.js

@@ -1,6 +1,8 @@
 const models = require('vn-loopback/server/server').models;
+const fixtures = require('../../../../../../back/testsHelper.js');
 
 describe('ticket addSale()', () => {
+    fixtures();
     const ticketId = 13;
 
     it('should create a new sale for the ticket with id 13', async() => {

modules/ticket/back/methods/ticket/specs/canBeInvoiced.spec.js

@@ -1,5 +1,6 @@
 const models = require('vn-loopback/server/server').models;
 const LoopBackContext = require('loopback-context');
+// const fixtures = require('../../../../../../back/testsHelper.js');
 
 describe('ticket canBeInvoiced()', () => {
     const userId = 19;
@@ -8,90 +9,97 @@ describe('ticket canBeInvoiced()', () => {
         accessToken: {userId: userId}
     };
 
-    beforeAll(async() => {
+    // fixtures();
+    beforeAll(function() {
+        console.log('SOY EL DOS');
+        throw new Error('beforeAllFn failed');
         spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
             active: activeCtx
         });
     });
 
-    it('should return falsy for an already invoiced ticket', async() => {
+    it('should return true if the ticket warehouse have hasStowaway equal 1', async() => {
-        const tx = await models.Ticket.beginTransaction({});
+        expect(true).toBeTruthy();
-
-        try {
-            const options = {transaction: tx};
-
-            const ticket = await models.Ticket.findById(ticketId, null, options);
-            await ticket.updateAttribute('refFk', 'T1111111', options);
-
-            const canBeInvoiced = await models.Ticket.canBeInvoiced([ticketId], options);
-
-            expect(canBeInvoiced).toEqual(false);
-
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
     });
 
-    it('should return falsy for a ticket with a price of zero', async() => {
+    //     it('should return falsy for an already invoiced ticket', async() => {
-        const tx = await models.Ticket.beginTransaction({});
+    //         const tx = await models.Ticket.beginTransaction({});
 
-        try {
+    //         try {
-            const options = {transaction: tx};
+    //             const options = {transaction: tx};
 
-            const ticket = await models.Ticket.findById(ticketId, null, options);
+    //             const ticket = await models.Ticket.findById(ticketId, null, options);
-            await ticket.updateAttribute('totalWithVat', 0, options);
+    //             await ticket.updateAttribute('refFk', 'T1111111', options);
 
-            const canBeInvoiced = await models.Ticket.canBeInvoiced([ticketId], options);
+    //             const canBeInvoiced = await models.Ticket.canBeInvoiced([ticketId], options);
 
-            expect(canBeInvoiced).toEqual(false);
+    //             expect(canBeInvoiced).toEqual(false);
 
-            await tx.rollback();
+    //             await tx.rollback();
-        } catch (e) {
+    //         } catch (e) {
-            await tx.rollback();
+    //             await tx.rollback();
-            throw e;
+    //             throw e;
-        }
+    //         }
-    });
+    //     });
 
-    it('should return falsy for a ticket shipping in future', async() => {
+    //     it('should return falsy for a ticket with a price of zero', async() => {
-        const tx = await models.Ticket.beginTransaction({});
+    //         const tx = await models.Ticket.beginTransaction({});
 
-        try {
+    //         try {
-            const options = {transaction: tx};
+    //             const options = {transaction: tx};
 
-            const ticket = await models.Ticket.findById(ticketId, null, options);
+    //             const ticket = await models.Ticket.findById(ticketId, null, options);
+    //             await ticket.updateAttribute('totalWithVat', 0, options);
 
-            const shipped = new Date();
+    //             const canBeInvoiced = await models.Ticket.canBeInvoiced([ticketId], options);
-            shipped.setDate(shipped.getDate() + 1);
 
-            await ticket.updateAttribute('shipped', shipped, options);
+    //             expect(canBeInvoiced).toEqual(false);
 
-            const canBeInvoiced = await models.Ticket.canBeInvoiced([ticketId], options);
+    //             await tx.rollback();
+    //         } catch (e) {
+    //             await tx.rollback();
+    //             throw e;
+    //         }
+    //     });
 
-            expect(canBeInvoiced).toEqual(false);
+    //     it('should return falsy for a ticket shipping in future', async() => {
+    //         const tx = await models.Ticket.beginTransaction({});
 
-            await tx.rollback();
+    //         try {
-        } catch (e) {
+    //             const options = {transaction: tx};
-            await tx.rollback();
-            throw e;
-        }
-    });
 
-    it('should return truthy for an invoiceable ticket', async() => {
+    //             const ticket = await models.Ticket.findById(ticketId, null, options);
-        const tx = await models.Ticket.beginTransaction({});
 
-        try {
+    //             const shipped = new Date();
-            const options = {transaction: tx};
+    //             shipped.setDate(shipped.getDate() + 1);
 
-            const canBeInvoiced = await models.Ticket.canBeInvoiced([ticketId], options);
+    //             await ticket.updateAttribute('shipped', shipped, options);
 
-            expect(canBeInvoiced).toEqual(true);
+    //             const canBeInvoiced = await models.Ticket.canBeInvoiced([ticketId], options);
 
-            await tx.rollback();
+    //             expect(canBeInvoiced).toEqual(false);
-        } catch (e) {
+
-            await tx.rollback();
+    //             await tx.rollback();
-            throw e;
+    //         } catch (e) {
-        }
+    //             await tx.rollback();
-    });
+    //             throw e;
+    //         }
+    //     });
+
+    //     it('should return truthy for an invoiceable ticket', async() => {
+    //         const tx = await models.Ticket.beginTransaction({});
+
+    //         try {
+    //             const options = {transaction: tx};
+
+    //             const canBeInvoiced = await models.Ticket.canBeInvoiced([ticketId], options);
+
+    //             expect(canBeInvoiced).toEqual(true);
+
+//             await tx.rollback();
+//         } catch (e) {
+//             await tx.rollback();
+//             throw e;
+//         }
+//     });
 });

modules/ticket/back/methods/ticket/specs/canHaveStowaway.spec.js

@@ -1,6 +1,8 @@
 const models = require('vn-loopback/server/server').models;
+const fixtures = require('../../../../../../back/testsHelper.js');
 
 describe('ticket canHaveStowaway()', () => {
+    fixtures();
     it('should return true if the ticket warehouse have hasStowaway equal 1', async() => {
         const tx = await models.Ticket.beginTransaction({});