diff --git a/modules/ticket/back/methods/sale/specs/updateQuantity.spec.js b/modules/ticket/back/methods/sale/specs/updateQuantity.spec.js
index 34c58ef98..0669711e7 100644
--- a/modules/ticket/back/methods/sale/specs/updateQuantity.spec.js
+++ b/modules/ticket/back/methods/sale/specs/updateQuantity.spec.js
@@ -232,86 +232,128 @@ describe('sale updateQuantity()', () => {
         }
     });
 
-    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));
+    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;
+            const tx = await models.Sale.beginTransaction({});
+            const itemId = 2;
+            const saleId = 17;
+            const minQuantity = 30;
+            const newQuantity = 31;
 
-        try {
-            const options = {transaction: tx};
+            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, 8 as price;`;
-                    params = null;
-                }
-                return models.Ticket.rawSql(sqlStatement, params, options);
-            });
+                    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 models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
 
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-
-    it('should throw error when increase quantity and the new price is lower than the previous one', async() => {
-        const ctx = {
-            req: {
-                accessToken: {userId: 1},
-                headers: {origin: 'localhost:5000'},
-                __: () => {}
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                throw e;
             }
-        };
-        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;
-
-        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) => {
-                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;
+        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'},
+                    __: () => {}
                 }
-                return models.Ticket.rawSql(sqlStatement, params, options);
-            });
+            };
+            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(1));
 
-            await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
+            const tx = await models.Sale.beginTransaction({});
+            const itemId = 2;
+            const saleId = 17;
+            const minQuantity = 30;
+            const newQuantity = 31;
 
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            error = e;
-        }
+            try {
+                const options = {transaction: tx};
 
-        expect(error).toEqual(new Error('The price of the item changed'));
+                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);
+                });
+
+                await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
+
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                throw e;
+            }
+        });
+
+        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));
+
+            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) => {
+                    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, 100000 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();
+                error = e;
+            }
+
+            expect(error).toEqual(new Error('The price of the item changed'));
+        });
     });
 });
diff --git a/modules/ticket/back/models/sale.js b/modules/ticket/back/models/sale.js
index ef3dd8ef7..4b7ed1043 100644
--- a/modules/ticket/back/models/sale.js
+++ b/modules/ticket/back/models/sale.js
@@ -106,7 +106,7 @@ module.exports = Self => {
                 tmp.zoneGetShipped;
             `, null, ctx.options);
 
-        if (!saleGrouping?.newPrice || saleGrouping.newPrice < instance.price)
+        if (!saleGrouping?.newPrice || saleGrouping.newPrice > instance.price)
             throw new UserError('The price of the item changed');
     });
 };