Rewrite RTC ICE and DTLS transport tests with alternative dependencies (Rebased)

webrtc/RTCDtlsTransport-getRemoteCertificates.html

@@ -4,104 +4,99 @@
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="RTCPeerConnection-helper.js"></script>
+<script src="RTCTransport-helper.js"></script>
 <script>
   'use strict';
 
   // The following helper functions are called from RTCPeerConnection-helper.js:
-  //   exchangeIceCandidates
-  //   doSignalingHandshake
-
-  /*
-    5.5.  RTCDtlsTransport Interface
-      interface RTCDtlsTransport : EventTarget {
-        readonly attribute RTCDtlsTransportState state;
-        sequence<ArrayBuffer> getRemoteCertificates();
-                 attribute EventHandler          onstatechange;
-                 attribute EventHandler          onerror;
-        ...
-      };
-
-      enum RTCDtlsTransportState {
-        "new",
-        "connecting",
-        "connected",
-        "closed",
-        "failed"
-      };
-
-      getRemoteCertificates
-        Returns the certificate chain in use by the remote side, with each certificate
-        encoded in binary Distinguished Encoding Rules (DER) [X690].
-        getRemoteCertificates() will return an empty list prior to selection of the
-        remote certificate, which will be completed by the time RTCDtlsTransportState
-        transitions to "connected".
-   */
-  async_test(t => {
+  //  exchangeIceCandidates
+  //  doSignalingHandshake
+
+  // The following helper functions are called from RTCTransport-helper.js:
+  //  waitForConnectedState
+
+  function validateConnectedDtlsTransport(dtlsTransport) {
+    const certs = dtlsTransport.getRemoteCertificates();
+
+    assert_greater_than(certs.length, 0,
+      'Expect DTLS transport to have at least one remote certificate when connected');
+
+    for (const cert of certs) {
+      assert_true(cert instanceof ArrayBuffer,
+        'Certificates should be represented as ArrayBuffers');
+    }
+  }
+
+  function validateConnectingDtlsTransport(dtlsTransport) {
+    if (dtlsTransport.state !== 'connected') {
+      assert_array_equals(dtlsTransport.getCertificates(), [],
+        'The DTLS certificate list should be empty before the transport is connected');
+    }
+  }
+
+  promise_test(async t => {
     const pc1 = new RTCPeerConnection();
     t.add_cleanup(() => pc1.close());
+
     const pc2 = new RTCPeerConnection();
     t.add_cleanup(() => pc2.close());
 
-    pc1.createDataChannel('test');
+    const [track] = await getTrackFromUserMedia('audio');
+    pc1.addTransceiver(track);
     exchangeIceCandidates(pc1, pc2);
 
-    doSignalingHandshake(pc1, pc2)
-    .then(t.step_func(() => {
-      // pc.sctp is set when set*Description(answer) is called
-      const sctpTransport1 = pc1.sctp;
-      const sctpTransport2 = pc2.sctp;
-
-      assert_true(sctpTransport1 instanceof RTCSctpTransport,
-        'Expect pc.sctp to be set to valid RTCSctpTransport');
-
-      assert_true(sctpTransport2 instanceof RTCSctpTransport,
-        'Expect pc.sctp to be set to valid RTCSctpTransport');
-
-      const dtlsTransport1 = sctpTransport1.transport;
-      const dtlsTransport2 = sctpTransport2.transport;
-
-      const testedTransports = new Set();
-
-      // Callback function that test the respective DTLS transports
-      // when they become connected.
-      const onConnected = t.step_func(dtlsTransport => {
-        const certs = dtlsTransport.getRemoteCertificates();
-
-        assert_greater_than(certs.length, 0,
-          'Expect DTLS transport to have at least one remote certificate when connected');
-
-        for(const cert of certs) {
-          assert_true(cert instanceof ArrayBuffer,
-            'Expect certificate elements be instance of ArrayBuffer');
-        }
-
-        testedTransports.add(dtlsTransport);
-
-        // End the test if both dtlsTransports are tested.
-        if(testedTransports.has(dtlsTransport1) && testedTransports.has(dtlsTransport2)) {
-          t.done();
-        }
-      })
-
-      for(const dtlsTransport of [dtlsTransport1, dtlsTransport2]) {
-        if(dtlsTransport.state === 'connected') {
-          onConnected(dtlsTransport);
-        } else {
-          assert_array_equals(dtlsTransport.getCertificates(), [],
-            'Expect DTLS certificates be initially empty until become connected');
-
-          dtlsTransport.addEventListener('statechange', t.step_func(() => {
-            if(dtlsTransport.state === 'connected') {
-              onConnected(dtlsTransport);
-            }
-          }));
-
-          dtlsTransport.addEventListener('error', t.step_func(err => {
-            assert_unreached(`Unexpected error during DTLS handshake: ${err}`);
-          }));
-        }
-      }
-    }));
-  });
+    await doSignalingHandshake(pc1, pc2);
+
+    const dtlsTransports1 = new Set([
+      ...pc1.getSenders(),
+      ...pc1.getReceivers()
+    ]
+    .map(senderReceiver => senderReceiver.transport));
+
+    const dtlsTransports2 = new Set([
+      ...pc2.getSenders(),
+      ...pc2.getReceivers()
+    ]
+    .map(senderReceiver => senderReceiver.transport));
+
+    const dtlsTransports = [...dtlsTransports1, ...dtlsTransports2];
+
+    for (const dtlsTransport of dtlsTransports) {
+      validateConnectingDtlsTransport(dtlsTransport);
+    }
+
+    await Promise.all([
+      waitForConnectedState(pc1),
+      waitForConnectedState(pc2)
+    ]);
+
+    for (const dtlsTransport of dtlsTransports) {
+      validateConnectedDtlsTransport(dtlsTransport);
+    }
+  }, 'RTP - connected DTLS transports should have valid remote certificates');
+
+  promise_test(async t => {
+    const pc1 = new RTCPeerConnection();
+    t.add_cleanup(() => pc1.close());
+
+    const pc2 = new RTCPeerConnection();
+    t.add_cleanup(() => pc2.close());
+
+    pc1.createDataChannel('');
+    exchangeIceCandidates(pc1, pc2);
+
+    await doSignalingHandshake(pc1, pc2);
+
+    validateConnectingDtlsTransport(pc1.sctp.transport);
+    validateConnectingDtlsTransport(pc2.sctp.transport);
+
+    await Promise.all([
+      waitForConnectedState(pc1),
+      waitForConnectedState(pc2)
+    ]);
+
+    validateConnectedDtlsTransport(pc1.sctp.transport);
+    validateConnectedDtlsTransport(pc2.sctp.transport);
+  }, 'SCTP - connected DTLS transports should have valid remote certificates');
 
 </script>