Test cases improvement

src/query/join.rs

@@ -637,4 +637,292 @@ mod tests {
             .join(" ")
         );
     }
+
+    fn cake_fruit_model(cake_id: i32, cake_name: String, fruit_id: i32, fruit_name: String) 
+    -> (sea_orm::tests_cfg::cake::Model, sea_orm::tests_cfg::fruit::Model) {
+        (cake_model(cake_id, cake_name), fruit_model(fruit_id, fruit_name, Some(cake_id)))
+    }
+
+    fn cake_model(id: i32, name: String) -> sea_orm::tests_cfg::cake::Model {
+        sea_orm::tests_cfg::cake::Model {
+            id,
+            name,
+        }
+    }
+
+    fn fruit_model(id: i32, name: String, cake_id: Option<i32>) -> sea_orm::tests_cfg::fruit::Model {
+        sea_orm::tests_cfg::fruit::Model {
+            id,
+            name,
+            cake_id
+        }
+    }
+
+    #[smol_potat::test]
+    pub async fn also_related() -> Result<(), sea_orm::DbErr> {
+        use sea_orm::{MockDatabase, DbBackend, EntityTrait, QuerySelect, Transaction, Statement};
+        use sea_orm::tests_cfg::*;
+
+        let db = MockDatabase::new(DbBackend::Postgres)
+            .append_query_results([[
+                cake_fruit_model(1, "apple cake".to_owned(), 1, "apple".to_owned())
+                ]])
+            .into_connection();
+
+        assert_eq!(
+            Cake::find()
+            .find_also_related(Fruit)
+            .select_only()
+            .column(cake::Column::Name)
+            .column(fruit::Column::Name)
+            .all(&db)
+            .await?,
+            [
+                (
+                    cake_model(1, "apple cake".to_owned()),
+                    Some(fruit_model(1, "apple".to_owned(), Some(1)))
+                )
+            ]
+        );
+
+        assert_eq!(
+            db.into_transaction_log(),
+            [Transaction::many([Statement::from_sql_and_values(
+                DbBackend::Postgres,
+                [
+                    r#"SELECT "cake"."name", "fruit"."name""#,
+                    r#"FROM "cake""#,
+                    r#"LEFT JOIN "fruit" ON "cake"."id" = "fruit"."cake_id""#
+                ]
+                .join(" ")
+                .as_str(),
+                []
+            ),])]
+        );
+
+        Ok(())
+    }
+
+    #[smol_potat::test]
+    pub async fn also_related_2() -> Result<(), sea_orm::DbErr> {
+        use sea_orm::{MockDatabase, DbBackend, EntityTrait, QuerySelect};
+        use sea_orm::tests_cfg::*;
+
+        let db = MockDatabase::new(DbBackend::Postgres)
+            .append_query_results([[
+                cake_fruit_model(1, "apple cake".to_owned(), 1, "apple".to_owned()),
+                cake_fruit_model(1, "apple cake".to_owned(), 2, "orange".to_owned())
+                ]])
+            .into_connection();
+
+        assert_eq!(
+            Cake::find()
+            .find_also_related(Fruit)
+            .select_only()
+            .column(cake::Column::Name)
+            .column(fruit::Column::Name)
+            .all(&db)
+            .await?,
+            [
+                (
+                    cake_model(1, "apple cake".to_owned()),
+                    Some(fruit_model(1, "apple".to_owned(), Some(1)))
+                ), (
+                    cake_model(1, "apple cake".to_owned()),
+                    Some(fruit_model(2, "orange".to_owned(), Some(1)))
+                )
+            ]
+        );
+
+        Ok(())
+    }
+
+    #[smol_potat::test]
+    pub async fn also_related_3() -> Result<(), sea_orm::DbErr> {
+        use sea_orm::{MockDatabase, DbBackend, EntityTrait, QuerySelect};
+        use sea_orm::tests_cfg::*;
+
+        let db = MockDatabase::new(DbBackend::Postgres)
+            .append_query_results([[
+                cake_fruit_model(1, "apple cake".to_owned(), 1, "apple".to_owned()),
+                cake_fruit_model(1, "apple cake".to_owned(), 2, "orange".to_owned()),
+                cake_fruit_model(2, "orange cake".to_owned(), 2, "orange".to_owned())
+                ]])
+            .into_connection();
+
+        assert_eq!(
+            Cake::find()
+            .find_also_related(Fruit)
+            .select_only()
+            .column(cake::Column::Name)
+            .column(fruit::Column::Name)
+            .all(&db)
+            .await?,
+            [
+                (
+                    cake_model(1, "apple cake".to_owned()),
+                    Some(fruit_model(1, "apple".to_owned(), Some(1)))
+                ), 
+                (
+                    cake_model(1, "apple cake".to_owned()),
+                    Some(fruit_model(2, "orange".to_owned(), Some(1)))
+                ),
+                (
+                    cake_model(2, "orange cake".to_owned()),
+                    Some(fruit_model(2, "orange".to_owned(), Some(2)))
+                )
+            ]
+        );
+
+        Ok(())
+    }
+
+    // fixme: unsure on how to insert a cake with no fruit into query_result
+    // #[smol_potat::test]
+    pub async fn also_related_4() -> Result<(), sea_orm::DbErr> {
+        use sea_orm::{MockDatabase, DbBackend, EntityTrait, QuerySelect};
+        use sea_orm::tests_cfg::*;
+
+        let db = MockDatabase::new(DbBackend::Postgres)
+            .append_query_results([[
+                cake_fruit_model(1, "apple cake".to_owned(), 1, "apple".to_owned()),
+                cake_fruit_model(1, "apple cake".to_owned(), 2, "orange".to_owned()),
+                cake_fruit_model(2, "orange cake".to_owned(), 2, "orange".to_owned()),
+                ]])
+            .append_query_results([[
+                cake_model(3, "chocolate cake".to_owned()) // no fruit in cake
+            ]])
+            .into_connection();
+
+        assert_eq!(
+            Cake::find()
+            .find_also_related(Fruit)
+            .select_only()
+            .column(cake::Column::Name)
+            .column(fruit::Column::Name)
+            .all(&db)
+            .await?,
+            [
+                (
+                    cake_model(1, "apple cake".to_owned()),
+                    Some(fruit_model(1, "apple".to_owned(), Some(1)))
+                ), 
+                (
+                    cake_model(1, "apple cake".to_owned()),
+                    Some(fruit_model(2, "orange".to_owned(), Some(1)))
+                ),
+                (
+                    cake_model(2, "orange cake".to_owned()),
+                    Some(fruit_model(2, "orange".to_owned(), Some(2)))
+                ),
+                (
+                    cake_model(3, "chocolate cake".to_owned()),
+                    None
+                )
+            ]
+        );
+
+        Ok(())
+    }
+
+    #[smol_potat::test]
+    #[cfg(any(
+        feature = "mock",
+    ))]
+    pub async fn with_related() -> Result<(), sea_orm::DbErr> {
+        use sea_orm::{MockDatabase, DbBackend, EntityTrait, QuerySelect, Transaction, Statement};
+        use sea_orm::tests_cfg::*;
+
+        let db = MockDatabase::new(DbBackend::Postgres)
+            .append_query_results([[
+                cake_fruit_model(1, "apple cake".to_owned(), 1, "apple".to_owned()),
+                cake_fruit_model(1, "apple cake".to_owned(), 2, "orange".to_owned())
+            ]])
+            .into_connection();
+
+        assert_eq!(
+            Cake::find()
+            .find_with_related(Fruit)
+            .select_only()
+            .column(cake::Column::Name)
+            .column(fruit::Column::Name)
+            .all(&db)
+            .await?,
+            [
+                (
+                    cake_model(1, "apple cake".to_owned()),
+                    vec![
+                        fruit_model(1, "apple".to_owned(), Some(1)), 
+                        fruit_model(2, "orange".to_owned(), Some(1))
+                    ]
+                )
+            ]
+        );
+
+        assert_eq!(
+            db.into_transaction_log(),
+            [Transaction::many([Statement::from_sql_and_values(
+                DbBackend::Postgres,
+                [
+                    r#"SELECT "cake"."name", "fruit"."name""#,
+                    r#"FROM "cake""#,
+                    r#"LEFT JOIN "fruit" ON "cake"."id" = "fruit"."cake_id""#,
+                    r#"ORDER BY "cake"."id" ASC"#
+                ]
+                .join(" ")
+                .as_str(),
+                []
+            ),])]
+        );
+
+        Ok(())
+    }
+
+    #[smol_potat::test]
+    #[cfg(any(
+        feature = "mock",
+    ))]
+    pub async fn with_related_2() -> Result<(), sea_orm::DbErr> {
+        use sea_orm::{MockDatabase, DbBackend, EntityTrait, QuerySelect};
+        use sea_orm::tests_cfg::*;
+
+        let db = MockDatabase::new(DbBackend::Postgres)
+            .append_query_results([[
+                cake_fruit_model(1, "apple cake".to_owned(), 1, "apple".to_owned()),
+                cake_fruit_model(2, "fruit cake".to_owned(), 1, "apple".to_owned()),
+                cake_fruit_model(2, "fruit cake".to_owned(), 2, "orange".to_owned()),
+                cake_fruit_model(2, "fruit cake".to_owned(), 3, "grape".to_owned()),
+                cake_fruit_model(2, "fruit cake".to_owned(), 4, "melon".to_owned()),
+            ]])
+            .into_connection();
+
+        assert_eq!(
+            Cake::find()
+            .find_with_related(Fruit)
+            .select_only()
+            .column(cake::Column::Name)
+            .column(fruit::Column::Name)
+            .all(&db)
+            .await?,
+            [
+                (
+                    cake_model(1, "apple cake".to_owned()),
+                    vec![
+                        fruit_model(1, "apple".to_owned(), Some(1)), 
+                    ]
+                ),
+                (
+                    cake_model(2, "fruit cake".to_owned()),
+                    vec![
+                        fruit_model(1, "apple".to_owned(), Some(2)), 
+                        fruit_model(2, "orange".to_owned(), Some(2)),
+                        fruit_model(3, "grape".to_owned(), Some(2)),
+                        fruit_model(4, "melon".to_owned(), Some(2)),
+                    ]
+                )
+            ]
+        );
+
+        Ok(())
+    }
 }

