Function TestErrorPropagation_TokenizerToParser

pkg/errors/integration_test.go:27–128

TestErrorPropagation_TokenizerToParser tests that errors from the tokenizer propagate correctly with error codes intact through the parsing pipeline.

(t *testing.T)

// TestErrorPropagation_TokenizerToParser tests that errors from the tokenizer
// propagate correctly with error codes intact through the parsing pipeline.
func TestErrorPropagation_TokenizerToParser(t *testing.T) {
	tests := []struct {
		name           string
		sql            string
		expectedCode   errors.ErrorCode
		expectedInMsg  string
		checkTokenizer bool // if true, we expect tokenizer to catch the error
	}{
		{
			name:          "unterminated string literal",
			sql:           "SELECT * FROM users WHERE name = 'unterminated",
			expectedCode:  errors.ErrCodeUnterminatedString,
			expectedInMsg: "unterminated",
		},
		{
			name:          "unexpected token in SELECT",
			sql:           "SELECT * FROM",
			expectedCode:  errors.ErrCodeExpectedToken, // Expects table name after FROM
			expectedInMsg: "expected",
		},
		{
			name:          "incomplete SQL statement",
			sql:           "",
			expectedCode:  errors.ErrCodeIncompleteStatement,
			expectedInMsg: "incomplete",
		},
		{
			name:          "invalid syntax - missing table name",
			sql:           "INSERT INTO VALUES (1, 2)",
			expectedCode:  errors.ErrCodeExpectedToken, // Parser expects table name after INSERT INTO
			expectedInMsg: "expected",
		},
		{
			name:          "unexpected keyword usage",
			sql:           "SELECT FROM users",
			expectedCode:  errors.ErrCodeExpectedToken,
			expectedInMsg: "expected",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Get tokenizer from pool
			tkz := tokenizer.GetTokenizer()
			defer tokenizer.PutTokenizer(tkz)

			// Tokenize the input
			tokens, tokenErr := tkz.Tokenize([]byte(tt.sql))

			// If tokenizer caught an error with a code, verify it
			if tokenErr != nil {
				if err, ok := tokenErr.(*errors.Error); ok {
					if err.Code != "" {
						t.Logf("Tokenizer caught error with code: %s", err.Code)
						// Verify the error code is what we expected
						if tt.checkTokenizer && err.Code != tt.expectedCode {
							t.Errorf("Tokenizer error code mismatch: expected %s, got %s", tt.expectedCode, err.Code)
						}