Add monitoring/metrics/contrib package to Nomulus release

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=150007228

java/google/registry/monitoring/metrics/contrib/AbstractMetricSubject.java

@@ -0,0 +1,210 @@
+// Copyright 2017 The Nomulus Authors. All Rights Reserved.
+//
+// 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.
+
+package google.registry.monitoring.metrics.contrib;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Function;
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Ordering;
+import com.google.common.truth.FailureStrategy;
+import com.google.common.truth.Subject;
+import google.registry.monitoring.metrics.Metric;
+import google.registry.monitoring.metrics.MetricPoint;
+import java.util.HashSet;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+/**
+ * Base truth subject for asserting things about {@link Metric} instances.
+ *
+ * <p>For use with the Google <a href="https://google.github.io/truth/">Truth</a> framework.
+ */
+abstract class AbstractMetricSubject<
+        T, M extends Metric<T>, S extends AbstractMetricSubject<T, M, S>>
+    extends Subject<S, M> {
+
+  /** And chainer to allow fluent assertions. */
+  public static class And<S extends AbstractMetricSubject<?, ?, S>> {
+
+    private final S subject;
+
+    And(S subject) {
+      this.subject = subject;
+    }
+
+    public S and() {
+      return subject;
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  And<S> andChainer() {
+    return new And<>((S) this);
+  }
+
+  /** List of label value tuples about which an assertion has been made so far.
+   *
+   * <p>Used to track what tuples have been seen, in order to support hasNoOtherValues() assertions.
+   */
+  protected final Set<ImmutableList<String>> expectedNondefaultLabelTuples = new HashSet<>();
+
+  /**
+   * Function to convert a metric point to a nice string representation for use in error messages.
+   */
+  protected final Function<MetricPoint<T>, String> metricPointConverter =
+      new Function<MetricPoint<T>, String>() {
+        @Override
+        public String apply(MetricPoint<T> metricPoint) {
+          return String.format(
+              "%s => %s",
+              Joiner.on(':').join(metricPoint.labelValues()),
+              getMessageRepresentation(metricPoint.value()));
+        }
+      };
+
+  protected AbstractMetricSubject(FailureStrategy strategy, M actual) {
+    super(strategy, checkNotNull(actual));
+  }
+
+  /**
+   * Returns the string representation of the subject.
+   *
+   * <p>For metrics, it makes sense to use the metric name, as given in the schema.
+   */
+  @Override
+  public String actualCustomStringRepresentation() {
+    return actual().getMetricSchema().name();
+  }
+
+  /**
+   * Asserts that the metric has a given value for the specified label values.
+   *
+   * @param value the value which the metric should have
+   * @param labels the labels for which the value is being asserted; the number and order of labels
+   *     should match the definition of the metric
+   */
+  public And<S> hasValueForLabels(T value, String... labels) {
+    MetricPoint<T> metricPoint = findMetricPointForLabels(ImmutableList.copyOf(labels));
+    if (metricPoint == null) {
+      failWithBadResults(
+          "has a value for labels",
+          Joiner.on(':').join(labels),
+          "has labeled values",
+          Lists.transform(
+              Ordering.<MetricPoint<T>>natural().sortedCopy(actual().getTimestampedValues()),
+              metricPointConverter));
+    }
+    if (!metricPoint.value().equals(value)) {
+      failWithBadResults(
+          String.format("has a value of %s for labels", value),
+          Joiner.on(':').join(labels),
+          "has a value of",
+          getMessageRepresentation(metricPoint.value()));
+    }
+    expectedNondefaultLabelTuples.add(ImmutableList.copyOf(labels));
+    return andChainer();
+  }
+
+  /**
+   * Asserts that the metric has any (non-default) value for the specified label values.
+   *
+   * @param labels the labels for which the value is being asserted; the number and order of labels
+   *     should match the definition of the metric
+   */
+  public And<S> hasAnyValueForLabels(String... labels) {
+    MetricPoint<T> metricPoint = findMetricPointForLabels(ImmutableList.copyOf(labels));
+    if (metricPoint == null) {
+      failWithBadResults(
+          "has a value for labels",
+          Joiner.on(':').join(labels),
+          "has labeled values",
+          Lists.transform(
+              Ordering.<MetricPoint<T>>natural().sortedCopy(actual().getTimestampedValues()),
+              metricPointConverter));
+    }
+    if (hasDefaultValue(metricPoint)) {
+      failWithBadResults(
+          "has a non-default value for labels",
+          Joiner.on(':').join(labels),
+          "has a value of",
+          getMessageRepresentation(metricPoint.value()));
+    }
+    expectedNondefaultLabelTuples.add(ImmutableList.copyOf(labels));
+    return andChainer();
+  }
+
+  /**
+   * Asserts that the metric does not have a (non-default) value for the specified label values.
+   */
+  protected And<S> doesNotHaveAnyValueForLabels(String... labels) {
+    MetricPoint<T> metricPoint = findMetricPointForLabels(ImmutableList.copyOf(labels));
+    if (metricPoint != null) {
+      failWithBadResults(
+          "has no value for labels",
+          Joiner.on(':').join(labels),
+          "has a value of",
+          getMessageRepresentation(metricPoint.value()));
+    }
+    return andChainer();
+  }
+
+  /**
+   * Asserts that the metric has no (non-default) values other than those about which an assertion
+   * has already been made.
+   */
+  public And<S> hasNoOtherValues() {
+    for (MetricPoint<T> metricPoint : actual().getTimestampedValues()) {
+      if (!expectedNondefaultLabelTuples.contains(metricPoint.labelValues())) {
+        if (!hasDefaultValue(metricPoint)) {
+          failWithBadResults(
+              "has",
+              "no other nondefault values",
+              "has labeled values",
+              Lists.transform(
+                  Ordering.<MetricPoint<T>>natural().sortedCopy(actual().getTimestampedValues()),
+                  metricPointConverter));
+        }
+        return andChainer();
+      }
+    }
+    return andChainer();
+  }
+
+  private @Nullable MetricPoint<T> findMetricPointForLabels(ImmutableList<String> labels) {
+    if (actual().getMetricSchema().labels().size() != labels.size()) {
+      return null;
+    }
+    for (MetricPoint<T> metricPoint : actual().getTimestampedValues()) {
+      if (metricPoint.labelValues().equals(labels)) {
+        return metricPoint;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Returns true if the metric point has a non-default value.
+   *
+   * <p>This should be overridden by subclasses. E.g. for incrementable metrics, the method should
+   * return true if the value is not zero, and so on.
+   */
+  protected abstract boolean hasDefaultValue(MetricPoint<T> metricPoint);
+
+  /** Returns a string representation of a metric point value, for use in error messages. */
+  protected abstract String getMessageRepresentation(T value);
+}