1/*
2 *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include "webrtc/base/fakesslidentity.h"
12#include "webrtc/base/gunit.h"
13#include "webrtc/base/network.h"
14#include "webrtc/p2p/base/faketransportcontroller.h"
15#include "webrtc/p2p/base/p2ptransport.h"
16
17using cricket::Candidate;
18using cricket::Candidates;
19using cricket::Transport;
20using cricket::FakeTransport;
21using cricket::TransportChannel;
22using cricket::FakeTransportChannel;
23using cricket::IceRole;
24using cricket::TransportDescription;
25using rtc::SocketAddress;
26
27static const char kIceUfrag1[] = "TESTICEUFRAG0001";
28static const char kIcePwd1[] = "TESTICEPWD00000000000001";
29
30static const char kIceUfrag2[] = "TESTICEUFRAG0002";
31static const char kIcePwd2[] = "TESTICEPWD00000000000002";
32
33class TransportTest : public testing::Test,
34                      public sigslot::has_slots<> {
35 public:
36  TransportTest()
37      : transport_(new FakeTransport("test content name")), channel_(NULL) {}
38  ~TransportTest() {
39    transport_->DestroyAllChannels();
40  }
41  bool SetupChannel() {
42    channel_ = CreateChannel(1);
43    return (channel_ != NULL);
44  }
45  FakeTransportChannel* CreateChannel(int component) {
46    return static_cast<FakeTransportChannel*>(
47        transport_->CreateChannel(component));
48  }
49  void DestroyChannel() {
50    transport_->DestroyChannel(1);
51    channel_ = NULL;
52  }
53
54 protected:
55  rtc::scoped_ptr<FakeTransport> transport_;
56  FakeTransportChannel* channel_;
57};
58
59// This test verifies channels are created with proper ICE
60// role, tiebreaker and remote ice mode and credentials after offer and
61// answer negotiations.
62TEST_F(TransportTest, TestChannelIceParameters) {
63  transport_->SetIceRole(cricket::ICEROLE_CONTROLLING);
64  transport_->SetIceTiebreaker(99U);
65  cricket::TransportDescription local_desc(kIceUfrag1, kIcePwd1);
66  ASSERT_TRUE(transport_->SetLocalTransportDescription(local_desc,
67                                                       cricket::CA_OFFER,
68                                                       NULL));
69  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());
70  EXPECT_TRUE(SetupChannel());
71  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());
72  EXPECT_EQ(cricket::ICEMODE_FULL, channel_->remote_ice_mode());
73  EXPECT_EQ(kIceUfrag1, channel_->ice_ufrag());
74  EXPECT_EQ(kIcePwd1, channel_->ice_pwd());
75
76  cricket::TransportDescription remote_desc(kIceUfrag1, kIcePwd1);
77  ASSERT_TRUE(transport_->SetRemoteTransportDescription(remote_desc,
78                                                        cricket::CA_ANSWER,
79                                                        NULL));
80  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());
81  EXPECT_EQ(99U, channel_->IceTiebreaker());
82  EXPECT_EQ(cricket::ICEMODE_FULL, channel_->remote_ice_mode());
83  // Changing the transport role from CONTROLLING to CONTROLLED.
84  transport_->SetIceRole(cricket::ICEROLE_CONTROLLED);
85  EXPECT_EQ(cricket::ICEROLE_CONTROLLED, channel_->GetIceRole());
86  EXPECT_EQ(cricket::ICEMODE_FULL, channel_->remote_ice_mode());
87  EXPECT_EQ(kIceUfrag1, channel_->remote_ice_ufrag());
88  EXPECT_EQ(kIcePwd1, channel_->remote_ice_pwd());
89}
90
91// Verifies that IceCredentialsChanged returns true when either ufrag or pwd
92// changed, and false in other cases.
93TEST_F(TransportTest, TestIceCredentialsChanged) {
94  EXPECT_TRUE(cricket::IceCredentialsChanged("u1", "p1", "u2", "p2"));
95  EXPECT_TRUE(cricket::IceCredentialsChanged("u1", "p1", "u2", "p1"));
96  EXPECT_TRUE(cricket::IceCredentialsChanged("u1", "p1", "u1", "p2"));
97  EXPECT_FALSE(cricket::IceCredentialsChanged("u1", "p1", "u1", "p1"));
98}
99
100// This test verifies that the callee's ICE role changes from controlled to
101// controlling when the callee triggers an ICE restart.
102TEST_F(TransportTest, TestIceControlledToControllingOnIceRestart) {
103  EXPECT_TRUE(SetupChannel());
104  transport_->SetIceRole(cricket::ICEROLE_CONTROLLED);
105
106  cricket::TransportDescription desc(kIceUfrag1, kIcePwd1);
107  ASSERT_TRUE(transport_->SetRemoteTransportDescription(desc,
108                                                        cricket::CA_OFFER,
109                                                        NULL));
110  ASSERT_TRUE(transport_->SetLocalTransportDescription(desc,
111                                                       cricket::CA_ANSWER,
112                                                       NULL));
113  EXPECT_EQ(cricket::ICEROLE_CONTROLLED, transport_->ice_role());
114
115  cricket::TransportDescription new_local_desc(kIceUfrag2, kIcePwd2);
116  ASSERT_TRUE(transport_->SetLocalTransportDescription(new_local_desc,
117                                                       cricket::CA_OFFER,
118                                                       NULL));
119  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());
120  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());
121}
122
123// This test verifies that the caller's ICE role changes from controlling to
124// controlled when the callee triggers an ICE restart.
125TEST_F(TransportTest, TestIceControllingToControlledOnIceRestart) {
126  EXPECT_TRUE(SetupChannel());
127  transport_->SetIceRole(cricket::ICEROLE_CONTROLLING);
128
129  cricket::TransportDescription desc(kIceUfrag1, kIcePwd1);
130  ASSERT_TRUE(transport_->SetLocalTransportDescription(desc,
131                                                       cricket::CA_OFFER,
132                                                       NULL));
133  ASSERT_TRUE(transport_->SetRemoteTransportDescription(desc,
134                                                        cricket::CA_ANSWER,
135                                                        NULL));
136  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());
137
138  cricket::TransportDescription new_local_desc(kIceUfrag2, kIcePwd2);
139  ASSERT_TRUE(transport_->SetLocalTransportDescription(new_local_desc,
140                                                       cricket::CA_ANSWER,
141                                                       NULL));
142  EXPECT_EQ(cricket::ICEROLE_CONTROLLED, transport_->ice_role());
143  EXPECT_EQ(cricket::ICEROLE_CONTROLLED, channel_->GetIceRole());
144}
145
146// This test verifies that the caller's ICE role is still controlling after the
147// callee triggers ICE restart if the callee's ICE mode is LITE.
148TEST_F(TransportTest, TestIceControllingOnIceRestartIfRemoteIsIceLite) {
149  EXPECT_TRUE(SetupChannel());
150  transport_->SetIceRole(cricket::ICEROLE_CONTROLLING);
151
152  cricket::TransportDescription desc(kIceUfrag1, kIcePwd1);
153  ASSERT_TRUE(transport_->SetLocalTransportDescription(desc,
154                                                       cricket::CA_OFFER,
155                                                       NULL));
156
157  cricket::TransportDescription remote_desc(
158      std::vector<std::string>(),
159      kIceUfrag1, kIcePwd1, cricket::ICEMODE_LITE,
160      cricket::CONNECTIONROLE_NONE, NULL, cricket::Candidates());
161  ASSERT_TRUE(transport_->SetRemoteTransportDescription(remote_desc,
162                                                        cricket::CA_ANSWER,
163                                                        NULL));
164
165  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());
166
167  cricket::TransportDescription new_local_desc(kIceUfrag2, kIcePwd2);
168  ASSERT_TRUE(transport_->SetLocalTransportDescription(new_local_desc,
169                                                       cricket::CA_ANSWER,
170                                                       NULL));
171  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());
172  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());
173}
174
175// Tests channel role is reversed after receiving ice-lite from remote.
176TEST_F(TransportTest, TestSetRemoteIceLiteInOffer) {
177  transport_->SetIceRole(cricket::ICEROLE_CONTROLLED);
178  cricket::TransportDescription remote_desc(
179      std::vector<std::string>(),
180      kIceUfrag1, kIcePwd1, cricket::ICEMODE_LITE,
181      cricket::CONNECTIONROLE_ACTPASS, NULL, cricket::Candidates());
182  ASSERT_TRUE(transport_->SetRemoteTransportDescription(remote_desc,
183                                                        cricket::CA_OFFER,
184                                                        NULL));
185  cricket::TransportDescription local_desc(kIceUfrag1, kIcePwd1);
186  ASSERT_TRUE(transport_->SetLocalTransportDescription(local_desc,
187                                                       cricket::CA_ANSWER,
188                                                       NULL));
189  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());
190  EXPECT_TRUE(SetupChannel());
191  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());
192  EXPECT_EQ(cricket::ICEMODE_LITE, channel_->remote_ice_mode());
193}
194
195// Tests ice-lite in remote answer.
196TEST_F(TransportTest, TestSetRemoteIceLiteInAnswer) {
197  transport_->SetIceRole(cricket::ICEROLE_CONTROLLING);
198  cricket::TransportDescription local_desc(kIceUfrag1, kIcePwd1);
199  ASSERT_TRUE(transport_->SetLocalTransportDescription(local_desc,
200                                                       cricket::CA_OFFER,
201                                                       NULL));
202  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());
203  EXPECT_TRUE(SetupChannel());
204  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());
205  // Channels will be created in ICEFULL_MODE.
206  EXPECT_EQ(cricket::ICEMODE_FULL, channel_->remote_ice_mode());
207  cricket::TransportDescription remote_desc(
208      std::vector<std::string>(),
209      kIceUfrag1, kIcePwd1, cricket::ICEMODE_LITE,
210      cricket::CONNECTIONROLE_NONE, NULL, cricket::Candidates());
211  ASSERT_TRUE(transport_->SetRemoteTransportDescription(remote_desc,
212                                                        cricket::CA_ANSWER,
213                                                        NULL));
214  EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());
215  // After receiving remote description with ICEMODE_LITE, channel should
216  // have mode set to ICEMODE_LITE.
217  EXPECT_EQ(cricket::ICEMODE_LITE, channel_->remote_ice_mode());
218}
219
220TEST_F(TransportTest, TestGetStats) {
221  EXPECT_TRUE(SetupChannel());
222  cricket::TransportStats stats;
223  EXPECT_TRUE(transport_->GetStats(&stats));
224  // Note that this tests the behavior of a FakeTransportChannel.
225  ASSERT_EQ(1U, stats.channel_stats.size());
226  EXPECT_EQ(1, stats.channel_stats[0].component);
227  transport_->ConnectChannels();
228  EXPECT_TRUE(transport_->GetStats(&stats));
229  ASSERT_EQ(1U, stats.channel_stats.size());
230  EXPECT_EQ(1, stats.channel_stats[0].component);
231}
232
233