Add a matcher for TimeSeries protos and add missing stackdriver_utils_test cases. (#26)

Author: isturdy

opencensus/exporters/stats/BUILD

@@ -18,7 +18,7 @@ load("//opencensus:copts.bzl", "DEFAULT_COPTS", "TEST_COPTS")
 
 licenses(["notice"])  # Apache License 2.0
 
-package(default_visibility = ["//visibility:private"])
+package(default_visibility = ["//opencensus/exporters/stats:__subpackages__"])
 
 # Public exporter libraries.
 
@@ -76,6 +76,21 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "test_utils",
+    testonly = 1,
+    srcs = ["internal/testing/time_series_matcher.cc"],
+    hdrs = ["internal/testing/time_series_matcher.h"],
+    deps = [
+        "//google/api:distribution",
+        "//google/api:metric",
+        "//google/monitoring/v3:common",
+        "//google/monitoring/v3:metric",
+        "//opencensus/stats",
+        "@com_google_googletest//:gtest",
+    ],
+)
+
 # Tests.
 # ========================================================================= #
 
@@ -85,9 +100,11 @@ cc_test(
     copts = TEST_COPTS,
     deps = [
         ":stackdriver_utils",
+        ":test_utils",
         "//google/api:distribution",
         "//google/api:label",
         "//google/api:metric",
+        "//google/monitoring/v3:common",
         "//google/monitoring/v3:metric",
         "//opencensus/stats",
         "//opencensus/stats:test_utils",

opencensus/exporters/stats/internal/stackdriver_utils_test.cc

@@ -26,9 +26,12 @@
 #include "google/monitoring/v3/common.pb.h"
 #include "google/protobuf/timestamp.pb.h"
 #include "gtest/gtest.h"
+#include "opencensus/exporters/stats/internal/testing/time_series_matcher.h"
 #include "opencensus/stats/stats.h"
 #include "opencensus/stats/testing/test_utils.h"
 
+using opencensus::stats::testing::TestUtils;
+
 namespace opencensus {
 namespace exporters {
 namespace stats {
@@ -142,7 +145,187 @@ TEST(StackdriverUtilsTest, SetMetricDescriptorDescription) {
   EXPECT_EQ(description, metric_descriptor.description());
 }
 
-// TODO: MakeTimeSeriesSumDouble
+TEST(StackdriverUtilsTest, MakeTimeSeriesSumDouble) {
+  const auto measure = opencensus::stats::MeasureRegistry::RegisterDouble(
+      "measure_sum_double", "", "");
+  const std::string task = "test_task";
+  const std::string view_name = "test_view";
+  const std::string tag_key_1 = "foo";
+  const std::string tag_key_2 = "bar";
+  const auto view_descriptor =
+      opencensus::stats::ViewDescriptor()
+          .set_name(view_name)
+          .set_measure(measure.GetDescriptor().name())
+          .set_aggregation(opencensus::stats::Aggregation::Sum())
+          .set_aggregation_window(
+              opencensus::stats::AggregationWindow::Cumulative())
+          .add_column(tag_key_1)
+          .add_column(tag_key_2);
+  const opencensus::stats::ViewData data = TestUtils::MakeViewData(
+      view_descriptor, {{{"v1", "v1"}, 1.0}, {{"v1", "v2"}, 2.0}});
+  const std::vector<google::monitoring::v3::TimeSeries> time_series =
+      MakeTimeSeries(view_descriptor, data, task);
+
+  for (const auto& ts : time_series) {
+    EXPECT_EQ("custom.googleapis.com/opencensus/test_view", ts.metric().type());
+    EXPECT_EQ("global", ts.resource().type());
+    ASSERT_EQ(1, ts.points_size());
+    EXPECT_EQ(absl::ToUnixSeconds(data.start_time()),
+              ts.points(0).interval().start_time().seconds());
+    EXPECT_EQ(absl::ToUnixSeconds(data.end_time()),
+              ts.points(0).interval().end_time().seconds());
+  }
+
+  EXPECT_THAT(
+      time_series,
+      ::testing::UnorderedElementsAre(
+          testing::TimeSeriesDouble(
+              {{"opencensus_task", task}, {tag_key_1, "v1"}, {tag_key_2, "v1"}},
+              1.0),
+          testing::TimeSeriesDouble(
+              {{"opencensus_task", task}, {tag_key_1, "v1"}, {tag_key_2, "v2"}},
+              2.0)));
+}
+
+TEST(StackdriverUtilsTest, MakeTimeSeriesSumInt) {
+  const auto measure = opencensus::stats::MeasureRegistry::RegisterInt(
+      "measure_sum_int", "", "");
+  const std::string task = "test_task";
+  const std::string view_name = "test_descriptor";
+  const std::string tag_key_1 = "foo";
+  const std::string tag_key_2 = "bar";
+  const auto view_descriptor =
+      opencensus::stats::ViewDescriptor()
+          .set_name(view_name)
+          .set_measure(measure.GetDescriptor().name())
+          .set_aggregation(opencensus::stats::Aggregation::Sum())
+          .set_aggregation_window(
+              opencensus::stats::AggregationWindow::Cumulative())
+          .add_column(tag_key_1)
+          .add_column(tag_key_2);
+  const opencensus::stats::ViewData data = TestUtils::MakeViewData(
+      view_descriptor, {{{"v1", "v1"}, 1.0}, {{"v1", "v2"}, 2.0}});
+  const std::vector<google::monitoring::v3::TimeSeries> time_series =
+      MakeTimeSeries(view_descriptor, data, task);
+
+  for (const auto& ts : time_series) {
+    EXPECT_EQ(absl::StrCat("custom.googleapis.com/opencensus/", view_name),
+              ts.metric().type());
+    EXPECT_EQ("global", ts.resource().type());
+    ASSERT_EQ(1, ts.points_size());
+    EXPECT_EQ(absl::ToUnixSeconds(data.start_time()),
+              ts.points(0).interval().start_time().seconds());
+    EXPECT_EQ(absl::ToUnixSeconds(data.end_time()),
+              ts.points(0).interval().end_time().seconds());
+  }
+
+  EXPECT_THAT(
+      time_series,
+      ::testing::UnorderedElementsAre(
+          testing::TimeSeriesInt(
+              {{"opencensus_task", task}, {tag_key_1, "v1"}, {tag_key_2, "v1"}},
+              1),
+          testing::TimeSeriesInt(
+              {{"opencensus_task", task}, {tag_key_1, "v1"}, {tag_key_2, "v2"}},
+              2)));
+}
+
+TEST(StackdriverUtilsTest, MakeTimeSeriesCountDouble) {
+  const auto measure = opencensus::stats::MeasureRegistry::RegisterDouble(
+      "measure_count_double", "", "");
+  const std::string task = "test_task";
+  const std::string view_name = "test_descriptor";
+  const std::string tag_key_1 = "foo";
+  const std::string tag_key_2 = "bar";
+  const auto view_descriptor =
+      opencensus::stats::ViewDescriptor()
+          .set_name(view_name)
+          .set_measure(measure.GetDescriptor().name())
+          .set_aggregation(opencensus::stats::Aggregation::Count())
+          .set_aggregation_window(
+              opencensus::stats::AggregationWindow::Cumulative())
+          .add_column(tag_key_1)
+          .add_column(tag_key_2);
+  const opencensus::stats::ViewData data = TestUtils::MakeViewData(
+      view_descriptor,
+      {{{"v1", "v1"}, 1.0}, {{"v1", "v1"}, 3.0}, {{"v1", "v2"}, 2.0}});
+  const std::vector<google::monitoring::v3::TimeSeries> time_series =
+      MakeTimeSeries(view_descriptor, data, task);
+
+  for (const auto& ts : time_series) {
+    EXPECT_EQ(absl::StrCat("custom.googleapis.com/opencensus/", view_name),
+              ts.metric().type());
+    EXPECT_EQ("global", ts.resource().type());
+    ASSERT_EQ(1, ts.points_size());
+    EXPECT_EQ(absl::ToUnixSeconds(data.start_time()),
+              ts.points(0).interval().start_time().seconds());
+    EXPECT_EQ(absl::ToUnixSeconds(data.end_time()),
+              ts.points(0).interval().end_time().seconds());
+  }
+
+  EXPECT_THAT(
+      time_series,
+      ::testing::UnorderedElementsAre(
+          testing::TimeSeriesInt(
+              {{"opencensus_task", task}, {tag_key_1, "v1"}, {tag_key_2, "v1"}},
+              2),
+          testing::TimeSeriesInt(
+              {{"opencensus_task", task}, {tag_key_1, "v1"}, {tag_key_2, "v2"}},
+              1)));
+}
+
+TEST(StackdriverUtilsTest, MakeTimeSeriesDistributionDouble) {
+  const auto measure = opencensus::stats::MeasureRegistry::RegisterDouble(
+      "measure_distribution_double", "", "");
+  const std::string task = "test_task";
+  const std::string view_name = "test_view";
+  const std::string tag_key_1 = "foo";
+  const std::string tag_key_2 = "bar";
+  const auto bucket_boundaries =
+      opencensus::stats::BucketBoundaries::Explicit({0});
+  const auto view_descriptor =
+      opencensus::stats::ViewDescriptor()
+          .set_name(view_name)
+          .set_measure(measure.GetDescriptor().name())
+          .set_aggregation(
+              opencensus::stats::Aggregation::Distribution(bucket_boundaries))
+          .set_aggregation_window(
+              opencensus::stats::AggregationWindow::Cumulative())
+          .add_column(tag_key_1)
+          .add_column(tag_key_2);
+  const opencensus::stats::ViewData data = TestUtils::MakeViewData(
+      view_descriptor,
+      {{{"v1", "v1"}, -1.0}, {{"v1", "v1"}, 7.0}, {{"v1", "v2"}, 1.0}});
+  const std::vector<google::monitoring::v3::TimeSeries> time_series =
+      MakeTimeSeries(view_descriptor, data, task);
+
+  for (const auto& ts : time_series) {
+    EXPECT_EQ("custom.googleapis.com/opencensus/test_view", ts.metric().type());
+    EXPECT_EQ("global", ts.resource().type());
+    ASSERT_EQ(1, ts.points_size());
+    EXPECT_EQ(absl::ToUnixSeconds(data.start_time()),
+              ts.points(0).interval().start_time().seconds());
+    EXPECT_EQ(absl::ToUnixSeconds(data.end_time()),
+              ts.points(0).interval().end_time().seconds());
+  }
+
+  auto distribution1 = TestUtils::MakeDistribution(&bucket_boundaries);
+  TestUtils::AddToDistribution(&distribution1, -1.0);
+  TestUtils::AddToDistribution(&distribution1, 7.0);
+
+  auto distribution2 = TestUtils::MakeDistribution(&bucket_boundaries);
+  TestUtils::AddToDistribution(&distribution2, 1.0);
+
+  EXPECT_THAT(
+      time_series,
+      ::testing::UnorderedElementsAre(
+          testing::TimeSeriesDistribution(
+              {{"opencensus_task", task}, {tag_key_1, "v1"}, {tag_key_2, "v1"}},
+              distribution1),
+          testing::TimeSeriesDistribution(
+              {{"opencensus_task", task}, {tag_key_1, "v1"}, {tag_key_2, "v2"}},
+              distribution2)));
+}
 
 }  // namespace
 }  // namespace stats

opencensus/exporters/stats/internal/testing/time_series_matcher.cc

@@ -0,0 +1,149 @@
+// Copyright 2018, OpenCensus Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "opencensus/exporters/stats/internal/testing/time_series_matcher.h"
+
+#include <cstdint>
+#include <map>
+#include <string>
+
+#include "gmock/gmock.h"
+#include "google/api/distribution.pb.h"
+#include "google/api/metric.pb.h"
+#include "google/monitoring/v3/common.pb.h"
+#include "google/monitoring/v3/metric.pb.h"
+#include "opencensus/stats/stats.h"
+
+namespace opencensus {
+namespace exporters {
+namespace stats {
+namespace testing {
+
+bool TimeSeriesMatcher::MatchAndExplain(
+    google::monitoring::v3::TimeSeries time_series,
+    ::testing::MatchResultListener* listener) const {
+  // Check labels.
+  const auto& labels = time_series.metric().labels();
+  for (const auto& label : labels) {
+    if (tags_.find(label.first) == tags_.end()) {
+      *listener << "has an extra label \"" << label.first << "\"";
+      return false;
+    }
+  }
+  for (const auto& tag : tags_) {
+    const auto& label = labels.find(tag.first);
+    if (label == labels.end()) {
+      *listener << "is missing the label \"" << tag.first << "\"";
+      return false;
+    }
+    if (absl::string_view(label->second) != tag.second) {
+      *listener << "has the wrong value for the label \"" << tag.first
+                << "\": actual \"" << label->second << "\"";
+      return false;
+    }
+  }
+
+  // Check data.
+  if (time_series.points_size() != 1) {
+    *listener << "has " << time_series.points_size() << " points; expected 1";
+    return false;
+  }
+  const auto& point = time_series.points(0);
+  switch (type_) {
+    case Type::kDouble: {
+      // Note that proto3 does not allow distinguishing between default and
+      // unset oneof cases.
+      if (point.value().double_value() != double_value_) {
+        *listener << "value is " << point.value().double_value()
+                  << "; expected " << double_value_;
+        return false;
+      }
+      return true;
+    }
+    case Type::kInt64: {
+      if (point.value().int64_value() != int_value_) {
+        *listener << "value is " << point.value().int64_value() << "; expected "
+                  << int_value_;
+        return false;
+      }
+      return true;
+    }
+    case Type::kDistribution: {
+      const auto& distribution = point.value().distribution_value();
+      if (distribution.count() != distribution_value_.count()) {
+        *listener << "count is " << distribution.count() << "; expected "
+                  << distribution_value_.count();
+        return false;
+      }
+      if (distribution.mean() != distribution_value_.mean()) {
+        *listener << "mean is " << distribution.mean() << "; expected "
+                  << distribution_value_.mean();
+        return false;
+      }
+      if (distribution.sum_of_squared_deviation() !=
+          distribution_value_.sum_of_squared_deviation()) {
+        *listener << "sum_of_squared_deviation is "
+                  << distribution.sum_of_squared_deviation() << "; expected "
+                  << distribution_value_.sum_of_squared_deviation();
+        return false;
+      }
+      const auto& buckets = distribution.bucket_options().explicit_buckets();
+      if (buckets.bounds_size() !=
+          distribution_value_.bucket_boundaries().lower_boundaries().size()) {
+        *listener << "has " << buckets.bounds_size() << " buckets; expected "
+                  << distribution_value_.bucket_boundaries()
+                         .lower_boundaries()
+                         .size();
+        return false;
+      }
+      for (int i = 0; i < buckets.bounds_size(); ++i) {
+        if (buckets.bounds(i) !=
+            distribution_value_.bucket_boundaries().lower_boundaries()[i]) {
+          *listener << "has the wrong boundaries";
+          return false;
+        }
+        if (distribution.bucket_counts(i) !=
+            distribution_value_.bucket_counts()[i]) {
+          *listener << "has " << distribution.bucket_counts(i)
+                    << "values in the " << i << "th bucket; expected "
+                    << distribution_value_.bucket_counts()[i];
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+
+void TimeSeriesMatcher::DescribeTo(::std::ostream* os) const {
+  switch (type_) {
+    case Type::kDouble: {
+      *os << double_value_;
+      break;
+    }
+    case Type::kInt64: {
+      *os << int_value_;
+      break;
+    }
+    case Type::kDistribution: {
+      *os << distribution_value_.DebugString();
+      break;
+    }
+  }
+}
+
+}  // namespace testing
+}  // namespace stats
+}  // namespace exporters
+}  // namespace opencensus