refactor

src/Business/lu-busy-business.js

@@ -0,0 +1,113 @@
+/**
+ * Created by robin on 10/24/15.
+ */
+
+(function () {
+    'use strict';
+    angular.module('luticate2Utils')
+        .factory('luBusyBusiness', [function() {
+
+            var luBusyBusiness = {};
+            luBusyBusiness.promises = {};
+            luBusyBusiness.loaders = [];
+            luBusyBusiness.errors = [];
+
+            luBusyBusiness.STATUS_RUNNING = 0;
+            luBusyBusiness.STATUS_RESOLVED = 1;
+            luBusyBusiness.STATUS_REJECTED = 2;
+
+            luBusyBusiness.build = function(array)
+            {
+                luBusyBusiness[array] = {};
+                for (var id in luBusyBusiness.promises) {
+                    if (luBusyBusiness.promises.hasOwnProperty(id)) {
+                        var promise = luBusyBusiness.promises[id];
+                        promise[array].forEach(function (group) {
+                            if (luBusyBusiness[array][group] == null) {
+                                luBusyBusiness[array][group] = [];
+                            }
+                            luBusyBusiness[array][group].push(promise);
+                        });
+                    }
+                }
+            };
+
+            luBusyBusiness.newPromise = function(id, groups, loaderGroups, errorGroups) {
+                return {
+                    id: id,
+                    groups: groups,
+                    loaderGroups: loaderGroups,
+                    errorGroups: errorGroups
+                };
+            };
+
+            luBusyBusiness.initLuBusy = function(data) {
+                var p = {
+                    loaders : [],
+                    errors: [],
+                    status: luBusyBusiness.STATUS_RUNNING,
+                    id: data.id
+                };
+
+                if (data.groups instanceof Array) {
+                    data.groups.forEach(function (group) {
+                        p.loaders.push(group);
+                        p.errors.push(group);
+                    });
+                }
+                else if (typeof data.groups === 'string') {
+                    p.loaders.push(data.groups);
+                    p.errors.push(data.groups);
+                }
+
+                if (data.loaderGroups instanceof Array) {
+                    data.loaderGroups.forEach(function (group) {
+                        p.loaders.push(group);
+                    });
+                }
+                else if (typeof data.loaderGroups === 'string') {
+                    p.loaders.push(data.loaderGroups);
+                }
+
+                if (data.errorGroups instanceof Array) {
+                    data.errorGroups.forEach(function (group) {
+                        p.errors.push(group);
+                    });
+                }
+                else if (typeof data.errorGroups === 'string') {
+                    p.errors.push(data.errorGroups);
+                }
+
+                luBusyBusiness.promises[data.id] = p;
+
+                luBusyBusiness.build("loaders");
+                luBusyBusiness.build("errors");
+            };
+
+            luBusyBusiness.getLoadersGroup = function(group) {
+                if (luBusyBusiness.loaders[group] == null) {
+                    return null;
+                }
+                return luBusyBusiness.loaders[group];
+            };
+
+            luBusyBusiness.getErrorsGroup = function(group) {
+                if (luBusyBusiness.errors[group] == null) {
+                    return null;
+                }
+                return luBusyBusiness.errors[group];
+            };
+
+            luBusyBusiness.reject = function(promise, error) {
+                luBusyBusiness.promises[promise.id].status = luBusyBusiness.STATUS_REJECTED;
+                luBusyBusiness.promises[promise.id].value = error;
+            };
+
+            luBusyBusiness.resolve = function(promise, data) {
+                luBusyBusiness.promises[promise.id].status = luBusyBusiness.STATUS_RESOLVED;
+                luBusyBusiness.promises[promise.id].value = data;
+            };
+
+            return luBusyBusiness;
+        }]);
+})();

src/Business/lu-promise.js

