fetch_ml/internal/tracking/plugins/wandb_test.go

package plugins_test

import (
	"context"
	"testing"

	"github.com/jfraeys/fetch_ml/internal/tracking"
	"github.com/jfraeys/fetch_ml/internal/tracking/plugins"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// TestNewWandbPlugin tests plugin creation and basic behavior
func TestNewWandbPlugin(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()
	require.NotNil(t, plugin)
	assert.Equal(t, "wandb", plugin.Name(), "plugin name should be wandb")

	// Verify teardown is no-op
	err := plugin.Teardown(context.Background(), "task-1")
	assert.NoError(t, err, "teardown should be no-op")
}

// TestWandbPluginName tests plugin name
func TestWandbPluginName(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()
	assert.Equal(t, "wandb", plugin.Name())
}

// TestWandbPluginProvisionSidecarDisabled tests disabled mode
func TestWandbPluginProvisionSidecarDisabled(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled: false,
		Mode:    tracking.ModeDisabled,
	}

	env, err := plugin.ProvisionSidecar(context.Background(), "task-1", config)
	require.NoError(t, err)
	assert.Nil(t, env)
}

// TestWandbPluginProvisionSidecarRemoteNoKey tests remote mode without API key
func TestWandbPluginProvisionSidecarRemoteNoKey(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled:  true,
		Mode:     tracking.ModeRemote,
		Settings: map[string]any{},
	}

	_, err := plugin.ProvisionSidecar(context.Background(), "task-1", config)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "wandb remote mode requires api_key")
}

// TestWandbPluginProvisionSidecarRemoteWithKey tests remote mode with API key
func TestWandbPluginProvisionSidecarRemoteWithKey(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled: true,
		Mode:    tracking.ModeRemote,
		Settings: map[string]any{
			"api_key": "test-key-123",
			"project": "my-project",
			"entity":  "my-entity",
		},
	}

	env, err := plugin.ProvisionSidecar(context.Background(), "task-1", config)
	require.NoError(t, err)
	require.NotNil(t, env)

	assert.Equal(t, "test-key-123", env["WANDB_API_KEY"])
	assert.Equal(t, "my-project", env["WANDB_PROJECT"])
	assert.Equal(t, "my-entity", env["WANDB_ENTITY"])
}

// TestWandbPluginProvisionSidecarPartialConfig tests with partial configuration
func TestWandbPluginProvisionSidecarPartialConfig(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled: true,
		Mode:    tracking.ModeSidecar,
		Settings: map[string]any{
			"api_key": "test-key",
		},
	}

	env, err := plugin.ProvisionSidecar(context.Background(), "task-1", config)
	require.NoError(t, err)
	require.NotNil(t, env)

	assert.Equal(t, "test-key", env["WANDB_API_KEY"])
	assert.NotContains(t, env, "WANDB_PROJECT")
	assert.NotContains(t, env, "WANDB_ENTITY")
}

// TestWandbPluginProvisionSidecarSidecarEmptySettings tests sidecar mode with empty settings
func TestWandbPluginProvisionSidecarSidecarEmptySettings(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled:  true,
		Mode:     tracking.ModeSidecar,
		Settings: map[string]any{},
	}

	env, err := plugin.ProvisionSidecar(context.Background(), "task-1", config)
	require.NoError(t, err)
	require.NotNil(t, env)
	assert.Empty(t, env, "empty settings should produce empty env")
}

// TestWandbPluginProvisionSidecarRemoteOnlyAPIKey tests remote mode with only api_key
func TestWandbPluginProvisionSidecarRemoteOnlyAPIKey(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled: true,
		Mode:    tracking.ModeRemote,
		Settings: map[string]any{
			"api_key": "test-key",
		},
	}

	env, err := plugin.ProvisionSidecar(context.Background(), "task-1", config)
	require.NoError(t, err)
	require.NotNil(t, env)
	assert.Equal(t, "test-key", env["WANDB_API_KEY"])
	assert.NotContains(t, env, "WANDB_PROJECT")
	assert.NotContains(t, env, "WANDB_ENTITY")
}

// TestWandbPluginTeardown tests teardown (no-op)
func TestWandbPluginTeardown(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	err := plugin.Teardown(context.Background(), "task-1")
	require.NoError(t, err)
}

// TestWandbPluginHealthCheckDisabled tests health check for disabled config
func TestWandbPluginHealthCheckDisabled(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled: false,
	}

	healthy := plugin.HealthCheck(context.Background(), config)
	assert.True(t, healthy)
}

// TestWandbPluginHealthCheckRemoteWithKey tests health check with API key
func TestWandbPluginHealthCheckRemoteWithKey(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled: true,
		Mode:    tracking.ModeRemote,
		Settings: map[string]any{
			"api_key": "test-key",
		},
	}

	healthy := plugin.HealthCheck(context.Background(), config)
	assert.True(t, healthy)
}

// TestWandbPluginHealthCheckRemoteWithoutKey tests health check without API key
func TestWandbPluginHealthCheckRemoteWithoutKey(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled:  true,
		Mode:     tracking.ModeRemote,
		Settings: map[string]any{},
	}

	healthy := plugin.HealthCheck(context.Background(), config)
	assert.False(t, healthy)
}

// TestWandbPluginHealthCheckSidecar tests health check for sidecar mode
func TestWandbPluginHealthCheckSidecar(t *testing.T) {
	t.Parallel()

	plugin := plugins.NewWandbPlugin()

	config := tracking.ToolConfig{
		Enabled:  true,
		Mode:     tracking.ModeSidecar,
		Settings: map[string]any{},
	}

	healthy := plugin.HealthCheck(context.Background(), config)
	assert.True(t, healthy)
}