Function TestParseUpdateCommandWithWhere

parser/parser_test.go:754–805

(t *testing.T)

}

func TestParseUpdateCommandWithWhere(t *testing.T) {
	tests := []struct {
		input                string
		expectedTableName    string
		expectedChanges      map[token.Token]ast.Anonymitifier
		expectedWhereCommand ast.Expression
	}{
		{
			input:             "UPDATE tbl SET colName TO 5 WHERE id EQUAL 3;",
			expectedTableName: "tbl",
			expectedChanges: map[token.Token]ast.Anonymitifier{
				{Type: token.IDENT, Literal: "colName"}: {Token: token.Token{Type: token.LITERAL, Literal: "5"}},
			},
			expectedWhereCommand: ast.ConditionExpression{
				Left:      ast.Identifier{Token: token.Token{Type: token.IDENT, Literal: "id"}},
				Right:     ast.Anonymitifier{Token: token.Token{Type: token.LITERAL, Literal: "3"}},
				Condition: token.Token{Type: token.EQUAL, Literal: "EQUAL"},
			},
		},
	}

	for testIndex, tt := range tests {
		lexer := lexer.RunLexer(tt.input)
		parserInstance := New(lexer)
		sequences, err := parserInstance.ParseSequence()
		if err != nil {
			t.Fatalf("Got error from parser: %s", err)
		}

		if len(sequences.Commands) != 1 {
			t.Fatalf("[%d] sequences does not contain 1 statements. got=%d", testIndex, len(sequences.Commands))
		}

		actualUpdateCommand, ok := sequences.Commands[0].(*ast.UpdateCommand)

		if !ok {
			t.Errorf("[%d] actualUpdateCommand is not %T. got=%T", testIndex, &ast.UpdateCommand{}, sequences.Commands[0])
		}

		if !testUpdateStatement(t, actualUpdateCommand, tt.expectedTableName, tt.expectedChanges) {
			return
		}

		if !actualUpdateCommand.HasWhereCommand() {
			t.Errorf("[%d] actualUpdateCommand should have where command", testIndex)
		}

		if !whereStatementIsValid(t, actualUpdateCommand.WhereCommand, tt.expectedWhereCommand) {
			return
		}
	}
}

func TestParseLogicOperatorsInCommand(t *testing.T) {