Debian Codegraph @

addons/web/static/tests/views/form/auto_save.test.js

raw
1 import { expect, test } from "@odoo/hoot";
2 import { unload } from "@odoo/hoot-dom";
3 import { animationFrame, Deferred, mockSendBeacon } from "@odoo/hoot-mock";
4 import {
5 contains,
6 defineActions,
7 defineModels,
8 fieldInput,
9 fields,
10 getService,
11 hideTab,
12 makeServerError,
13 models,
14 mountView,
15 mountViewInDialog,
16 mountWithCleanup,
17 onRpc,
18 } from "../../web_test_helpers";
19
20 import { WebClient } from "@web/webclient/webclient";
21
22 onRpc("has_group", () => true);
23
24 class Partner extends models.Model {
25 name = fields.Char();
26 expertise = fields.Char({ default: "Marketing" });
27 _records = [
28 { id: 1, name: "Xavier Lancer", expertise: "Sales" },
29 { id: 2, name: "Keth MacBeat", expertise: "HR" },
30 ];
31 }
32
33 defineModels([Partner]);
34
35 test("save on hiding tab", async () => {
36 onRpc("web_save", () => {
37 expect.step("save");
38 });
39 await mountView({
40 type: "form",
41 resModel: "partner",
42 arch: `<form><field name="name"/></form>`,
43 resId: 1,
44 });
45 expect('.o_field_widget[name="name"] input').toHaveValue("Xavier Lancer");
46 await fieldInput("name").edit("Mathiew Brown");
47 await hideTab();
48 expect.verifySteps(["save"]);
49 });
50
51 test("save on hiding tab (not dirty)", async () => {
52 onRpc("web_save", () => {
53 expect.step("save");
54 });
55 await mountView({
56 type: "form",
57 resModel: "partner",
58 arch: `<form><field name="name"/></form>`,
59 resId: 1,
60 });
61 await hideTab();
62 // should not have saved
63 expect.verifySteps([]);
64 });
65
66 test("save on hiding tab (invalid field)", async () => {
67 onRpc("web_save", () => {
68 expect.step("save");
69 });
70 await mountView({
71 type: "form",
72 resModel: "partner",
73 arch: `<form><field name="name" required="1"/></form>`,
74 });
75 await hideTab();
76 // should not save because of invalid field
77 expect.verifySteps([]);
78 });
79
80 test("save only once when hiding tab several times quickly", async () => {
81 onRpc("web_save", () => {
82 expect.step("save");
83 });
84 await mountView({
85 type: "form",
86 resModel: "partner",
87 arch: `<form><field name="name"/></form>`,
88 resId: 1,
89 });
90 expect('.o_field_widget[name="name"] input').toHaveValue("Xavier Lancer");
91 await fieldInput("name").edit("Mathiew Brown");
92 await hideTab();
93 await hideTab();
94 await hideTab();
95 // should have saved, but only once
96 expect.verifySteps(["save"]);
97 });
98
99 test.tags("desktop");
100 test(`save when page changed`, async () => {
101 defineActions([
102 {
103 id: 1,
104 name: "Partner",
105 res_model: "partner",
106 views: [
107 [false, "list"],
108 [false, "form"],
109 ],
110 },
111 ]);
112
113 Partner._views = {
114 list: `<list><field name="name"/></list>`,
115 form: `
116 <form>
117 <group>
118 <field name="name"/>
119 </group>
120 </form>
121 `,
122 };
123
124 onRpc("web_save", ({ args }) => {
125 expect.step("web_save");
126 expect(args).toEqual([[1], { name: "aaa" }]);
127 });
128 await mountWithCleanup(WebClient);
129 await getService("action").doAction(1);
130 await contains(`.o_data_row td.o_data_cell`).click();
131 expect(`.o_breadcrumb`).toHaveText("Partner\nXavier Lancer");
132
133 await contains(`.o_field_widget[name='name'] input`).edit("aaa");
134 await contains(`.o_pager button.o_pager_next`).click();
135 expect.verifySteps(["web_save"]);
136 expect(`.o_form_editable`).toHaveCount(1);
137 expect(`.o_breadcrumb`).toHaveText("Partner\nKeth MacBeat");
138 expect(`.o_field_widget[name="name"] input`).toHaveValue("Keth MacBeat");
139
140 await contains(`.o_form_button_cancel`, { visible: false }).click();
141 expect(`.o_breadcrumb`).toHaveText("Partner\nKeth MacBeat");
142 expect(`.o_field_widget[name="name"] input`).toHaveValue("Keth MacBeat");
143
144 await contains(`.o_pager button.o_pager_previous`).click();
145 expect(`.o_form_saved`).toHaveCount(1);
146 expect(`.o_breadcrumb`).toHaveText("Partner\naaa");
147 expect(`.o_field_widget[name="name"] input`).toHaveValue("aaa");
148 });
149
150 test.tags("desktop");
151 test(`save when breadcrumb clicked`, async () => {
152 defineActions([
153 {
154 id: 1,
155 name: "Partner",
156 res_model: "partner",
157 views: [
158 [false, "list"],
159 [false, "form"],
160 ],
161 },
162 ]);
163
164 Partner._views = {
165 list: `<list><field name="name"/></list>`,
166 form: `
167 <form>
168 <group>
169 <field name="name"/>
170 </group>
171 </form>
172 `,
173 };
174
175 onRpc("web_save", ({ args }) => {
176 expect.step("web_save");
177 expect(args).toEqual([[1], { name: "aaa" }]);
178 });
179
180 await mountWithCleanup(WebClient);
181 await getService("action").doAction(1);
182 expect(`.o_field_cell:eq(0)`).toHaveText("Xavier Lancer");
183
184 await contains(`.o_data_row td.o_data_cell`).click();
185 expect(`.o_breadcrumb`).toHaveText("Partner\nXavier Lancer");
186
187 await contains(`.o_field_widget[name='name'] input`).edit("aaa");
188 await contains(`.breadcrumb-item.o_back_button`).click();
189 expect.verifySteps(["web_save"]);
190 expect(`.o_breadcrumb`).toHaveText("Partner");
191 expect(`.o_field_cell:eq(0)`).toHaveText("aaa");
192
193 await contains(`.o_data_row td.o_data_cell`).click();
194 expect(`.o_form_editable`).toHaveCount(1);
195 expect(`.o_breadcrumb`).toHaveText("Partner\naaa");
196 expect('.o_field_widget[name="name"] input').toHaveValue("aaa");
197 });
198
199 test.tags("desktop");
200 test(`error on save when breadcrumb clicked`, async () => {
201 defineActions([
202 {
203 id: 1,
204 name: "Partner",
205 res_model: "partner",
206 views: [
207 [false, "list"],
208 [false, "form"],
209 ],
210 },
211 ]);
212
213 Partner._views = {
214 list: `<list><field name="name"/></list>`,
215 form: `
216 <form>
217 <group>
218 <field name="name"/>
219 </group>
220 </form>
221 `,
222 };
223
224 onRpc("web_save", () => {
225 expect.step("web_save");
226 throw makeServerError({ message: "Cannot save" });
227 });
228 await mountWithCleanup(WebClient);
229 await getService("action").doAction(1);
230 await contains(`.o_data_row td.o_data_cell`).click();
231
232 await contains(`.o_field_widget[name='name'] input`).edit("aaa");
233 await contains(`.breadcrumb-item.o_back_button`).click();
234 expect.verifySteps(["web_save"]);
235 await animationFrame();
236 expect(`.o_form_error_dialog`).toHaveCount(1);
237 });
238
239 test.tags("desktop");
240 test(`save when action changed`, async () => {
241 defineActions([
242 {
243 id: 1,
244 name: "Partner",
245 res_model: "partner",
246 views: [
247 [false, "list"],
248 [false, "form"],
249 ],
250 },
251 {
252 id: 2,
253 name: "Other action",
254 res_model: "partner",
255 views: [[false, "kanban"]],
256 },
257 ]);
258
259 Partner._views = {
260 list: `<list><field name="name"/></list>`,
261 form: `
262 <form>
263 <group>
264 <field name="name"/>
265 </group>
266 </form>
267 `,
268 kanban: `
269 <kanban>
270 <templates>
271 <t t-name="card"/>
272 </templates>
273 </kanban>
274 `,
275 };
276
277 onRpc("web_save", ({ args }) => {
278 expect.step("web_save");
279 expect(args).toEqual([[1], { name: "aaa" }]);
280 });
281
282 await mountWithCleanup(WebClient);
283 await getService("action").doAction(1);
284
285 await contains(`.o_data_row td.o_data_cell`).click();
286 expect(`.o_breadcrumb`).toHaveText("Partner\nXavier Lancer");
287
288 await contains(`.o_field_widget[name='name'] input`).edit("aaa");
289 await getService("action").doAction(2, { clearBreadcrumbs: true });
290 expect.verifySteps(["web_save"]);
291
292 expect(`.o_breadcrumb`).toHaveText("Other action");
293 await getService("action").doAction(1, { clearBreadcrumbs: true });
294
295 await contains(`.o_data_row td.o_data_cell`).click();
296 expect(`.o_form_editable`).toHaveCount(1);
297 expect(`.o_breadcrumb`).toHaveText("Partner\naaa");
298 expect('.o_field_widget[name="name"] input').toHaveValue("aaa");
299 });
300
301 test("save on closing tab/browser", async () => {
302 const sendBeaconDeferred = new Deferred();
303 mockSendBeacon((_, blob) => {
304 expect.step("sendBeacon");
305 blob.text().then((r) => {
306 const { params } = JSON.parse(r);
307 if (params.method === "web_save" && params.model === "partner") {
308 expect(params.args).toEqual([[1], { name: "test" }]);
309 }
310 sendBeaconDeferred.resolve();
311 });
312 return true;
313 });
314
315 await mountView({
316 resModel: "partner",
317 type: "form",
318 arch: `
319 <form>
320 <group>
321 <field name="name"/>
322 </group>
323 </form>
324 `,
325 resId: 1,
326 });
327
328 expect(`.o_field_widget[name="name"] input`).not.toHaveValue("test");
329 await contains(`.o_field_widget[name="name"] input`).edit("test");
330
331 const [event] = await unload();
332 await sendBeaconDeferred;
333 expect.verifySteps(["sendBeacon"]);
334 expect(event.defaultPrevented).toBe(false);
335
336 // With all changes saved, the save/discard buttons should now be invisible.
337 // While it typically doesn't matter when leaving a page, an urgent save may get triggered
338 // by a user action that remains on the page, e.g. opening a VoIP client (see opw 4308954).
339 await animationFrame();
340 expect(`.o_form_status_indicator_buttons:not(.invisible)`).toHaveCount(0);
341 });
342
343 test("save on closing tab/browser (sendBeacon fails)", async () => {
344 mockSendBeacon(() => {
345 expect.step("sendBeacon");
346 return false;
347 });
348
349 await mountView({
350 resModel: "partner",
351 type: "form",
352 arch: `
353 <form>
354 <group>
355 <field name="name"/>
356 </group>
357 </form>
358 `,
359 resId: 1,
360 });
361
362 expect(`.o_field_widget[name="name"] input`).not.toHaveValue("test");
363 await contains(`.o_field_widget[name="name"] input`).edit("test");
364
365 const [event] = await unload();
366 await animationFrame();
367 expect.verifySteps(["sendBeacon"]);
368 expect(event.defaultPrevented).toBe(true);
369 expect(`.o_notification`).toHaveCount(1);
370
371 await contains(`.o_form_button_save`).click();
372 expect(`.o_notification`).toHaveCount(0);
373 });
374
375 test("save on closing tab/browser (invalid field)", async () => {
376 mockSendBeacon(() => expect.step("sendBeacon"));
377 onRpc("partner", "web_save", () => expect.step("save"));
378
379 await mountView({
380 resModel: "partner",
381 type: "form",
382 arch: `
383 <form>
384 <group>
385 <field name="name" required="1"/>
386 </group>
387 </form>
388 `,
389 resId: 1,
390 });
391 await contains(`.o_field_widget[name="name"] input`).edit("");
392 const [event] = await unload();
393 await animationFrame();
394 expect.verifySteps([]);
395 expect(event.defaultPrevented).toBe(true);
396 expect(`.o_notification`).toHaveCount(1);
397 });
398
399 test("save on closing tab/browser (not dirty)", async () => {
400 mockSendBeacon(() => expect.step("sendBeacon"));
401 onRpc("partner", "web_save", () => expect.step("save"));
402
403 await mountView({
404 resModel: "partner",
405 type: "form",
406 arch: `
407 <form>
408 <group>
409 <field name="name"/>
410 </group>
411 </form>
412 `,
413 resId: 1,
414 });
415
416 await unload();
417 await animationFrame();
418 expect.verifySteps([]);
419 });
420
421 test("save on closing tab/browser (not dirty but trailing spaces)", async () => {
422 Partner._fields.expertise = fields.Char({ trim: true });
423 Partner._records[0].expertise = "name with trailing spaces ";
424
425 mockSendBeacon(() => {
426 throw new Error("no write should be done");
427 });
428 onRpc(({ method }) => expect.step(method));
429
430 await mountView({
431 resModel: "partner",
432 type: "form",
433 arch: `<form><field name="expertise"/></form>`,
434 resId: 1,
435 });
436 expect.verifySteps(["get_views", "web_read"]);
437 expect(`.o_field_widget[name=expertise] input`).toHaveValue("name with trailing spaces ");
438
439 await unload();
440 await animationFrame();
441 expect.verifySteps([]);
442 });
443
444 test("save on closing tab/browser (not dirty) with text field", async () => {
445 Partner._fields.information = fields.Text();
446
447 mockSendBeacon(() => expect.step("sendBeacon"));
448 onRpc("web_save", () => expect.step("save"));
449
450 await mountView({
451 resModel: "partner",
452 type: "form",
453 arch: `
454 <form>
455 <group>
456 <field name="information"/>
457 </group>
458 </form>
459 `,
460 resId: 1,
461 });
462 expect(`.o_field_widget[name=information] textarea`).toHaveValue("");
463
464 await unload();
465 await animationFrame();
466 expect.verifySteps([]);
467 });
468
469 test.tags("desktop");
470 test(`save on closing tab/browser (detached form)`, async () => {
471 defineActions([
472 {
473 id: 1,
474 name: "Partner",
475 res_model: "partner",
476 views: [
477 [false, "list"],
478 [false, "form"],
479 ],
480 },
481 ]);
482 Partner._views = {
483 list: `<list><field name="name"/></list>`,
484 form: `
485 <form>
486 <group>
487 <field name="name"/>
488 </group>
489 </form>
490 `,
491 };
492
493 mockSendBeacon(() => expect.step("sendBeacon"));
494 onRpc("web_save", () => expect.step("save"));
495
496 await mountWithCleanup(WebClient);
497 await getService("action").doAction(1);
498
499 await contains(`.o_data_row td.o_data_cell`).click();
500 expect(`.o_breadcrumb`).toHaveText("Partner\nXavier Lancer");
501
502 await contains(`.o_back_button`).click();
503 expect(`.o_breadcrumb`).toHaveText("Partner");
504
505 await unload();
506 await animationFrame();
507 expect.verifySteps([]);
508 });
509
510 test("save on closing tab/browser (onchanges)", async () => {
511 Partner._onChanges = {
512 expertise(record) {
513 record.name = `copy: ${record.expertise}`;
514 },
515 };
516
517 const sendBeaconDeferred = new Deferred();
518 mockSendBeacon((_, blob) => {
519 expect.step("sendBeacon");
520 blob.text().then((r) => {
521 const { params } = JSON.parse(r);
522 if (params.method === "web_save" && params.model === "partner") {
523 expect(params.args).toEqual([[1], { expertise: "test" }]);
524 }
525 sendBeaconDeferred.resolve();
526 });
527 return true;
528 });
529
530 const onchangeDeferred = new Deferred();
531 onRpc("partner", "onchange", () => onchangeDeferred);
532
533 await mountView({
534 resModel: "partner",
535 type: "form",
536 arch: `
537 <form>
538 <group>
539 <field name="name"/>
540 <field name="expertise"/>
541 </group>
542 </form>
543 `,
544 resId: 1,
545 });
546
547 await contains(`.o_field_widget[name="expertise"] input`).edit("test", { confirm: "blur" });
548 await unload();
549 await animationFrame();
550 await sendBeaconDeferred;
551 expect.verifySteps(["sendBeacon"]);
552 });
553
554 test("save on closing tab/browser (onchanges 2)", async () => {
555 Partner._onChanges = {
556 expertise() {},
557 };
558
559 const sendBeaconDeferred = new Deferred();
560 mockSendBeacon((_, blob) => {
561 expect.step("sendBeacon");
562 blob.text().then((r) => {
563 const { params } = JSON.parse(r);
564 if (params.method === "web_save") {
565 expect(params.args).toEqual([[1], { expertise: "test1", name: "test2" }]);
566 }
567 sendBeaconDeferred.resolve();
568 });
569 return true;
570 });
571
572 const onchangeDeferred = new Deferred();
573 onRpc("partner", "onchange", () => onchangeDeferred);
574
575 await mountView({
576 resModel: "partner",
577 type: "form",
578 arch: `
579 <form>
580 <group>
581 <field name="expertise"/>
582 <field name="name"/>
583 </group>
584 </form>
585 `,
586 resId: 1,
587 });
588
589 await contains(`.o_field_widget[name="expertise"] input`).edit("test1", { confirm: "blur" });
590 await contains(`.o_field_widget[name="name"] input`).edit("test2", { confirm: "blur" });
591
592 await unload();
593 await animationFrame();
594 await sendBeaconDeferred;
595 expect.verifySteps(["sendBeacon"]);
596 });
597
598 test("save on closing tab/browser (pending change)", async () => {
599 const sendBeaconDeferred = new Deferred();
600 mockSendBeacon((_, blob) => {
601 expect.step("sendBeacon");
602 blob.text().then((r) => {
603 const { params } = JSON.parse(r);
604 if (params.method === "web_save") {
605 expect(params.args).toEqual([[1], { expertise: "test" }]);
606 }
607 sendBeaconDeferred.resolve();
608 });
609 return true;
610 });
611
612 onRpc(({ method }) => expect.step(method));
613 await mountView({
614 resModel: "partner",
615 type: "form",
616 arch: `<form><field name="expertise"/></form>`,
617 resId: 1,
618 });
619 expect.verifySteps(["get_views", "web_read"]);
620
621 // edit 'expertise' but do not focusout -> the model isn't aware of the change
622 // until the 'beforeunload' event is triggered
623 await contains(`.o_field_widget[name="expertise"] input`).edit("test", { confirm: false });
624 await unload();
625 await animationFrame();
626 await sendBeaconDeferred;
627 expect.verifySteps(["sendBeacon"]);
628 });
629
630 test("save on closing tab/browser (onchanges + pending change)", async () => {
631 Partner._fields.unformatted_name = fields.Char();
632 Partner._onChanges = {
633 unformatted_name(record) {
634 record.name = record.unformatted_name.toLowerCase().trim();
635 },
636 };
637
638 const sendBeaconDeferred = new Deferred();
639 mockSendBeacon((_, blob) => {
640 expect.step("sendBeacon");
641 blob.text().then((r) => {
642 const { params } = JSON.parse(r);
643 if (params.method === "web_save") {
644 expect(params.args).toEqual([
645 [1],
646 { unformatted_name: "John Doe ", name: "john doe", expertise: "test" },
647 ]);
648 }
649 sendBeaconDeferred.resolve();
650 });
651 return true;
652 });
653
654 const onchangeDeferred = new Deferred();
655 onRpc("partner", "onchange", () => onchangeDeferred);
656 onRpc(({ method }) => expect.step(method));
657
658 await mountView({
659 type: "form",
660 resModel: "partner",
661 arch: `
662 <form>
663 <field name="unformatted_name"/>
664 <field name="name"/>
665 <field name="expertise"/>
666 </form>
667 `,
668 resId: 1,
669 });
670 expect.verifySteps(["get_views", "web_read"]);
671
672 // edit 'unformatted_name' and simulate a focusout (trigger the 'change' event)
673 await contains(`.o_field_widget[name="unformatted_name"] input`).edit("John Doe ", {
674 confirm: "blur",
675 });
676 expect.verifySteps(["onchange"]);
677
678 // edit 'name' and simulate a focusout (trigger the 'change' event)
679 await contains(`.o_field_widget[name="name"] input`).edit("john doe", { confirm: "blur" });
680
681 // edit 'expertise' but do not focusout -> the model isn't aware of the change
682 // until the 'beforeunload' event is triggered
683 await contains(`.o_field_widget[name="expertise"] input`).edit("test", { confirm: false });
684
685 // trigger the 'beforeunload' event -> notifies the model directly and saves
686 await unload();
687 await animationFrame();
688 await sendBeaconDeferred;
689 expect.verifySteps(["sendBeacon"]);
690 });
691
692 test("save on closing tab/browser (invalid pending change)", async () => {
693 Partner._fields.age = fields.Integer();
694
695 mockSendBeacon(() => expect.step("sendBeacon"));
696 onRpc(({ method }) => expect.step(method));
697
698 await mountView({
699 resModel: "partner",
700 type: "form",
701 arch: `<form><field name="age"/></form>`,
702 resId: 1,
703 });
704 expect.verifySteps(["get_views", "web_read"]);
705
706 // edit 'expertise' but do not focusout -> the model isn't aware of the change
707 // until the 'beforeunload' event is triggered
708 await contains(`.o_field_widget[name="age"] input`).edit("invalid value", { confirm: false });
709 await unload();
710 await animationFrame();
711 expect.verifySteps([]);
712 });
713
714 test("save on closing tab/browser (onchanges + invalid field)", async () => {
715 Partner._onChanges = {
716 expertise(record) {
717 record.name = `copy: ${record.expertise}`;
718 },
719 };
720
721 mockSendBeacon(() => expect.step("sendBeacon"));
722 const onchangeDeferred = new Deferred();
723 onRpc("partner", "onchange", () => onchangeDeferred);
724 onRpc(({ method }) => expect.step(method));
725
726 await mountView({
727 resModel: "partner",
728 type: "form",
729 arch: `
730 <form>
731 <group>
732 <field name="expertise"/>
733 <field name="name" required="1"/>
734 </group>
735 </form>
736 `,
737 resId: 1,
738 });
739 expect.verifySteps(["get_views", "web_read"]);
740
741 await contains(`.o_field_widget[name="expertise"] input`).edit("test", { confirm: "blur" });
742 expect.verifySteps(["onchange"]);
743
744 await contains(`.o_field_widget[name="name"] input`).edit("", { confirm: "blur" });
745 await unload();
746 await animationFrame();
747 expect.verifySteps([]);
748 });
749
750 test("save when action button clicked", async () => {
751 onRpc("web_save", () => expect.step("save"));
752 await mountView({
753 resModel: "partner",
754 type: "form",
755 arch: `<form><field name="expertise"/></form>`,
756 actionMenus: {},
757 resId: 1,
758 });
759 expect(`.o_field_widget[name='expertise'] input`).toHaveValue("Sales");
760
761 await contains(`.o_field_widget[name='expertise'] input`).edit("test");
762 expect(`.o_field_widget[name='expertise'] input`).toHaveValue("test");
763
764 await contains(`.o_cp_action_menus button`).click();
765 await contains(`.o-dropdown--menu .dropdown-item`).click();
766 expect.verifySteps(["save"]);
767 expect(`.o_field_widget[name='expertise'] input`).toHaveValue("test");
768
769 await contains(`.o_pager_previous`).click();
770 expect(`.o_field_widget[name='expertise'] input`).toHaveValue("test");
771 });
772
773 test.tags("desktop");
774 test(`save when action button clicked on desktop`, async () => {
775 await mountView({
776 resModel: "partner",
777 type: "form",
778 arch: `<form><field name="expertise"/></form>`,
779 actionMenus: {},
780 resId: 1,
781 });
782
783 await contains(`.o_field_widget[name='expertise'] input`).edit("test");
784 expect(`.o_pager_counter`).toHaveText("1 / 1");
785
786 await contains(`.o_cp_action_menus button`).click();
787 await contains(`.o-dropdown--menu .dropdown-item`).click();
788 expect(`.o_pager_counter`).toHaveText("2 / 2");
789
790 await contains(`.o_pager_previous`).click();
791 expect(`.o_pager_counter`).toHaveText("1 / 2");
792 });
793
794 test("error on save when action button clicked", async () => {
795 onRpc("web_save", () => {
796 expect.step("save");
797 throw makeServerError();
798 });
799 await mountView({
800 resModel: "partner",
801 type: "form",
802 arch: `<form><field name="expertise"/></form>`,
803 actionMenus: {},
804 resId: 1,
805 });
806
807 await contains(`.o_field_widget[name='expertise'] input`).edit("test");
808 await contains(`.o_cp_action_menus button`).click();
809 await contains(`.o-dropdown--menu .dropdown-item`).click();
810 expect.verifySteps(["save"]);
811 await animationFrame();
812 expect(`.o_form_error_dialog`).toHaveCount(1);
813 });
814
815 test.tags("desktop");
816 test(`save when create button clicked`, async () => {
817 onRpc("web_save", () => expect.step("save"));
818 await mountView({
819 resModel: "partner",
820 type: "form",
821 arch: `<form><field name="expertise"/></form>`,
822 resId: 1,
823 });
824 expect(`.o_field_widget[name='expertise'] input`).toHaveValue("Sales");
825
826 await contains(`.o_field_widget[name='expertise'] input`).edit("test");
827 await contains(`.o_control_panel_main_buttons .o_form_button_create`).click();
828 expect.verifySteps(["save"]);
829 expect(`.o_field_widget[name='expertise'] input`).toHaveValue("Marketing");
830 expect(`.o_breadcrumb .active`).toHaveText("New");
831 });
832
833 test("error on save when create button clicked", async () => {
834 onRpc("web_save", () => {
835 expect.step("save");
836 throw makeServerError();
837 });
838 await mountView({
839 resModel: "partner",
840 type: "form",
841 arch: `<form><field name="expertise"/></form>`,
842 actionMenus: {},
843 resId: 1,
844 });
845
846 await contains(`.o_field_widget[name='expertise'] input`).edit("test");
847 await contains(`.o_form_button_create`).click();
848 expect.verifySteps(["save"]);
849 await animationFrame();
850 expect(`.o_form_error_dialog`).toHaveCount(1);
851 });
852
853 test("doesn't autosave when in dialog (visibility change)", async () => {
854 onRpc("web_save", () => {
855 expect.step("should not call web_save");
856 });
857 await mountViewInDialog({
858 resModel: "partner",
859 type: "form",
860 arch: `<form><field name="name"/></form>`,
861 resId: 1,
862 });
863 expect('.o_field_widget[name="name"] input').toHaveValue("Xavier Lancer");
864 await fieldInput("name").edit("Mathiew Brown");
865 await hideTab();
866 expect.verifySteps([]);
867 });
868
869 test("doesn't autosave when in dialog (beacon)", async () => {
870 mockSendBeacon(() => expect.step("sendBeacon"));
871 await mountViewInDialog({
872 resModel: "partner",
873 type: "form",
874 arch: `<form><field name="name"/></form>`,
875 resId: 1,
876 });
877 expect('.o_field_widget[name="name"] input').toHaveValue("Xavier Lancer");
878 await fieldInput("name").edit("Mathiew Brown");
879 await unload();
880 await animationFrame();
881 expect.verifySteps([]);
882 });
883
884 test.tags("desktop");
885 test(`doesn't autosave when a many2one search more is open (visibility change)`, async () => {
886 Partner._fields.product_id = fields.Many2one({ relation: "product" });
887
888 class Product extends models.Model {
889 name = fields.Char();
890 _records = [
891 { id: 37, name: "xphone" },
892 { id: 41, name: "xpad" },
893 ];
894 }
895
896 Product._views = {
897 form: `
898 <form>
899 <group>
900 <field name="name"/>
901 </group>
902 </form>
903 `,
904 list: `
905 <list>
906 <field name="name"/>
907 </list>
908 `,
909 };
910
911 defineModels([Product]);
912
913 onRpc("web_save", () => {
914 expect.step("should not call web_save");
915 });
916 await mountView({
917 resModel: "partner",
918 type: "form",
919 arch: `
920 <form>
921 <sheet>
922 <field name="product_id" domain="[]" context="{'lang': 'en_US'}" widget="many2one"/>
923 </sheet>
924 </form>
925 `,
926 resId: 1,
927 });
928 await contains(`.o_field_many2one_selection .o-autocomplete--input`).click();
929 await contains(`.o_m2o_dropdown_option_search_more`).click();
930 expect(`.modal`).toHaveCount(1);
931 await contains(`.o_create_button`).click();
932 expect(`.modal`).toHaveCount(2);
933 await hideTab();
934 expect.verifySteps([]);
935 });
936
937 test(`doesn't autosave when a x2many is in openned (visibility change)`, async () => {
938 Partner._fields.child_ids = fields.One2many({ string: "one2many field", relation: "partner" });
939 Partner._records[0].child_ids = [1, 2];
940 onRpc("web_save", () => {
941 expect.step("web_save");
942 });
943 await mountView({
944 resModel: "partner",
945 type: "form",
946 arch: `
947 <form>
948 <field name="expertise"/>
949 <field name="child_ids">
950 <kanban>
951 <templates>
952 <t t-name="card">
953 <field name="name"/>
954 </t>
955 </templates>
956 </kanban>
957 <form>
958 <field name="name"/>
959 </form>
960 </field>
961 </form>
962 `,
963 resId: 1,
964 });
965 await fieldInput("expertise").edit("HR");
966 expect(`.o_form_status_indicator_buttons:not(.invisible)`).toHaveCount(1);
967
968 await contains(`.o-kanban-button-new`).click();
969 expect(`.modal`).toHaveCount(1);
970 await fieldInput("name").edit("Test McTest");
971
972 await hideTab();
973 await animationFrame();
974 expect(`.o_form_status_indicator_buttons:not(.invisible)`).toHaveCount(1);
975 expect.verifySteps([]); // should not call web_save
976 await contains(`.o_form_button_save`).click();
977 expect.verifySteps(["web_save"]);
978 });
979
980 test(`doesn't autosave when a x2many is in openned (visibility change) 2`, async () => {
981 Partner._fields.child_ids = fields.One2many({ string: "one2many field", relation: "partner" });
982 Partner._records[0].child_ids = [1, 2];
983 onRpc("web_save", () => {
984 expect.step("web_save");
985 });
986 await mountView({
987 resModel: "partner",
988 type: "form",
989 arch: `
990 <form>
991 <field name="expertise"/>
992 <field name="child_ids">
993 <kanban>
994 <templates>
995 <t t-name="card">
996 <field name="name"/>
997 </t>
998 </templates>
999 </kanban>
1000 <form>
1001 <field name="name"/>
1002 </form>
1003 </field>
1004 </form>
1005 `,
1006 resId: 1,
1007 });
1008 await fieldInput("expertise").edit("HR");
1009 expect(`.o_form_status_indicator_buttons:not(.invisible)`).toHaveCount(1);
1010
1011 await contains(`.o-kanban-button-new`).click();
1012 expect(`.modal`).toHaveCount(1);
1013 await fieldInput("name").edit("Test McTest");
1014
1015 await hideTab();
1016 await animationFrame();
1017 expect(`.o_form_status_indicator_buttons:not(.invisible)`).toHaveCount(1);
1018 expect.verifySteps([]); // should not call web_save
1019 await contains(`.o_dialog .o_form_button_cancel`).click();
1020 expect.verifySteps([]); // should not call web_save
1021
1022 await hideTab();
1023 await animationFrame();
1024 expect(`.o_form_status_indicator_buttons:not(.invisible)`).toHaveCount(0);
1025 expect.verifySteps(["web_save"]);
1026 });