[IMP] *: adapt tests to comparison menu

Tests have been adapted accross all affected modules to support the new
"comparison" menu component.

Task ID: 2245719

Co-authored-by: Mathieu Duckerts-Antoine <dam@odoo.com>
Co-authored-by: Julien Mougenot <jum@odoo.com>

6 files changed, 575 insertions, 395 deletions

diff --git a/addons/web/static/tests/control_panel/comparison_menu_tests.js b/addons/web/static/tests/control_panel/comparison_menu_tests.js
new file mode 100644
index 00000000000..141250c3bb4
--- /dev/null
+++ b/addons/web/static/tests/control_panel/comparison_menu_tests.js
@@ -0,0 +1,145 @@
+odoo.define('web.comparison_menu_tests', function (require) {
+    "use strict";
+
+    const {
+        controlPanel: cpHelpers,
+        createControlPanel,
+        mock,
+    } = require('web.test_utils');
+
+    const { patchDate } = mock;
+    const searchMenuTypes = ['filter', 'comparison'];
+
+    QUnit.module('Components', {
+        beforeEach() {
+            this.fields = {
+                birthday: { string: "Birthday", type: "date", store: true, sortable: true },
+                date_field: { string: "Date", type: "date", store: true, sortable: true },
+                float_field: { string: "Float", type: "float", group_operator: 'sum' },
+                foo: { string: "Foo", type: "char", store: true, sortable: true },
+            };
+            this.viewInfo = {
+                arch: `
+                    <search>
+                        <filter name="birthday" date="birthday"/>
+                        <filter name="date_field" date="date_field"/>
+                    </search>`,
+                fields: this.fields,
+            };
+        },
+    }, function () {
+
+        QUnit.module('ComparisonMenu');
+
+        QUnit.test('simple rendering', async function (assert) {
+            assert.expect(6);
+
+            const unpatchDate = patchDate(1997, 0, 9, 12, 0, 0);
+            const params = {
+                cpStoreConfig: { viewInfo: this.viewInfo, searchMenuTypes },
+                cpProps: { fields: this.fields, searchMenuTypes },
+            };
+            const controlPanel = await createControlPanel(params);
+
+            assert.containsOnce(controlPanel, ".o_dropdown.o_filter_menu");
+            assert.containsNone(controlPanel, ".o_dropdown.o_comparison_menu");
+
+            await cpHelpers.toggleFilterMenu(controlPanel);
+            await cpHelpers.toggleMenuItem(controlPanel, "Birthday");
+            await cpHelpers.toggleMenuItemOption(controlPanel, "Birthday", "January");
+
+            assert.containsOnce(controlPanel, 'div.o_comparison_menu > button i.fa.fa-adjust');
+            assert.strictEqual(controlPanel.el.querySelector('div.o_comparison_menu > button span').innerText.trim(), "Comparison");
+
+            await cpHelpers.toggleComparisonMenu(controlPanel);
+
+            const comparisonOptions = [...controlPanel.el.querySelectorAll(
+                '.o_comparison_menu li'
+            )];
+            assert.strictEqual(comparisonOptions.length, 2);
+            assert.deepEqual(
+                comparisonOptions.map(e => e.innerText),
+                ["Birthday: Previous Period", "Birthday: Previous Year"]
+            );
+
+            controlPanel.destroy();
+            unpatchDate();
+        });
+
+        QUnit.test('activate a comparison works', async function (assert) {
+            assert.expect(5);
+
+            const unpatchDate = patchDate(1997, 0, 9, 12, 0, 0);
+            const params = {
+                cpStoreConfig: { viewInfo: this.viewInfo, searchMenuTypes },
+                cpProps: { fields: this.fields, searchMenuTypes },
+            };
+            const controlPanel = await createControlPanel(params);
+
+            await cpHelpers.toggleFilterMenu(controlPanel);
+            await cpHelpers.toggleMenuItem(controlPanel, "Birthday");
+            await cpHelpers.toggleMenuItemOption(controlPanel, "Birthday", "January");
+            await cpHelpers.toggleComparisonMenu(controlPanel);
+            await cpHelpers.toggleMenuItem(controlPanel, "Birthday: Previous Period");
+
+            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), [
+                "Birthday: January 1997",
+                "Birthday: Previous Period",
+            ]);
+
+            await cpHelpers.toggleFilterMenu(controlPanel);
+            await cpHelpers.toggleMenuItem(controlPanel, "Date");
+            await cpHelpers.toggleMenuItemOption(controlPanel, "Date", "December");
+            await cpHelpers.toggleComparisonMenu(controlPanel);
+            await cpHelpers.toggleMenuItem(controlPanel, "Date: Previous Year");
+
+            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), [
+                ["Birthday: January 1997", "Date: December 1996"].join("or"),
+                "Date: Previous Year",
+            ]);
+
+            await cpHelpers.toggleFilterMenu(controlPanel);
+            await cpHelpers.toggleMenuItem(controlPanel, "Date");
+            await cpHelpers.toggleMenuItemOption(controlPanel, "Date", "1996");
+
+            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), [
+                "Birthday: January 1997",
+            ]);
+
+            await cpHelpers.toggleComparisonMenu(controlPanel);
+            await cpHelpers.toggleMenuItem(controlPanel, "Birthday: Previous Year");
+
+            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), [
+                "Birthday: January 1997",
+                "Birthday: Previous Year",
+            ]);
+
+            await cpHelpers.removeFacet(controlPanel);
+
+            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), []);
+
+            controlPanel.destroy();
+            unpatchDate();
+        });
+
+        QUnit.test('no timeRanges key in search query if "comparison" not in searchMenuTypes', async function (assert) {
+            assert.expect(1);
+
+            const params = {
+                cpStoreConfig: {
+                    viewInfo: this.viewInfo, searchMenuTypes: ['filter'],
+                },
+                cpProps: { fields: this.fields, searchMenuTypes: ['filter'] },
+            };
+            const controlPanel = await createControlPanel(params);
+
+            await cpHelpers.toggleFilterMenu(controlPanel);
+            await cpHelpers.toggleMenuItem(controlPanel, "Birthday");
+            await cpHelpers.toggleMenuItemOption(controlPanel, "Birthday", 0);
+
+            assert.notOk("timeRanges" in controlPanel.getQuery());
+
+            controlPanel.destroy();
+        });
+    });
+});
diff --git a/addons/web/static/tests/control_panel/control_panel_model_tests.js b/addons/web/static/tests/control_panel/control_panel_model_tests.js
index 6c571597182..fb73a58dce6 100644
--- a/addons/web/static/tests/control_panel/control_panel_model_tests.js
+++ b/addons/web/static/tests/control_panel/control_panel_model_tests.js
@@ -37,7 +37,7 @@ odoo.define('web.control_panel_model_tests', function (require) {
             assert.expect(1);
 
             const model = createControlPanelModel();
-            assert.deepEqual(sanitizeFilters(model), [{ type: 'timeRange' }]);
+            assert.deepEqual(sanitizeFilters(model), []);
         });
 
         QUnit.test('one field tag', function (assert) {
@@ -55,7 +55,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     fieldType: "many2one",
                     type: "field"
                 },
-                { type: 'timeRange' },
             ]);
         });
 