tests/active_enum_tests.rs

@@ -371,6 +371,27 @@ pub async fn find_linked_active_enum(db: &DatabaseConnection) -> Result<(), DbEr
             })
         )]
     );
+    assert_eq!(
+        ActiveEnum::find()
+            .find_with_linked(active_enum::ActiveEnumChildLink)
+            .all(db)
+            .await?,
+        [(
+            active_enum::Model {
+                id: 2,
+                category: Some(Category::Small),
+                color: Some(Color::White),
+                tea: Some(Tea::BreakfastTea),
+            },
+            vec![active_enum_child::Model {
+                id: 1,
+                parent_id: 2,
+                category: Some(Category::Big),
+                color: Some(Color::Black),
+                tea: Some(Tea::EverydayTea),
+            }]
+        )]
+    );
 
     assert_eq!(
         active_enum_child::Model {
@@ -411,6 +432,27 @@ pub async fn find_linked_active_enum(db: &DatabaseConnection) -> Result<(), DbEr
             })
         )]
     );
+    assert_eq!(
+        ActiveEnumChild::find()
+            .find_with_linked(active_enum_child::ActiveEnumLink)
+            .all(db)
+            .await?,
+        [(
+            active_enum_child::Model {
+                id: 1,
+                parent_id: 2,
+                category: Some(Category::Big),
+                color: Some(Color::Black),
+                tea: Some(Tea::EverydayTea),
+            },
+            vec![active_enum::Model {
+                id: 2,
+                category: Some(Category::Small),
+                color: Some(Color::White),
+                tea: Some(Tea::BreakfastTea),
+            }]
+        )]
+    );
 
     Ok(())
 }

