400 lines
17 KiB
C++
400 lines
17 KiB
C++
// Copyright 2017 Google Inc. All Rights Reserved.
|
|
//
|
|
// Unit tests for the metrics collections,
|
|
// EngineMetrics, SessionMetrics and CryptoMetrics.
|
|
|
|
#include "metrics_collections.h"
|
|
|
|
#include <sstream>
|
|
|
|
#include "device_files.h"
|
|
#include "gmock/gmock.h"
|
|
#include "google/protobuf/text_format.h"
|
|
#include "gtest/gtest.h"
|
|
#include "log.h"
|
|
#include "metrics.pb.h"
|
|
#include "wv_cdm_types.h"
|
|
|
|
using drm_metrics::WvCdmMetrics;
|
|
using google::protobuf::TextFormat;
|
|
|
|
namespace {
|
|
const char kSessionId1[] = "session_id_1";
|
|
const char kSessionId2[] = "session_id_2";
|
|
} // anonymous namespace
|
|
|
|
namespace wvcdm {
|
|
namespace metrics {
|
|
|
|
// TODO(blueeyes): Improve this implementation by supporting full message
|
|
// API In CDM. That allows us to use MessageDifferencer.
|
|
class EngineMetricsTest : public ::testing::Test {
|
|
};
|
|
|
|
TEST_F(EngineMetricsTest, AllEngineMetrics) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
// Set some values in all of the engine metrics.
|
|
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease);
|
|
engine_metrics.cdm_engine_close_session_.Increment(NO_ERROR);
|
|
engine_metrics.cdm_engine_decrypt_.Record(1.0, NO_ERROR,
|
|
metrics::Pow2Bucket(8));
|
|
engine_metrics.cdm_engine_find_session_for_key_.Increment(false);
|
|
engine_metrics.cdm_engine_generate_key_request_.Record(1.0, NO_ERROR, kLicenseTypeRelease);
|
|
engine_metrics.cdm_engine_get_provisioning_request_.Record(1.0, NO_ERROR);
|
|
engine_metrics.cdm_engine_get_usage_info_.Record(1.0, NO_ERROR,
|
|
UNKNOWN_ERROR);
|
|
engine_metrics.cdm_engine_handle_provisioning_response_.Record(1.0, NO_ERROR);
|
|
engine_metrics.cdm_engine_open_key_set_session_.Increment(NO_ERROR);
|
|
engine_metrics.cdm_engine_open_session_.Increment(NO_ERROR);
|
|
engine_metrics.cdm_engine_query_key_status_.Record(1.0, NO_ERROR);
|
|
engine_metrics.cdm_engine_release_all_usage_info_.Increment(NO_ERROR);
|
|
engine_metrics.cdm_engine_release_usage_info_.Increment(NO_ERROR);
|
|
engine_metrics.cdm_engine_remove_keys_.Increment(NO_ERROR);
|
|
engine_metrics.cdm_engine_restore_key_.Record(1.0, NO_ERROR);
|
|
engine_metrics.cdm_engine_unprovision_.Increment(NO_ERROR, kSecurityLevelL1);
|
|
|
|
// Also set and serialize the oemcrypto dynamic adapter metrics.
|
|
OemCryptoDynamicAdapterMetrics adapter_metrics;
|
|
adapter_metrics.SetInitializationMode(OEMCrypto_INITIALIZED_FORCING_L3);
|
|
adapter_metrics.SetL1ApiVersion(2);
|
|
adapter_metrics.SetL1MinApiVersion(1);
|
|
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
adapter_metrics.Serialize(actual_metrics.mutable_engine_metrics());
|
|
|
|
ASSERT_TRUE(actual_metrics.has_engine_metrics());
|
|
EXPECT_EQ(0, actual_metrics.session_metrics_size());
|
|
|
|
// Spot check some metrics.
|
|
ASSERT_EQ(1,
|
|
actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size());
|
|
EXPECT_EQ(2, actual_metrics.engine_metrics()
|
|
.cdm_engine_add_key_time_us(0)
|
|
.attributes().error_code());
|
|
ASSERT_EQ(1,
|
|
actual_metrics.engine_metrics().cdm_engine_close_session_size());
|
|
EXPECT_EQ(0, actual_metrics.engine_metrics()
|
|
.cdm_engine_close_session(0)
|
|
.attributes().error_code());
|
|
ASSERT_EQ(1,
|
|
actual_metrics.engine_metrics().cdm_engine_decrypt_time_us_size());
|
|
EXPECT_EQ(0, actual_metrics.engine_metrics()
|
|
.cdm_engine_decrypt_time_us(0)
|
|
.attributes().error_code());
|
|
EXPECT_EQ(1.0, actual_metrics.engine_metrics()
|
|
.cdm_engine_decrypt_time_us(0)
|
|
.mean());
|
|
EXPECT_EQ(OEMCrypto_INITIALIZED_FORCING_L3,
|
|
actual_metrics.engine_metrics().oemcrypto_initialization_mode()
|
|
.int_value());
|
|
ASSERT_EQ(
|
|
1, actual_metrics.engine_metrics()
|
|
.cdm_engine_get_usage_info_time_us_size());
|
|
|
|
EXPECT_EQ(UNKNOWN_ERROR, actual_metrics.engine_metrics()
|
|
.cdm_engine_get_usage_info_time_us(0).attributes().error_detail());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
// Set some values in some of the engine metrics and some crypto metrics.
|
|
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease);
|
|
engine_metrics.cdm_engine_close_session_.Increment(UNKNOWN_ERROR);
|
|
CryptoMetrics* crypto_metrics = engine_metrics.GetCryptoMetrics();
|
|
|
|
crypto_metrics->crypto_session_get_device_unique_id_.Increment(NO_ERROR);
|
|
crypto_metrics->crypto_session_generic_decrypt_
|
|
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
|
|
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
|
|
ASSERT_TRUE(actual_metrics.has_engine_metrics());
|
|
EXPECT_EQ(0, actual_metrics.session_metrics_size());
|
|
|
|
// Spot check some metrics.
|
|
ASSERT_EQ(1,
|
|
actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size());
|
|
EXPECT_EQ(2, actual_metrics.engine_metrics()
|
|
.cdm_engine_add_key_time_us(0)
|
|
.attributes().error_code());
|
|
ASSERT_EQ(1,
|
|
actual_metrics.engine_metrics().cdm_engine_close_session_size());
|
|
EXPECT_EQ(UNKNOWN_ERROR, actual_metrics.engine_metrics()
|
|
.cdm_engine_close_session(0)
|
|
.attributes().error_code());
|
|
ASSERT_EQ(1, actual_metrics.engine_metrics().crypto_metrics()
|
|
.crypto_session_get_device_unique_id_size());
|
|
EXPECT_EQ(1, actual_metrics.engine_metrics().crypto_metrics()
|
|
.crypto_session_get_device_unique_id(0)
|
|
.count());
|
|
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics().crypto_metrics()
|
|
.crypto_session_get_device_unique_id(0)
|
|
.attributes().error_code());
|
|
ASSERT_EQ(1, actual_metrics.engine_metrics().crypto_metrics()
|
|
.crypto_session_generic_decrypt_time_us_size());
|
|
EXPECT_EQ(2.0, actual_metrics.engine_metrics().crypto_metrics()
|
|
.crypto_session_generic_decrypt_time_us(0)
|
|
.mean());
|
|
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics().crypto_metrics()
|
|
.crypto_session_generic_decrypt_time_us(0)
|
|
.attributes().error_code());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EmptyEngineMetrics) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
|
|
// Empty engine metics will still produce an engine metrics record.
|
|
EXPECT_TRUE(actual_metrics.has_engine_metrics());
|
|
EXPECT_EQ(0, actual_metrics.session_metrics_size());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EngineMetricsWithSessions) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
// Set a values in an engine metric and in a crypto metric.
|
|
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease);
|
|
engine_metrics.GetCryptoMetrics()
|
|
->crypto_session_load_certificate_private_key_.Record(2.0, NO_ERROR);
|
|
|
|
// Create two sessions and record some metrics.
|
|
std::shared_ptr<SessionMetrics> session_metrics_1 =
|
|
engine_metrics.AddSession();
|
|
session_metrics_1->SetSessionId(kSessionId1);
|
|
std::shared_ptr<SessionMetrics> session_metrics_2 =
|
|
engine_metrics.AddSession();
|
|
session_metrics_2->SetSessionId(kSessionId2);
|
|
// Record a CryptoMetrics metric in the session.
|
|
session_metrics_2->GetCryptoMetrics()->crypto_session_generic_decrypt_
|
|
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
|
|
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
|
|
// Spot check some metrics.
|
|
ASSERT_TRUE(actual_metrics.has_engine_metrics());
|
|
EXPECT_EQ(1,
|
|
actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size());
|
|
EXPECT_EQ(2, actual_metrics.session_metrics_size());
|
|
EXPECT_EQ(kSessionId1,
|
|
actual_metrics.session_metrics(0).session_id().string_value());
|
|
EXPECT_EQ(kSessionId2,
|
|
actual_metrics.session_metrics(1).session_id().string_value());
|
|
EXPECT_EQ(1, actual_metrics.session_metrics(1).crypto_metrics()
|
|
.crypto_session_generic_decrypt_time_us_size());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessions) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
// Create one more session than the max allowed closed sessions.
|
|
std::vector<std::shared_ptr<SessionMetrics>> session_metrics;
|
|
for (int i = 0; i < kMaxCompletedSessions + 1; i++) {
|
|
session_metrics.push_back(engine_metrics.AddSession());
|
|
session_metrics.back()->SetSessionId(std::to_string(i));
|
|
}
|
|
|
|
// Mark sessions as completed.
|
|
for (auto it = session_metrics.begin(); it != session_metrics.end(); it++) {
|
|
(*it)->SetCompleted();
|
|
}
|
|
|
|
engine_metrics.ConsolidateSessions();
|
|
|
|
// Consolidate the metrics now. These should now be consolidated down to
|
|
// kMaxCompletedSessions.
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
ASSERT_EQ(kMaxCompletedSessions, actual_metrics.session_metrics_size());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessionsNoClosedSessions) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
// Create one more session than the max allowed closed sessions.
|
|
std::vector<std::shared_ptr<SessionMetrics>> session_metrics;
|
|
for (int i = 0; i < kMaxCompletedSessions + 1; i++) {
|
|
session_metrics.push_back(engine_metrics.AddSession());
|
|
session_metrics.back()->SetSessionId(std::to_string(i));
|
|
}
|
|
|
|
// Consolidate sessions will do nothing since no sessions are closed.
|
|
engine_metrics.ConsolidateSessions();
|
|
|
|
// Serializing now will include all sessions since none are closed.
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
ASSERT_EQ(kMaxCompletedSessions + 1, actual_metrics.session_metrics_size());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessionsNoSessions) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
// Consolidate sessions will do nothing since there are no sessions
|
|
engine_metrics.ConsolidateSessions();
|
|
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
ASSERT_EQ(0, actual_metrics.session_metrics_size());
|
|
}
|
|
|
|
class SessionMetricsTest : public ::testing::Test {
|
|
};
|
|
|
|
TEST_F(SessionMetricsTest, AllSessionMetrics) {
|
|
SessionMetrics session_metrics;
|
|
session_metrics.SetSessionId(kSessionId1);
|
|
session_metrics.cdm_session_life_span_.Record(1.0);
|
|
session_metrics.cdm_session_renew_key_.Record(1.0, NO_ERROR);
|
|
session_metrics.cdm_session_restore_offline_session_.Increment(
|
|
NO_ERROR, DeviceFiles::ResponseType::kObjectNotInitialized);
|
|
session_metrics.cdm_session_restore_usage_session_.Increment(
|
|
NO_ERROR, DeviceFiles::ResponseType::kObjectNotInitialized);
|
|
session_metrics.cdm_session_license_request_latency_ms_.Record(
|
|
2.0, kKeyRequestTypeInitial);
|
|
|
|
// Record a CryptoMetrics metric in the session.
|
|
session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_
|
|
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
|
|
|
|
WvCdmMetrics::SessionMetrics actual_metrics;
|
|
session_metrics.Serialize(&actual_metrics);
|
|
|
|
// Spot check metrics.
|
|
EXPECT_STREQ(kSessionId1,
|
|
actual_metrics.session_id().string_value().c_str());
|
|
EXPECT_EQ(1.0, actual_metrics.cdm_session_life_span_ms().double_value());
|
|
EXPECT_EQ(1, actual_metrics.cdm_session_renew_key_time_us_size());
|
|
EXPECT_EQ(1, actual_metrics.cdm_session_restore_offline_session_size());
|
|
EXPECT_EQ(1, actual_metrics.cdm_session_restore_usage_session_size());
|
|
EXPECT_EQ(1, actual_metrics.crypto_metrics()
|
|
.crypto_session_generic_decrypt_time_us_size());
|
|
}
|
|
|
|
TEST_F(SessionMetricsTest, EmptySessionMetrics) {
|
|
SessionMetrics session_metrics;
|
|
|
|
WvCdmMetrics::SessionMetrics actual_metrics;
|
|
session_metrics.Serialize(&actual_metrics);
|
|
|
|
EXPECT_TRUE(actual_metrics.has_crypto_metrics());
|
|
EXPECT_FALSE(actual_metrics.has_session_id());
|
|
EXPECT_FALSE(actual_metrics.has_cdm_session_life_span_ms());
|
|
EXPECT_EQ(0, actual_metrics.cdm_session_renew_key_time_us_size());
|
|
EXPECT_EQ(0, actual_metrics.cdm_session_restore_offline_session_size());
|
|
EXPECT_EQ(0, actual_metrics.cdm_session_restore_usage_session_size());
|
|
}
|
|
|
|
class CryptoMetricsTest : public ::testing::Test {
|
|
};
|
|
|
|
TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
|
|
CryptoMetrics crypto_metrics;
|
|
|
|
// Crypto session metrics.
|
|
crypto_metrics.crypto_session_delete_all_usage_reports_.Increment(NO_ERROR);
|
|
crypto_metrics.crypto_session_delete_multiple_usage_information_
|
|
.Increment(NO_ERROR);
|
|
crypto_metrics.crypto_session_generic_decrypt_
|
|
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
|
|
crypto_metrics.crypto_session_generic_encrypt_
|
|
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
|
|
crypto_metrics.crypto_session_generic_sign_
|
|
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
|
|
crypto_metrics.crypto_session_generic_verify_
|
|
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
|
|
crypto_metrics.crypto_session_get_device_unique_id_.Increment(NO_ERROR);
|
|
crypto_metrics.crypto_session_get_token_.Increment(NO_ERROR);
|
|
crypto_metrics.crypto_session_life_span_.Record(1.0);
|
|
crypto_metrics.crypto_session_load_certificate_private_key_
|
|
.Record(1.0, NO_ERROR);
|
|
crypto_metrics.crypto_session_open_.Record(1.0, NO_ERROR, kLevelDefault);
|
|
crypto_metrics.crypto_session_update_usage_information_
|
|
.Record(1.0, NO_ERROR);
|
|
crypto_metrics.crypto_session_usage_information_support_.Record(true);
|
|
crypto_metrics.crypto_session_security_level_.Record(kSecurityLevelL2);
|
|
|
|
// Oem crypto metrics.
|
|
crypto_metrics.oemcrypto_api_version_.Record(123);
|
|
crypto_metrics.oemcrypto_close_session_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_copy_buffer_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_deactivate_usage_entry_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_decrypt_cenc_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_delete_usage_entry_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_delete_usage_table_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_derive_keys_from_session_key_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_force_delete_usage_entry_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_generate_derived_keys_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_generate_nonce_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_generate_rsa_signature_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generate_signature_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generic_decrypt_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generic_encrypt_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generic_sign_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generic_verify_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_get_device_id_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_get_key_data_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_max_number_of_sessions_.Record(7);
|
|
crypto_metrics.oemcrypto_number_of_open_sessions_.Record(5);
|
|
crypto_metrics.oemcrypto_get_oem_public_certificate_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_provisioning_method_.Record(OEMCrypto_Keybox);
|
|
crypto_metrics.oemcrypto_get_random_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_initialize_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_is_anti_rollback_hw_present_.Record(true);
|
|
crypto_metrics.oemcrypto_is_keybox_valid_.Record(true);
|
|
crypto_metrics.oemcrypto_load_device_rsa_key_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_load_keys_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_refresh_keys_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_report_usage_.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_rewrap_device_rsa_key_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_rewrap_device_rsa_key_30_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_security_patch_level_.Record(123);
|
|
crypto_metrics.oemcrypto_select_key_
|
|
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_update_usage_table_
|
|
.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
|
|
WvCdmMetrics::CryptoMetrics actual_metrics;
|
|
crypto_metrics.Serialize(&actual_metrics);
|
|
|
|
// Spot check some metrics.
|
|
EXPECT_EQ(1, actual_metrics.crypto_session_delete_all_usage_reports_size());
|
|
EXPECT_EQ(1, actual_metrics.crypto_session_delete_all_usage_reports_size());
|
|
EXPECT_EQ(123, actual_metrics.oemcrypto_api_version().int_value());
|
|
EXPECT_EQ(1, actual_metrics.oemcrypto_generic_sign_time_us_size());
|
|
}
|
|
|
|
} // namespace metrics
|
|
} // namespace wvcdm
|