// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <deque>

#include "content/common/media/webrtc_identity_messages.h"
#include "content/renderer/media/webrtc_identity_service.h"
#include "ipc/ipc_message.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace content {

namespace {

static const char FAKE_ORIGIN[] = "http://fake.com";
static const char FAKE_IDENTITY_NAME[] = "fake identity";
static const char FAKE_COMMON_NAME[] = "fake common name";
static const char FAKE_CERTIFICATE[] = "fake cert";
static const char FAKE_PRIVATE_KEY[] = "fake private key";
static const int FAKE_ERROR = 100;

class WebRTCIdentityServiceForTest : public WebRTCIdentityService {
 public:
  virtual bool Send(IPC::Message* message) OVERRIDE {
    messages_.push_back(*message);
    delete message;
    return true;
  }

  virtual bool OnControlMessageReceived(const IPC::Message& message) OVERRIDE {
    return WebRTCIdentityService::OnControlMessageReceived(message);
  }

  IPC::Message GetLastMessage() { return messages_.back(); }

  int GetNumberOfMessages() { return messages_.size(); }

  void ClearMessages() { messages_.clear(); }

 private:
  std::deque<IPC::Message> messages_;
};

class WebRTCIdentityServiceTest : public ::testing::Test {
 public:
  WebRTCIdentityServiceTest()
      : service_(new WebRTCIdentityServiceForTest()), last_error_(0) {}

 protected:
  void OnIdentityReady(const std::string& cert, const std::string& key) {
    last_certificate_ = cert;
    last_private_key_ = key;
  }

  void OnRequestFailed(int error) { last_error_ = error; }

  void ResetRequestResult() {
    last_certificate_ = "";
    last_private_key_ = "";
    last_error_ = 0;
  }

  int RequestIdentity() {
    return service_->RequestIdentity(
        GURL(FAKE_ORIGIN),
        FAKE_IDENTITY_NAME,
        FAKE_COMMON_NAME,
        base::Bind(&WebRTCIdentityServiceTest::OnIdentityReady,
                   base::Unretained(this)),
        base::Bind(&WebRTCIdentityServiceTest::OnRequestFailed,
                   base::Unretained(this)));
  }

  scoped_ptr<WebRTCIdentityServiceForTest> service_;
  std::string last_certificate_;
  std::string last_private_key_;
  int last_error_;
};

}  // namespace

TEST_F(WebRTCIdentityServiceTest, TestSendRequest) {
  RequestIdentity();

  IPC::Message ipc = service_->GetLastMessage();
  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_RequestIdentity::ID);
}

TEST_F(WebRTCIdentityServiceTest, TestSuccessCallback) {
  int id = RequestIdentity();

  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
      id, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
  EXPECT_EQ(FAKE_CERTIFICATE, last_certificate_);
  EXPECT_EQ(FAKE_PRIVATE_KEY, last_private_key_);
}

TEST_F(WebRTCIdentityServiceTest, TestFailureCallback) {
  int id = RequestIdentity();

  service_->OnControlMessageReceived(
      WebRTCIdentityHostMsg_RequestFailed(id, FAKE_ERROR));
  EXPECT_EQ(FAKE_ERROR, last_error_);
}

TEST_F(WebRTCIdentityServiceTest, TestCancelRequest) {
  int request_id = RequestIdentity();
  service_->ClearMessages();

  service_->CancelRequest(request_id);

  IPC::Message ipc = service_->GetLastMessage();
  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_CancelRequest::ID);
}

TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestSentAfterSuccess) {
  int id = RequestIdentity();
  RequestIdentity();
  EXPECT_EQ(1, service_->GetNumberOfMessages());
  service_->ClearMessages();

  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
      id, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));

  IPC::Message ipc = service_->GetLastMessage();
  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_RequestIdentity::ID);
}

TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestSentAfterFailure) {
  int id = RequestIdentity();
  RequestIdentity();
  EXPECT_EQ(1, service_->GetNumberOfMessages());
  service_->ClearMessages();

  service_->OnControlMessageReceived(
      WebRTCIdentityHostMsg_RequestFailed(id, FAKE_ERROR));

  IPC::Message ipc = service_->GetLastMessage();
  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_RequestIdentity::ID);
}

TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestSentAfterCancelOutstanding) {
  int outstand_request_id = RequestIdentity();
  RequestIdentity();

  EXPECT_EQ(1, service_->GetNumberOfMessages());
  service_->ClearMessages();

  service_->CancelRequest(outstand_request_id);

  // Should have two messages sent: one for cancelling the outstanding request,
  // one for requesting the queued request.
  EXPECT_EQ(2, service_->GetNumberOfMessages());
  IPC::Message ipc = service_->GetLastMessage();
  EXPECT_EQ(ipc.type(), WebRTCIdentityMsg_RequestIdentity::ID);
}

TEST_F(WebRTCIdentityServiceTest, TestCancelQueuedRequest) {
  int sent_id = RequestIdentity();
  int queued_request_id = RequestIdentity();
  EXPECT_EQ(1, service_->GetNumberOfMessages());
  service_->ClearMessages();

  service_->CancelRequest(queued_request_id);

  // Verifies that the queued request is not sent after the outstanding request
  // returns.
  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
      sent_id, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));

  EXPECT_EQ(0, service_->GetNumberOfMessages());
}

TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestSuccessCallback) {
  int id1 = RequestIdentity();
  int id2 = RequestIdentity();

  // Completes the outstanding request.
  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
      id1, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
  EXPECT_EQ(FAKE_CERTIFICATE, last_certificate_);
  EXPECT_EQ(FAKE_PRIVATE_KEY, last_private_key_);

  ResetRequestResult();

  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
      id2, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
  EXPECT_EQ(FAKE_CERTIFICATE, last_certificate_);
  EXPECT_EQ(FAKE_PRIVATE_KEY, last_private_key_);
}

TEST_F(WebRTCIdentityServiceTest, TestQueuedRequestFailureCallback) {
  int id1 = RequestIdentity();
  int id2 = RequestIdentity();

  // Completes the outstanding request.
  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
      id1, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));
  EXPECT_EQ(FAKE_CERTIFICATE, last_certificate_);
  EXPECT_EQ(FAKE_PRIVATE_KEY, last_private_key_);

  ResetRequestResult();

  service_->OnControlMessageReceived(
      WebRTCIdentityHostMsg_RequestFailed(id2, FAKE_ERROR));
  EXPECT_EQ(FAKE_ERROR, last_error_);
}

// Verifies that receiving a response for a cancelled request does not incur the
// callbacks.
TEST_F(WebRTCIdentityServiceTest, TestRequestCompletedAfterCancelled) {
  int id1 = RequestIdentity();
  RequestIdentity();
  service_->CancelRequest(id1);

  service_->OnControlMessageReceived(WebRTCIdentityHostMsg_IdentityReady(
      id1, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY));

  EXPECT_NE(FAKE_CERTIFICATE, last_certificate_);
  EXPECT_NE(FAKE_PRIVATE_KEY, last_private_key_);

  service_->OnControlMessageReceived(
      WebRTCIdentityHostMsg_RequestFailed(id1, FAKE_ERROR));
  EXPECT_NE(FAKE_ERROR, last_error_);
}

}  // namespace content