unload should invalidate async hasMany: failing test

tests/integration/records/unload-test.js

@@ -2008,3 +2008,113 @@ test('1 sync : many async unload sync side', function(assert) {
     })
   );
 });
+
+test('unload should invalidate async hasMany', function(assert) {
+  let isUnloaded = false;
+  env.adapter.coalesceFindRequests = false;
+
+  env.adapter.findRecord = (store, type, id) => {
+    assert.equal(type, Boat, 'findRecord(_, type) is correct');
+
+    if (id === '2' && isUnloaded) {
+      throw "not found";
+    }
+
+    let relationships = {
+      person: {
+        data: {
+          type: 'person',
+          id: '1'
+        }
+      }
+    };
+
+    return {
+      data: {
+        type: 'boat',
+        id: id,
+        relationships
+      }
+    }
+  };
+
+  env.adapter.findHasMany = (store, snapshot, link) => {
+    assert.equal(snapshot.modelName, 'person', 'findHasMany(_, snapshot) is correct');
+    assert.equal(link, 'boats', 'findHasMany(_, _, link) is correct');
+
+    let relationships = {
+      person: {
+        data: {
+          type: 'person',
+          id: 1
+        }
+      }
+    };
+
+    let data = [
+      {
+        id: 3,
+        type: 'boat',
+        relationships
+      }
+    ];
+
+    if (!isUnloaded) {
+      data.unshift({
+        id: 2,
+        type: 'boat',
+        relationships
+      });
+    }
+
+    return {
+      data
+    };
+  };
+
+  let person = run(() =>
+    env.store.push({
+      data: {
+        id: 1,
+        type: 'person',
+        relationships: {
+          boats: {
+            links: { related: 'boats' }
+//            data: [{
+//              id: 2,
+//              type: 'boat'
+//            },{
+//              id: 3,
+//              type: 'boat'
+//            },
+//            ]
+          }
+        }
+      }
+    })
+  );
+  let boats, boat2, boat3;
+
+  return run(() =>
+    person.get('boats').then((asyncRecords) => {
+      boats = asyncRecords;
+      [boat2, boat3] = boats.toArray();
+    }).then(() => {
+      assert.deepEqual(person.hasMany('boats').ids(), ['2', '3'], 'initially relationship established rhs');
+      assert.equal(boat2.belongsTo('person').id(), '1', 'initially relationship established rhs');
+      assert.equal(boat3.belongsTo('person').id(), '1', 'initially relationship established rhs');
+
+      isUnloaded = true;
+      run(() => boat2.unloadRecord());
+
+      assert.deepEqual(boats.mapBy('id'), ['3'], 'unloaded boat is removed from ManyArray');
+      //NOTE: uncommenting the next line fixes this test
+//      return person.hasMany('boats').reload();
+    }).then(() => {
+      assert.deepEqual(person.hasMany('boats').ids(), ['3'], 'hasMany should also only have 1 left');
+      return run(() => person.get('boats'));
+    }).then(newBoats => {
+      assert.equal(newBoats.length, 1, 'new ManyArray has only 1 boat after unload');
+    })
+  );
+});