src/lib/privacy/private_index_decoding_test.cc

#include "src/lib/privacy/private_index_decoding.h"

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "src/logger/event_vector_index.h"

namespace cobalt {
namespace {

const int64_t kMinValue = -10;
const int64_t kMaxValue = 50;
const uint64_t kMaxCount = 100;
const uint64_t kNumIndexPoints = 5;

}  // namespace

class PrivateIndexDecodingTest : public testing::Test {
 protected:
  void SetUp() override { PrepareMetricDimensions(); }

  void PrepareMetricDimensions() {
    auto dimension = metric_dimensions_.Add();
    dimension->set_dimension("dimension_consecutive");
    (*dimension->mutable_event_codes())[0] = "dim_0";
    (*dimension->mutable_event_codes())[1] = "dim_1";
    (*dimension->mutable_event_codes())[2] = "dim_2";

    dimension = metric_dimensions_.Add();
    dimension->set_dimension("dimension_non_consecutive");
    (*dimension->mutable_event_codes())[0] = "dim_0";
    (*dimension->mutable_event_codes())[100] = "dim_1";
    (*dimension->mutable_event_codes())[200] = "dim_2";
    (*dimension->mutable_event_codes())[300] = "dim_3";

    dimension = metric_dimensions_.Add();
    dimension->set_dimension("dimension_max_event_code");
    dimension->set_max_event_code(10);
    (*dimension->mutable_event_codes())[1] = "dim_0";
    (*dimension->mutable_event_codes())[2] = "dim_1";
  }

  uint64_t MaxEventVectorIndex() { return logger::GetNumEventVectors(metric_dimensions_) - 1; }

  uint64_t MaxIndexForIntegerValue() {
    return logger::GetNumEventVectors(metric_dimensions_) * kNumIndexPoints - 1;
  }

  uint64_t MinIndexForCount() { return MaxIndexForIntegerValue() + 1; }

  uint64_t MaxIndexForCount() { return 2 * MinIndexForCount() - 1; }

