coder/coderd/templatebuilder/errors_test.go

package templatebuilder_test

import (
	"strings"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/coder/coder/v2/coderd/templatebuilder"
)

func TestClassifyProvisionerError(t *testing.T) {
	t.Parallel()

	t.Run("NetworkErrors", func(t *testing.T) {
		t.Parallel()

		tests := []struct {
			name     string
			jobError string
			logs     []string
		}{
			{
				name:     "DNSFailure",
				jobError: "init failed",
				logs:     []string{"Error: Failed to query available provider packages", "dial tcp: lookup registry.terraform.io: no such host"},
			},
			{
				name:     "ConnectionRefused",
				jobError: "terraform init: connection refused",
				logs:     nil,
			},
			{
				name:     "IOTimeout",
				jobError: "context deadline exceeded",
				logs:     []string{"dial tcp 1.2.3.4:443: i/o timeout"},
			},
			{
				name:     "TLSTimeout",
				jobError: "init error",
				logs:     []string{"net/http: TLS handshake timeout"},
			},
		}

		for _, tc := range tests {
			t.Run(tc.name, func(t *testing.T) {
				t.Parallel()
				result := templatebuilder.ClassifyProvisionerError(tc.jobError, tc.logs)
				require.Contains(t, result, "unreachable from your provisioner")
			})
		}
	})

	t.Run("NetworkTakesPrecedenceOverAuth", func(t *testing.T) {
		t.Parallel()
		// When both network and auth patterns appear, network wins
		// (checked first).
		result := templatebuilder.ClassifyProvisionerError(
			"connection refused",
			[]string{"AccessDenied: check credentials"},
		)
		require.Contains(t, result, "unreachable from your provisioner")
	})

	t.Run("AuthErrors", func(t *testing.T) {
		t.Parallel()

		tests := []struct {
			name     string
			jobError string
			logs     []string
		}{
			{
				name:     "AWSNoCredentials",
				jobError: "terraform plan: exit status 1",
				logs: []string{
					"Initializing the backend...",
					"Initializing provider plugins...",
					"Error: No valid credential sources found",
					"",
					"  on main.tf line 10, in provider \"aws\":",
					"  10:   region = \"us-east-1\"",
				},
			},
			{
				name:     "GCPDefaultCredentials",
				jobError: "terraform plan: exit status 1",
				logs: []string{
					"Error: could not find default credentials",
				},
			},
			{
				name:     "AzureAuthFailure",
				jobError: "terraform plan: exit status 1",
				logs:     []string{"Error: AuthorizationFailed for subscription"},
			},
			{
				name:     "CaseInsensitive",
				jobError: "terraform plan: exit status 1",
				logs:     []string{"Error: ACCESSDENIED on resource"},
			},
		}

		for _, tc := range tests {
			t.Run(tc.name, func(t *testing.T) {
				t.Parallel()
				result := templatebuilder.ClassifyProvisionerError(tc.jobError, tc.logs)
				require.Contains(t, result, "Cloud provider authentication failed")
			})
		}
	})

	t.Run("AuthErrorNoLogsNoDanglingNewlines", func(t *testing.T) {
		t.Parallel()
		// Auth pattern in jobError with nil logs should not produce
		// trailing newlines.
		result := templatebuilder.ClassifyProvisionerError(
			"AccessDenied: you are not allowed",
			nil,
		)
		require.Contains(t, result, "Cloud provider authentication failed")
		require.False(t, strings.HasSuffix(result, "\n"), "should not end with newline")
	})

	t.Run("UnrecognizedErrorIncludesLogs", func(t *testing.T) {
		t.Parallel()
		result := templatebuilder.ClassifyProvisionerError(
			"terraform plan: exit status 1",
			[]string{
				"Initializing the backend...",
				"Initializing provider plugins...",
				"",
				"Error: Unsupported block type",
				"",
				"  on main.tf line 5, in resource \"null_resource\" \"test\":",
				"  5:   invalid_block {",
			},
		)
		require.Contains(t, result, "terraform plan: exit status 1")
		require.Contains(t, result, "Unsupported block type")
		require.Contains(t, result, "on main.tf line 5")
	})

	t.Run("UnrecognizedErrorNoLogs", func(t *testing.T) {
		t.Parallel()
		result := templatebuilder.ClassifyProvisionerError(
			"terraform plan: exit status 1",
			nil,
		)
		require.Equal(t, "terraform plan: exit status 1", result)
	})

	t.Run("EmptyErrorPassthrough", func(t *testing.T) {
		t.Parallel()
		result := templatebuilder.ClassifyProvisionerError("", nil)
		require.Equal(t, "", result)
	})

	t.Run("MultipleDiagnosticBlocks", func(t *testing.T) {
		t.Parallel()
		result := templatebuilder.ClassifyProvisionerError(
			"terraform plan: exit status 1",
			[]string{
				"Warning: Deprecated resource",
				"  Use the new resource instead.",
				"",
				"Error: Invalid reference",
				"  on main.tf line 12:",
				"  12:   value = var.undefined",
			},
		)
		require.Contains(t, result, "Deprecated resource")
		require.Contains(t, result, "Invalid reference")
		require.Contains(t, result, "on main.tf line 12")
	})

	t.Run("LogContextCappedAtMax", func(t *testing.T) {
		t.Parallel()
		var logs []string
		for i := 0; i < 50; i++ {
			logs = append(logs, "Error: problem number "+strings.Repeat("x", 10))
		}
		result := templatebuilder.ClassifyProvisionerError("exit status 1", logs)
		parts := strings.SplitN(result, "\n\n", 2)
		require.Len(t, parts, 2, "should have jobError and log context")
		contextLines := strings.Split(strings.TrimSpace(parts[1]), "\n")
		// 20 diagnostic lines + 1 truncation marker.
		require.Equal(t, 21, len(contextLines))
		require.Equal(t, "... (truncated)", contextLines[20])
	})

	t.Run("NonDiagnosticLogsFiltered", func(t *testing.T) {
		t.Parallel()
		result := templatebuilder.ClassifyProvisionerError(
			"terraform plan: exit status 1",
			[]string{
				"Initializing the backend...",
				"Initializing provider plugins...",
				"- Finding latest version of hashicorp/aws...",
				"- Installing hashicorp/aws v5.0.0...",
			},
		)
		require.Equal(t, "terraform plan: exit status 1", result)
	})
}

