feat(service): handle flash object preventDuplicates similar to global option (#282)

fixes #281

Author: makepanic

addon/services/flash-messages.js

@@ -88,6 +88,8 @@ export default Service.extend({
   _newFlashMessage(options = {}) {
     assert('The flash message cannot be empty when preventDuplicates is enabled.',
         get(this, 'defaultPreventDuplicates') ? options.message : true);
+    assert('The flash message cannot be empty when preventDuplicates is enabled.',
+        get(options, 'preventDuplicates') ? options.message : true);
 
     const flashService = this;
     const allDefaults = getWithDefault(this, 'flashMessageDefaults', {});
@@ -155,7 +157,11 @@ export default Service.extend({
   },
 
   _enqueue(flashInstance) {
-    const preventDuplicates = get(this, 'defaultPreventDuplicates');
+    const instancePreventDuplicates = get(flashInstance, 'preventDuplicates');
+    const preventDuplicates = typeof instancePreventDuplicates === 'boolean' ?
+      // always prefer instance option over global option
+      instancePreventDuplicates :
+      get(this, 'defaultPreventDuplicates');
 
     if (preventDuplicates) {
       const guid = get(flashInstance, '_guid');

addon/utils/computed.js

@@ -2,6 +2,7 @@ import { typeOf } from '@ember/utils';
 import { computed, get } from '@ember/object';
 import { guidFor as emberGuidFor } from '@ember/object/internals';
 import { A as emberArray } from '@ember/array';
+import { isNone } from '@ember/utils';
 
 export function add(...dependentKeys) {
   const computedFunc = computed({
@@ -30,6 +31,10 @@ export function guidFor(dependentKey) {
     get() {
       const value = get(this, dependentKey);
 
+      // it's possible that a value has no toString as some objects don't implement the guid field
+      // this early return it to avoid errors being thrown when calling undefined.toString()
+      if (isNone(value)) return;
+
       return emberGuidFor(value.toString());
     }
   });

tests/unit/services/flash-messages-test.js

@@ -184,6 +184,17 @@ module('FlashMessagesService', function(hooks) {
     );
   });
 
+  test('when preventDuplicates is `false` but flashInstance preventDuplicates is `true` setting a message is not required', function(assert) {
+    set(service, 'defaultPreventDuplicates', false);
+
+    assert.throws(() => {
+        service.add({ preventDuplicates: true });
+      },
+      new EmberError('Assertion Failed: The flash message cannot be empty when preventDuplicates is enabled.'),
+      'Error is thrown'
+    );
+  });
+
   test('it adds duplicate messages to the queue if preventDuplicates is `false`', function(assert) {
     set(service, 'defaultPreventDuplicates', false);
     const expectedResult = emberArray([ 'foo', 'foo', 'bar' ]);
@@ -205,6 +216,43 @@ module('FlashMessagesService', function(hooks) {
     assert.equal(get(service, 'queue').length, 2, 'it does not add duplicate messages to the queue');
   });
 
+  test('it does not add duplicate messages to the queue if flashInstance preventDuplicates is `true`', function(assert) {
+    set(service, 'defaultPreventDuplicates', false);
+    const messages = emberArray([ 'foo', 'foo', 'bar' ]);
+    const expectedResult = messages.uniq();
+    messages.forEach((message) => service.success(message, {preventDuplicates: true}));
+    const result = get(service, 'queue').mapBy('message');
+
+    assert.deepEqual(result, expectedResult, 'it does not add duplicate messages to the queue');
+    assert.equal(get(service, 'queue').length, 2, 'it does not add duplicate messages to the queue');
+  });
+
+  test('flashInstance preventDuplicates prefers instance preventDuplicates over global', function(assert) {
+    set(service, 'defaultPreventDuplicates', true);
+    const messages = emberArray([ 'foo', 'foo', 'bar' ]);
+    const expectedResult = [ 'foo', 'foo', 'bar' ];
+    messages.forEach((message) => service.success(message, {preventDuplicates: false}));
+    const result = get(service, 'queue').mapBy('message');
+
+    assert.deepEqual(result, expectedResult, 'it adds duplicate messages to the queue');
+    assert.equal(get(service, 'queue').length, 3, 'it adds duplicate messages to the queue');
+  });
+
+  test('it does use the global preventDuplicates if the instance option isn\'t set', function(assert) {
+    set(service, 'defaultPreventDuplicates', false);
+    service.success('foo');
+    service.success('foo');
+    service.success('bar', {preventDuplicates: true});
+    service.success('bar', {preventDuplicates: true});
+    service.success('foo');
+    service.success('baz', {preventDuplicates: true});
+
+    const result = get(service, 'queue').mapBy('message');
+
+    assert.deepEqual(result, ['foo', 'foo', 'bar', 'foo', 'baz'], 'it adds duplicated messages if preventDuplicates isn\'t set');
+    assert.equal(get(service, 'queue').length, 5, 'it handles duplicates where preventDuplicates is false');
+  });
+
   test('it supports chaining', function(assert) {
     service
       .registerTypes(['meow'])