<!doctype html>
<meta charset=utf-8>
<title>RTCIceTransport-extensions.https.html</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script>
'use strict';

// These tests are based on the following extension specification:
// https://w3c.github.io/webrtc-ice/

function makeIceTransport(t) {
  const iceTransport = new RTCIceTransport();
  t.add_cleanup(() => iceTransport.stop());
  return iceTransport;
}

test(() => {
  const iceTransport = new RTCIceTransport();
}, 'RTCIceTransport constructor does not throw');

test(() => {
  const iceTransport = new RTCIceTransport();
  assert_equals(iceTransport.role, null, 'Expect role to be null');
  assert_equals(iceTransport.state, 'new', `Expect state to be 'new'`);
  assert_equals(iceTransport.gatheringState, 'new',
    `Expect gatheringState to be 'new'`);
  assert_array_equals(iceTransport.getLocalCandidates(), [],
    'Expect no local candidates');
  assert_array_equals(iceTransport.getRemoteCandidates(), [],
    'Expect no remote candidates');
  assert_equals(iceTransport.getSelectedCandidatePair(), null,
    'Expect no selected candidate pair');
  assert_not_equals(iceTransport.getLocalParameters(), null,
    'Expect local parameters generated');
  assert_equals(iceTransport.getRemoteParameters(), null,
    'Expect no remote parameters');
}, 'RTCIceTransport initial properties are set');

test(t => {
  const iceTransport = makeIceTransport(t);
  assert_throws(new TypeError(), () =>
    iceTransport.gather({ iceServers: null }));
}, 'gather() with { iceServers: null } should throw TypeError');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.gather({ iceServers: undefined });
}, 'gather() with { iceServers: undefined } should succeed');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.gather({ iceServers: [{
    urls: ['turns:turn.example.org', 'turn:turn.example.net'],
    username: 'user',
    credential: 'cred',
  }] });
}, 'gather() with one turns server, one turn server, username, credential' +
    ' should succeed');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.gather({ iceServers: [{
    urls: ['stun:stun1.example.net', 'stun:stun2.example.net'],
  }] });
}, 'gather() with 2 stun servers should succeed');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.stop();
  assert_throws('InvalidStateError', () => iceTransport.gather({}));
}, 'gather() throws if closed');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.gather({});
  assert_equals(iceTransport.gatheringState, 'gathering');
}, `gather() transitions gatheringState to 'gathering'`);

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.gather({});
  assert_throws('InvalidStateError', () => iceTransport.gather({}));
}, 'gather() throws if called twice');

promise_test(async t => {
  const iceTransport = makeIceTransport(t);
  const watcher = new EventWatcher(t, iceTransport, 'gatheringstatechange');
  iceTransport.gather({});
  await watcher.wait_for('gatheringstatechange');
  assert_equals(iceTransport.gatheringState, 'complete');
}, `eventually transition gatheringState to 'complete'`);

promise_test(async t => {
  const iceTransport = makeIceTransport(t);
  const watcher = new EventWatcher(t, iceTransport,
      [ 'icecandidate', 'gatheringstatechange' ]);
  iceTransport.gather({});
  let candidate;
  do {
    ({ candidate } = await watcher.wait_for('icecandidate'));
  } while (candidate !== null);
  assert_equals(iceTransport.gatheringState, 'gathering');
  await watcher.wait_for('gatheringstatechange');
  assert_equals(iceTransport.gatheringState, 'complete');
}, 'onicecandidate fires with null candidate before gatheringState' +
    ` transitions to 'complete'`);

promise_test(async t => {
  const iceTransport = makeIceTransport(t);
  const watcher = new EventWatcher(t, iceTransport, 'icecandidate');
  iceTransport.gather({});
  const { candidate } = await watcher.wait_for('icecandidate');
  assert_not_equals(candidate.candidate, '');
  assert_array_equals(iceTransport.getLocalCandidates(), [candidate]);
}, 'gather() returns at least one host candidate');

promise_test(async t => {
  const iceTransport = makeIceTransport(t);
  const watcher = new EventWatcher(t, iceTransport, 'icecandidate');
  iceTransport.gather({ gatherPolicy: 'relay' });
  const { candidate } = await watcher.wait_for('icecandidate');
  assert_equals(candidate, null);
  assert_array_equals(iceTransport.getLocalCandidates(), []);
}, `gather() returns no candidates with { gatherPolicy: 'relay'} and no turn` +
    ' servers');

const dummyRemoteParameters = {
  usernameFragment: 'dummyUsernameFragment',
  password: 'dummyPassword',
};

test(() => {
  const iceTransport = new RTCIceTransport();
  iceTransport.stop();
  assert_throws('InvalidStateError',
    () => iceTransport.start(dummyRemoteParameters));
  assert_equals(iceTransport.getRemoteParameters(), null);
}, `start() throws if closed`);

