1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <deque>
6
7#include "content/common/media/webrtc_identity_messages.h"
8#include "content/renderer/media/webrtc_identity_service.h"
9#include "ipc/ipc_message.h"
10#include "testing/gtest/include/gtest/gtest.h"
11
12namespace content {
13
14namespace {
15
16static const char FAKE_ORIGIN[] = "http://fake.com";
17static const char FAKE_IDENTITY_NAME[] = "fake identity";
18static const char FAKE_COMMON_NAME[] = "fake common name";
19static const char FAKE_CERTIFICATE[] = "fake cert";
20static const char FAKE_PRIVATE_KEY[] = "fake private key";
21static const int FAKE_ERROR = 100;
22
23class WebRTCIdentityServiceForTest : public WebRTCIdentityService {
24 public:
25  virtual bool Send(IPC::Message* message) OVERRIDE {
26    messages_.push_back(*message);
27    delete message;
28    return true;
29  }
30
31  virtual bool OnControlMessageReceived(const IPC::Message& message) OVERRIDE {
32    return WebRTCIdentityService::OnControlMessageReceived(message);
33  }
34
35  IPC::Message GetLastMessage() { return messages_.back(); }
36
37  int GetNumberOfMessages() { return messages_.size(); }
38
39  void ClearMessages() { messages_.clear(); }
40
41 private:
42  std::deque<IPC::Message> messages_;
43};
44
45class WebRTCIdentityServiceTest : public ::testing::Test {
46 public:
47  WebRTCIdentityServiceTest()
48      : service_(new WebRTCIdentityServiceForTest()), last_error_(0) {}
49
50 protected:
51  void OnIdentityReady(const std::string& cert, const std::string& key) {
52    last_certificate_ = cert;
53    last_private_key_ = key;
54  }
55
56  void OnRequestFailed(int error) { last_error_ = error; }
57
58  void ResetRequestResult() {
59    last_certificate_ = "";
60    last_private_key_ = "";
61    last_error_ = 0;
62  }
63
64  int RequestIdentity() {
65    return service_->RequestIdentity(
66        GURL(FAKE_ORIGIN),
67        FAKE_IDENTITY_NAME,
68        FAKE_COMMON_NAME,
69        base::Bind(&WebRTCIdentityServiceTest::OnIdentityReady,
70                   base::Unretained(this)),
71        base::Bind(&WebRTCIdentityServiceTest::OnRequestFailed,
72                   base::Unretained(this)));
73  }
74
75  scoped_ptr<WebRTCIdentityServiceForTest> service_;
76  std::string last_certificate_;
77  std::string last_private_key_;
78  int last_error_;
79};
80
81}  // namespace
82
83TEST_F(WebRTCIdentityServiceTest, TestSendRequest) {
84  RequestIdentity();
85
86  IPC::Message ipc = service_->GetLastMessage();
87  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_RequestIdentity::ID);
88}
89
90TEST_F(WebRTCIdentityServiceTest, TestSuccessCallback) {
91  int id = RequestIdentity();
92
93  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
94      id, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
95  EXPECT_EQ(FAKE_CERTIFICATE, last_certificate_);
96  EXPECT_EQ(FAKE_PRIVATE_KEY, last_private_key_);
97}
98
99TEST_F(WebRTCIdentityServiceTest, TestFailureCallback) {
100  int id = RequestIdentity();
101
102  service_->OnControlMessageReceived(
103      WebRTCIdentityHostMsg_RequestFailed(id, FAKE_ERROR));
104  EXPECT_EQ(FAKE_ERROR, last_error_);
105}
106
107TEST_F(WebRTCIdentityServiceTest, TestCancelRequest) {
108  int request_id = RequestIdentity();
109  service_->ClearMessages();
110
111  service_->CancelRequest(request_id);
112
113  IPC::Message ipc = service_->GetLastMessage();
114  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_CancelRequest::ID);
115}
116
117TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestSentAfterSuccess) {
118  int id = RequestIdentity();
119  RequestIdentity();
120  EXPECT_EQ(1, service_->GetNumberOfMessages());
121  service_->ClearMessages();
122
123  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
124      id, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
125
126  IPC::Message ipc = service_->GetLastMessage();
127  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_RequestIdentity::ID);
128}
129
130TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestSentAfterFailure) {
131  int id = RequestIdentity();
132  RequestIdentity();
133  EXPECT_EQ(1, service_->GetNumberOfMessages());
134  service_->ClearMessages();
135
136  service_->OnControlMessageReceived(
137      WebRTCIdentityHostMsg_RequestFailed(id, FAKE_ERROR));
138
139  IPC::Message ipc = service_->GetLastMessage();
140  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_RequestIdentity::ID);
141}
142
143TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestSentAfterCancelOutstanding) {
144  int outstand_request_id = RequestIdentity();
145  RequestIdentity();
146
147  EXPECT_EQ(1, service_->GetNumberOfMessages());
148  service_->ClearMessages();
149
150  service_->CancelRequest(outstand_request_id);
151
152  // Should have two messages sent: one for cancelling the outstanding request,
153  // one for requesting the queued request.
154  EXPECT_EQ(2, service_->GetNumberOfMessages());
155  IPC::Message ipc = service_->GetLastMessage();
156  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_RequestIdentity::ID);
157}
158
159TEST_F(WebRTCIdentityServiceTest, TestCancelQueuedRequest) {
160  int sent_id = RequestIdentity();
161  int queued_request_id = RequestIdentity();
162  EXPECT_EQ(1, service_->GetNumberOfMessages());
163  service_->ClearMessages();
164
165  service_->CancelRequest(queued_request_id);
166
167  // Verifies that the queued request is not sent after the outstanding request
168  // returns.
169  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
170      sent_id, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
171
172  EXPECT_EQ(0, service_->GetNumberOfMessages());
173}
174
175TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestSuccessCallback) {
176  int id1 = RequestIdentity();
177  int id2 = RequestIdentity();
178
179  // Completes the outstanding request.
180  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
181      id1, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
182  EXPECT_EQ(FAKE_CERTIFICATE, last_certificate_);
183  EXPECT_EQ(FAKE_PRIVATE_KEY, last_private_key_);
184
185  ResetRequestResult();
186
187  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
188      id2, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
189  EXPECT_EQ(FAKE_CERTIFICATE, last_certificate_);
190  EXPECT_EQ(FAKE_PRIVATE_KEY, last_private_key_);
191}
192
193TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestFailureCallback) {
194  int id1 = RequestIdentity();
195  int id2 = RequestIdentity();
196
197  // Completes the outstanding request.
198  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
199      id1, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
200  EXPECT_EQ(FAKE_CERTIFICATE, last_certificate_);
201  EXPECT_EQ(FAKE_PRIVATE_KEY, last_private_key_);
202
203  ResetRequestResult();
204
205  service_->OnControlMessageReceived(
206      WebRTCIdentityHostMsg_RequestFailed(id2, FAKE_ERROR));
207  EXPECT_EQ(FAKE_ERROR, last_error_);
208}
209
210// Verifies that receiving a response for a cancelled request does not incur the
211// callbacks.
212TEST_F(WebRTCIdentityServiceTest, TestRequestCompletedAfterCancelled) {
213  int id1 = RequestIdentity();
214  RequestIdentity();
215  service_->CancelRequest(id1);
216
217  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
218      id1, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
219
220  EXPECT_NE(FAKE_CERTIFICATE, last_certificate_);
221  EXPECT_NE(FAKE_PRIVATE_KEY, last_private_key_);
222
223  service_->OnControlMessageReceived(
224      WebRTCIdentityHostMsg_RequestFailed(id1, FAKE_ERROR));
225  EXPECT_NE(FAKE_ERROR, last_error_);
226}
227
228}  // namespace content
229