[BUGFIX] Async relational validations resolve with fake positive (ado…

…pted-ember-addons#494)

.travis.yml

@@ -7,9 +7,8 @@ sudo: required
 dist: trusty
 
 cache:
+  yarn: true
   directories:
-    - node_modules
-    - $HOME/.npm
     - $HOME/.cache # includes bowers cache
 
 addons:
@@ -44,17 +43,17 @@ matrix:
 before_install:
   - export DISPLAY=:99.0
   - sh -e /etc/init.d/xvfb start
-  - npm config set spin false
-  - npm install -g npm@^3
+  - curl -o- -L https://yarnpkg.com/install.sh | bash
+  - export PATH=$HOME/.yarn/bin:$PATH
   - npm install -g codeclimate-test-reporter
+  - npm install -g bower
 
 install:
-  - npm install -g bower
-  - npm install
+  - yarn install --no-lockfile
   - bower install
 
 script:
-  - ember try:one $EMBER_TRY_SCENARIO --- ember test
+  - node_modules/.bin/ember try:one $EMBER_TRY_SCENARIO test --skip-cleanup
 
 after_script:
   - codeclimate-test-reporter < coverage/lcov.info

addon/validations/factory.js

@@ -568,6 +568,7 @@ function createTopLevelPropsMixin(validatableAttrs) {
      */
     __attrsResultCollection__: computed(...validatableAttrs.map((attr) => `attrs.${attr}`), function() {
       return ResultCollection.create({
+        attribute: `Model:${this}`,
         content: validatableAttrs.map((attr) => get(this, `attrs.${attr}`))
       });
     }).readOnly()
@@ -803,11 +804,11 @@ function resolveDebounce(resolve)  {
  * @param  {Object} options
  * @param  {Array} options.on Only validate the given attributes. If empty, will validate over all validatable attribute
  * @param  {Array} options.excludes Exclude validation on the given attributes
- * @param  {Boolean} async      If `false`, will get all validations and will error if an async validations is found.
+ * @param  {Boolean} isAsync      If `false`, will get all validations and will error if an async validations is found.
  *                              If `true`, will get all validations and wrap them in a promise hash
- * @return {Promise or Object}  Promise if async is true, object if async is false
+ * @return {Promise or Object}  Promise if isAsync is true, object if isAsync is false
  */
-function validate(options = {}, async = true) {
+function validate(options = {}, isAsync = true) {
   let model = get(this, 'model');
   let whiteList = makeArray(options.on);
   let blackList = makeArray(options.excludes);
@@ -821,7 +822,7 @@ function validate(options = {}, async = true) {
       let validationResult = get(this, `attrs.${name}`);
 
       // If an async validation is found, throw an error
-      if (!async && get(validationResult, 'isAsync')) {
+      if (!isAsync && get(validationResult, 'isAsync')) {
         throw new Error(`[ember-cp-validations] Synchronous validation failed due to ${name} being an async validation.`);
       }
 
@@ -832,17 +833,21 @@ function validate(options = {}, async = true) {
   }, []);
 
   let validations = ResultCollection.create({
+    attribute: `Validate:${model}`,
     content: validationResults
   });
 
   let resultObject = { model, validations };
 
-  if (async) {
-    if (get(validations, 'isAsync')) {
-      return RSVP.allSettled(makeArray(get(validations, '_promise'))).then(() => resultObject);
-    }
-
-    return Promise.resolve(resultObject);
+  if (isAsync) {
+    return Promise.resolve(get(validations, '_promise')).then(() => {
+      /*
+        NOTE: When dealing with belongsTo and hasMany relationships, there are cases
+        where we have to resolve the actual models and only then resolve all the underlying
+        validation promises. This is the reason that `validate` must be called recursively.
+       */
+      return get(validations, 'isValidating') ? this.validate(options, isAsync) : resultObject;
+    });
   }
 
   return resultObject;
@@ -883,7 +888,14 @@ function validateAttribute(attribute, value) {
 
   let result = { model, validations };
 
-  return Promise.resolve(get(validations, 'isAsync') ? get(validations, '_promise').then(() => result) : result);
+  return Promise.resolve(get(validations, '_promise')).then(() => {
+    /*
+      NOTE: When dealing with belongsTo and hasMany relationships, there are cases
+      where we have to resolve the actual models and only then resolve all the underlying
+      validation promises. This is the reason that `validateAttribute` must be called recursively.
+     */
+    return get(validations, 'isValidating') ? this.validateAttribute(attribute, value) : result;
+  });
 }
 
 /**

addon/validations/result-collection.js

@@ -338,10 +338,20 @@ export default Ember.ArrayProxy.extend({
    * @private
    * @type {Promise}
    */
-  _promise: computed('content.@each._promise', cycleBreaker(function() {
-    return RSVP.allSettled(compact(flatten(this.getEach('_promise'))));
+  _promise: computed('content.@each._promise', '_contentValidations.@each._promise', cycleBreaker(function() {
+    let promises = [ this.get('_contentValidations').getEach('_promise'), this.getEach('_promise') ];
+    return RSVP.allSettled(compact(flatten(promises)));
   })).readOnly(),
 
+  /**
+  * @property _contentValidations
+  * @type {Array}
+  * @private
+  */
+  _contentValidations: computed('content.@each._validations', function() {
+    return emberArray(compact(this.getEach('_validations')));
+  }).readOnly(),
+
   /**
    * @property _contentValidators
    * @type {Array}

addon/validators/belongs-to.js

@@ -81,11 +81,12 @@ const {
  *  @extends Base
  */
 const BelongsTo = Base.extend({
-  validate(value) {
+  validate(value, ...args) {
     if (value) {
       if (isPromise(value)) {
-        return value.then((model) => model ? get(model, 'validations') : true);
+        return value.then((model) => this.validate(model, ...args));
       }
+
       return get(value, 'validations');
     }
 
@@ -95,7 +96,12 @@ const BelongsTo = Base.extend({
 
 BelongsTo.reopenClass({
   getDependentsFor(attribute) {
-    return [ `model.${attribute}.isDeleted` ];
+    return [
+      `model.${attribute}.isDeleted`,
+      `model.${attribute}.content.isDeleted`,
+      `model.${attribute}.validations`,
+      `model.${attribute}.content.validations`
+    ];
   }
 });
 

addon/validators/has-many.js

@@ -54,11 +54,12 @@ import { isPromise } from 'ember-cp-validations/utils/utils';
  *  @extends Base
  */
 const HasMany = Base.extend({
-  validate(value) {
+  validate(value, ...args) {
     if (value) {
       if (isPromise(value)) {
-        return value.then((models) => models ? models.map((m) => m.get('validations')) : true);
+        return value.then((models) => this.validate(models, ...args));
       }
+
       return value.map((m) => m.get('validations'));
     }
 
@@ -71,7 +72,13 @@ HasMany.reopenClass({
     /*
       The [email protected] must be added for older ember-data versions
      */
-    return [ `model.${attribute}.[]`, `model.${attribute}[email protected]`, `model.${attribute}[email protected]` ];
+    return [
+      `model.${attribute}.[]`,
+      `model.${attribute}[email protected]`,
+      `model.${attribute}[email protected]`,
+      `model.${attribute}[email protected]`,
+      `model.${attribute}[email protected]`
+    ];
   }
 });
 

bower.json

@@ -1,14 +1,11 @@
 {
   "name": "ember-cp-validations",
   "dependencies": {
-    "jquery": "~2.2.4",
+    "jquery": "~2.1.4",
     "ember": "2.10.0",
     "ember-cli-shims": "~0.1.3",
     "moment": ">= 2.8.0",
     "moment-timezone": ">= 0.1.0",
     "font-awesome": "~4.5.0"
-  },
-  "devDependencies": {
-    "ember-qunit-notifications": "0.1.0"
   }
 }

tests/dummy/app/models/order-selection-question.js

@@ -26,6 +26,8 @@ const Validations = buildValidations({
       validator('presence', true)
     ]
   }
+}, {
+  debounce: 10
 });
 
 export default DS.Model.extend(Validations, {

tests/integration/validations/model-relationships-test.js

@@ -485,3 +485,101 @@ test('presence on empty DS.PromiseArray', function(assert) {
   assert.equal(friends.get('isValid'), false);
   assert.equal(friends.get('message'), 'This field can\'t be blank');
 });
+
+test('debounce should work across nested HasMany relationships', function(assert) {
+  this.register('validator:presence', PresenceValidator);
+  this.register('validator:has-many', HasManyValidator);
+
+  let done = assert.async();
+
+  let FriendValidations = buildValidations({
+    name: validator('presence', { presence: true, debounce: 50 })
+  });
+
+  let friend = setupObject(this, Ember.Object.extend(FriendValidations));
+  let user = setupObject(this, Ember.Object.extend(HasManyValidations), {
+    friends: new Ember.RSVP.Promise((resolve) => {
+      resolve([ friend ]);
+    })
+  });
+
+  user.validate().then(({ validations }) => {
+    assert.equal(friend.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(user.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValid'), false, 'User should not be valid');
+
+    friend.set('name', 'Offir');
+    return user.validate();
+
+  }).then(({ validations }) => {
+    assert.equal(friend.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(user.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValid'), true, 'User should be valid');
+    done();
+  });
+});
+
+test('debounce should work across nested BelongsTo relationships', function(assert) {
+  this.register('validator:presence', PresenceValidator);
+  this.register('validator:belongs-to', BelongsToValidator);
+
+  let done = assert.async();
+
+  let FriendValidations = buildValidations({
+    name: validator('presence', { presence: true, debounce: 50 })
+  });
+
+  let friend = setupObject(this, Ember.Object.extend(FriendValidations));
+
+  let user = setupObject(this, Ember.Object.extend(BelongsToValidations), {
+    friend: new Ember.RSVP.Promise((resolve) => {
+      resolve(friend);
+    })
+  });
+
+  user.validate().then(({ validations }) => {
+    assert.equal(friend.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(user.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValid'), false, 'User should not be valid');
+
+    friend.set('name', 'Offir');
+    return user.validate();
+
+  }).then(({ validations }) => {
+    assert.equal(friend.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(user.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValid'), true, 'User should be valid');
+    done();
+  });
+});
+
+test('Validations should work across two-way BelongsTo relationships', function(assert) {
+  this.register('validator:presence', PresenceValidator);
+  this.register('validator:belongs-to', BelongsToValidator);
+
+  let done = assert.async();
+
+  let user2 = setupObject(this, Ember.Object.extend(BelongsToValidations));
+
+  let user = setupObject(this, Ember.Object.extend(BelongsToValidations), {
+    friend: new Ember.RSVP.Promise((resolve) => {
+      resolve(user2);
+    })
+  });
+
+  user2.set('friend', new Ember.RSVP.Promise((resolve) => {
+    resolve(user);
+  }));
+
+  user.validate().then(({ validations }) => {
+    assert.equal(user.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(user2.get('validations.isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValidating'), false, 'All promises should be resolved');
+    assert.equal(validations.get('isValid'), true, 'User should be valid');
+    done();
+  });
+});