chromium/src/third_party/blink/web_tests/http/tests/credentialmanager/credentialscontainer-get-with-virtual-authenticator.html - manifest_repos/chromium_src - Git at Google

 <!DOCTYPE html>
 <title>Credential Manager: End-to-end tests for get() with a virtual authenticator.</title>
 <script src="../resources/testharness.js"></script>
 <script src="../resources/testharnessreport.js"></script>
 <body>
 <script type="module">
 import {AuthenticatorTransport} from '/gen/third_party/blink/public/mojom/webauthn/authenticator.mojom.m.js';
 import {ACCEPTABLE_CREDENTIAL, ACCEPTABLE_CREDENTIAL_ID, authenticatorSetup, deepCopy, GET_CREDENTIAL_OPTIONS, MAKE_CREDENTIAL_OPTIONS, PUBLIC_KEY_USER} from './resources/test-inputs.js';
 import {TestAuthenticatorManager} from './resources/virtual-navigator-credentials.js';

 if (document.location.host != "subdomain.example.test:8443") {
   document.location = "https://subdomain.example.test:8443/credentialmanager/credentialscontainer-get-with-virtual-authenticator.html";
   promise_test(_ => new Promise(_ => {}), "Stall tests on the wrong host.");
 }

 const manager = new TestAuthenticatorManager;

 authenticatorSetup(manager, "CTAP2_0", () => {
   promise_test(async _ => {
     let authenticators = await manager.authenticators();
     assert_equals(authenticators.length, 1);
     let testAuthenticator = authenticators[0];
     assert_true(await testAuthenticator.generateAndRegisterKey(ACCEPTABLE_CREDENTIAL_ID, "subdomain.example.test"));
   }, "Set up the testing environment for ctap 2.0.");

   promise_test(async t => {
     let testAuthenticator = await manager.createAuthenticator();
     t.add_cleanup(async () => {
       let id = await testAuthenticator.id();
       return manager.removeAuthenticator(id);
     });
     assert_true(await testAuthenticator.generateAndRegisterKey(ACCEPTABLE_CREDENTIAL_ID, "subdomain.example.test"));
     let keys = await testAuthenticator.registeredKeys();
     assert_equals(keys.length, 1);
     var customGetAssertionOptions = deepCopy(GET_CREDENTIAL_OPTIONS);
     var someOtherCredential = deepCopy(ACCEPTABLE_CREDENTIAL);
     someOtherCredential.id = new TextEncoder().encode("someOtherCredential");
     customGetAssertionOptions.allowCredentials = [someOtherCredential];

     return promise_rejects_dom(t, "NotAllowedError",
       navigator.credentials.get({ publicKey : customGetAssertionOptions}));
   }, "navigator.credentials.get() for unregistered device returns NotAllowedError");

   promise_test(async t => {
     // Injecting resident credentials through the mojo virtual authenticator is
     // not supported.
     var customMakeCredOptions = deepCopy(MAKE_CREDENTIAL_OPTIONS);
     customMakeCredOptions.authenticatorSelection.requireResidentKey = true;
     var residentCredential =
       await navigator.credentials.create({ publicKey : customMakeCredOptions });

     var customGetAssertionOptions = deepCopy(GET_CREDENTIAL_OPTIONS);
     delete customGetAssertionOptions.allowCredentials;
     customGetAssertionOptions.user = PUBLIC_KEY_USER;
     return navigator.credentials.get({ publicKey : customGetAssertionOptions })
       .then(credential => assert_equals(credential.id, residentCredential.id));
   }, "navigator.credentials.get() with empty allowCredentials returns a resident credential");

   promise_test(t => {
     var customGetCredentialOptions = deepCopy(GET_CREDENTIAL_OPTIONS);
     customGetCredentialOptions.allowCredentials.transports = [];
     return navigator.credentials.get({publicKey: customGetCredentialOptions}).then();
   }, "navigator.credentials.get() with missing transports in allowCredentials.");

   promise_test(async t => {
     const authAbortController = new AbortController();
     const authAbortSignal = authAbortController.signal;
     return navigator.credentials.get({ publicKey : GET_CREDENTIAL_OPTIONS, signal : authAbortSignal});
   }, "navigator.credentials.get() with abort signal flag not set");

   promise_test(async t => {
     const authAbortController = new AbortController();
     const authAbortSignal = authAbortController.signal;
     authAbortController.abort();
     var promise = navigator.credentials.get({ publicKey : GET_CREDENTIAL_OPTIONS, signal : authAbortSignal});
     return promise_rejects_dom(t, "AbortError", promise);
   }, "navigator.credentials.get() with abort signal flag set before sending request");

   promise_test(async t => {
     const authAbortController = new AbortController();
     const authAbortSignal = authAbortController.signal;
     var promise = navigator.credentials.get({ publicKey : GET_CREDENTIAL_OPTIONS, signal : authAbortSignal});
     authAbortController.abort();
     return promise_rejects_dom(t, "AbortError", promise);
   }, "navigator.credentials.get() with abort signal flag set after sending request");

   promise_test(async t => {
     const authAbortController = new AbortController();
     const authAbortSignal = authAbortController.signal;
     let promise = await navigator.credentials.get({ publicKey : GET_CREDENTIAL_OPTIONS, signal : authAbortSignal});
     authAbortController.abort();
     return promise;
   }, "navigator.credentials.get() with abort signal flag set after promise resolved");

   promise_test(async t => {
     let bleTestAuthenticator = await manager.createAuthenticator({
       transport: AuthenticatorTransport.BLE,
     });
     t.add_cleanup(async () => {
       let id = await bleTestAuthenticator.id();
       return manager.removeAuthenticator(id);
     });
     let bleCredential = deepCopy(ACCEPTABLE_CREDENTIAL);
     bleCredential.id = new TextEncoder().encode("bleCredential");
     bleCredential.transports = ["ble"]
     assert_true(await bleTestAuthenticator.generateAndRegisterKey(bleCredential.id, "subdomain.example.test"));
     let keys = await bleTestAuthenticator.registeredKeys();
     assert_equals(keys.length, 1);

     let customGetAssertionOptions = deepCopy(GET_CREDENTIAL_OPTIONS);
     customGetAssertionOptions.allowCredentials = [bleCredential];
     return navigator.credentials.get({ publicKey : customGetAssertionOptions });
   }, "navigator.credentials.get() with authenticators supporting different transports");
 }, {});
 </script>
	<!DOCTYPE html>
	<title>Credential Manager: End-to-end tests for get() with a virtual authenticator.</title>
	<script src="../resources/testharness.js"></script>
	<script src="../resources/testharnessreport.js"></script>
	<body>
	<script type="module">
	import {AuthenticatorTransport} from '/gen/third_party/blink/public/mojom/webauthn/authenticator.mojom.m.js';
	import {ACCEPTABLE_CREDENTIAL, ACCEPTABLE_CREDENTIAL_ID, authenticatorSetup, deepCopy, GET_CREDENTIAL_OPTIONS, MAKE_CREDENTIAL_OPTIONS, PUBLIC_KEY_USER} from './resources/test-inputs.js';
	import {TestAuthenticatorManager} from './resources/virtual-navigator-credentials.js';

	if (document.location.host != "subdomain.example.test:8443") {
	document.location = "https://subdomain.example.test:8443/credentialmanager/credentialscontainer-get-with-virtual-authenticator.html";
	promise_test(_ => new Promise(_ => {}), "Stall tests on the wrong host.");
	}

	const manager = new TestAuthenticatorManager;

	authenticatorSetup(manager, "CTAP2_0", () => {
	promise_test(async _ => {
	let authenticators = await manager.authenticators();
	assert_equals(authenticators.length, 1);
	let testAuthenticator = authenticators[0];
	assert_true(await testAuthenticator.generateAndRegisterKey(ACCEPTABLE_CREDENTIAL_ID, "subdomain.example.test"));
	}, "Set up the testing environment for ctap 2.0.");

	promise_test(async t => {
	let testAuthenticator = await manager.createAuthenticator();
	t.add_cleanup(async () => {
	let id = await testAuthenticator.id();
	return manager.removeAuthenticator(id);
	});
	assert_true(await testAuthenticator.generateAndRegisterKey(ACCEPTABLE_CREDENTIAL_ID, "subdomain.example.test"));
	let keys = await testAuthenticator.registeredKeys();
	assert_equals(keys.length, 1);
	var customGetAssertionOptions = deepCopy(GET_CREDENTIAL_OPTIONS);
	var someOtherCredential = deepCopy(ACCEPTABLE_CREDENTIAL);
	someOtherCredential.id = new TextEncoder().encode("someOtherCredential");
	customGetAssertionOptions.allowCredentials = [someOtherCredential];

	return promise_rejects_dom(t, "NotAllowedError",
	navigator.credentials.get({ publicKey : customGetAssertionOptions}));
	}, "navigator.credentials.get() for unregistered device returns NotAllowedError");

	promise_test(async t => {
	// Injecting resident credentials through the mojo virtual authenticator is
	// not supported.
	var customMakeCredOptions = deepCopy(MAKE_CREDENTIAL_OPTIONS);
	customMakeCredOptions.authenticatorSelection.requireResidentKey = true;
	var residentCredential =
	await navigator.credentials.create({ publicKey : customMakeCredOptions });

	var customGetAssertionOptions = deepCopy(GET_CREDENTIAL_OPTIONS);
	delete customGetAssertionOptions.allowCredentials;
	customGetAssertionOptions.user = PUBLIC_KEY_USER;
	return navigator.credentials.get({ publicKey : customGetAssertionOptions })
	.then(credential => assert_equals(credential.id, residentCredential.id));
	}, "navigator.credentials.get() with empty allowCredentials returns a resident credential");

	promise_test(t => {
	var customGetCredentialOptions = deepCopy(GET_CREDENTIAL_OPTIONS);
	customGetCredentialOptions.allowCredentials.transports = [];
	return navigator.credentials.get({publicKey: customGetCredentialOptions}).then();
	}, "navigator.credentials.get() with missing transports in allowCredentials.");

	promise_test(async t => {
	const authAbortController = new AbortController();
	const authAbortSignal = authAbortController.signal;
	return navigator.credentials.get({ publicKey : GET_CREDENTIAL_OPTIONS, signal : authAbortSignal});
	}, "navigator.credentials.get() with abort signal flag not set");

	promise_test(async t => {
	const authAbortController = new AbortController();
	const authAbortSignal = authAbortController.signal;
	authAbortController.abort();
	var promise = navigator.credentials.get({ publicKey : GET_CREDENTIAL_OPTIONS, signal : authAbortSignal});
	return promise_rejects_dom(t, "AbortError", promise);
	}, "navigator.credentials.get() with abort signal flag set before sending request");

	promise_test(async t => {
	const authAbortController = new AbortController();
	const authAbortSignal = authAbortController.signal;
	var promise = navigator.credentials.get({ publicKey : GET_CREDENTIAL_OPTIONS, signal : authAbortSignal});
	authAbortController.abort();
	return promise_rejects_dom(t, "AbortError", promise);
	}, "navigator.credentials.get() with abort signal flag set after sending request");

	promise_test(async t => {
	const authAbortController = new AbortController();
	const authAbortSignal = authAbortController.signal;
	let promise = await navigator.credentials.get({ publicKey : GET_CREDENTIAL_OPTIONS, signal : authAbortSignal});
	authAbortController.abort();
	return promise;
	}, "navigator.credentials.get() with abort signal flag set after promise resolved");

	promise_test(async t => {
	let bleTestAuthenticator = await manager.createAuthenticator({
	transport: AuthenticatorTransport.BLE,
	});
	t.add_cleanup(async () => {
	let id = await bleTestAuthenticator.id();
	return manager.removeAuthenticator(id);
	});
	let bleCredential = deepCopy(ACCEPTABLE_CREDENTIAL);
	bleCredential.id = new TextEncoder().encode("bleCredential");
	bleCredential.transports = ["ble"]
	assert_true(await bleTestAuthenticator.generateAndRegisterKey(bleCredential.id, "subdomain.example.test"));
	let keys = await bleTestAuthenticator.registeredKeys();
	assert_equals(keys.length, 1);

	let customGetAssertionOptions = deepCopy(GET_CREDENTIAL_OPTIONS);
	customGetAssertionOptions.allowCredentials = [bleCredential];
	return navigator.credentials.get({ publicKey : customGetAssertionOptions });
	}, "navigator.credentials.get() with authenticators supporting different transports");
	}, {});
	</script>