Rewrite test code

rikonaka · Jul 7, 2023 · 98a54ad · 98a54ad
1 parent 18c1c90
commit 98a54ad
Show file tree

Hide file tree

Showing 6 changed files with 127 additions and 97 deletions.
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -31,14 +31,15 @@ jobs:
       mariadb:
         image: mariadb
         env:
+          MARIADB_DATABSE: test
           MARIADB_ROOT_PASSWORD: password
         ports:
           - 3306:3306
 
     steps:
     - uses: actions/checkout@v3
-    - name: Init database
-      run: mysql -h127.0.0.1 -P3306 -uroot -ppassword -e "CREATE database test;"
+    # - name: Init mariadb
+    #   run: mysql -h127.0.0.1 -P3306 -uroot -ppassword -e "CREATE database test;"
     - name: Build
       run: cargo build --verbose
     - name: Run tests

diff --git a/README.md b/README.md
@@ -14,67 +14,65 @@ Struct-free Rust SQL tool.
 use rssql::PostgreSQL;
 
 async fn test_postgresql() {
-    // Connect to database
-    let url = "postgre://user:password@docker:15432/test";
-    let mut postgresql = PostgreSQL::connect(url).await.unwrap();
-    // Check connection
+    /// Connect to database.
+    let mut postgresql = PostgreSQL::connect("postgre://user:password@127.0.0.1:5432/test")
+        .await
+        .unwrap();
+    /// Check connection.
     let check = postgresql.check_connection().await;
-    println!("{}", check);
-    // Select all from table `info`
+    assert_eq!(check, true);
+    let sql = "CREATE TABLE IF NOT EXISTS info (id INT PRIMARY KEY NOT NULL, name VARCHAR(16), date DATE)";
+    let _ = postgresql.execute(sql).await.unwrap();
+    /// Insert 10 rows data into table `info`.
+    for i in 0..10 {
+        let sql = format!(
+            "INSERT INTO info (id, name, date) VALUES ({}, 'test{}', '2023-07-07')",
+            i, i
+        );
+        let _ = postgresql.execute(&sql).await.unwrap();
+    }
+    /// Select all from table `info`.
     let rets = postgresql.execute("SELECT * FROM info").await.unwrap();
     // let rets = postgresql.execute_fetch_all("SELECT * FROM info").await.unwrap();
     // let rets = postgresql.execute_fetch_one("SELECT * FROM info").await.unwrap();
     println!("{}", rets);
-    // Insert one row data into table `info`
-    let rets = postgresql.execute("INSERT INTO info (name, date) VALUES ('test3', '2022-01-01')").await.unwrap();
+    /// Get first one from returns by column name.
+    for column in &rets.column {
+        println!("{}", rets.get_first_one(&column).unwrap());
+    }
+    /// Get all by column name.
+    for r in rets.get_all("name").unwrap() {
+        println!("{}", r);
+    }
+    /// Close the connection.
+    postgresql.close().await;
+}
+```
+
+### Show the result
+
+```rust
+use rssql::PostgreSQL;
+
+async fn postgresql_select() {
+    let mut postgresql = PostgreSQL::connect("postgre://user:password@127.0.0.1:5432/test")
+        .await
+        .unwrap();
+    let check = postgresql.check_connection().await;
+    assert_eq!(check, true);
     let rets = postgresql.execute("SELECT * FROM info").await.unwrap();
     println!("{}", rets);
-    // Close the connection
     postgresql.close().await;
 }
 ```
 
 **Output**
 
 ```bash
-true
-+----+-------+------------+
-| id | name  |    date    |
-+----+-------+------------+
-| 1  | test1 | 2023-06-11 |
-| 2  | test2 | 2023-06-11 |
-+----+-------+------------+
 +----+-------+------------+
 | id | name  |    date    |
 +----+-------+------------+
 | 1  | test1 | 2023-06-11 |
 | 2  | test2 | 2023-06-11 |
-| 3  | test3 | 2022-01-01 |
 +----+-------+------------+
-```
-
-### Get data by column name
-
-```rust
-use rssql::PostgreSQL;
-
-async fn test_postgresql_one() {
-    // Connect to database
-    let url = "postgre://user:password@docker:15432/test";
-    let mut postgresql = PostgreSQL::connect(url).await.unwrap();
-    // Check connection
-    let check = postgresql.check_connection().await;
-    println!("{}", check);
-    let rets = postgresql.execute("SELECT * FROM info").await.unwrap();
-    // Get first data by column name 
-    for c in &rets.column {
-        println!("{}", rets.get_first_one(&c).unwrap());
-    }
-    // Get all data by column name 
-    for r in rets.get_all("id").unwrap() {
-        println!("{}", r);
-    }
-    // Close the connection
-    postgresql.close().await;
-}
 ```
diff --git a/src/lib.rs b/src/lib.rs
@@ -61,20 +61,31 @@ impl SQLRets {
     /// Get first data by column name.
     ///
     /// ```
