Add more unit tests (#25)

Author: mickel8

lib/ex_ice/candidate_pair.ex

@@ -52,6 +52,7 @@ defmodule ExICE.CandidatePair do
     }
   end
 
+  @doc false
   @spec schedule_keepalive(t(), Process.dest()) :: t()
   def schedule_keepalive(pair, dest \\ self())
 
@@ -65,6 +66,7 @@ defmodule ExICE.CandidatePair do
     %{pair | keepalive_timer: ref}
   end
 
+  @doc false
   @spec recompute_priority(t(), ICEAgent.role()) :: t()
   def recompute_priority(pair, role) do
     %__MODULE__{pair | priority: priority(role, pair.local_cand, pair.remote_cand)}

test/candidate_pair_test.exs

@@ -1,27 +1,25 @@
 defmodule ExICE.CandidatePairTest do
-  use ExUnit.Case
+  use ExUnit.Case, async: true
 
-  # alias ExICE.{Candidate, CandidatePair}
+  alias ExICE.{Candidate, CandidatePair}
 
-  # describe "CandidatePair.new/3" do
-  #   test "creates candidate pair with correct priority" do
-  #     addr1 = {192, 168, 1, 1}
-  #     port1 = 12_345
-  #     c1 = Candidate.new(:host, addr1, port1, addr1, port1, nil)
-  #     c1 = %Candidate{c1 | priority: 100}
+  test "new/3" do
+    addr1 = {192, 168, 1, 1}
+    port1 = 12_345
+    c1 = Candidate.new(:host, addr1, port1, addr1, port1, nil)
+    c1 = %Candidate{c1 | priority: 100}
 
-  #     addr2 = {192, 168, 1, 2}
-  #     port2 = 23_456
-  #     c2 = Candidate.new(:host, addr2, port2, addr2, port2, nil)
-  #     c2 = %Candidate{c2 | priority: 200}
+    addr2 = {192, 168, 1, 2}
+    port2 = 23_456
+    c2 = Candidate.new(:host, addr2, port2, addr2, port2, nil)
+    c2 = %Candidate{c2 | priority: 200}
 
-  #     c1c2 = CandidatePair.new(:controlling, :frozen, c1, c2)
-  #     assert c1c2.priority == 429_496_730_000
+    c1c2 = CandidatePair.new(c1, c2, :controlling, :frozen)
+    assert c1c2.priority == 429_496_730_000
 
-  #     c2c1 = CandidatePair.new(:controlled, :frozen, c1, c2)
-  #     assert c2c1.priority == 429_496_730_001
+    c2c1 = CandidatePair.new(c1, c2, :controlled, :frozen)
+    assert c2c1.priority == 429_496_730_001
 
-  #     assert abs(c1c2.priority - c2c1.priority) == 1
-  #   end
-  # end
+    assert abs(c1c2.priority - c2c1.priority) == 1
+  end
 end

test/candidate_test.exs

@@ -1,9 +1,9 @@
 defmodule ExICE.CandidateTest do
-  use ExUnit.Case
+  use ExUnit.Case, async: true
 
   alias ExICE.Candidate
 
-  test "candidate's foundation is calculated correctly" do
+  test "candidate's foundation" do
     # FIXME socket shouldn't be nil
     ip = {192, 168, 1, 1}
     port = 12_345
@@ -18,7 +18,7 @@ defmodule ExICE.CandidateTest do
     assert f1 != f2
   end
 
-  test "marshal returns correct candidate string representation" do
+  test "marshal/1" do
     ip = {192, 168, 1, 1}
     port = 12_345
     expected_m_c = "936255739 1 UDP 1234 192.168.1.1 12345 typ host"
@@ -29,7 +29,7 @@ defmodule ExICE.CandidateTest do
     assert m_c == expected_m_c
   end
 
-  test "unmarshal returns correct candidate from its string representation" do
+  test "unmarshal/1" do
     ip = {192, 168, 1, 1}
     port = 12_345
     m_c = "936255739 1 UDP 1234 192.168.1.1 12345 typ host"