tests/crud/updates.rs

@@ -52,6 +52,7 @@ pub async fn test_update_cake(db: &DbConn) {
     let cake_model = cake.unwrap();
     assert_eq!(cake_model.name, "Extra chocolate mud cake");
     assert_eq!(cake_model.price, dec!(20.00));
+    assert!(!cake_model.gluten_free);
 }
 
 pub async fn test_update_bakery(db: &DbConn) {

tests/loader_tests.rs

@@ -47,6 +47,7 @@ async fn loader_load_many() -> Result<(), DbErr> {
 
     let bakery_1 = insert_bakery(&ctx.db, "SeaSide Bakery").await?;
     let bakery_2 = insert_bakery(&ctx.db, "Offshore Bakery").await?;
+    let bakery_3 = insert_bakery(&ctx.db, "Offshore Bakery").await?;
 
     let baker_1 = insert_baker(&ctx.db, "Baker 1", bakery_1.id).await?;
     let baker_2 = insert_baker(&ctx.db, "Baker 2", bakery_1.id).await?;
@@ -115,6 +116,7 @@ async fn loader_load_many_multi() -> Result<(), DbErr> {
 
     let bakery_1 = insert_bakery(&ctx.db, "SeaSide Bakery").await?;
     let bakery_2 = insert_bakery(&ctx.db, "Offshore Bakery").await?;
+    let bakery_3 = insert_bakery(&ctx.db, "Onshore Bakery").await?;
 
     let baker_1 = insert_baker(&ctx.db, "John", bakery_1.id).await?;
     let baker_2 = insert_baker(&ctx.db, "Jane", bakery_1.id).await?;
@@ -129,9 +131,9 @@ async fn loader_load_many_multi() -> Result<(), DbErr> {
     let bakers = bakeries.load_many(baker::Entity, &ctx.db).await?;
     let cakes = bakeries.load_many(cake::Entity, &ctx.db).await?;
 
-    assert_eq!(bakeries, [bakery_1, bakery_2]);
-    assert_eq!(bakers, [vec![baker_1, baker_2], vec![baker_3]]);
-    assert_eq!(cakes, [vec![cake_1], vec![cake_2, cake_3]]);
+    assert_eq!(bakeries, [bakery_1, bakery_2, bakery_3]);
+    assert_eq!(bakers, [vec![baker_1, baker_2], vec![baker_3], vec![]]);
+    assert_eq!(cakes, [vec![cake_1], vec![cake_2, cake_3], vec![]]);
 
     Ok(())
 }