Function TestErrorCodeExtraction

pkg/errors/integration_test.go:132–186

TestErrorCodeExtraction tests that error codes can be reliably extracted from errors returned by the parser using the IsCode helper.

(t *testing.T)

// TestErrorCodeExtraction tests that error codes can be reliably extracted
// from errors returned by the parser using the IsCode helper.
func TestErrorCodeExtraction(t *testing.T) {
	testCases := []struct {
		name         string
		sql          string
		expectedCode errors.ErrorCode
	}{
		{
			name:         "unexpected token after SELECT",
			sql:          "SELECT *** FROM users",
			expectedCode: errors.ErrCodeExpectedToken, // Parser expects FROM, semicolon, or end of statement
		},
		{
			name:         "missing FROM clause",
			sql:          "SELECT * users",
			expectedCode: errors.ErrCodeExpectedToken, // Parser expects FROM keyword
		},
		{
			name:         "invalid WHERE clause",
			sql:          "SELECT * FROM users WHERE",
			expectedCode: errors.ErrCodeExpectedToken, // Expected expression after WHERE, got EOF
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Tokenize
			tkz := tokenizer.GetTokenizer()
			defer tokenizer.PutTokenizer(tkz)

			tokens, err := tkz.Tokenize([]byte(tc.sql))
			if err != nil {
				t.Skipf("Tokenizer error: %v", err)
			}

			// Parse
			p := parser.NewParser()
			_, parseErr := p.ParseFromModelTokens(tokens)

			if parseErr == nil {
				t.Fatalf("Expected error for SQL: %s", tc.sql)
			}

			// Check error code using IsCode
			if !errors.IsCode(parseErr, tc.expectedCode) {
				if structErr, ok := parseErr.(*errors.Error); ok {
					t.Errorf("IsCode returned false for code %s, error has code %s", tc.expectedCode, structErr.Code)
				} else {
					t.Errorf("Error is not structured, cannot extract code: %v", parseErr)
				}
			}

			t.Logf("Successfully verified error code %s matches error: %v", tc.expectedCode, parseErr)
		})
	}
}

// TestErrorLocationPropagation tests that error location information
// propagates correctly from tokenizer through parser.