8c6ccdd1ab
* fix: use dsIndexProvider cache on migrations * chore: use same comment as before * feat: org-aware TTL cache for schemaversion migration and warmup for single tenant * chore: use LRU cache * chore: change DefaultCacheTTL to 1 minute * chore: address copilot reviews * chore: use expirable cache * chore: remove unused import
1255 lines
44 KiB
Go
1255 lines
44 KiB
Go
package conversion
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
"github.com/stretchr/testify/require"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/apimachinery/pkg/conversion"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/runtime/schema"
|
|
|
|
"github.com/grafana/grafana/apps/dashboard/pkg/apis"
|
|
dashv0 "github.com/grafana/grafana/apps/dashboard/pkg/apis/dashboard/v0alpha1"
|
|
dashv1 "github.com/grafana/grafana/apps/dashboard/pkg/apis/dashboard/v1beta1"
|
|
dashv2alpha1 "github.com/grafana/grafana/apps/dashboard/pkg/apis/dashboard/v2alpha1"
|
|
dashv2beta1 "github.com/grafana/grafana/apps/dashboard/pkg/apis/dashboard/v2beta1"
|
|
"github.com/grafana/grafana/apps/dashboard/pkg/migration"
|
|
"github.com/grafana/grafana/apps/dashboard/pkg/migration/schemaversion"
|
|
migrationtestutil "github.com/grafana/grafana/apps/dashboard/pkg/migration/testutil"
|
|
common "github.com/grafana/grafana/pkg/apimachinery/apis/common/v0alpha1"
|
|
"github.com/grafana/grafana/pkg/apimachinery/utils"
|
|
)
|
|
|
|
func TestConversionMatrixExist(t *testing.T) {
|
|
// Initialize the migrator with a test data source provider
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
// Use TestLibraryElementProvider for tests that need library panel models with repeat options
|
|
leProvider := migrationtestutil.NewTestLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
versions := []metav1.Object{
|
|
&dashv0.Dashboard{Spec: common.Unstructured{Object: map[string]any{"title": "dashboardV0"}}},
|
|
&dashv1.Dashboard{Spec: common.Unstructured{Object: map[string]any{"title": "dashboardV1"}}},
|
|
&dashv2alpha1.Dashboard{Spec: dashv2alpha1.DashboardSpec{Title: "dashboardV2alpha1"}},
|
|
&dashv2beta1.Dashboard{Spec: dashv2beta1.DashboardSpec{Title: "dashboardV2beta1"}},
|
|
}
|
|
|
|
scheme := runtime.NewScheme()
|
|
err := RegisterConversions(scheme, dsProvider, leProvider)
|
|
require.NoError(t, err)
|
|
|
|
for idx, in := range versions {
|
|
kind := fmt.Sprintf("%T", in)[1:]
|
|
t.Run(kind, func(t *testing.T) {
|
|
for i, out := range versions {
|
|
if i == idx {
|
|
continue // skip the same version
|
|
}
|
|
err = scheme.Convert(in, out, nil)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// Make sure we get the right title for each value
|
|
meta, err := utils.MetaAccessor(in)
|
|
require.NoError(t, err)
|
|
require.True(t, strings.HasPrefix(meta.FindTitle(""), "dashboard"))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDeepCopyValid(t *testing.T) {
|
|
dash1 := &dashv0.Dashboard{}
|
|
meta1, err := utils.MetaAccessor(dash1)
|
|
require.NoError(t, err)
|
|
meta1.SetFolder("f1")
|
|
require.Equal(t, "f1", dash1.Annotations[utils.AnnoKeyFolder])
|
|
|
|
dash1Copy := dash1.DeepCopyObject()
|
|
metaCopy, err := utils.MetaAccessor(dash1Copy)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "f1", metaCopy.GetFolder())
|
|
|
|
// Changing a property on the copy should not effect the original
|
|
metaCopy.SetFolder("XYZ")
|
|
require.Equal(t, "f1", meta1.GetFolder()) // 💣💣💣
|
|
}
|
|
|
|
func TestDashboardConversionToAllVersions(t *testing.T) {
|
|
// Initialize the migrator with a test data source provider
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
// Use TestLibraryElementProvider for tests that need library panel models with repeat options
|
|
leProvider := migrationtestutil.NewTestLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
// Set up conversion scheme
|
|
scheme := runtime.NewScheme()
|
|
err := RegisterConversions(scheme, dsProvider, leProvider)
|
|
require.NoError(t, err)
|
|
|
|
// Read all files from input directory recursively
|
|
inputBaseDir := filepath.Join("testdata", "input")
|
|
err = filepath.WalkDir(inputBaseDir, func(path string, d os.DirEntry, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if d.IsDir() {
|
|
return nil
|
|
}
|
|
|
|
// Get relative path from input directory
|
|
relPath, err := filepath.Rel(inputBaseDir, path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
t.Run(fmt.Sprintf("Convert_%s", relPath), func(t *testing.T) {
|
|
// Read input dashboard file
|
|
// ignore gosec G304 as this function is only used in the test process
|
|
//nolint:gosec
|
|
inputData, err := os.ReadFile(path)
|
|
require.NoError(t, err, "Failed to read input file")
|
|
|
|
// Parse the input dashboard to get its version
|
|
var rawDash map[string]interface{}
|
|
err = json.Unmarshal(inputData, &rawDash)
|
|
require.NoError(t, err, "Failed to unmarshal dashboard JSON")
|
|
|
|
// Extract apiVersion to determine source type
|
|
fileName := d.Name()
|
|
var sourceDash metav1.Object
|
|
var sourceVersion string
|
|
|
|
apiVersion, ok := rawDash["apiVersion"].(string)
|
|
if !ok {
|
|
// Non-API object: wrap raw dashboard JSON based on filename prefix
|
|
// These are raw dashboard specs (like output from v0 to v1 migration)
|
|
// Filename format: v1beta1.something.json or v0alpha1.something.json
|
|
parts := strings.SplitN(fileName, ".", 2)
|
|
if len(parts) < 2 {
|
|
t.Skipf("Skipping %s - cannot determine version from filename", relPath)
|
|
return
|
|
}
|
|
sourceVersion = parts[0]
|
|
|
|
switch sourceVersion {
|
|
case "v0alpha1":
|
|
sourceDash = &dashv0.Dashboard{
|
|
TypeMeta: metav1.TypeMeta{
|
|
Kind: "Dashboard",
|
|
APIVersion: dashv0.APIVERSION,
|
|
},
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: strings.TrimSuffix(fileName, ".json"),
|
|
},
|
|
Spec: common.Unstructured{Object: rawDash},
|
|
}
|
|
case "v1beta1":
|
|
sourceDash = &dashv1.Dashboard{
|
|
TypeMeta: metav1.TypeMeta{
|
|
Kind: "Dashboard",
|
|
APIVersion: dashv1.APIVERSION,
|
|
},
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: strings.TrimSuffix(fileName, ".json"),
|
|
},
|
|
Spec: common.Unstructured{Object: rawDash},
|
|
}
|
|
default:
|
|
t.Skipf("Skipping %s - unsupported version prefix %s for non-API object", relPath, sourceVersion)
|
|
return
|
|
}
|
|
} else {
|
|
// Parse group and version from apiVersion (format: "group/version")
|
|
gv, err := schema.ParseGroupVersion(apiVersion)
|
|
require.NoError(t, err)
|
|
require.Equal(t, dashv0.GROUP, gv.Group)
|
|
|
|
// Validate that the input file starts with the apiVersion declared in the object
|
|
expectedPrefix := fmt.Sprintf("%s.", gv.Version)
|
|
if !strings.HasPrefix(fileName, expectedPrefix) {
|
|
t.Fatalf(
|
|
"Input file %s does not match its declared apiVersion %s. "+
|
|
"Expected filename to start with \"%s\". "+
|
|
"Example: if apiVersion is \"dashboard.grafana.app/v1beta1\", "+
|
|
"filename should start with \"v1beta1.<descriptive-name>.json\"",
|
|
fileName, apiVersion, expectedPrefix)
|
|
}
|
|
|
|
// Create source object based on version
|
|
switch gv.Version {
|
|
case "v0alpha1":
|
|
var dash dashv0.Dashboard
|
|
err = json.Unmarshal(inputData, &dash)
|
|
sourceDash = &dash
|
|
case "v1beta1":
|
|
var dash dashv1.Dashboard
|
|
err = json.Unmarshal(inputData, &dash)
|
|
sourceDash = &dash
|
|
case "v2alpha1":
|
|
var dash dashv2alpha1.Dashboard
|
|
err = json.Unmarshal(inputData, &dash)
|
|
sourceDash = &dash
|
|
case "v2beta1":
|
|
var dash dashv2beta1.Dashboard
|
|
err = json.Unmarshal(inputData, &dash)
|
|
sourceDash = &dash
|
|
default:
|
|
t.Fatalf("Unsupported source version: %s", gv.Version)
|
|
}
|
|
require.NoError(t, err, "Failed to unmarshal dashboard into typed object")
|
|
sourceVersion = gv.Version
|
|
}
|
|
|
|
// Calculate output directory (preserve subdirectory structure)
|
|
relDir := filepath.Dir(relPath)
|
|
outBaseDir := filepath.Join("testdata", "output")
|
|
outDir := outBaseDir
|
|
if relDir != "." {
|
|
outDir = filepath.Join(outBaseDir, relDir)
|
|
}
|
|
|
|
// Ensure output directory exists
|
|
// ignore gosec G301 as this function is only used in the test process
|
|
//nolint:gosec
|
|
err = os.MkdirAll(outDir, 0755)
|
|
require.NoError(t, err, "Failed to create output directory")
|
|
|
|
// Get target versions from the dashboard manifest
|
|
manifest := apis.LocalManifest()
|
|
targetVersions := make(map[string]runtime.Object)
|
|
|
|
// Get original filename without extension
|
|
originalName := strings.TrimSuffix(fileName, ".json")
|
|
|
|
// Get all Dashboard versions from the manifest
|
|
for _, kind := range manifest.ManifestData.Kinds() {
|
|
if kind.Kind == "Dashboard" {
|
|
for _, version := range kind.Versions {
|
|
// Skip converting to the same version
|
|
if version.VersionName == sourceVersion {
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("%s.%s.json", originalName, version.VersionName)
|
|
typeMeta := metav1.TypeMeta{
|
|
APIVersion: fmt.Sprintf("%s/%s", dashv0.APIGroup, version.VersionName),
|
|
Kind: kind.Kind, // Dashboard
|
|
}
|
|
|
|
// Create target object based on version
|
|
switch version.VersionName {
|
|
case "v0alpha1":
|
|
targetVersions[filename] = &dashv0.Dashboard{TypeMeta: typeMeta}
|
|
case "v1beta1":
|
|
targetVersions[filename] = &dashv1.Dashboard{TypeMeta: typeMeta}
|
|
case "v2alpha1":
|
|
targetVersions[filename] = &dashv2alpha1.Dashboard{TypeMeta: typeMeta}
|
|
case "v2beta1":
|
|
targetVersions[filename] = &dashv2beta1.Dashboard{TypeMeta: typeMeta}
|
|
default:
|
|
t.Logf("Unknown version %s, skipping", version.VersionName)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
// Convert to each target version
|
|
for filename, target := range targetVersions {
|
|
t.Run(fmt.Sprintf("Convert_to_%s", filename), func(t *testing.T) {
|
|
// Create a copy of the input dashboard for conversion
|
|
inputCopy := sourceDash.(runtime.Object).DeepCopyObject()
|
|
|
|
// Convert to target version
|
|
err = scheme.Convert(inputCopy, target, nil)
|
|
|
|
// Check if this is a V2→V0/V1 downgrade conversion (not yet implemented)
|
|
var dataLossErr *ConversionDataLossError
|
|
if err != nil && errors.As(err, &dataLossErr) {
|
|
// Check if this is a V2 downgrade
|
|
if strings.HasPrefix(sourceVersion, "v2") &&
|
|
(strings.Contains(filename, "v0alpha1") || strings.Contains(filename, "v1beta1")) {
|
|
// Write output file anyway for V2 downgrades (even with data loss)
|
|
// This helps with debugging and understanding what data is preserved
|
|
t.Logf("V2→V0/V1 conversion has expected data loss: %v", err)
|
|
testConversion(t, target.(metav1.Object), filename, outDir)
|
|
t.Skipf("V2→V0/V1 conversions not yet fully implemented - data loss expected")
|
|
return
|
|
}
|
|
// For non-V2-downgrade conversions, data loss is a real error
|
|
require.NoError(t, err, "Conversion failed for %s", filename)
|
|
}
|
|
|
|
// Test the changes in the conversion result
|
|
testConversion(t, target.(metav1.Object), filename, outDir)
|
|
})
|
|
}
|
|
})
|
|
|
|
return nil
|
|
})
|
|
require.NoError(t, err, "Failed to walk input directory")
|
|
}
|
|
|
|
// TestMigratedDashboardsConversion tests conversion of already-migrated dashboards
|
|
// from the migration package's latest_version output directory
|
|
func TestMigratedDashboardsConversion(t *testing.T) {
|
|
// Initialize the migrator with a test data source provider
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
// Use TestLibraryElementProvider for tests that need library panel models with repeat options
|
|
leProvider := migrationtestutil.NewTestLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
// Set up conversion scheme
|
|
scheme := runtime.NewScheme()
|
|
err := RegisterConversions(scheme, dsProvider, leProvider)
|
|
require.NoError(t, err)
|
|
|
|
// Read all files from migration package's latest_version directory
|
|
inputDir := filepath.Join("..", "testdata", "output", "latest_version")
|
|
files, err := os.ReadDir(inputDir)
|
|
require.NoError(t, err, "Failed to read latest_version directory")
|
|
|
|
for _, file := range files {
|
|
if file.IsDir() {
|
|
continue
|
|
}
|
|
|
|
t.Run(fmt.Sprintf("Convert_%s", file.Name()), func(t *testing.T) {
|
|
// Read input dashboard file
|
|
inputFile := filepath.Join(inputDir, file.Name())
|
|
// ignore gosec G304 as this function is only used in the test process
|
|
//nolint:gosec
|
|
inputData, err := os.ReadFile(inputFile)
|
|
require.NoError(t, err, "Failed to read input file")
|
|
|
|
// Parse the raw dashboard JSON
|
|
var rawDash map[string]interface{}
|
|
err = json.Unmarshal(inputData, &rawDash)
|
|
require.NoError(t, err, "Failed to unmarshal dashboard JSON")
|
|
|
|
// These files are from the old migration system and are raw dashboard JSON
|
|
// We need to wrap them in the proper v1beta1 API structure
|
|
sourceDash := &dashv1.Dashboard{
|
|
TypeMeta: metav1.TypeMeta{
|
|
Kind: "Dashboard",
|
|
APIVersion: dashv1.APIVERSION,
|
|
},
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: strings.TrimSuffix(file.Name(), ".json"),
|
|
},
|
|
Spec: common.Unstructured{Object: rawDash},
|
|
}
|
|
|
|
// Ensure output directory exists
|
|
outDir := filepath.Join("testdata", "migrated_dashboards_output")
|
|
// ignore gosec G301 as this function is only used in the test process
|
|
//nolint:gosec
|
|
err = os.MkdirAll(outDir, 0755)
|
|
require.NoError(t, err, "Failed to create output directory")
|
|
|
|
// Get target versions from the dashboard manifest
|
|
manifest := apis.LocalManifest()
|
|
targetVersions := make(map[string]runtime.Object)
|
|
|
|
// Get original filename without extension
|
|
originalName := strings.TrimSuffix(file.Name(), ".json")
|
|
|
|
// Get all Dashboard versions from the manifest
|
|
for _, kind := range manifest.ManifestData.Kinds() {
|
|
if kind.Kind == "Dashboard" {
|
|
for _, version := range kind.Versions {
|
|
// Skip v1beta1 since that's our source version
|
|
if version.VersionName == "v1beta1" {
|
|
continue
|
|
}
|
|
|
|
// Prefix with v1beta1-mig- to indicate these came from v1beta1 dashboards
|
|
// that went through the migration pipeline
|
|
filename := fmt.Sprintf("v1beta1-mig-%s.%s.json", originalName, version.VersionName)
|
|
typeMeta := metav1.TypeMeta{
|
|
APIVersion: fmt.Sprintf("%s/%s", dashv0.APIGroup, version.VersionName),
|
|
Kind: kind.Kind, // Dashboard
|
|
}
|
|
|
|
// Create target object based on version
|
|
switch version.VersionName {
|
|
case "v0alpha1":
|
|
targetVersions[filename] = &dashv0.Dashboard{TypeMeta: typeMeta}
|
|
case "v2alpha1":
|
|
targetVersions[filename] = &dashv2alpha1.Dashboard{TypeMeta: typeMeta}
|
|
case "v2beta1":
|
|
targetVersions[filename] = &dashv2beta1.Dashboard{TypeMeta: typeMeta}
|
|
default:
|
|
t.Logf("Unknown version %s, skipping", version.VersionName)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
// Convert to each target version
|
|
for filename, target := range targetVersions {
|
|
t.Run(fmt.Sprintf("Convert_to_%s", filename), func(t *testing.T) {
|
|
// Create a copy of the input dashboard for conversion
|
|
inputCopy := sourceDash.DeepCopyObject()
|
|
|
|
// Convert to target version
|
|
err := scheme.Convert(inputCopy, target, nil)
|
|
require.NoError(t, err, "Conversion failed for %s", filename)
|
|
|
|
// Test the changes in the conversion result
|
|
testConversion(t, target.(metav1.Object), filename, outDir)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// shouldOverrideOutput checks if OUTPUT_OVERRIDE environment variable is set to "true"
|
|
func shouldOverrideOutput() bool {
|
|
return os.Getenv("OUTPUT_OVERRIDE") == "true"
|
|
}
|
|
|
|
// setupTestConversionScheme initializes the migration system and sets up the conversion scheme
|
|
// with test data source and library element providers. Returns the configured scheme.
|
|
func setupTestConversionScheme(t *testing.T) *runtime.Scheme {
|
|
t.Helper()
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
leProvider := migrationtestutil.NewLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
scheme := runtime.NewScheme()
|
|
err := RegisterConversions(scheme, dsProvider, leProvider)
|
|
require.NoError(t, err, "Failed to register conversions")
|
|
return scheme
|
|
}
|
|
|
|
// writeOrCompareOutputFile writes or compares an output file based on OUTPUT_OVERRIDE environment variable.
|
|
// If OUTPUT_OVERRIDE is true, it writes/overrides the file. Otherwise, it compares with existing file.
|
|
// obj should be JSON-marshalable (typically a Dashboard or similar struct).
|
|
func writeOrCompareOutputFile(t *testing.T, obj interface{}, outputPath string, filename string) {
|
|
t.Helper()
|
|
|
|
outputData, err := json.MarshalIndent(obj, "", " ")
|
|
require.NoError(t, err, "Failed to marshal output data")
|
|
|
|
outputOverride := shouldOverrideOutput()
|
|
|
|
// If file exists and OUTPUT_OVERRIDE is not set, compare instead of writing
|
|
if _, err := os.Stat(outputPath); err == nil && !outputOverride {
|
|
// ignore gosec G304 as this function is only used in the test process
|
|
//nolint:gosec
|
|
existingData, err := os.ReadFile(outputPath)
|
|
require.NoError(t, err, "Failed to read existing output file")
|
|
require.JSONEq(t, string(existingData), string(outputData), "%s did not match", outputPath)
|
|
t.Logf("✓ Conversion to %s matches existing file", filename)
|
|
} else {
|
|
// Ensure output directory exists
|
|
outputDir := filepath.Dir(outputPath)
|
|
// ignore gosec G301 as this function is only used in the test process
|
|
//nolint:gosec
|
|
err = os.MkdirAll(outputDir, 0755)
|
|
require.NoError(t, err, "Failed to create output directory")
|
|
|
|
err = os.WriteFile(outputPath, outputData, 0644)
|
|
require.NoError(t, err, "Failed to write output file")
|
|
if outputOverride {
|
|
t.Logf("✓ Overrode output file: %s", filename)
|
|
} else {
|
|
t.Logf("✓ Generated %s", filename)
|
|
}
|
|
}
|
|
}
|
|
|
|
// readInputFile reads and unmarshals a JSON input file into the provided target.
|
|
// target should be a pointer to the struct type to unmarshal into.
|
|
func readInputFile(t *testing.T, inputPath string, target interface{}) {
|
|
t.Helper()
|
|
// ignore gosec G304 as this function is only used in the test process
|
|
//nolint:gosec
|
|
inputData, err := os.ReadFile(inputPath)
|
|
require.NoError(t, err, "Failed to read input file %s", inputPath)
|
|
|
|
err = json.Unmarshal(inputData, target)
|
|
require.NoError(t, err, "Failed to unmarshal input file %s", inputPath)
|
|
}
|
|
|
|
func testConversion(t *testing.T, convertedDash metav1.Object, filename, outputDir string) {
|
|
t.Helper()
|
|
|
|
outPath := filepath.Join(outputDir, filename)
|
|
outBytes, err := json.MarshalIndent(convertedDash, "", " ")
|
|
require.NoError(t, err, "failed to marshal converted dashboard")
|
|
|
|
// Check if OUTPUT_OVERRIDE environment variable is set to override existing files
|
|
outputOverride := shouldOverrideOutput()
|
|
|
|
if _, err := os.Stat(outPath); os.IsNotExist(err) || outputOverride {
|
|
// Ensure the output directory exists
|
|
// ignore gosec G301 as this function is only used in the test process
|
|
//nolint:gosec
|
|
err = os.MkdirAll(outputDir, 0755)
|
|
require.NoError(t, err, "failed to create output directory %s", outputDir)
|
|
|
|
err = os.WriteFile(outPath, outBytes, 0644)
|
|
require.NoError(t, err, "failed to write output file %s", outPath)
|
|
if outputOverride {
|
|
t.Logf("✓ Overrode output file: %s", filename)
|
|
} else {
|
|
t.Logf("✓ Created new output file: %s", filename)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ignore gosec G304 as this function is only used in the test process
|
|
//nolint:gosec
|
|
existingBytes, err := os.ReadFile(outPath)
|
|
require.NoError(t, err, "failed to read existing output file")
|
|
require.JSONEq(t, string(existingBytes), string(outBytes), "%s did not match", outPath)
|
|
t.Logf("✓ Conversion to %s matches existing file", filename)
|
|
}
|
|
|
|
// TestConversionMetrics tests that conversion-level metrics are recorded correctly
|
|
func TestConversionMetrics(t *testing.T) {
|
|
// Initialize migration with test providers
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
// Use TestLibraryElementProvider for tests that need library panel models with repeat options
|
|
leProvider := migrationtestutil.NewTestLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
// Create a test registry for metrics
|
|
registry := prometheus.NewRegistry()
|
|
migration.RegisterMetrics(registry)
|
|
|
|
// Set up conversion scheme
|
|
scheme := runtime.NewScheme()
|
|
err := RegisterConversions(scheme, dsProvider, leProvider)
|
|
require.NoError(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
source metav1.Object
|
|
target metav1.Object
|
|
expectAPISuccess bool
|
|
expectMetricsSuccess bool
|
|
expectedSourceAPI string
|
|
expectedTargetAPI string
|
|
expectedSourceSchema string
|
|
expectedTargetSchema string
|
|
expectedErrorType string
|
|
}{
|
|
{
|
|
name: "successful v0 to v1 conversion with schema migration",
|
|
source: &dashv0.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "test-uid-1"},
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"title": "test dashboard",
|
|
"schemaVersion": 14,
|
|
"panels": []any{}, // Add empty panels array to avoid data loss detection issues
|
|
}},
|
|
},
|
|
target: &dashv1.Dashboard{},
|
|
expectAPISuccess: true,
|
|
expectMetricsSuccess: true,
|
|
expectedSourceAPI: dashv0.APIVERSION,
|
|
expectedTargetAPI: dashv1.APIVERSION,
|
|
expectedSourceSchema: "14",
|
|
expectedTargetSchema: fmt.Sprintf("%d", 41), // LATEST_VERSION
|
|
},
|
|
{
|
|
name: "successful v1 to v0 conversion without schema migration",
|
|
source: &dashv1.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "test-uid-2"},
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"title": "test dashboard",
|
|
"schemaVersion": 42,
|
|
"panels": []any{}, // Add empty panels array to avoid data loss detection issues
|
|
}},
|
|
},
|
|
target: &dashv0.Dashboard{},
|
|
expectAPISuccess: true,
|
|
expectMetricsSuccess: true,
|
|
expectedSourceAPI: dashv1.APIVERSION,
|
|
expectedTargetAPI: dashv0.APIVERSION,
|
|
expectedSourceSchema: "42",
|
|
expectedTargetSchema: "42", // V1→V0 keeps same schema version
|
|
},
|
|
{
|
|
name: "successful v2alpha1 to v2beta1 conversion",
|
|
source: &dashv2alpha1.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "test-uid-3"},
|
|
Spec: dashv2alpha1.DashboardSpec{
|
|
Title: "test dashboard",
|
|
Elements: map[string]dashv2alpha1.DashboardElement{}, // Add empty elements
|
|
Annotations: []dashv2alpha1.DashboardAnnotationQueryKind{},
|
|
Links: []dashv2alpha1.DashboardDashboardLink{},
|
|
},
|
|
},
|
|
target: &dashv2beta1.Dashboard{},
|
|
expectAPISuccess: true,
|
|
expectMetricsSuccess: true,
|
|
expectedSourceAPI: dashv2alpha1.APIVERSION,
|
|
expectedTargetAPI: dashv2beta1.APIVERSION,
|
|
expectedSourceSchema: "v2alpha1",
|
|
expectedTargetSchema: "v2beta1",
|
|
},
|
|
{
|
|
name: "successful v2alpha1 to v0 conversion",
|
|
source: &dashv2alpha1.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "test-uid-4"},
|
|
Spec: dashv2alpha1.DashboardSpec{
|
|
Title: "test dashboard",
|
|
Elements: map[string]dashv2alpha1.DashboardElement{},
|
|
Annotations: []dashv2alpha1.DashboardAnnotationQueryKind{},
|
|
Links: []dashv2alpha1.DashboardDashboardLink{},
|
|
},
|
|
},
|
|
target: &dashv0.Dashboard{},
|
|
expectAPISuccess: true,
|
|
expectMetricsSuccess: true,
|
|
expectedSourceAPI: dashv2alpha1.APIVERSION,
|
|
expectedTargetAPI: dashv0.APIVERSION,
|
|
expectedSourceSchema: "v2alpha1",
|
|
expectedTargetSchema: "42", // V2→V0 results in latest schema version
|
|
},
|
|
{
|
|
name: "successful v2beta1 to v0 conversion",
|
|
source: &dashv2beta1.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "test-uid-5"},
|
|
Spec: dashv2beta1.DashboardSpec{
|
|
Title: "test dashboard",
|
|
Elements: map[string]dashv2beta1.DashboardElement{},
|
|
Annotations: []dashv2beta1.DashboardAnnotationQueryKind{},
|
|
Links: []dashv2beta1.DashboardDashboardLink{},
|
|
},
|
|
},
|
|
target: &dashv0.Dashboard{},
|
|
expectAPISuccess: true,
|
|
expectMetricsSuccess: true,
|
|
expectedSourceAPI: dashv2beta1.APIVERSION,
|
|
expectedTargetAPI: dashv0.APIVERSION,
|
|
expectedSourceSchema: "v2beta1",
|
|
expectedTargetSchema: "42", // V2→V0 results in latest schema version
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Reset metrics before each test
|
|
migration.MDashboardConversionSuccessTotal.Reset()
|
|
migration.MDashboardConversionFailureTotal.Reset()
|
|
|
|
// Execute conversion
|
|
err := scheme.Convert(tt.source, tt.target, nil)
|
|
|
|
// Check error expectation
|
|
if tt.expectAPISuccess {
|
|
require.NoError(t, err, "expected successful conversion")
|
|
} else {
|
|
require.Error(t, err, "expected conversion to fail")
|
|
}
|
|
|
|
// Collect metrics and verify they were recorded correctly
|
|
metricFamilies, err := registry.Gather()
|
|
require.NoError(t, err)
|
|
|
|
var successTotal, failureTotal float64
|
|
for _, mf := range metricFamilies {
|
|
if mf.GetName() == "grafana_dashboard_migration_conversion_success_total" {
|
|
for _, metric := range mf.GetMetric() {
|
|
successTotal += metric.GetCounter().GetValue()
|
|
}
|
|
} else if mf.GetName() == "grafana_dashboard_migration_conversion_failure_total" {
|
|
for _, metric := range mf.GetMetric() {
|
|
failureTotal += metric.GetCounter().GetValue()
|
|
}
|
|
}
|
|
}
|
|
|
|
if tt.expectAPISuccess && tt.expectMetricsSuccess {
|
|
require.Equal(t, float64(1), successTotal, "success metric should be incremented")
|
|
require.Equal(t, float64(0), failureTotal, "failure metric should not be incremented")
|
|
} else {
|
|
require.Equal(t, float64(0), successTotal, "success metric should not be incremented")
|
|
require.Equal(t, float64(1), failureTotal, "failure metric should be incremented")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestConversionMetricsWrapper tests the withConversionMetrics wrapper function
|
|
func TestConversionMetricsWrapper(t *testing.T) {
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
// Use TestLibraryElementProvider for tests that need library panel models with repeat options
|
|
leProvider := migrationtestutil.NewTestLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
// Create a test registry for metrics
|
|
registry := prometheus.NewRegistry()
|
|
migration.RegisterMetrics(registry)
|
|
|
|
tests := []struct {
|
|
name string
|
|
source interface{}
|
|
target interface{}
|
|
conversionFunction func(a, b interface{}, scope conversion.Scope) error
|
|
expectAPISuccess bool
|
|
expectMetricsSuccess bool
|
|
expectedSourceUID string
|
|
expectedSourceAPI string
|
|
expectedTargetAPI string
|
|
}{
|
|
{
|
|
name: "successful conversion wrapper",
|
|
source: &dashv0.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "test-wrapper-1"},
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"title": "test dashboard",
|
|
"schemaVersion": 20,
|
|
"panels": []any{}, // Add empty panels array
|
|
}},
|
|
},
|
|
target: &dashv1.Dashboard{},
|
|
conversionFunction: func(a, b interface{}, scope conversion.Scope) error {
|
|
// Simulate successful conversion - need to set target panels too
|
|
tgt := b.(*dashv1.Dashboard)
|
|
tgt.Spec = common.Unstructured{Object: map[string]any{
|
|
"title": "test dashboard",
|
|
"schemaVersion": 20,
|
|
"panels": []any{},
|
|
}}
|
|
return nil
|
|
},
|
|
expectAPISuccess: true,
|
|
expectMetricsSuccess: true,
|
|
expectedSourceUID: "test-wrapper-1",
|
|
expectedSourceAPI: dashv0.APIVERSION,
|
|
expectedTargetAPI: dashv1.APIVERSION,
|
|
},
|
|
{
|
|
name: "failed conversion wrapper",
|
|
source: &dashv1.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "test-wrapper-2"},
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"title": "test dashboard",
|
|
"schemaVersion": 30,
|
|
"panels": []any{}, // Add empty panels
|
|
}},
|
|
},
|
|
target: &dashv0.Dashboard{},
|
|
conversionFunction: func(a, b interface{}, scope conversion.Scope) error {
|
|
// Simulate conversion failure
|
|
return fmt.Errorf("conversion failed")
|
|
},
|
|
expectAPISuccess: true, // wrapper returns nil to avoid 500 response
|
|
expectMetricsSuccess: false, // but still records failure metrics
|
|
expectedSourceUID: "test-wrapper-2",
|
|
expectedSourceAPI: dashv1.APIVERSION,
|
|
expectedTargetAPI: dashv0.APIVERSION,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Reset metrics
|
|
migration.MDashboardConversionSuccessTotal.Reset()
|
|
migration.MDashboardConversionFailureTotal.Reset()
|
|
|
|
// Create wrapped function
|
|
wrappedFunc := withConversionMetrics(tt.expectedSourceAPI, tt.expectedTargetAPI, tt.conversionFunction)
|
|
|
|
// Execute wrapped function
|
|
err := wrappedFunc(tt.source, tt.target, nil)
|
|
|
|
// Check error expectation
|
|
if tt.expectAPISuccess {
|
|
require.NoError(t, err, "expected successful conversion")
|
|
} else {
|
|
require.Error(t, err, "expected conversion to fail")
|
|
}
|
|
|
|
// Collect metrics and verify they were recorded correctly
|
|
metricFamilies, err := registry.Gather()
|
|
require.NoError(t, err)
|
|
|
|
var successTotal, failureTotal float64
|
|
for _, mf := range metricFamilies {
|
|
if mf.GetName() == "grafana_dashboard_migration_conversion_success_total" {
|
|
for _, metric := range mf.GetMetric() {
|
|
successTotal += metric.GetCounter().GetValue()
|
|
}
|
|
} else if mf.GetName() == "grafana_dashboard_migration_conversion_failure_total" {
|
|
for _, metric := range mf.GetMetric() {
|
|
failureTotal += metric.GetCounter().GetValue()
|
|
}
|
|
}
|
|
}
|
|
|
|
if tt.expectAPISuccess && tt.expectMetricsSuccess {
|
|
require.GreaterOrEqual(t, successTotal, float64(1), "success metric should be incremented")
|
|
require.Equal(t, float64(0), failureTotal, "failure metric should not be incremented")
|
|
} else {
|
|
require.Equal(t, float64(0), successTotal, "success metric should not be incremented")
|
|
require.GreaterOrEqual(t, failureTotal, float64(1), "failure metric should be incremented")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestSchemaVersionExtraction tests that schema versions are extracted correctly from different dashboard types
|
|
func TestSchemaVersionExtraction(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
dashboard interface{}
|
|
expectedVersion string
|
|
}{
|
|
{
|
|
name: "v0 dashboard with numeric schema version",
|
|
dashboard: &dashv0.Dashboard{
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"schemaVersion": 25,
|
|
}},
|
|
},
|
|
expectedVersion: "25",
|
|
},
|
|
{
|
|
name: "v1 dashboard with float schema version",
|
|
dashboard: &dashv1.Dashboard{
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"schemaVersion": 30.0,
|
|
}},
|
|
},
|
|
expectedVersion: "30",
|
|
},
|
|
{
|
|
name: "v2alpha1 dashboard without numeric schema version",
|
|
dashboard: &dashv2alpha1.Dashboard{
|
|
Spec: dashv2alpha1.DashboardSpec{Title: "test"},
|
|
},
|
|
expectedVersion: "", // v2+ dashboards don't track schema versions
|
|
},
|
|
{
|
|
name: "v2beta1 dashboard without numeric schema version",
|
|
dashboard: &dashv2beta1.Dashboard{
|
|
Spec: dashv2beta1.DashboardSpec{Title: "test"},
|
|
},
|
|
expectedVersion: "", // v2+ dashboards don't track schema versions
|
|
},
|
|
{
|
|
name: "dashboard with missing schema version",
|
|
dashboard: &dashv0.Dashboard{
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"title": "test",
|
|
}},
|
|
},
|
|
expectedVersion: "0", // When schema version is missing, GetSchemaVersion() returns 0
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Test the schema version extraction logic by creating a wrapper and checking the metrics labels
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
// Use TestLibraryElementProvider for tests that need library panel models with repeat options
|
|
leProvider := migrationtestutil.NewTestLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
// Create a test registry for metrics
|
|
registry := prometheus.NewRegistry()
|
|
migration.RegisterMetrics(registry)
|
|
|
|
// Reset metrics
|
|
migration.MDashboardConversionFailureTotal.Reset()
|
|
|
|
// Create a wrapper that always fails so we can inspect the failure metrics labels
|
|
wrappedFunc := withConversionMetrics("test/source", "test/target", func(a, b interface{}, scope conversion.Scope) error {
|
|
return fmt.Errorf("test error")
|
|
})
|
|
|
|
// Execute wrapper with a dummy target
|
|
_ = wrappedFunc(tt.dashboard, &dashv0.Dashboard{}, nil)
|
|
|
|
// Collect metrics and verify schema version label
|
|
metricFamilies, err := registry.Gather()
|
|
require.NoError(t, err)
|
|
|
|
found := false
|
|
for _, mf := range metricFamilies {
|
|
if mf.GetName() == "grafana_dashboard_migration_conversion_failure_total" {
|
|
for _, metric := range mf.GetMetric() {
|
|
labels := make(map[string]string)
|
|
for _, label := range metric.GetLabel() {
|
|
labels[label.GetName()] = label.GetValue()
|
|
}
|
|
if labels["source_schema_version"] == tt.expectedVersion {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
require.True(t, found, "expected schema version %s not found in metrics", tt.expectedVersion)
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestConversionLogging tests that conversion-level logging works correctly
|
|
func TestConversionLogging(t *testing.T) {
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
// Use TestLibraryElementProvider for tests that need library panel models with repeat options
|
|
leProvider := migrationtestutil.NewTestLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
// Create a test registry for metrics
|
|
registry := prometheus.NewRegistry()
|
|
migration.RegisterMetrics(registry)
|
|
|
|
// Set up conversion scheme
|
|
scheme := runtime.NewScheme()
|
|
err := RegisterConversions(scheme, dsProvider, leProvider)
|
|
require.NoError(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
source metav1.Object
|
|
target metav1.Object
|
|
expectSuccess bool
|
|
expectedLogMsg string
|
|
expectedFields map[string]interface{}
|
|
}{
|
|
{
|
|
name: "successful v0 to v1 conversion logging",
|
|
source: &dashv0.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "test-uid-log-1"},
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"title": "test dashboard",
|
|
"schemaVersion": 20,
|
|
}},
|
|
},
|
|
target: &dashv1.Dashboard{},
|
|
expectSuccess: true,
|
|
expectedLogMsg: "Dashboard conversion succeeded",
|
|
expectedFields: map[string]interface{}{
|
|
"sourceVersionAPI": dashv0.APIVERSION,
|
|
"targetVersionAPI": dashv1.APIVERSION,
|
|
"dashboardUID": "test-uid-log-1",
|
|
"sourceSchemaVersion": "20",
|
|
"targetSchemaVersion": fmt.Sprintf("%d", 42), // LATEST_VERSION
|
|
},
|
|
},
|
|
{
|
|
name: "failed conversion logging",
|
|
source: &dashv0.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "test-uid-log-2"},
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"title": "old dashboard",
|
|
"schemaVersion": 5, // Below minimum version
|
|
}},
|
|
},
|
|
target: &dashv1.Dashboard{},
|
|
expectSuccess: true, // Conversion succeeds but with error status
|
|
expectedLogMsg: "Dashboard conversion succeeded", // Still logs success since conversion doesn't fail
|
|
expectedFields: map[string]interface{}{
|
|
"sourceVersionAPI": dashv0.APIVERSION,
|
|
"targetVersionAPI": dashv1.APIVERSION,
|
|
"dashboardUID": "test-uid-log-2",
|
|
"sourceSchemaVersion": "5",
|
|
"targetSchemaVersion": fmt.Sprintf("%d", 42), // LATEST_VERSION
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Reset metrics
|
|
migration.MDashboardConversionSuccessTotal.Reset()
|
|
migration.MDashboardConversionFailureTotal.Reset()
|
|
|
|
// Execute conversion
|
|
err := scheme.Convert(tt.source, tt.target, nil)
|
|
|
|
// Check error expectation
|
|
if tt.expectSuccess {
|
|
require.NoError(t, err, "expected successful conversion")
|
|
} else {
|
|
require.Error(t, err, "expected conversion to fail")
|
|
}
|
|
|
|
// Note: Similar to schema migration tests, we can't easily capture
|
|
// the actual log output since the logger is global and uses grafana-app-sdk.
|
|
// However, we verify that the conversion completes, ensuring the logging
|
|
// code paths in withConversionMetrics are executed.
|
|
|
|
t.Logf("Conversion completed - logging code paths executed for: %s", tt.expectedLogMsg)
|
|
t.Logf("Expected log fields: %+v", tt.expectedFields)
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestConversionLogLevels tests that appropriate log levels are used
|
|
func TestConversionLogLevels(t *testing.T) {
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
// Use TestLibraryElementProvider for tests that need library panel models with repeat options
|
|
leProvider := migrationtestutil.NewTestLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
t.Run("log levels and structured fields verification", func(t *testing.T) {
|
|
// Create test wrapper to verify logging behavior
|
|
var logBuffer bytes.Buffer
|
|
handler := slog.NewTextHandler(&logBuffer, &slog.HandlerOptions{
|
|
Level: slog.LevelDebug,
|
|
})
|
|
_ = slog.New(handler) // We would use this if we could inject it
|
|
|
|
// Test successful conversion wrapper
|
|
successWrapper := withConversionMetrics(
|
|
dashv0.APIVERSION,
|
|
dashv1.APIVERSION,
|
|
func(a, b interface{}, scope conversion.Scope) error {
|
|
return nil // Simulate success
|
|
},
|
|
)
|
|
|
|
source := &dashv0.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "log-test-1"},
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"schemaVersion": 25,
|
|
"title": "test",
|
|
}},
|
|
}
|
|
target := &dashv1.Dashboard{}
|
|
|
|
err := successWrapper(source, target, nil)
|
|
require.NoError(t, err, "successful conversion should not error")
|
|
|
|
// Test failed conversion wrapper
|
|
failureWrapper := withConversionMetrics(
|
|
dashv1.APIVERSION,
|
|
dashv0.APIVERSION,
|
|
func(a, b interface{}, scope conversion.Scope) error {
|
|
return fmt.Errorf("simulated conversion failure")
|
|
},
|
|
)
|
|
|
|
source2 := &dashv1.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "log-test-2"},
|
|
Spec: common.Unstructured{Object: map[string]any{
|
|
"schemaVersion": 30,
|
|
"title": "test",
|
|
}},
|
|
}
|
|
target2 := &dashv0.Dashboard{}
|
|
|
|
err = failureWrapper(source2, target2, nil)
|
|
require.NoError(t, err, "conversion wrapper returns nil to avoid 500 response, but logs error and records metrics")
|
|
|
|
// The logging code paths are executed in both cases above
|
|
// Success case logs at Debug level with fields:
|
|
// - sourceVersionAPI, targetVersionAPI, dashboardUID, sourceSchemaVersion, targetSchemaVersion
|
|
|
|
// Failure case logs at Error level with additional fields:
|
|
// - errorType, error (in addition to the success fields)
|
|
|
|
t.Log("✓ Success logging uses Debug level")
|
|
t.Log("✓ Failure logging uses Error level")
|
|
t.Log("✓ All structured fields included in log messages")
|
|
t.Log("✓ Dashboard UID extraction works for different dashboard types")
|
|
t.Log("✓ Wrapper returns nil to avoid 500 response even on errors")
|
|
t.Log("✓ Schema version extraction handles various formats")
|
|
})
|
|
}
|
|
|
|
// TestConversionLoggingFields tests that all expected fields are included in log messages
|
|
func TestConversionLoggingFields(t *testing.T) {
|
|
dsProvider := migrationtestutil.NewDataSourceProvider(migrationtestutil.StandardTestConfig)
|
|
// Use TestLibraryElementProvider for tests that need library panel models with repeat options
|
|
leProvider := migrationtestutil.NewTestLibraryElementProvider()
|
|
migration.Initialize(dsProvider, leProvider, migration.DefaultCacheTTL)
|
|
|
|
t.Run("verify all log fields are present", func(t *testing.T) {
|
|
// Test that the conversion wrapper includes all expected structured fields
|
|
// This is verified by ensuring conversions complete successfully, which means
|
|
// the logging code in withConversionMetrics is executed with all field extractions
|
|
|
|
testCases := []struct {
|
|
name string
|
|
source interface{}
|
|
target interface{}
|
|
}{
|
|
{
|
|
name: "v0 dashboard logging fields",
|
|
source: &dashv0.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "field-test-1"},
|
|
Spec: common.Unstructured{Object: map[string]any{"schemaVersion": 20}},
|
|
},
|
|
target: &dashv1.Dashboard{},
|
|
},
|
|
{
|
|
name: "v1 dashboard logging fields",
|
|
source: &dashv1.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "field-test-2"},
|
|
Spec: common.Unstructured{Object: map[string]any{"schemaVersion": 35}},
|
|
},
|
|
target: &dashv0.Dashboard{},
|
|
},
|
|
{
|
|
name: "v2alpha1 dashboard logging fields",
|
|
source: &dashv2alpha1.Dashboard{
|
|
ObjectMeta: metav1.ObjectMeta{UID: "field-test-3"},
|
|
Spec: dashv2alpha1.DashboardSpec{Title: "test"},
|
|
},
|
|
target: &dashv2beta1.Dashboard{},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
wrapper := withConversionMetrics("test/source", "test/target", func(a, b interface{}, scope conversion.Scope) error {
|
|
return nil
|
|
})
|
|
|
|
err := wrapper(tc.source, tc.target, nil)
|
|
require.NoError(t, err, "conversion should succeed")
|
|
|
|
// The wrapper executed successfully, meaning all field extractions
|
|
// and logging statements were executed with proper structured logging
|
|
t.Log("✓ UID extraction executed")
|
|
t.Log("✓ Schema version extraction executed")
|
|
t.Log("✓ API version identification executed")
|
|
t.Log("✓ Structured logging fields populated")
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestConvertAPIVersionToFuncName(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
input string
|
|
expected string
|
|
}{
|
|
{
|
|
name: "v0alpha1 with full API version",
|
|
input: "dashboard.grafana.app/v0alpha1",
|
|
expected: "V0",
|
|
},
|
|
{
|
|
name: "v1beta1 with full API version",
|
|
input: "dashboard.grafana.app/v1beta1",
|
|
expected: "V1",
|
|
},
|
|
{
|
|
name: "v2alpha1 with full API version",
|
|
input: "dashboard.grafana.app/v2alpha1",
|
|
expected: "V2alpha1",
|
|
},
|
|
{
|
|
name: "v2beta1 with full API version",
|
|
input: "dashboard.grafana.app/v2beta1",
|
|
expected: "V2beta1",
|
|
},
|
|
{
|
|
name: "v0alpha1 without group",
|
|
input: "v0alpha1",
|
|
expected: "V0",
|
|
},
|
|
{
|
|
name: "v1beta1 without group",
|
|
input: "v1beta1",
|
|
expected: "V1",
|
|
},
|
|
{
|
|
name: "v2alpha1 without group",
|
|
input: "v2alpha1",
|
|
expected: "V2alpha1",
|
|
},
|
|
{
|
|
name: "v2beta1 without group",
|
|
input: "v2beta1",
|
|
expected: "V2beta1",
|
|
},
|
|
{
|
|
name: "unknown version",
|
|
input: "unknown/version",
|
|
expected: "version",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
result := convertAPIVersionToFuncName(tc.input)
|
|
require.Equal(t, tc.expected, result)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetErroredConversionFunc(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
err error
|
|
expectedResult string
|
|
}{
|
|
{
|
|
name: "conversion error with function name",
|
|
err: NewConversionError("test error", "v2alpha1", "v2beta1", "ConvertDashboard_V2alpha1_to_V2beta1"),
|
|
expectedResult: "ConvertDashboard_V2alpha1_to_V2beta1",
|
|
},
|
|
{
|
|
name: "migration error with function name",
|
|
err: schemaversion.NewMigrationError("test error", 1, 2, "migration.Migrate"),
|
|
expectedResult: "migration.Migrate",
|
|
},
|
|
{
|
|
name: "regular error",
|
|
err: fmt.Errorf("regular error"),
|
|
expectedResult: "",
|
|
},
|
|
{
|
|
name: "nil error",
|
|
err: nil,
|
|
expectedResult: "",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
result := getErroredConversionFunc(tc.err)
|
|
require.Equal(t, tc.expectedResult, result)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestConversionError(t *testing.T) {
|
|
t.Run("conversion error creation and methods", func(t *testing.T) {
|
|
err := NewConversionError("test error message", "v0alpha1", "v1beta1", "TestFunction")
|
|
|
|
// Test Error() method
|
|
expectedErrorMsg := "conversion from v0alpha1 to v1beta1 failed in TestFunction: test error message"
|
|
require.Equal(t, expectedErrorMsg, err.Error())
|
|
|
|
// Test GetFunctionName() method
|
|
require.Equal(t, "TestFunction", err.GetFunctionName())
|
|
|
|
// Test GetCurrentAPIVersion() method
|
|
require.Equal(t, "v0alpha1", err.GetCurrentAPIVersion())
|
|
|
|
// Test GetTargetAPIVersion() method
|
|
require.Equal(t, "v1beta1", err.GetTargetAPIVersion())
|
|
|
|
// Test that it implements the error interface
|
|
var _ error = err
|
|
})
|
|
}
|