OLD | NEW |
1 'use strict'; | 1 'use strict'; |
2 | 2 |
3 // Run a set of tests for a given |sensorType|. |updateReading| is | 3 // Run a set of tests for a given |sensorType|. |updateReading| is |
4 // a called by the test to provide the mock values for sensor. |verifyReading| | 4 // a called by the test to provide the mock values for sensor. |verifyReading| |
5 // is called so that the value read in JavaScript are the values expected (the o
nes | 5 // is called so that the value read in JavaScript are the values expected (the o
nes |
6 // sent by |updateReading|). | 6 // sent by |updateReading|). |
7 function runGenericSensorTests(sensorType, updateReading, verifyReading) { | 7 function runGenericSensorTests(sensorType, updateReading, verifyReading) { |
8 sensor_test(sensor => { | 8 sensor_test(sensor => { |
9 sensor.mockSensorProvider.setGetSensorShouldFail(true); | 9 sensor.mockSensorProvider.setGetSensorShouldFail(true); |
10 let sensorObject = new sensorType; | 10 let sensorObject = new sensorType; |
11 sensorObject.start(); | 11 sensorObject.start(); |
12 return new Promise((resolve, reject) => { | 12 return new Promise((resolve, reject) => { |
13 let wrapper = new CallbackWrapper(event => { | 13 let wrapper = new CallbackWrapper(event => { |
14 assert_false(sensorObject.activated); | 14 assert_false(sensorObject.activated); |
15 assert_equals(event.error.name, 'NotReadableError'); | 15 assert_equals(event.error.name, 'NotReadableError'); |
16 sensorObject.onerror = null; | 16 sensorObject.onerror = null; |
17 resolve(); | 17 resolve(); |
18 }, reject); | 18 }, reject); |
19 | 19 |
20 sensorObject.onerror = wrapper.callback; | 20 sensorObject.onerror = wrapper.callback; |
21 }); | 21 }); |
22 }, 'Test that "onerror" is send when sensor is not supported.'); | 22 }, 'Test that "onerror" is send when sensor is not supported.'); |
23 | 23 |
24 sensor_test(sensor => { | 24 sensor_test(sensor => { |
25 let sensorObject = new sensorType({frequency: 560}); | 25 sensor.mockPermissionService.setSensorPermission(false); |
26 sensorObject.start(); | 26 let sensorObject = new sensorType(); |
| 27 sensorObject.start(); |
27 | 28 |
28 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 29 let testPromise = |
29 .then(mockSensor => { | 30 sensor.mockSensorProvider.getCreatedSensor().then(mockSensor => { |
30 mockSensor.setStartShouldFail(true); | |
31 return mockSensor.addConfigurationCalled(); }) | |
32 .then(mockSensor => { | |
33 return new Promise((resolve, reject) => { | 31 return new Promise((resolve, reject) => { |
34 let wrapper = new CallbackWrapper(event => { | 32 let wrapper = new CallbackWrapper(event => { |
35 assert_false(sensorObject.activated); | 33 assert_false(sensorObject.activated); |
36 assert_equals(event.error.name, 'NotReadableError'); | 34 assert_equals(event.error.name, 'NotReadableError'); |
37 sensorObject.onerror = null; | 35 sensorObject.onerror = null; |
38 resolve(); | 36 reject; |
39 }, reject); | 37 }, resolve()); |
40 | |
41 sensorObject.onerror = wrapper.callback; | |
42 }); | 38 }); |
43 }); | 39 }); |
44 return testPromise; | 40 return testPromise; |
| 41 }, 'Test that "onerror" is sent when permission is denied.'); |
| 42 |
| 43 sensor_test(sensor => { |
| 44 sensor.mockPermissionService.setSensorPermission(true); |
| 45 let sensorObject = new sensorType({frequency: 560}); |
| 46 sensorObject.start(); |
| 47 |
| 48 let testPromise = |
| 49 sensor.mockSensorProvider.getCreatedSensor() |
| 50 .then(mockSensor => { |
| 51 mockSensor.setStartShouldFail(true); |
| 52 return mockSensor.addConfigurationCalled(); |
| 53 }) |
| 54 .then(mockSensor => { |
| 55 return new Promise((resolve, reject) => { |
| 56 let wrapper = new CallbackWrapper(event => { |
| 57 assert_equals(sensorObject.state, 'errored'); |
| 58 assert_equals(event.error.name, 'OperationError'); |
| 59 sensorObject.onerror = null; |
| 60 resolve(); |
| 61 }, reject); |
| 62 |
| 63 sensorObject.onerror = wrapper.callback; |
| 64 }); |
| 65 }); |
| 66 return testPromise; |
45 }, 'Test that "onerror" is send when start() call has failed.'); | 67 }, 'Test that "onerror" is send when start() call has failed.'); |
46 | 68 |
47 sensor_test(sensor => { | 69 sensor_test(sensor => { |
48 let sensorObject = new sensorType({frequency: 560}); | 70 sensor.mockPermissionService.setSensorPermission(true); |
49 sensorObject.start(); | 71 let sensorObject = new sensorType({frequency: 560}); |
| 72 sensorObject.start(); |
50 | 73 |
51 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 74 let testPromise = |
52 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) | 75 sensor.mockSensorProvider.getCreatedSensor() |
53 .then(mockSensor => { | 76 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
54 return new Promise((resolve, reject) => { | 77 .then(mockSensor => { |
55 let wrapper = new CallbackWrapper(() => { | 78 return new Promise((resolve, reject) => { |
56 let configuration = mockSensor.active_sensor_configurations_[0]; | 79 let wrapper = new CallbackWrapper(() => { |
57 assert_equals(configuration.frequency, 60); | 80 let configuration = |
58 sensorObject.stop(); | 81 mockSensor.active_sensor_configurations_[0]; |
59 assert_false(sensorObject.activated); | 82 assert_equals(configuration.frequency, 60); |
60 resolve(mockSensor); | 83 sensorObject.stop(); |
61 }, reject); | 84 assert_false(sensorObject.state.activated); |
62 sensorObject.onactivate = wrapper.callback; | 85 resolve(mockSensor); |
63 sensorObject.onerror = reject; | 86 }, reject); |
| 87 sensorObject.onactivate = wrapper.callback; |
| 88 sensorObject.onerror = reject; |
| 89 }); |
| 90 }) |
| 91 .then(mockSensor => { |
| 92 return mockSensor.removeConfigurationCalled(); |
64 }); | 93 }); |
65 }) | 94 return testPromise; |
66 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }
); | |
67 return testPromise; | |
68 }, 'Test that frequency is capped to 60.0 Hz.'); | 95 }, 'Test that frequency is capped to 60.0 Hz.'); |
69 | 96 |
70 sensor_test(sensor => { | 97 sensor_test(sensor => { |
| 98 sensor.mockPermissionService.setSensorPermission(true); |
71 let maxSupportedFrequency = 15; | 99 let maxSupportedFrequency = 15; |
72 sensor.mockSensorProvider.setMaximumSupportedFrequency(maxSupportedFrequency
); | 100 sensor.mockSensorProvider.setMaximumSupportedFrequency(maxSupportedFrequency
); |
73 let sensorObject = new sensorType({frequency: 50}); | 101 let sensorObject = new sensorType({frequency: 50}); |
74 sensorObject.start(); | 102 sensorObject.start(); |
75 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 103 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
76 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) | 104 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
77 .then(mockSensor => { | 105 .then(mockSensor => { |
78 return new Promise((resolve, reject) => { | 106 return new Promise((resolve, reject) => { |
79 let wrapper = new CallbackWrapper(() => { | 107 let wrapper = new CallbackWrapper(() => { |
80 let configuration = mockSensor.active_sensor_configurations_[0]; | 108 let configuration = mockSensor.active_sensor_configurations_[0]; |
81 assert_equals(configuration.frequency, maxSupportedFrequency); | 109 assert_equals(configuration.frequency, maxSupportedFrequency); |
82 sensorObject.stop(); | 110 sensorObject.stop(); |
83 assert_false(sensorObject.activated); | 111 assert_false(sensorObject.activated); |
84 resolve(mockSensor); | 112 resolve(mockSensor); |
85 }, reject); | 113 }, reject); |
86 sensorObject.onactivate = wrapper.callback; | 114 sensorObject.onactivate = wrapper.callback; |
87 sensorObject.onerror = reject; | 115 sensorObject.onerror = reject; |
88 }); | 116 }); |
89 }) | 117 }) |
90 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 118 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
91 return testPromise; | 119 return testPromise; |
92 }, 'Test that frequency is capped to the maximum supported from frequency.'); | 120 }, 'Test that frequency is capped to the maximum supported from frequency.'); |
93 | 121 |
94 sensor_test(sensor => { | 122 sensor_test(sensor => { |
| 123 sensor.mockPermissionService.setSensorPermission(true); |
95 let minSupportedFrequency = 2; | 124 let minSupportedFrequency = 2; |
96 sensor.mockSensorProvider.setMinimumSupportedFrequency(minSupportedFrequency
); | 125 sensor.mockSensorProvider.setMinimumSupportedFrequency(minSupportedFrequency
); |
97 let sensorObject = new sensorType({frequency: -1}); | 126 let sensorObject = new sensorType({frequency: -1}); |
98 sensorObject.start(); | 127 sensorObject.start(); |
99 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 128 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
100 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) | 129 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
101 .then(mockSensor => { | 130 .then(mockSensor => { |
102 return new Promise((resolve, reject) => { | 131 return new Promise((resolve, reject) => { |
103 let wrapper = new CallbackWrapper(() => { | 132 let wrapper = new CallbackWrapper(() => { |
104 let configuration = mockSensor.active_sensor_configurations_[0]; | 133 let configuration = mockSensor.active_sensor_configurations_[0]; |
105 assert_equals(configuration.frequency, minSupportedFrequency); | 134 assert_equals(configuration.frequency, minSupportedFrequency); |
106 sensorObject.stop(); | 135 sensorObject.stop(); |
107 assert_false(sensorObject.activated); | 136 assert_false(sensorObject.activated); |
108 resolve(mockSensor); | 137 resolve(mockSensor); |
109 }, reject); | 138 }, reject); |
110 sensorObject.onactivate = wrapper.callback; | 139 sensorObject.onactivate = wrapper.callback; |
111 sensorObject.onerror = reject; | 140 sensorObject.onerror = reject; |
112 }); | 141 }); |
113 }) | 142 }) |
114 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 143 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
115 return testPromise; | 144 return testPromise; |
116 }, 'Test that frequency is limited to the minimum supported from frequency.'); | 145 }, 'Test that frequency is limited to the minimum supported from frequency.'); |
117 | 146 |
118 sensor_test(sensor => { | 147 sensor_test(sensor => { |
| 148 sensor.mockPermissionService.setSensorPermission(true); |
119 let sensorObject = new sensorType({frequency: 60}); | 149 let sensorObject = new sensorType({frequency: 60}); |
120 assert_false(sensorObject.activated); | 150 assert_false(sensorObject.activated); |
121 sensorObject.start(); | 151 sensorObject.start(); |
122 assert_false(sensorObject.activated); | 152 assert_false(sensorObject.activated); |
123 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 153 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
124 .then((mockSensor) => { | 154 .then((mockSensor) => { |
125 return new Promise((resolve, reject) => { | 155 return new Promise((resolve, reject) => { |
126 let wrapper = new CallbackWrapper(() => { | 156 let wrapper = new CallbackWrapper(() => { |
127 assert_true(sensorObject.activated); | 157 assert_true(sensorObject.activated); |
128 sensorObject.stop(); | 158 sensorObject.stop(); |
129 assert_false(sensorObject.activated); | 159 assert_false(sensorObject.activated); |
130 resolve(mockSensor); | 160 resolve(mockSensor); |
131 }, reject); | 161 }, reject); |
132 sensorObject.onactivate = wrapper.callback; | 162 sensorObject.onactivate = wrapper.callback; |
133 sensorObject.onerror = reject; | 163 sensorObject.onerror = reject; |
134 }); | 164 }); |
135 }) | 165 }) |
136 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 166 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
137 return testPromise; | 167 return testPromise; |
138 }, 'Test that sensor can be successfully created and its states are correct.')
; | 168 }, 'Test that sensor can be successfully created and its states are correct.')
; |
139 | 169 |
140 sensor_test(sensor => { | 170 sensor_test(sensor => { |
| 171 sensor.mockPermissionService.setSensorPermission(true); |
141 let sensorObject = new sensorType(); | 172 let sensorObject = new sensorType(); |
142 sensorObject.start(); | 173 sensorObject.start(); |
143 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 174 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
144 .then((mockSensor) => { | 175 .then((mockSensor) => { |
145 return new Promise((resolve, reject) => { | 176 return new Promise((resolve, reject) => { |
146 let wrapper = new CallbackWrapper(() => { | 177 let wrapper = new CallbackWrapper(() => { |
147 assert_true(sensorObject.activated); | 178 assert_true(sensorObject.activated); |
148 sensorObject.stop(); | 179 sensorObject.stop(); |
149 assert_false(sensorObject.activated); | 180 assert_false(sensorObject.activated); |
150 resolve(mockSensor); | 181 resolve(mockSensor); |
151 }, reject); | 182 }, reject); |
152 | 183 |
153 sensorObject.onactivate = wrapper.callback; | 184 sensorObject.onactivate = wrapper.callback; |
154 sensorObject.onerror = reject; | 185 sensorObject.onerror = reject; |
155 }); | 186 }); |
156 }) | 187 }) |
157 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 188 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
158 return testPromise; | 189 return testPromise; |
159 }, 'Test that sensor can be constructed with default configuration.'); | 190 }, 'Test that sensor can be constructed with default configuration.'); |
160 | 191 |
161 sensor_test(sensor => { | 192 sensor_test(sensor => { |
| 193 sensor.mockPermissionService.setSensorPermission(true); |
162 let sensorObject = new sensorType({frequency: 60}); | 194 let sensorObject = new sensorType({frequency: 60}); |
163 sensorObject.start(); | 195 sensorObject.start(); |
164 | 196 |
165 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 197 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
166 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) | 198 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
167 .then(mockSensor => { | 199 .then(mockSensor => { |
168 return new Promise((resolve, reject) => { | 200 return new Promise((resolve, reject) => { |
169 let wrapper = new CallbackWrapper(() => { | 201 let wrapper = new CallbackWrapper(() => { |
170 assert_true(sensorObject.activated); | 202 assert_true(sensorObject.activated); |
171 sensorObject.stop(); | 203 sensorObject.stop(); |
(...skipping 28 matching lines...) Expand all Loading... |
200 sensorObject.onchange = wrapper.callback; | 232 sensorObject.onchange = wrapper.callback; |
201 sensorObject.onerror = reject; | 233 sensorObject.onerror = reject; |
202 }); | 234 }); |
203 }) | 235 }) |
204 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 236 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
205 | 237 |
206 return testPromise; | 238 return testPromise; |
207 } | 239 } |
208 | 240 |
209 sensor_test(sensor => { | 241 sensor_test(sensor => { |
| 242 sensor.mockPermissionService.setSensorPermission(true); |
210 return checkOnChangeIsCalledAndReadingIsValid(sensor); | 243 return checkOnChangeIsCalledAndReadingIsValid(sensor); |
211 }, 'Test that onChange is called and sensor reading is valid (onchange reporti
ng).'); | 244 }, 'Test that onChange is called and sensor reading is valid (onchange reporti
ng).'); |
212 | 245 |
213 sensor_test(sensor => { | 246 sensor_test(sensor => { |
| 247 sensor.mockPermissionService.setSensorPermission(true); |
214 sensor.mockSensorProvider.setContinuousReportingMode(); | 248 sensor.mockSensorProvider.setContinuousReportingMode(); |
215 return checkOnChangeIsCalledAndReadingIsValid(sensor); | 249 return checkOnChangeIsCalledAndReadingIsValid(sensor); |
216 }, 'Test that onChange is called and sensor reading is valid (continuous repor
ting).'); | 250 }, 'Test that onChange is called and sensor reading is valid (continuous repor
ting).'); |
217 | 251 |
218 sensor_test(sensor => { | 252 sensor_test(sensor => { |
| 253 sensor.mockPermissionService.setSensorPermission(true); |
219 let sensorObject = new sensorType; | 254 let sensorObject = new sensorType; |
220 sensorObject.start(); | 255 sensorObject.start(); |
221 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 256 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
222 .then(mockSensor => { | 257 .then(mockSensor => { |
223 return mockSensor.setUpdateSensorReadingFunction(updateReading); | 258 return mockSensor.setUpdateSensorReadingFunction(updateReading); |
224 }) | 259 }) |
225 .then(mockSensor => { | 260 .then(mockSensor => { |
226 return new Promise((resolve, reject) => { | 261 return new Promise((resolve, reject) => { |
227 let wrapper = new CallbackWrapper(() => { | 262 let wrapper = new CallbackWrapper(() => { |
228 assert_true(verifyReading(sensorObject)); | 263 assert_true(verifyReading(sensorObject)); |
(...skipping 18 matching lines...) Expand all Loading... |
247 resolve(mockSensor); | 282 resolve(mockSensor); |
248 sensorObject.onerror = reject; | 283 sensorObject.onerror = reject; |
249 }); | 284 }); |
250 }) | 285 }) |
251 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 286 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
252 | 287 |
253 return testPromise; | 288 return testPromise; |
254 }, 'Test that sensor receives suspend / resume notifications when page' | 289 }, 'Test that sensor receives suspend / resume notifications when page' |
255 + ' visibility changes.'); | 290 + ' visibility changes.'); |
256 | 291 |
| 292 |
257 sensor_test(sensor => { | 293 sensor_test(sensor => { |
| 294 sensor.mockPermissionService.setSensorPermission(true); |
258 let sensor1 = new sensorType({frequency: 60}); | 295 let sensor1 = new sensorType({frequency: 60}); |
259 sensor1.start(); | 296 sensor1.start(); |
260 | 297 |
261 let sensor2 = new sensorType({frequency: 20}); | 298 let sensor2 = new sensorType({frequency: 20}); |
262 sensor2.start(); | 299 sensor2.start(); |
263 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 300 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
264 .then(mockSensor => { | 301 .then(mockSensor => { |
265 return mockSensor.setUpdateSensorReadingFunction(updateReading); | 302 return mockSensor.setUpdateSensorReadingFunction(updateReading); |
266 }) | 303 }) |
267 .then((mockSensor) => { | 304 .then((mockSensor) => { |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
337 fastSensor.onerror = reject; | 374 fastSensor.onerror = reject; |
338 slowSensor.onerror = reject; | 375 slowSensor.onerror = reject; |
339 }); | 376 }); |
340 }) | 377 }) |
341 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 378 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
342 | 379 |
343 return testPromise; | 380 return testPromise; |
344 } | 381 } |
345 | 382 |
346 sensor_test(sensor => { | 383 sensor_test(sensor => { |
| 384 sensor.mockPermissionService.setSensorPermission(true); |
347 return checkFrequencyHintWorks(sensor); | 385 return checkFrequencyHintWorks(sensor); |
348 }, 'Test that frequency hint works (onchange reporting).'); | 386 }, 'Test that frequency hint works (onchange reporting).'); |
349 | 387 |
350 sensor_test(sensor => { | 388 sensor_test(sensor => { |
| 389 sensor.mockPermissionService.setSensorPermission(true); |
351 sensor.mockSensorProvider.setContinuousReportingMode(); | 390 sensor.mockSensorProvider.setContinuousReportingMode(); |
352 return checkFrequencyHintWorks(sensor); | 391 return checkFrequencyHintWorks(sensor); |
353 }, 'Test that frequency hint works (continuous reporting).'); | 392 }, 'Test that frequency hint works (continuous reporting).'); |
354 } | 393 } |
OLD | NEW |