[RFR] Move PromisesResolver to ES6

src/javascripts/ng-admin/Crud/misc/PromisesResolver.js

@@ -2,55 +2,11 @@
 define(function () {
     'use strict';
 
-    function PromisesResolver($q) {
-
-        function allEvenFailed(promises) {
-            if (!Array.isArray(promises)) {
-                throw 'allEvenFailed can only handle an array of promises';
-            }
-            var deferred = $q.defer();
-            if (promises.length === 0) {
-                deferred.resolve([]);
-                return deferred.promise;
-            }
-
-            var states = [];
-            var results = [];
-
-            promises.forEach(function (promise, key) {
-                states[key] = false; // promises are not resolved by default
-            });
-
-            promises.forEach(function (promise, key) {
-                function resolve(result) {
-                    states[key] = true;
-                    results[key] = result; // result may be an error
-                    for (var i in states) {
-                        if (!states[i]) {
-                            return;
-                        }
-                    }
-                    deferred.resolve(results);
-                }
-                function resolveSuccess(result) {
-                    return resolve({ status: 'success', result: result });
-                }
-                function resolveError(result) {
-                    return resolve({ status: 'error', error: result })
-                }
-                // whether the promise ends with success or error, consider it done
-                $q.when(promise).then(resolveSuccess, resolveError);
-            });
-
-            return deferred.promise;
-        };
-
-        return {
-            allEvenFailed: allEvenFailed
-        };
+    function PromisesResolver(AdminDescription) {
+        return AdminDescription.getPromisesResolver();
     }
 
-    PromisesResolver.$inject = ['$q'];
+    PromisesResolver.$inject = ['AdminDescription'];
 
     return PromisesResolver;
 });

src/javascripts/ng-admin/es6/lib/Factory.js

@@ -1,6 +1,7 @@
 import Application from "./Application";
 import Entity from "./Entity/Entity";
 import DataStore from "./DataStore/DataStore";
+import PromisesResolver from "./Utils/PromisesResolver";
 
 import ReadQueries from "./Queries/ReadQueries";
 import WriteQueries from "./Queries/WriteQueries";
@@ -77,6 +78,10 @@ class Factory {
         return new WriteQueries(RestWrapper, PromisesResolver, Application);
     }
 
+    getPromisesResolver() {
+        return PromisesResolver;
+    }
+
     _init() {
         this.registerFieldType('boolean', BooleanField);
         this.registerFieldType('choice', ChoiceField);

src/javascripts/ng-admin/es6/lib/Utils/PromisesResolver.js

@@ -0,0 +1,48 @@
+
+class PromisesResolver {
+    static allEvenFailed(promises) {
+        if (!Array.isArray(promises)) {
+            throw Error('allEvenFailed can only handle an array of promises');
+        }
+
+        return new Promise((resolve, reject) => {
+            if (promises.length === 0) {
+                return resolve([]);
+            }
+
+            let states = [],
+                results = [];
+
+            promises.forEach((promise, key) => {
+                states[key] = false; // promises are not resolved by default
+            });
+
+            promises.forEach((promise, key) => {
+                function resolveState(result) {
+                    states[key] = true;
+                    results[key] = result; // result may be an error
+                    for (let i in states) {
+                        if (!states[i]) {
+                            return;
+                        }
+                    }
+
+                    resolve(results);
+                }
+
+                function resolveSuccess(result) {
+                    return resolveState({status: 'success', result: result});
+                }
+
+                function resolveError(result) {
+                    return resolveState({status: 'error', error: result})
+                }
+
+                // whether the promise ends with success or error, consider it done
+                promise.then(resolveSuccess, resolveError);
+            });
+        });
+    }
+}
+
+export default PromisesResolver;

src/javascripts/ng-admin/es6/tests/lib/Utils/PromisesResolverTest.js

@@ -0,0 +1,48 @@
+var assert = require('chai').assert;
+var expect = require('chai').expect;
+
+import PromisesResolver from "../../../lib/Utils/PromisesResolver";
+
+describe('PromisesResolver', () => {
+
+    describe("allEvenFailed()", () => {
+
+        it('should throw an exception when the argument is not an array', () => {
+            var error = 'allEvenFailed can only handle an array of promises';
+
+            expect(() => { PromisesResolver.allEvenFailed('nope') }).to.throw(error);
+            expect(() => { PromisesResolver.allEvenFailed() }).to.throw(error);
+            expect(() => { PromisesResolver.allEvenFailed(1) }).to.throw(error);
+        });
+
+        it('should resolve all promises', (done) => {
+            let p1Result = false,
+                p2Result = false,
+                p1 = new Promise((resolve, reject) => {
+                    resolve('p1');
+                }),
+                p2 = new Promise((resolve, reject) => {
+                    resolve('p2');
+                });
+
+            p1.then((result) => {
+                p1Result = result;
+            });
+            p2.then((result) => {
+                p2Result = result;
+            });
+
+            let result = PromisesResolver.allEvenFailed([p1, p2]);
+
+            // Check that all promises were resolved
+            result.then(() => {
+                assert.equal(p1Result, 'p1');
+                assert.equal(p2Result, 'p2');
+
+                // assert.equal does not throw an error when failing,
+                // so we use a callback that timeout in case of error
+                done();
+            });
+        });
+    });
+});

src/javascripts/ng-admin/es6/tests/lib/Utils/orderElementTest.js

@@ -2,7 +2,7 @@ var assert = require('chai').assert;
 
 import orderElement from "../../../lib/Utils/orderElement";
 
-describe('Menu', () => {
+describe('orderElement', () => {
 
     describe("order()", () => {
 

src/javascripts/test/unit/Crud/list/DatagridControllerSpec.js

@@ -13,18 +13,18 @@ define(function (require) {
             entries = [
                 new Entry('my_entity', {value: 1}, 1),
                 new Entry('my_entity', {value: 2}, 2),
-                new Entry('my_entity', {value: 3}, 3),
+                new Entry('my_entity', {value: 3}, 3)
             ];
 
             dataGridController = new DataGridController({
+                listActions: function() {
+                    return [];
+                },
                 entity: function () {
                     return new Entity('my_entity');
                 },
                 entries: entries,
-                selection: [],
-                listActions: function () {
-                    return [];
-                }
+                selection: []
             }, {
                 search: function () {
                     return {};