////////////////////////////////////////////////////////////////////////////////
// Copyright 2019 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 "common/content_id_util.h"

#include <stddef.h>

#include <string>

#include "testing/gmock.h"
#include "testing/gunit.h"
#include "protos/public/errors.pb.h"
#include "protos/public/external_license.pb.h"
#include "protos/public/license_protocol.pb.h"
#include "protos/public/widevine_pssh.pb.h"

namespace {
const char kContentId[] = "TestContentId";
const char kPlayReadyChallenge[] = "<TestPRChallenge></TestPRChallenge>";
}  // namespace

namespace widevine {

// Builds a SignedMessage that includes an ExternalLicenseRequest.
SignedMessage BuildSignedExternalLicenseRequest(const ExternalLicenseType type,
                                                const std::string& request,
                                                const std::string& content_id) {
  ExternalLicenseRequest external_license_request;
  external_license_request.set_request_type(type);
  external_license_request.set_request(request);
  LicenseRequest::ContentIdentification::WidevinePsshData* cenc_id =
      external_license_request.mutable_content_id()
          ->mutable_widevine_pssh_data();
  WidevinePsshData widevine_pssh_data;
  widevine_pssh_data.set_content_id(content_id);
  std::string widevine_pssh_string;
  widevine_pssh_data.SerializeToString(&widevine_pssh_string);
  cenc_id->add_pssh_data(widevine_pssh_string);
  SignedMessage signed_message;
  signed_message.set_type(SignedMessage::EXTERNAL_LICENSE_REQUEST);
  EXPECT_TRUE(
      external_license_request.SerializeToString(signed_message.mutable_msg()));
  return signed_message;
}

TEST(ContentIdUtil, GetContentId) {
  std::string content_id;
  EXPECT_OK(GetContentIdFromSignedExternalLicenseRequest(
      BuildSignedExternalLicenseRequest(PLAYREADY_LICENSE_NEW,
                                        kPlayReadyChallenge, kContentId),
      &content_id));
  EXPECT_EQ(kContentId, content_id);
}

TEST(ContentIdUtil, GetContentIdFailureWithIncorrectType) {
  std::string content_id;
  SignedMessage signed_message = BuildSignedExternalLicenseRequest(
      PLAYREADY_LICENSE_NEW, kPlayReadyChallenge, kContentId);
  signed_message.set_type(SignedMessage::SERVICE_CERTIFICATE_REQUEST);
  Status status =
      GetContentIdFromSignedExternalLicenseRequest(signed_message, &content_id);
  EXPECT_EQ(error::INVALID_ARGUMENT, status.error_code());
  EXPECT_TRUE(content_id.empty());
}

TEST(ContentIdUtil, GetContentIdFailureWithInvalidExternalLicenseRequest) {
  std::string content_id;
  SignedMessage signed_message = BuildSignedExternalLicenseRequest(
      PLAYREADY_LICENSE_NEW, kPlayReadyChallenge, kContentId);
  signed_message.set_msg("Invalid payload");
  Status status =
      GetContentIdFromSignedExternalLicenseRequest(signed_message, &content_id);
  EXPECT_EQ(EXTERNAL_LICENSE_REQUEST_PARSE_ERROR, status.error_code());
  EXPECT_TRUE(content_id.empty());
}

}  // namespace widevine