mirror of
https://github.com/servo/servo.git
synced 2025-07-02 04:53:39 +01:00
356 lines
12 KiB
HTML
356 lines
12 KiB
HTML
<!doctype html>
|
|
<meta charset="utf-8">
|
|
<title>Tests for PaymentInstruments interface</title>
|
|
<link rel="help" href="https://w3c.github.io/payment-handler/#paymentinstruments-interface">
|
|
<link rel="manifest" href="basic-card.json">
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
<script src="register-and-activate-service-worker.js"></script>
|
|
<script>
|
|
function runTests(registration) {
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
await registration.paymentManager.instruments.set('instrument-key-1', {
|
|
name: 'Instrument Name 1',
|
|
});
|
|
await registration.paymentManager.instruments.set('instrument-key-2', {
|
|
name: 'Instrument Name 2',
|
|
});
|
|
await registration.paymentManager.instruments.delete('instrument-key-1');
|
|
await registration.paymentManager.instruments.set('instrument-key-1', {
|
|
name: 'Instrument Name 1',
|
|
});
|
|
const keys = await registration.paymentManager.instruments.keys();
|
|
assert_array_equals(keys, ['instrument-key-2', 'instrument-key-1']);
|
|
}, 'Instrument keys are returned in the original insertion order');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
await registration.paymentManager.instruments.set(
|
|
'existing-instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
},
|
|
);
|
|
const result = await registration.paymentManager.instruments.delete(
|
|
'existing-instrument-key',
|
|
);
|
|
assert_true(result);
|
|
}, 'Deleting an existing instrument returns true');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
await registration.paymentManager.instruments.set(
|
|
'existing-instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
},
|
|
);
|
|
await registration.paymentManager.instruments.delete(
|
|
'existing-instrument-key',
|
|
);
|
|
const result = await registration.paymentManager.instruments.delete(
|
|
'existing-instrument-key',
|
|
);
|
|
assert_false(result);
|
|
}, 'Deleting an existing instrument the second time returns false');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
const result = await registration.paymentManager.instruments.delete(
|
|
'non-existing-instrument-key',
|
|
);
|
|
assert_false(result);
|
|
}, 'Deleting a non-existing instrument returns false');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
await registration.paymentManager.instruments.set(
|
|
'existing-instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
icons: [
|
|
{
|
|
src: '/images/rgrg-256x256.png',
|
|
sizes: '256x256',
|
|
type: 'image/png',
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
capabilities: {supportedNetworks: ['mir'], supportedTypes: ['prepaid']},
|
|
},
|
|
);
|
|
const result = await registration.paymentManager.instruments.get(
|
|
'existing-instrument-key',
|
|
);
|
|
assert_equals(result.name, 'Instrument Name');
|
|
}, 'Getting an existing instrument returns the instrument');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
const result = await registration.paymentManager.instruments.get(
|
|
'non-existing-instrument-key',
|
|
);
|
|
assert_equals(result, undefined);
|
|
}, 'Getting a non-existing instrument returns undefined');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
await registration.paymentManager.instruments.set(
|
|
'existing-instrument-key',
|
|
{
|
|
name: 'Instrument Name v1',
|
|
icons: [
|
|
{src: '/images/green-16x16.png', sizes: '16x16', type: 'image/png'},
|
|
],
|
|
method: 'basic-card',
|
|
capabilities: {supportedNetworks: ['mir'], supportedTypes: ['prepaid']},
|
|
},
|
|
);
|
|
let result = await registration.paymentManager.instruments.get(
|
|
'existing-instrument-key',
|
|
);
|
|
assert_equals(result.name, 'Instrument Name v1');
|
|
assert_equals(result.icons.length, 1);
|
|
assert_equals(
|
|
result.icons[0].src,
|
|
new URL('/images/green-16x16.png', window.location.href).href,
|
|
);
|
|
assert_equals(result.icons[0].sizes, '16x16');
|
|
assert_equals(result.icons[0].type, 'image/png');
|
|
assert_equals(result.method, 'basic-card');
|
|
assert_array_equals(result.capabilities.supportedNetworks, ['mir']);
|
|
assert_array_equals(result.capabilities.supportedTypes, ['prepaid']);
|
|
await registration.paymentManager.instruments.set(
|
|
'existing-instrument-key',
|
|
{
|
|
name: 'Instrument Name v2',
|
|
icons: [
|
|
{
|
|
src: '/images/rgrg-256x256.png',
|
|
sizes: '256x256',
|
|
type: 'image/png',
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
capabilities: {supportedNetworks: ['visa'], supportedTypes: ['credit']},
|
|
},
|
|
);
|
|
result = await registration.paymentManager.instruments.get(
|
|
'existing-instrument-key',
|
|
);
|
|
assert_equals(result.name, 'Instrument Name v2');
|
|
assert_equals(result.icons.length, 1);
|
|
assert_equals(
|
|
result.icons[0].src,
|
|
new URL('/images/rgrg-256x256.png', window.location.href).href,
|
|
);
|
|
assert_equals(result.icons[0].sizes, '256x256');
|
|
assert_equals(result.icons[0].type, 'image/png');
|
|
assert_equals(result.method, 'basic-card');
|
|
assert_array_equals(result.capabilities.supportedNetworks, ['visa']);
|
|
assert_array_equals(result.capabilities.supportedTypes, ['credit']);
|
|
}, 'Resetting an existing instrument updates the instrument');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
await registration.paymentManager.instruments.set(
|
|
'existing-instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
icons: [
|
|
{
|
|
src: '/images/rgrg-256x256.png',
|
|
sizes: '256x256',
|
|
type: 'image/png',
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
capabilities: {supportedNetworks: ['mir'], supportedTypes: ['prepaid']},
|
|
},
|
|
);
|
|
await registration.paymentManager.instruments.clear();
|
|
const result = await registration.paymentManager.instruments.get(
|
|
'existing-instrument-key',
|
|
);
|
|
assert_equals(result, undefined);
|
|
}, 'Clearing the instruments');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
const setPromise = registration.paymentManager.instruments.set(
|
|
'instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
icons: [
|
|
{
|
|
src: '/images/rgrg-256x256.png',
|
|
sizes: '256x256',
|
|
type: 'image/jif',
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
},
|
|
);
|
|
return promise_rejects(t, new TypeError(), setPromise);
|
|
}, 'Cannot register instruments with invalid icon media type image/jif');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
const setPromise = registration.paymentManager.instruments.set(
|
|
'instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
icons: [
|
|
{
|
|
src: '/images/rgrg-256x256.png',
|
|
sizes: '256x256',
|
|
type: 'image/pn' + 'g'.repeat(1000),
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
},
|
|
);
|
|
return promise_rejects(t, new TypeError(), setPromise);
|
|
}, "Don't crash when registering instruments with very long icon media type image/pngggggg...");
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
return registration.paymentManager.instruments.set('instrument-key', {
|
|
name: 'Instrument Name',
|
|
icons: [
|
|
{
|
|
src: '/images/rgrg-256x256.png',
|
|
sizes: '8'.repeat(100000) + 'x' + '8'.repeat(100000),
|
|
type: 'image/png',
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
});
|
|
}, "Don't crash when registering an instrument with a very long icon size 888...x888...");
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
const setPromise = registration.paymentManager.instruments.set(
|
|
'instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
icons: [
|
|
{
|
|
src: '/images/rgrg-256x256.png',
|
|
sizes: '256 256',
|
|
type: 'image/png',
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
},
|
|
);
|
|
return promise_rejects(t, new TypeError(), setPromise);
|
|
}, 'Cannot register instruments with invalid icon size "256 256" (missing "x")');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
const setPromise = registration.paymentManager.instruments.set(
|
|
'instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
icons: [
|
|
{
|
|
src: '/images/rg\0rg-256x256.png',
|
|
sizes: '256x256',
|
|
type: 'image/png',
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
},
|
|
);
|
|
return promise_rejects(t, new TypeError(), setPromise);
|
|
}, 'Cannot register instruments with invalid icon URL (has a null character)');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
const setPromise = registration.paymentManager.instruments.set(
|
|
'instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
icons: [
|
|
{
|
|
src: 'http://test.example/images/rgrg-256x256.png',
|
|
sizes: '256x256',
|
|
type: 'image/png',
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
},
|
|
);
|
|
return promise_rejects(t, new TypeError(), setPromise);
|
|
}, 'Cannot register instruments with non-existing non-https icon URL');
|
|
|
|
promise_test(async t => {
|
|
await registration.paymentManager.instruments.clear();
|
|
const setPromise = registration.paymentManager.instruments.set(
|
|
'instrument-key',
|
|
{
|
|
name: 'Instrument Name',
|
|
icons: [
|
|
{
|
|
src:
|
|
'http://www.chromium.org/_/rsrc/1438879449147/config/customLogo.gif',
|
|
sizes: '48x48',
|
|
type: 'image/gif',
|
|
},
|
|
],
|
|
method: 'basic-card',
|
|
},
|
|
);
|
|
return promise_rejects(t, new TypeError(), setPromise);
|
|
}, 'Cannot register instruments with an existing non-https icon URL');
|
|
|
|
async function testUnusualStrings(existingKey, nonExistingKey) {
|
|
await registration.paymentManager.instruments.clear();
|
|
await registration.paymentManager.instruments.set(existingKey, {
|
|
name: existingKey,
|
|
icons: [
|
|
{src: '/images/rgrg-256x256.png', sizes: '256x256', type: 'image/png'},
|
|
],
|
|
method: existingKey,
|
|
capabilities: {aCapabilityName: existingKey},
|
|
});
|
|
const hasExistingInstrument = await registration.paymentManager.instruments.has(
|
|
existingKey,
|
|
);
|
|
assert_true(hasExistingInstrument);
|
|
const hasNonExistingInstrument = await registration.paymentManager.instruments.has(
|
|
nonExistingKey,
|
|
);
|
|
assert_false(hasNonExistingInstrument);
|
|
const existingInstrument = await registration.paymentManager.instruments.get(
|
|
existingKey,
|
|
);
|
|
assert_equals(existingInstrument.name, existingKey);
|
|
const nonExistingInstrument = await registration.paymentManager.instruments.get(
|
|
nonExistingKey,
|
|
);
|
|
assert_equals(nonExistingInstrument, undefined);
|
|
const deletedExistingInstrument = await registration.paymentManager.instruments.delete(
|
|
existingKey,
|
|
);
|
|
assert_true(deletedExistingInstrument);
|
|
const deletedNonExistingInstrument = await registration.paymentManager.instruments.delete(
|
|
nonExistingKey,
|
|
);
|
|
assert_false(deletedNonExistingInstrument);
|
|
}
|
|
|
|
promise_test(async t => {
|
|
const length = 100000;
|
|
await testUnusualStrings('0'.repeat(length), '1'.repeat(length));
|
|
}, "Don't crash on very long key, name, method, and capability strings.");
|
|
|
|
promise_test(async t => {
|
|
await testUnusualStrings('foo\0bar', 'foo\0baz');
|
|
}, "Don't crash on null characters in key, name, method, and capability strings.");
|
|
}
|
|
|
|
registerAndActiveServiceWorker('basic-card.js', 'payment-app/', runTests);
|
|
</script>
|