  google::protobuf::RepeatedPtrField<MetricDefinition::MetricDimension> metric_dimensions_;
};

TEST_F(PrivateIndexDecodingTest, DecodeAsEventVectorValid) {
  std::vector<uint32_t> event_vector;
  // Check that the minimum private index is decoded correctly.
  util::Status status = DecodePrivateIndexAsEventVector(0, metric_dimensions_, &event_vector);
  ASSERT_TRUE(status.ok());
  EXPECT_EQ(event_vector, std::vector<uint32_t>({0, 0, 0}));

  // Check that the maximum private index is decoded correctly.
  status =
      DecodePrivateIndexAsEventVector(MaxEventVectorIndex(), metric_dimensions_, &event_vector);
  ASSERT_TRUE(status.ok());
  EXPECT_EQ(event_vector, std::vector<uint32_t>({2, 300, 10}));
}

TEST_F(PrivateIndexDecodingTest, DecodeAsEventVectorInvalid) {
  std::vector<uint32_t> event_vector;
  util::Status status =
      DecodePrivateIndexAsEventVector(MaxEventVectorIndex() + 1, metric_dimensions_, &event_vector);
  EXPECT_FALSE(status.ok());
}

TEST_F(PrivateIndexDecodingTest, DecodeAsIntegerValid) {
  std::vector<uint32_t> event_vector;
  int64_t integer_value;
  // Check that the minimum private index is decoded correctly.
  util::Status status = DecodePrivateIndexAsInteger(0, metric_dimensions_, kMinValue, kMaxValue,
                                                    kNumIndexPoints, &event_vector, &integer_value);
  ASSERT_TRUE(status.ok());
  EXPECT_EQ(event_vector, std::vector<uint32_t>({0, 0, 0}));
  EXPECT_EQ(integer_value, kMinValue);

  // Check that the maximum private index is decoded correctly.
  status = DecodePrivateIndexAsInteger(MaxIndexForIntegerValue(), metric_dimensions_, kMinValue,
                                       kMaxValue, kNumIndexPoints, &event_vector, &integer_value);
  ASSERT_TRUE(status.ok());
  EXPECT_EQ(event_vector, std::vector<uint32_t>({2, 300, 10}));
  EXPECT_EQ(integer_value, kMaxValue);
}

TEST_F(PrivateIndexDecodingTest, DecodeAsIntegerInvalid) {
  std::vector<uint32_t> event_vector;
  int64_t integer_value;
  util::Status status =
      DecodePrivateIndexAsInteger(MaxIndexForIntegerValue() + 1, metric_dimensions_, kMinValue,
                                  kMaxValue, kNumIndexPoints, &event_vector, &integer_value);
  EXPECT_FALSE(status.ok());
}

TEST_F(PrivateIndexDecodingTest, DecodeAsSumOrCountValidSum) {
  std::vector<uint32_t> event_vector;
  SumOrCount sum_or_count;
  // Check that the minimum private index that corresponds to sum is decoded correctly.
  util::Status status =
      DecodePrivateIndexAsSumOrCount(0, metric_dimensions_, kMinValue, kMaxValue, kMaxCount,
                                     kNumIndexPoints, &event_vector, &sum_or_count);
  ASSERT_TRUE(status.ok());
  EXPECT_EQ(event_vector, std::vector<uint32_t>({0, 0, 0}));
  EXPECT_EQ(sum_or_count.type, SumOrCount::SUM);
  EXPECT_EQ(sum_or_count.sum, kMinValue);

  // Check that the maximum private index that corresponds to a sum is decoded correctly.
  status = DecodePrivateIndexAsSumOrCount(MaxIndexForIntegerValue(), metric_dimensions_, kMinValue,
                                          kMaxValue, kMaxCount, kNumIndexPoints, &event_vector,
                                          &sum_or_count);
  ASSERT_TRUE(status.ok());
  EXPECT_EQ(event_vector, std::vector<uint32_t>({2, 300, 10}));
  EXPECT_EQ(sum_or_count.type, SumOrCount::SUM);
  EXPECT_EQ(sum_or_count.sum, kMaxValue);
}

TEST_F(PrivateIndexDecodingTest, DecodeAsSumOrCountValidCount) {
  std::vector<uint32_t> event_vector;
  SumOrCount sum_or_count;
  // Check that the minimum private index that corresponds to a count is decoded correctly.
  util::Status status =
      DecodePrivateIndexAsSumOrCount(MinIndexForCount(), metric_dimensions_, kMinValue, kMaxValue,
                                     kMaxCount, kNumIndexPoints, &event_vector, &sum_or_count);
  ASSERT_TRUE(status.ok());
  EXPECT_EQ(event_vector, std::vector<uint32_t>({0, 0, 0}));
  EXPECT_EQ(sum_or_count.type, SumOrCount::COUNT);
  EXPECT_EQ(sum_or_count.count, 0u);

  // Check that the maximum private index that corresponds to a count is decoded correctly.
  status =
      DecodePrivateIndexAsSumOrCount(MaxIndexForCount(), metric_dimensions_, kMinValue, kMaxValue,
                                     kMaxCount, kNumIndexPoints, &event_vector, &sum_or_count);
  ASSERT_TRUE(status.ok());
  EXPECT_EQ(event_vector, std::vector<uint32_t>({2, 300, 10}));
  EXPECT_EQ(sum_or_count.type, SumOrCount::COUNT);
  EXPECT_EQ(sum_or_count.count, kMaxCount);
}

TEST_F(PrivateIndexDecodingTest, DecodeAsSumOrCountInvalid) {
  std::vector<uint32_t> event_vector;
  SumOrCount sum_or_count;

  util::Status status = DecodePrivateIndexAsSumOrCount(
      MaxIndexForCount() + 1, metric_dimensions_, kMinValue, kMaxValue, kMaxCount, kNumIndexPoints,
      &event_vector, &sum_or_count);
  EXPECT_FALSE(status.ok());
}

}  // namespace cobalt