[FIX] web: deal with reference fields

The reference fields haven't been correctly implemented with the new views.
This commit restores their behaviour.

Note that an small improvement has been introduced in this commit.
Before saas-16, a `name_get` was done for each record (so 80 if the field
was displayed in a full list view), which is not optimal. The calls are now
batched by model (so one `name_get` by model appearing in the field values).

3 files changed, 169 insertions, 2 deletions

diff --git a/addons/web/static/tests/fields/relational_fields_tests.js b/addons/web/static/tests/fields/relational_fields_tests.js
index e67faabe220..5a2844f620d 100644
--- a/addons/web/static/tests/fields/relational_fields_tests.js
+++ b/addons/web/static/tests/fields/relational_fields_tests.js
@@ -34,6 +34,8 @@ QUnit.module('relational_fields', {
                     date: {string: "Some Date", type: "date"},
                     datetime: {string: "Datetime Field", type: 'datetime'},
                     user_id: {string: "User", type: 'many2one', relation: 'user'},
+                    reference: {string: "Reference Field", type: 'reference', selection: [
+                        ["product", "Product"], ["partner_type", "Partner Type"], ["partner", "Partner"]]},
                 },
                 records: [{
                     id: 1,
@@ -47,6 +49,7 @@ QUnit.module('relational_fields', {
                     timmy: [],
                     trululu: 4,
                     user_id: 17,
+                    reference: 'product,37',
                 }, {
                     id: 2,
                     display_name: "second record",
@@ -6419,6 +6422,103 @@ QUnit.module('relational_fields', {
         });
     });
 
+    QUnit.module('FieldReference');
+
+    QUnit.test('reference in form view', function (assert) {
+        assert.expect(15);
+
+        var form = createView({
+            View: FormView,
+            model: 'partner',
+            data: this.data,
+            arch: '<form string="Partners">' +
+                    '<sheet>' +
+                        '<group>' +
+                            '<field name="reference" string="custom label"/>' +
+                        '</group>' +
+                    '</sheet>' +
+                '</form>',
+            archs: {
+                'product,false,form': '<form string="Product"><field name="display_name"/></form>',
+            },
+            res_id: 1,
+            mockRPC: function (route, args) {
+                if (args.method === 'get_formview_action') {
+                    assert.deepEqual(args.args[0], [37], "should call get_formview_action with correct id");
+                    return $.when({
+                        res_id: 17,
+                        type: 'ir.actions.act_window',
+                        target: 'current',
+                        res_model: 'res.partner'
+                    });
+                }
+                if (args.method === 'get_formview_id') {
+                    assert.deepEqual(args.args[0], [37], "should call get_formview_id with correct id");
+                    return $.when(false);
+                }
+                if (args.method === 'name_search') {
+                    assert.strictEqual(args.model, 'partner_type',
+                        "the name_search should be done on the newly set model");
+                }
+                if (args.method === 'write') {
+                    assert.strictEqual(args.model, 'partner',
+                        "should write on the current model");
+                    assert.deepEqual(args.args, [[1], {reference: 'partner_type,12'}],
+                        "should write the correct value");
+                }
+                return this._super(route, args);
+            },
+        });
+
+        testUtils.intercept(form, 'do_action', function (event) {
+            assert.strictEqual(event.data.action.res_id, 17,
+                "should do a do_action with correct parameters");
+        });
+
+        assert.strictEqual(form.$('a.o_form_uri:contains(xphone)').length, 1,
+                        "should contain a link");
+        form.$('a.o_form_uri').click(); // click on the link in readonly mode (should trigger do_action)
+
+        form.$buttons.find('.o_form_button_edit').click();
+
+        assert.strictEqual(form.$('.o_field_widget').length, 2,
+            "should contain two field widgets (selection and many2one)");
+        assert.strictEqual(form.$('.o_field_many2one').length, 1,
+            "should contain one many2one");
+        assert.strictEqual(form.$('.o_field_widget select').val(), "product",
+            "widget should contain one select with the model");
+        assert.strictEqual(form.$('.o_field_widget input').val(), "xphone",
+            "widget should contain one input with the record");
+
+        var options = _.map(form.$('.o_field_widget select > option'), function (el) {
+            return $(el).val();
+        });
+        assert.deepEqual(options, ['', 'product', 'partner_type', 'partner'],
+            "the options should be correctly set");
+
+
+        form.$('.o_external_button').click(); // click on the external button (should do an RPC)
+
+        assert.strictEqual($('.modal .modal-title').text().trim(), 'Open: custom label',
+                        "dialog title should display the custom string label");
+        $('.modal .o_form_button_cancel').click();
+
+        form.$('.o_field_widget select').val('partner_type').trigger('change');
+        assert.strictEqual(form.$('.o_field_widget input').val(), "",
+            "many2one value should be reset after model change");
+
+        var $dropdown = form.$('.o_field_many2one input').autocomplete('widget');
+        // change the value of the m2o with a suggestion of the dropdown
+        form.$('.o_field_many2one input').click(); // will trigger a name_search on partner_type model
+        $dropdown.find('li:first()').click();
+
+        form.$buttons.find('.o_form_button_save').click();
+        assert.strictEqual(form.$('a.o_form_uri:contains(gold)').length, 1,
+                        "should contain a link with the new value");
+
+        form.destroy();
+    });
+
 });
 });
 });
