1 files changed, 108 insertions, 1 deletions

diff --git a/addons/web/static/tests/views/basic_model_tests.js b/addons/web/static/tests/views/basic_model_tests.js
index 180d38668c7..cc3834e188e 100644
--- a/addons/web/static/tests/views/basic_model_tests.js
+++ b/addons/web/static/tests/views/basic_model_tests.js
@@ -707,7 +707,7 @@ QUnit.module('Views', {
     });
 
     QUnit.test('internal state of groups remains when reloading', function (assert) {
-        assert.expect(9);
+        assert.expect(10);
 
         this.params.fieldNames = ['foo'];
         this.params.domain = [];
@@ -739,6 +739,9 @@ QUnit.module('Views', {
             var record = model.get(resultID);
             assert.strictEqual(record.data.length, 2, "should have 2 groups");
             var groupID = record.data[0].id;
+            assert.strictEqual(model.localData[groupID].parentID, resultID,
+                "parentID should be correctly set on groups");
+
             model.toggleGroup(groupID);
 
             record = model.get(resultID);
@@ -772,6 +775,43 @@ QUnit.module('Views', {
         model.destroy();
     });
 
+    QUnit.test('read group when grouped by a selection field', function (assert) {
+        assert.expect(5);
+
+        this.data.partner.fields.selection = {
+            type: 'selection',
+            selection: [['a', 'A'], ['b', 'B']],
+        };
+        this.data.partner.records[0].selection = 'a';
+
+        var model = createModel({
+            Model: BasicModel,
+            data: this.data,
+        });
+        var params = {
+            modelName: 'partner',
+            fields: this.data.partner.fields,
+            fieldNames: ['foo'],
+            groupedBy: ['selection'],
+        };
+
+        model.load(params).then(function (resultID) {
+            var dataPoint = model.get(resultID);
+            assert.strictEqual(dataPoint.data.length, 2, "should have two groups");
+
+            var groupFalse = _.findWhere(dataPoint.data, {value: false});
+            assert.ok(groupFalse, "should have a group for value false");
+            assert.deepEqual(groupFalse.domain, [['selection', '=', false]],
+                "group's domain should be correct");
+
+            var groupA = _.findWhere(dataPoint.data, {value: 'A'});
+            assert.ok(groupA, "should have a group for value 'a'");
+            assert.deepEqual(groupA.domain, [['selection', '=', 'a']],
+                "group's domain should be correct");
+        });
+        model.destroy();
+    });
+
     QUnit.test('create record, then save', function (assert) {
         assert.expect(5);
 
@@ -1371,4 +1411,71 @@ QUnit.module('Views', {
 
         model.destroy();
     });
+
+    QUnit.test('changes are discarded when reloading from a new record', function (assert) {
+        // practical use case: click on 'Create' to open a form view in edit
+        // mode (new record), click on 'Discard', then open an existing record
+        assert.expect(2);
+
+        this.data.partner.fields.foo.default = 'default';
+        var model = createModel({
+            Model: BasicModel,
+            data: this.data,
+        });
+
+        // load a new record (default_get)
+        var params = _.extend(this.params, {
+            res_id: undefined,
+            type: 'record',
+            fieldNames: ['foo'],
+        });
+        model.load(params).then(function (resultID) {
+            var record = model.get(resultID);
+            assert.strictEqual(record.data.foo, 'default',
+                "should be the default value");
+
+            // reload with id 2
+            model.reload(record.id, {currentId: 2}).then(function (resultID) {
+                var record = model.get(resultID);
+                assert.strictEqual(record.data.foo, 'gnap',
+                    "should be the value of record 2");
+            });
+        });
+
+        model.destroy();
+    });
+
+    QUnit.test('has a proper evaluation context', function (assert) {
+        assert.expect(1);
+
+        this.params.fieldNames = Object.keys(this.data.partner.fields);
+        this.params.res_id = 1;
+
+        var model = createModel({
+            Model: BasicModel,
+            data: this.data,
+        });
+
+        model.load(this.params).then(function (resultID) {
+            var record = model.get(resultID);
+            assert.deepEqual(record.evalContext, {
+                active_id: 1,
+                active_ids: [1],
+                active_model: "partner",
+                bar: 1,
+                category: [12],
+                current_date: moment().format('YYYY-MM-DD'),
+                date: "2017-01-25",
+                display_name: "first partner",
+                foo: "blip",
+                id: 1,
+                product_id: 37,
+                product_ids: [],
+                qux: false,
+                total: 0
+            }, "should use the proper eval context");
+        });
+        model.destroy();
+    });
+
 });});