test/gatherer_test.exs

@@ -1,5 +1,5 @@
 defmodule ExICE.GathererTest do
-  use ExUnit.Case
+  use ExUnit.Case, async: true
 
   alias ExICE.{Candidate, Gatherer}
 

test/ice_agent/impl_test.exs

@@ -19,6 +19,42 @@ defmodule ExICE.ICEAgent.ImplTest do
     end
   end
 
+  describe "add_remote_candidate/2" do
+    setup do
+      ice_agent =
+        ICEAgent.Impl.new(
+          controlling_process: self(),
+          role: :controlling,
+          if_discovery_module: IfDiscovery.Mock,
+          transport_module: Transport.Mock
+        )
+
+      %{ice_agent: ice_agent}
+    end
+
+    test "with correct remote candidate", %{ice_agent: ice_agent} do
+      remote_cand = Candidate.new(:host, {192, 168, 0, 2}, 8445, nil, nil, nil)
+      ice_agent = ICEAgent.Impl.add_remote_candidate(ice_agent, Candidate.marshal(remote_cand))
+
+      assert [%Candidate{} = r_cand] = ice_agent.remote_cands
+      # override id for the purpose of comparision
+      r_cand = %Candidate{r_cand | id: remote_cand.id}
+      assert r_cand == remote_cand
+    end
+
+    test "with invalid remote candidate", %{ice_agent: ice_agent} do
+      ice_agent = ICEAgent.Impl.add_remote_candidate(ice_agent, "some invalid candidate string")
+      assert [] == ice_agent.remote_cands
+    end
+
+    test "after setting end-of-candidates", %{ice_agent: ice_agent} do
+      remote_cand = Candidate.new(:host, {192, 168, 0, 2}, 8445, nil, nil, nil)
+      ice_agent = ICEAgent.Impl.end_of_candidates(ice_agent)
+      ice_agent = ICEAgent.Impl.add_remote_candidate(ice_agent, Candidate.marshal(remote_cand))
+      assert [] == ice_agent.remote_cands
+    end
+  end
+
   describe "incoming binding request" do
     setup do
       ice_agent =
@@ -502,42 +538,74 @@ defmodule ExICE.ICEAgent.ImplTest do
     end
   end
 
-  test "gather srflx candidates" do
-    ice_agent =
-      ICEAgent.Impl.new(
-        controlling_process: self(),
-        role: :controlling,
-        transport_module: Transport.Mock,
-        if_discovery_module: IfDiscovery.Mock,
-        stun_servers: ["stun:192.168.0.3:19302"]
-      )
+  describe "gather srflx candidates" do
+    setup do
+      ice_agent =
+        ICEAgent.Impl.new(
+          controlling_process: self(),
+          role: :controlling,
+          transport_module: Transport.Mock,
+          if_discovery_module: IfDiscovery.Mock,
+          stun_servers: ["stun:192.168.0.3:19302"]
+        )
+        |> ICEAgent.Impl.set_remote_credentials("someufrag", "somepwd")
+        |> ICEAgent.Impl.gather_candidates()
 
-    ice_agent = ICEAgent.Impl.set_remote_credentials(ice_agent, "someufrag", "somepwd")
-    ice_agent = ICEAgent.Impl.gather_candidates(ice_agent)
-    [local_cand] = ice_agent.local_cands
+      [local_cand] = ice_agent.local_cands
 
-    # assert no transactions are started until handle_timeout is called
-    assert [{_socket, nil}] = :ets.lookup(:transport_mock, local_cand.socket)
+      # assert no transactions are started until handle_timeout is called
+      assert [{_socket, nil}] = :ets.lookup(:transport_mock, local_cand.socket)
 
-    ice_agent = ICEAgent.Impl.handle_timeout(ice_agent)
+      %{ice_agent: ice_agent}
+    end
 