@@ -67,7 +66,7 @@ odoo.define('web.control_panel_model_tests', function (require) {
             </search>`;
             const fields = this.fields;
             const model = createControlPanelModel({ viewInfo: { arch, fields } });
-            assert.deepEqual(sanitizeFilters(model), [{ type: 'timeRange' }]);
+            assert.deepEqual(sanitizeFilters(model), []);
         });
 
         QUnit.test('one separator tag and one field tag', function (assert) {
@@ -86,7 +85,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     fieldType: "many2one",
                     type: "field"
                 },
-                { type: 'timeRange' },
             ]);
         });
 
@@ -104,7 +102,40 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     domain: "[]",
                     type: "filter",
                 },
-                { type: 'timeRange' },
+            ]);
+        });
+
+        QUnit.test('one filter tag with date attribute', function (assert) {
+            assert.expect(1);
+            const arch = `
+                <search>
+                    <filter name="date_filter" string="Date" date="date_field"/>
+                </search>`;
+            const fields = this.fields;
+            const model = createControlPanelModel({ viewInfo: { arch, fields } });
+            const dateFilterId = Object.values(model.state.filters)[0].id;
+            assert.deepEqual(sanitizeFilters(model), [
+                {
+                    defaultOptionId: "this_month",
+                    description: "Date",
+                    fieldName: "date_field",
+                    fieldType: "date",
+                    isDateFilter: true,
+                    hasOptions: true,
+                    type: "filter"
+                  },
+                  {
+                    comparisonOptionId: "previous_period",
+                    dateFilterId,
+                    description: "Date: Previous Period",
+                    type: "comparison"
+                  },
+                  {
+                    comparisonOptionId: "previous_year",
+                    dateFilterId,
+                    description: "Date: Previous Year",
+                    type: "comparison"
+                  }
             ]);
         });
 
@@ -125,7 +156,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     hasOptions: true,
                     type: "groupBy",
                 },
-                { type: 'timeRange' },
             ]);
         });
 
@@ -149,7 +179,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     domain: "[('bar', '=', 3)]",
                     type: "filter",
                 },
-                { type: 'timeRange' },
             ]);
         });
 
@@ -174,7 +203,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     domain: "[('bar', '=', 3)]",
                     type: "filter",
                 },
-                { type: 'timeRange' },
             ]);
         });
 
@@ -199,7 +227,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     fieldType: "many2one",
                     type: "field",
                 },
-                { type: 'timeRange' },
             ]);
         });
 
@@ -225,7 +252,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     fieldType: "many2one",
                     type: "field"
                 },
-                { type: 'timeRange' },
             ]);
         });
 
@@ -266,7 +292,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     type: "favorite",
                     userId: 2
                 },
-                { type: 'timeRange' }
             ]);
 
         });
@@ -286,7 +311,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     isDefault: true,
                     type: 'filter'
                 },
-                { type: 'timeRange' },
             ]);
 
         });
@@ -328,7 +352,6 @@ odoo.define('web.control_panel_model_tests', function (require) {
                     isDefault: true,
                     type: 'groupBy',
                 },
-                { type: 'timeRange' },
             ]);
 
         });
diff --git a/addons/web/static/tests/control_panel/favorite_menu_tests.js b/addons/web/static/tests/control_panel/favorite_menu_tests.js
index 5aadc99f619..905b3758859 100644
--- a/addons/web/static/tests/control_panel/favorite_menu_tests.js
+++ b/addons/web/static/tests/control_panel/favorite_menu_tests.js
@@ -323,13 +323,20 @@ odoo.define('web.favorite_menu_tests', function (require) {
             controlPanel.destroy();
         });
 
-        QUnit.test('toggle favorite correctly clears filter, groupbys, time ranges and field "options"', async function (assert) {
-            assert.expect(8);
+        QUnit.test('toggle favorite correctly clears filter, groupbys, comparison and field "options"', async function (assert) {
+            assert.expect(11);
 
             const unpatchDate = patchDate(2019, 6, 31, 13, 43, 0);
 
             const favoriteFilters = [{
-                context: "{'group_by': ['foo'], 'time_ranges': {'field': 'birthday', 'range': 'this_year'}}",
+                context: `
+                    {
+                        "group_by": ["foo"],
+                        "comparison": {
+                            "favorite comparison content": "bla bla..."
+                        },
+                    }
+                `,
                 domain: "['!', ['foo', '=', 'qsdf']]",
                 id: 7,
                 is_default: false,
@@ -337,14 +344,15 @@ odoo.define('web.favorite_menu_tests', function (require) {
                 sort: "[]",
                 user_id: [2, "Mitchell Admin"],
             }];
+            let firstSearch = true;
             const arch = `
             <search>
                 <field string="Foo" name="foo"/>
-                <filter string="Date Field Filter" name="positive" date="date_field"/>
+                <filter string="Date Field Filter" name="positive" date="date_field" default_period="this_year"/>
                 <filter string="Date Field Groupby" name="coolName" context="{'group_by': 'date_field'}"/>
             </search>
         `;
-            const searchMenuTypes = ['filter', 'groupBy', 'timeRange', 'favorite'];
+            const searchMenuTypes = ['filter', 'groupBy', 'comparison', 'favorite'];
             const params = {
                 cpStoreConfig: {
                     viewInfo: { favoriteFilters, arch, fields: this.fields },
@@ -353,24 +361,34 @@ odoo.define('web.favorite_menu_tests', function (require) {
                         search_default_positive: true,
                         search_default_coolName: true,
                         search_default_foo: "a",
-                        time_ranges: { field: 'date_field', range: 'today', comparisonRange: 'previous_period' }
                     }
                 },
                 cpProps: { searchMenuTypes, action: {}, fields: this.fields },
                 search: function (searchQuery) {
                     const { domain, groupBy, timeRanges } = searchQuery;
-                    assert.deepEqual(domain, ['!', ['foo', '=', 'qsdf']]);
-                    assert.deepEqual(groupBy, ['foo']);
-                    assert.deepEqual(timeRanges, {
-                        fieldDescription: "Birthday",
-                        fieldName: "birthday",
-                        range: [
-                            "&", ["birthday", ">=", "2019-01-01"], ["birthday", "<", "2020-01-01"]
-                        ],
-                        rangeDescription: "This Year",
-                        rangeId: "this_year"
-                    });
-                }
+                    if (firstSearch) {
+                        assert.deepEqual(domain, [['foo', '=', 'a']]);
+                        assert.deepEqual(groupBy, ['date_field:month']);
+                        assert.deepEqual(timeRanges, {
+                            comparisonId: "previous_period",
+                            comparisonRange: ["&", ["date_field", ">=", "2018-01-01"], ["date_field", "<=", "2018-12-31"]],
+                            comparisonRangeDescription: "2018",
+                            fieldDescription: "Date Field Filter",
+                            fieldName: "date_field",
+                            range: ["&", ["date_field", ">=", "2019-01-01"], ["date_field", "<=", "2019-12-31"]],
+                            rangeDescription: "2019",
+                        });
+                        firstSearch = false;
+                    } else {
+                        assert.deepEqual(domain, ['!', ['foo', '=', 'qsdf']]);
+                        assert.deepEqual(groupBy, ['foo']);
+                        assert.deepEqual(timeRanges, {
+                            "favorite comparison content": "bla bla...",
+                            range: undefined,
+                            comparisonRange: undefined,
+                        });
+                    }
+                },
             };
             const controlPanel = await createControlPanel(params);
 
@@ -379,35 +397,26 @@ odoo.define('web.favorite_menu_tests', function (require) {
                 "&",
                 ["foo", "=", "a"],
                 "&",
-                ["date_field", ">=", "2019-07-01"],
-                ["date_field", "<=", "2019-07-31"]
+                ["date_field", ">=", "2019-01-01"],
+                ["date_field", "<=", "2019-12-31"]
             ]);
             assert.deepEqual(groupBy, ['date_field:month']);
-            assert.deepEqual(timeRanges, {
-                comparisonRange: [
-                    "&", ["date_field", ">=", "2019-07-30"], ["date_field", "<", "2019-07-31"]
-                ],
-                comparisonRangeDescription: "Previous Period",
-                comparisonRangeId: "previous_period",
-                fieldDescription: "Date",
-                fieldName: "date_field",
-                range: [
-                    "&", ["date_field", ">=", "2019-07-31"], ["date_field", "<", "2019-08-01"]
-                ],
-                rangeDescription: "Today",
-                rangeId: "today"
-            });
+            assert.deepEqual(timeRanges, {});
 
             assert.deepEqual(
                 cpHelpers.getFacetTexts(controlPanel),
                 [
                     'Foo\na',
-                    'Date Field Filter: July 2019',
+                    'Date Field Filter: 2019',
                     'Date Field Groupby: Month',
-                    'Date: Today / Previous Period'
                 ]
-            );
+                );
+
+            // activate a comparison
+            await cpHelpers.toggleComparisonMenu(controlPanel);
+            await cpHelpers.toggleMenuItem(controlPanel, "Date Field Filter: Previous period");
 
+            // activate the unique existing favorite
             await cpHelpers.toggleFavoriteMenu(controlPanel);
             await cpHelpers.toggleMenuItem(controlPanel, 0);
 
diff --git a/addons/web/static/tests/control_panel/filter_menu_tests.js b/addons/web/static/tests/control_panel/filter_menu_tests.js
index 4728c356728..15a41a21aea 100644
--- a/addons/web/static/tests/control_panel/filter_menu_tests.js
+++ b/addons/web/static/tests/control_panel/filter_menu_tests.js
@@ -185,20 +185,20 @@ odoo.define('web.filter_menu_tests', function (require) {
                 ["&", ["date_field", ">=", "2017-01-01"], ["date_field", "<=", "2017-12-31"]],
                 ["&", ["date_field", ">=", "2017-01-01"], ["date_field", "<=", "2017-12-31"]],
                 ["|",
-                    "&", ["date_field", ">=", "2017-01-01"], ["date_field", "<=", "2017-12-31"],
-                    "&", ["date_field", ">=", "2016-01-01"], ["date_field", "<=", "2016-12-31"]
+                    "&", ["date_field", ">=", "2016-01-01"], ["date_field", "<=", "2016-12-31"],
+                    "&", ["date_field", ">=", "2017-01-01"], ["date_field", "<=", "2017-12-31"]
                 ],
                 ["|",
                     "|",
-                    "&", ["date_field", ">=", "2017-01-01"], ["date_field", "<=", "2017-12-31"],
-                    "&", ["date_field", ">=", "2016-01-01"], ["date_field", "<=", "2016-12-31"],
-                    "&", ["date_field", ">=", "2015-01-01"], ["date_field", "<=", "2015-12-31"]
+                        "&", ["date_field", ">=", "2015-01-01"], ["date_field", "<=", "2015-12-31"],
+                        "&", ["date_field", ">=", "2016-01-01"], ["date_field", "<=", "2016-12-31"],
+                        "&", ["date_field", ">=", "2017-01-01"], ["date_field", "<=", "2017-12-31"]
                 ],
                 ["|",
                     "|",
-                    "&", ["date_field", ">=", "2017-03-01"], ["date_field", "<=", "2017-03-31"],
-                    "&", ["date_field", ">=", "2016-03-01"], ["date_field", "<=", "2016-03-31"],
-                    "&", ["date_field", ">=", "2015-03-01"], ["date_field", "<=", "2015-03-31"]
+                        "&", ["date_field", ">=", "2015-03-01"], ["date_field", "<=", "2015-03-31"],
+                        "&", ["date_field", ">=", "2016-03-01"], ["date_field", "<=", "2016-03-31"],
+                        "&", ["date_field", ">=", "2017-03-01"], ["date_field", "<=", "2017-03-31"]
                 ]
             ];
 
@@ -252,16 +252,16 @@ odoo.define('web.filter_menu_tests', function (require) {
                 { description: 'February', facetContent: 'Date: February 2017', selectedoptions: [1, 7] },
                 { description: 'February', facetContent: 'Date: 2017', selectedoptions: [7] },
                 { description: 'January', facetContent: 'Date: January 2017', selectedoptions: [2, 7] },
-                { description: 'Q4', facetContent: 'Date: January 2017 / Q4 2017', selectedoptions: [2, 3, 7] },
+                { description: 'Q4', facetContent: 'Date: January 2017/Q4 2017', selectedoptions: [2, 3, 7] },
                 { description: 'January', facetContent: 'Date: Q4 2017', selectedoptions: [3, 7] },
                 { description: 'Q4', facetContent: 'Date: 2017', selectedoptions: [7] },
                 { description: 'Q1', facetContent: 'Date: Q1 2017', selectedoptions: [6, 7] },
                 { description: 'Q1', facetContent: 'Date: 2017', selectedoptions: [7] },
                 { description: '2017', selectedoptions: [] },
                 { description: '2017', facetContent: 'Date: 2017', selectedoptions: [7] },
-                { description: '2016', facetContent: 'Date: 2017 / 2016', selectedoptions: [7, 8] },
-                { description: '2015', facetContent: 'Date: 2017 / 2016 / 2015', selectedoptions: [7, 8, 9] },
-                { description: 'March', facetContent: 'Date: March 2017 / March 2016 / March 2015', selectedoptions: [0, 7, 8, 9] }
+                { description: '2016', facetContent: 'Date: 2016/2017', selectedoptions: [7, 8] },
+                { description: '2015', facetContent: 'Date: 2015/2016/2017', selectedoptions: [7, 8, 9] },
+                { description: 'March', facetContent: 'Date: March 2015/March 2016/March 2017', selectedoptions: [0, 7, 8, 9] }
             ];
             for (const s of steps) {
                 const index = expectedDescriptions.indexOf(s.description);
diff --git a/addons/web/static/tests/control_panel/search_utils_tests.js b/addons/web/static/tests/control_panel/search_utils_tests.js
new file mode 100644
index 00000000000..60a7ae5089d
--- /dev/null
+++ b/addons/web/static/tests/control_panel/search_utils_tests.js
@@ -0,0 +1,336 @@
+odoo.define('web.search_utils_tests', function (require) {
+    "use strict";
+
+    const { constructDateDomain } = require('web.searchUtils');
+    const testUtils = require('web.test_utils');
+    const { _t } = require('web.core');
+
+    const patchDate = testUtils.mock.patchDate;
+
+    QUnit.module('SearchUtils', function () {
+
+        QUnit.module('Construct domain');
+
+        QUnit.test('construct simple domain based on date field (no comparisonOptionId)', function (assert) {
+            assert.expect(4);
+            const unpatchDate = patchDate(2020, 5, 1, 13, 0, 0);
+            const referenceMoment = moment().utc();
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', []),
+                {
+                    domain: "[]",
+                    description: "",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['this_month', 'this_year']),
+                {
+                    domain: `["&", ["date_field", ">=", "2020-06-01"], ["date_field", "<=", "2020-06-30"]]`,
+                    description: "June 2020",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['second_quarter', 'this_year']),
+                {
+                    domain: `["&", ["date_field", ">=", "2020-04-01"], ["date_field", "<=", "2020-06-30"]]`,
+                    description: "Q2 2020",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['this_year']),
+                {
+                    domain: `["&", ["date_field", ">=", "2020-01-01"], ["date_field", "<=", "2020-12-31"]]`,
+                    description: "2020",
+                }
+            );
+            unpatchDate();
+        });
+
+        QUnit.test('construct simple domain based on datetime field (no comparisonOptionId)', function (assert) {
+            assert.expect(3);
+            const unpatchDate = patchDate(2020, 5, 1, 13, 0, 0);
+            const referenceMoment = moment().utc();
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'datetime', ['this_month', 'this_year']),
+                {
+                    domain: `["&", ["date_field", ">=", "2020-06-01 00:00:00"], ["date_field", "<=", "2020-06-30 23:59:59"]]`,
+                    description: "June 2020",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'datetime', ['second_quarter', 'this_year']),
+                {
+                    domain: `["&", ["date_field", ">=", "2020-04-01 00:00:00"], ["date_field", "<=", "2020-06-30 23:59:59"]]`,
+                    description: "Q2 2020",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'datetime', ['this_year']),
+                {
+                    domain: `["&", ["date_field", ">=", "2020-01-01 00:00:00"], ["date_field", "<=", "2020-12-31 23:59:59"]]`,
+                    description: "2020",
+                }
+            );
+            unpatchDate();
+        });
+
+        QUnit.test('construct domain based on date field (no comparisonOptionId)', function (assert) {
+            assert.expect(3);
+            const unpatchDate = patchDate(2020, 0, 1, 12, 0, 0);
+            const referenceMoment = moment().utc();
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['this_month', 'first_quarter', 'this_year']),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                    `"&", ["date_field", ">=", "2020-01-01"], ["date_field", "<=", "2020-01-31"], ` +
+                                    `"&", ["date_field", ">=", "2020-01-01"], ["date_field", "<=", "2020-03-31"]` +
+                            "]",
+                    description: "January 2020/Q1 2020",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['second_quarter', 'this_year', 'last_year']),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                    `"&", ["date_field", ">=", "2019-04-01"], ["date_field", "<=", "2019-06-30"], ` +
+                                    `"&", ["date_field", ">=", "2020-04-01"], ["date_field", "<=", "2020-06-30"]` +
+                            "]",
+                    description: "Q2 2019/Q2 2020",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['this_year', 'this_month', 'antepenultimate_month']),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                    `"&", ["date_field", ">=", "2020-01-01"], ["date_field", "<=", "2020-01-31"], ` +
+                                    `"&", ["date_field", ">=", "2020-11-01"], ["date_field", "<=", "2020-11-30"]` +
+                            "]",
+                    description: "January 2020/November 2020",
+                }
+            );
+            unpatchDate();
+        });
+
+        QUnit.test('construct domain based on datetime field (no comparisonOptionId)', function (assert) {
+            assert.expect(3);
+            const unpatchDate = patchDate(2020, 0, 1, 12, 0, 0);
+            const referenceMoment = moment().utc();
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'datetime', ['this_month', 'first_quarter', 'this_year']),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                    `"&", ["date_field", ">=", "2020-01-01 00:00:00"], ["date_field", "<=", "2020-01-31 23:59:59"], ` +
+                                    `"&", ["date_field", ">=", "2020-01-01 00:00:00"], ["date_field", "<=", "2020-03-31 23:59:59"]` +
+                            "]",
+                    description: "January 2020/Q1 2020",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'datetime', ['second_quarter', 'this_year', 'last_year']),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                    `"&", ["date_field", ">=", "2019-04-01 00:00:00"], ["date_field", "<=", "2019-06-30 23:59:59"], ` +
+                                    `"&", ["date_field", ">=", "2020-04-01 00:00:00"], ["date_field", "<=", "2020-06-30 23:59:59"]` +
+                            "]",
+                    description: "Q2 2019/Q2 2020",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'datetime', ['this_year', 'this_month', 'antepenultimate_month']),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                    `"&", ["date_field", ">=", "2020-01-01 00:00:00"], ["date_field", "<=", "2020-01-31 23:59:59"], ` +
+                                    `"&", ["date_field", ">=", "2020-11-01 00:00:00"], ["date_field", "<=", "2020-11-30 23:59:59"]` +
+                            "]",
+                    description: "January 2020/November 2020",
+                }
+            );
+            unpatchDate();
+        });
+
+        QUnit.test('construct comparison domain based on date field and option "previous_period"', function (assert) {
+            assert.expect(5);
+            const unpatchDate = patchDate(2020, 0, 1, 12, 0, 0);
+            const referenceMoment = moment().utc();
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['this_month', 'first_quarter', 'this_year'], 'previous_period'),
+                {
+                    domain: "[" +
+                                `"|", "|", ` +
+                                `"&", ["date_field", ">=", "2019-10-01"], ["date_field", "<=", "2019-10-31"], ` +
+                                `"&", ["date_field", ">=", "2019-11-01"], ["date_field", "<=", "2019-11-30"], ` +
+                                `"&", ["date_field", ">=", "2019-12-01"], ["date_field", "<=", "2019-12-31"]` +
+                            "]",
+                    description: "October 2019/November 2019/December 2019",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['second_quarter', 'this_year', 'last_year'], 'previous_period'),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                `"&", ["date_field", ">=", "2018-01-01"], ["date_field", "<=", "2018-03-31"], ` +
+                                    `"&", ["date_field", ">=", "2019-01-01"], ["date_field", "<=", "2019-03-31"]` +
+                            "]",
+                    description: "Q1 2018/Q1 2019",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['this_year', 'antepenultimate_year', 'this_month', 'antepenultimate_month'], 'previous_period'),
+                {
+                    domain: "[" +
+                                `"|", "|", "|", ` +
+                                    `"&", ["date_field", ">=", "2015-02-01"], ["date_field", "<=", "2015-02-28"], ` +
+                                    `"&", ["date_field", ">=", "2015-12-01"], ["date_field", "<=", "2015-12-31"], ` +
+                                    `"&", ["date_field", ">=", "2017-02-01"], ["date_field", "<=", "2017-02-28"], ` +
+                                    `"&", ["date_field", ">=", "2017-12-01"], ["date_field", "<=", "2017-12-31"]` +
+                            "]",
+                    description: "February 2015/December 2015/February 2017/December 2017",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['this_year', 'last_year'], 'previous_period'),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                    `"&", ["date_field", ">=", "2017-01-01"], ["date_field", "<=", "2017-12-31"], ` +
+                                    `"&", ["date_field", ">=", "2018-01-01"], ["date_field", "<=", "2018-12-31"]` +
+                            "]",
+                    description: "2017/2018",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['second_quarter', 'third_quarter', 'last_year'], 'previous_period'),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                `"&", ["date_field", ">=", "2018-10-01"], ["date_field", "<=", "2018-12-31"], ` +
+                                    `"&", ["date_field", ">=", "2019-01-01"], ["date_field", "<=", "2019-03-31"]` +
+                            "]",
+                    description: "Q4 2018/Q1 2019",
+                }
+            );
+            unpatchDate();
+        });
+
+        QUnit.test('construct comparison domain based on datetime field and option "previous_year"', function (assert) {
+            assert.expect(3);
+            const unpatchDate = patchDate(2020, 5, 1, 13, 0, 0);
+            const referenceMoment = moment().utc();
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'datetime', ['this_month', 'first_quarter', 'this_year'], 'previous_year'),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                    `"&", ["date_field", ">=", "2019-06-01 00:00:00"], ["date_field", "<=", "2019-06-30 23:59:59"], ` +
+                                    `"&", ["date_field", ">=", "2019-01-01 00:00:00"], ["date_field", "<=", "2019-03-31 23:59:59"]` +
+                            "]",
+                    description: "June 2019/Q1 2019",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'datetime', ['second_quarter', 'this_year', 'last_year'], 'previous_year'),
+                {
+                    domain: "[" +
+                                `"|", ` +
+                                    `"&", ["date_field", ">=", "2018-04-01 00:00:00"], ["date_field", "<=", "2018-06-30 23:59:59"], ` +
+                                    `"&", ["date_field", ">=", "2019-04-01 00:00:00"], ["date_field", "<=", "2019-06-30 23:59:59"]` +
+                            "]",
+                    description: "Q2 2018/Q2 2019",
+                }
+            );
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'datetime', ['this_year', 'antepenultimate_year', 'this_month', 'antepenultimate_month'], 'previous_year'),
+                {
+                    domain: "[" +
+                                `"|", "|", "|", ` +
+                                `"&", ["date_field", ">=", "2017-04-01 00:00:00"], ["date_field", "<=", "2017-04-30 23:59:59"], ` +
+                                `"&", ["date_field", ">=", "2017-06-01 00:00:00"], ["date_field", "<=", "2017-06-30 23:59:59"], ` +
+                                `"&", ["date_field", ">=", "2019-04-01 00:00:00"], ["date_field", "<=", "2019-04-30 23:59:59"], ` +
+                                `"&", ["date_field", ">=", "2019-06-01 00:00:00"], ["date_field", "<=", "2019-06-30 23:59:59"]` +
+                            "]",
+                    description: "April 2017/June 2017/April 2019/June 2019",
+                }
+            );
+            unpatchDate();
+        });
+
+        QUnit.module('Options translation');
+
+        QUnit.test("Quarter option: custom translation", async function (assert) {
+            assert.expect(1);
+
+            const unpatchDate = patchDate(2020, 5, 1, 13, 0, 0);
+            const referenceMoment = moment().locale('en');
+            testUtils.mock.patch(_t.database.db, {
+                "Q2": "Deuxième trimestre de l'an de grâce",
+            });
+
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['second_quarter', 'this_year']),
+                {
+                    domain: `["&", ["date_field", ">=", "2020-04-01"], ["date_field", "<=", "2020-06-30"]]`,
+                    description: "Deuxième trimestre de l'an de grâce 2020",
+                },
+                "Quarter term should be translated"
+            );
+
+            unpatchDate();
+            testUtils.mock.unpatch(_t.database.db);
+        });
+
+        QUnit.test("Quarter option: right to left", async function (assert) {
+            assert.expect(1);
+
+            const unpatchDate = patchDate(2020, 5, 1, 13, 0, 0);
+            const referenceMoment = moment().locale('en');
+            testUtils.mock.patch(_t.database.parameters, {
+                direction: "rtl",
+            });
+
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['second_quarter', 'this_year']),
+                {
+                    domain: `["&", ["date_field", ">=", "2020-04-01"], ["date_field", "<=", "2020-06-30"]]`,
+                    description: "2020 Q2",
+                },
+                "Notation should be right to left"
+            );
+
+            unpatchDate();
+            testUtils.mock.unpatch(_t.database.parameters);
+        });
+
+        QUnit.test("Quarter option: custom translation and right to left", async function (assert) {
+            assert.expect(1);
+
+            const unpatchDate = patchDate(2020, 5, 1, 13, 0, 0);
+            const referenceMoment = moment().locale('en');
+            testUtils.mock.patch(_t.database.db, {
+                "Q2": "2e Trimestre",
+            });
+            testUtils.mock.patch(_t.database.parameters, {
+                direction: "rtl",
+            });
+
+            assert.deepEqual(
+                constructDateDomain(referenceMoment, 'date_field', 'date', ['second_quarter', 'this_year']),
+                {
+                    domain: `["&", ["date_field", ">=", "2020-04-01"], ["date_field", "<=", "2020-06-30"]]`,
+                    description: "2020 2e Trimestre",
+                },
+                "Quarter term should be translated and notation should be right to left"
+            );
+
+            unpatchDate();
+            testUtils.mock.unpatch(_t.database.db);
+            testUtils.mock.unpatch(_t.database.parameters);
+        });
+    });
+});
diff --git a/addons/web/static/tests/control_panel/time_range_menu_tests.js b/addons/web/static/tests/control_panel/time_range_menu_tests.js
deleted file mode 100644
index 17b6936c9ca..00000000000
--- a/addons/web/static/tests/control_panel/time_range_menu_tests.js
+++ /dev/null
@@ -1,333 +0,0 @@
-odoo.define('web.time_range_menu_tests', function (require) {
-    "use strict";
-
-    const testUtils = require('web.test_utils');
-    const { TIME_RANGE_OPTIONS, COMPARISON_TIME_RANGE_OPTIONS } = require('web.searchUtils');
-
-    const { controlPanel: cpHelpers, createControlPanel, mock } = testUtils;
-    const { patchDate } = mock;
-
-    const searchMenuTypes = ['timeRange'];
-
-    QUnit.module('Components', {
-        beforeEach: function () {
-            this.fields = {
-                birthday: { string: "Birthday", type: "date", store: true, sortable: true },
-                date_field: { string: "Date", type: "date", store: true, sortable: true },
-                float_field: { string: "Float", type: "float", group_operator: 'sum' },
-                foo: { string: "Foo", type: "char", store: true, sortable: true },
-            };
-        },
-    }, function () {
-
-        QUnit.module('TimeRangeMenu');
-
-        QUnit.test('simple rendering', async function (assert) {
-            assert.expect(12);
-
-            const params = {
-                cpStoreConfig: { viewInfo: { fields: this.fields }, searchMenuTypes },
-                cpProps: { fields: this.fields, searchMenuTypes },
-            };
-            const controlPanel = await createControlPanel(params);
-
-            assert.containsOnce(controlPanel, 'div.o_time_range_menu > button i.fa.fa-calendar');
-            assert.strictEqual(controlPanel.el.querySelector('div.o_time_range_menu > button span').innerText.trim(), 'Time Ranges');
-
-            await cpHelpers.toggleTimeRangeMenu(controlPanel);
-
-            assert.containsN(controlPanel, 'div.o_time_range_section', 3);
-
-            let selectEls = [...controlPanel.el.querySelectorAll('div.o_time_range_section select')];
-            assert.strictEqual(selectEls.length, 2);
-            assert.deepEqual(selectEls.map(e => e.value), ['birthday', 'this_month']);
-            assert.containsN(controlPanel, 'div.o_time_range_section label', 3);
-
-            const labelEls = [...controlPanel.el.querySelectorAll('div.o_time_range_section label')];
-            assert.deepEqual(labelEls.map(e => e.innerText.trim()), ['Based On', 'Range', 'Compare To']);
-            assert.containsOnce(controlPanel, 'div.o_time_range_section input[type="checkbox"]');
-
-            assert.containsOnce(controlPanel, 'div.o_time_range_menu ul button');
-            assert.strictEqual(
-                // text is upper cased in enterprise
-                controlPanel.el.querySelector('div.o_time_range_menu ul button').innerText.trim().toUpperCase(),
-                'APPLY'
-            );
-
-            await cpHelpers.toggleTimeRangeMenuBox(controlPanel);
-
-            selectEls = controlPanel.el.querySelectorAll('div.o_time_range_section select');
-            assert.strictEqual(selectEls.length, 3);
-            assert.strictEqual(selectEls[2].value, 'previous_period');
-
-            controlPanel.destroy();
-        });
-
-        QUnit.test('initialization with default time range without comparisonRange', async function (assert) {
-            assert.expect(5);
-
-            const unpatchDate = patchDate(2020, 0, 29, 15, 0, 0);
-
-            const params = {
-                cpStoreConfig: {
-                    viewInfo: { fields: this.fields },
-                    searchMenuTypes,
-                    actionContext: {
-                        time_ranges: { field: 'date_field', range: 'this_week' }
-                    }
-                },
-                cpProps: { fields: this.fields, searchMenuTypes },
-            };
-            const controlPanel = await createControlPanel(params);
-
-            const { timeRanges } = controlPanel.getQuery();
-            assert.deepEqual(timeRanges, {
-                fieldDescription: "Date",
-                fieldName: "date_field",
-                range: [
-                    "&",
-                    ["date_field", ">=", "2020-01-27"],
-                    ["date_field", "<", "2020-02-03"]
-                ],
-                rangeDescription: "This Week",
-                rangeId: "this_week"
-            });
-
-            await cpHelpers.toggleTimeRangeMenu(controlPanel);
-
-            const selectEls = controlPanel.el.querySelectorAll('div.o_time_range_section select');
-            assert.strictEqual(selectEls.length, 2);
-            assert.deepEqual(
-                [...selectEls].map(e => e.value),
-                ['date_field', 'this_week']
-            );
-
-            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), ['Date: This Week']);
-            assert.containsOnce(controlPanel.el.querySelector('.o_searchview .o_searchview_facet'),
-                'span.fa.fa-calendar.o_searchview_facet_label');
-
-            controlPanel.destroy();
-            unpatchDate();
-        });
-
-        QUnit.test('initialization with default time range with comparisonRange', async function (assert) {
-            assert.expect(4);
-
-            const unpatchDate = patchDate(2020, 0, 29, 15, 0, 0);
-
-            const params = {
-                cpStoreConfig: {
-                    viewInfo: { fields: this.fields },
-                    searchMenuTypes,
-                    actionContext: {
-                        time_ranges: { field: 'date_field', range: 'today', comparisonRange: 'previous_year' }
-                    }
-                },
-                cpProps: { fields: this.fields, searchMenuTypes },
-            };
-            const controlPanel = await createControlPanel(params);
-
-            const { timeRanges } = controlPanel.getQuery();
-            assert.deepEqual(timeRanges, {
-                comparisonRange: [
-                    "&",
-                    ["date_field", ">=", "2019-01-29"],
-                    ["date_field", "<", "2019-01-30"]
-                ],
-                comparisonRangeDescription: "Previous Year",
-                comparisonRangeId: "previous_year",
-                fieldDescription: "Date",
-                fieldName: "date_field",
-                range: [
-                    "&",
-                    ["date_field", ">=", "2020-01-29"],
-                    ["date_field", "<", "2020-01-30"]
-                ],
-                rangeDescription: "Today",
-                rangeId: "today"
-            });
-
-            await cpHelpers.toggleTimeRangeMenu(controlPanel);
-
-            const selectEls = controlPanel.el.querySelectorAll('div.o_time_range_section select');
-            assert.strictEqual(selectEls.length, 3);
-            assert.deepEqual(
-                [...selectEls].map(e => e.value),
-                ['date_field', 'today', 'previous_year']
-            );
-
-            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), ['Date: Today / Previous Year']);
-
-            controlPanel.destroy();
-            unpatchDate();
-        });
-
-        QUnit.test('activate a time range works', async function (assert) {
-            assert.expect(3);
-
-            const unpatchDate = patchDate(2020, 0, 29, 1, 0, 0);
-
-            const params = {
-                cpStoreConfig: {
-                    viewInfo: { fields: this.fields },
-                    searchMenuTypes,
-                },
-                cpProps: { fields: this.fields, searchMenuTypes },
-                search: function (searchQuery) {
-                    const { timeRanges } = searchQuery;
-                    assert.deepEqual(timeRanges, {
-                        comparisonRange: [
-                            "&",
-                            ["birthday", ">=", "2019-01-29"],
-                            ["birthday", "<", "2019-01-30"]
-                        ],
-                        comparisonRangeDescription: "Previous Year",
-                        comparisonRangeId: "previous_year",
-                        fieldDescription: "Birthday",
-                        fieldName: "birthday",
-                        range: [
-                            "&",
-                            ["birthday", ">=", "2020-01-29"],
-                            ["birthday", "<", "2020-01-30"]
-                        ],
-                        rangeDescription: "Today",
-                        rangeId: "today"
-                    });
-                }
-            };
-            const controlPanel = await createControlPanel(params);
-
-            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), []);
-
-            await cpHelpers.toggleTimeRangeMenu(controlPanel);
-            await cpHelpers.toggleTimeRangeMenuBox(controlPanel);
-
-            await cpHelpers.selectField(controlPanel, 'birthday');
-            await cpHelpers.selectRange(controlPanel, 'today');
-            await cpHelpers.selectComparisonRange(controlPanel, 'previous_year');
-
-            await cpHelpers.applyTimeRange(controlPanel);
-
-            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), ['Birthday: Today / Previous Year']);
-
-            controlPanel.destroy();
-            unpatchDate();
-        });
-
-        QUnit.test('no timeRanges key in search query if "timeRange" not in searchMenuTypes', async function (assert) {
-            assert.expect(1);
-
-            const params = {
-                cpStoreConfig: {
-                    viewInfo: { fields: this.fields },
-                    actionContext: {
-                        time_ranges: { field: 'date_field', range: 'this_week' }
-                    }
-                },
-                cpProps: { fields: this.fields },
-            };
-            const controlPanel = await createControlPanel(params);
-
-            const { timeRanges } = controlPanel.getQuery();
-            assert.strictEqual(timeRanges, undefined);
-
-            controlPanel.destroy();
-        });
-
-        QUnit.test('time ranges generated are correct', async function (assert) {
-            assert.expect(85);
-
-            const unpatchDate = patchDate(2017, 2, 22, 1, 0, 0);
-
-            const ranges = {
-                last_7_days: ['&', ["birthday", ">=", "2017-03-15"], ["birthday", "<", "2017-03-22"]],
-                last_30_days: ['&', ["birthday", ">=", "2017-02-20"], ["birthday", "<", "2017-03-22"]],
-                last_365_days: ['&', ["birthday", ">=", "2016-03-22"], ["birthday", "<", "2017-03-22"]],
-                last_5_years: ['&', ["birthday", ">=", "2012-03-22"], ["birthday", "<", "2017-03-22"]],
-                today: ['&', ["birthday", ">=", "2017-03-22"], ["birthday", "<", "2017-03-23"]],
-                this_week: ['&', ["birthday", ">=", "2017-03-20"], ["birthday", "<", "2017-03-27"]],
-                this_month: ['&', ["birthday", ">=", "2017-03-01"], ["birthday", "<", "2017-04-01"]],
-                this_quarter: ['&', ["birthday", ">=", "2017-01-01"], ["birthday", "<", "2017-04-01"]],
-                this_year: ['&', ["birthday", ">=", "2017-01-01"], ["birthday", "<", "2018-01-01"]],
-                yesterday: ['&', ["birthday", ">=", "2017-03-21"], ["birthday", "<", "2017-03-22"]],
-                last_week: ['&', ["birthday", ">=", "2017-03-13"], ["birthday", "<", "2017-03-20"]],
-                last_month: ['&', ["birthday", ">=", "2017-02-01"], ["birthday", "<", "2017-03-01"]],
-                last_quarter: ['&', ["birthday", ">=", "2016-10-01"], ["birthday", "<", "2017-01-01"]],
-                last_year: ['&', ["birthday", ">=", "2016-01-01"], ["birthday", "<", "2017-01-01"]],
-            };
-            const comparisonRanges = {
-                previous_period: {
-                    last_7_days: ['&', ["birthday", ">=", "2017-03-08"], ["birthday", "<", "2017-03-15"]],
-                    last_30_days: ['&', ["birthday", ">=", "2017-01-21"], ["birthday", "<", "2017-02-20"]],
-                    last_365_days: ['&', ["birthday", ">=", "2015-03-23"], ["birthday", "<", "2016-03-22"]],
-                    last_5_years: ['&', ["birthday", ">=", "2007-03-22"], ["birthday", "<", "2012-03-22"]],
-                    today: ['&', ["birthday", ">=", "2017-03-21"], ["birthday", "<", "2017-03-22"]],
-                    this_week: ['&', ["birthday", ">=", "2017-03-13"], ["birthday", "<", "2017-03-20"]],
-                    this_month: ['&', ["birthday", ">=", "2017-02-01"], ["birthday", "<", "2017-03-01"]],
-                    this_quarter: ['&', ["birthday", ">=", "2016-10-01"], ["birthday", "<", "2017-01-01"]],
-                    this_year: ['&', ["birthday", ">=", "2016-01-01"], ["birthday", "<", "2017-01-01"]],
-                    yesterday: ['&', ["birthday", ">=", "2017-03-20"], ["birthday", "<", "2017-03-21"]],
-                    last_week: ['&', ["birthday", ">=", "2017-03-06"], ["birthday", "<", "2017-03-13"]],
-                    last_month: ['&', ["birthday", ">=", "2017-01-01"], ["birthday", "<", "2017-02-01"]],
-                    last_quarter: ['&', ["birthday", ">=", "2016-07-01"], ["birthday", "<", "2016-10-01"]],
-                    last_year: ['&', ["birthday", ">=", "2015-01-01"], ["birthday", "<", "2016-01-01"]],
-                },
-                previous_year: {
-                    last_7_days: ["&", ["birthday", ">=", "2016-03-15"], ["birthday", "<", "2016-03-22"]],
-                    last_30_days: ["&", ["birthday", ">=", "2016-02-21"], ["birthday", "<", "2016-03-22"]],
-                    last_365_days: ["&", ["birthday", ">=", "2015-03-23"], ["birthday", "<", "2016-03-22"]],
-                    last_5_years: ["&", ["birthday", ">=", "2011-03-22"], ["birthday", "<", "2016-03-22"]],
-                    today: ["&", ["birthday", ">=", "2016-03-22"], ["birthday", "<", "2016-03-23"]],
-                    this_week: ["&", ["birthday", ">=", "2016-03-21"], ["birthday", "<", "2016-03-28"]],
-                    this_month: ["&", ["birthday", ">=", "2016-03-01"], ["birthday", "<", "2016-04-01"]],
-                    this_quarter: ["&", ["birthday", ">=", "2016-01-01"], ["birthday", "<", "2016-04-01"]],
-                    this_year: ["&", ["birthday", ">=", "2016-01-01"], ["birthday", "<", "2017-01-01"]],
-                    yesterday: ["&", ["birthday", ">=", "2016-03-21"], ["birthday", "<", "2016-03-22"]],
-                    last_week: ["&", ["birthday", ">=", "2016-03-14"], ["birthday", "<", "2016-03-21"]],
-                    last_month: ["&", ["birthday", ">=", "2016-02-01"], ["birthday", "<", "2016-03-01"]],
-                    last_quarter: ["&", ["birthday", ">=", "2015-10-01"], ["birthday", "<", "2016-01-01"]],
-                    last_year: ["&", ["birthday", ">=", "2015-01-01"], ["birthday", "<", "2016-01-01"]],
-                }
-            };
-
-            const params = {
-                cpStoreConfig: {
-                    viewInfo: { fields: this.fields },
-                    searchMenuTypes,
-                },
-                cpProps: { fields: this.fields, searchMenuTypes },
-                search: function (searchQuery) {
-                    const { timeRanges } = searchQuery;
-                    const { range, comparisonRange, rangeId, comparisonRangeId } = timeRanges;
-                    if (!comparisonRangeId) {
-                        assert.deepEqual(range, ranges[rangeId]);
-                    } else {
-                        assert.deepEqual(comparisonRange, comparisonRanges[comparisonRangeId][rangeId]);
-                    }
-                }
-            };
-            const controlPanel = await createControlPanel(params);
-
-            assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), []);
-
-            await cpHelpers.toggleTimeRangeMenu(controlPanel);
-
-            for (const o of Object.values(TIME_RANGE_OPTIONS)) {
-                await cpHelpers.selectRange(controlPanel, o.id);
-                await cpHelpers.applyTimeRange(controlPanel);
-                assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), [`Birthday: ${o.description}`]);
-
-                await cpHelpers.toggleTimeRangeMenuBox(controlPanel);
-                for (const co of Object.values(COMPARISON_TIME_RANGE_OPTIONS)) {
-                    await cpHelpers.selectComparisonRange(controlPanel, co.id);
-                    await cpHelpers.applyTimeRange(controlPanel);
-                    assert.deepEqual(cpHelpers.getFacetTexts(controlPanel), [`Birthday: ${o.description} / ${co.description}`]);
-                }
-                await cpHelpers.toggleTimeRangeMenuBox(controlPanel);
-            }
-
-            controlPanel.destroy();
-            unpatchDate();
-        });
-    });
-});