test(() => {
  const iceTransport = new RTCIceTransport();
  assert_throws(new TypeError(), () => iceTransport.start({}));
  assert_throws(new TypeError(),
    () => iceTransport.start({ usernameFragment: 'dummy' }));
  assert_throws(new TypeError(),
    () => iceTransport.start({ password: 'dummy' }));
  assert_equals(iceTransport.getRemoteParameters(), null);
}, 'start() throws if usernameFragment or password not set');

const assert_ice_parameters_equals = (a, b) => {
  assert_equals(a.usernameFragment, b.usernameFragment,
      'usernameFragments are equal');
  assert_equals(a.password, b.password, 'passwords are equal');
};

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.start(dummyRemoteParameters);
  assert_equals(iceTransport.state, 'new');
  assert_ice_parameters_equals(iceTransport.getRemoteParameters(),
      dummyRemoteParameters);
}, `start() does not transition state to 'checking' if no remote candidates ` +
    'added');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.start(dummyRemoteParameters);
  assert_equals(iceTransport.role, 'controlled');
}, `start() with default role sets role attribute to 'controlled'`);

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.start(dummyRemoteParameters, 'controlling');
  assert_equals(iceTransport.role, 'controlling');
}, `start() sets role attribute to 'controlling'`);

const candidate1 = new RTCIceCandidate({
  candidate: 'candidate:1 1 udp 2113929471 203.0.113.100 10100 typ host',
});

test(() => {
  const iceTransport = new RTCIceTransport();
  iceTransport.stop();
  assert_throws('InvalidStateError',
    () => iceTransport.addRemoteCandidate(candidate1));
  assert_array_equals(iceTransport.getRemoteCandidates(), []);
}, 'addRemoteCandidate() throws if closed');

test(() => {
  const iceTransport = new RTCIceTransport();
  assert_throws('OperationError',
    () => iceTransport.addRemoteCandidate(
      new RTCIceCandidate({ candidate: 'invalid' })));
  assert_array_equals(iceTransport.getRemoteCandidates(), []);
}, 'addRemoteCandidate() throws on invalid candidate');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.addRemoteCandidate(candidate1);
  iceTransport.start(dummyRemoteParameters);
  assert_equals(iceTransport.state, 'checking');
  assert_array_equals(iceTransport.getRemoteCandidates(), [candidate1]);
}, `start() transitions state to 'checking' if one remote candidate had been ` +
    'added');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.start(dummyRemoteParameters);
  iceTransport.addRemoteCandidate(candidate1);
  assert_equals(iceTransport.state, 'checking');
  assert_array_equals(iceTransport.getRemoteCandidates(), [candidate1]);
}, `addRemoteCandidate() transitions state to 'checking' if start() had been ` +
    'called before');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.start(dummyRemoteParameters);
  assert_throws('InvalidStateError',
    () => iceTransport.start(dummyRemoteParameters, 'controlling'));
}, 'start() throws if later called with a different role');

test(t => {
  const iceTransport = makeIceTransport(t);
  iceTransport.start({
    usernameFragment: 'user',
    password: 'pass',
  });
  iceTransport.addRemoteCandidate(candidate1);
  const changedRemoteParameters = {
    usernameFragment: 'user2',
    password: 'pass',
  };
  iceTransport.start(changedRemoteParameters);
  assert_equals(iceTransport.state, 'new');
  assert_array_equals(iceTransport.getRemoteCandidates(), []);
  assert_ice_parameters_equals(iceTransport.getRemoteParameters(),
      changedRemoteParameters);
}, `start() flushes remote candidates and transitions state to 'new' if ` +
   'later called with different remote parameters');

promise_test(async t => {
  const localTransport = makeIceTransport(t);
  const remoteTransport = makeIceTransport(t);
  localTransport.onicecandidate = e => {
    if (e.candidate) {
      remoteTransport.addRemoteCandidate(e.candidate);
    }
  };
  remoteTransport.onicecandidate = e => {
    if (e.candidate) {
      localTransport.addRemoteCandidate(e.candidate);
    }
  };
  localTransport.gather({});
  remoteTransport.gather({});
  localTransport.start(remoteTransport.getLocalParameters(), 'controlling');
  remoteTransport.start(localTransport.getLocalParameters(), 'controlled');
  const localWatcher = new EventWatcher(t, localTransport, 'statechange');
  const remoteWatcher = new EventWatcher(t, remoteTransport, 'statechange');
  await Promise.all([
    localWatcher.wait_for('statechange').then(() => {
      assert_equals(localTransport.state, 'connected');
    }),
    remoteWatcher.wait_for('statechange').then(() => {
      assert_equals(remoteTransport.state, 'connected');
    }),
  ]);
}, 'Two RTCIceTransports connect to each other');

</script>