diff --git a/modules/ticket/back/models/specs/sale.spec.js b/modules/ticket/back/models/specs/sale.spec.js
index d078dc8e2..d50c039db 100644
--- a/modules/ticket/back/models/specs/sale.spec.js
+++ b/modules/ticket/back/models/specs/sale.spec.js
@@ -1,42 +1,36 @@
 /* eslint max-len: ["error", { "code": 150 }]*/
-
-const models = require('vn-loopback/server/server').models;
+const {models} = require('vn-loopback/server/server');
 const LoopBackContext = require('loopback-context');
 
-describe('sale model ', () => {
-    const ctx = {
-        req: {
-            accessToken: {userId: 9},
-            headers: {origin: 'localhost:5000'},
-            __: () => {}
-        }
-    };
-    function getActiveCtx(userId) {
-        return {
-            active: {
-                accessToken: {userId},
-                http: {
-                    req: {
-                        headers: {origin: 'http://localhost'}
-                    }
-                }
-            }
-        };
+fdescribe('sale model ', () => {
+    const developerId = 9;
+    const buyerId = 35;
+    const employeeId = 1;
+
+    const ctx = getCtx(developerId);
+    let tx;
+    let options;
+
+    function getCtx(userId, active = false) {
+        const accessToken = {userId};
+        const headers = {origin: 'localhost:5000'};
+        if (!active) return {req: {accessToken, headers, __: () => {}}};
+        return {active: {accessToken, http: {req: {headers}}}};
     }
 
+    beforeEach(async() => {
+        tx = await models.Sale.beginTransaction({});
+        options = {transaction: tx};
+    });
+
+    afterEach(async() => await tx.rollback());
+
     describe('quantity field ', () => {
         it('should add quantity if the quantity is greater than it should be and is role advanced', async() => {
             const saleId = 17;
-            const buyerId = 35;
-            const ctx = {
-                req: {
-                    accessToken: {userId: buyerId},
-                    headers: {origin: 'localhost:5000'},
-                    __: () => {}
-                }
-            };
-            const tx = await models.Sale.beginTransaction({});
-            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(buyerId));
+            const ctx = getCtx(buyerId);
+
+            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getCtx(buyerId, true));
             spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
                 if (sqlStatement.includes('catalog_calcFromItem')) {
                     sqlStatement = `CREATE OR REPLACE TEMPORARY TABLE tmp.ticketCalculateItem ENGINE = MEMORY
@@ -46,131 +40,74 @@ describe('sale model ', () => {
                 return models.Ticket.rawSql(sqlStatement, params, options);
             });
 
-            try {
-                const options = {transaction: tx};
+            const isRoleAdvanced = await models.ACL.checkAccessAcl(ctx, 'Ticket', 'isRoleAdvanced', '*');
 
-                const isRoleAdvanced = await models.ACL.checkAccessAcl(ctx, 'Ticket', 'isRoleAdvanced', '*');
+            expect(isRoleAdvanced).toEqual(true);
 
-                expect(isRoleAdvanced).toEqual(true);
+            const originalLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
 
-                const originalLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
+            expect(originalLine.quantity).toEqual(30);
 
-                expect(originalLine.quantity).toEqual(30);
+            const newQuantity = originalLine.quantity + 1;
+            await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
 
-                const newQuantity = originalLine.quantity + 1;
-                await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
+            const modifiedLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
 
-                const modifiedLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
-
-                expect(modifiedLine.quantity).toEqual(newQuantity);
-
-                await tx.rollback();
-            } catch (e) {
-                await tx.rollback();
-                throw e;
-            }
+            expect(modifiedLine.quantity).toEqual(newQuantity);
         });
 
         it('should update the quantity of a given sale current line', async() => {
-            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(9));
+            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getCtx(developerId, true));
 
-            const tx = await models.Sale.beginTransaction({});
             const saleId = 25;
             const newQuantity = 4;
 
-            try {
-                const options = {transaction: tx};
+            const originalLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
 
-                const originalLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
+            expect(originalLine.quantity).toEqual(20);
 
-                expect(originalLine.quantity).toEqual(20);
+            await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
 
-                await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
+            const modifiedLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
 
-                const modifiedLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
-
-                expect(modifiedLine.quantity).toEqual(newQuantity);
-
-                await tx.rollback();
-            } catch (e) {
-                await tx.rollback();
-                throw e;
-            }
+            expect(modifiedLine.quantity).toEqual(newQuantity);
         });
 
         it('should throw an error if the quantity is negative and it is not a refund ticket', async() => {
-            const ctx = {
-                req: {
-                    accessToken: {userId: 1},
-                    headers: {origin: 'localhost:5000'},
-                    __: () => {}
-                }
-            };
-            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(1));
+            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getCtx(employeeId, true));
 
             const saleId = 17;
             const newQuantity = -10;
 
-            const tx = await models.Sale.beginTransaction({});
-
-            let error;
             try {
-                const options = {transaction: tx};
-
                 await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
-
-                await tx.rollback();
             } catch (e) {
-                await tx.rollback();
-                error = e;
+                expect(e).toEqual(new Error('You can only add negative amounts in refund tickets'));
             }
-
-            expect(error).toEqual(new Error('You can only add negative amounts in refund tickets'));
         });
 
         it('should update a negative quantity when is a ticket refund', async() => {
-            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(9));
+            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getCtx(developerId, true));
 
-            const tx = await models.Sale.beginTransaction({});
             const saleId = 32;
             const newQuantity = -10;
 
-            try {
-                const options = {transaction: tx};
+            await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
 
-                await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
+            const modifiedLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
 
-                const modifiedLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
-
-                expect(modifiedLine.quantity).toEqual(newQuantity);
-
-                await tx.rollback();
-            } catch (e) {
-                await tx.rollback();
-                throw e;
-            }
+            expect(modifiedLine.quantity).toEqual(newQuantity);
         });
 
         it('should throw an error if the quantity is less than the minimum quantity of the item', async() => {
-            const ctx = {
-                req: {
-                    accessToken: {userId: 1},
-                    headers: {origin: 'localhost:5000'},
-                    __: () => {}
-                }
-            };
-            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(1));
+            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getCtx(employeeId, true));
 
-            const tx = await models.Sale.beginTransaction({});
             const itemId = 2;
             const saleId = 17;
             const minQuantity = 30;
             const newQuantity = minQuantity - 1;
 
-            let error;
             try {
-                const options = {transaction: tx};
-
                 const item = await models.Item.findById(itemId, null, options);
                 await item.updateAttribute('minQuantity', minQuantity, options);
                 spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
@@ -183,157 +120,90 @@ describe('sale model ', () => {
                 });
 
                 await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
-
-                await tx.rollback();
             } catch (e) {
-                await tx.rollback();
-                error = e;
+                expect(e).toEqual(new Error('The amount cannot be less than the minimum'));
             }
-
-            expect(error).toEqual(new Error('The amount cannot be less than the minimum'));
         });
 
         it('should change quantity if has minimum quantity and new quantity is equal than item available', async() => {
-            const ctx = {
-                req: {
-                    accessToken: {userId: 1},
-                    headers: {origin: 'localhost:5000'},
-                    __: () => {}
-                }
-            };
-            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(1));
+            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getCtx(employeeId, true));
 
-            const tx = await models.Sale.beginTransaction({});
             const itemId = 2;
             const saleId = 17;
             const minQuantity = 30;
             const newQuantity = minQuantity - 1;
 
-            try {
-                const options = {transaction: tx};
+            const item = await models.Item.findById(itemId, null, options);
+            await item.updateAttribute('minQuantity', minQuantity, options);
+
+            spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
+                if (sqlStatement.includes('catalog_calcFromItem')) {
+                    sqlStatement = `CREATE OR REPLACE TEMPORARY TABLE tmp.ticketCalculateItem ENGINE = MEMORY
+                            SELECT ${newQuantity} as available;`;
+                    params = null;
+                }
+                return models.Ticket.rawSql(sqlStatement, params, options);
+            });
+
+            await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
+        });
+
+        describe('newPrice', () => {
+            it('should increase quantity if you have enough available and the new price is the same as the previous one', async() => {
+                spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getCtx(employeeId, true));
+
+                const itemId = 2;
+                const saleId = 17;
+                const minQuantity = 30;
+                const newQuantity = 31;
 
                 const item = await models.Item.findById(itemId, null, options);
                 await item.updateAttribute('minQuantity', minQuantity, options);
-
                 spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
                     if (sqlStatement.includes('catalog_calcFromItem')) {
-                        sqlStatement = `CREATE OR REPLACE TEMPORARY TABLE tmp.ticketCalculateItem ENGINE = MEMORY
-                            SELECT ${newQuantity} as available;`;
+                        sqlStatement = `
+                    CREATE OR REPLACE TEMPORARY TABLE tmp.ticketCalculateItem ENGINE = MEMORY SELECT ${newQuantity} as available;
+                    CREATE OR REPLACE TEMPORARY TABLE tmp.ticketComponentPrice ENGINE = MEMORY SELECT 1 as grouping, 7.07 as price;`;
                         params = null;
                     }
                     return models.Ticket.rawSql(sqlStatement, params, options);
                 });
 
                 await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
-
-                await tx.rollback();
-            } catch (e) {
-                await tx.rollback();
-                throw e;
-            }
-        });
-
-        describe('newPrice', () => {
-            it('should increase quantity if you have enough available and the new price is the same as the previous one', async() => {
-                const ctx = {
-                    req: {
-                        accessToken: {userId: 1},
-                        headers: {origin: 'localhost:5000'},
-                        __: () => {}
-                    }
-                };
-                spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(1));
-
-                const tx = await models.Sale.beginTransaction({});
-                const itemId = 2;
-                const saleId = 17;
-                const minQuantity = 30;
-                const newQuantity = 31;
-
-                try {
-                    const options = {transaction: tx};
-
-                    const item = await models.Item.findById(itemId, null, options);
-                    await item.updateAttribute('minQuantity', minQuantity, options);
-                    spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
-                        if (sqlStatement.includes('catalog_calcFromItem')) {
-                            sqlStatement = `
-                    CREATE OR REPLACE TEMPORARY TABLE tmp.ticketCalculateItem ENGINE = MEMORY SELECT ${newQuantity} as available;
-                    CREATE OR REPLACE TEMPORARY TABLE tmp.ticketComponentPrice ENGINE = MEMORY SELECT 1 as grouping, 7.07 as price;`;
-                            params = null;
-                        }
-                        return models.Ticket.rawSql(sqlStatement, params, options);
-                    });
-
-                    await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
-
-                    await tx.rollback();
-                } catch (e) {
-                    await tx.rollback();
-                    throw e;
-                }
             });
 
             it('should increase quantity when the new price is lower than the previous one', async() => {
-                const ctx = {
-                    req: {
-                        accessToken: {userId: 1},
-                        headers: {origin: 'localhost:5000'},
-                        __: () => {}
-                    }
-                };
-                spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(1));
+                spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getCtx(employeeId, true));
 
-                const tx = await models.Sale.beginTransaction({});
                 const itemId = 2;
                 const saleId = 17;
                 const minQuantity = 30;
                 const newQuantity = 31;
 
-                try {
-                    const options = {transaction: tx};
-
-                    const item = await models.Item.findById(itemId, null, options);
-                    await item.updateAttribute('minQuantity', minQuantity, options);
-                    spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
-                        if (sqlStatement.includes('catalog_calcFromItem')) {
-                            sqlStatement = `
+                const item = await models.Item.findById(itemId, null, options);
+                await item.updateAttribute('minQuantity', minQuantity, options);
+                spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
+                    if (sqlStatement.includes('catalog_calcFromItem')) {
+                        sqlStatement = `
                     CREATE OR REPLACE TEMPORARY TABLE tmp.ticketCalculateItem ENGINE = MEMORY SELECT ${newQuantity} as available;
                     CREATE OR REPLACE TEMPORARY TABLE tmp.ticketComponentPrice ENGINE = MEMORY SELECT 1 as grouping, 1 as price;`;
-                            params = null;
-                        }
-                        return models.Ticket.rawSql(sqlStatement, params, options);
-                    });
+                        params = null;
+                    }
+                    return models.Ticket.rawSql(sqlStatement, params, options);
+                });
 
-                    await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
-
-                    await tx.rollback();
-                } catch (e) {
-                    await tx.rollback();
-                    throw e;
-                }
+                await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
             });
 
             it('should throw error when increase quantity and the new price is higher than the previous one', async() => {
-                const ctx = {
-                    req: {
-                        accessToken: {userId: 1},
-                        headers: {origin: 'localhost:5000'},
-                        __: () => {}
-                    }
-                };
-                spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(1));
+                spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getCtx(employeeId, true));
 
-                const tx = await models.Sale.beginTransaction({});
                 const itemId = 2;
                 const saleId = 17;
                 const minQuantity = 30;
                 const newQuantity = 31;
 
-                let error;
                 try {
-                    const options = {transaction: tx};
-
                     const item = await models.Item.findById(itemId, null, options);
                     await item.updateAttribute('minQuantity', minQuantity, options);
                     spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
@@ -347,14 +217,9 @@ describe('sale model ', () => {
                     });
 
                     await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
-
-                    await tx.rollback();
                 } catch (e) {
-                    await tx.rollback();
-                    error = e;
+                    expect(e).toEqual(new Error('The price of the item changed'));
                 }
-
-                expect(error).toEqual(new Error('The price of the item changed'));
             });
         });
     });