A platform for community discussion. Free, open, simple.
import { click, settled } from "@ember/test-helpers";
import { module, test } from "qunit";
import { setupRenderingTest } from "discourse/tests/helpers/component-test";
import {
setupRichEditor,
testMarkdown,
} from "discourse/tests/helpers/rich-editor-helper";
module(
"Integration | Component | prosemirror-editor - local-dates plugin extension",
function (hooks) {
setupRenderingTest(hooks);
function findDate() {
return document.querySelector(".ProseMirror .discourse-local-date");
}
function findRange() {
return document.querySelector(".ProseMirror .discourse-local-date-range");
}
async function editDate(context, assert, markdown, markup) {
const [editor] = await setupRichEditor(assert, markdown);
await click(".composer-local-date__edit-button");
const { model } = context.owner.lookup("service:modal").activeModal.opts;
if (markup) {
model.insertDate(markup);
await settled();
}
return { editor, model };
}
test("local date", async function (assert) {
const markdown = "[date=2021-01-01 time=12:00:00]";
await testMarkdown(
assert,
markdown,
() => {
const span = findDate();
assert.dom(span).exists();
assert.strictEqual(span.dataset.date, "2021-01-01");
assert.strictEqual(span.dataset.time, "12:00:00");
},
markdown
);
});
test("local date without time", async function (assert) {
const markdown = "[date=2021-01-01]";
await testMarkdown(
assert,
markdown,
() => {
const span = findDate();
assert.dom(span).exists();
assert.strictEqual(span.dataset.date, "2021-01-01");
assert.strictEqual(span.dataset.time, undefined);
},
markdown
);
});
test("local date with timezone", async function (assert) {
const markdown =
"[date=2021-01-01 time=12:00:00 timezone=America/New_York]";
await testMarkdown(
assert,
markdown,
() => {
assert.strictEqual(findDate().dataset.timezone, "America/New_York");
},
markdown
);
});
test("local date with format", async function (assert) {
const markdown =
'[date=2021-01-01 time=12:00:00 format="YYYY-MM-DD HH:mm"]';
await testMarkdown(
assert,
markdown,
() => {
const span = findDate();
assert.strictEqual(span.dataset.format, "YYYY-MM-DD HH:mm");
assert.true(span.textContent.includes("2021-01-01"));
},
markdown
);
});
test("local date with recurring", async function (assert) {
const markdown = "[date=2021-01-01 time=12:00:00 recurring=1.weeks]";
await testMarkdown(
assert,
markdown,
() => {
assert.strictEqual(findDate().dataset.recurring, "1.weeks");
},
markdown
);
});
test("local date with timezones", async function (assert) {
const markdown =
"[date=2021-01-01 time=12:00:00 timezones=Europe/Paris|Asia/Tokyo]";
await testMarkdown(
assert,
markdown,
() => {
assert.strictEqual(
findDate().dataset.timezones,
"Europe/Paris|Asia/Tokyo"
);
},
markdown
);
});
test("local date with countdown", async function (assert) {
const markdown = "[date=2099-01-01 time=12:00:00 countdown=true]";
await testMarkdown(
assert,
markdown,
() => {
assert.strictEqual(findDate().dataset.countdown, "true");
},
markdown
);
});
test("local date with displayedTimezone", async function (assert) {
const markdown =
"[date=2021-01-01 time=12:00:00 displayedTimezone=Europe/London]";
await testMarkdown(
assert,
markdown,
() => {
assert.strictEqual(
findDate().dataset.displayedTimezone,
"Europe/London"
);
},
markdown
);
});
test("local date range", async function (assert) {
const markdown = "[date-range from=2021-01-01 to=2021-01-02]";
await testMarkdown(
assert,
markdown,
() => {
const rangeSpan = findRange();
assert.dom(rangeSpan).exists();
const fromSpan = rangeSpan.querySelector('[data-range="from"]');
const toSpan = rangeSpan.querySelector('[data-range="to"]');
assert.strictEqual(fromSpan.dataset.date, "2021-01-01");
assert.strictEqual(toSpan.dataset.date, "2021-01-02");
},
markdown
);
});
test("local date range with time", async function (assert) {
const markdown =
"[date-range from=2021-01-01T12:00:00 to=2021-01-02T13:00:00]";
await testMarkdown(
assert,
markdown,
() => {
const rangeSpan = findRange();
const fromSpan = rangeSpan.querySelector('[data-range="from"]');
const toSpan = rangeSpan.querySelector('[data-range="to"]');
assert.strictEqual(fromSpan.dataset.date, "2021-01-01");
assert.strictEqual(fromSpan.dataset.time, "12:00:00");
assert.strictEqual(toSpan.dataset.date, "2021-01-02");
assert.strictEqual(toSpan.dataset.time, "13:00:00");
},
markdown
);
});
test("local date range with timezone", async function (assert) {
const markdown =
"[date-range from=2021-01-01 to=2021-01-02 timezone=America/New_York]";
await testMarkdown(
assert,
markdown,
() => {
const rangeSpan = findRange();
const fromSpan = rangeSpan.querySelector('[data-range="from"]');
const toSpan = rangeSpan.querySelector('[data-range="to"]');
assert.strictEqual(fromSpan.dataset.timezone, "America/New_York");
assert.strictEqual(toSpan.dataset.timezone, "America/New_York");
},
markdown
);
});
test("local date range with format", async function (assert) {
const markdown =
"[date-range from=2021-01-01 to=2021-01-02 format=YYYY-MM-DD]";
await testMarkdown(
assert,
markdown,
() => {
const rangeSpan = findRange();
const fromSpan = rangeSpan.querySelector('[data-range="from"]');
const toSpan = rangeSpan.querySelector('[data-range="to"]');
assert.strictEqual(fromSpan.dataset.format, "YYYY-MM-DD");
assert.strictEqual(toSpan.dataset.format, "YYYY-MM-DD");
},
markdown
);
});
test("local date range with timezones", async function (assert) {
const markdown =
"[date-range from=2021-01-01 to=2021-01-02 timezones=Europe/Paris|Asia/Tokyo]";
await testMarkdown(
assert,
markdown,
() => {
const rangeSpan = findRange();
const fromSpan = rangeSpan.querySelector('[data-range="from"]');
const toSpan = rangeSpan.querySelector('[data-range="to"]');
assert.strictEqual(
fromSpan.dataset.timezones,
"Europe/Paris|Asia/Tokyo"
);
assert.strictEqual(
toSpan.dataset.timezones,
"Europe/Paris|Asia/Tokyo"
);
},
markdown
);
});
test("local date range with countdown", async function (assert) {
const markdown =
"[date-range from=2099-01-01 to=2099-01-02 countdown=true]";
await testMarkdown(
assert,
markdown,
() => {
const rangeSpan = findRange();
const fromSpan = rangeSpan.querySelector('[data-range="from"]');
const toSpan = rangeSpan.querySelector('[data-range="to"]');
assert.strictEqual(fromSpan.dataset.countdown, "true");
assert.strictEqual(toSpan.dataset.countdown, "true");
},
markdown
);
});
test("local date range with displayedTimezone", async function (assert) {
const markdown =
"[date-range from=2021-01-01 to=2021-01-02 displayedTimezone=Europe/London]";
await testMarkdown(
assert,
markdown,
() => {
const rangeSpan = findRange();
const fromSpan = rangeSpan.querySelector('[data-range="from"]');
const toSpan = rangeSpan.querySelector('[data-range="to"]');
assert.strictEqual(
fromSpan.dataset.displayedTimezone,
"Europe/London"
);
assert.strictEqual(toSpan.dataset.displayedTimezone, "Europe/London");
},
markdown
);
});
test("edit seeds the modal from the node attributes", async function (assert) {
const { model } = await editDate(
this,
assert,
'[date=2021-01-01 time=12:00:00 timezone=America/New_York format="YYYY-MM-DD" recurring=1.weeks timezones=Europe/Paris|Asia/Tokyo countdown=true displayedTimezone=Europe/London]'
);
assert.deepEqual(model.initialValues, {
date: "2021-01-01",
time: "12:00:00",
toDate: null,
toTime: null,
timezone: "America/New_York",
format: "YYYY-MM-DD",
timezones: ["Europe/Paris", "Asia/Tokyo"],
recurring: "1.weeks",
countdown: "true",
displayedTimezone: "Europe/London",
});
});
test("edit seeds the modal from a range's node attributes", async function (assert) {
const { model } = await editDate(
this,
assert,
"[date-range from=2021-01-01T12:00:00 to=2021-01-02T13:00:00 timezone=America/New_York]"
);
assert.deepEqual(model.initialValues, {
date: "2021-01-01",
time: "12:00:00",
toDate: "2021-01-02",
toTime: "13:00:00",
timezone: "America/New_York",
format: null,
timezones: [],
recurring: null,
countdown: null,
displayedTimezone: null,
});
});
test("applying an edit replaces the date node", async function (assert) {
const { editor } = await editDate(
this,
assert,
"before [date=2021-01-01 time=12:00:00] after",
"[date=2022-02-02 time=13:00:00]"
);
assert.strictEqual(
editor.value,
"before [date=2022-02-02 time=13:00:00] after"
);
});
test("applying an edit can turn a date into a range", async function (assert) {
const { editor } = await editDate(
this,
assert,
"[date=2021-01-01 time=12:00:00]",
"[date-range from=2021-01-01T12:00:00 to=2021-01-02T13:00:00]"
);
assert.strictEqual(
editor.value,
"[date-range from=2021-01-01T12:00:00 to=2021-01-02T13:00:00]"
);
});
test("applying an edit can turn a range into a date", async function (assert) {
const { editor } = await editDate(
this,
assert,
"[date-range from=2021-01-01T12:00:00 to=2021-01-02T13:00:00]",
"[date=2021-01-01 time=12:00:00]"
);
assert.strictEqual(editor.value, "[date=2021-01-01 time=12:00:00]");
});
}
);