ember-inspector 4.4.1 → 4.5.0

package/tests/acceptance/component-tree-test.js

@@ -209,6 +209,8 @@ module('Component Tab', function (hooks) {
   });
 
   test('It allows users to navigate nodes with arrow keys', async function (assert) {
+    assert.expect(3);
+
     await visit('/component-tree');
 
     // select first node with down arrow key
@@ -329,11 +331,13 @@ module('Component Tab', function (hooks) {
   });
 
   test('Previewing / showing a view on the client', async function (assert) {
+    assert.expect(2);
+
     await visit('/component-tree');
 
     respondWith('view:showInspection', ({ id, pin }) => {
       assert.equal(id, 'render-node:1', 'application route');
-      assert.strictEqual(pin, false, 'preview only');
+      assert.false(pin, 'preview only');
       return false;
     });
 
@@ -345,6 +349,8 @@ module('Component Tab', function (hooks) {
   });
 
   test('Scrolling an element into view', async function (assert) {
+    assert.expect(1);
+
     await visit('/component-tree');
 
     respondWith('view:scrollIntoView', ({ id }) => {
@@ -356,6 +362,8 @@ module('Component Tab', function (hooks) {
   });
 
   test('View DOM element in Elements panel', async function (assert) {
+    assert.expect(1);
+
     await visit('/component-tree');
 
     respondWith('view:inspectElement', ({ id }) => {
@@ -367,11 +375,13 @@ module('Component Tab', function (hooks) {
   });
 
   test('Inspects the component in the object inspector on click and shows tooltip', async function (assert) {
+    assert.expect(3);
+
     await visit('/component-tree');
 
     respondWith('view:showInspection', ({ id, pin }) => {
       assert.equal(id, 'render-node:3', '<TodoList>');
-      assert.strictEqual(pin, true, 'pin');
+      assert.true(pin, 'pin');
       return false;
     });
 
@@ -388,12 +398,14 @@ module('Component Tab', function (hooks) {
   });
 
   test('Selects a component in the tree in response to a message from the context menu', async function (assert) {
+    assert.expect(5);
+
     // Go to the component tree and populate it before sending the message from the context menu
     await visit('/component-tree');
 
     respondWith('view:showInspection', ({ id, pin }) => {
       assert.equal(id, 'render-node:3', '<TodoList>');
-      assert.strictEqual(pin, true, 'pin');
+      assert.true(pin, 'pin');
       return false;
     });
 
@@ -425,6 +437,8 @@ module('Component Tab', function (hooks) {
   });
 
   test('Can inspect component arguments that are objects in component tree', async function (assert) {
+    assert.expect(1);
+
     await visit('/component-tree');
 
     respondWith('objectInspector:inspectById', ({ objectId }) => {

package/tests/acceptance/container-test.js

@@ -1,7 +1,7 @@
-import Ember from 'ember';
+import TestAdapter from '@ember/test/adapter';
 import { module, test } from 'qunit';
 import { setupApplicationTest } from 'ember-qunit';
-import { visit, findAll, click, fillIn, currentURL } from 'ember-test-helpers';
+import { visit, findAll, click, fillIn, currentURL } from '@ember/test-helpers';
 import { setupTestAdapter, respondWith } from '../test-adapter';
 
 function getTypes() {
@@ -161,6 +161,8 @@ module('Container Tab', function (outer) {
     });
 
     test('Successfully redirects if the container type is not found', async function (assert) {
+      assert.expect(1);
+
       respondWith('container:getInstances', ({ containerType }) => {
         if (containerType === 'random-type') {
           return {
@@ -170,13 +172,13 @@ module('Container Tab', function (outer) {
         }
       });
 
-      let adapterException = Ember.Test.adapter.exception;
+      let adapterException = TestAdapter.exception;
 
       // Failed route causes a promise unhandled rejection
       // even though there's an `error` action defined :(
-      Ember.Test.adapter.exception = (err) => {
+      TestAdapter.exception = (err) => {
         if (!err || err.status !== 404) {
-          return adapterException.call(Ember.Test.adapter, err);
+          return adapterException.call(TestAdapter, err);
         }
       };
 
@@ -184,7 +186,7 @@ module('Container Tab', function (outer) {
         await visit('/container-types/random-type');
         assert.equal(currentURL(), '/container-types');
       } finally {
-        Ember.Test.adapter.exception = adapterException;
+        TestAdapter.exception = adapterException;
       }
     });
   });

package/tests/acceptance/data-test.js

@@ -259,6 +259,8 @@ module('Data Tab', function (outer) {
     });
 
     test('Can inspect store in data pane', async function (assert) {
+      assert.expect(1);
+
       respondWith('data:getModelTypes', {
         type: 'data:modelTypesAdded',
         modelTypes: getModelTypes(),

package/tests/acceptance/deprecation-test.js

@@ -90,6 +90,8 @@ module('Deprecation Tab', function (outer) {
     });
 
     test('No source map', async function (assert) {
+      assert.expect(6);
+
       await visit('/deprecations');
 
       await toggleDeprecationSource();
@@ -129,6 +131,8 @@ module('Deprecation Tab', function (outer) {
     });
 
     test("With source map, source found, can't open resource", async function (assert) {
+      assert.expect(12);
+
       await visit('/deprecations');
 
       await toggleDeprecationSource();

package/tests/acceptance/object-inspector-test.js

@@ -165,6 +165,8 @@ module('Object Inspector', function (hooks) {
   });
 
   test('Digging deeper into objects', async function (assert) {
+    assert.expect(8);
+
     await visit('/');
 
     await sendMessage({
@@ -572,6 +574,8 @@ module('Object Inspector', function (hooks) {
   });
 
   test('Send to console', async function (assert) {
+    assert.expect(6);
+
     await visit('/');
 
     await sendMessage({
@@ -696,6 +700,8 @@ module('Object Inspector', function (hooks) {
   });
 
   test('Date fields are editable', async function (assert) {
+    assert.expect(5);
+
     await visit('/');
 
     let date = new Date(2019, 7, 13); // 2019-08-13
@@ -721,6 +727,26 @@ module('Object Inspector', function (hooks) {
       ],
     });
 
+    respondWith(
+      'objectInspector:saveProperty',
+      ({ objectId, property, value }) => {
+        assert.strictEqual(typeof value, 'number', 'sent as timestamp');
+        date = new Date(value);
+
+        return {
+          type: 'objectInspector:updateProperty',
+          objectId,
+          property,
+          mixinIndex: 0,
+          value: {
+            inspect: date.toString(),
+            type: 'type-date',
+            isCalculated: false,
+          },
+        };
+      }
+    );
+
     await click('[data-test-object-detail-name]');
 
     assert.dom('[data-test-object-property-value]').hasText(date.toString());
@@ -733,7 +759,7 @@ module('Object Inspector', function (hooks) {
     respondWith(
       'objectInspector:saveProperty',
       ({ objectId, property, value }) => {
-        assert.ok(typeof value === 'number', 'sent as timestamp');
+        assert.strictEqual(typeof value, 'number', 'sent as timestamp');
         date = new Date(value);
 
         return {
@@ -757,6 +783,8 @@ module('Object Inspector', function (hooks) {
   });
 
   test('Errors are correctly displayed', async function (assert) {
+    assert.expect(8);
+
     await visit('/');
 
     await sendMessage({

package/tests/acceptance/promise-test.js

@@ -217,6 +217,8 @@ module('Promise Tab', function (outer) {
 
     // TODO: is this test realistic? (having stack traces without turning on instrumentWithStack)
     test('Can trace promise when there is a stack', async function (assert) {
+      assert.expect(1);
+
       respondWith('promise:getAndObservePromises', {
         type: 'promise:promisesUpdated',
         promises: [
@@ -254,6 +256,8 @@ module('Promise Tab', function (outer) {
     });
 
     test('Toggling promise trace option', async function (assert) {
+      assert.expect(2);
+
       respondWith('promise:getAndObservePromises', {
         type: 'promise:promisesUpdated',
         promises: [generatePromise()],
@@ -267,7 +271,7 @@ module('Promise Tab', function (outer) {
       respondWith(
         'promise:setInstrumentWithStack',
         ({ applicationId, applicationName, instrumentWithStack }) => {
-          assert.strictEqual(instrumentWithStack, true, 'instrumentWithStack');
+          assert.true(instrumentWithStack, 'instrumentWithStack');
 
           return {
             type: 'promise:instrumentWithStack',
@@ -282,6 +286,8 @@ module('Promise Tab', function (outer) {
     });
 
     test('Logging error stack trace in the console', async function (assert) {
+      assert.expect(2);
+
       respondWith('promise:getAndObservePromises', {
         type: 'promise:promisesUpdated',
         promises: [
@@ -310,6 +316,8 @@ module('Promise Tab', function (outer) {
     });
 
     test('Send fulfillment value to console', async function (assert) {
+      assert.expect(2);
+
       respondWith('promise:getAndObservePromises', {
         type: 'promise:promisesUpdated',
         promises: [
@@ -338,6 +346,8 @@ module('Promise Tab', function (outer) {
     });
 
     test('Sending objects to the object inspector', async function (assert) {
+      assert.expect(1);
+
       respondWith('promise:getAndObservePromises', {
         type: 'promise:promisesUpdated',
         promises: [

package/tests/acceptance/route-tree-test.js

@@ -5,6 +5,7 @@ import {
   findAll,
   triggerEvent,
   visit,
+  waitUntil,
 } from '@ember/test-helpers';
 import { classify } from '@ember/string';
 import { module, test } from 'qunit';
@@ -106,6 +107,13 @@ module('Route Tree Tab', function (outer) {
     test('Route tree is successfully displayed', async function (assert) {
       await visit('route-tree');
 
+      await waitUntil(
+        function () {
+          return findAll('.js-route-tree-item').length === 6;
+        },
+        { timeout: 2000 }
+      );
+
       let routeNodes = findAll('.js-route-tree-item');
       assert.equal(routeNodes.length, 6, 'correct number of nodes');
 
@@ -162,6 +170,8 @@ module('Route Tree Tab', function (outer) {
     });
 
     test('Clicking on route handlers and controller sends an inspection message', async function (assert) {
+      assert.expect(2);
+
       await visit('route-tree');
 
       let applicationRow = find('.js-route-tree-item');

package/tests/acceptance/whats-new-test.js

@@ -49,7 +49,7 @@ module('Whats New', function (outer) {
   setupApplicationTest(outer);
 
   outer.beforeEach(function () {
-    this.config = this.owner.lookup('config:main');
+    this.config = this.owner.lookup('service:config');
     this.originalVersion = this.config.version;
   });
 

package/tests/ember_debug/ember-debug-test.js

@@ -31,6 +31,8 @@ module('Ember Debug', function (hooks) {
   }
 
   test('EmberDebug#inspect sends inspectable objects', function (assert) {
+    assert.expect(2);
+
     let obj = EmberObject.create();
     EmberDebug.inspect(obj);
     assert.equal(name, 'objectInspector:updateObject');

package/tests/ember_debug/object-inspector-test.js

@@ -19,6 +19,8 @@ import hasEmberVersion from '@ember/test-helpers/has-ember-version';
 import { compareVersion } from 'ember-debug/utils/version';
 import EmberDebug from 'ember-debug/main';
 import setupEmberDebugTest from '../helpers/setup-ember-debug-test';
+import EmberRoute from '@ember/routing/route';
+import Controller from '@ember/controller';
 
 const GlimmerComponent = (function () {
   try {
@@ -72,9 +74,25 @@ async function inspectObject(object) {
 }
 
 module('Ember Debug - Object Inspector', function (hooks) {
-  setupEmberDebugTest(hooks);
+  setupEmberDebugTest(hooks, {
+    routes() {
+      this.route('simple');
+    },
+  });
 
   hooks.beforeEach(async function () {
+    this.owner.register('route:application', EmberRoute);
+
+    this.owner.register('controller:application', Controller);
+
+    this.owner.register(
+      'template:application',
+      hbs(
+        '<div class="application" style="line-height: normal;">{{outlet}}</div>',
+        { moduleName: 'my-app/templates/application.hbs' }
+      )
+    );
+    this.owner.register('route:simple', EmberRoute);
     this.owner.register('component:x-simple', Component);
     this.owner.register(
       'template:simple',
@@ -498,7 +516,7 @@ module('Ember Debug - Object Inspector', function (hooks) {
     assert.equal(message.objectId, objectId);
     assert.equal(message.property, 'name');
     assert.equal(message.mixinIndex, 1);
-    assert.equal(message.value.isCalculated, true);
+    assert.true(message.value.isCalculated);
     assert.equal(message.value.inspect, inspect('Alex'));
     assert.equal(message.value.type, 'type-string');
 
@@ -688,8 +706,9 @@ module('Ember Debug - Object Inspector', function (hooks) {
       'Does not calculate expensive properties'
     );
 
-    assert.ok(
-      message.details[3].name !== 'MixinToSkip',
+    assert.notStrictEqual(
+      message.details[3].name,
+      'MixinToSkip',
       'Correctly skips mixins'
     );
   });
@@ -798,8 +817,9 @@ module('Ember Debug - Object Inspector', function (hooks) {
       'Does not calculate expensive properties'
     );
 
-    assert.ok(
-      message.details[3].name !== 'MixinToSkip',
+    assert.notStrictEqual(
+      message.details[3].name,
+      'MixinToSkip',
       'Correctly skips mixins'
     );
   });
@@ -819,7 +839,7 @@ module('Ember Debug - Object Inspector', function (hooks) {
 
     let serializedServiceProperty = message.details[1].properties[0];
 
-    assert.equal(serializedServiceProperty.isService, true);
+    assert.true(serializedServiceProperty.isService);
   });
 
   test('Proxy Service should be successfully tagged as service on serialization', async function (assert) {
@@ -837,7 +857,7 @@ module('Ember Debug - Object Inspector', function (hooks) {
 
     let serializedServiceProperty = message.details[1].properties[0];
 
-    assert.equal(serializedServiceProperty.isService, true);
+    assert.true(serializedServiceProperty.isService);
   });
 
   test('Computed property dependent keys and code should be successfully serialized', async function (assert) {
@@ -901,10 +921,11 @@ module('Ember Debug - Object Inspector', function (hooks) {
     });
 
     assert.ok(didDestroy, 'Original willDestroy is preserved.');
-    assert.ok(!objectInspector.sentObjects[objectId], 'Object is dropped');
+    assert.notOk(objectInspector.sentObjects[objectId], 'Object is dropped');
     assert.deepEqual(message, { objectId });
   });
 
+  // eslint-disable-next-line qunit/require-expect
   test('Properties ending with `Binding` are skipped', async function (assert) {
     let object = EmberObject.create({
       bar: 'test',
@@ -1025,7 +1046,7 @@ module('Ember Debug - Object Inspector', function (hooks) {
     let getter = message.details[1].properties[0];
     assert.equal(getter.name, 'hi');
     assert.ok(getter.isGetter);
-    assert.ok(!getter.isTracked);
+    assert.notOk(getter.isTracked);
     assert.equal(getter.value.type, 'type-number');
     assert.equal(getter.value.inspect, '123');
   });
@@ -1114,7 +1135,7 @@ module('Ember Debug - Object Inspector', function (hooks) {
     test('Inspecting GlimmerComponent does not cause errors', async function (assert) {
       let instance;
 
-      class FooComponent extends GlimmerComponent {
+      class Foo extends GlimmerComponent {
         constructor(...args) {
           super(...args);
           instance = this;
@@ -1131,15 +1152,20 @@ module('Ember Debug - Object Inspector', function (hooks) {
         }
       }
 
-      this.owner.register('component:foo', FooComponent);
-      this.owner.register('template:simple', hbs`<Foo />`);
+      this.owner.register('template:simple', hbs`<Foo />`, {
+        moduleName: 'my-app/templates/simple.hbs',
+      });
 
+      this.owner.register('component:foo', Foo);
+      this.owner.register(
+        `template:components/foo`,
+        hbs('text only', {
+          moduleName: 'my-app/templates/components/foo.hbs',
+        })
+      );
       await visit('/simple');
 
-      assert.ok(
-        instance instanceof FooComponent,
-        'an instance of FooComponent has been created'
-      );
+      assert.ok(instance instanceof Foo, 'an instance of Foo has been created');
 
       let { details, errors } = await inspectObject(instance);
 
@@ -1159,13 +1185,19 @@ module('Ember Debug - Object Inspector', function (hooks) {
       assert.ok(properties.indexOf('bar') > -1, 'contains bar');
       assert.ok(properties.indexOf('baz') > -1, 'contains baz');
 
-      assert.ok(properties.indexOf('bounds') === -1, 'does not contain bounds');
-      assert.ok(
-        properties.indexOf('element') === -1,
+      assert.strictEqual(
+        properties.indexOf('bounds'),
+        -1,
+        'does not contain bounds'
+      );
+      assert.strictEqual(
+        properties.indexOf('element'),
+        -1,
         'does not contain element'
       );
-      assert.ok(
-        properties.indexOf('debugName') === -1,
+      assert.strictEqual(
+        properties.indexOf('debugName'),
+        -1,
         'does not contain debugName'
       );
     });