// Copyright 2017 Google Inc. All Rights Reserved.
//
// This file contains unit tests for the WvContentDecryptionModule class
// that pertain to collecting and reporting metrics.

#include "gmock/gmock.h"
#include "log.h"
#include "metrics.pb.h"
#include "string_conversions.h"
#include "test_base.h"
#include "test_printers.h"
#include "wv_cdm_types.h"
#include "wv_content_decryption_module.h"

using ::testing::Eq;
using ::testing::StrEq;
using ::testing::Ge;
using ::testing::Gt;
using ::testing::Lt;
using ::testing::Test;
using wvcdm::CdmResponseType;

namespace wvcdm {

// This class is used to test the metrics-related feaures of the
// WvContentDecryptionModule class.
class WvContentDecryptionModuleMetricsTest : public ::testing::Test {
 protected:

  wvcdm::WvContentDecryptionModule decryptor_;
};

TEST_F(WvContentDecryptionModuleMetricsTest, NoMetrics) {
  // Get metrics before any operations are performed.
  std::string serialized_metrics;
  decryptor_.GetSerializedMetrics(&serialized_metrics);
  EXPECT_TRUE(serialized_metrics.empty());
}

TEST_F(WvContentDecryptionModuleMetricsTest, EngineOnlyMetrics) {
  std::string request;
  std::string provisioning_server_url;
  CdmCertificateType cert_type = kCertificateWidevine;
  std::string cert_authority, cert, wrapped_key;

  // This call will create a CdmEngine instance with an EngineMetrics instance.
  EXPECT_EQ(wvcdm::NO_ERROR,
            decryptor_.GetProvisioningRequest(cert_type, cert_authority,
                                              kDefaultCdmIdentifier, &request,
                                              &provisioning_server_url));
  std::string serialized_metrics;
  decryptor_.GetSerializedMetrics(&serialized_metrics);

  drm_metrics::WvCdmMetricsGroup metrics_group;
  ASSERT_TRUE(metrics_group.ParseFromString(serialized_metrics))
      << "Unexpected failure deserializing metrics: "
      << wvcdm::b2a_hex(serialized_metrics);
  ASSERT_THAT(metrics_group.metrics().size(), Eq(1));

  // 100 is an arbitrary high value that shouldn't ever occur.
  EXPECT_THAT(
      metrics_group.metrics(0).engine_metrics()
          .oemcrypto_initialization_mode().int_value(),
      Lt(100));
  EXPECT_THAT(
      metrics_group.metrics(0).engine_metrics()
          .oemcrypto_initialization_mode().int_value(),
      Ge(0));
  ASSERT_THAT(metrics_group.metrics(0).engine_metrics()
                  .cdm_engine_get_provisioning_request_time_us().size(), Eq(1));
  EXPECT_THAT(metrics_group.metrics(0).engine_metrics()
                  .cdm_engine_get_provisioning_request_time_us(0)
                  .operation_count(),
                      Eq(1u));
}


TEST_F(WvContentDecryptionModuleMetricsTest, EngineAndSessionMetrics) {
  CdmSessionId session_id;
  wvcdm::CdmKeySystem key_system("com.widevine");

  // Openning the session will fail with NEEDS_PROVISIONING error. But it will
  // still create some session-level stats.
  EXPECT_EQ(CdmResponseType::NEED_PROVISIONING,
            decryptor_.OpenSession(key_system, NULL,
                                   kDefaultCdmIdentifier, NULL, &session_id));

  // The metrics will have a single engine and single session stats.
  std::string serialized_metrics;
  decryptor_.GetSerializedMetrics(&serialized_metrics);

  // Spot check some metric values.
  drm_metrics::WvCdmMetricsGroup metrics_group;
  ASSERT_TRUE(metrics_group.ParseFromString(serialized_metrics))
      << "Unexpected failure deserializing metrics: "
      << wvcdm::b2a_hex(serialized_metrics);
  ASSERT_THAT(metrics_group.metrics().size(), Eq(1));

  // Validate engine-level metrics.
  EXPECT_TRUE(metrics_group.metrics(0).engine_metrics()
              .has_oemcrypto_initialization_mode());
  ASSERT_THAT(
      metrics_group.metrics(0).engine_metrics().cdm_engine_open_session().size(),
      Eq(1));
  EXPECT_THAT(metrics_group.metrics(0).engine_metrics()
              .cdm_engine_open_session(0).count(), Eq(1));
  EXPECT_THAT(metrics_group.metrics(0).engine_metrics()
                  .cdm_engine_open_session(0).attributes().error_code(),
                      Eq(CdmResponseType::NEED_PROVISIONING));

  // Validate a session-level metric.
  ASSERT_THAT(metrics_group.metrics(0).session_metrics().size(), Eq(1));
  EXPECT_THAT(
      metrics_group.metrics(0).session_metrics(0)
          .cdm_session_life_span_ms().double_value(),
      Gt(0.0))
          << "Unexpected failure with session_metrics: "
          << wvcdm::b2a_hex(serialized_metrics);
}

TEST_F(WvContentDecryptionModuleMetricsTest, MultipleEngineMetric) {
  CdmSessionId session_id;
  wvcdm::CdmKeySystem key_system("com.widevine");
  CdmIdentifier identifier = { "foo", "bar", "baz" };

  // Openning the session will fail with NEEDS_PROVISIONING error. But it will
  // still create some session-level stats.
  EXPECT_EQ(CdmResponseType::NEED_PROVISIONING,
            decryptor_.OpenSession(key_system, NULL,
                                   kDefaultCdmIdentifier, NULL, &session_id));
  // Open a second engine with a custom identifier.
  EXPECT_EQ(CdmResponseType::NEED_PROVISIONING,
            decryptor_.OpenSession(key_system, NULL,
                                   identifier, NULL, &session_id));

  // The metrics will now have two engines with single session stats each.
  std::string serialized_metrics;
  decryptor_.GetSerializedMetrics(&serialized_metrics);

  // Spot check some metric values.
  drm_metrics::WvCdmMetricsGroup metrics_group;
  ASSERT_TRUE(metrics_group.ParseFromString(serialized_metrics));

  // Two engine-level metrics are expected.
  ASSERT_THAT(metrics_group.metrics().size(), Eq(2));

  for (int i = 0; i < metrics_group.metrics().size(); i++) {
    drm_metrics::WvCdmMetrics::EngineMetrics engine_metrics =
        metrics_group.metrics(i).engine_metrics();
    // Validate an engine-level metric.
    EXPECT_TRUE(engine_metrics.has_oemcrypto_initialization_mode());
    ASSERT_THAT(engine_metrics.cdm_engine_open_session().size(), Eq(1));
    EXPECT_THAT(engine_metrics.cdm_engine_open_session(0).count(), Eq(1));
    EXPECT_THAT(
        engine_metrics.cdm_engine_open_session(0).attributes().error_code(),
        Eq(CdmResponseType::NEED_PROVISIONING));

    // Validate a session-level metric.
    ASSERT_THAT(metrics_group.metrics(i).session_metrics().size(), Eq(1));
    EXPECT_THAT(metrics_group.metrics(i).session_metrics(0)
                .cdm_session_life_span_ms().double_value(), Gt(0.0));
  }
}

}