1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
odoo.define('web.abstract_model_tests', function (require) {
"use strict";
const AbstractModel = require('web.AbstractModel');
const Domain = require('web.Domain');
QUnit.module('Views', {}, function () {
QUnit.module('AbstractModel');
QUnit.test('leave sample mode when unknown route is called on sample server', async function (assert) {
assert.expect(4);
const Model = AbstractModel.extend({
_isEmpty() {
return true;
},
async __load() {
if (this.isSampleModel) {
await this._rpc({ model: 'partner', method: 'unknown' });
}
},
});
const model = new Model(null, {
modelName: 'partner',
fields: {},
useSampleModel: true,
SampleModel: Model,
});
assert.ok(model.useSampleModel);
assert.notOk(model._isInSampleMode);
await model.load({});
assert.notOk(model.useSampleModel);
assert.notOk(model._isInSampleMode);
model.destroy();
});
QUnit.test("don't cath general error on sample server in sample mode", async function (assert) {
assert.expect(5);
const error = new Error();
const Model = AbstractModel.extend({
_isEmpty() {
return true;
},
async __reload() {
if (this.isSampleModel) {
await this._rpc({ model: 'partner', method: 'read_group' });
}
},
async _rpc() {
throw error;
},
});
const model = new Model(null, {
modelName: 'partner',
fields: {},
useSampleModel: true,
SampleModel: Model,
});
assert.ok(model.useSampleModel);
assert.notOk(model._isInSampleMode);
await model.load({});
assert.ok(model.useSampleModel);
assert.ok(model._isInSampleMode);
async function reloadModel() {
try {
await model.reload();
} catch (e) {
assert.strictEqual(e, error);
}
}
await reloadModel();
model.destroy();
});
QUnit.test('fetch sample data: concurrency', async function (assert) {
assert.expect(3);
const Model = AbstractModel.extend({
_isEmpty() {
return true;
},
__get() {
return { isSample: !!this.isSampleModel };
},
});
const model = new Model(null, {
modelName: 'partner',
fields: {},
useSampleModel: true,
SampleModel: Model,
});
await model.load({ domain: Domain.FALSE_DOMAIN, });
const beforeReload = model.get(null, { withSampleData: true });
const reloaded = model.reload(null, { domain: Domain.TRUE_DOMAIN });
const duringReload = model.get(null, { withSampleData: true });
await reloaded;
const afterReload = model.get(null, { withSampleData: true });
assert.strictEqual(beforeReload.isSample, true,
"Sample data flag must be true before reload"
);
assert.strictEqual(duringReload.isSample, true,
"Sample data flag must be true during reload"
);
assert.strictEqual(afterReload.isSample, false,
"Sample data flag must be true after reload"
);
});
});
});
|
