opentelemetry-go/sdk/metric/metricdata/metricdatatest/assertion.go

// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

// Package metricdatatest provides testing functionality for use with the
// metricdata package.
package metricdatatest // import "go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"

import (
	"fmt"

	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/sdk/metric/metricdata"
)

// Datatypes are the concrete data-types the metricdata package provides.
type Datatypes interface {
	metricdata.DataPoint[float64] |
		metricdata.DataPoint[int64] |
		metricdata.Gauge[float64] |
		metricdata.Gauge[int64] |
		metricdata.Histogram[float64] |
		metricdata.Histogram[int64] |
		metricdata.HistogramDataPoint[float64] |
		metricdata.HistogramDataPoint[int64] |
		metricdata.Extrema[int64] |
		metricdata.Extrema[float64] |
		metricdata.Metrics |
		metricdata.ResourceMetrics |
		metricdata.ScopeMetrics |
		metricdata.Sum[float64] |
		metricdata.Sum[int64] |
		metricdata.Exemplar[float64] |
		metricdata.Exemplar[int64] |
		metricdata.ExponentialHistogram[float64] |
		metricdata.ExponentialHistogram[int64] |
		metricdata.ExponentialHistogramDataPoint[float64] |
		metricdata.ExponentialHistogramDataPoint[int64] |
		metricdata.ExponentialBucket |
		metricdata.Summary |
		metricdata.SummaryDataPoint |
		metricdata.QuantileValue

	// Interface types are not allowed in union types, therefore the
	// Aggregation and Value type from metricdata are not included here.
}

// TestingT is an interface that implements [testing.T], but without the
// private method of [testing.TB], so other testing packages can rely on it as
// well.
// The methods in this interface must match the [testing.TB] interface.
type TestingT interface {
	Helper()
	// DO NOT CHANGE: any modification will not be backwards compatible and
	// must never be done outside of a new major release.

	Error(...any)
	// DO NOT CHANGE: any modification will not be backwards compatible and
	// must never be done outside of a new major release.
}

type config struct {
	ignoreTimestamp bool
	ignoreExemplars bool
	ignoreValue     bool
}

func newConfig(opts []Option) config {
	var cfg config
	for _, opt := range opts {
		cfg = opt.apply(cfg)
	}
	return cfg
}

// Option allows for fine grain control over how AssertEqual operates.
type Option interface {
	apply(cfg config) config
}

type fnOption func(cfg config) config

func (fn fnOption) apply(cfg config) config {
	return fn(cfg)
}

// IgnoreTimestamp disables checking if timestamps are different.
func IgnoreTimestamp() Option {
	return fnOption(func(cfg config) config {
		cfg.ignoreTimestamp = true
		return cfg
	})
}

// IgnoreExemplars disables checking if Exemplars are different.
func IgnoreExemplars() Option {
	return fnOption(func(cfg config) config {
		cfg.ignoreExemplars = true
		return cfg
	})
}

// IgnoreValue disables checking if values are different. This can be
// useful for non-deterministic values, like measured durations.
//
// This will ignore the value and trace information for Exemplars;
// the buckets, zero count, scale, sum, max, min, and counts of
// ExponentialHistogramDataPoints; the buckets, sum, count, max,
// and min of HistogramDataPoints; the value of DataPoints.
func IgnoreValue() Option {
	return fnOption(func(cfg config) config {
		cfg.ignoreValue = true
		return cfg
	})
}

// AssertEqual asserts that the two concrete data-types from the metricdata
// package are equal.
func AssertEqual[T Datatypes](t TestingT, expected, actual T, opts ...Option) bool {
	t.Helper()

	cfg := newConfig(opts)

	// Generic types cannot be type asserted. Use an interface instead.
	aIface := any(actual)

	var r []string
	switch e := any(expected).(type) {
	case metricdata.Exemplar[int64]:
		r = equalExemplars(e, aIface.(metricdata.Exemplar[int64]), cfg)
	case metricdata.Exemplar[float64]:
		r = equalExemplars(e, aIface.(metricdata.Exemplar[float64]), cfg)
	case metricdata.DataPoint[int64]:
		r = equalDataPoints(e, aIface.(metricdata.DataPoint[int64]), cfg)
	case metricdata.DataPoint[float64]:
		r = equalDataPoints(e, aIface.(metricdata.DataPoint[float64]), cfg)
	case metricdata.Gauge[int64]:
		r = equalGauges(e, aIface.(metricdata.Gauge[int64]), cfg)
	case metricdata.Gauge[float64]:
		r = equalGauges(e, aIface.(metricdata.Gauge[float64]), cfg)
	case metricdata.Histogram[float64]:
		r = equalHistograms(e, aIface.(metricdata.Histogram[float64]), cfg)
	case metricdata.Histogram[int64]:
		r = equalHistograms(e, aIface.(metricdata.Histogram[int64]), cfg)
	case metricdata.HistogramDataPoint[float64]:
		r = equalHistogramDataPoints(e, aIface.(metricdata.HistogramDataPoint[float64]), cfg)
	case metricdata.HistogramDataPoint[int64]:
		r = equalHistogramDataPoints(e, aIface.(metricdata.HistogramDataPoint[int64]), cfg)
	case metricdata.Extrema[int64]:
		r = equalExtrema(e, aIface.(metricdata.Extrema[int64]), cfg)
	case metricdata.Extrema[float64]:
		r = equalExtrema(e, aIface.(metricdata.Extrema[float64]), cfg)
	case metricdata.Metrics:
		r = equalMetrics(e, aIface.(metricdata.Metrics), cfg)
	case metricdata.ResourceMetrics:
		r = equalResourceMetrics(e, aIface.(metricdata.ResourceMetrics), cfg)
	case metricdata.ScopeMetrics:
		r = equalScopeMetrics(e, aIface.(metricdata.ScopeMetrics), cfg)
	case metricdata.Sum[int64]:
		r = equalSums(e, aIface.(metricdata.Sum[int64]), cfg)
	case metricdata.Sum[float64]:
		r = equalSums(e, aIface.(metricdata.Sum[float64]), cfg)
	case metricdata.ExponentialHistogram[float64]:
		r = equalExponentialHistograms(e, aIface.(metricdata.ExponentialHistogram[float64]), cfg)
	case metricdata.ExponentialHistogram[int64]:
		r = equalExponentialHistograms(e, aIface.(metricdata.ExponentialHistogram[int64]), cfg)
	case metricdata.ExponentialHistogramDataPoint[float64]:
		r = equalExponentialHistogramDataPoints(e, aIface.(metricdata.ExponentialHistogramDataPoint[float64]), cfg)
	case metricdata.ExponentialHistogramDataPoint[int64]:
		r = equalExponentialHistogramDataPoints(e, aIface.(metricdata.ExponentialHistogramDataPoint[int64]), cfg)
	case metricdata.ExponentialBucket:
		r = equalExponentialBuckets(e, aIface.(metricdata.ExponentialBucket), cfg)
	case metricdata.Summary:
		r = equalSummary(e, aIface.(metricdata.Summary), cfg)
	case metricdata.SummaryDataPoint:
		r = equalSummaryDataPoint(e, aIface.(metricdata.SummaryDataPoint), cfg)
	case metricdata.QuantileValue:
		r = equalQuantileValue(e, aIface.(metricdata.QuantileValue), cfg)
	default:
		// We control all types passed to this, panic to signal developers
		// early they changed things in an incompatible way.
		panic(fmt.Sprintf("unknown types: %T", expected))
	}

	if len(r) > 0 {
		t.Error(r)
		return false
	}
	return true
}

