front/core/components/contextmenu/index.js

@@ -223,26 +223,29 @@ export default class Contextmenu {
                 delete userFilter.where;
         }
 
-        function removeProp(instance, findProp, prop) {
+        function removeProp(obj, targetProp, prop) {
-            if (prop == findProp)
+            if (prop == targetProp)
-                delete instance[prop];
+                delete obj[prop];
 
             if (prop === 'and' || prop === 'or') {
-                const instanceCopy = instance[prop].slice();
+                const arrayCopy = obj[prop].slice();
-                for (let param of instanceCopy) {
+                for (let param of arrayCopy) {
                     const [key] = Object.keys(param);
-                    const index = instance[prop].findIndex(param => {
+                    const index = obj[prop].findIndex(param => {
                         return Object.keys(param)[0] == key;
                     });
-                    if (key == findProp)
+                    if (key == targetProp)
-                        instance[prop].splice(index, 1);
+                        obj[prop].splice(index, 1);
 
                     if (param[key] instanceof Array)
                         removeProp(param, filterKey, key);
+
+                    if (Object.keys(param).length == 0)
+                        obj[prop].splice(index, 1);
                 }
 
-                if (instance[prop].length == 0)
+                if (obj[prop].length == 0)
-                    delete instance[prop];
+                    delete obj[prop];
             }
         }
 

front/core/components/smart-table/index.js

@@ -54,20 +54,6 @@ export default class SmartTable extends Component {
 
     set viewConfigId(value) {
         this._viewConfigId = value;
-
-        /*         if (value) {
-            this.defaultViewConfig = {};
-
-            const url = 'DefaultViewConfigs';
-            const filter = {where: {tableCode: value}};
-            this.$http.get(url, {filter})
-                .then(res => {
-                    if (res && res.data.length) {
-                        const columns = res.data[0].columns;
-                        this.defaultViewConfig = columns;
-                    }
-                });
-        } */
     }
 
     getDefaultViewConfig() {
@@ -163,7 +149,7 @@ export default class SmartTable extends Component {
             }
         }
 
-        let styleElement = document.querySelector('style[id="smart-table"]');
+        const styleElement = document.querySelector('style[id="smart-table"]');
 
         if (styleElement)
             styleElement.parentNode.removeChild(styleElement);
@@ -379,23 +365,33 @@ export default class SmartTable extends Component {
         for (let key of whereKeys) {
             removeProp(where, field, key);
 
-            if (!Object.keys(where))
+            if (Object.keys(where).length == 0)
                 delete userFilter.where;
         }
 
-        function removeProp(instance, findProp, prop) {
+        function removeProp(obj, targetProp, prop) {
-            if (prop == findProp)
+            if (prop == targetProp)
-                delete instance[prop];
+                delete obj[prop];
 
-            if (prop === 'and') {
+            if (prop === 'and' || prop === 'or') {
-                for (let [index, param] of instance[prop].entries()) {
+                const arrayCopy = obj[prop].slice();
+                for (let param of arrayCopy) {
                     const [key] = Object.keys(param);
-                    if (key == findProp)
+                    const index = obj[prop].findIndex(param => {
-                        instance[prop].splice(index, 1);
+                        return Object.keys(param)[0] == key;
+                    });
+                    if (key == targetProp)
+                        obj[prop].splice(index, 1);
 
                     if (param[key] instanceof Array)
                         removeProp(param, field, key);
+
+                    if (Object.keys(param).length == 0)
+                        obj[prop].splice(index, 1);
                 }
+
+                if (obj[prop].length == 0)
+                    delete obj[prop];
             }
         }
 
@@ -429,7 +425,7 @@ export default class SmartTable extends Component {
         if (!model.isChanged)
             return this.vnApp.showError(this.$t('No changes to save'));
 
-        this.model.save()
+        return this.model.save()
             .then(() => this.vnApp.showSuccess(this.$t('Data saved!')));
     }
 }

front/core/components/smart-table/index.spec.js

@@ -0,0 +1,229 @@
+describe('Component smartTable', () => {
+    let $element;
+    let controller;
+    let $httpBackend;
+
+    beforeEach(ngModule('vnCore'));
+
+    beforeEach(inject(($compile, $rootScope, _$httpBackend_) => {
+        $httpBackend = _$httpBackend_;
+        $element = $compile(`<smart-table></smart-table>`)($rootScope);
+        controller = $element.controller('smartTable');
+    }));
+
+    afterEach(() => {
+        $element.remove();
+    });
+
+    describe('options setter()', () => {
+        it(`should throw an error if the table doesn't have an identifier`, () => {
+            const options = {activeButtons: {shownColumns: []}};
+
+            expect(() => controller.options = options).toThrowError(/View identifier not defined/);
+        });
+
+        it('should not throw an error if the table does have an identifier', () => {
+            const options = {activeButtons: {shownColumns: []}};
+            controller.viewConfigId = 'test';
+
+            expect(() => controller.options = options).not.toThrow();
+        });
+    });
+
+    describe('getDefaultViewConfig()', () => {
+        it('should perform a query and return the default view columns', done => {
+            const expectedResponse = [{
+                columns: {}
+            }];
+
+            $httpBackend.expectGET('DefaultViewConfigs').respond(expectedResponse);
+            controller.getDefaultViewConfig().then(columns => {
+                expect(columns).toEqual(expectedResponse[0].columns);
+                done();
+            }).catch(done.fail);
+            $httpBackend.flush();
+        });
+    });
+
+    describe('viewConfig setter', () => {
+        it('should just call applyViewConfig() if a viewConfig was provided', () => {
+            spyOn(controller, 'applyViewConfig');
+            controller.viewConfig = [{}];
+
+            expect(controller.applyViewConfig).toHaveBeenCalled();
+        });
+
+        it('should not get a defaultConfig then insert a new one', () => {
+            spyOn(controller, 'applyViewConfig');
+
+            controller.$.userViewModel = {
+                insert: jest.fn()
+            };
+
+            const emptyResponse = [{
+                columns: {}
+            }];
+
+            controller.columns = [
+                {field: 'test1'},
+                {field: 'test2'}
+            ];
+
+            $httpBackend.expectGET('DefaultViewConfigs').respond(emptyResponse);
+            controller.viewConfig = [];
+            $httpBackend.flush();
+
+            const expectedObject = {configuration: {'test1': true, 'test2': true}};
+
+            expect(controller.$.userViewModel.insert).toHaveBeenCalledWith(expect.objectContaining(expectedObject));
+            expect(controller.applyViewConfig).toHaveBeenCalled();
+        });
+    });
+
+    describe('addFilter()', () => {
+        it('should call the model addFilter() with a basic where filter if exprBuilder() was not received', () => {
+            controller.model = {addFilter: jest.fn()};
+
+            controller.addFilter('myField', 'myValue');
+
+            const expectedFilter = {
+                where: {
+                    myField: 'myValue'
+                }
+            };
+
+            expect(controller.model.addFilter).toHaveBeenCalledWith(expectedFilter);
+        });
+
+        it('should call the model addFilter() with a built where filter resultant of exprBuilder()', () => {
+            controller.exprBuilder = jest.fn().mockReturnValue({builtField: 'builtValue'});
+            controller.model = {addFilter: jest.fn()};
+
+            controller.addFilter('myField', 'myValue');
+
+            const expectedFilter = {
+                where: {
+                    builtField: 'builtValue'
+                }
+            };
+
+            expect(controller.model.addFilter).toHaveBeenCalledWith(expectedFilter);
+        });
+    });
+
+    describe('applySort()', () => {
+        it('should call the model refresh() without making changes on the model order', () => {
+            controller.model = {refresh: jest.fn()};
+
+            controller.applySort();
+
+            expect(controller.model.order).toBeUndefined();
+            expect(controller.model.refresh).toHaveBeenCalled();
+        });
+
+        it('should call the model.refresh() after setting model order according to the controller sortCriteria', () => {
+            controller.model = {refresh: jest.fn()};
+            const orderBy = {field: 'myField', sortType: 'ASC'};
+            controller.sortCriteria = [orderBy];
+
+            controller.applySort();
+
+            expect(controller.model.order).toEqual(`${orderBy.field} ${orderBy.sortType}`);
+            expect(controller.model.refresh).toHaveBeenCalled();
+        });
+    });
+
+    describe('filterSanitizer()', () => {
+        it('should remove the where filter after leaving no fields in it', () => {
+            controller.model = {
+                userFilter: {
+                    where: {fieldToRemove: 'valueToRemove'}
+                },
+                userParams: {}
+            };
+
+            const result = controller.filterSanitizer('fieldToRemove');
+
+            const exectedObject = {userFilter: {}, userParams: {}};
+
+            expect(result).toEqual(exectedObject);
+        });
+
+        it('should remove the where filter after leaving no fields and "empty ands/ors" in it', () => {
+            controller.model = {
+                userFilter: {
+                    where: {
+                        and: [
+                            {aFieldToRemove: 'aValueToRemove'},
+                            {aFieldToRemove: 'aValueToRemove'},
+                            {
+                                or: [
+                                    {aFieldToRemove: 'aValueToRemove'},
+                                    {aFieldToRemove: 'aValueToRemove'},
+                                ]
+                            }
+                        ]
+                    }
+                },
+                userParams: {}
+            };
+
+            const result = controller.filterSanitizer('aFieldToRemove');
+
+            const exectedObject = {userFilter: {}, userParams: {}};
+
+            expect(result).toEqual(exectedObject);
+        });
+
+        it('should not remove the where filter after leaving no empty "ands/ors" in it', () => {
+            controller.model = {
+                userFilter: {
+                    where: {
+                        and: [
+                            {aFieldToRemove: 'aValueToRemove'},
+                            {aFieldToRemove: 'aValueToRemove'},
+                            {
+                                or: [
+                                    {aFieldToRemove: 'aValueToRemove'},
+                                    {aFieldToRemove: 'aValueToRemove'},
+                                ]
+                            }
+                        ],
+                        or: [{dontKillMe: 'thanks'}]
+                    }
+                },
+                userParams: {}
+            };
+
+            const result = controller.filterSanitizer('aFieldToRemove');
+
+            const exectedObject = {userFilter: {where: {or: [{dontKillMe: 'thanks'}]}}, userParams: {}};
+
+            expect(result).toEqual(exectedObject);
+        });
+    });
+
+    describe('saveAll()', () => {
+        it('should throw an error if there are no changes to save in the model', () => {
+            jest.spyOn(controller.vnApp, 'showError');
+            controller.model = {isChanged: false};
+            controller.saveAll();
+
+            expect(controller.vnApp.showError).toHaveBeenCalledWith('No changes to save');
+        });
+
+        it('should call the showSuccess() if there are changes to save in the model', done => {
+            jest.spyOn(controller.vnApp, 'showSuccess');
+
+            controller.model = {
+                save: jest.fn().mockReturnValue(Promise.resolve()),
+                isChanged: true
+            };
+
+            controller.saveAll().then(() => {
+                expect(controller.vnApp.showSuccess).toHaveBeenCalledWith('Data saved!');
+                done();
+            }).catch(done.fail);
+        });
+    });
+});

modules/monitor/front/index/tickets/index.spec.js

@@ -123,6 +123,24 @@ describe('Component vnMonitorSalesTickets', () => {
         });
     });
 
+    describe('dateRange()', () => {
+        it('should return two dates with the hours at the start and end of the given date', () => {
+            const now = new Date();
+
+            const today = now.getDate();
+
+            const dateRange = controller.dateRange(now);
+            const start = dateRange[0].toString();
+            const end = dateRange[1].toString();
+
+            expect(start).toContain(today);
+            expect(start).toContain('00:00:00');
+
+            expect(end).toContain(today);
+            expect(end).toContain('23:59:59');
+        });
+    });
+
     describe('preview()', () => {
         it('should show the dialog summary', () => {
             controller.$.summary = {show: () => {}};