Debian Codegraph @

addons/web/static/tests/views/fields/daterange_field.test.js

raw
1 import { after, beforeEach, expect, test } from "@odoo/hoot";
2 import {
3 animationFrame,
4 click,
5 Deferred,
6 edit,
7 press,
8 queryAll,
9 queryAllProperties,
10 queryAllTexts,
11 queryAllValues,
12 queryFirst,
13 queryValue,
14 resize,
15 } from "@odoo/hoot-dom";
16 import { disableAnimations, mockDate, mockTimeZone } from "@odoo/hoot-mock";
17 import { resetDateFieldWidths } from "@web/views/list/column_width_hook";
18 import {
19 clickSave,
20 contains,
21 defineModels,
22 fields,
23 models,
24 mountView,
25 onRpc,
26 pagerNext,
27 patchWithCleanup,
28 } from "../../web_test_helpers";
29 import { _makeUser, user } from "@web/core/user";
30
31 function getPickerCell(expr) {
32 return queryAll(`.o_datetime_picker .o_date_item_cell:text(${expr})`);
33 }
34
35 class Partner extends models.Model {
36 date = fields.Date({ string: "A date", searchable: true });
37 datetime = fields.Datetime({ string: "A datetime", searchable: true });
38 datetime_end = fields.Datetime({ string: "Datetime End" });
39 bool_field = fields.Boolean({ string: "A boolean" });
40 _records = [
41 {
42 id: 1,
43 date: "2017-02-03",
44 datetime: "2017-02-08 10:00:00",
45 },
46 ];
47 }
48
49 class User extends models.Model {
50 _name = "res.users";
51
52 name = fields.Char();
53
54 has_group() {
55 return true;
56 }
57 }
58
59 defineModels([Partner, User]);
60
61 beforeEach(() => {
62 // Date field should not have an offset as they are ignored.
63 // However, in the test environement, a UTC timezone is set to run all tests. And if any code does not use the safe timezone method
64 // provided by the framework (which happens in this case inside the date range picker lib), unexpected behavior kicks in as the timezone
65 // of the dev machine collides with the timezone set by the test env.
66 // To avoid failing test on dev's local machines, a hack is to apply an timezone offset greater than the difference between UTC and the dev's
67 // machine timezone. For belgium, > 60 is enough. For India, > 5h30 is required, hence 330.
68 mockTimeZone(+5.5);
69
70 disableAnimations();
71 });
72
73 test("Datetime field without daterange widget", async () => {
74 await mountView({
75 type: "form",
76 resModel: "partner",
77 resId: 1,
78 arch: `
79 <form>
80 <field name="datetime"/>
81 </form>`,
82 });
83
84 await contains("button[data-field=datetime]").click();
85 expect(".o_datetime_picker").toBeDisplayed();
86 expect(".o_toggle_range").toHaveCount(0);
87 });
88
89 test.tags("desktop");
90 test("Datetime field - interaction with the datepicker", async () => {
91 Partner._records[0].datetime_end = "2017-03-13 00:00:00";
92
93 await mountView({
94 type: "form",
95 resModel: "partner",
96 resId: 1,
97 arch: `
98 <form>
99 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
100 </form>`,
101 });
102
103 // Check date range picker initialization
104 expect(".o_field_daterange").toHaveCount(1);
105 expect(".o_datetime_picker").toHaveCount(0);
106
107 // open the first one
108 await contains(".o_field_daterange:first button[data-field=datetime]").click();
109
110 expect(".o_datetime_picker").toBeDisplayed();
111
112 expect(".o_date_item_cell.o_select_start").toHaveText("8");
113 await contains("button.o_next").click();
114 expect(".o_date_item_cell.o_select_end").toHaveText("13");
115
116 let [timeInputStart, timeInputEnd] = queryAll(".o_time_picker_input");
117 expect(timeInputStart).toHaveValue("15:30");
118 expect(timeInputEnd).toHaveValue("5:30");
119
120 await click(timeInputStart);
121 await animationFrame();
122 expect(".o_time_picker_option").toHaveCount(24 * 4);
123 // Close picker
124 await contains(".o_form_view_container").click();
125 expect(".o_datetime_picker").toHaveCount(0);
126
127 // Try to check with end date
128 await contains(".o_field_daterange:first button[data-field=datetime_end]").click();
129
130 expect(".o_datetime_picker").toBeDisplayed();
131
132 expect(".o_date_item_cell.o_select_end").toHaveText("13");
133 await contains("button.o_previous").click();
134 expect(".o_date_item_cell.o_select_start").toHaveText("8");
135
136 [timeInputStart, timeInputEnd] = queryAll(".o_time_picker_input");
137 expect(timeInputStart).toHaveValue("15:30");
138 expect(timeInputEnd).toHaveValue("5:30");
139
140 await click(timeInputStart);
141 await animationFrame();
142 expect(".o_time_picker_option").toHaveCount(24 * 4);
143
144 // Select a new range and check that inputs are updated
145 await contains(getPickerCell("8").at(0)).click(); // 02/08/2017
146 await contains(getPickerCell("9").at(0)).click(); // 02/09/2017
147
148 // Save
149 await clickSave();
150
151 // Check date after save
152 expect("button[data-field=datetime]").toHaveValue("02/08/2017 15:30:00");
153 expect("button[data-field=datetime_end]").toHaveValue("02/09/2017 05:30:00");
154 });
155
156 test("Datetime field - interaction with the datepicker (same initial dates)", async () => {
157 Partner._records[0].datetime_end = "2017-02-08 15:00:00";
158
159 await mountView({
160 type: "form",
161 resModel: "partner",
162 resId: 1,
163 arch: `
164 <form>
165 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
166 </form>`,
167 });
168 expect("button[data-field=datetime]").toHaveValue("02/08/2017 15:30:00");
169 expect("button[data-field=datetime_end]").toHaveValue("02/08/2017 20:30:00");
170 await contains("button[data-field=datetime]").click();
171 expect(".o_date_item_cell.o_select_start").toHaveText("8");
172 expect(".o_date_item_cell.o_select_end").toHaveText("8");
173 expect("input[data-field=datetime]").toBeFocused();
174 await contains(getPickerCell("8").at(0)).click();
175 await animationFrame();
176 expect("input[data-field=datetime_end]").toBeFocused();
177 await contains(getPickerCell("10").at(0)).click();
178 await animationFrame();
179 expect("input[data-field=datetime]").toHaveValue("02/08/2017 15:30:00");
180 expect("button[data-field=datetime_end]").toHaveValue("02/10/2017 20:30:00");
181 });
182
183 test.tags("desktop");
184 test("Date field - interaction with the datepicker", async () => {
185 Partner._fields.date_end = fields.Date({ string: "Date end" });
186 Partner._records[0].date_end = "2017-02-08";
187
188 await mountView({
189 type: "form",
190 resModel: "partner",
191 resId: 1,
192 arch: `
193 <form>
194 <field name="date" widget="daterange" options="{'end_date_field': 'date_end'}"/>
195 </form>`,
196 });
197
198 // Check date range picker initialization
199 expect(".o_field_daterange").toHaveCount(1);
200 expect(".o_datetime_picker").toHaveCount(0);
201
202 // open the first one
203 await contains("button[data-field=date]").click();
204 expect(".o_datetime_picker:first").toBeDisplayed();
205 expect(".o_select_start").toHaveText("3");
206 expect(".o_select_end").toHaveText("8");
207
208 // Change date
209 await contains(getPickerCell("16")).click(); // 2017-02-16
210 await contains("button.o_next").click();
211 await contains(getPickerCell("12")).click(); // 2017-03-12
212
213 // Close picker
214 await contains(".o_form_view").click();
215
216 // Check date after change
217 expect(".o_datetime_picker:first").not.toHaveCount();
218 expect("button[data-field=date]").toHaveValue("02/16/2017");
219 expect("button[data-field=date_end]").toHaveValue("03/12/2017");
220
221 // Try to change range with end date
222 await contains("button[data-field=date_end]").click();
223
224 expect(".o_datetime_picker:first").toBeDisplayed();
225 expect(".o_select_end").toHaveText("12");
226 await contains("button.o_previous").click();
227 expect(".o_select_start").toHaveText("16");
228
229 // Change date
230 await contains(getPickerCell("13")).click();
231 await contains("button.o_next").click();
232 await contains(getPickerCell("18")).click();
233 // Close picker
234 await contains(".o_form_view").click();
235
236 // Check date after change
237 expect(".o_datetime_picker:first").not.toHaveCount();
238 expect("button[data-field=date]").toHaveValue("02/13/2017");
239 expect("button[data-field=date_end]").toHaveValue("03/18/2017");
240
241 // Save
242 await clickSave();
243
244 // Check date after save
245 expect("button[data-field=date]").toHaveValue("02/13/2017");
246 expect("button[data-field=date_end]").toHaveValue("03/18/2017");
247 });
248
249 test("Date field - interaction with the datepicker - empty dates", async () => {
250 Partner._fields.date_start = fields.Date({ string: "Date end", required: true });
251 Partner._fields.date_end = fields.Date({ string: "Date end", required: true });
252
253 await mountView({
254 type: "form",
255 resModel: "partner",
256 resId: 1,
257 arch: `
258 <form>
259 <field name="date_start" widget="daterange" options="{'end_date_field': 'date_end'}"/>
260 </form>`,
261 });
262
263 // open the first one
264 await contains("input[data-field=date_start]").click();
265
266 expect(".o_select_start").not.toHaveCount();
267 expect(".o_select_end").not.toHaveCount();
268
269 // Change date
270 await contains(getPickerCell("5")).click();
271 await contains(getPickerCell("12")).click();
272
273 expect(".o_select_start").toHaveText("5");
274 expect(".o_select_end").toHaveText("12");
275 });
276
277 test("date picker should still be present when scrolling outside of it", async () => {
278 Partner._records[0].datetime_end = "2017-03-13 00:00:00";
279
280 await mountView({
281 type: "form",
282 resModel: "partner",
283 resId: 1,
284 arch: `
285 <form>
286 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
287 </form>`,
288 });
289
290 await contains("button[data-field=datetime]").click();
291 expect(".o_datetime_picker").toBeDisplayed();
292 await contains(document.body).scroll({ top: 50 });
293 expect(".o_datetime_picker").toBeDisplayed();
294 });
295
296 test("DateRangeField with label opens datepicker on click", async () => {
297 Partner._fields.date_end = fields.Date({ string: "Date end" });
298 Partner._records[0].date_end = "2017-02-08";
299
300 await mountView({
301 type: "form",
302 resModel: "partner",
303 resId: 1,
304 arch: `
305 <form>
306 <label for="date" string="Daterange" />
307 <field name="date" widget="daterange" options="{'end_date_field': 'date_end'}"/>
308 </form>`,
309 });
310
311 await contains("label.o_form_label").click();
312 expect(".o_datetime_picker").toBeDisplayed();
313 });
314
315 test("Datetime field manually input value should send utc value to server", async () => {
316 expect.assertions(4);
317
318 Partner._records[0].datetime_end = "2017-03-13 00:00:00";
319
320 onRpc("web_save", ({ args }) => {
321 expect(args[1]).toEqual({
322 datetime: "2017-02-08 06:00:00",
323 });
324 });
325
326 await mountView({
327 type: "form",
328 resModel: "partner",
329 arch: `
330 <form>
331 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
332 </form>`,
333 resId: 1,
334 });
335
336 // check date display correctly in readonly
337 expect("button[data-field=datetime]").toHaveValue("02/08/2017 15:30:00");
338 expect("button[data-field=datetime_end]").toHaveValue("03/13/2017 05:30:00");
339
340 // update input for Datetime
341 await contains("button[data-field=datetime]").click();
342 await contains("input[data-field=datetime]").edit("02/08/2017 11:30:00");
343 // save form
344 await clickSave();
345
346 expect("button[data-field=datetime]").toHaveValue("02/08/2017 11:30:00");
347 });
348
349 test("Daterange field keyup should not erase end date", async () => {
350 Partner._records[0].datetime_end = "2017-03-13 00:00:00";
351
352 await mountView({
353 type: "form",
354 resModel: "partner",
355 arch: `
356 <form>
357 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
358 </form>`,
359 resId: 1,
360 });
361
362 // check date display correctly in readonly
363 expect("button[data-field=datetime]").toHaveValue("02/08/2017 15:30:00");
364 expect("button[data-field=datetime_end]").toHaveValue("03/13/2017 05:30:00");
365
366 // reveal the o_datetime_picker
367 await contains("button[data-field=datetime]").click();
368
369 // the keyup event should not be handled by o_datetime_picker
370 await contains("input[data-field=datetime]").press("ArrowLeft");
371 expect("input[data-field=datetime]").toHaveValue("02/08/2017 15:30:00");
372 expect("button[data-field=datetime_end]").toHaveValue("03/13/2017 05:30:00");
373 });
374
375 test("Render with initial empty value: date field", async () => {
376 // 2014-08-14 12:34:56 -> the day E. Zuckerman, who invented pop-up ads, has apologised.
377 mockDate("22014-08-14 12:34:56", +0);
378 Partner._fields.date_end = fields.Date({ string: "Date end" });
379
380 await mountView({
381 type: "form",
382 resModel: "partner",
383 arch: `
384 <form>
385 <field name="date" widget="daterange" options="{'end_date_field': 'date_end'}"/>
386 </form>`,
387 });
388
389 await contains("input[data-field=date]").click();
390 expect(".o_datetime_picker").toHaveCount(1);
391
392 // Select a value (today)
393 await contains(".o_today").click();
394 expect("button[data-field=date]").toHaveValue("08/14/2014");
395
396 // Reopen the datepicker
397 await contains("button[data-field=date]").click();
398
399 // Add an end date
400 await contains(".o_toggle_range").click();
401 await press("Enter");
402 await animationFrame();
403 expect("button[data-field=date]").toHaveValue(queryValue("button[data-field=date_end]"));
404 });
405
406 test("Render with initial empty value: datetime field", async () => {
407 // 2014-08-14 12:34:56 -> the day E. Zuckerman, who invented pop-up ads, has apologised.
408 mockDate("2014-08-14 12:34:56", +0);
409
410 await mountView({
411 type: "form",
412 resModel: "partner",
413 arch: `
414 <form>
415 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
416 </form>`,
417 });
418
419 await contains("input[data-field=datetime]").click();
420 expect(".o_datetime_picker").toBeVisible();
421 expect(".o_toggle_range").toBeVisible();
422
423 // Select a value (today)
424 await contains(".o_today").click();
425 expect(".o_field_daterange input:eq(0)").toHaveValue("08/14/2014 12:00:00");
426
427 // Add an end date
428 await contains(".o_toggle_range").click();
429
430 expect("input[data-field=datetime]").toHaveValue("08/14/2014 12:00:00");
431 expect("button[data-field=datetime_end]").toHaveValue("08/14/2014 13:00:00");
432 });
433
434 test("Render with initial empty value and optional start date", async () => {
435 mockDate("2014-08-14 12:34:56", +0);
436
437 await mountView({
438 type: "form",
439 resModel: "partner",
440 arch: `
441 <form>
442 <field name="datetime_end" widget="daterange" options="{'start_date_field': 'datetime'}"/>
443 </form>`,
444 });
445
446 await contains("input[data-field=datetime_end]").click();
447 expect(".o_datetime_picker").toHaveCount(1);
448 expect(".o_toggle_range").toHaveCount(1);
449
450 // Select a value (today)
451 await contains(".o_today").click();
452 expect(".o_field_daterange input:eq(0)").toHaveValue("08/14/2014 13:00:00");
453 expect(".o_toggle_range").toBeVisible();
454
455 // Add an end date
456 await contains(".o_toggle_range").click();
457
458 expect("button[data-field=datetime]").toHaveValue("08/14/2014 12:00:00");
459 expect("input[data-field=datetime_end]").toHaveValue("08/14/2014 13:00:00");
460 });
461
462 test("initial empty date with optional start date", async () => {
463 mockDate("2014-08-14 12:34:56", +0);
464
465 Partner._records[0].datetime = "2017-03-13 00:00:00";
466 Partner._records[0].datetime_end = false;
467
468 await mountView({
469 type: "form",
470 resModel: "partner",
471 arch: `
472 <form>
473 <field name="datetime_end" widget="daterange" options="{'start_date_field': 'datetime'}"/>
474 </form>`,
475 resId: 1,
476 });
477
478 await contains("button.o_daterange_start").click();
479 expect(".o_datetime_picker").toHaveCount(1);
480
481 // Add an end date
482 await contains(".o_toggle_range").click();
483
484 expect(".o_datetime_picker").toHaveCount(1);
485 expect("input[data-field=datetime]").toHaveValue("03/13/2017 00:00:00");
486 expect("button[data-field=datetime_end]").toHaveValue("03/13/2017 01:00:00");
487 });
488
489 test("initial empty date with optional end date", async () => {
490 // 2014-08-14 12:34:56 -> the day E. Zuckerman, who invented pop-up ads, has apologised.
491 mockDate("2014-08-14 12:34:56", +0);
492
493 Partner._records[0].datetime = false;
494 Partner._records[0].datetime_end = "2017-03-13 00:00:00";
495
496 await mountView({
497 type: "form",
498 resModel: "partner",
499 arch: `
500 <form>
501 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
502 </form>`,
503 resId: 1,
504 });
505
506 await contains("button.o_daterange_end").click();
507 expect(".o_datetime_picker").toHaveCount(1);
508
509 // Add a start date
510 await contains(".o_toggle_range").click();
511
512 expect("button[data-field=datetime]").toHaveValue("03/12/2017 23:00:00");
513 expect("input[data-field=datetime_end]").toHaveValue("03/13/2017 00:00:00");
514 });
515
516 test("Datetime field - open datepicker and toggle range with optional end date", async () => {
517 mockDate("2014-08-14 12:34:56", +0);
518
519 Partner._records[0].datetime = "2017-03-13 00:00:00";
520 Partner._records[0].datetime_end = false;
521
522 await mountView({
523 type: "form",
524 resModel: "partner",
525 arch: `
526 <form>
527 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
528 </form>`,
529 resId: 1,
530 });
531
532 await contains("button[data-field=datetime]").click();
533 expect(".o_datetime_picker").toHaveCount(1);
534 expect("input[data-field=datetime]").toHaveValue("03/13/2017 00:00:00");
535 expect("button[data-field=datetime_end]").toHaveCount(0);
536 expect(".o_time_picker_input").toHaveValue("0:00");
537
538 // Range mode: on (add a end date)
539 await contains(".o_toggle_range").click();
540 await animationFrame();
541 expect("input[data-field=datetime]").toHaveValue("03/13/2017 00:00:00");
542 expect("button[data-field=datetime_end]").toHaveValue("03/13/2017 01:00:00");
543
544 // Range mode: off
545 await contains(".o_toggle_range").click();
546 await animationFrame();
547 expect("input[data-field=datetime]").toHaveValue("03/13/2017 00:00:00");
548 expect("button[data-field=datetime_end]").toHaveCount(0);
549 expect(".o_time_picker_input").toHaveValue("0:00");
550 });
551
552 test("Datetime field - open datepicker and toggle range with optional start date", async () => {
553 mockDate("2014-08-14 12:34:56", +0);
554
555 Partner._records[0].datetime = false;
556 Partner._records[0].datetime_end = "2017-03-13 00:00:00";
557
558 await mountView({
559 type: "form",
560 resModel: "partner",
561 arch: `
562 <form>
563 <field name="datetime_end" widget="daterange" options="{'start_date_field': 'datetime'}"/>
564 </form>`,
565 resId: 1,
566 });
567
568 await contains("button[data-field=datetime_end]").click();
569 expect(".o_datetime_picker").toHaveCount(1);
570 expect("button[data-field=datetime]").toHaveCount(0);
571 expect("input[data-field=datetime_end]").toHaveValue("03/13/2017 00:00:00");
572 expect(".o_time_picker_input").toHaveValue("0:00");
573
574 // Range mode: on (add a end date)
575 await contains(".o_toggle_range").click();
576 await animationFrame();
577 expect("input[data-field=datetime]").toHaveValue("03/12/2017 23:00:00");
578 expect("button[data-field=datetime_end]").toHaveValue("03/13/2017 00:00:00");
579
580 // Range mode: off
581 await contains(".o_toggle_range").click();
582 await animationFrame();
583 expect("button[data-field=datetime]").toHaveCount(0);
584 expect("input[data-field=datetime_end]").toHaveValue("03/13/2017 00:00:00");
585 expect(".o_time_picker_input").toHaveValue("0:00");
586 });
587
588 test.tags("desktop");
589 test("Datetime field - open datepicker and switch page", async () => {
590 Partner._records[0].datetime_end = "2017-03-13 00:00:00";
591 Partner._records.push({
592 id: 2,
593 date: "2017-03-04",
594 datetime: "2017-03-10 11:00:00",
595 datetime_end: "2017-04-15 00:00:00",
596 });
597
598 await mountView({
599 type: "form",
600 resModel: "partner",
601 resId: 1,
602 resIds: [1, 2],
603 arch: `
604 <form>
605 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
606 </form>`,
607 });
608
609 // Check date range picker initialization
610 expect(".o_field_daterange").toHaveCount(1);
611 expect(".o_datetime_picker").toHaveCount(0);
612
613 // open datepicker
614 await contains("button[data-field=datetime]").click();
615
616 expect(".o_datetime_picker:first").toBeDisplayed();
617
618 // Start date: id=1
619 expect(".o_select_start").toHaveText("8");
620 // End date: id=1
621 await contains("button.o_next").click();
622 expect(".o_select_end").toHaveText("13");
623
624 let [timePickerStart, timePickerEnd] = queryAll(".o_time_picker_input");
625 expect(timePickerStart).toHaveValue("15:30");
626 expect(timePickerEnd).toHaveValue("5:30");
627
628 // Close picker
629 await contains(".o_form_view").click();
630 expect(".o_datetime_picker:first").not.toHaveCount();
631
632 await pagerNext();
633
634 // Check date range picker initialization
635 expect(".o_field_daterange").toHaveCount(1);
636 expect(".o_datetime_picker").toHaveCount(0);
637
638 // open date range picker
639 await contains("button[data-field=datetime]").click();
640
641 expect(".o_datetime_picker:first").toBeDisplayed();
642
643 // Start date: id=2
644 expect(".o_select_start").toHaveText("10");
645 // End date id=2
646 await contains("button.o_next").click();
647 expect(".o_select_end").toHaveText("15");
648
649 [timePickerStart, timePickerEnd] = queryAll(".o_time_picker_input");
650 expect(timePickerStart).toHaveValue("16:30");
651 expect(timePickerEnd).toHaveValue("5:30");
652 });
653
654 test("related end date, both start date and end date empty", async () => {
655 Partner._records[0].datetime = false;
656
657 await mountView({
658 type: "form",
659 resModel: "partner",
660 arch: /* xml */ `
661 <form>
662 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
663 </form>`,
664 resId: 1,
665 });
666
667 expect(".o_field_daterange input").toHaveCount(1);
668 expect(".o_field_daterange input:eq(0)").toHaveAttribute("data-field", "datetime");
669 expect(".o_field_daterange input:eq(0)").toHaveValue("");
670 expect(".o_toggle_range").toHaveCount(0);
671 await contains(".o_field_daterange input:eq(0)").edit("06/06/2023 12:00:00");
672 expect(".o_field_daterange input").toHaveCount(1);
673 expect(".o_field_daterange input:eq(0)").toHaveAttribute("data-field", "datetime");
674 expect(".o_field_daterange input:eq(0)").toHaveValue("06/06/2023 12:00:00");
675
676 await contains("input[data-field=datetime]").click();
677 await contains(".o_toggle_range").click();
678
679 expect(".o_field_daterange input").toHaveCount(1);
680 expect(".o_field_daterange input").toHaveAttribute("data-field", "datetime");
681 expect(".o_field_daterange input").toHaveValue("06/06/2023 12:00:00");
682 expect(".o_field_daterange button").toHaveAttribute("data-field", "datetime_end");
683 expect(".o_field_daterange button").toHaveValue("06/06/2023 13:00:00");
684
685 await press("Enter");
686 await animationFrame();
687 expect(".o_toggle_range").toHaveCount(0);
688 });
689
690 test("required: related end date, both start date and end date empty", async () => {
691 Partner._records[0].datetime = false;
692
693 await mountView({
694 type: "form",
695 resModel: "partner",
696 arch: /* xml */ `
697 <form>
698 <field name="bool_field"/>
699 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}" required="bool_field"/>
700 </form>`,
701 resId: 1,
702 });
703
704 expect(".o_field_daterange input").toHaveCount(1);
705 expect(".o_field_daterange input:eq(0)").toHaveAttribute("data-field", "datetime");
706 expect(".o_field_daterange input:eq(0)").toHaveValue("");
707 expect(".o_toggle_range").toHaveCount(0);
708 await contains(".o_field_boolean input").click();
709 expect(".o_field_daterange input").toHaveCount(2);
710 expect(".o_field_daterange input:eq(0)").toHaveAttribute("data-field", "datetime");
711 expect(".o_field_daterange input:eq(0)").toHaveValue("");
712 expect(".o_field_daterange input:eq(1)").toHaveAttribute("data-field", "datetime_end");
713 expect(".o_field_daterange input:eq(1)").toHaveValue("");
714 expect(".o_toggle_range").toHaveCount(0);
715 await contains(".o_field_daterange input:eq(0)").edit("06/06/2023 12:00:00");
716 expect(".o_field_daterange input").toHaveCount(2);
717 expect(".o_field_daterange input:eq(0)").toHaveAttribute("data-field", "datetime");
718 expect(".o_field_daterange input:eq(0)").toHaveValue("06/06/2023 12:00:00");
719 expect(".o_field_daterange input:eq(1)").toHaveAttribute("data-field", "datetime_end");
720 expect(".o_field_daterange input:eq(1)").toHaveValue("");
721 expect(".o_toggle_range").toHaveCount(0);
722 await contains(".o_field_daterange input:eq(1)").edit("07/07/2023 13:00:00");
723 expect(".o_field_daterange input").toHaveCount(0);
724 expect(".o_field_daterange button").toHaveCount(2);
725 expect(".o_field_daterange button:eq(0)").toHaveAttribute("data-field", "datetime");
726 expect(".o_field_daterange button:eq(0)").toHaveValue("06/06/2023 12:00:00");
727 expect(".o_field_daterange button:eq(1)").toHaveAttribute("data-field", "datetime_end");
728 expect(".o_field_daterange button:eq(1)").toHaveValue("07/07/2023 13:00:00");
729 expect(".o_toggle_range").toHaveCount(0);
730 await contains(".o_field_daterange button[data-field=datetime]").click();
731 await contains(".o_field_daterange input[data-field=datetime]").clear();
732 expect(".o_field_daterange input").toHaveCount(1);
733 expect(".o_field_daterange input").toHaveAttribute("data-field", "datetime");
734 expect(".o_field_daterange input").toHaveValue("");
735 expect(".o_field_daterange button").toHaveAttribute("data-field", "datetime_end");
736 expect(".o_field_daterange button").toHaveValue("07/07/2023 13:00:00");
737 expect(".o_toggle_range").toHaveCount(0);
738
739 // Open the picker, this checks that props validation for the picker isn't
740 // broken by required being present
741 await contains(".o_field_daterange input:eq(0)").click();
742 });
743
744 test("related start date, both start date and end date empty", async () => {
745 Partner._records[0].datetime = false;
746
747 await mountView({
748 type: "form",
749 resModel: "partner",
750 arch: /* xml */ `
751 <form>
752 <field name="datetime_end" widget="daterange" options="{'start_date_field': 'datetime'}"/>
753 </form>`,
754 resId: 1,
755 });
756
757 expect(".o_field_daterange input").toHaveCount(1);
758 expect(".o_field_daterange input:eq(0)").toHaveAttribute("data-field", "datetime_end");
759 expect(".o_field_daterange input:eq(0)").toHaveValue("");
760 expect(".o_toggle_range").toHaveCount(0);
761 });
762
763 test("related end date, start date set and end date empty", async () => {
764 await mountView({
765 type: "form",
766 resModel: "partner",
767 arch: /* xml */ `
768 <form>
769 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
770 </form>`,
771 resId: 1,
772 });
773
774 expect(".o_field_daterange button").toHaveCount(1);
775 expect(".o_field_daterange button:eq(0)").toHaveAttribute("data-field", "datetime");
776
777 // Open the datepicker
778 await contains("button[data-field=datetime]").click();
779 expect(".o_toggle_range").toBeVisible();
780 });
781
782 test("related start date, start date set and end date empty", async () => {
783 await mountView({
784 type: "form",
785 resModel: "partner",
786 arch: /* xml */ `
787 <form>
788 <field name="datetime_end" widget="daterange" options="{'start_date_field': 'datetime'}"/>
789 </form>`,
790 resId: 1,
791 });
792
793 expect(".o_field_daterange button").toHaveCount(1);
794 expect(".o_field_daterange button:eq(0)").toHaveAttribute("data-field", "datetime");
795
796 // Open the datepicker
797 await contains("button[data-field=datetime]").click();
798 expect(".o_toggle_range").toBeVisible();
799 });
800
801 test("related end date, start date empty and end date set", async () => {
802 const recordData = Partner._records[0];
803 recordData.datetime_end = recordData.datetime;
804 recordData.datetime = false;
805
806 await mountView({
807 type: "form",
808 resModel: "partner",
809 arch: /* xml */ `
810 <form>
811 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
812 </form>`,
813 resId: 1,
814 });
815
816 expect(".o_field_daterange button").toHaveCount(1);
817 expect(".o_field_daterange button:eq(0)").toHaveAttribute("data-field", "datetime_end");
818
819 // Open the datepicker
820 await contains("button[data-field=datetime_end]").click();
821 expect(".o_toggle_range").toBeVisible();
822 });
823
824 test("related start date, start date empty and end date set", async () => {
825 const recordData = Partner._records[0];
826 recordData.datetime_end = recordData.datetime;
827 recordData.datetime = false;
828
829 await mountView({
830 type: "form",
831 resModel: "partner",
832 arch: /* xml */ `
833 <form>
834 <field name="datetime_end" widget="daterange" options="{'start_date_field': 'datetime'}"/>
835 </form>`,
836 resId: 1,
837 });
838
839 expect(".o_field_daterange button").toHaveCount(1);
840 expect(".o_field_daterange button:eq(0)").toHaveAttribute("data-field", "datetime_end");
841
842 // Open the datepicker
843 await contains("button[data-field=datetime_end]").click();
844 expect(".o_toggle_range").toBeVisible();
845 });
846
847 test("related end date, both start date and end date set", async () => {
848 const recordData = Partner._records[0];
849 recordData.datetime_end = recordData.datetime;
850
851 await mountView({
852 type: "form",
853 resModel: "partner",
854 arch: /* xml */ `
855 <form>
856 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
857 </form>`,
858 resId: 1,
859 });
860
861 expect(".o_field_daterange button").toHaveCount(2);
862 expect(".o_field_daterange button:eq(0)").toHaveAttribute("data-field", "datetime");
863 expect(".o_field_daterange button:eq(1)").toHaveAttribute("data-field", "datetime_end");
864 expect(".o_toggle_range").toHaveCount(0);
865 });
866
867 test("related start date, both start date and end date set", async () => {
868 const recordData = Partner._records[0];
869 recordData.datetime_end = recordData.datetime;
870
871 await mountView({
872 type: "form",
873 resModel: "partner",
874 arch: /* xml */ `
875 <form>
876 <field name="datetime_end" widget="daterange" options="{'start_date_field': 'datetime'}"/>
877 </form>`,
878 resId: 1,
879 });
880
881 expect(".o_field_daterange button").toHaveCount(2);
882 expect(".o_field_daterange button:eq(0)").toHaveAttribute("data-field", "datetime");
883 expect(".o_field_daterange button:eq(0)").toHaveValue("02/08/2017 15:30:00");
884 expect(".o_field_daterange button:eq(1)").toHaveAttribute("data-field", "datetime_end");
885 expect(".o_field_daterange button:eq(1)").toHaveValue("02/08/2017 15:30:00");
886 await contains(".o_field_daterange button:eq(0)").click();
887 await contains(".o_field_daterange input").clear();
888 expect(".o_field_daterange button[data-field]").toHaveCount(1);
889 expect(".o_field_daterange button[data-field]").toHaveAttribute("data-field", "datetime_end");
890 expect(".o_field_daterange button[data-field]").toHaveValue("02/08/2017 15:30:00");
891 await contains(".o_field_daterange button[data-field]").click();
892 await contains(".o_field_daterange input").clear();
893 expect(".o_field_daterange input").toHaveCount(1);
894 expect(".o_field_daterange input").toHaveAttribute("data-field", "datetime_end");
895 expect(".o_field_daterange input").toHaveValue("");
896 expect(".o_toggle_range").toHaveCount(0);
897 });
898
899 test("related start date, required, both start date and end date set", async () => {
900 Partner._fields.date_end = fields.Date({ string: "Some Date" });
901 const [firstRecord] = Partner._records;
902 firstRecord.date_end = firstRecord.date;
903
904 await mountView({
905 type: "form",
906 resModel: "partner",
907 arch: /* xml */ `
908 <form>
909 <field name="date" widget="daterange" options="{'start_date_field': 'date_end'}" required="1" />
910 </form>`,
911 resId: 1,
912 });
913
914 expect(".o_field_daterange button:eq(0)").toHaveValue("02/03/2017");
915 expect(".fa-long-arrow-right").toHaveCount(1);
916 expect(".o_field_daterange button:eq(1)").toHaveValue("02/03/2017");
917 });
918
919 test("list daterange with start date and empty end date", async () => {
920 Partner._fields.date_end = fields.Date({ string: "Some Date" });
921
922 await mountView({
923 type: "list",
924 resModel: "partner",
925 arch: /* xml */ `
926 <list>
927 <field name="date" widget="daterange" options="{'end_date_field': 'date_end'}" />
928 </list>`,
929 });
930
931 expect(".o_field_daterange").toHaveText("Feb 3, 2017");
932 expect(".o_field_daterange .fa-long-arrow-right").toHaveCount(0);
933 });
934
935 test("list daterange with empty start date and end date", async () => {
936 Partner._fields.date_end = fields.Date({ string: "Some Date" });
937 const [firstRecord] = Partner._records;
938 [firstRecord.date, firstRecord.date_end] = [firstRecord.date_end, firstRecord.date];
939
940 await mountView({
941 type: "list",
942 resModel: "partner",
943 arch: /* xml */ `
944 <list>
945 <field name="date" widget="daterange" options="{'end_date_field': 'date_end'}" />
946 </list>`,
947 });
948
949 expect(".o_field_daterange").toHaveText("Feb 3, 2017");
950 expect(".o_field_daterange .fa-long-arrow-right").toHaveCount(0);
951 });
952
953 test("list daterange: column widths", async () => {
954 await resize({ width: 800 });
955 patchWithCleanup(user, _makeUser({ user_context: { lang: "fr" } }));
956 document.body.style.fontFamily = "sans-serif";
957 resetDateFieldWidths();
958 after(resetDateFieldWidths);
959 Partner._fields.char_field = fields.Char();
960 Partner._fields.date_end = fields.Date();
961 Partner._records[0].date_end = "2017-02-04";
962 Partner._records[0].datetime_end = "2017-02-09 17:00:00";
963
964 await mountView({
965 type: "list",
966 resModel: "partner",
967 arch: /* xml */ `
968 <list>
969 <field name="date" widget="daterange" options="{'end_date_field': 'date_end'}" />
970 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}" />
971 <field name="char_field" />
972 </list>`,
973 });
974
975 expect(".o_data_row").toHaveCount(1);
976 const columnWidths = queryAllProperties(".o_list_table thead th", "offsetWidth");
977 expect(columnWidths).toEqual([40, 220, 352, 188]);
978 });
979
980 test("list daterange: column widths (numeric format)", async () => {
981 await resize({ width: 800 });
982 document.body.style.fontFamily = "sans-serif";
983 resetDateFieldWidths();
984 after(resetDateFieldWidths);
985
986 Partner._fields.char_field = fields.Char();
987 Partner._fields.date_end = fields.Date();
988 Partner._records[0].date_end = "2017-02-04";
989 Partner._records[0].datetime_end = "2017-02-09 17:00:00";
990
991 await mountView({
992 type: "list",
993 resModel: "partner",
994 arch: /* xml */ `
995 <list>
996 <field name="date" widget="daterange" options="{'end_date_field': 'date_end', 'numeric': true}" />
997 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end', 'numeric': true}" />
998 <field name="char_field" />
999 </list>`,
1000 });
1001
1002 expect(".o_data_row").toHaveCount(1);
1003 expect(queryAllTexts(".o_data_cell")).toEqual([
1004 "02/03/2017\n02/04/2017",
1005 "02/08/2017 15:30:00\n02/09/2017 22:30:00",
1006 "",
1007 ]);
1008 const columnWidths = queryAllProperties(".o_list_table thead th", "offsetWidth");
1009 expect(columnWidths).toEqual([40, 187, 310, 263]);
1010 });
1011
1012 test("list daterange: column widths (show_time=false)", async () => {
1013 await resize({ width: 800 });
1014 document.body.style.fontFamily = "sans-serif";
1015 resetDateFieldWidths();
1016 after(resetDateFieldWidths);
1017
1018 Partner._fields.char_field = fields.Char();
1019 Partner._fields.date_end = fields.Date();
1020 Partner._records[0].date_end = "2017-02-04";
1021 Partner._records[0].datetime_end = "2017-02-09 17:00:00";
1022
1023 await mountView({
1024 type: "list",
1025 resModel: "partner",
1026 arch: /* xml */ `
1027 <list>
1028 <field name="datetime" widget="daterange" options="{'show_time': false, 'end_date_field': 'datetime_end'}" />
1029 <field name="char_field" />
1030 </list>`,
1031 });
1032
1033 expect(".o_data_row").toHaveCount(1);
1034 expect(queryAllTexts(".o_data_cell")).toEqual(["Feb 8, 2017\nFeb 9, 2017", ""]);
1035 const columnWidths = queryAllProperties(".o_list_table thead th", "offsetWidth");
1036 expect(columnWidths).toEqual([40, 219, 541]);
1037 });
1038
1039 test("list daterange: column widths (no record)", async () => {
1040 await resize({ width: 800 });
1041 patchWithCleanup(user, _makeUser({ user_context: { lang: "fr" } }));
1042 document.body.style.fontFamily = "sans-serif";
1043 resetDateFieldWidths();
1044 after(resetDateFieldWidths);
1045
1046 Partner._fields.char_field = fields.Char();
1047 Partner._fields.date_end = fields.Date();
1048 Partner._records = [];
1049
1050 await mountView({
1051 type: "list",
1052 resModel: "partner",
1053 arch: /* xml */ `
1054 <list>
1055 <field name="date" widget="daterange" options="{'end_date_field': 'date_end'}" />
1056 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}" />
1057 <field name="char_field" />
1058 </list>`,
1059 });
1060
1061 expect(".o_data_row").toHaveCount(0);
1062 const columnWidths = queryAllProperties(".o_list_table thead th", "offsetWidth");
1063 expect(columnWidths).toEqual([40, 220, 352, 188]);
1064 });
1065
1066 test.tags("desktop");
1067 test("list daterange: start date input width matches its span counterpart", async () => {
1068 Partner._records[0].datetime_end = "2017-02-09 17:00:00";
1069
1070 await mountView({
1071 type: "list",
1072 resModel: "partner",
1073 arch: /* xml */ `
1074 <list multi_edit="1">
1075 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end', 'numeric': true}" />
1076 </list>`,
1077 });
1078
1079 expect(".o_data_row").toHaveCount(1);
1080 await contains(".o_list_record_selector input").click();
1081 const initialWidth = queryFirst(".o_field_daterange span").offsetWidth;
1082 await contains(".o_field_daterange span:first").click();
1083 await animationFrame();
1084 expect(".o_field_daterange input").toHaveProperty("offsetWidth", initialWidth);
1085 });
1086
1087 test("always range: related end date, both start date and end date empty", async () => {
1088 Partner._records[0].datetime = false;
1089
1090 await mountView({
1091 type: "form",
1092 resModel: "partner",
1093 arch: /* xml */ `
1094 <form>
1095 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end', 'always_range': '1'}"/>
1096 </form>`,
1097 resId: 1,
1098 });
1099
1100 expect(".o_field_daterange input").toHaveCount(2);
1101 expect(".o_field_daterange input:eq(0)").toHaveAttribute("data-field", "datetime");
1102 expect(".o_field_daterange input:eq(0)").toHaveValue("");
1103 expect(".o_field_daterange input:eq(1)").toHaveAttribute("data-field", "datetime_end");
1104 expect(".o_field_daterange input:eq(1)").toHaveValue("");
1105 expect(".o_toggle_range").toHaveCount(0);
1106 await contains(".o_field_daterange input:eq(0)").edit("06/06/2023 12:00:00");
1107 expect(".o_field_daterange input").toHaveCount(2);
1108 expect(".o_field_daterange input:eq(0)").toHaveAttribute("data-field", "datetime");
1109 expect(".o_field_daterange input:eq(0)").toHaveValue("06/06/2023 12:00:00");
1110 expect(".o_field_daterange input:eq(1)").toHaveAttribute("data-field", "datetime_end");
1111 expect(".o_field_daterange input:eq(1)").toHaveValue("");
1112 expect(".o_toggle_range").toHaveCount(0);
1113 await contains(".o_field_daterange input:eq(1)").edit("07/07/2023 13:00:00");
1114 await animationFrame();
1115
1116 expect(".o_field_daterange button").toHaveCount(2);
1117 expect(".o_field_daterange button:eq(0)").toHaveAttribute("data-field", "datetime");
1118 expect(".o_field_daterange button:eq(0)").toHaveValue("06/06/2023 12:00:00");
1119 expect(".o_field_daterange button:eq(1)").toHaveAttribute("data-field", "datetime_end");
1120 expect(".o_field_daterange button:eq(1)").toHaveValue("07/07/2023 13:00:00");
1121 expect(".o_toggle_range").toHaveCount(0);
1122 await contains(".o_field_daterange button:eq(0)").click();
1123 await contains(".o_field_daterange input").clear();
1124 await animationFrame();
1125
1126 expect(".o_field_daterange input").toHaveCount(1);
1127 expect(".o_field_daterange input").toHaveAttribute("data-field", "datetime");
1128 expect(".o_field_daterange input").toHaveValue("");
1129 expect(".o_field_daterange button").toHaveAttribute("data-field", "datetime_end");
1130 expect(".o_field_daterange button").toHaveValue("07/07/2023 13:00:00");
1131 expect(".o_toggle_range").toHaveCount(0);
1132 });
1133
1134 test("there is no arrow between the dates with option always_range if nothing is set and it is readonly", async () => {
1135 await mountView({
1136 type: "form",
1137 resModel: "partner",
1138 arch: /* xml */ `
1139 <form>
1140 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end', 'always_range': 'true'}" />
1141 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end', 'always_range': 'true'}" readonly="true" />
1142 </form>`,
1143 });
1144
1145 await contains(".o_form_button_save").click();
1146 await animationFrame();
1147 expect(".o_datetime_picker").toHaveCount(0);
1148 expect(".fa-long-arrow-right").toHaveCount(1);
1149 });
1150
1151 test("invalid empty date with optional end date", async () => {
1152 Partner._fields.date_end = fields.Date({ string: "Date end" });
1153 Partner._records[0].date_end = "2017-02-08";
1154
1155 await mountView({
1156 type: "form",
1157 resModel: "partner",
1158 arch: /* xml */ `
1159 <form>
1160 <label for="date" string="Daterange" />
1161 <field name="date" widget="daterange" options="{'end_date_field': 'date_end','always_range': '1'}" string="Planned Date" required="date_end"/>
1162 <field name="date_end" invisible="1" required="date"/>
1163 </form>`,
1164 resId: 1,
1165 });
1166
1167 expect(".o_field_daterange button").toHaveCount(2);
1168 await contains(".o_field_daterange button:eq(1)").click();
1169 await contains("input[data-field=date_end]").clear();
1170 await contains(".o_form_view").click();
1171 expect(".o_field_daterange input").toHaveValue("");
1172 expect(".o_field_daterange").toHaveClass("o_field_invalid");
1173 });
1174
1175 test("invalid empty date with optional start date", async () => {
1176 Partner._fields.date_end = fields.Date({ string: "Date end" });
1177 Partner._records[0].date_end = "2017-02-08";
1178
1179 await mountView({
1180 type: "form",
1181 resModel: "partner",
1182 arch: /* xml */ `
1183 <form>
1184 <label for="date_end" string="Daterange" />
1185 <field name="date" invisible="1" required="date_end"/>
1186 <field name="date_end" widget="daterange" options="{'start_date_field': 'date','always_range': '1'}" string="Planned Date" required="date"/>
1187 </form>`,
1188 resId: 1,
1189 });
1190
1191 expect(".o_field_daterange button").toHaveCount(2);
1192 await contains(".o_field_daterange button:eq(0)").click();
1193 await contains("input[data-field=date]").clear();
1194 await contains(".o_form_view").click();
1195 expect(".o_field_daterange input").toHaveValue("");
1196 expect(".o_field_daterange").toHaveClass("o_field_invalid");
1197 });
1198
1199 test.tags("desktop");
1200 test("date values are selected eagerly and do not flicker", async () => {
1201 Partner._onChanges.datetime = () => {};
1202
1203 const def = new Deferred();
1204 onRpc("onchange", async () => {
1205 await def;
1206 expect.step("onchange");
1207 });
1208
1209 await mountView({
1210 type: "form",
1211 resModel: "partner",
1212 arch: `
1213 <form>
1214 <field name="datetime" options="{'end_date_field': 'datetime_end'}"/>
1215 </form>`,
1216 resId: 1,
1217 });
1218
1219 await contains(".o_field_datetime button").click();
1220 await contains(getPickerCell("19")).click();
1221 await contains(".o_toggle_range").click();
1222 await press("enter");
1223
1224 expect(".o_field_datetime input").toHaveValue("02/19/2017 15:30:00");
1225 expect(".o_field_datetime button").toHaveValue("02/19/2017 16:30:00");
1226 expect.verifySteps([]);
1227
1228 def.resolve();
1229 await animationFrame();
1230
1231 expect(queryAllValues(".o_field_datetime button")).toEqual([
1232 "02/19/2017 15:30:00",
1233 "02/19/2017 16:30:00",
1234 ]);
1235 expect.verifySteps(["onchange"]);
1236 });
1237
1238 test("update the selected input date after removing the existing date", async () => {
1239 Partner._fields.date_end = fields.Date({ string: "Date end" });
1240 Partner._records[0].date_end = "2017-02-08";
1241
1242 await mountView({
1243 type: "form",
1244 resModel: "partner",
1245 arch: /* xml */ `
1246 <form>
1247 <field name="date" widget="daterange" options="{'start_date_field': 'date_end'}" required="1" />
1248 </form>`,
1249 resId: 1,
1250 });
1251 await contains("button[data-field=date]").click();
1252 await contains("input[data-field=date]").press("Backspace");
1253 await contains(getPickerCell("12")).click();
1254 await animationFrame();
1255
1256 expect("button[data-field=date]").toHaveValue("02/12/2017");
1257 });
1258
1259 test("daterange with inverted start date and end date", async () => {
1260 Partner._records[0].datetime_end = "2017-02-01 00:00:00";
1261
1262 await mountView({
1263 type: "form",
1264 resModel: "partner",
1265 arch: `
1266 <form>
1267 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
1268 </form>`,
1269 resId: 1,
1270 });
1271
1272 expect(".o_field_daterange button:eq(0)").toHaveValue("02/08/2017 15:30:00");
1273 expect(".o_field_daterange button:eq(1)").toHaveValue("02/01/2017 05:30:00");
1274
1275 await contains("button[data-field=datetime]").click();
1276
1277 expect(".o_selected").toHaveCount(8, {
1278 message: "should correctly display the range even if invalid",
1279 });
1280 });
1281
1282 test("daterange field in kanban with show_time option", async () => {
1283 mockTimeZone(+2);
1284 Partner._records[0].datetime_end = "2017-03-13 00:00:00";
1285
1286 await mountView({
1287 type: "kanban",
1288 resModel: "partner",
1289 arch: `
1290 <kanban>
1291 <templates>
1292 <t t-name="card">
1293 <field name="datetime" widget="daterange" options="{'show_time': false, 'end_date_field': 'datetime_end'}"/>
1294 </t>
1295 </templates>
1296 </kanban>`,
1297 resId: 1,
1298 });
1299
1300 expect(queryAllTexts(".o_field_daterange span")).toEqual(["Feb 8, 2017", "Mar 13, 2017"]);
1301 });
1302
1303 test("updating time keeps selected dates", async () => {
1304 Partner._records[0].datetime_end = "2017-03-13 00:02:00";
1305
1306 await mountView({
1307 type: "form",
1308 resModel: "partner",
1309 resId: 1,
1310 arch: /* xml */ `
1311 <form>
1312 <field name="datetime" options="{'end_date_field': 'datetime_end'}"/>
1313 </form>
1314 `,
1315 });
1316
1317 expect("button[data-field=datetime]").toHaveValue("02/08/2017 15:30:00");
1318 expect("button[data-field=datetime_end]").toHaveValue("03/13/2017 05:32:00");
1319
1320 await contains("button[data-field=datetime_end]").click();
1321
1322 expect(".o_time_picker:first .o_time_picker_input").toHaveValue("15:30");
1323 expect(".o_time_picker:last .o_time_picker_input").toHaveValue("5:32");
1324
1325 await click(getPickerCell("16").at(-1));
1326 await animationFrame();
1327 await contains(".o_time_picker:eq(1) .o_time_picker_input").edit("5:05", { confirm: "Enter" });
1328 await animationFrame();
1329
1330 expect("input[data-field=datetime]").toHaveValue("02/08/2017 15:30:00");
1331 expect("button[data-field=datetime_end]").toHaveValue("03/16/2017 05:05:00");
1332 expect(".o_time_picker:first .o_time_picker_input").toHaveValue("15:30");
1333 expect(".o_time_picker:last .o_time_picker_input").toHaveValue("5:05");
1334
1335 await contains(".o_time_picker:eq(0) .o_time_picker_input").click();
1336 await animationFrame();
1337 await edit("15:35", { confirm: "enter" });
1338 await animationFrame();
1339
1340 expect("input[data-field=datetime]").toHaveValue("02/08/2017 15:35:00");
1341 expect("button[data-field=datetime_end]").toHaveValue("03/16/2017 05:05:00");
1342 expect(".o_time_picker:first .o_time_picker_input").toHaveValue("15:35");
1343 expect(".o_time_picker:last .o_time_picker_input").toHaveValue("5:05");
1344 });
1345
1346 test("daterange in readonly with same dates but different hours", async () => {
1347 Partner._records[0].datetime_end = "2017-02-08 17:00:00";
1348 await mountView({
1349 type: "form",
1350 resModel: "partner",
1351 resId: 1,
1352 arch: `
1353 <form edit="0">
1354 <field name="datetime" widget="daterange" options="{'end_date_field': 'datetime_end'}"/>
1355 </form>`,
1356 });
1357 expect(".o_field_daterange").toHaveText("Feb 8, 2017, 3:30 PM\n10:30 PM", {
1358 message: "end date only shows time since it has the same day as start date",
1359 });
1360 });
1361
1362 test("daterange in list view with missing first date", async () => {
1363 Partner._records[0].datetime_end = Partner._records[0].datetime;
1364 Partner._records[0].datetime = false;
1365
1366 await mountView({
1367 type: "list",
1368 resModel: "partner",
1369 arch: /* xml */ `
1370 <list multi_edit="1">
1371 <field name="datetime_end" widget="daterange" options="{'start_date_field': 'datetime'}" />
1372 </list>
1373 `,
1374 });
1375
1376 expect(".o_field_daterange[name=datetime_end]").toHaveText("Feb 8, 2017, 3:30 PM");
1377 });