diff options
Diffstat (limited to 'dom/media/webrtc/tests/mochitests/test_peerConnection_gatherWithSetConfiguration.html')
| -rw-r--r-- | dom/media/webrtc/tests/mochitests/test_peerConnection_gatherWithSetConfiguration.html | 450 |
1 files changed, 450 insertions, 0 deletions
diff --git a/dom/media/webrtc/tests/mochitests/test_peerConnection_gatherWithSetConfiguration.html b/dom/media/webrtc/tests/mochitests/test_peerConnection_gatherWithSetConfiguration.html new file mode 100644 index 0000000000..6710e628aa --- /dev/null +++ b/dom/media/webrtc/tests/mochitests/test_peerConnection_gatherWithSetConfiguration.html @@ -0,0 +1,450 @@ +<!DOCTYPE HTML> +<html> +<head> + <script type="application/javascript" src="pc.js"></script> + <script type="application/javascript" src="iceTestUtils.js"></script> + <script type="application/javascript" src="helpers_from_wpt/sdp.js"></script></head> +<body> +<pre id="test"> +<script type="application/javascript"> + createHTML({ + bug: "1253706", + title: "Test ICE gathering when setConfiguration is used to change the ICE config" + }); + + const tests = [ + async function baselineV4Cases() { + await checkSrflx([{urls:[`stun:${turnAddressV4}`]}]); + await checkRelayUdp([{urls:[`turn:${turnAddressV4}`], username, credential}]); + await checkRelayTcp([{urls:[`turn:${turnAddressV4}?transport=tcp`], username, credential}]); + await checkRelayUdpTcp([{urls:[`turn:${turnAddressV4}`, `turn:${turnAddressV4}?transport=tcp`], username, credential}]); + await checkNoSrflx(); + await checkNoRelay(); + }, + + async function addStunServerBeforeOffer() { + const pc = new RTCPeerConnection(); + try { + pc.setConfiguration({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + const candidates = await gatherWithTimeout(pc, 32000, `just a stun server`); + ok(candidates.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(!candidates.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + } finally { + pc.close(); + } + }, + + async function addTurnServerBeforeOffer() { + const pc = new RTCPeerConnection(); + try { + pc.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}`], username, credential}]}); + const candidates = await gatherWithTimeout(pc, 32000, `a turn (udp) server`); + ok(candidates.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(candidates.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + } finally { + pc.close(); + } + }, + + async function addTurnTcpServerBeforeOffer() { + const pc = new RTCPeerConnection(); + try { + pc.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}?transport=tcp`], username, credential}]}); + const candidates = await gatherWithTimeout(pc, 32000, `a turn (tcp) server`); + ok(!candidates.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(candidates.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + } finally { + pc.close(); + } + }, + + async function addStunServerAfterOffer() { + const pc = new RTCPeerConnection(); + try { + const candidates1 = await gatherWithTimeout(pc, 32000, `no ICE servers`); + ok(!candidates1.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(!candidates1.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + await pc.setLocalDescription({type: "rollback"}); + + pc.setConfiguration({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + const candidates2 = await gatherWithTimeout(pc, 32000, `just a stun server`); + ok(candidates2.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(!candidates2.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + } finally { + pc.close(); + } + }, + + async function addTurnServerAfterOffer() { + const pc = new RTCPeerConnection(); + try { + const candidates1 = await gatherWithTimeout(pc, 32000, `no ICE servers`); + ok(!candidates1.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(!candidates1.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + await pc.setLocalDescription({type: "rollback"}); + + pc.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}`], username, credential}]}); + const candidates2 = await gatherWithTimeout(pc, 32000, `a turn (udp) server`); + ok(candidates2.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(candidates2.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + } finally { + pc.close(); + } + }, + + async function addTurnTcpServerAfterOffer() { + const pc = new RTCPeerConnection(); + try { + const candidates1 = await gatherWithTimeout(pc, 32000, `no ICE servers`); + ok(!candidates1.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(!candidates1.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + await pc.setLocalDescription({type: "rollback"}); + + pc.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}?transport=tcp`], username, credential}]}); + const candidates2 = await gatherWithTimeout(pc, 32000, `a turn (tcp) server`); + ok(!candidates2.some(c => c.candidate.includes("srflx")), "Should get no srflx candidates"); + ok(candidates2.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + } finally { + pc.close(); + } + }, + + async function removeStunServerBeforeOffer() { + const pc = new RTCPeerConnection({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + try { + pc.setConfiguration({}); + const candidates = await gatherWithTimeout(pc, 32000, `no ICE servers`); + ok(!candidates.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(!candidates.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + } finally { + pc.close(); + } + }, + + async function removeTurnServerBeforeOffer() { + const pc = new RTCPeerConnection({iceServers: [{urls:[`turn:${turnAddressV4}`], username, credential}]}); + try { + pc.setConfiguration({}); + const candidates = await gatherWithTimeout(pc, 32000, `no ICE servers`); + ok(!candidates.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(!candidates.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + } finally { + pc.close(); + } + }, + + async function removeTurnTcpServerBeforeOffer() { + const pc = new RTCPeerConnection({iceServers: [{urls:[`turn:${turnAddressV4}?transport=tcp`], username, credential}]}); + try { + pc.setConfiguration({}); + const candidates = await gatherWithTimeout(pc, 32000, `no ICE servers`); + ok(!candidates.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(!candidates.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + } finally { + pc.close(); + } + }, + + async function removeStunServerAfterOffer() { + const pc = new RTCPeerConnection({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + try { + const candidates1 = await gatherWithTimeout(pc, 32000, `just a stun server`); + ok(candidates1.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(!candidates1.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + await pc.setLocalDescription({type: "rollback"}); + + pc.setConfiguration({}); + const candidates2 = await gatherWithTimeout(pc, 32000, `no ICE servers`); + ok(!candidates2.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(!candidates2.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + } finally { + pc.close(); + } + }, + + async function removeTurnServerAfterOffer() { + const pc = new RTCPeerConnection({iceServers: [{urls:[`turn:${turnAddressV4}`], username, credential}]}); + try { + const candidates1 = await gatherWithTimeout(pc, 32000, `a turn (udp) server`); + ok(candidates1.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(candidates1.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + await pc.setLocalDescription({type: "rollback"}); + + pc.setConfiguration({}); + const candidates2 = await gatherWithTimeout(pc, 32000, `no ICE servers`); + ok(!candidates2.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(!candidates2.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + } finally { + pc.close(); + } + }, + + async function removeTurnTcpServerAfterOffer() { + const pc = new RTCPeerConnection({iceServers: [{urls:[`turn:${turnAddressV4}?transport=tcp`], username, credential}]}); + try { + const candidates1 = await gatherWithTimeout(pc, 32000, `a turn (tcp) server`); + ok(!candidates1.some(c => c.candidate.includes("srflx")), "Should get no srflx candidates"); + ok(candidates1.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + await pc.setLocalDescription({type: "rollback"}); + + pc.setConfiguration({}); + const candidates2 = await gatherWithTimeout(pc, 32000, `no ICE servers`); + ok(!candidates2.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(!candidates2.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + } finally { + pc.close(); + } + }, + + async function addStunServerAfterNegotiation() { + const offerer = new RTCPeerConnection(); + const answerer = new RTCPeerConnection({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + try { + const candidatePromise = trickleIce(offerer); + await connect(offerer, answerer, 32000, `no ICE servers`); + const candidates = await candidatePromise; + const ufrags = Array.from(new Set(candidates.map(c => c.usernameFragment))); + is(ufrags.length, 1, "Should have one ufrag in candidate set"); + + offerer.setConfiguration({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + const candidates2 = await gatherWithTimeout(offerer, 32000, `just a stun server`); + ok(candidates2.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(!candidates2.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + const ufrags2 = Array.from(new Set(candidates2.map(c => c.usernameFragment))); + is(ufrags2.length, 1, "Should have one ufrag in candidate set"); + isnot(ufrags[0], ufrags2[0], "ufrag should change, because setConfiguration should have triggered an ICE restart"); + } finally { + offerer.close(); + answerer.close(); + } + }, + + async function addTurnServerAfterNegotiation() { + const offerer = new RTCPeerConnection(); + const answerer = new RTCPeerConnection({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + try { + const candidatePromise = trickleIce(offerer); + await connect(offerer, answerer, 32000, `no ICE servers`); + const candidates = await candidatePromise; + const ufrags = Array.from(new Set(candidates.map(c => c.usernameFragment))); + is(ufrags.length, 1, "Should have one ufrag in candidate set"); + + offerer.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}`], username, credential}]}); + const candidates2 = await gatherWithTimeout(offerer, 32000, `a turn (udp) server`); + ok(candidates2.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(candidates2.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + const ufrags2 = Array.from(new Set(candidates2.map(c => c.usernameFragment))); + is(ufrags2.length, 1, "Should have one ufrag in candidate set"); + isnot(ufrags[0], ufrags2[0], "ufrag should change, because setConfiguration should have triggered an ICE restart"); + } finally { + offerer.close(); + answerer.close(); + } + }, + + async function addTurnTcpServerAfterNegotiation() { + const offerer = new RTCPeerConnection(); + const answerer = new RTCPeerConnection({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + try { + const candidatePromise = trickleIce(offerer); + await connect(offerer, answerer, 32000, `no ICE servers`); + const candidates = await candidatePromise; + const ufrags = Array.from(new Set(candidates.map(c => c.usernameFragment))); + is(ufrags.length, 1, "Should have one ufrag in candidate set"); + + offerer.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}?transport=tcp`], username, credential}]}); + const candidates2 = await gatherWithTimeout(offerer, 32000, `a turn (tcp) server`); + ok(!candidates2.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(candidates2.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + const ufrags2 = Array.from(new Set(candidates2.map(c => c.usernameFragment))); + is(ufrags2.length, 1, "Should have one ufrag in candidate set"); + isnot(ufrags[0], ufrags2[0], "ufrag should change, because setConfiguration should have triggered an ICE restart"); + } finally { + offerer.close(); + answerer.close(); + } + }, + + async function addStunServerBeforeCreateAnswer() { + const offerer = new RTCPeerConnection(); + const answerer = new RTCPeerConnection(); + + try { + await answerer.setRemoteDescription(await offerer.createOffer({offerToReceiveAudio: true})); + + answerer.setConfiguration({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + const candidates = await gatherWithTimeout(answerer, 32000, `just a stun server`); + ok(candidates.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(!candidates.some(c => c.candidate.includes("relay")), "Should not get any relay candidates"); + } finally { + offerer.close(); + answerer.close(); + } + }, + + async function addTurnServerBeforeCreateAnswer() { + const offerer = new RTCPeerConnection(); + const answerer = new RTCPeerConnection(); + + try { + await answerer.setRemoteDescription(await offerer.createOffer({offerToReceiveAudio: true})); + + answerer.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}`], username, credential}]}); + const candidates = await gatherWithTimeout(answerer, 32000, `a turn (udp) server`); + ok(candidates.some(c => c.candidate.includes("srflx")), "Should get at least one srflx candidate"); + ok(candidates.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + } finally { + offerer.close(); + answerer.close(); + } + }, + + async function addTurnTcpServerBeforeCreateAnswer() { + const offerer = new RTCPeerConnection(); + const answerer = new RTCPeerConnection(); + + try { + await answerer.setRemoteDescription(await offerer.createOffer({offerToReceiveAudio: true})); + + answerer.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}?transport=tcp`], username, credential}]}); + const candidates = await gatherWithTimeout(answerer, 32000, `a turn (tcp) server`); + ok(!candidates.some(c => c.candidate.includes("srflx")), "Should not get any srflx candidates"); + ok(candidates.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + } finally { + offerer.close(); + answerer.close(); + } + }, + + async function relayPolicyPreventsSrflx() { + const pc = new RTCPeerConnection(); + try { + pc.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}`], username, credential}], iceTransportPolicy: "relay"}); + const candidates = await gatherWithTimeout(pc, 32000, `a turn (udp) server`); + ok(!candidates.some(c => c.candidate.includes("srflx")), "Should not get a srflx candidate"); + ok(candidates.some(c => c.candidate.includes("relay")), "Should get at least one relay candidate"); + } finally { + pc.close(); + } + }, + + async function addOffererStunServerAllowsIceToConnect() { + const offerer = new RTCPeerConnection(); + const answerer = new RTCPeerConnection(); + + try { + try { + // Both ends are behind a simulated endpoint-independent NAT, which + // requires at least one side to have a srflx candidate to work. + await connect(offerer, answerer, 2000, `no ICE servers`); + ok(false, "ICE should either have failed, or timed out!"); + } catch (e) { + if (!(e instanceof Error)) throw e; + ok(true, "ICE should either have failed, or timed out!"); + } + + offerer.setConfiguration({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + await connect(offerer, answerer, 32000, `just a STUN server`); + } finally { + offerer.close(); + answerer.close(); + } + }, + + async function addAnswererStunServerDoesNotAllowIceToConnect() { + const offerer = new RTCPeerConnection(); + const answerer = new RTCPeerConnection(); + + try { + try { + // Both ends are behind a simulated endpoint-independent NAT, which + // requires at least one side to have a srflx candidate to work. + await connect(offerer, answerer, 2000, `no ICE servers`); + ok(false, "ICE should either have failed, or timed out!"); + } catch (e) { + if (!(e instanceof Error)) throw e; + ok(true, "ICE should either have failed, or timed out!"); + } + + // This _won't_ help, because the answerer does not get to decide to + // trigger an ICE restart. + answerer.setConfiguration({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + try { + await connectNoTrickleWait(offerer, answerer, 2000, `no ICE servers`); + ok(false, "ICE should either have failed, or timed out!"); + } catch (e) { + if (!(e instanceof Error)) throw e; + ok(true, "ICE should either have failed, or timed out!"); + } + } finally { + offerer.close(); + answerer.close(); + } + }, + + async function addOffererTurnServerAllowsIceToConnect() { + await pushPrefs( + ['media.peerconnection.nat_simulator.filtering_type', 'PORT_DEPENDENT'], + ['media.peerconnection.nat_simulator.mapping_type', 'PORT_DEPENDENT']); + + const offerer = new RTCPeerConnection({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + const answerer = new RTCPeerConnection({iceServers: [{urls:[`stun:${turnAddressV4}`]}]}); + + try { + try { + // Both ends are behind a simulated port-dependent NAT, which + // requires at least one side to have a relay candidate to work. + await connect(offerer, answerer, 2000, `just a STUN server`); + ok(false, "ICE should either have failed, or timed out!"); + } catch (e) { + if (!(e instanceof Error)) throw e; + ok(true, "ICE should either have failed, or timed out!"); + } + + offerer.setConfiguration({iceServers: [{urls:[`turn:${turnAddressV4}`], username, credential}]}); + await connect(offerer, answerer, 32000, `a TURN (udp) server`); + } finally { + offerer.close(); + answerer.close(); + await SpecialPowers.popPrefEnv(); + } + }, + + ]; + + runNetworkTest(async () => { + const turnServer = iceServersArray.find(server => "username" in server); + username = turnServer.username; + credential = turnServer.credential; + // Just use the first url. It might make sense to look for TURNS first, + // since that will always use a hostname, but on CI we don't have TURNS + // support anyway (see bug 1323439). + const turnHostname = getTurnHostname(turnServer.urls[0]); + turnAddressV4 = await dnsLookupV4(turnHostname); + + await pushPrefs( + ['media.peerconnection.ice.obfuscate_host_addresses', false], + ['media.peerconnection.nat_simulator.filtering_type', 'ENDPOINT_INDEPENDENT'], + ['media.peerconnection.nat_simulator.mapping_type', 'ENDPOINT_INDEPENDENT'], + ['media.peerconnection.ice.loopback', true], + ['media.getusermedia.insecure.enabled', true]); + + for (const test of tests) { + info(`Running test: ${test.name}`); + try { + await test(); + } catch (e) { + ok(false, `Caught ${e.name}: ${e.message} ${e.stack}`); + } + info(`Done running test: ${test.name}`); + // Make sure we don't build up a pile of GC work, and also get PCImpl to + // print their timecards. + await new Promise(r => SpecialPowers.exactGC(r)); + } + + await SpecialPowers.popPrefEnv(); + }, { useIceServer: true }); +</script> +</pre> +</body> +</html> |