-    /// use rssql::MySQL;
-    /// async fn test_mysql_one() {
-    ///     let url = "mysql://user:password@127.0.0.1:13306/test";
-    ///     let mut mysql = MySQL::connect(url).await.unwrap();
-    ///     let check = mysql.check_connection().await;
-    ///     println!("{}", check);
-    ///     let rets = mysql.execute("SELECT * FROM info").await.unwrap();
-    ///     for c in &rets.column {
-    ///         println!("{}", rets.get_first_one(&c).unwrap());
+    /// use rssql::PostgreSQL;
+    /// async fn get_data() {
+    ///     let mut postgresql = PostgreSQL::connect("postgre://user:password@127.0.0.1:5432/test")
+    ///         .await
+    ///         .unwrap();
+    ///     let check = postgresql.check_connection().await;
+    ///     assert_eq!(check, true);
+    ///     let sql = "CREATE TABLE IF NOT EXISTS info (id INT PRIMARY KEY NOT NULL, name VARCHAR(16), date DATE)";
+    ///     let _ = postgresql.execute(sql).await.unwrap();
+    ///     for i in 0..10 {
+    ///         let sql = format!(
+    ///             "INSERT INTO info (id, name, date) VALUES ({}, 'test{}', '2023-07-07')",
+    ///             i, i
+    ///         );
+    ///         let _ = postgresql.execute(&sql).await.unwrap();
     ///     }
-    ///     for r in rets.get_all("id").unwrap() {
+    ///     let rets = postgresql.execute("SELECT * FROM info").await.unwrap();
+    ///     println!("{}", rets);
+    ///     for column in &rets.column {
+    ///         println!("{}", rets.get_first_one(&column).unwrap());
+    ///     }
+    ///     for r in rets.get_all("name").unwrap() {
     ///         println!("{}", r);
     ///     }
