| <!DOCTYPE html> |
| <script src="../resources/testharness.js"></script> |
| <script src="../resources/testharnessreport.js"></script> |
| <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script> |
| <script src="file:///gen/services/device/public/mojom/nfc.mojom.js"></script> |
| <script src="resources/nfc-helpers.js"></script> |
| <script> |
| |
| 'use strict'; |
| |
| const invalid_type_messages = |
| [ |
| // Invalid NDEFMessageSource type |
| undefined, |
| |
| // NDEFMessage.records: should have at least 1 valid record. |
| // https://w3c.github.io/web-nfc/#the-push-method - Step 8. |
| createMessage([{}]), |
| |
| // https://w3c.github.io/web-nfc/#dfn-map-text-to-ndef |
| // NDEFRecord must have data. |
| createMessage([createTextRecord()]), |
| |
| // NDEFRecord.data for 'text' record must be number or string. |
| createMessage([createTextRecord(test_buffer_data)]), |
| createMessage([createTextRecord(test_json_data)]), |
| |
| // https://w3c.github.io/web-nfc/#dfn-map-a-json-object-to-ndef |
| // NDEFRecord must have data. |
| createMessage([createJsonRecord()]), |
| |
| // NDEFRecord.data for 'json' record must be object. |
| createMessage([createJsonRecord(test_buffer_data)]), |
| createMessage([createJsonRecord(test_number_data)]), |
| createMessage([createJsonRecord(test_text_data)]), |
| |
| // https://w3c.github.io/web-nfc/#dfn-map-a-url-to-ndef |
| // NDEFRecord must have data. |
| createMessage([createUrlRecord()]), |
| |
| // NDEFRecord.data for 'url' record must be string. |
| createMessage([createUrlRecord(test_buffer_data)]), |
| createMessage([createUrlRecord(test_number_data)]), |
| createMessage([createUrlRecord(test_json_data)]), |
| |
| // https://w3c.github.io/web-nfc/#dfn-map-binary-data-to-ndef |
| // NDEFRecord must have data. |
| createMessage([createOpaqueRecord()]), |
| // NDEFRecord.data for 'opaque' record must be ArrayBuffer. |
| createMessage([createOpaqueRecord(test_text_data)]), |
| createMessage([createOpaqueRecord(test_number_data)]), |
| createMessage([createOpaqueRecord(test_json_data)]) |
| ]; |
| |
| const invalid_syntax_messages = |
| [ |
| // NDEFRecord.mediaType for 'text' record must be 'text/*'. |
| createMessage([createRecord('text', 'application/json', |
| test_number_data)]), |
| |
| // Data for 'url' record, must be a valid URL. |
| createMessage([createUrlRecord('Invalid URL:// Data')]), |
| |
| // NDEFRecord.mediaType for 'json' record must be 'application/json' or |
| // starts with 'application/' and ends with '+json'. |
| createMessage([createRecord('json', 'image/png', test_json_data)]), |
| createMessage([createRecord('json', 'application/x+y', test_json_data)]), |
| createMessage([createRecord('json', 'custom/app+json', test_json_data)]), |
| ]; |
| |
| nfc_test(() => { |
| let promises = []; |
| invalid_type_messages.forEach(message => { |
| promises.push( |
| assertRejectsWithError(navigator.nfc.push(message), 'TypeError')); |
| }); |
| return Promise.all(promises); |
| }, 'Test that promise is rejected with TypeError if NDEFMessage is invalid.'); |
| |
| nfc_test(() => { |
| let promises = []; |
| invalid_syntax_messages.forEach(message => { |
| promises.push( |
| assertRejectsWithError(navigator.nfc.push(message), 'SyntaxError')); |
| }); |
| return Promise.all(promises); |
| }, 'Test that promise is rejected with SyntaxError if NDEFMessage contains' + |
| ' invalid records.'); |
| |
| nfc_test(() => { |
| mockNFC.setHWStatus(NFCHWStatus.DISABLED); |
| return assertRejectsWithError(navigator.nfc.push(test_text_data), |
| 'NotSupportedError'); |
| }, 'nfc.push should fail when NFC HW is disabled.'); |
| |
| nfc_test(() => { |
| mockNFC.setHWStatus(NFCHWStatus.NOT_SUPPORTED); |
| return assertRejectsWithError(navigator.nfc.push(test_text_data), |
| 'NotSupportedError'); |
| }, 'nfc.push should fail when NFC HW is not supported.'); |
| |
| nfc_test(() => { |
| return navigator.nfc.push(test_text_data, { timeout: 1 }); |
| }, 'nfc.push should succeed when NFC HW is enabled'); |
| |
| nfc_test(() => { |
| return assertRejectsWithError( |
| navigator.nfc.push(test_text_data, { timeout: 'invalid' }), 'TypeError'); |
| }, 'nfc.push should fail when invalid timeout is provided'); |
| |
| nfc_test(() => { |
| return assertRejectsWithError( |
| navigator.nfc.push(test_text_data, { timeout: -1 }), 'TypeError'); |
| }, 'nfc.push should fail when invalid negative timeout value is provided'); |
| |
| nfc_test(() => { |
| mockNFC.setPendingPushCompleted(false); |
| return assertRejectsWithError( |
| navigator.nfc.push(test_text_data,{ timeout: 1 }), |
| 'TimeoutError'); |
| }, 'nfc.push should fail with TimeoutError when push operation is not' + |
| ' completed before specified timeout value.'); |
| |
| nfc_test(async () => { |
| let message = createMessage([createTextRecord(test_text_data), |
| createJsonRecord(test_json_data), |
| createOpaqueRecord(test_buffer_data), |
| createTextRecord(test_number_data), |
| createUrlRecord(test_url_data)], |
| test_message_origin); |
| await navigator.nfc.push(message); |
| assertNDEFMessagesEqual(message, mockNFC.pushedMessage()); |
| }, 'nfc.push NDEFMessage containing text, json, opaque and url records with' |
| + ' default NFCPushOptions.'); |
| |
| nfc_test(async () => { |
| await navigator.nfc.push(test_text_data); |
| assertNDEFMessagesEqual(test_text_data, mockNFC.pushedMessage()); |
| }, 'nfc.push String with default NFCPushOptions.'); |
| |
| nfc_test(async () => { |
| await navigator.nfc.push(test_buffer_data); |
| assertNDEFMessagesEqual(test_buffer_data, mockNFC.pushedMessage()); |
| }, 'nfc.push ArrayBuffer with default NFCPushOptions.'); |
| |
| nfc_test(() => { |
| return navigator.nfc.push(createMessage([createRecord('empty')])); |
| }, 'nfc.push with "empty" record should succeed.'); |
| |
| nfc_test(async () => { |
| await navigator.nfc.push(test_text_data); |
| assertNFCPushOptionsEqual(createNFCPushOptions('any', Infinity, true), |
| mockNFC.pushOptions(), 'any'); |
| }, 'Check that default NFCPushOptions values are correctly set.'); |
| |
| nfc_test(async () => { |
| let nfcPushOptions = createNFCPushOptions('tag', 1, false); |
| await navigator.nfc.push(test_text_data, nfcPushOptions); |
| assertNFCPushOptionsEqual(nfcPushOptions, mockNFC.pushOptions()); |
| }, 'Check that provided NFCPushOptions values are correctly converted.'); |
| |
| nfc_test(async () => { |
| await navigator.nfc.push(test_text_data); |
| await navigator.nfc.cancelPush(); |
| }, 'nfc.cancelPush should succeed if there is not a pending push operation.'); |
| |
| nfc_test(async () => { |
| mockNFC.setPendingPushCompleted(false); |
| let promise = navigator.nfc.push(test_text_data, { timeout: 100 }); |
| await navigator.nfc.cancelPush(); |
| await assertRejectsWithError(promise, 'AbortError'); |
| }, 'nfc.cancelPush should reject pending promise with AbortError.'); |
| |
| nfc_test(() => { |
| return assertRejectsWithError( |
| navigator.nfc.push(new ArrayBuffer(32 * 1024 + 1)), |
| 'NotSupportedError'); |
| }, 'Reject promise with NotSupportedError if NFC message size exceeds 32KB.'); |
| |
| nfc_test(() => { |
| let message = createMessage([createTextRecord(test_text_data)]); |
| message.url = '%00/invalid/ path'; |
| return assertRejectsWithError( |
| navigator.nfc.push(message), |
| 'SyntaxError'); |
| }, 'Reject promise with SyntaxError if WebNFC Id cannot be created from' + |
| ' provided URL.'); |
| |
| nfc_test(() => { |
| let message = createMessage([createRecord('json','application/json', |
| { get x(){ return this; } })]); |
| return assertRejectsWithError( |
| navigator.nfc.push(message), |
| 'SyntaxError'); |
| }, 'Reject promise with SyntaxError if "json" record cannot be serialized.'); |
| |
| </script> |