// AssertAggregationsEqual asserts that two Aggregations are equal.
func AssertAggregationsEqual(t TestingT, expected, actual metricdata.Aggregation, opts ...Option) bool {
	t.Helper()

	cfg := newConfig(opts)
	if r := equalAggregations(expected, actual, cfg); len(r) > 0 {
		t.Error(r)
		return false
	}
	return true
}

// AssertHasAttributes asserts that all Datapoints or HistogramDataPoints have all passed attrs.
func AssertHasAttributes[T Datatypes](t TestingT, actual T, attrs ...attribute.KeyValue) bool {
	t.Helper()

	var reasons []string

	switch e := any(actual).(type) {
	case metricdata.Exemplar[int64]:
		reasons = hasAttributesExemplars(e, attrs...)
	case metricdata.Exemplar[float64]:
		reasons = hasAttributesExemplars(e, attrs...)
	case metricdata.DataPoint[int64]:
		reasons = hasAttributesDataPoints(e, attrs...)
	case metricdata.DataPoint[float64]:
		reasons = hasAttributesDataPoints(e, attrs...)
	case metricdata.Gauge[int64]:
		reasons = hasAttributesGauge(e, attrs...)
	case metricdata.Gauge[float64]:
		reasons = hasAttributesGauge(e, attrs...)
	case metricdata.Sum[int64]:
		reasons = hasAttributesSum(e, attrs...)
	case metricdata.Sum[float64]:
		reasons = hasAttributesSum(e, attrs...)
	case metricdata.HistogramDataPoint[int64]:
		reasons = hasAttributesHistogramDataPoints(e, attrs...)
	case metricdata.HistogramDataPoint[float64]:
		reasons = hasAttributesHistogramDataPoints(e, attrs...)
	case metricdata.Extrema[int64], metricdata.Extrema[float64]:
		// Nothing to check.
	case metricdata.Histogram[int64]:
		reasons = hasAttributesHistogram(e, attrs...)
	case metricdata.Histogram[float64]:
		reasons = hasAttributesHistogram(e, attrs...)
	case metricdata.Metrics:
		reasons = hasAttributesMetrics(e, attrs...)
	case metricdata.ScopeMetrics:
		reasons = hasAttributesScopeMetrics(e, attrs...)
	case metricdata.ResourceMetrics:
		reasons = hasAttributesResourceMetrics(e, attrs...)
	case metricdata.ExponentialHistogram[int64]:
		reasons = hasAttributesExponentialHistogram(e, attrs...)
	case metricdata.ExponentialHistogram[float64]:
		reasons = hasAttributesExponentialHistogram(e, attrs...)
	case metricdata.ExponentialHistogramDataPoint[int64]:
		reasons = hasAttributesExponentialHistogramDataPoints(e, attrs...)
	case metricdata.ExponentialHistogramDataPoint[float64]:
		reasons = hasAttributesExponentialHistogramDataPoints(e, attrs...)
	case metricdata.ExponentialBucket:
		// Nothing to check.
	case metricdata.Summary:
		reasons = hasAttributesSummary(e, attrs...)
	case metricdata.SummaryDataPoint:
		reasons = hasAttributesSummaryDataPoint(e, attrs...)
	case metricdata.QuantileValue:
		// Nothing to check.
	default:
		// We control all types passed to this, panic to signal developers
		// early they changed things in an incompatible way.
		panic(fmt.Sprintf("unknown types: %T", actual))
	}

	if len(reasons) > 0 {
		t.Error(reasons)
		return false
	}

	return true
}