-    assert [{_socket, packet}] = :ets.lookup(:transport_mock, local_cand.socket)
-    assert {:ok, req} = ExSTUN.Message.decode(packet)
+    test "success response", %{ice_agent: ice_agent} do
+      [local_cand] = ice_agent.local_cands
 
-    resp =
-      Message.new(req.transaction_id, %Type{class: :success_response, method: :binding}, [
-        %XORMappedAddress{address: {192, 168, 0, 2}, port: local_cand.port + 1}
-      ])
-      |> Message.encode()
+      ice_agent = ICEAgent.Impl.handle_timeout(ice_agent)
 
-    ice_agent =
-      ICEAgent.Impl.handle_udp(ice_agent, local_cand.socket, {192, 168, 0, 3}, 19_302, resp)
+      assert [{_socket, packet}] = :ets.lookup(:transport_mock, local_cand.socket)
+      assert {:ok, req} = ExSTUN.Message.decode(packet)
 
-    assert [srflx_cand | _cands] = ice_agent.local_cands
-    assert srflx_cand.type == :srflx
-    assert srflx_cand.address == {192, 168, 0, 2}
-    assert srflx_cand.port == local_cand.port + 1
+      resp =
+        Message.new(req.transaction_id, %Type{class: :success_response, method: :binding}, [
+          %XORMappedAddress{address: {192, 168, 0, 2}, port: local_cand.port + 1}
+        ])
+        |> Message.encode()
+
+      ice_agent =
+        ICEAgent.Impl.handle_udp(ice_agent, local_cand.socket, {192, 168, 0, 3}, 19_302, resp)
+
+      # assert there is a new, srflx candidate
+      assert [srflx_cand | _cands] = ice_agent.local_cands
+      assert srflx_cand.type == :srflx
+      assert srflx_cand.address == {192, 168, 0, 2}
+      assert srflx_cand.port == local_cand.port + 1
+      # assert gathering transaction succeeded
+      assert ice_agent.gathering_transactions[req.transaction_id].state == :complete
+    end
+
+    test "error response", %{ice_agent: ice_agent} do
+      [local_cand] = ice_agent.local_cands
 
-    assert ice_agent.gathering_transactions[req.transaction_id].state == :complete
+      ice_agent = ICEAgent.Impl.handle_timeout(ice_agent)
+
+      assert [{_socket, packet}] = :ets.lookup(:transport_mock, local_cand.socket)
+      assert {:ok, req} = ExSTUN.Message.decode(packet)
+
+      resp =
+        Message.new(req.transaction_id, %Type{class: :error_response, method: :binding}, [
+          %ErrorCode{code: 400}
+        ])
+        |> Message.encode()
+
+      ice_agent =
+        ICEAgent.Impl.handle_udp(ice_agent, local_cand.socket, {192, 168, 0, 3}, 19_302, resp)
+
+      # assert there are no new candidates
+      assert [local_cand] == ice_agent.local_cands
+      # assert gathering transaction failed
+      assert ice_agent.gathering_transactions[req.transaction_id].state == :failed
+    end
   end
 end

test/ice_agent_test.exs

@@ -1,5 +1,5 @@
 defmodule ExICE.ICEAgentTest do
-  use ExUnit.Case
+  use ExUnit.Case, async: true
 
   alias ExICE.ICEAgent
 

test/integration/p2p_test.exs

@@ -1,5 +1,5 @@
 defmodule ExICE.Integration.P2PTest do
-  use ExUnit.Case
+  use ExUnit.Case, async: true
 
   require Logger
 

test/uri_test.exs

@@ -4,7 +4,7 @@ defmodule ExICE.URITest do
   alias ExICE.URI
 
   describe "URI.parse/1" do
-    test "parses valid URI correctly" do
+    test "with valid URI" do
       for {uri_string, expected_uri} <- [
             {
               "stun:stun.l.google.com:19302",
@@ -27,7 +27,7 @@ defmodule ExICE.URITest do
       end
     end
 
-    test "returns an error for invalid URI" do
+    test "with invalid URI" do
       for invalid_uri_string <- [
             "",
             "some random string",