func TestClassifyProvisionerErrorCategory(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		jobError string
		logs     []string
		expected templatebuilder.ProvisionerErrorCategory
	}{
		{
			name:     "DNSFailure",
			jobError: "init failed",
			logs:     []string{"dial tcp: lookup registry.terraform.io: no such host"},
			expected: templatebuilder.ProvisionerErrorNetwork,
		},
		{
			name:     "TLSTimeout",
			jobError: "init error",
			logs:     []string{"net/http: TLS handshake timeout"},
			expected: templatebuilder.ProvisionerErrorNetwork,
		},
		{
			name:     "AWSNoCredentials",
			jobError: "terraform plan: exit status 1",
			logs:     []string{"Error: No valid credential sources found"},
			expected: templatebuilder.ProvisionerErrorAuth,
		},
		{
			name:     "CaseInsensitiveAuth",
			jobError: "terraform plan: exit status 1",
			logs:     []string{"Error: ACCESSDENIED on resource"},
			expected: templatebuilder.ProvisionerErrorAuth,
		},
		{
			name:     "NetworkTakesPrecedenceOverAuth",
			jobError: "connection refused",
			logs:     []string{"AccessDenied: check credentials"},
			expected: templatebuilder.ProvisionerErrorNetwork,
		},
		{
			name:     "TerraformSyntaxError",
			jobError: "terraform plan: exit status 1",
			logs:     []string{"Error: Unsupported block type"},
			expected: templatebuilder.ProvisionerErrorUnknown,
		},
		{
			name:     "Empty",
			jobError: "",
			logs:     nil,
			expected: templatebuilder.ProvisionerErrorUnknown,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			require.Equal(t, tc.expected,
				templatebuilder.ClassifyProvisionerErrorCategory(tc.jobError, tc.logs))
		})
	}
}

// The message shown to the user and the category reported as telemetry are
// derived from the same classification, so they must agree.
func TestClassifyProvisionerErrorMessageMatchesCategory(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name            string
		jobError        string
		logs            []string
		category        templatebuilder.ProvisionerErrorCategory
		messageContains string
	}{
		{
			name:            "Network",
			jobError:        "terraform init: connection refused",
			category:        templatebuilder.ProvisionerErrorNetwork,
			messageContains: "unreachable from your provisioner",
		},
		{
			name:            "Auth",
			jobError:        "AccessDenied: you are not allowed",
			category:        templatebuilder.ProvisionerErrorAuth,
			messageContains: "Cloud provider authentication failed",
		},
		{
			name:            "Unknown",
			jobError:        "terraform plan: exit status 1",
			category:        templatebuilder.ProvisionerErrorUnknown,
			messageContains: "terraform plan: exit status 1",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			require.Equal(t, tc.category,
				templatebuilder.ClassifyProvisionerErrorCategory(tc.jobError, tc.logs))
			require.Contains(t,
				templatebuilder.ClassifyProvisionerError(tc.jobError, tc.logs),
				tc.messageContains)
		})
	}
}