[#153] 테스트 커버리지 회복

src/ast/dml/delete.rs

@@ -48,6 +48,7 @@ impl From<DeleteQuery> for SQLStatement {
 }
 
 #[cfg(test)]
+#[allow(non_snake_case)]
 mod tests {
     use crate::ast::types::SQLExpression;
 
@@ -76,4 +77,20 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn test_From_DeleteQuery_for_SQLStatement() {
+        let delete_query = DeleteQuery::builder()
+            .set_from_table(TableName::new(None, "table".into()))
+            .set_where(WhereClause {
+                expression: SQLExpression::String("a".into()),
+            })
+            .build();
+
+        let sql_statement: SQLStatement = delete_query.clone().into();
+        assert_eq!(
+            sql_statement,
+            SQLStatement::DML(DMLStatement::DeleteQuery(delete_query))
+        );
+    }
 }

src/ast/dml/insert.rs

@@ -61,3 +61,33 @@ impl From<InsertQuery> for SQLStatement {
         SQLStatement::DML(DMLStatement::InsertQuery(value))
     }
 }
+
+#[cfg(test)]
+#[allow(non_snake_case)]
+mod tests {
+    use crate::ast::types::SQLExpression;
+
+    use super::*;
+
+    #[test]
+    fn test_From_InsertQuery_for_SQLStatement() {
+        let insert_query = InsertQuery::builder()
+            .set_into_table(TableName::new(None, "table".into()))
+            .set_columns(vec!["a".into(), "b".into()])
+            .set_values(vec![InsertValue {
+                list: vec![Some(SQLExpression::String("a".into()))],
+            }])
+            .build();
+
+        assert_eq!(
+            SQLStatement::from(insert_query),
+            SQLStatement::DML(DMLStatement::InsertQuery(InsertQuery {
+                into_table: Some(TableName::new(None, "table".into())),
+                columns: vec!["a".into(), "b".into()],
+                data: InsertData::Values(vec![InsertValue {
+                    list: vec![Some(SQLExpression::String("a".into()))],
+                }]),
+            }))
+        );
+    }
+}

src/ast/dml/select.rs

@@ -287,4 +287,34 @@ mod tests {
         assert_eq!(aggregate_columns.len(), 1);
         assert_eq!(aggregate_columns[0].column_name, "bar");
     }
+
+    #[test]
+    fn test_From_SelectQuery_for_SQLStatement() {
+        let select_query = SelectQuery::builder()
+            .add_select_item(
+                SelectItem::builder()
+                    .set_item(SQLExpression::String("a".into()))
+                    .build(),
+            )
+            .build();
+
+        assert_eq!(
+            SQLStatement::from(select_query),
+            SQLStatement::DML(DMLStatement::SelectQuery(SelectQuery {
+                select_items: vec![SelectKind::SelectItem(SelectItem {
+                    item: Some(SQLExpression::String("a".into())),
+                    alias: None
+                })],
+                from_table: None,
+                join_clause: vec![],
+                where_clause: None,
+                order_by_clause: None,
+                group_by_clause: None,
+                having_clause: None,
+                limit: None,
+                offset: None,
+                has_aggregate: false,
+            }))
+        );
+    }
 }

src/ast/dml/update.rs

@@ -55,6 +55,7 @@ impl From<UpdateQuery> for SQLStatement {
 }
 
 #[cfg(test)]
+#[allow(non_snake_case)]
 mod tests {
     use crate::ast::types::SQLExpression;
 
@@ -90,4 +91,22 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn test_From_UpdateQuery_for_SQLStatement() {
+        let update_query = UpdateQuery::builder()
+            .set_target_table(TableName::new(None, "table".into()))
+            .add_update_item(UpdateItem {
+                column: "a".into(),
+                value: SQLExpression::String("b".into()),
+            })
+            .set_where(WhereClause {
+                expression: SQLExpression::String("a".into()),
+            })
+            .build();
+        assert_eq!(
+            SQLStatement::from(update_query.clone()),
+            SQLStatement::DML(DMLStatement::UpdateQuery(update_query))
+        );
+    }
 }

src/lexer/test/select.rs

@@ -72,12 +72,31 @@ pub fn select_text() {
         expected: Vec<Token>,
     }
 
