[MERGE] forward port branch saas-16 up to 104dfe3c07d

8 files changed, 225 insertions, 35 deletions

diff --git a/addons/web/static/tests/fields/relational_fields_tests.js b/addons/web/static/tests/fields/relational_fields_tests.js
index aacbb744252..1a7badd353f 100644
--- a/addons/web/static/tests/fields/relational_fields_tests.js
+++ b/addons/web/static/tests/fields/relational_fields_tests.js
@@ -1,11 +1,13 @@
 odoo.define('web.relational_fields_tests', function (require) {
 "use strict";
 
+var BasicModel = require('web.BasicModel');
 var concurrency = require('web.concurrency');
 var FormView = require('web.FormView');
 var ListView = require('web.ListView');
 var relationalFields = require('web.relational_fields');
 var testUtils = require('web.test_utils');
+var Widget = require('web.Widget');
 
 var createView = testUtils.createView;
 
@@ -361,7 +363,6 @@ QUnit.module('relational_fields', {
         form.destroy();
     });
 
-
     QUnit.test('many2one readonly fields with option "no_open"', function (assert) {
         assert.expect(1);
 
@@ -564,10 +565,71 @@ QUnit.module('relational_fields', {
         form.destroy();
     });
 
+    QUnit.test('many2one field with option standalone', function (assert) {
+        assert.expect(3);
+        var done = assert.async();
+
+        var M2O_DELAY = relationalFields.FieldMany2One.prototype.AUTOCOMPLETE_DELAY;
+        relationalFields.FieldMany2One.prototype.AUTOCOMPLETE_DELAY = 0;
+
+        var fixture = $('#qunit-fixture');
+        var self = this;
+
+        var model = testUtils.createModel({
+            Model: BasicModel,
+            data: this.data,
+        });
+
+        model.makeRecord('coucou', [{
+            name: 'partner_id',
+            relation: 'partner',
+            type: 'many2one',
+            value: [1, 'first partner'],
+        }], {
+            partner_id: {
+                options: {
+                    no_open: true,
+                },
+            },
+        }).then(function (recordID) {
+            var record = model.get(recordID);
+            var parent = new Widget();
+            testUtils.addMockEnvironment(parent, {
+                data: self.data,
+                mockRPC: function (route, args) {
+                    assert.step(args.method);
+                    return this._super.apply(this, arguments);
+                },
+            });
+
+            var relField = new relationalFields.FieldMany2One(parent,
+                'partner_id',
+                record,
+                {
+                    mode: 'edit',
+                    standalone: true,
+            });
+
+            relField.appendTo(fixture);
+            $('input.o_input').val('xyzzrot').trigger('input');
+
+            concurrency.delay(0).then(function () {
+                var $dropdown = $('input.o_input').autocomplete('widget');
+                $dropdown.find('.o_m2o_dropdown_option:contains(Create)')
+                    .first().mouseenter().click();
+                assert.verifySteps(['name_search', 'name_create']);
+                parent.destroy();
+                model.destroy();
+                relationalFields.FieldMany2One.prototype.AUTOCOMPLETE_DELAY = M2O_DELAY;
+                done();
+            });
+        });
+    });
+
     // QUnit.test('onchange on a many2one to a different model', function (assert) {
-        // This test is commented because the mock server does not give the correct response.
-        // It should return a couple [id, display_name], but I don't know the logic used
-        // by the server, so it's hard to emulate it correctly
+    // This test is commented because the mock server does not give the correct response.
+    // It should return a couple [id, display_name], but I don't know the logic used
+    // by the server, so it's hard to emulate it correctly
     //     assert.expect(2);
 
     //     this.data.partner.records[0].product_id = 41;
@@ -995,14 +1057,16 @@ QUnit.module('relational_fields', {
                     assert.deepEqual(
                         args.kwargs.context,
                         {hey: "ho", hello: "world", test: "yop"},
-                        'the field attr context should have been used for the '
-                        + 'RPC (evaluated and merged with the session one)');
+                        'the field attr context should have been used for the ' +
+                        'RPC (evaluated and merged with the session one)');
+                    return $.when([]);
                 }
                 if (args.method === 'name_search' && args.model === 'partner') {
                     assert.deepEqual(args.kwargs.args, [['id', 'in', [12]]],
                         'the field attr domain should have been used for the RPC (and evaluated)');
                     assert.deepEqual(args.kwargs.context, {hey: 'ho', timmy: [[6, false, [12]]]},
                         'the field attr context should have been used for the RPC (and evaluated)');
+                    return $.when([]);
                 }
                 return this._super.apply(this, arguments);
             },
@@ -3652,6 +3716,34 @@ QUnit.module('relational_fields', {
         form.destroy();
     });
 
+    QUnit.test('id in one2many obtained in onchange is properly set', function (assert) {
+        assert.expect(1);
+
+        this.data.partner.onchanges.turtles = function (obj) {
+            obj.turtles = [
+                [5],
+                [1, 3, {turtle_foo: "kawa"}]
+            ];
+        };
+        var form = createView({
+            View: FormView,
+            model: 'partner',
+            data: this.data,
+            arch: '<form string="Partners">' +
+                    '<field name="turtles">' +
+                        '<tree>' +
+                            '<field name="id"/>' +
+                            '<field name="turtle_foo"/>' +
+                        '</tree>' +
+                    '</field>' +
+                '</form>',
+        });
+
+        assert.strictEqual(form.$('tr.o_data_row').text(), '3kawa',
+            "should have properly displayed id and foo field");
+        form.destroy();
+    });
+
     QUnit.test('sub form view with a required field', function (assert) {
         assert.expect(2);
         this.data.partner.fields.foo.required = true;
diff --git a/addons/web/static/tests/helpers/mock_server.js b/addons/web/static/tests/helpers/mock_server.js
index cab291ec012..06b85dd8f9e 100644
--- a/addons/web/static/tests/helpers/mock_server.js
+++ b/addons/web/static/tests/helpers/mock_server.js
@@ -465,25 +465,7 @@ var MockServer = Class.extend({
     _mockNameSearch: function (model, args, _kwargs) {
         var str = args && typeof args[0] === 'string' ? args[0] : _kwargs.name;
         var domain = (args && args[1]) || _kwargs.args || [];
-        var dom = domain[0];
-        var records = this.data[model].records;
-        if (dom) {
-            records = _.filter(records, function (record) {
-                var value = record[dom[0]];
-                if (value instanceof Array) {
-                    value = value[0];
-                }
-                if (dom[1] === 'not in') {
-                    return !_.contains(dom[2], value);
-                } else if (dom[1] === 'in') {
-                    return _.contains(dom[2], value);
-                } else if (dom[1] === '==') {
-                    return dom[2] == value;
-                } else if (dom[1] === '!=') {
-                    return dom[2] != value;
-                }
-            });
-        }
+        var records = this._getRecords(model, domain);
         if (str.length) {
             records = _.filter(records, function (record) {
                 return record.display_name.indexOf(str) !== -1;
@@ -632,7 +614,9 @@ var MockServer = Class.extend({
             var fieldName = groupByField.split(':')[0];
             var aggregateFunction = groupByField.split(':')[1] || 'month';
             if (fields[fieldName].type === 'date') {
-                if (aggregateFunction === 'day') {
+                if (!val) {
+                    return false;
+                } else if (aggregateFunction === 'day') {
                     return moment(val).format('YYYY-MM-DD');
                 } else {
                     return moment(val).format('MMMM YYYY');
diff --git a/addons/web/static/tests/views/calendar_tests.js b/addons/web/static/tests/views/calendar_tests.js
index 011843eefee..dfc42c6f746 100644
--- a/addons/web/static/tests/views/calendar_tests.js
+++ b/addons/web/static/tests/views/calendar_tests.js
@@ -3,6 +3,7 @@ odoo.define('web.calendar_tests', function (require) {
 
 var CalendarView = require('web.CalendarView');
 var CalendarRenderer = require('web.CalendarRenderer');
+var fieldUtils = require('web.field_utils');
 var testUtils = require('web.test_utils');
 var session = require('web.session');
 
@@ -431,6 +432,8 @@ QUnit.module('Views', {
                 'mode="week" '+
                 'readonly_form_view_id="1">'+
                     '<field name="name"/>'+
+                    '<field name="start"/>'+
+                    '<field name="allday"/>'+
             '</calendar>',
             archs: archs,
             viewOptions: {
@@ -478,14 +481,14 @@ QUnit.module('Views', {
         $('.modal button.btn:contains(Create)').trigger('click');
         var $newevent = calendar.$('.fc-event:contains(new event)');
 
-        assert.strictEqual($newevent.text().replace(/[\s\n\r]+/g, ''), "08:00-10:00newevent",
-            "should display the new event with time and title");
+        assert.strictEqual($newevent.text().replace(/[\s\n\r]+/g, ''), "08:00-10:00newevent12/13/201608:00:00False",
+            "should display the new event with time, title and additional fields");
 
         assert.deepEqual($newevent.data('fcSeg').event.record,
             {
                 display_name: "new event",
-                start: "2016-12-13 06:00:00",
-                stop: "2016-12-13 08:00:00",
+                start: fieldUtils.parse.datetime("2016-12-13 06:00:00", this.data.event.fields.start, {isUTC: true}),
+                stop: fieldUtils.parse.datetime("2016-12-13 08:00:00", this.data.event.fields.stop, {isUTC: true}),
                 allday: false,
                 name: "new event",
                 id: 1
@@ -616,8 +619,8 @@ QUnit.module('Views', {
         assert.deepEqual($newevent.data('fcSeg').event.record,
             {
                 display_name: "new event",
-                start: "2016-12-13 06:00:00",
-                stop: "2016-12-13 08:00:00",
+                start: fieldUtils.parse.datetime("2016-12-13 06:00:00", this.data.event.fields.start, {isUTC: true}),
+                stop: fieldUtils.parse.datetime("2016-12-13 08:00:00", this.data.event.fields.stop, {isUTC: true}),
                 allday: false,
                 name: "new event",
                 id: 1
@@ -691,8 +694,8 @@ QUnit.module('Views', {
         assert.deepEqual($newevent.data('fcSeg').event.record,
             {
                 display_name: "new event",
-                start: "2016-12-14 00:00:00",
-                stop: "2016-12-15 00:00:00",
+                start: fieldUtils.parse.datetime("2016-12-14 00:00:00", this.data.event.fields.start, {isUTC: true}),
+                stop: fieldUtils.parse.datetime("2016-12-15 00:00:00", this.data.event.fields.stop, {isUTC: true}),
                 allday: true,
                 name: "new event",
                 id: 1
diff --git a/addons/web/static/tests/views/form_tests.js b/addons/web/static/tests/views/form_tests.js
index 09ddcc20d46..183e5958b62 100644
--- a/addons/web/static/tests/views/form_tests.js
+++ b/addons/web/static/tests/views/form_tests.js
@@ -3555,10 +3555,13 @@ QUnit.module('Views', {
                     '</sheet>' +
                 '</form>',
             res_id: 2,
+            viewOptions: {
+                context: {some_context: true},
+            },
             intercepts: {
                 execute_action: function (e) {
                     assert.deepEqual(e.data.action_data.context, {test: 2},
-                        "button context should have been evaluated and given to the action");
+                        "button context should have been evaluated and given to the action, without previous context");
                 },
             },
         });
diff --git a/addons/web/static/tests/views/graph_tests.js b/addons/web/static/tests/views/graph_tests.js
index 7a7d22d96d6..33b2fd8ffbd 100644
--- a/addons/web/static/tests/views/graph_tests.js
+++ b/addons/web/static/tests/views/graph_tests.js
@@ -344,6 +344,34 @@ QUnit.module('Views', {
             done();
         });
     });
+
+    QUnit.test('correctly use group_by key from the context', function (assert) {
+        var done = assert.async();
+        assert.expect(2);
+
+        var graph = createView({
+            View: GraphView,
+            model: 'foo',
+            data: this.data,
+            arch: '<graph><field name="product_id" /></graph>',
+            groupBy: ['color_id'],
+            viewOptions: {
+                context: {
+                    graph_measure: 'foo',
+                    graph_mode: 'line',
+                },
+            },
+        });
+        return concurrency.delay(0).then(function () {
+            assert.strictEqual(graph.$('text:contains(xphone)').length, 0,
+                        'should not contain a text element with product in legend');
+            assert.strictEqual(graph.$('text:contains(red)').length, 1,
+                        'should contain a text element with color in legend');
+            graph.destroy();
+            done();
+        });
+    });
+
 });
 
 });
diff --git a/addons/web/static/tests/views/kanban_tests.js b/addons/web/static/tests/views/kanban_tests.js
index 89ec104fc41..dd0a52868f6 100644
--- a/addons/web/static/tests/views/kanban_tests.js
+++ b/addons/web/static/tests/views/kanban_tests.js
@@ -1626,6 +1626,35 @@ QUnit.module('Views', {
                         "column should contain 1 records");
         kanban.destroy();
     });
+
+    QUnit.test('don\'t fold column quick create after creation', function (assert) {
+        assert.expect(2);
+
+        var kanban = createView({
+            View: KanbanView,
+            model: 'partner',
+            data: this.data,
+            arch: '<kanban on_create="quick_create">' +
+                        '<field name="product_id"/>' +
+                        '<templates><t t-name="kanban-box">' +
+                            '<div><field name="foo"/></div>' +
+                        '</t></templates>' +
+                    '</kanban>',
+            groupBy: ['product_id'],
+        });
+
+        // add a new column
+        kanban.$('.o_kanban_group:first .o_kanban_quick_add').click();
+        var $quickCreate = kanban.$('.o_kanban_quick_create');
+        $quickCreate.find('input').val('new partner');
+        $quickCreate.find('button.o_kanban_add').click();
+        assert.strictEqual(this.data.partner.records.length, 5,
+            "should have created a 'new partner' column");
+
+        assert.strictEqual(kanban.$('.o_kanban_add:visible').length, 1,
+            "the add button should still be visible");
+        kanban.destroy();
+    });
 });
 
 });
diff --git a/addons/web/static/tests/views/list_tests.js b/addons/web/static/tests/views/list_tests.js
index 09109d92b84..e3d8acfe84a 100644
--- a/addons/web/static/tests/views/list_tests.js
+++ b/addons/web/static/tests/views/list_tests.js
@@ -2466,6 +2466,23 @@ QUnit.module('Views', {
 
         list.destroy();
     });
+
+    QUnit.test('list grouped by date:month', function (assert) {
+        assert.expect(1);
+
+        var list = createView({
+            View: ListView,
+            model: 'foo',
+            data: this.data,
+            arch: '<tree><field name="date"/></tree>',
+            groupBy: ['date:month'],
+        });
+
+        assert.strictEqual(list.$('tbody').text(), "January 2017 (1)Undefined (3)",
+            "the group names should be correct");
+
+        list.destroy();
+    });
 });
 
 });
diff --git a/addons/web/static/tests/views/pivot_tests.js b/addons/web/static/tests/views/pivot_tests.js
index c3acdb52399..267437845b0 100644
--- a/addons/web/static/tests/views/pivot_tests.js
+++ b/addons/web/static/tests/views/pivot_tests.js
@@ -825,4 +825,38 @@ QUnit.module('Views', {
         pivot.destroy();
     });
 
+    QUnit.test('correctly use group_by key from the context', function (assert) {
+        assert.expect(7);
+
+        var pivot = createView({
+            View: PivotView,
+            model: 'partner',
+            data: this.data,
+            arch: '<pivot>' +
+                        '<field name="customer" type="col" />' +
+                        '<field name="foo" type="measure" />' +
+                '</pivot>',
+            groupBy: ['product_id'],
+        });
+
+        assert.strictEqual(pivot.$('thead .o_pivot_header_cell_opened').length, 1,
+            'column: should have one opened header');
+        assert.strictEqual(pivot.$('thead .o_pivot_header_cell_closed:contains(First)').length, 1,
+            'column: should display one closed header with "First"');
+        assert.strictEqual(pivot.$('thead .o_pivot_header_cell_closed:contains(Second)').length, 1,
+            'column: should display one closed header with "Second"');
+
+        assert.strictEqual(pivot.$('tbody .o_pivot_header_cell_opened').length, 1,
+            'row: should have one opened header');
+        assert.strictEqual(pivot.$('tbody .o_pivot_header_cell_closed:contains(xphone)').length, 1,
+            'row: should display one closed header with "xphone"');
+        assert.strictEqual(pivot.$('tbody .o_pivot_header_cell_closed:contains(xpad)').length, 1,
+            'row: should display one closed header with "xpad"');
+
+        assert.strictEqual(pivot.$('tbody tr:first td:nth(3)').text(), '32',
+            'selected measure should be foo, with total 32');
+
+        pivot.destroy();
+    });
+
 });});