[FIX] web: BasicModel: default_get: correctly fetch m2o inside o2m

In general (e.g. read, search_read), values for many2one fields are pairs
[id, display_name]. The default_get is an exception, it only returns the id,
so we need to manually perform a name_get afterwards. In the case of
list views, those name_get RPCs are batched.

Before this rev., the code in charge of it didn't handle the case where the
many2one value was false, so it crashed when it happened.

This rev. deals with this use case and a test case has been added.

addons/web/static/src/js/views/basic/basic_model.js

@@ -1576,15 +1576,17 @@ var BasicModel = AbstractModel.extend({
         var self = this;
         var model;
         var records = [];
+        var ids = [];
         list = this._applyX2ManyOperations(list);
-        var ids = _.map(list.data, function (localId) {
+        _.each(list.data, function (localId) {
             var record = self.localData[localId];
             var data = record._changes || record.data;
             var many2oneId = data[fieldName];
+            if (!many2oneId) { return; }
             var many2oneRecord = self.localData[many2oneId];
             records.push(many2oneRecord);
+            ids.push(many2oneRecord.res_id);
             model = many2oneRecord.model;
-            return many2oneRecord.res_id;
         });
         return this._rpc({
                 model: model,

addons/web/static/tests/views/basic_model_tests.js

@@ -1323,6 +1323,64 @@ QUnit.module('Views', {
         model.destroy();
     });
 
+    QUnit.test('default_get: fetch many2one with default (empty & not) inside x2manys', function (assert) {
+        assert.expect(4);
+
+        this.data.partner.fields.o2m = {
+            string: "O2M", type: 'one2many', relation: 'partner', default: [
+                [6, 0, []],
+                [0, 0, {category: false}],
+                [0, 0, {category: 12}],
+            ],
+        };
+        this.data.partner.fields.category.type = 'many2one';
+
+        var model = createModel({
+            Model: BasicModel,
+            data: this.data,
+            mockRPC: function (route, args) {
+                if (args.method === 'name_get' && args.model === 'partner_type') {
+                    assert.deepEqual(args.args, [[12]], "should name_get on category 12");
+                }
+                return this._super(route, args);
+            },
+        });
+
+        var params = {
+            fieldNames: ['o2m'],
+            fields: this.data.partner.fields,
+            fieldsInfo: {
+                form: {
+                    o2m: {
+                        relatedFields: this.data.partner.fields,
+                        fieldsInfo: {
+                            list: {
+                                category: {
+                                    relatedFields: { display_name: {} },
+                                },
+                            },
+                        },
+                        viewType: 'list',
+                    },
+                },
+            },
+            modelName: 'partner',
+            type: 'record',
+            viewType: 'form',
+        };
+
+        model.load(params).then(function (resultID) {
+            var record = model.get(resultID);
+            assert.strictEqual(record.data.o2m.count, 2, "o2m field should contain 2 records");
+            assert.strictEqual(record.data.o2m.data[0].data.category, false,
+                "first category field should be empty");
+            assert.strictEqual(record.data.o2m.data[1].data.category.data.display_name, "gold",
+                "second category field should have been correctly fetched");
+        });
+
+        model.destroy();
+    });
+
     QUnit.test('default_get: fetch x2manys inside x2manys', function (assert) {
         assert.expect(3);