| OLD | NEW |
|---|
| (Empty) |
| 1 <!DOCTYPE html> | |
| 2 <script src="../resources/testharness.js"></script> | |
| 3 <script src="../resources/testharness-helpers.js"></script> | |
| 4 <script src="../resources/testharnessreport.js"></script> | |
| 5 <script src="../resources/bluetooth/bluetooth-helpers.js"></script> | |
| 6 <script> | |
| 7 'use strict'; | |
| 8 | |
| 9 test(t => { assert_true(window.testRunner instanceof Object); t.done(); }, | |
| 10 'window.testRunner is required for the following tests.'); | |
| 11 | |
| 12 promise_test(() => { | |
| 13 testRunner.setBluetoothManualChooser(true); | |
| 14 let requestDevicePromise = | |
| 15 setBluetoothFakeAdapter('FailStartDiscoveryAdapter') | |
| 16 .then(() => requestDeviceWithKeyDown({ | |
| 17 filters: [{services: ['generic_access']}]})); | |
| 18 return getBluetoothManualChooserEvents(3) | |
| 19 .then(events => { | |
| 20 assert_array_equals(events, | |
| 21 ['chooser-opened(file://)', | |
| 22 'discovering', | |
| 23 'discovery-failed-to-start'], | |
| 24 events); | |
| 25 testRunner.sendBluetoothManualChooserEvent('cancelled', ''); | |
| 26 return assert_promise_rejects_with_message( | |
| 27 requestDevicePromise, | |
| 28 new DOMException('User cancelled the requestDevice() chooser.', | |
| 29 'NotFoundError'), | |
| 30 'The adapter failed to start a discovery session.'); | |
| 31 }); | |
| 32 }, 'Discovery session fails to start.'); | |
| 33 | |
| 34 promise_test(() => { | |
| 35 return setBluetoothFakeAdapter('NotPresentAdapter') | |
| 36 .then(() => assert_promise_rejects_with_message( | |
| 37 requestDeviceWithKeyDown({filters: [{services: ['generic_access']}]}), | |
| 38 new DOMException('Bluetooth adapter not available.', 'NotFoundError'), | |
| 39 'Bluetooth adapter is not present.')); | |
| 40 }, 'Reject with NotFoundError if the adapter is not present.'); | |
| 41 | |
| 42 promise_test(() => { | |
| 43 testRunner.setBluetoothManualChooser(true); | |
| 44 let requestDevicePromise = | |
| 45 setBluetoothFakeAdapter('NotPoweredAdapter') | |
| 46 .then(() => requestDeviceWithKeyDown({ | |
| 47 filters: [{services: ['generic_access']}]})); | |
| 48 return getBluetoothManualChooserEvents(2) | |
| 49 .then(events => { | |
| 50 assert_array_equals(events, | |
| 51 ['chooser-opened(file://)', | |
| 52 'adapter-disabled'], | |
| 53 events); | |
| 54 testRunner.sendBluetoothManualChooserEvent('cancelled', ''); | |
| 55 return assert_promise_rejects_with_message( | |
| 56 requestDevicePromise, | |
| 57 new DOMException('User cancelled the requestDevice() chooser.', | |
| 58 'NotFoundError'), | |
| 59 'Bluetooth adapter is not powered.'); | |
| 60 }); | |
| 61 }, 'Reject with NotFoundError if the adapter is off.'); | |
| 62 | |
| 63 promise_test(() => { | |
| 64 return setBluetoothFakeAdapter('EmptyAdapter') | |
| 65 .then(() => assert_promise_rejects_with_message( | |
| 66 requestDeviceWithKeyDown({filters: [{services: ['generic_access']}]}), | |
| 67 new DOMException('User cancelled the requestDevice() chooser.', | |
| 68 'NotFoundError'), | |
| 69 'No Bluetooth devices in range.')); | |
| 70 }, 'Reject with NotFoundError if there are no devices around.'); | |
| 71 | |
| 72 promise_test(() => { | |
| 73 return setBluetoothFakeAdapter('HeartRateAdapter') | |
| 74 .then(() => Promise.all([ | |
| 75 requestDeviceWithKeyDown({filters: [{services: [heart_rate.alias]}]}), | |
| 76 requestDeviceWithKeyDown({filters: [{services: [heart_rate.name]}]}), | |
| 77 requestDeviceWithKeyDown({filters: [{services: [heart_rate.uuid]}]}) | |
| 78 ])).then(devices => { | |
| 79 devices.forEach(device => { | |
| 80 assert_equals(device.constructor.name, 'BluetoothDevice'); | |
| 81 }); | |
| 82 }); | |
| 83 }, 'Mock will resolve.'); | |
| 84 | |
| 85 promise_test(() => { | |
| 86 return setBluetoothFakeAdapter('HeartRateAdapter') | |
| 87 .then(() => assert_promise_rejects( | |
| 88 navigator.bluetooth.requestDevice({ | |
| 89 filters: [{services: ['heart_rate']}]}), | |
| 90 new DOMException('', 'SecurityError'))); | |
| 91 }, 'Requires a user gesture.'); | |
| 92 | |
| 93 promise_test(() => { | |
| 94 return setBluetoothFakeAdapter('HeartRateAdapter') | |
| 95 .then(() => callWithKeyDown(() => { | |
| 96 var first = navigator.bluetooth.requestDevice({ | |
| 97 filters: [{services: ['heart_rate']}]}); | |
| 98 var second = navigator.bluetooth.requestDevice({ | |
| 99 filters: [{services: ['heart_rate']}]}); | |
| 100 return Promise.all([ | |
| 101 first.then(device => assert_equals( | |
| 102 device.constructor.name, 'BluetoothDevice')), | |
| 103 assert_promise_rejects(second, new DOMException('', 'SecurityError')), | |
| 104 ]); | |
| 105 })); | |
| 106 }, 'Consumes a user gesture.'); | |
| 107 | |
| 108 promise_test(() => { | |
| 109 return setBluetoothFakeAdapter('HeartRateAdapter') | |
| 110 .then(() => Promise.all([ | |
| 111 requestDeviceWithKeyDown({filters: [{services: [heart_rate.alias]}]}), | |
| 112 requestDeviceWithKeyDown({filters: [{services: [heart_rate.name]}]}), | |
| 113 requestDeviceWithKeyDown({filters: [{services: [heart_rate.uuid]}]}) | |
| 114 ])).then(devices => { | |
| 115 // requestDevice should return the same object if it was created | |
| 116 // earlier. https://crbug.com/495270 | |
| 117 // TODO(ortuno): Change to assert_equals. | |
| 118 assert_not_equals(devices[0], devices[1]); | |
| 119 assert_not_equals(devices[1], devices[2]); | |
| 120 }); | |
| 121 }, 'Returned device should always be the same.'); | |
| 122 | |
| 123 promise_test(() => { | |
| 124 // The work of this test is done in the ScanFilterCheckingAdapter. It asserts | |
| 125 // that this requestDevice() call tells the platform to scan for only devices | |
| 126 // that include the Battery, Glucose, or Heart Rate services. | |
| 127 return setBluetoothFakeAdapter('ScanFilterCheckingAdapter') | |
| 128 .then(() => requestDeviceWithKeyDown({ | |
| 129 filters: [{services: ['battery_service']}, | |
| 130 {services: ['glucose', 'heart_rate']}], | |
| 131 // The optionalServices shouldn't affect the platform's scan. | |
| 132 optionalServices: ['generic_access'] | |
| 133 })); | |
| 134 }, 'Filters restrict the platform\'s Bluetooth scan.'); | |
| 135 | |
| 136 promise_test(() => { | |
| 137 testRunner.setBluetoothManualChooser(true); | |
| 138 let requestDevicePromise = | |
| 139 setBluetoothFakeAdapter('GlucoseHeartRateAdapter') | |
| 140 .then(() => requestDeviceWithKeyDown({ | |
| 141 filters: [{services: ['glucose']}, | |
| 142 {services: ['heart_rate']}] | |
| 143 })); | |
| 144 return getBluetoothManualChooserEvents(5) | |
| 145 .then(events => { | |
| 146 assert_equals(events.length, 5, events); | |
| 147 assert_equals(events[0], 'chooser-opened(file://)', 'events[0]'); | |
| 148 let idsByName = new AddDeviceEventSet(); | |
| 149 for (let addedDevice of [events[1], events[2]]) { | |
| 150 idsByName.assert_add_device_event(addedDevice); | |
| 151 } | |
| 152 assert_true(idsByName.has('Heart Rate Device')); | |
| 153 assert_true(idsByName.has('Glucose Device')); | |
| 154 assert_equals(events[3], 'discovering'); | |
| 155 assert_equals(events[4], 'discovery-idle'); | |
| 156 testRunner.sendBluetoothManualChooserEvent('selected', | |
| 157 idsByName.get('Glucose Device')
); | |
| 158 return requestDevicePromise; | |
| 159 }).then(device => assert_equals(device.name, 'Glucose Device')); | |
| 160 }, 'The chooser includes all devices.'); | |
| 161 | |
| 162 promise_test(() => { | |
| 163 return setBluetoothFakeAdapter('GlucoseHeartRateAdapter') | |
| 164 .then(() => requestDeviceWithKeyDown({ | |
| 165 filters: [{services: ['glucose']}]})) | |
| 166 .then(device => assert_equals(device.name, 'Glucose Device')); | |
| 167 }, 'Simple filter selects matching device.'); | |
| 168 | |
| 169 promise_test(() => { | |
| 170 return setBluetoothFakeAdapter('GlucoseHeartRateAdapter') | |
| 171 .then(() => requestDeviceWithKeyDown({ | |
| 172 filters: [{services: ['glucose', 'tx_power']}] | |
| 173 })).then(device => assert_equals(device.name, 'Glucose Device')); | |
| 174 }, 'Filter with 2 services returns a matching device.'); | |
| 175 | |
| 176 promise_test(() => { | |
| 177 return setBluetoothFakeAdapter('GlucoseHeartRateAdapter') | |
| 178 .then(() => requestDeviceWithKeyDown({ | |
| 179 filters: [{services: ['battery_service']}, | |
| 180 {services: ['heart_rate']}] | |
| 181 })).then(device => assert_equals(device.name, 'Heart Rate Device')); | |
| 182 }, 'An extra filter doesn\'t prevent matching.'); | |
| 183 | |
| 184 promise_test(() => { | |
| 185 return setBluetoothFakeAdapter('GlucoseHeartRateAdapter') | |
| 186 .then(() => requestDeviceWithKeyDown({ | |
| 187 filters: [{services: ['glucose']}], | |
| 188 optionalServices: ['tx_power']})) | |
| 189 .then(device => { | |
| 190 assert_equals(device.uuids.length, 2); | |
| 191 assert_in_array(BluetoothUUID.getService('glucose'), device.uuids); | |
| 192 assert_in_array(BluetoothUUID.getService('tx_power'), device.uuids); | |
| 193 }); | |
| 194 }, 'We should only see UUID\'s that we\'ve been given permission for.') | |
| 195 | |
| 196 | |
| 197 promise_test(() => { | |
| 198 // Both devices support the Generic Access service, but things need to | |
| 199 // support both services to pass the filter, and neither has a Battery | |
| 200 // service. | |
| 201 return setBluetoothFakeAdapter('GlucoseHeartRateAdapter') | |
| 202 .then(() => assert_promise_rejects( | |
| 203 requestDeviceWithKeyDown({ | |
| 204 filters: [{services: ['heart_rate', 'battery_service']}] | |
| 205 }), new DOMException('', 'NotFoundError'))); | |
| 206 }, 'Too-strict filters do prevent matching.'); | |
| 207 | |
| 208 promise_test(() => { | |
| 209 testRunner.setBluetoothManualChooser(true); | |
| 210 | |
| 211 // Open the chooser, looking for a Heart Rate device. | |
| 212 let requestDevicePromise = | |
| 213 setBluetoothFakeAdapter('SecondDiscoveryFindsHeartRateAdapter') | |
| 214 .then(() => requestDeviceWithKeyDown({ | |
| 215 filters: [{services: ['heart_rate']}] | |
| 216 })); | |
| 217 | |
| 218 // The adapter finds nothing, so we just see discovery start and stop. | |
| 219 return getBluetoothManualChooserEvents(3).then(events => { | |
| 220 assert_array_equals(events, | |
| 221 ['chooser-opened(file://)', | |
| 222 'discovering', | |
| 223 'discovery-idle', | |
| 224 ]); | |
| 225 | |
| 226 // On the second discovery, the adapter finds the Heart Rate device. | |
| 227 testRunner.sendBluetoothManualChooserEvent('rescan', ''); | |
| 228 return getBluetoothManualChooserEvents(3); | |
| 229 }).then(events => { | |
| 230 assert_equals(events.length, 3, events); | |
| 231 assert_equals(events[0], 'discovering', 'events[0]'); | |
| 232 let idsByName = new AddDeviceEventSet(); | |
| 233 idsByName.assert_add_device_event(events[1]); | |
| 234 assert_true(idsByName.has('Heart Rate Device')); | |
| 235 assert_equals(events[2], 'discovery-idle'); | |
| 236 | |
| 237 // Select it and let the test complete. | |
| 238 testRunner.sendBluetoothManualChooserEvent('selected', | |
| 239 idsByName.get('Heart Rate Device'
)); | |
| 240 return requestDevicePromise; | |
| 241 }).then(device => assert_equals(device.name, 'Heart Rate Device')); | |
| 242 }, 'The chooser can restart the BT scan.'); | |
| 243 </script> | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1910933002:
bluetooth: Separate requestDevice tests (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@bluetooth-mojo-gatt-connect