logster 2.11.4 → 2.12.1

data/client-app/tests/integration/components/back-trace-test.js

@@ -1,84 +1,86 @@
 import { module, test } from "qunit";
 import { setupRenderingTest } from "ember-qunit";
-import { render, find, findAll } from "@ember/test-helpers";
+import { find, findAll, render } from "@ember/test-helpers";
 import hbs from "htmlbars-inline-precompile";
-import { uninitialize, mutatePreload } from "client-app/lib/preload";
+import { mutatePreload, uninitialize } from "client-app/lib/preload";
 
-module("Integration | Component | back-trace", function(hooks) {
+module("Integration | Component | back-trace", function (hooks) {
   setupRenderingTest(hooks);
 
-  hooks.beforeEach(function() {
+  hooks.beforeEach(function () {
     uninitialize();
   });
 
-  hooks.afterEach(function() {
+  hooks.afterEach(function () {
     uninitialize();
   });
 
-  test("backtrace lines display and work correctly", async function(assert) {
+  test("backtrace lines display and work correctly", async function (assert) {
     const backtrace = `/var/www/discourse/vendor/bundle/ruby/2.6.0/gems/activerecord-6.0.1/lib/active_record/relation/finder_methods.rb:317:in \`exists?'
 /var/www/discourse/lib/permalink_constraint.rb:6:in \`matches?'
 /var/www/discourse/plugins/discourse-prometheus/lib/middleware/metrics.rb:17:in \`call'
 activerecord-6.0.1/lib/active_record/relation/finder_methods.rb:317:in \`exists?'`;
     this.set("backtrace", backtrace);
-    await render(hbs`{{back-trace backtrace=backtrace}}`);
+    await render(hbs`<BackTrace @backtrace={{this.backtrace}} />`);
 
     const [gem, app, plugin, gem2] = findAll("a");
-    assert.equal(
+    assert.strictEqual(
       gem.href,
       "https://github.com/rails/rails/tree/v6.0.1/activerecord/lib/active_record/relation/finder_methods.rb#L317"
     );
 
-    assert.equal(
+    assert.strictEqual(
       app.href,
       "https://github.com/discourse/discourse/blob/ce512452b512b909c38e9c63f2a0e1f8c17a2399/lib/permalink_constraint.rb#L6"
     );
 
-    assert.equal(
+    assert.strictEqual(
       plugin.href,
       "https://github.com/discourse/discourse-prometheus/blob/master/lib/middleware/metrics.rb#L17"
     );
 
-    assert.equal(
+    assert.strictEqual(
       gem2.href,
       "https://github.com/rails/rails/tree/v6.0.1/activerecord/lib/active_record/relation/finder_methods.rb#L317"
     );
 
     let gemLine = find("div.backtrace-line");
-    assert.equal(
+    assert.strictEqual(
       gemLine.textContent.trim(),
       "activerecord-6.0.1/lib/active_record/relation/finder_methods.rb:317:in `exists?'",
       "gem lines are truncated"
     );
   });
 
-  test("non-ruby backtraces don't break things", async function(assert) {
+  test("non-ruby backtraces don't break things", async function (assert) {
     this.set(
       "backtrace",
       `m/<@https://discourse-cdn.com/assets/application-f59d2.br.js:1:27448
 m@https://discourse-cdn.com/assets/application-f59d2.br.js:1:27560
 string@https://discourse-cdn.com/assets/application-f59d2.br.js:1:27869`
     );
-    await render(hbs`{{back-trace backtrace=backtrace}}`);
+    await render(hbs`<BackTrace @backtrace={{this.backtrace}} />`);
     const lines = this.backtrace.split("\n");
     findAll("div.backtrace-line").forEach((node, index) => {
-      assert.equal(node.textContent.trim(), lines[index]);
+      assert.strictEqual(node.textContent.trim(), lines[index]);
     });
   });
 
-  test("Github links use commit sha", async function(assert) {
+  test("Github links use commit sha", async function (assert) {
     const backtrace = `/var/www/discourse/lib/permalink_constraint.rb:6:in \`matches?'`;
     let env = [
       { application_version: "123abc" },
-      { application_version: "abc123" }
+      { application_version: "abc123" },
     ];
     this.setProperties({
       backtrace,
-      env
+      env,
     });
-    await render(hbs`{{back-trace backtrace=backtrace env=env}}`);
+    await render(
+      hbs`<BackTrace @backtrace={{this.backtrace}} @env={{this.env}} />`
+    );
     let href = find("a").href;
-    assert.equal(
+    assert.strictEqual(
       href,
       "https://github.com/discourse/discourse/blob/123abc/lib/permalink_constraint.rb#L6",
       "uses the first application_version if there are multiple versions"
@@ -86,27 +88,31 @@ string@https://discourse-cdn.com/assets/application-f59d2.br.js:1:27869`
 
     env = { application_version: "567def" };
     this.set("env", env);
-    await render(hbs`{{back-trace backtrace=backtrace env=env}}`);
+    await render(
+      hbs`<BackTrace @backtrace={{this.backtrace}} @env={{this.env}} />`
+    );
     href = find("a").href;
-    assert.equal(
+    assert.strictEqual(
       href,
       "https://github.com/discourse/discourse/blob/567def/lib/permalink_constraint.rb#L6",
       "uses application_version when env is only a hash"
     );
 
     this.set("env", null);
-    await render(hbs`{{back-trace backtrace=backtrace env=env}}`);
+    await render(
+      hbs`<BackTrace @backtrace={{this.backtrace}} @env={{this.env}} />`
+    );
     href = find("a").href;
-    assert.equal(
+    assert.strictEqual(
       href,
       "https://github.com/discourse/discourse/blob/ce512452b512b909c38e9c63f2a0e1f8c17a2399/lib/permalink_constraint.rb#L6",
       "falls back to preload if env doesn't contain application_version"
     );
 
     mutatePreload("application_version", null);
-    await render(hbs`{{back-trace backtrace=backtrace}}`);
+    await render(hbs`<BackTrace @backtrace={{this.backtrace}} />`);
     href = find("a").href;
-    assert.equal(
+    assert.strictEqual(
       href,
       "https://github.com/discourse/discourse/blob/master/lib/permalink_constraint.rb#L6",
       "falls back to master branch when neither preload nor application_version in env are available"

data/client-app/tests/integration/components/env-tab-test.js

@@ -1,6 +1,6 @@
 import { module, test } from "qunit";
 import { setupRenderingTest } from "ember-qunit";
-import { render, find, findAll, click } from "@ember/test-helpers";
+import { click, find, findAll, render } from "@ember/test-helpers";
 import hbs from "htmlbars-inline-precompile";
 import Message from "client-app/models/message";
 import { init } from "client-app/lib/preload";
@@ -9,11 +9,14 @@ const time1 = new Date("2010-01-01T01:00:00").getTime();
 const time2 = new Date("2015-01-01T01:00:00").getTime();
 
 const message = Message.create({
-  env: [{ a: "aa", b: "bb", time: time1 }, { c: "cc", d: "dd", time: time2 }]
+  env: [
+    { a: "aa", b: "bb", time: time1 },
+    { c: "cc", d: "dd", time: time2 },
+  ],
 });
 
 const message2 = Message.create({
-  env: { e: "ee", f: "ff" }
+  env: { e: "ee", f: "ff" },
 });
 
 const message3 = Message.create({
@@ -21,12 +24,12 @@ const message3 = Message.create({
     { env_key_2: "value1", default_expanded: "vvv1", notExpanded: "dsdcz" },
     { env_key_2: "value2", default_expanded: "vvv2", notExpanded: "uerue" },
     { env_key_2: "value3", notExpanded: "weeww" },
-    { env_key_2: "value4", notExpanded: "cxc" }
-  ]
+    { env_key_2: "value4", notExpanded: "cxc" },
+  ],
 });
 
 const message4 = Message.create({
-  env: { env_key_2: "value", default_expanded: "vvv", notExpanded: "wwww" }
+  env: { env_key_2: "value", default_expanded: "vvv", notExpanded: "wwww" },
 });
 
 function reduceToContent(node) {
@@ -35,30 +38,38 @@ function reduceToContent(node) {
   );
 }
 
-module("Integration | Component | env-tab", function(hooks) {
+module("Integration | Component | env-tab", function (hooks) {
   setupRenderingTest(hooks);
 
-  test("it renders", async function(assert) {
-    const callback = newPosition => this.set("envPosition", newPosition);
+  test("it renders", async function (assert) {
+    const callback = (newPosition) => this.set("envPosition", newPosition);
     this.setProperties({
       message,
       callback,
-      envPosition: 0
+      envPosition: 0,
     });
     await render(
-      hbs`{{env-tab message=message envChangedAction=callback currentEnvPosition=envPosition}}`
+      hbs`<EnvTab @message={{this.message}} @envChangedAction={{this.callback}} @currentEnvPosition={{this.envPosition}} />`
     );
 
-    assert.equal(
+    assert.strictEqual(
       find(".current-number").textContent,
       "1/2",
       "shows the current over the total number of env objects"
     );
     let trs = findAll("tr");
-    assert.equal(trs.length, 3);
-    assert.equal(reduceToContent(trs[0]), "a: aa", "has the right content");
-    assert.equal(reduceToContent(trs[1]), "b: bb", "has the right content");
-    assert.equal(
+    assert.strictEqual(trs.length, 3);
+    assert.strictEqual(
+      reduceToContent(trs[0]),
+      "a: aa",
+      "has the right content"
+    );
+    assert.strictEqual(
+      reduceToContent(trs[1]),
+      "b: bb",
+      "has the right content"
+    );
+    assert.strictEqual(
       reduceToContent(trs[2]),
       "time: 1 Jan 10",
       "has the right content"
@@ -76,36 +87,52 @@ module("Integration | Component | env-tab", function(hooks) {
     assert.dom("button").doesNotExist("doesn't show buttons for non-array env");
 
     trs = findAll("tr");
-    assert.equal(trs.length, 2);
-    assert.equal(reduceToContent(trs[0]), "e: ee", "has the right content");
-    assert.equal(reduceToContent(trs[1]), "f: ff", "has the right content");
+    assert.strictEqual(trs.length, 2);
+    assert.strictEqual(
+      reduceToContent(trs[0]),
+      "e: ee",
+      "has the right content"
+    );
+    assert.strictEqual(
+      reduceToContent(trs[1]),
+      "f: ff",
+      "has the right content"
+    );
   });
 
-  test("it works correctly", async function(assert) {
-    const callback = newPosition => this.set("envPosition", newPosition);
+  test("it works correctly", async function (assert) {
+    const callback = (newPosition) => this.set("envPosition", newPosition);
     this.setProperties({
       message,
       callback,
-      envPosition: 0
+      envPosition: 0,
     });
     await render(
-      hbs`{{env-tab message=message envChangedAction=callback currentEnvPosition=envPosition}}`
+      hbs`<EnvTab @message={{this.message}} @envChangedAction={{this.callback}} @currentEnvPosition={{this.envPosition}} />`
     );
 
     const buttons = findAll("button.nav-btn");
     await click(buttons[2]);
 
-    assert.equal(
+    assert.strictEqual(
       find(".current-number").textContent,
       "2/2",
       "shows the current over the total number of env objects"
     );
 
     const trs = findAll("tr");
-    assert.equal(trs.length, 3);
-    assert.equal(reduceToContent(trs[0]), "c: cc", "has the right content");
-    assert.equal(reduceToContent(trs[1]), "d: dd", "has the right content");
-    assert.equal(
+    assert.strictEqual(trs.length, 3);
+    assert.strictEqual(
+      reduceToContent(trs[0]),
+      "c: cc",
+      "has the right content"
+    );
+    assert.strictEqual(
+      reduceToContent(trs[1]),
+      "d: dd",
+      "has the right content"
+    );
+    assert.strictEqual(
       reduceToContent(trs[2]),
       "time: 1 Jan 15",
       "has the right content"
@@ -119,51 +146,50 @@ module("Integration | Component | env-tab", function(hooks) {
     assert.ok(buttons[3].disabled, "forward buttons are disabled");
   });
 
-  test("expandable env keys", async function(assert) {
-    document.getElementById(
-      "preloaded-data"
-    ).dataset.preloaded = JSON.stringify({
-      env_expandable_keys: ["env_key_2", "default_expanded"]
-    });
+  test("expandable env keys", async function (assert) {
+    document.getElementById("preloaded-data").dataset.preloaded =
+      JSON.stringify({
+        env_expandable_keys: ["env_key_2", "default_expanded"],
+      });
     init();
-    const callback = newPosition => this.set("envPosition", newPosition);
+    const callback = (newPosition) => this.set("envPosition", newPosition);
     this.setProperties({
       message: message3,
       callback,
-      envPosition: 0
+      envPosition: 0,
     });
     await render(
-      hbs`{{env-tab message=message envChangedAction=callback currentEnvPosition=envPosition}}`
+      hbs`<EnvTab @message={{this.message}} @envChangedAction={{this.callback}} @currentEnvPosition={{this.envPosition}} />`
     );
 
     const trs = findAll(".env-table tr");
     const expandable = trs[0];
     const defaultExpanded = trs[1];
 
-    assert.equal(
+    assert.strictEqual(
       expandable.children[1].textContent.trim(),
       "value1, 3 more",
       "expandable env keys shown correctly"
     );
 
-    assert.equal(
+    assert.strictEqual(
       defaultExpanded.children[1].textContent.trim(),
       "vvv1, [vvv2]",
       "list is expanded by default when its length is 3 or less"
     );
 
-    assert.equal(
+    assert.strictEqual(
       findAll("a.expand-list").length,
       1,
       "only whitelisted env keys are expandable"
     );
 
     const expandBtn = find("a.expand-list");
-    assert.equal(expandBtn.textContent.trim(), "3 more");
+    assert.strictEqual(expandBtn.textContent.trim(), "3 more");
     await click(expandBtn);
 
     const expanded = find(".env-table tr");
-    assert.equal(
+    assert.strictEqual(
       expanded.children[1].textContent.trim(),
       "value1, [value2, value3, value4]",
       "expanded env keys shown correctly"
@@ -172,23 +198,23 @@ module("Integration | Component | env-tab", function(hooks) {
     this.setProperties({
       message: message4,
       callback,
-      envPosition: 0
+      envPosition: 0,
     });
     await render(
-      hbs`{{env-tab message=message envChangedAction=callback currentEnvPosition=envPosition}}`
+      hbs`<EnvTab @message={{this.message}} @envChangedAction={{this.callback}} @currentEnvPosition={{this.envPosition}} />`
     );
     const recreatedEnv = {};
-    findAll(".env-table tr").forEach(node => {
-      recreatedEnv[
-        node.children[0].innerText.trim()
-      ] = node.children[1].innerText.trim();
+    findAll(".env-table tr").forEach((node) => {
+      recreatedEnv[node.children[0].innerText.trim()] =
+        node.children[1].innerText.trim();
     });
-    Object.keys(recreatedEnv).forEach(k => {
-      assert.equal(
-        recreatedEnv[k],
+
+    for (const [k, v] of Object.entries(recreatedEnv)) {
+      assert.strictEqual(
+        v,
         this.message.env[k],
-        `${k}: ${recreatedEnv[k]} === ${this.message.env[k]}`
+        `${k}: ${v} === ${this.message.env[k]}`
       );
-    });
+    }
   });
 });

data/client-app/tests/integration/components/message-info-test.js

@@ -1,6 +1,6 @@
 import { module, test } from "qunit";
 import { setupRenderingTest } from "ember-qunit";
-import { render, find, findAll, click } from "@ember/test-helpers";
+import { click, find, findAll, render } from "@ember/test-helpers";
 import hbs from "htmlbars-inline-precompile";
 import Message from "client-app/models/message";
 
@@ -10,45 +10,47 @@ const messageTitle = "This Is Title";
 const message = Message.create({
   backtrace,
   message: messageTitle,
-  env: { c: "cc", d: "dd" }
+  env: { c: "cc", d: "dd" },
 });
 
-module("Integration | Component | message-info", function(hooks) {
+module("Integration | Component | message-info", function (hooks) {
   setupRenderingTest(hooks);
 
-  test("it renders", async function(assert) {
-    const callback = newPosition => this.set("currentEnvPosition", newPosition);
+  test("it renders", async function (assert) {
+    const callback = (newPosition) =>
+      this.set("currentEnvPosition", newPosition);
     this.setProperties({
       actionsInMenu: true,
       showTitle: false,
       envPosition: 0,
       message,
-      callback
+      callback,
     });
 
     await render(
-      hbs`{{message-info
-            currentMessage=message
-            showTitle=showTitle
-            currentEnvPosition=envPosition
-            envChangedAction=callback
-            showShare=true
-            actionsInMenu=actionsInMenu}}`
+      hbs`<MessageInfo
+        @currentMessage={{this.message}}
+        @showTitle={{this.showTitle}}
+        @currentEnvPosition={{this.envPosition}}
+        @envChangedAction={{this.callback}}
+        @showShare={{true}}
+        @actionsInMenu={{this.actionsInMenu}}
+      />`
     );
     let activeTab = find(".message-info .content.active pre");
-    assert.equal(
+    assert.strictEqual(
       activeTab.textContent.trim(),
       backtrace,
       "default active tab is backtrace"
     );
     assert.dom(".message-info .content h3").doesNotExist("no titles are shown");
-    assert.equal(findAll(".tabs a").length, 3, "3 tabs shown");
-    assert.equal(
+    assert.strictEqual(findAll(".tabs a").length, 3, "3 tabs shown");
+    assert.strictEqual(
       find(".tabs a.active").textContent.trim(),
       "backtrace",
       "default active tab is backtrace"
     );
-    assert.equal(
+    assert.strictEqual(
       findAll(".message-actions button").length,
       2,
       "2 buttons shown when `actionsInMenu` is true"
@@ -59,7 +61,7 @@ module("Integration | Component | message-info", function(hooks) {
     assert.dom(".message-actions button.share").exists("share button is shown");
 
     await click(find(".message-actions button.expand.no-text"));
-    assert.equal(
+    assert.strictEqual(
       findAll(".actions-menu button").length,
       3,
       "extra buttons shown inside a menu"
@@ -73,10 +75,10 @@ module("Integration | Component | message-info", function(hooks) {
 
     this.setProperties({
       showTitle: true,
-      actionsInMenu: false
+      actionsInMenu: false,
     });
 
-    assert.equal(
+    assert.strictEqual(
       findAll(".message-info .content h3").length,
       3,
       "titles are shown"
@@ -84,7 +86,7 @@ module("Integration | Component | message-info", function(hooks) {
     assert
       .dom(".message-actions button.expand.no-text")
       .doesNotExist("menu expand button is not shown");
-    assert.equal(
+    assert.strictEqual(
       findAll(".message-actions button").length,
       4,
       "all actions buttons are shown inline when `actionsInMenu` is false"
@@ -92,7 +94,7 @@ module("Integration | Component | message-info", function(hooks) {
 
     await click(findAll(".tabs a")[0]);
     activeTab = find(".message-info .content.active pre");
-    assert.equal(activeTab.textContent, messageTitle, "can switch tabs");
+    assert.strictEqual(activeTab.textContent, messageTitle, "can switch tabs");
 
     assert
       .dom(".message-actions button.solve")
@@ -108,7 +110,7 @@ module("Integration | Component | message-info", function(hooks) {
 
     message.set("env", [
       { sd: "dx", application_version: "fsfdsf" },
-      { vcv: "dxc" }
+      { vcv: "dxc" },
     ]);
     this.set("message", message);
     assert

data/client-app/tests/integration/components/patterns-list-test.js

@@ -1,20 +1,21 @@
 import { module, test } from "qunit";
 import { setupRenderingTest } from "ember-qunit";
 import hbs from "htmlbars-inline-precompile";
-import { fillIn, render, findAll } from "@ember/test-helpers";
+import { fillIn, findAll, render } from "@ember/test-helpers";
 import Pattern from "client-app/models/pattern-item";
 
-module("Integration | Component | patterns-list", function(hooks) {
+module("Integration | Component | patterns-list", function (hooks) {
   setupRenderingTest(hooks);
 
-  test("it renders", async function(assert) {
+  test("it renders", async function (assert) {
     this.setProperties({
       mutable: true,
-      patterns: []
+      patterns: [],
     });
     await render(
-      hbs`{{patterns-list patterns=patterns mutable=mutable key="suppression"}}`
+      hbs`<PatternsList @patterns={{this.patterns}} @mutable={{this.mutable}} @key="suppression" />`
     );
+
     assert
       .dom(".pattern-input")
       .exists("It shows an input when patterns are emtpy");
@@ -25,7 +26,7 @@ module("Integration | Component | patterns-list", function(hooks) {
     const pattern1 = Pattern.create({ value: "/somepattern/" });
     const pattern2 = Pattern.create({ value: "/anotherpattern/" });
     this.set("patterns", [pattern1, pattern2]);
-    assert.equal(
+    assert.strictEqual(
       findAll(".pattern-input").length,
       3, // yes 3 because there is always an empty pattern input
       "It correctly displays patterns"
@@ -34,15 +35,17 @@ module("Integration | Component | patterns-list", function(hooks) {
       .dom(".btn.save")
       .doesNotExist("No save buttons are shown when there is 0 buffer");
     const counters = findAll("input.count");
-    assert.equal(counters.length, 3, "counters shown for all patterns");
+    assert.strictEqual(counters.length, 3, "counters shown for all patterns");
     assert.ok(
-      counters.every(c => c.disabled),
+      counters.every((c) => c.disabled),
       "counters are disabled"
     );
 
     pattern1.set("count", 6);
     this.set("patterns", [pattern1, pattern2]);
-    const counterPresent = !!findAll("input.count").find(c => c.value === "6");
+    const counterPresent = !!findAll("input.count").find(
+      (c) => c.value === "6"
+    );
     assert.ok(counterPresent, "counter shows correct value");
     assert.dom(".btn.reset").exists("Reset button is shown");
 
@@ -55,7 +58,7 @@ module("Integration | Component | patterns-list", function(hooks) {
       .exists("Save buttons are shown when there is buffer");
     assert.dom(".btn.trash").exists("Trash buttons are shown");
 
-    let disabled = inputs.every(inp => inp.disabled);
+    let disabled = inputs.every((inp) => inp.disabled);
     assert.notOk(
       disabled,
       "All inputs are not disabled when the list is mutable"
@@ -64,7 +67,7 @@ module("Integration | Component | patterns-list", function(hooks) {
     this.set("mutable", false);
 
     inputs = findAll(".pattern-input");
-    disabled = inputs.every(inp => inp.disabled);
+    disabled = inputs.every((inp) => inp.disabled);
     assert.ok(disabled, "All inputs are disabled when the list is immutable");
     assert
       .dom(".btn.trash")

data/client-app/tests/test-helper.js

@@ -1,8 +1,12 @@
-import Application from '../app';
-import config from '../config/environment';
-import { setApplication } from '@ember/test-helpers';
-import { start } from 'ember-qunit';
+import Application from "client-app/app";
+import config from "client-app/config/environment";
+import * as QUnit from "qunit";
+import { setApplication } from "@ember/test-helpers";
+import { setup } from "qunit-dom";
+import { start } from "ember-qunit";
 
 setApplication(Application.create(config.APP));
 
+setup(QUnit.assert);
+
 start();