testing/web-platform/tests/credential-management/fedcm.https.html

   1 <!DOCTYPE html>
   2 <title>Federated Credential Management API basics.</title>
   3 <link rel="help" href="https://wicg.github.io/FedCM">
   4 <script src="/resources/testharness.js"></script>
   5 <script src="/resources/testharnessreport.js"></script>
   6 <script type="module">
   7   import {fedcm_test} from './support/fedcm-helper.js';
   8   const test_options = {
   9     federated: {
  10       providers: [{
  11         url: 'https://idp.test',
  12         clientId: '1',
  13         nonce: '2',
  14       }]
  15     }
  16   };
  17
  18   fedcm_test(async (t, mock) => {
  19     mock.returnIdToken("a_token");
  20     const token = await navigator.credentials.get(test_options);
  21     assert_equals(token, "a_token");
  22   }, "Successfully obtaining id_token should resolve the promise.");
  23
  24   fedcm_test(async (t, mock) => {
  25     mock.returnError("ApprovalDeclined");
  26     const result = navigator.credentials.get(test_options);
  27     return promise_rejects_dom(t, 'AbortError', result);
  28   }, "User approval decline should reject the promise.");
  29
  30   fedcm_test(async (t, mock) => {
  31     mock.returnError("ErrorTooManyRequests");
  32     const first = await navigator.credentials.get(test_options);
  33     const second = await navigator.credentials.get(test_options);
  34     assert_equals(first, undefined);
  35     return promise_rejects_dom(t, 'AbortError', second);
  36   },
  37   "When there's a pending request, a second `get` call should be rejected. ",
  38   "Only one navigator.credentials.get request may be outstanding at one time.");
  39
  40   promise_test(async t => {
  41     const result = navigator.credentials.get({
  42     federated: {
  43       providers: [{
  44         clientId: '1',
  45         nonce: '2',
  46       }]
  47     }
  48     });
  49     return promise_rejects_js(t, TypeError, result);
  50   }, "Reject when url is missing" );
  51
  52   promise_test(async t => {
  53     const result = navigator.credentials.get({
  54     federated: {
  55       providers: [{
  56         url: 'test',
  57         clientId: '1',
  58         nonce: '2',
  59       }]
  60     }
  61     });
  62     return promise_rejects_dom(t, "InvalidStateError", result);
  63   }, "Reject when url is invalid");
  64
  65   promise_test(async t => {
  66     const result = navigator.credentials.get({
  67     federated: {
  68       providers: [{
  69         url: 'https://idp.test',
  70         nonce: '2',
  71       }]
  72     }
  73     });
  74     return promise_rejects_js(t, TypeError, result);
  75   }, "Reject when clientId is missing" );
  76
  77   promise_test(async t => {
  78     const result = navigator.credentials.get({
  79     federated: {
  80       providers: [{
  81         url: 'https://idp.test',
  82         clientId: '',
  83         nonce: '1',
  84       }]
  85     }
  86     });
  87     return promise_rejects_dom(t, "InvalidStateError", result);
  88   }, "Reject when clientId is empty");
  89
  90   fedcm_test(async (t, mock) => {
  91     mock.returnIdToken("a_token");
  92     const token = await navigator.credentials.get({
  93     federated: {
  94       providers: [{
  95         url: 'https://idp.test',
  96         clientId: '1',
  97       }]
  98     }
  99     });
 100
 101     assert_equals(token, "a_token");
 102   }, "nonce is not required in FederatedIdentityProvider.");
 103
 104   fedcm_test(async (t, mock) => {
 105     let controller = new AbortController();
 106     mock.returnPendingPromise();
 107     let aborted = false;
 108     const token_promise = navigator.credentials.get({
 109     federated: {
 110       providers: [{
 111         url: 'https://idp.test',
 112         clientId: '1',
 113       }],
 114     },
 115     signal: controller.signal,
 116     });
 117     assert_equals(aborted, false);
 118     controller.abort();
 119     try {
 120       await token_promise;
 121     } catch (e) {
 122       aborted = true;
 123       assert_equals(e.name, "AbortError");
 124     }
 125     assert_equals(aborted, true);
 126   }, "test the abort signal");
 127
 128   fedcm_test(async (t, mock) => {
 129     let controller = new AbortController();
 130     mock.returnPendingPromise();
 131     let aborted = false;
 132     const token_promise = navigator.credentials.get({
 133     federated: {
 134       providers: [{
 135         url: 'https://idp.test',
 136         clientId: '1',
 137       }],
 138     },
 139     signal: controller.signal,
 140     });
 141     assert_equals(aborted, false);
 142     controller.abort();
 143     try {
 144       await token_promise;
 145     } catch (e) {
 146       aborted = true;
 147       assert_equals(e.name, "AbortError");
 148     }
 149     assert_equals(aborted, true);
 150
 151     mock.returnIdToken("a_token");
 152     const token = await navigator.credentials.get(test_options);
 153     assert_equals(token, "a_token");
 154   }, "get after abort should work");
 155
 156   promise_test(function(t) {
 157     // Logout API not supported yet.
 158     return promise_rejects_dom(t, "NotSupportedError",
 159       FederatedCredential.logout([{
 160         account_id: "1234",
 161         endpoint: "https://rp.example/logout.php"
 162       }])
 163     );
 164   }, "navigator.credentials.logout() basic.");
 165 </script>