external-dns/endpoint/endpoint_benchmark_test.go

/*
Copyright 2026 The Kubernetes 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.
*/

package endpoint

import (
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"
)

var (
	providerSpecificKeys = []string{
		"alias",
		"provider/target-hosted-zone",
		"provider/evaluate-target-health",
		"provider/weight",
		"provider/region",
		"provider/failover",
		"provider/geolocation-continent-code",
		"provider/geolocation-country-code",
		"provider/geolocation-subdivision-code",
		"provider/geoproximity-region",
		"provider/geoproximity-bias",
		"provider/geoproximity-coordinates",
		"provider/geoproximity-local-zone-group",
		"provider/multi-value-answer",
		"provider/health-check-id",
		"same-zone",
	}
)

// TestEndpointGeneration validates that generateBenchmarkEndpoints
// creates correct data for both slice implementations.
func TestEndpointGeneration(t *testing.T) {
	for _, setProps := range []int{0, 1, 3, 5, 16} {
		t.Run(fmt.Sprintf("set=%d", setProps), func(t *testing.T) {
			endpoints := generateBenchmarkEndpoints(10, setProps)
			assert.Len(t, endpoints, 10)
			for _, ep := range endpoints {
				assert.Len(t, ep.ProviderSpecific, setProps)
			}
		})
	}
}

// BenchmarkProviderSpecificRealisticAccess simulates realistic provider behavior:
// The provider checks ALL its supported properties on each endpoint,
// even though only a few (setProps) are actually configured.
func BenchmarkProviderSpecificRandomAccess(b *testing.B) {
	// setProps: how many properties are actually set on the endpoint
	// The provider will still check all 16 keys
	setPropsOptions := []int{0, 1, 5, 9, 16}
	endpointCounts := []int{100, 1000, 10000, 50000, 100000, 200000}

	keys := []string{
		"provider/weight",
		"nonexistent",
		"provider/geoproximity-region",
		"same-zone",
	}

	for _, setProps := range setPropsOptions {
		for _, epCount := range endpointCounts {
			endpoints := generateBenchmarkEndpoints(epCount, setProps)
			b.Run(fmt.Sprintf("slice/set=%d/endpoints=%d", setProps, epCount), func(b *testing.B) {
				for b.Loop() {
					for _, ep := range endpoints {
						// Provider checks random supported properties
						for _, key := range keys {
							ep.GetProviderSpecificProperty(key)
						}
					}
				}
			})
		}
	}
}

func BenchmarkProviderSpecificDelete(b *testing.B) {
	propertyCounts := []int{0, 5, 10}
	endpointCounts := []int{100, 300, 1000, 10000, 50000}

	keys := []string{
		"provider/weight",
		"nonexistent",
	}

	for _, propCount := range propertyCounts {
		for _, epCount := range endpointCounts {
			b.Run(fmt.Sprintf("slice/props=%d/endpoints=%d", propCount, epCount), func(b *testing.B) {
				template := generateBenchmarkEndpoints(epCount, propCount)
				b.ResetTimer()
				for b.Loop() {
					// Shallow copy is enough if we only care about the slice structure
					endpoints := make([]*Endpoint, len(template))
					copy(endpoints, template)
					for _, ep := range endpoints {
						for _, key := range keys {
							ep.DeleteProviderSpecificProperty(key)
						}
					}
				}
			})
		}
	}
}

// generateBenchmarkEndpoints creates endpoints with realistic AWS provider-specific properties.
// setPropsCount determines how many of the providerSpecificKeys are actually set on each endpoint.
func generateBenchmarkEndpoints(count, setPropsCount int) []*Endpoint {
	endpoints := make([]*Endpoint, count)
	for i := range count {
		ep := &Endpoint{
			DNSName:    fmt.Sprintf("endpoint-%d.example.com", i),
			RecordType: RecordTypeA,
			Targets:    Targets{fmt.Sprintf("192.0.2.%d", i%256)},
			RecordTTL:  TTL(300),
			Labels:     NewLabels(),
		}

		// Set only the first setPropsCount properties
		if setPropsCount > 0 {
			ep.ProviderSpecific = make(ProviderSpecific, setPropsCount)
			for j := range setPropsCount {
				key := providerSpecificKeys[j%len(providerSpecificKeys)]
				ep.ProviderSpecific[j] = ProviderSpecificProperty{
					Name:  key,
					Value: fmt.Sprintf("value-%d", j),
				}
			}
		}

		endpoints[i] = ep
	}
	return endpoints
}