diff --git a/addons/web/static/tests/views/basic_model_tests.js b/addons/web/static/tests/views/basic_model_tests.js
index 97047365436..715f6099e0a 100644
--- a/addons/web/static/tests/views/basic_model_tests.js
+++ b/addons/web/static/tests/views/basic_model_tests.js
@@ -20,6 +20,7 @@ QUnit.module('Views', {
                     product_ids: {string: "Favorite products", type: 'one2many', relation: 'product'},
                     category: {string: "Category M2M", type: 'many2many', relation: 'partner_type'},
                     date: {string: "Date Field", type: 'date'},
+                    reference: {string: "Reference Field", type: 'reference', selection: [["product", "Product"], ["partner_type", "Partner Type"], ["partner", "Partner"]]},
                 },
                 records: [
                     {id: 1, foo: 'blip', bar: 1, product_id: 37, category: [12], display_name: "first partner", date: "2017-01-25"},
@@ -1777,6 +1778,7 @@ QUnit.module('Views', {
                 product_id: 37,
                 product_ids: [],
                 qux: false,
+                reference: false,
                 total: 0
             }, "should use the proper eval context");
         });
@@ -1820,4 +1822,39 @@ QUnit.module('Views', {
         model.destroy();
     });
 
+    QUnit.test('fetch references in list, with not too many rpcs', function (assert) {
+        assert.expect(5);
+
+        this.data.partner.records[0].reference = 'product,37';
+        this.data.partner.records[1].reference = 'product,41';
+
+        this.params.fieldNames = ['reference'];
+        this.params.domain = [];
+        this.params.groupedBy = [];
+        this.params.res_id = undefined;
+
+        var model = createModel({
+            Model: BasicModel,
+            data: this.data,
+            mockRPC: function (route, args) {
+                assert.step(route);
+                if (route === "/web/dataset/call_kw/product/name_get") {
+                    assert.deepEqual(args.args, [[37, 41]],
+                        "the name_get should contain the product ids");
+                }
+                return this._super(route, args);
+            },
+        });
+
+        model.load(this.params).then(function (resultID) {
+            var record = model.get(resultID);
+
+            assert.strictEqual(record.data[0].data.reference.data.display_name, "xphone",
+                "name_get should have been correctly fetched");
+            assert.verifySteps(["/web/dataset/search_read",  "/web/dataset/call_kw/product/name_get"],
+                "should have done 2 rpc (searchread and name_get for product)");
+        });
+        model.destroy();
+    });
+
 });});
diff --git a/addons/web/static/tests/views/list_tests.js b/addons/web/static/tests/views/list_tests.js
index c39e6d2b1b0..e451c5a9c69 100644
--- a/addons/web/static/tests/views/list_tests.js
+++ b/addons/web/static/tests/views/list_tests.js
@@ -23,6 +23,8 @@ QUnit.module('Views', {
                     currency_id: {string: "Currency", type: "many2one",
                                   relation: "res_currency", default: 1},
                     datetime: {string: "Datetime Field", type: 'datetime'},
+                    reference: {string: "Reference Field", type: 'reference', selection: [
+                        ["bar", "Bar"], ["res_currency", "Currency"], ["event", "Event"]]},
                 },
                 records: [
                     {
@@ -37,11 +39,12 @@ QUnit.module('Views', {
                         currency_id: 2,
                         date: "2017-01-25",
                         datetime: "2016-12-12 10:55:05",
+                        reference: 'bar,1',
                     },
                     {id: 2, bar: true, foo: "blip", int_field: 9, qux: 13,
-                     m2o: 2, m2m: [1, 2, 3], amount: 500},
+                     m2o: 2, m2m: [1, 2, 3], amount: 500, reference: 'res_currency,1'},
                     {id: 3, bar: true, foo: "gnap", int_field: 17, qux: -3,
-                     m2o: 1, m2m: [], amount: 300},
+                     m2o: 1, m2m: [], amount: 300, reference: 'res_currency,2'},
                     {id: 4, bar: false, foo: "blip", int_field: -4, qux: 9,
                      m2o: 1, m2m: [1], amount: 0},
                 ]
@@ -2400,6 +2403,33 @@ QUnit.module('Views', {
         list.destroy();
     });
 
+    QUnit.test('reference field rendering', function (assert) {
+        assert.expect(4);
+
+        this.data.foo.records.push({
+            id: 5,
+            reference: 'res_currency,2',
+        });
+
+        var list = createView({
+            View: ListView,
+            model: 'foo',
+            data: this.data,
+            arch: '<tree><field name="reference"/></tree>',
+            mockRPC: function (route, args) {
+                if (args.method === 'name_get') {
+                    assert.step(args.model);
+                }
+                return this._super.apply(this, arguments);
+            },
+        });
+
+        assert.verifySteps(['bar', 'res_currency'], "should have done 1 name_get by model in reference values");
+        assert.strictEqual(list.$('tbody td').text(), "Value 1USDEUREUR",
+            "should have the display_name of the reference");
+        list.destroy();
+    });
+
 });
 
 });