-    let test_cases = vec![TestCase {
-        name: "문자열: 'I''m Sam'".to_owned(),
-        input: r#"SELECT 'I''m Sam'"#.to_owned(),
-        want_error: false,
-        expected: vec![Token::Select, Token::String("I'm Sam".to_owned())],
-    }];
+    let test_cases = vec![
+        TestCase {
+            name: "문자열: 'I''m Sam'".to_owned(),
+            input: r#"SELECT 'I''m Sam'"#.to_owned(),
+            want_error: false,
+            expected: vec![Token::Select, Token::String("I'm Sam".to_owned())],
+        },
+        TestCase {
+            name: "빈 문자열".to_owned(),
+            input: r#"SELECT ''"#.to_owned(),
+            want_error: false,
+            expected: vec![Token::Select, Token::String("".to_owned())],
+        },
+        TestCase {
+            name: "빈 문자열 as foo".to_owned(),
+            input: r#"SELECT '' as foo"#.to_owned(),
+            want_error: false,
+            expected: vec![
+                Token::Select,
+                Token::String("".to_owned()),
+                Token::As,
+                Token::Identifier("foo".to_owned()),
+            ],
+        },
+    ];
 
     for t in test_cases {
         let got = Tokenizer::string_to_tokens(t.input);
@@ -180,6 +199,60 @@ pub fn test_operators() {
                 Token::Integer(2),
             ],
         },
+        TestCase {
+            name: "연산자: -".to_owned(),
+            input: r#"SELECT 1 - 2"#.to_owned(),
+            want_error: false,
+            expected: vec![
+                Token::Select,
+                Token::Integer(1),
+                Token::Operator(OperatorToken::Minus),
+                Token::Integer(2),
+            ],
+        },
+        TestCase {
+            name: "연산자: +".to_owned(),
+            input: r#"SELECT 1 + 2"#.to_owned(),
+            want_error: false,
+            expected: vec![
+                Token::Select,
+                Token::Integer(1),
+                Token::Operator(OperatorToken::Plus),
+                Token::Integer(2),
+            ],
+        },
+        TestCase {
+            name: "연산자: *".to_owned(),
+            input: r#"SELECT 1 * 2"#.to_owned(),
+            want_error: false,
+            expected: vec![
+                Token::Select,
+                Token::Integer(1),
+                Token::Operator(OperatorToken::Asterisk),
+                Token::Integer(2),
+            ],
+        },
+        TestCase {
+            name: "연산자: =".to_owned(),
+            input: r#"SELECT 1 = 2"#.to_owned(),
+            want_error: false,
+            expected: vec![
+                Token::Select,
+                Token::Integer(1),
+                Token::Operator(OperatorToken::Eq),
+                Token::Integer(2),
+            ],
+        },
+        TestCase {
+            name: "연산자: !".to_owned(),
+            input: r#"SELECT ! True"#.to_owned(),
+            want_error: false,
+            expected: vec![
+                Token::Select,
+                Token::Operator(OperatorToken::Not),
+                Token::Boolean(true),
+            ],
+        },
     ];
 
     for t in test_cases {
@@ -216,6 +289,17 @@ pub fn test_identifier() {
             want_error: false,
             expected: vec![Token::Select, Token::Identifier("foo".to_owned())],
         },
+        TestCase {
+            name: "백틱 파싱 as foo".to_owned(),
+            input: r#"SELECT `foo` as foo"#.to_owned(),
+            want_error: false,
+            expected: vec![
+                Token::Select,
+                Token::Identifier("foo".to_owned()),
+                Token::As,
+                Token::Identifier("foo".to_owned()),
+            ],
+        },
         TestCase {
             name: "백틱 안에 백틱 파싱".to_owned(),
             input: r#"SELECT `foo``bar`"#.to_owned(),
@@ -322,3 +406,15 @@ pub fn select_from_where_1() {
 //         ]
 //     );
 // }
+
+#[test]
+fn test_command_query() {
+    let text = r#"\l"#.to_owned();
+
+    let tokens = Tokenizer::string_to_tokens(text).unwrap();
+
+    assert_eq!(
+        tokens,
+        vec![Token::Backslash, Token::Identifier("l".to_owned()),]
+    );
+}