////////////////////////////////////////////////////////////////////////////////
// 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.
////////////////////////////////////////////////////////////////////////////////

#ifndef COMMON_MOCK_RSA_KEY_H_
#define COMMON_MOCK_RSA_KEY_H_

#include <string>

#include "testing/gmock.h"
#include "common/hash_algorithm.h"
#include "common/rsa_key.h"

namespace widevine {

class MockRsaPrivateKey : public RsaPrivateKey {
 public:
  MockRsaPrivateKey() : RsaPrivateKey(RSA_new()) {}
  ~MockRsaPrivateKey() override {}

  MOCK_METHOD(bool, Decrypt,
              (const std::string& encrypted_message,
               std::string* decrypted_message),
              (const, override));
  // TODO(b/155438325): remove this function after the below function is fully
  // propagated.
  MOCK_METHOD(bool, GenerateSignature,
              (const std::string& message, std::string* signature),
              (const, override));
  MOCK_METHOD(bool, GenerateSignature,
              (const std::string& message, HashAlgorithm hash_algorithm,
               std::string* signature),
              (const, override));
  MOCK_METHOD(bool, MatchesPrivateKey, (const RsaPrivateKey& private_key),
              (const, override));
  MOCK_METHOD(bool, MatchesPublicKey, (const RsaPublicKey& public_key),
              (const, override));

 private:
  MockRsaPrivateKey(const MockRsaPrivateKey&) = delete;
  MockRsaPrivateKey& operator=(const MockRsaPrivateKey&) = delete;
};

class MockRsaPublicKey : public RsaPublicKey {
 public:
  MockRsaPublicKey() : RsaPublicKey(RSA_new()) {}
  ~MockRsaPublicKey() override {}

  MOCK_METHOD(bool, Encrypt,
              (const std::string& clear_message,
               std::string* encrypted_message),
              (const, override));
  // TODO(b/155438325): remove this function after the below function is fully
  // propagated.
  MOCK_METHOD(bool, VerifySignature,
              (const std::string& message, const std::string& signature),
              (const, override));
  MOCK_METHOD(bool, VerifySignature,
              (const std::string& message, HashAlgorithm hash_algorithm,
               const std::string& signature),
              (const, override));
  MOCK_METHOD(bool, MatchesPrivateKey, (const RsaPrivateKey& private_key),
              (const, override));
  MOCK_METHOD(bool, MatchesPublicKey, (const RsaPublicKey& public_key),
              (const, override));

 private:
  MockRsaPublicKey(const MockRsaPublicKey&) = delete;
  MockRsaPublicKey& operator=(const MockRsaPublicKey&) = delete;
};

class MockRsaKeyFactory : public RsaKeyFactory {
 public:
  MockRsaKeyFactory() {}
  ~MockRsaKeyFactory() override {}

  MOCK_METHOD(std::unique_ptr<RsaPrivateKey>, CreateFromPkcs1PrivateKey,
              (const std::string& private_key), (const, override));
  MOCK_METHOD(std::unique_ptr<RsaPrivateKey>, CreateFromPkcs8PrivateKey,
              (const std::string& private_key,
               const std::string& private_key_passphrase),
              (const, override));
  MOCK_METHOD(std::unique_ptr<RsaPublicKey>, CreateFromPkcs1PublicKey,
              (const std::string& public_key), (const, override));

 private:
  MockRsaKeyFactory(const MockRsaKeyFactory&) = delete;
  MockRsaKeyFactory& operator=(const MockRsaKeyFactory&) = delete;
};

}  // namespace widevine

#endif  // COMMON_MOCK_RSA_KEY_H_