[FEAT BUGFIX] adds adapterOptions ability to model.reload()

addon/-private/system/model/internal-model.js

@@ -412,13 +412,13 @@ export default class InternalModel {
     }
   }
 
-  reload() {
+  reload(options) {
     this.startedReloading();
     let internalModel = this;
     let promiseLabel = "DS: Model#reload of " + this;
 
     return new Promise(function(resolve) {
-      internalModel.send('reloadRecord', resolve);
+      internalModel.send('reloadRecord', { resolve, options });
     }, promiseLabel).then(function() {
       internalModel.didCleanError();
       return internalModel;

addon/-private/system/model/model.js

@@ -816,13 +816,23 @@ const Model = EmberObject.extend(Evented, {
     ```
 
     @method reload
-    @return {Promise} a promise that will be resolved with the record when the
+    @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter request
+
+   @return {Promise} a promise that will be resolved with the record when the
     adapter returns successfully or rejected if the adapter returns
     with an error.
   */
-  reload() {
+  reload(options) {
+    let wrappedAdapterOptions;
+
+    if (typeof options === 'object' && options !== null && options.adapterOptions) {
+      wrappedAdapterOptions = {
+        adapterOptions: options.adapterOptions
+      };
+    }
+
     return PromiseObject.create({
-      promise: this._internalModel.reload().then(() => this)
+      promise: this._internalModel.reload(wrappedAdapterOptions).then(() => this)
     });
   },
 

addon/-private/system/model/states.js

@@ -261,8 +261,8 @@ const DirtyState = {
       internalModel.transitionTo('inFlight');
     },
 
-    reloadRecord(internalModel, resolve) {
-      resolve(internalModel.store._reloadRecord(internalModel));
+    reloadRecord(internalModel, { resolve, options }) {
+      resolve(internalModel.store._reloadRecord(internalModel, options));
     },
 
     rolledBack(internalModel) {
@@ -580,8 +580,8 @@ const RootState = {
         internalModel.transitionTo('updated.inFlight');
       },
 
-      reloadRecord(internalModel, resolve) {
-        resolve(internalModel.store._reloadRecord(internalModel));
+      reloadRecord(internalModel, { resolve, options }) {
+        resolve(internalModel.store._reloadRecord(internalModel, options));
       },
 
       deleteRecord(internalModel) {

addon/-private/system/store.js

@@ -1063,17 +1063,18 @@ Store = Service.extend({
     @method reloadRecord
     @private
     @param {DS.Model} internalModel
+    @param options optional to include adapterOptions
     @return {Promise} promise
   */
-  _reloadRecord(internalModel) {
+  _reloadRecord(internalModel, options) {
     let { id, modelName } = internalModel;
     let adapter = this.adapterFor(modelName);
 
     assert(`You cannot reload a record without an ID`, id);
     assert(`You tried to reload a record but you have no adapter (for ${modelName})`, adapter);
     assert(`You tried to reload a record but your adapter does not implement 'findRecord'`, typeof adapter.findRecord === 'function' || typeof adapter.find === 'function');
 
-    return this._scheduleFetch(internalModel);
+    return this._scheduleFetch(internalModel, options);
   },
 
   /**

tests/integration/records/reload-test.js

@@ -56,6 +56,44 @@ test("When a single record is requested, the adapter's find method should be cal
   });
 });
 
+test("When a single record is requested, the adapter's find method should be called unless it's loaded.", function(assert) {
+  let count = 0;
+  let reloadOptions = {
+    adapterOptions: {
+      makeSnazzy: true
+    }
+  };
+
+  env.adapter.findRecord = function(store, type, id, snapshot) {
+    if (count === 0) {
+      count++;
+      return resolve({ data: { id: id, type: 'person', attributes: { name: "Tom Dale" } } });
+    } else if (count === 1) {
+      assert.equal(snapshot.adapterOptions, reloadOptions.adapterOptions, 'We passed adapterOptions via reload');
+      count++;
+      return resolve({ data: { id: id, type: 'person', attributes: { name: "Braaaahm Dale" } } });
+    } else {
+      assert.ok(false, "Should not get here");
+    }
+  };
+
+  run(function() {
+    env.store.findRecord('person', 1).then(function(person) {
+      assert.equal(get(person, 'name'), "Tom Dale", "The person is loaded with the right name");
+      assert.equal(get(person, 'isLoaded'), true, "The person is now loaded");
+
+      let promise = person.reload(reloadOptions);
+
+      assert.equal(get(person, 'isReloading'), true, "The person is now reloading");
+
+      return promise;
+    }).then(function(person) {
+      assert.equal(get(person, 'isReloading'), false, "The person is no longer reloading");
+      assert.equal(get(person, 'name'), "Braaaahm Dale", "The person is now updated with the right name");
+    });
+  });
+});
+
 test("When a record is reloaded and fails, it can try again", function(assert) {
   var tom;
   run(function() {