////////////////////////////////////////////////////////////////////////////////
// Copyright 2016 Google LLC.
//
// This software is licensed under the terms defined in the Widevine Master
// License Agreement. For a copy of this agreement, please contact
// widevine-licensing@google.com.
////////////////////////////////////////////////////////////////////////////////

#include "provisioning_sdk/internal/provisioning_session_impl.h"

#include "testing/gmock.h"
#include "testing/gunit.h"
#include "common/mock_rsa_key.h"
#include "provisioning_sdk/internal/provisioning_engine_impl.h"

using ::testing::_;
using ::testing::ByMove;
using ::testing::DoAll;
using ::testing::IsEmpty;
using ::testing::Return;

namespace {
const char kDevicePrivateKey[] = "device_private_key";
const char kDevicePublicKey[] = "device_public_key";
}  // namespace

namespace widevine {

// Fake session impl to deal with abstract methods..
class FakeProvisioningSessionImpl : public ProvisioningSessionImpl {
 public:
  explicit FakeProvisioningSessionImpl(const ProvisioningEngineImpl& engine) :
      ProvisioningSessionImpl(engine) {}

  ProvisioningStatus ProcessMessage(const std::string& message,
                                    std::string* response,
                                    bool* done) override {
    return INTERNAL_ERROR;
  }
};

class ProvisioningSessionImplTest : public ::testing::Test {
 protected:
  ProvisioningSessionImplTest()
      : session_impl_(engine_impl_) {
    mock_rsa_key_factory_ = new MockRsaKeyFactory;
    session_impl_.set_rsa_key_factory(
        std::unique_ptr<RsaKeyFactory>(mock_rsa_key_factory_));
  }

  ProvisioningEngineImpl engine_impl_;
  FakeProvisioningSessionImpl session_impl_;
  MockRsaKeyFactory* mock_rsa_key_factory_ = nullptr;
};

TEST_F(ProvisioningSessionImplTest, InitializeWithInvalidPublicKey) {
  EXPECT_CALL(*mock_rsa_key_factory_,
              CreateFromPkcs1PublicKey(kDevicePublicKey))
      .WillOnce(Return(ByMove(nullptr)));
  EXPECT_EQ(
      INVALID_DRM_DEVICE_PUBLIC_KEY,
      session_impl_.Initialize(kDevicePublicKey, kDevicePrivateKey));
}

TEST_F(ProvisioningSessionImplTest, InitializeWithInvalidPrivateKey) {
  EXPECT_CALL(*mock_rsa_key_factory_,
              CreateFromPkcs1PublicKey(kDevicePublicKey))
      .WillOnce(
          Return(ByMove(std::unique_ptr<RsaPublicKey>(new MockRsaPublicKey))));
  EXPECT_CALL(*mock_rsa_key_factory_,
              CreateFromPkcs8PrivateKey(kDevicePrivateKey, IsEmpty()))
      .WillOnce(Return(ByMove(nullptr)));
  EXPECT_EQ(
      INVALID_DRM_DEVICE_PRIVATE_KEY,
      session_impl_.Initialize(kDevicePublicKey, kDevicePrivateKey));
}

TEST_F(ProvisioningSessionImplTest, InitializeWithMismatchPublicPrivateKey) {
  MockRsaPublicKey* mock_rsa_public_key = new MockRsaPublicKey;
  EXPECT_CALL(*mock_rsa_key_factory_,
              CreateFromPkcs1PublicKey(kDevicePublicKey))
      .WillOnce(
          Return(ByMove(std::unique_ptr<RsaPublicKey>(mock_rsa_public_key))));
  EXPECT_CALL(*mock_rsa_key_factory_,
              CreateFromPkcs8PrivateKey(kDevicePrivateKey, IsEmpty()))
      .WillOnce(Return(
          ByMove(std::unique_ptr<RsaPrivateKey>(new MockRsaPrivateKey))));
  EXPECT_CALL(*mock_rsa_public_key, MatchesPrivateKey(_))
      .WillOnce(Return(false));
  EXPECT_EQ(
      INVALID_DRM_DEVICE_PRIVATE_KEY,
      session_impl_.Initialize(kDevicePublicKey, kDevicePrivateKey));
}


}  // namespace widevine