test(provider): cover resolveEffectiveProvider and isOpenAICompatibleProvider

Both helpers had partial coverage — resolveEffectiveProvider's 'explicit Provider wins' branch was implicitly exercised through the merge tests, and isOpenAICompatibleProvider's alias-table tail was completely uncovered (80%).

Add focused, table-driven tests:

  - resolveEffectiveProvider: documents the explicit-Provider-wins contract and the openai backward-compat fallback when Provider is empty.

  - isOpenAICompatibleProvider: walks the actual Aliases map and asserts that every alias whose APIType is 'openai' is reported as compatible. This means new openai-flavoured aliases automatically get coverage when they're added.

Both helpers now reach 100% coverage; package coverage 95.8% -> 96.4%.

Assisted-By: docker-agent

Author: dgageot

pkg/model/provider/resolve_test.go

@@ -0,0 +1,74 @@
+package provider
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/docker/docker-agent/pkg/config/latest"
+)
+
+func TestResolveEffectiveProvider(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		cfg  latest.ProviderConfig
+		want string
+	}{
+		{
+			name: "explicit Provider wins",
+			cfg:  latest.ProviderConfig{Provider: "anthropic"},
+			want: "anthropic",
+		},
+		{
+			name: "empty Provider falls back to openai (backward compat)",
+			cfg:  latest.ProviderConfig{},
+			want: "openai",
+		},
+		{
+			name: "explicit Provider wins even if APIType also set",
+			cfg:  latest.ProviderConfig{Provider: "google", APIType: "openai_chatcompletions"},
+			want: "google",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			assert.Equal(t, tt.want, resolveEffectiveProvider(tt.cfg))
+		})
+	}
+}
+
+func TestIsOpenAICompatibleProvider(t *testing.T) {
+	t.Parallel()
+
+	// Direct OpenAI api types — first switch arm.
+	openAIArm := []string{"openai", "openai_chatcompletions", "openai_responses"}
+	for _, p := range openAIArm {
+		t.Run("direct/"+p, func(t *testing.T) {
+			t.Parallel()
+			assert.True(t, isOpenAICompatibleProvider(p))
+		})
+	}
+
+	// Aliases that point to the openai api — the previously-uncovered tail.
+	for name, alias := range Aliases {
+		if alias.APIType == "openai" {
+			t.Run("alias/"+name, func(t *testing.T) {
+				t.Parallel()
+				assert.True(t, isOpenAICompatibleProvider(name), "alias %s should map to openai", name)
+			})
+		}
+	}
+
+	// Negative cases.
+	negatives := []string{"anthropic", "google", "dmr", "amazon-bedrock", "unknown", ""}
+	for _, p := range negatives {
+		t.Run("negative/"+p, func(t *testing.T) {
+			t.Parallel()
+			assert.False(t, isOpenAICompatibleProvider(p))
+		})
+	}
+}