forked from Mapan/odoo17e
696 lines
31 KiB
JavaScript
696 lines
31 KiB
JavaScript
/* @odoo-module */
|
|
|
|
import { startServer } from "@bus/../tests/helpers/mock_python_environment";
|
|
|
|
import { documentService } from "@documents/core/document_service";
|
|
import { DocumentsSearchPanel } from "@documents/views/search/documents_search_panel";
|
|
import {
|
|
getEnrichedSearchArch,
|
|
createDocumentsViewWithMessaging,
|
|
} from "@documents/../tests/documents_test_utils";
|
|
|
|
import { XLSX_MIME_TYPES } from "@documents_spreadsheet/helpers";
|
|
import { mockActionService } from "@documents_spreadsheet/../tests/spreadsheet_test_utils";
|
|
|
|
import { start } from "@mail/../tests/helpers/test_utils";
|
|
|
|
import { Model } from "@odoo/o-spreadsheet";
|
|
|
|
import { loadBundle } from "@web/core/assets";
|
|
import { browser } from "@web/core/browser/browser";
|
|
import { fileUploadService } from "@web/core/file_upload/file_upload_service";
|
|
import { x2ManyCommands } from "@web/core/orm_service";
|
|
import { registry } from "@web/core/registry";
|
|
import { SearchPanel } from "@web/search/search_panel/search_panel";
|
|
import {
|
|
click,
|
|
getFixture,
|
|
mockDownload,
|
|
nextTick,
|
|
patchWithCleanup,
|
|
} from "@web/../tests/helpers/utils";
|
|
import { setupViewRegistries } from "@web/../tests/views/helpers";
|
|
import { contains } from "@web/../tests/utils";
|
|
|
|
const serviceRegistry = registry.category("services");
|
|
|
|
let target;
|
|
|
|
QUnit.module(
|
|
"documents_spreadsheet kanban",
|
|
{
|
|
beforeEach() {
|
|
setupViewRegistries();
|
|
target = getFixture();
|
|
serviceRegistry.add("document.document", documentService);
|
|
serviceRegistry.add("file_upload", fileUploadService);
|
|
serviceRegistry.add("documents_pdf_thumbnail", {
|
|
start() {
|
|
return {
|
|
enqueueRecords: () => {},
|
|
};
|
|
},
|
|
});
|
|
// Due to the search panel allowing double clicking on elements, the base
|
|
// methods have a debounce time in order to not do anything on dblclick.
|
|
// This patch removes those features
|
|
patchWithCleanup(DocumentsSearchPanel.prototype, {
|
|
toggleCategory() {
|
|
return SearchPanel.prototype.toggleCategory.call(this, ...arguments);
|
|
},
|
|
toggleFilterGroup() {
|
|
return SearchPanel.prototype.toggleFilterGroup.call(this, ...arguments);
|
|
},
|
|
toggleFilterValue() {
|
|
return SearchPanel.prototype.toggleFilterValue.call(this, ...arguments);
|
|
},
|
|
});
|
|
},
|
|
},
|
|
() => {
|
|
QUnit.test("download spreadsheet from the document inspector", async function (assert) {
|
|
assert.expect(4);
|
|
patchWithCleanup(browser, { setInterval: (fn) => fn(), clearInterval: () => {} });
|
|
const pyEnv = await startServer();
|
|
const documentsFolderId1 = pyEnv["documents.folder"].create({
|
|
display_name: "Workspace1",
|
|
has_write_access: true,
|
|
});
|
|
pyEnv["documents.document"].create({
|
|
name: "My spreadsheet",
|
|
spreadsheet_data: "{}",
|
|
is_favorited: false,
|
|
folder_id: documentsFolderId1,
|
|
handler: "spreadsheet",
|
|
});
|
|
mockDownload((options) => {
|
|
assert.step(options.url);
|
|
assert.ok(options.data.zip_name);
|
|
assert.ok(options.data.files);
|
|
});
|
|
const serverData = {
|
|
views: {
|
|
"documents.document,false,kanban": `
|
|
<kanban js_class="documents_kanban"><templates><t t-name="kanban-box">
|
|
<div>
|
|
<i class="fa fa-circle-thin o_record_selector"/>
|
|
<field name="name"/>
|
|
<field name="handler"/>
|
|
</div>
|
|
</t></templates></kanban>
|
|
`,
|
|
"documents.document,false,search": getEnrichedSearchArch(),
|
|
},
|
|
};
|
|
const { openView } = await start({
|
|
serverData,
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
|
|
await click(target, ".o_kanban_record:nth-of-type(1) .o_record_selector");
|
|
await click(target, "button.o_inspector_download");
|
|
await nextTick();
|
|
assert.verifySteps(["/spreadsheet/xlsx"]);
|
|
});
|
|
QUnit.test("share spreadsheet from the document inspector", async function (assert) {
|
|
const pyEnv = await startServer();
|
|
const folderId = pyEnv["documents.folder"].create({
|
|
display_name: "Workspace1",
|
|
has_write_access: true,
|
|
});
|
|
await loadBundle("spreadsheet.o_spreadsheet");
|
|
const model = new Model();
|
|
const documentId = pyEnv["documents.document"].create({
|
|
name: "My spreadsheet",
|
|
spreadsheet_data: JSON.stringify(model.exportData()),
|
|
folder_id: folderId,
|
|
handler: "spreadsheet",
|
|
});
|
|
const serverData = {
|
|
views: {
|
|
"documents.document,false,kanban": `
|
|
<kanban js_class="documents_kanban"><templates><t t-name="kanban-box">
|
|
<div>
|
|
<i class="fa fa-circle-thin o_record_selector"/>
|
|
<field name="name"/>
|
|
<field name="handler"/>
|
|
</div>
|
|
</t></templates></kanban>
|
|
`,
|
|
"documents.document,false,search": getEnrichedSearchArch(),
|
|
},
|
|
};
|
|
patchWithCleanup(browser, {
|
|
navigator: {
|
|
...browser.navigator,
|
|
clipboard: {
|
|
writeText: (url) => {
|
|
assert.step("share url copied");
|
|
assert.strictEqual(url, "localhost:8069/share/url/132465");
|
|
},
|
|
},
|
|
},
|
|
});
|
|
const { openView } = await start({
|
|
mockRPC: async (route, args) => {
|
|
if (args.method === "action_get_share_url") {
|
|
assert.step("spreadsheet_shared");
|
|
const [shareVals] = args.args;
|
|
assert.strictEqual(args.model, "documents.share");
|
|
const excel = JSON.parse(JSON.stringify(model.exportXLSX().files));
|
|
assert.deepEqual(shareVals, {
|
|
document_ids: [x2ManyCommands.set([documentId])],
|
|
folder_id: folderId,
|
|
type: "ids",
|
|
spreadsheet_shares: [
|
|
{
|
|
spreadsheet_data: JSON.stringify(model.exportData()),
|
|
document_id: documentId,
|
|
excel_files: excel,
|
|
},
|
|
],
|
|
});
|
|
return "localhost:8069/share/url/132465";
|
|
}
|
|
},
|
|
serverData,
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
await click(target, ".o_kanban_record:nth-of-type(1) .o_record_selector");
|
|
await click(target, "button.o_inspector_share");
|
|
await contains(".o_notification.border-success", {
|
|
text: "The share url has been copied to your clipboard.",
|
|
});
|
|
assert.verifySteps(["spreadsheet_shared", "share url copied"]);
|
|
});
|
|
|
|
QUnit.test("share a selected spreadsheet from the share button", async function (assert) {
|
|
const pyEnv = await startServer();
|
|
const folderId = pyEnv["documents.folder"].create({
|
|
display_name: "Workspace1",
|
|
has_write_access: true,
|
|
});
|
|
await loadBundle("spreadsheet.o_spreadsheet");
|
|
const model = new Model();
|
|
const documentId = pyEnv["documents.document"].create({
|
|
name: "My spreadsheet",
|
|
spreadsheet_data: JSON.stringify(model.exportData()),
|
|
folder_id: folderId,
|
|
handler: "spreadsheet",
|
|
});
|
|
const serverData = {
|
|
views: {
|
|
"documents.document,false,kanban": `
|
|
<kanban js_class="documents_kanban"><templates><t t-name="kanban-box">
|
|
<div>
|
|
<i class="fa fa-circle-thin o_record_selector"/>
|
|
<field name="name"/>
|
|
<field name="handler"/>
|
|
</div>
|
|
</t></templates></kanban>
|
|
`,
|
|
"documents.document,false,search": getEnrichedSearchArch(),
|
|
},
|
|
};
|
|
const { openView } = await start({
|
|
mockRPC: async (route, args) => {
|
|
if (args.method === "open_share_popup") {
|
|
assert.step("spreadsheet_shared");
|
|
const [shareVals] = args.args;
|
|
assert.strictEqual(args.model, "documents.share");
|
|
assert.deepEqual(shareVals.document_ids, [
|
|
x2ManyCommands.set([documentId]),
|
|
]);
|
|
assert.strictEqual(shareVals.folder_id, folderId);
|
|
assert.strictEqual(shareVals.type, "ids");
|
|
assert.deepEqual(shareVals.spreadsheet_shares, [
|
|
{
|
|
spreadsheet_data: JSON.stringify(model.exportData()),
|
|
document_id: documentId,
|
|
excel_files: JSON.parse(JSON.stringify(model.exportXLSX().files)),
|
|
},
|
|
]);
|
|
return "localhost:8069/share/url/132465";
|
|
}
|
|
},
|
|
serverData,
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
await click(target, ".o_kanban_record:nth-of-type(1) .o_record_selector");
|
|
const menu = target.querySelector(".o_control_panel .d-xl-inline-flex .btn-group");
|
|
await click(menu, ".dropdown-toggle");
|
|
await click(menu, "button.dropdown-item.o_documents_kanban_share_domain");
|
|
assert.verifySteps(["spreadsheet_shared"]);
|
|
});
|
|
|
|
QUnit.test("share the full workspace from the share button", async function (assert) {
|
|
const pyEnv = await startServer();
|
|
const folderId = pyEnv["documents.folder"].create({
|
|
display_name: "Workspace1",
|
|
has_write_access: true,
|
|
});
|
|
await loadBundle("spreadsheet.o_spreadsheet");
|
|
const model = new Model();
|
|
const documentId = pyEnv["documents.document"].create({
|
|
name: "My spreadsheet",
|
|
spreadsheet_data: JSON.stringify(model.exportData()),
|
|
folder_id: folderId,
|
|
handler: "spreadsheet",
|
|
});
|
|
const serverData = {
|
|
views: {
|
|
"documents.document,false,kanban": `
|
|
<kanban js_class="documents_kanban"><templates><t t-name="kanban-box">
|
|
<div>
|
|
<i class="fa fa-circle-thin o_record_selector"/>
|
|
<field name="name"/>
|
|
<field name="handler"/>
|
|
</div>
|
|
</t></templates></kanban>
|
|
`,
|
|
"documents.document,false,search": getEnrichedSearchArch(),
|
|
},
|
|
};
|
|
const { openView } = await start({
|
|
mockRPC: async (route, args) => {
|
|
if (args.method === "open_share_popup") {
|
|
assert.step("spreadsheet_shared");
|
|
const [shareVals] = args.args;
|
|
assert.strictEqual(args.model, "documents.share");
|
|
assert.strictEqual(shareVals.folder_id, folderId);
|
|
assert.strictEqual(shareVals.type, "domain");
|
|
assert.deepEqual(shareVals.domain, [["folder_id", "child_of", folderId]]);
|
|
assert.deepEqual(shareVals.spreadsheet_shares, [
|
|
{
|
|
spreadsheet_data: JSON.stringify(model.exportData()),
|
|
document_id: documentId,
|
|
excel_files: JSON.parse(JSON.stringify(model.exportXLSX().files)),
|
|
},
|
|
]);
|
|
return "localhost:8069/share/url/132465";
|
|
}
|
|
},
|
|
serverData,
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
const menu = target.querySelector(".o_control_panel .d-xl-inline-flex .btn-group");
|
|
await click(menu, ".dropdown-toggle");
|
|
await click(menu, "button.dropdown-item.o_documents_kanban_share_domain");
|
|
assert.verifySteps(["spreadsheet_shared"]);
|
|
});
|
|
|
|
QUnit.test("thumbnail size in document side panel", async function (assert) {
|
|
assert.expect(9);
|
|
const pyEnv = await startServer();
|
|
const documentsFolderId1 = pyEnv["documents.folder"].create({
|
|
display_name: "Workspace1",
|
|
has_write_access: true,
|
|
});
|
|
pyEnv["documents.document"].create([
|
|
{
|
|
name: "My spreadsheet",
|
|
spreadsheet_data: "{}",
|
|
is_favorited: false,
|
|
folder_id: documentsFolderId1,
|
|
handler: "spreadsheet",
|
|
},
|
|
{
|
|
name: "",
|
|
spreadsheet_data: "{}",
|
|
is_favorited: true,
|
|
folder_id: documentsFolderId1,
|
|
handler: "spreadsheet",
|
|
},
|
|
{
|
|
name: "",
|
|
spreadsheet_data: "{}",
|
|
folder_id: documentsFolderId1,
|
|
handler: "spreadsheet",
|
|
},
|
|
]);
|
|
const serverData = {
|
|
views: {
|
|
"documents.document,false,kanban": `
|
|
<kanban js_class="documents_kanban"><templates><t t-name="kanban-box">
|
|
<div>
|
|
<i class="fa fa-circle-thin o_record_selector"/>
|
|
<field name="name"/>
|
|
<field name="handler"/>
|
|
</div>
|
|
</t></templates></kanban>
|
|
`,
|
|
"documents.document,false,search": getEnrichedSearchArch(),
|
|
},
|
|
};
|
|
const { openView } = await start({
|
|
serverData,
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
await click(target, ".o_kanban_record:nth-of-type(1) .o_record_selector");
|
|
assert.containsOnce(target, ".o_documents_inspector_preview .o_document_preview");
|
|
assert.equal(
|
|
target.querySelector(".o_documents_inspector_preview .o_document_preview img")
|
|
.dataset.src,
|
|
"/documents/image/1/268x130?field=thumbnail&unique="
|
|
);
|
|
await click(target, ".o_kanban_record:nth-of-type(2) .o_record_selector");
|
|
assert.containsN(target, ".o_documents_inspector_preview .o_document_preview", 2);
|
|
let previews = target.querySelectorAll(
|
|
".o_documents_inspector_preview .o_document_preview img"
|
|
);
|
|
assert.equal(
|
|
previews[0].dataset.src,
|
|
"/documents/image/1/120x130?field=thumbnail&unique="
|
|
);
|
|
assert.equal(
|
|
previews[1].dataset.src,
|
|
"/documents/image/2/120x130?field=thumbnail&unique="
|
|
);
|
|
await click(target, ".o_kanban_record:nth-of-type(3) .o_record_selector");
|
|
assert.containsN(target, ".o_documents_inspector_preview .o_document_preview", 3);
|
|
previews = target.querySelectorAll(
|
|
".o_documents_inspector_preview .o_document_preview img"
|
|
);
|
|
assert.equal(
|
|
previews[0].dataset.src,
|
|
"/documents/image/1/120x75?field=thumbnail&unique="
|
|
);
|
|
assert.equal(
|
|
previews[1].dataset.src,
|
|
"/documents/image/2/120x75?field=thumbnail&unique="
|
|
);
|
|
assert.equal(
|
|
previews[2].dataset.src,
|
|
"/documents/image/3/120x75?field=thumbnail&unique="
|
|
);
|
|
});
|
|
|
|
QUnit.test(
|
|
"open xlsx converts to o-spreadsheet, clone it and opens the spreadsheet",
|
|
async function (assert) {
|
|
const spreadsheetCopyId = 99;
|
|
const pyEnv = await startServer();
|
|
const spreadsheetId = pyEnv["documents.document"].create([
|
|
{
|
|
name: "My excel file",
|
|
mimetype: XLSX_MIME_TYPES[0],
|
|
thumbnail_status: "present",
|
|
},
|
|
]);
|
|
const serverData = {
|
|
views: {
|
|
"documents.document,false,kanban": `
|
|
<kanban js_class="documents_kanban">
|
|
<templates>
|
|
<t t-name="kanban-box">
|
|
<div>
|
|
<div name="document_preview" class="o_kanban_image_wrapper">a thumbnail</div>
|
|
<i class="fa fa-circle-thin o_record_selector"/>
|
|
<field name="name"/>
|
|
<field name="handler"/>
|
|
</div>
|
|
</t>
|
|
</templates>
|
|
</kanban>
|
|
`,
|
|
"documents.document,false,search": getEnrichedSearchArch(),
|
|
},
|
|
};
|
|
const { env, openView } = await start({
|
|
mockRPC: async (route, args) => {
|
|
if (args.method === "clone_xlsx_into_spreadsheet") {
|
|
assert.step("spreadsheet_cloned", "it should clone the spreadsheet");
|
|
assert.strictEqual(args.model, "documents.document");
|
|
assert.deepEqual(args.args, [spreadsheetId]);
|
|
return spreadsheetCopyId;
|
|
}
|
|
},
|
|
serverData,
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
mockActionService(env, (action) => {
|
|
assert.step(action.tag, "it should open the spreadsheet");
|
|
assert.deepEqual(action.params.spreadsheet_id, spreadsheetCopyId);
|
|
});
|
|
const fixture = getFixture();
|
|
await click(fixture, ".oe_kanban_previewer");
|
|
|
|
// confirm conversion to o-spreadsheet
|
|
await click(fixture, ".modal-content .btn.btn-primary");
|
|
assert.verifySteps(["spreadsheet_cloned", "action_open_spreadsheet"]);
|
|
}
|
|
);
|
|
|
|
QUnit.test(
|
|
"open WPS-marked xlsx converts to o-spreadsheet, clone it and opens the spreadsheet",
|
|
async function (assert) {
|
|
const spreadsheetCopyId = 99;
|
|
const pyEnv = await startServer();
|
|
const spreadsheetId = pyEnv["documents.document"].create([
|
|
{
|
|
name: "My excel file",
|
|
mimetype: XLSX_MIME_TYPES[1],
|
|
thumbnail_status: "present",
|
|
},
|
|
]);
|
|
const serverData = {
|
|
views: {
|
|
"documents.document,false,kanban": `
|
|
<kanban js_class="documents_kanban">
|
|
<templates>
|
|
<t t-name="kanban-box">
|
|
<div>
|
|
<div name="document_preview" class="o_kanban_image_wrapper">a thumbnail</div>
|
|
<i class="fa fa-circle-thin o_record_selector"/>
|
|
<field name="name"/>
|
|
<field name="handler"/>
|
|
</div>
|
|
</t>
|
|
</templates>
|
|
</kanban>
|
|
`,
|
|
"documents.document,false,search": getEnrichedSearchArch(),
|
|
},
|
|
};
|
|
const { env, openView } = await start({
|
|
mockRPC: async (route, args) => {
|
|
if (args.method === "clone_xlsx_into_spreadsheet") {
|
|
assert.step("spreadsheet_cloned", "it should clone the spreadsheet");
|
|
assert.strictEqual(args.model, "documents.document");
|
|
assert.deepEqual(args.args, [spreadsheetId]);
|
|
return spreadsheetCopyId;
|
|
}
|
|
},
|
|
serverData,
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
mockActionService(env, (action) => {
|
|
assert.step(action.tag, "it should open the spreadsheet");
|
|
assert.deepEqual(action.params.spreadsheet_id, spreadsheetCopyId);
|
|
});
|
|
const fixture = getFixture();
|
|
await click(fixture, ".oe_kanban_previewer");
|
|
|
|
// confirm conversion to o-spreadsheet
|
|
await click(fixture, ".modal-content .btn.btn-primary");
|
|
assert.verifySteps(["spreadsheet_cloned", "action_open_spreadsheet"]);
|
|
}
|
|
);
|
|
|
|
QUnit.test(
|
|
"download spreadsheet document while selecting requested document",
|
|
async function (assert) {
|
|
assert.expect(1);
|
|
const pyEnv = await startServer();
|
|
const documentsFolderId1 = pyEnv["documents.folder"].create({
|
|
display_name: "Workspace1",
|
|
has_write_access: true,
|
|
});
|
|
pyEnv["documents.document"].create([
|
|
{
|
|
name: "My spreadsheet",
|
|
raw: "{}",
|
|
is_favorited: false,
|
|
folder_id: documentsFolderId1,
|
|
handler: "spreadsheet",
|
|
},
|
|
{
|
|
name: "Request",
|
|
folder_id: documentsFolderId1,
|
|
type: "empty",
|
|
},
|
|
]);
|
|
const serverData = {
|
|
views: {
|
|
"documents.document,false,kanban": `
|
|
<kanban js_class="documents_kanban"><templates><t t-name="kanban-box">
|
|
<div>
|
|
<i class="fa fa-circle-thin o_record_selector"/>
|
|
<field name="name"/>
|
|
<field name="handler"/>
|
|
</div>
|
|
</t></templates></kanban>
|
|
`,
|
|
"documents.document,false,search": getEnrichedSearchArch(),
|
|
},
|
|
};
|
|
const { openView } = await start({
|
|
serverData,
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
await click(target, ".o_kanban_record:nth-of-type(1) .o_record_selector");
|
|
await click(target, ".o_kanban_record:nth-of-type(2) .o_record_selector");
|
|
await click(target, "button.o_inspector_download");
|
|
await contains(".o_notification", {
|
|
text: "Spreadsheets mass download not yet supported.\n Download spreadsheets individually instead.",
|
|
});
|
|
}
|
|
);
|
|
|
|
QUnit.test(
|
|
"can open spreadsheet while multiple documents are selected along with it",
|
|
async function (assert) {
|
|
assert.expect(3);
|
|
const pyEnv = await startServer();
|
|
const documentsFolderId = pyEnv["documents.folder"].create({
|
|
display_name: "demo-workspace",
|
|
has_write_access: true,
|
|
});
|
|
pyEnv["documents.document"].create([
|
|
{
|
|
name: "test-spreadsheet",
|
|
raw: "{}",
|
|
folder_id: documentsFolderId,
|
|
handler: "spreadsheet",
|
|
thumbnail_status: "present",
|
|
},
|
|
{
|
|
folder_id: documentsFolderId,
|
|
mimetype: "image/png",
|
|
name: "test-image-1",
|
|
},
|
|
{
|
|
folder_id: documentsFolderId,
|
|
mimetype: "image/png",
|
|
name: "test-image-2",
|
|
},
|
|
]);
|
|
const views = {
|
|
"documents.document,false,kanban": `<kanban js_class="documents_kanban">
|
|
<templates>
|
|
<t t-name="kanban-box">
|
|
<div>
|
|
<div name="document_preview" class="o_kanban_image_wrapper">THUMBNAIL</div>
|
|
<i class="fa fa-circle-thin o_record_selector"/>
|
|
<field name="name"/>
|
|
<field name="handler"/>
|
|
</div>
|
|
</t>
|
|
</templates>
|
|
</kanban>`,
|
|
};
|
|
const { env, openView } = await createDocumentsViewWithMessaging({
|
|
hasWebClient: true,
|
|
serverData: { views },
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
patchWithCleanup(env.services.action, {
|
|
doAction(action) {
|
|
assert.step(action.tag);
|
|
},
|
|
});
|
|
const fixture = getFixture();
|
|
const records = fixture.querySelectorAll(".o_kanban_record");
|
|
await click(records[0], ".o_record_selector");
|
|
await click(records[1], ".o_record_selector");
|
|
await click(records[2], ".o_record_selector");
|
|
await click(fixture.querySelector(".oe_kanban_previewer"));
|
|
assert.containsNone(target, ".o-FileViewer");
|
|
assert.verifySteps(["action_open_spreadsheet"]);
|
|
}
|
|
);
|
|
|
|
QUnit.test(
|
|
"spreadsheet should be skipped while toggling the preview in the FileViewer",
|
|
async function (assert) {
|
|
const pyEnv = await startServer();
|
|
const documentsFolderId = pyEnv["documents.folder"].create({
|
|
display_name: "dogsFTW",
|
|
has_write_access: true,
|
|
});
|
|
pyEnv["documents.document"].create([
|
|
{
|
|
name: "dog-stats",
|
|
raw: "{}",
|
|
folder_id: documentsFolderId,
|
|
handler: "spreadsheet",
|
|
thumbnail_status: "present",
|
|
},
|
|
{
|
|
folder_id: documentsFolderId,
|
|
mimetype: "image/png",
|
|
name: "pug",
|
|
},
|
|
{
|
|
folder_id: documentsFolderId,
|
|
mimetype: "image/png",
|
|
name: "chihuahua",
|
|
},
|
|
]);
|
|
const { openView } = await createDocumentsViewWithMessaging({
|
|
hasWebClient: true,
|
|
serverData: {
|
|
views: {
|
|
"documents.document,false,kanban": `<kanban js_class="documents_kanban">
|
|
<templates>
|
|
<t t-name="kanban-box">
|
|
<div>
|
|
<div name="document_preview" class="o_kanban_image_wrapper">THUMBNAIL</div>
|
|
<field name="name"/>
|
|
</div>
|
|
</t>
|
|
</templates>
|
|
</kanban>`,
|
|
},
|
|
},
|
|
});
|
|
await openView({
|
|
res_model: "documents.document",
|
|
views: [[false, "kanban"]],
|
|
});
|
|
await click(target, ".o_kanban_record:nth-of-type(3) div[name='document_preview']");
|
|
assert.containsOnce(target, ".o-FileViewer");
|
|
await click(target, ".o-FileViewer-navigation[aria-label='Next']");
|
|
assert.strictEqual(target.querySelector("div[name='name'] input").value, "pug");
|
|
}
|
|
);
|
|
}
|
|
);
|