@@ -1,113 +0,0 @@
-/**
- * Created by robin on 10/24/15.
- */
-
-(function () {
-    'use strict';
-    angular.module('luticate2Utils')
-        .factory('luPromise', [function() {
-
-            var luPromise = {};
-            luPromise.promises = {};
-            luPromise.loaders = [];
-            luPromise.errors = [];
-
-            luPromise.STATUS_RUNNING = 0;
-            luPromise.STATUS_RESOLVED = 1;
-            luPromise.STATUS_REJECTED = 2;
-
-            luPromise.build = function(array)
-            {
-                luPromise[array] = {};
-                for (var id in luPromise.promises) {
-                    if (luPromise.promises.hasOwnProperty(id)) {
-                        var promise = luPromise.promises[id];
-                        promise[array].forEach(function (group) {
-                            if (luPromise[array][group] == null) {
-                                luPromise[array][group] = [];
-                            }
-                            luPromise[array][group].push(promise);
-                        });
-                    }
-                }
-            };
-
-            luPromise.newPromise = function(id, groups, loaderGroups, errorGroups) {
-                return {
-                    id: id,
-                    groups: groups,
-                    loaderGroups: loaderGroups,
-                    errorGroups: errorGroups
-                };
-            };
-
-            luPromise.initPromise = function(data) {
-                var p = {
-                    loaders : [],
-                    errors: [],
-                    status: luPromise.STATUS_RUNNING,
-                    id: data.id
-                };
-
-                if (data.groups instanceof Array) {
-                    data.groups.forEach(function (group) {
-                        p.loaders.push(group);
-                        p.errors.push(group);
-                    });
-                }
-                else if (typeof data.groups === 'string') {
-                    p.loaders.push(data.groups);
-                    p.errors.push(data.groups);
-                }
-
-                if (data.loaderGroups instanceof Array) {
-                    data.loaderGroups.forEach(function (group) {
-                        p.loaders.push(group);
-                    });
-                }
-                else if (typeof data.loaderGroups === 'string') {
-                    p.loaders.push(data.loaderGroups);
-                }
-
-                if (data.errorGroups instanceof Array) {
-                    data.errorGroups.forEach(function (group) {
-                        p.errors.push(group);
-                    });
-                }
-                else if (typeof data.errorGroups === 'string') {
-                    p.errors.push(data.errorGroups);
-                }
-
-                luPromise.promises[data.id] = p;
-
-                luPromise.build("loaders");
-                luPromise.build("errors");
-            };
-
-            luPromise.getLoadersGroup = function(group) {
-                if (luPromise.loaders[group] == null) {
-                    return null;
-                }
-                return luPromise.loaders[group];
-            };
-
-            luPromise.getErrorsGroup = function(group) {
-                if (luPromise.errors[group] == null) {
-                    return null;
-                }
-                return luPromise.errors[group];
-            };
-
-            luPromise.reject = function(promise, error) {
-                luPromise.promises[promise.id].status = luPromise.STATUS_REJECTED;
-                luPromise.promises[promise.id].value = error;
-            };
-
-            luPromise.resolve = function(promise, data) {
-                luPromise.promises[promise.id].status = luPromise.STATUS_RESOLVED;
-                luPromise.promises[promise.id].value = data;
-            };
-
-            return luPromise;
-        }]);
-})();

src/DataAccess/lu-request.js

