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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
"use strict";
Components.utils.import("resource://gre/modules/ExtensionCommon.jsm");
Components.utils.import("resource://gre/modules/Schemas.jsm");
let {BaseContext, LocalAPIImplementation} = ExtensionCommon;
let schemaJson = [
{
namespace: "testnamespace",
functions: [{
name: "one_required",
type: "function",
parameters: [{
name: "first",
type: "function",
parameters: [],
}],
}, {
name: "one_optional",
type: "function",
parameters: [{
name: "first",
type: "function",
parameters: [],
optional: true,
}],
}, {
name: "async_required",
type: "function",
async: "first",
parameters: [{
name: "first",
type: "function",
parameters: [],
}],
}, {
name: "async_optional",
type: "function",
async: "first",
parameters: [{
name: "first",
type: "function",
parameters: [],
optional: true,
}],
}],
},
];
const global = this;
class StubContext extends BaseContext {
constructor() {
let fakeExtension = {id: "test@web.extension"};
super("testEnv", fakeExtension);
this.sandbox = Cu.Sandbox(global);
}
get cloneScope() {
return this.sandbox;
}
get principal() {
return Cu.getObjectPrincipal(this.sandbox);
}
}
let context;
function generateAPIs(extraWrapper, apiObj) {
context = new StubContext();
let localWrapper = {
shouldInject() {
return true;
},
getImplementation(namespace, name) {
return new LocalAPIImplementation(apiObj, name, context);
},
};
Object.assign(localWrapper, extraWrapper);
let root = {};
Schemas.inject(root, localWrapper);
return root.testnamespace;
}
add_task(function* testParameterValidation() {
yield Schemas.load("data:," + JSON.stringify(schemaJson));
let testnamespace;
function assertThrows(name, ...args) {
Assert.throws(() => testnamespace[name](...args),
/Incorrect argument types/,
`Expected testnamespace.${name}(${args.map(String).join(", ")}) to throw.`);
}
function assertNoThrows(name, ...args) {
try {
testnamespace[name](...args);
} catch (e) {
do_print(`testnamespace.${name}(${args.map(String).join(", ")}) unexpectedly threw.`);
throw new Error(e);
}
}
let cb = () => {};
for (let isChromeCompat of [true, false]) {
do_print(`Testing API validation with isChromeCompat=${isChromeCompat}`);
testnamespace = generateAPIs({
isChromeCompat,
}, {
one_required() {},
one_optional() {},
async_required() {},
async_optional() {},
});
assertThrows("one_required");
assertThrows("one_required", null);
assertNoThrows("one_required", cb);
assertThrows("one_required", cb, null);
assertThrows("one_required", cb, cb);
assertNoThrows("one_optional");
assertNoThrows("one_optional", null);
assertNoThrows("one_optional", cb);
assertThrows("one_optional", cb, null);
assertThrows("one_optional", cb, cb);
// Schema-based validation happens before an async method is called, so
// errors should be thrown synchronously.
// The parameter was declared as required, but there was also an "async"
// attribute with the same value as the parameter name, so the callback
// parameter is actually optional.
assertNoThrows("async_required");
assertNoThrows("async_required", null);
assertNoThrows("async_required", cb);
assertThrows("async_required", cb, null);
assertThrows("async_required", cb, cb);
assertNoThrows("async_optional");
assertNoThrows("async_optional", null);
assertNoThrows("async_optional", cb);
assertThrows("async_optional", cb, null);
assertThrows("async_optional", cb, cb);
}
});
add_task(function* testAsyncResults() {
yield Schemas.load("data:," + JSON.stringify(schemaJson));
function* runWithCallback(func) {
do_print(`Calling testnamespace.${func.name}, expecting callback with result`);
return yield new Promise(resolve => {
let result = "uninitialized value";
let returnValue = func(reply => {
result = reply;
resolve(result);
});
// When a callback is given, the return value must be missing.
do_check_eq(returnValue, undefined);
// Callback must be called asynchronously.
do_check_eq(result, "uninitialized value");
});
}
function* runFailCallback(func) {
do_print(`Calling testnamespace.${func.name}, expecting callback with error`);
return yield new Promise(resolve => {
func(reply => {
do_check_eq(reply, undefined);
resolve(context.lastError.message); // eslint-disable-line no-undef
});
});
}
for (let isChromeCompat of [true, false]) {
do_print(`Testing API invocation with isChromeCompat=${isChromeCompat}`);
let testnamespace = generateAPIs({
isChromeCompat,
}, {
async_required(cb) {
do_check_eq(cb, undefined);
return Promise.resolve(1);
},
async_optional(cb) {
do_check_eq(cb, undefined);
return Promise.resolve(2);
},
});
if (!isChromeCompat) { // No promises for chrome.
do_print("testnamespace.async_required should be a Promise");
let promise = testnamespace.async_required();
do_check_true(promise instanceof context.cloneScope.Promise);
do_check_eq(yield promise, 1);
do_print("testnamespace.async_optional should be a Promise");
promise = testnamespace.async_optional();
do_check_true(promise instanceof context.cloneScope.Promise);
do_check_eq(yield promise, 2);
}
do_check_eq(yield* runWithCallback(testnamespace.async_required), 1);
do_check_eq(yield* runWithCallback(testnamespace.async_optional), 2);
let otherSandbox = Cu.Sandbox(null, {});
let errorFactories = [
msg => { throw new context.cloneScope.Error(msg); },
msg => context.cloneScope.Promise.reject({message: msg}),
msg => Cu.evalInSandbox(`throw new Error("${msg}")`, otherSandbox),
msg => Cu.evalInSandbox(`Promise.reject({message: "${msg}"})`, otherSandbox),
];
for (let makeError of errorFactories) {
do_print(`Testing callback/promise with error caused by: ${makeError}`);
testnamespace = generateAPIs({
isChromeCompat,
}, {
async_required() { return makeError("ONE"); },
async_optional() { return makeError("TWO"); },
});
if (!isChromeCompat) { // No promises for chrome.
yield Assert.rejects(testnamespace.async_required(), /ONE/,
"should reject testnamespace.async_required()").catch(() => {});
yield Assert.rejects(testnamespace.async_optional(), /TWO/,
"should reject testnamespace.async_optional()").catch(() => {});
}
do_check_eq(yield* runFailCallback(testnamespace.async_required), "ONE");
do_check_eq(yield* runFailCallback(testnamespace.async_optional), "TWO");
}
}
});
|