-    ///     mysql.close().await;
+    ///     postgresql.close().await;
     /// }
     /// ```
     pub fn get_first_one(&self, column_name: &str) -> Option<SQLDataTypes> {
@@ -179,10 +190,12 @@ impl SQLite {
     /// ```
     /// use rssql::SQLite;
     /// async fn test_sqlite() {
-    ///     let url = "sqlite:sqlite_test.db?mode=rwc";
-    ///     let mut sqlite = SQLite::connect(url).await.unwrap();
-    ///     let sql = "SELECT * FROM info";
-    ///     let rets = sqlite.execute(sql).await.unwrap();
+    ///     let mut sqlite = SQLite::connect("sqlite:sqlite_test.db?mode=rwc").await.unwrap();
+    ///     let check = sqlite.check_connection().await;
+    ///     assert_eq!(check, true);
+    ///     let _ = sqlite.execute("CREATE TABLE IF NOT EXISTS info (name TEXT, md5 TEXT, sha1 TEXT)").await.unwrap();
+    ///     let _ = sqlite.execute("INSERT INTO info (name, md5, sha1) VALUES ('test1', 'test1', 'test1')").await.unwrap();
+    ///     let rets = sqlite.execute("SELECT * FROM info").await.unwrap();
     ///     println!("{}", rets);
     /// }
     /// ```
@@ -209,7 +222,7 @@ impl SQLite {
         match self.alive {
             true => {
                 let rows = sqlx::query(sql).fetch_all(&mut self.connection).await?;
-                sqlite::row_process(rows).await
+                sqlite::rows_process(rows).await
             }
             false => panic!("{}", CLOSED_CONNECTION_ERROR),
         }
@@ -220,7 +233,7 @@ impl SQLite {
             true => {
                 let row = sqlx::query(sql).fetch_one(&mut self.connection).await?;
                 let rows = vec![row];
-                sqlite::row_process(rows).await
+                sqlite::rows_process(rows).await
             }
             false => panic!("{}", CLOSED_CONNECTION_ERROR),
         }
@@ -260,10 +273,9 @@ impl MySQL {
     /// ```
     /// use rssql::MySQL;
     /// async fn test_mysql() {
-    ///     let url = "mysql://user:password@127.0.0.1:13306/test";
-    ///     let mut mysql = MySQL::connect(url).await.unwrap();
+    ///     let mut mysql = MySQL::connect("mysql://user:password@127.0.0.1:3306/test").await.unwrap();
     ///     let check = mysql.check_connection().await;
-    ///     println!("{}", check);
+    ///     assert_eq!(check, true);
     ///     let rets = mysql.execute("SELECT * FROM info").await.unwrap();
     ///     println!("{}", rets);
     ///     let rets = mysql.execute("INSERT INTO info (name, datetime, date) VALUES ('test3', '2011-01-01', '2011-02-02')").await.unwrap();
@@ -274,7 +286,6 @@ impl MySQL {
     /// ```
     /// # Output
     /// ```bash
-    /// true
     /// +----+-------+---------------------+------------+
     /// | id | name  |      datetime       |    date    |
     /// +----+-------+---------------------+------------+
@@ -303,7 +314,7 @@ impl MySQL {
         match self.alive {
             true => {
                 let rows = sqlx::query(sql).fetch_all(&mut self.connection).await?;
-                mysql::row_process(rows).await
+                mysql::rows_process(rows).await
             }
             false => panic!("{}", CLOSED_CONNECTION_ERROR),
         }
@@ -314,7 +325,7 @@ impl MySQL {
             true => {
                 let row = sqlx::query(sql).fetch_one(&mut self.connection).await?;
                 let rows = vec![row];
-                mysql::row_process(rows).await
+                mysql::rows_process(rows).await
             }
             false => panic!("{}", CLOSED_CONNECTION_ERROR),
         }
@@ -353,18 +364,16 @@ impl PostgreSQL {
     /// ```
     /// use rssql::PostgreSQL;
     /// async fn test_postgresql() {
-    ///     let url = "postgre://user:password@127.0.0.1:15432/test";
-    ///     let mut postgresql = PostgreSQL::connect(url).await.unwrap();
+    ///     let mut postgresql = PostgreSQL::connect("postgre://user:password@127.0.0.1:5432/test").await.unwrap();
     ///     let check = postgresql.check_connection().await;
-    ///     println!("{}", check);
+    ///     assert_eq!(check, true);
     ///     let rets = postgresql.execute("SELECT * FROM info").await.unwrap();
     ///     println!("{}", rets);
     ///     postgresql.close().await;
     /// }
     /// ```
     /// # Output
     /// ```bash
-    /// true
     /// +----+-------+------------+
     /// | id | name  |    date    |
     /// +----+-------+------------+
@@ -386,7 +395,7 @@ impl PostgreSQL {
         match self.alive {
             true => {
                 let rows = sqlx::query(sql).fetch_all(&mut self.connection).await?;
-                postgresql::row_process(rows).await
+                postgresql::rows_process(rows).await
             }
             false => panic!("{}", CLOSED_CONNECTION_ERROR),
         }
@@ -397,7 +406,7 @@ impl PostgreSQL {
             true => {
                 let row = sqlx::query(sql).fetch_one(&mut self.connection).await?;
                 let rows = vec![row];
-                postgresql::row_process(rows).await
+                postgresql::rows_process(rows).await
             }
             false => panic!("{}", CLOSED_CONNECTION_ERROR),
         }
@@ -430,26 +439,39 @@ mod tests {
     use super::*;
     #[tokio::test]
     async fn test_sqlite() {
-        let url = "sqlite:test.db?mode=rwc";
-        let mut sqlite = SQLite::connect(url).await.unwrap();
-        let sql = "CREATE TABLE IF NOT EXISTS info (name TEXT, md5 TEXT, sha1 TEXT)";
-        let _ = sqlite.execute(sql).await.unwrap();
-        let sql = "INSERT INTO info (name, md5, sha1) VALUES ('test1', 'test1', 'test1')";
-        let _ = sqlite.execute(sql).await.unwrap();
-        let sql = "SELECT * FROM info";
-        let rets = sqlite.execute(sql).await.unwrap();
+        let mut sqlite = SQLite::connect("sqlite:test.db?mode=rwc").await.unwrap();
+        let check = sqlite.check_connection().await;
+        assert_eq!(check, true);
+        let _ = sqlite
+            .execute("CREATE TABLE IF NOT EXISTS info (name TEXT, md5 TEXT, sha1 TEXT)")
+            .await
+            .unwrap();
+        for i in 0..10 {
+            let sql = format!(
+                "INSERT INTO info (name, md5, sha1) VALUES ('test{}', 'md5{}', 'sha1{}')",
+                i, i, i
+            );
+            let _ = sqlite.execute(&sql).await.unwrap();
+        }
+        let rets = sqlite.execute("SELECT * FROM info").await.unwrap();
         println!("{}", rets);
     }
     #[tokio::test]
     async fn test_mysql() {
-        let url = "mysql://root:password@127.0.0.1:3306/test";
-        let mut mysql = MySQL::connect(url).await.unwrap();
+        let mut mysql = MySQL::connect("mysql://root:password@127.0.0.1:3306/test")
+            .await
+            .unwrap();
         let check = mysql.check_connection().await;
-        println!("{}", check);
-        let sql = "CREATE TABLE IF NOT EXISTS info (id INT PRIMARY KEY NOT NULL AUTO_INCREMENT, name VARCHAR(30) NOT NULL, date DATE NOT NULL)";
-        let _ = mysql.execute(sql).await.unwrap();
-        let sql = "INSERT INTO info (id, name, date) VALUES (1, 'test3', '2011-02-02')";
+        assert_eq!(check, true);
+        let sql = "CREATE TABLE IF NOT EXISTS info (id INT PRIMARY KEY NOT NULL AUTO_INCREMENT, name VARCHAR(16), date DATE)";
         let _ = mysql.execute(sql).await.unwrap();
+        for i in 0..10 {
+            let sql = format!(
+                "INSERT INTO info (id, name, date) VALUES ({}, 'test{}', '2023-07-07')",
+                i, i
+            );
+            let _ = mysql.execute(&sql).await.unwrap();
+        }
         let rets = mysql.execute("SELECT * FROM info").await.unwrap();
         println!("{}", rets);
         for column in &rets.column {
@@ -462,16 +484,25 @@ mod tests {
     }
     #[tokio::test]
     async fn test_postgresql() {
-        let url = "postgre://user:password@127.0.0.1:5432/test";
-        let mut postgresql = PostgreSQL::connect(url).await.unwrap();
+        let mut postgresql = PostgreSQL::connect("postgre://user:password@127.0.0.1:5432/test")
+            .await
+            .unwrap();
         let check = postgresql.check_connection().await;
-        println!("{}", check);
-        let sql = "CREATE TABLE IF NOT EXISTS info (id INT PRIMARY KEY NOT NULL, name VARCHAR(30) NOT NULL, date DATE NOT NULL)";
-        let _ = postgresql.execute(sql).await.unwrap();
-        let sql = "INSERT INTO info (id, name, date) VALUES (1, 'test3', '2011-02-02')";
+        assert_eq!(check, true);
+        let sql = "CREATE TABLE IF NOT EXISTS info (id INT PRIMARY KEY NOT NULL, name VARCHAR(16), date DATE)";
         let _ = postgresql.execute(sql).await.unwrap();
+        for i in 0..10 {
+            let sql = format!(
+                "INSERT INTO info (id, name, date) VALUES ({}, 'test{}', '2023-07-07')",
+                i, i
+            );
+            let _ = postgresql.execute(&sql).await.unwrap();
+        }
         let rets = postgresql.execute("SELECT * FROM info").await.unwrap();
         println!("{}", rets);
+        for column in &rets.column {
+            println!("{}", rets.get_first_one(&column).unwrap());
+        }
         for r in rets.get_all("name").unwrap() {
             println!("{}", r);
         }

diff --git a/src/mysql.rs b/src/mysql.rs
@@ -63,7 +63,7 @@ impl fmt::Display for MySQLDataTypes {
     }
 }
 
-pub async fn row_process(rows: Vec<MySqlRow>) -> anyhow::Result<SQLRets> {
+pub async fn rows_process(rows: Vec<MySqlRow>) -> anyhow::Result<SQLRets> {
     let mut sql_rets = SQLRets::new();
 
     if rows.len() > 0 {

diff --git a/src/postgresql.rs b/src/postgresql.rs
@@ -100,7 +100,7 @@ impl fmt::Display for PostgreSQLDataTypes {
     }
 }
 
-pub async fn row_process(rows: Vec<PgRow>) -> anyhow::Result<SQLRets> {
+pub async fn rows_process(rows: Vec<PgRow>) -> anyhow::Result<SQLRets> {
     let mut sql_rets = SQLRets::new();
 
     if rows.len() > 0 {

diff --git a/src/sqlite.rs b/src/sqlite.rs
@@ -42,7 +42,7 @@ impl fmt::Display for SQLiteDataTypes {
     }
 }
 
-pub async fn row_process(rows: Vec<SqliteRow>) -> anyhow::Result<SQLRets> {
+pub async fn rows_process(rows: Vec<SqliteRow>) -> anyhow::Result<SQLRets> {
     let mut sql_rets = SQLRets::new();
 
     if rows.len() > 0 {