@@ -5,54 +5,54 @@
 (function () {
     'use strict';
     angular.module('luticate2Utils')
-        .factory('luRequest', ['$q', '$http', 'luPromise', function ($q, $http, luPromise) {
+        .factory('luRequest', ['$q', '$http', 'luBusyBusiness', function ($q, $http, luBusyBusiness) {
 
             var luRequest = {};
 
-            luRequest.get = function(url, dataGet, promise)
+            luRequest.get = function(url, dataGet, luBusyDbo)
             {
-                return luRequest.request(url, 'GET', dataGet, null, promise);
+                return luRequest.request(url, 'GET', dataGet, null, luBusyDbo);
             };
 
-            luRequest.post = function(url, dataGet, dataPost, promise)
+            luRequest.post = function(url, dataGet, dataPost, luBusyDbo)
             {
-                return luRequest.request(url, 'POST', dataGet, dataPost, promise);
+                return luRequest.request(url, 'POST', dataGet, dataPost, luBusyDbo);
             };
 
-            luRequest.put = function(url, dataGet, dataPost, promise)
+            luRequest.put = function(url, dataGet, dataPost, luBusyDbo)
             {
-                return luRequest.request(url, 'PUT', dataGet, dataPost, promise);
+                return luRequest.request(url, 'PUT', dataGet, dataPost, luBusyDbo);
             };
 
-            luRequest.delete = function(url, dataGet, dataPost, promise)
+            luRequest.delete = function(url, dataGet, dataPost, luBusyDbo)
             {
-                return luRequest.request(url, 'DELETE', dataGet, dataPost, promise);
+                return luRequest.request(url, 'DELETE', dataGet, dataPost, luBusyDbo);
             };
 
-            function reject(deferred, data, status, promise)
+            function reject(deferred, data, status, luBusyDbo)
             {
                 var obj = {
                     Data: data,
                     Status: status
                 };
                 deferred.reject(obj);
-                if (promise != null) {
-                    luPromise.reject(promise, obj);
+                if (luBusyDbo != null) {
+                    luBusyBusiness.reject(luBusyDbo, obj);
                 }
             }
 
-            function resolve(deferred, data, promise)
+            function resolve(deferred, data, luBusyDbo)
             {
                 deferred.resolve(data);
-                if (promise != null) {
-                    luPromise.resolve(promise, data);
+                if (luBusyDbo != null) {
+                    luBusyBusiness.resolve(luBusyDbo, data);
                 }
             }
 
-            luRequest.request = function(url, method, dataGet, dataPost, promise)
+            luRequest.request = function(url, method, dataGet, dataPost, luBusyDbo)
             {
-                if (promise != null) {
-                    luPromise.initPromise(promise);
+                if (luBusyDbo != null) {
+                    luBusyBusiness.initLuBusy(luBusyDbo);
                 }
                 var deferred = $q.defer();
 
@@ -72,19 +72,19 @@
                     .success(function (result, status) {
                         if (result == null || result.Message != null) {
                             var message = result == null ? "Failed to parse response" : result.Message;
-                            reject(deferred, message, status, promise);
+                            reject(deferred, message, status, luBusyDbo);
                         }
                         else {
-                            resolve(deferred, result.Data, promise);
+                            resolve(deferred, result.Data, luBusyDbo);
                         }
                     })
                     .error(function (result, status) {
                         if (result == null || result.Message != null) {
                             var message = result == null ? "Failed to parse response" : result.Message;
-                            reject(deferred, message, status, promise);
+                            reject(deferred, message, status, luBusyDbo);
                         }
                         else {
-                            reject(deferred, result, status, promise);
+                            reject(deferred, result, status, luBusyDbo);
                         }
                     });
                 return deferred.promise;

tests/Business/lu-busy-business.spec.js

@@ -0,0 +1,137 @@
+/**
+ * Created by robin on 12/11/16.
+ */
+
+describe('lu-promise factory', function() {
+    var luBusyBusiness;
+
+    // Before each test load our api.users module
+    beforeEach(angular.mock.module('luticate2Utils'));
+
+    // Before each test set our injected Users factory (_Users_) to our local Users variable
+    beforeEach(inject(function(_luBusyBusiness_) {
+        luBusyBusiness = _luBusyBusiness_;
+    }));
+
+    it('should init a simple promise', function()
+    {
+        var p  = luBusyBusiness.newPromise('my-id', 'all-groups', 'loader-groups', 'error-groups');
+        luBusyBusiness.initPromise(p);
+        expect(Object.keys(luBusyBusiness.promises).length).toEqual(1);
+
+        var d = luBusyBusiness.promises['my-id'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['all-groups', 'loader-groups']);
+        expect(d.errors).toEqual(['all-groups', 'error-groups']);
+        expect(d.status).toBe(luBusyBusiness.STATUS_RUNNING);
+        expect(d.id).toBe('my-id');
+
+        expect(Object.keys(luBusyBusiness.errors).length).toEqual(2);
+        expect(luBusyBusiness.errors['all-groups'].length).toEqual(1);
+        expect(luBusyBusiness.errors['all-groups'][0]['id']).toEqual('my-id');
+        expect(luBusyBusiness.errors['error-groups'].length).toEqual(1);
+        expect(luBusyBusiness.errors['error-groups'][0]['id']).toEqual('my-id');
+
+        expect(Object.keys(luBusyBusiness.loaders).length).toEqual(2);
+        expect(luBusyBusiness.loaders['all-groups'].length).toEqual(1);
+        expect(luBusyBusiness.loaders['all-groups'][0]['id']).toEqual('my-id');
+        expect(luBusyBusiness.loaders['loader-groups'].length).toEqual(1);
+        expect(luBusyBusiness.loaders['loader-groups'][0]['id']).toEqual('my-id');
+    });
+
+    it('should init a more complex promise 1', function()
+    {
+        var p  = luBusyBusiness.newPromise('my-id', ['all-groups', 'another-group'], 'loader-groups');
+        luBusyBusiness.initPromise(p);
+        expect(Object.keys(luBusyBusiness.promises).length).toEqual(1);
+
+        var d = luBusyBusiness.promises['my-id'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['all-groups', 'another-group', 'loader-groups']);
+        expect(d.errors).toEqual(['all-groups', 'another-group']);
+        expect(d.status).toBe(luBusyBusiness.STATUS_RUNNING);
+        expect(d.id).toBe('my-id');
+
+        expect(Object.keys(luBusyBusiness.errors).length).toEqual(2);
+        expect(luBusyBusiness.errors['all-groups'].length).toEqual(1);
+        expect(luBusyBusiness.errors['all-groups'][0]['id']).toEqual('my-id');
+        expect(luBusyBusiness.errors['another-group'].length).toEqual(1);
+        expect(luBusyBusiness.errors['another-group'][0]['id']).toEqual('my-id');
+
+        expect(Object.keys(luBusyBusiness.loaders).length).toEqual(3);
+        expect(luBusyBusiness.loaders['all-groups'].length).toEqual(1);
+        expect(luBusyBusiness.loaders['all-groups'][0]['id']).toEqual('my-id');
+        expect(luBusyBusiness.loaders['another-group'].length).toEqual(1);
+        expect(luBusyBusiness.loaders['another-group'][0]['id']).toEqual('my-id');
+        expect(luBusyBusiness.loaders['loader-groups'].length).toEqual(1);
+        expect(luBusyBusiness.loaders['loader-groups'][0]['id']).toEqual('my-id');
+    });
+
+    it('should init a more complex promise 2', function()
+    {
+        var p  = luBusyBusiness.newPromise('my-id', null, 'loader-groups');
+        luBusyBusiness.initPromise(p);
+        expect(Object.keys(luBusyBusiness.promises).length).toEqual(1);
+
+        var d = luBusyBusiness.promises['my-id'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['loader-groups']);
+        expect(d.errors).toEqual([]);
+        expect(d.status).toBe(luBusyBusiness.STATUS_RUNNING);
+        expect(d.id).toBe('my-id');
+
+        expect(Object.keys(luBusyBusiness.errors).length).toEqual(0);
+
+        expect(Object.keys(luBusyBusiness.loaders).length).toEqual(1);
+        expect(luBusyBusiness.loaders['loader-groups'].length).toEqual(1);
+        expect(luBusyBusiness.loaders['loader-groups'][0]['id']).toEqual('my-id');
+    });
+
+    it('should init multiple more complex promise 1', function()
+    {
+        var p1  = luBusyBusiness.newPromise('my-id', ['all-groups', 'another-group'], 'loader-groups');
+        luBusyBusiness.initPromise(p1);
+        var p2  = luBusyBusiness.newPromise('my-id2', ['all-groups', 'another-group'], null, 'an-error-group');
+        luBusyBusiness.initPromise(p2);
+        expect(Object.keys(luBusyBusiness.promises).length).toEqual(2);
+
+        var d = luBusyBusiness.promises['my-id'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['all-groups', 'another-group', 'loader-groups']);
+        expect(d.errors).toEqual(['all-groups', 'another-group']);
+        expect(d.status).toBe(luBusyBusiness.STATUS_RUNNING);
+        expect(d.id).toBe('my-id');
+
+        d = luBusyBusiness.promises['my-id2'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['all-groups', 'another-group']);
+        expect(d.errors).toEqual(['all-groups', 'another-group', 'an-error-group']);
+        expect(d.status).toBe(luBusyBusiness.STATUS_RUNNING);
+        expect(d.id).toBe('my-id2');
+
+        expect(Object.keys(luBusyBusiness.errors).length).toEqual(3);
+        expect(luBusyBusiness.errors['all-groups'].length).toEqual(2);
+        expect(luBusyBusiness.errors['all-groups'][0]['id']).toEqual('my-id');
+        expect(luBusyBusiness.errors['all-groups'][1]['id']).toEqual('my-id2');
+        expect(luBusyBusiness.errors['another-group'].length).toEqual(2);
+        expect(luBusyBusiness.errors['another-group'][0]['id']).toEqual('my-id');
+        expect(luBusyBusiness.errors['another-group'][1]['id']).toEqual('my-id2');
+        expect(luBusyBusiness.errors['an-error-group'].length).toEqual(1);
+        expect(luBusyBusiness.errors['an-error-group'][0]['id']).toEqual('my-id2');
+
+        expect(Object.keys(luBusyBusiness.loaders).length).toEqual(3);
+        expect(luBusyBusiness.loaders['all-groups'].length).toEqual(2);
+        expect(luBusyBusiness.loaders['all-groups'][0]['id']).toEqual('my-id');
+        expect(luBusyBusiness.loaders['all-groups'][1]['id']).toEqual('my-id2');
+        expect(luBusyBusiness.loaders['another-group'].length).toEqual(2);
+        expect(luBusyBusiness.loaders['another-group'][0]['id']).toEqual('my-id');
+        expect(luBusyBusiness.loaders['another-group'][1]['id']).toEqual('my-id2');
+        expect(luBusyBusiness.loaders['loader-groups'].length).toEqual(1);
+        expect(luBusyBusiness.loaders['loader-groups'][0]['id']).toEqual('my-id');
+    });
+});

tests/Business/lu-promise.spec.js

@@ -1,137 +0,0 @@
-/**
- * Created by robin on 12/11/16.
- */
-
-describe('lu-promise factory', function() {
-    var luPromise;
-
-    // Before each test load our api.users module
-    beforeEach(angular.mock.module('luticate2Utils'));
-
-    // Before each test set our injected Users factory (_Users_) to our local Users variable
-    beforeEach(inject(function(_luPromise_) {
-        luPromise = _luPromise_;
-    }));
-
-    it('should init a simple promise', function()
-    {
-        var p  = luPromise.newPromise('my-id', 'all-groups', 'loader-groups', 'error-groups');
-        luPromise.initPromise(p);
-        expect(Object.keys(luPromise.promises).length).toEqual(1);
-
-        var d = luPromise.promises['my-id'];
-        expect(d).not.toBe(null);
-        expect(d).not.toBe(undefined);
-        expect(d.loaders).toEqual(['all-groups', 'loader-groups']);
-        expect(d.errors).toEqual(['all-groups', 'error-groups']);
-        expect(d.status).toBe(luPromise.STATUS_RUNNING);
-        expect(d.id).toBe('my-id');
-
-        expect(Object.keys(luPromise.errors).length).toEqual(2);
-        expect(luPromise.errors['all-groups'].length).toEqual(1);
-        expect(luPromise.errors['all-groups'][0]['id']).toEqual('my-id');
-        expect(luPromise.errors['error-groups'].length).toEqual(1);
-        expect(luPromise.errors['error-groups'][0]['id']).toEqual('my-id');
-
-        expect(Object.keys(luPromise.loaders).length).toEqual(2);
-        expect(luPromise.loaders['all-groups'].length).toEqual(1);
-        expect(luPromise.loaders['all-groups'][0]['id']).toEqual('my-id');
-        expect(luPromise.loaders['loader-groups'].length).toEqual(1);
-        expect(luPromise.loaders['loader-groups'][0]['id']).toEqual('my-id');
-    });
-
-    it('should init a more complex promise 1', function()
-    {
-        var p  = luPromise.newPromise('my-id', ['all-groups', 'another-group'], 'loader-groups');
-        luPromise.initPromise(p);
-        expect(Object.keys(luPromise.promises).length).toEqual(1);
-
-        var d = luPromise.promises['my-id'];
-        expect(d).not.toBe(null);
-        expect(d).not.toBe(undefined);
-        expect(d.loaders).toEqual(['all-groups', 'another-group', 'loader-groups']);
-        expect(d.errors).toEqual(['all-groups', 'another-group']);
-        expect(d.status).toBe(luPromise.STATUS_RUNNING);
-        expect(d.id).toBe('my-id');
-
-        expect(Object.keys(luPromise.errors).length).toEqual(2);
-        expect(luPromise.errors['all-groups'].length).toEqual(1);
-        expect(luPromise.errors['all-groups'][0]['id']).toEqual('my-id');
-        expect(luPromise.errors['another-group'].length).toEqual(1);
-        expect(luPromise.errors['another-group'][0]['id']).toEqual('my-id');
-
-        expect(Object.keys(luPromise.loaders).length).toEqual(3);
-        expect(luPromise.loaders['all-groups'].length).toEqual(1);
-        expect(luPromise.loaders['all-groups'][0]['id']).toEqual('my-id');
-        expect(luPromise.loaders['another-group'].length).toEqual(1);
-        expect(luPromise.loaders['another-group'][0]['id']).toEqual('my-id');
-        expect(luPromise.loaders['loader-groups'].length).toEqual(1);
-        expect(luPromise.loaders['loader-groups'][0]['id']).toEqual('my-id');
-    });
-
-    it('should init a more complex promise 2', function()
-    {
-        var p  = luPromise.newPromise('my-id', null, 'loader-groups');
-        luPromise.initPromise(p);
-        expect(Object.keys(luPromise.promises).length).toEqual(1);
-
-        var d = luPromise.promises['my-id'];
-        expect(d).not.toBe(null);
-        expect(d).not.toBe(undefined);
-        expect(d.loaders).toEqual(['loader-groups']);
-        expect(d.errors).toEqual([]);
-        expect(d.status).toBe(luPromise.STATUS_RUNNING);
-        expect(d.id).toBe('my-id');
-
-        expect(Object.keys(luPromise.errors).length).toEqual(0);
-
-        expect(Object.keys(luPromise.loaders).length).toEqual(1);
-        expect(luPromise.loaders['loader-groups'].length).toEqual(1);
-        expect(luPromise.loaders['loader-groups'][0]['id']).toEqual('my-id');
-    });
-
-    it('should init multiple more complex promise 1', function()
-    {
-        var p1  = luPromise.newPromise('my-id', ['all-groups', 'another-group'], 'loader-groups');
-        luPromise.initPromise(p1);
-        var p2  = luPromise.newPromise('my-id2', ['all-groups', 'another-group'], null, 'an-error-group');
-        luPromise.initPromise(p2);
-        expect(Object.keys(luPromise.promises).length).toEqual(2);
-
-        var d = luPromise.promises['my-id'];
-        expect(d).not.toBe(null);
-        expect(d).not.toBe(undefined);
-        expect(d.loaders).toEqual(['all-groups', 'another-group', 'loader-groups']);
-        expect(d.errors).toEqual(['all-groups', 'another-group']);
-        expect(d.status).toBe(luPromise.STATUS_RUNNING);
-        expect(d.id).toBe('my-id');
-
-        d = luPromise.promises['my-id2'];
-        expect(d).not.toBe(null);
-        expect(d).not.toBe(undefined);
-        expect(d.loaders).toEqual(['all-groups', 'another-group']);
-        expect(d.errors).toEqual(['all-groups', 'another-group', 'an-error-group']);
-        expect(d.status).toBe(luPromise.STATUS_RUNNING);
-        expect(d.id).toBe('my-id2');
-
-        expect(Object.keys(luPromise.errors).length).toEqual(3);
-        expect(luPromise.errors['all-groups'].length).toEqual(2);
-        expect(luPromise.errors['all-groups'][0]['id']).toEqual('my-id');
-        expect(luPromise.errors['all-groups'][1]['id']).toEqual('my-id2');
-        expect(luPromise.errors['another-group'].length).toEqual(2);
-        expect(luPromise.errors['another-group'][0]['id']).toEqual('my-id');
-        expect(luPromise.errors['another-group'][1]['id']).toEqual('my-id2');
-        expect(luPromise.errors['an-error-group'].length).toEqual(1);
-        expect(luPromise.errors['an-error-group'][0]['id']).toEqual('my-id2');
-
-        expect(Object.keys(luPromise.loaders).length).toEqual(3);
-        expect(luPromise.loaders['all-groups'].length).toEqual(2);
-        expect(luPromise.loaders['all-groups'][0]['id']).toEqual('my-id');
-        expect(luPromise.loaders['all-groups'][1]['id']).toEqual('my-id2');
-        expect(luPromise.loaders['another-group'].length).toEqual(2);
-        expect(luPromise.loaders['another-group'][0]['id']).toEqual('my-id');
-        expect(luPromise.loaders['another-group'][1]['id']).toEqual('my-id2');
-        expect(luPromise.loaders['loader-groups'].length).toEqual(1);
-        expect(luPromise.loaders['loader-groups'][0]['id']).toEqual('my-id');
-    });
-});