Test baker and bakery create

tests/bakery_chain_tests.rs

@@ -25,5 +25,6 @@ async fn setup_schema(db: &DbConn) {
 }
 
 async fn create_entities(db: &DbConn) {
-    assert!(crud::create_bakery(db).await.is_ok());
+    crud::test_create_bakery(db).await;
+    crud::test_create_baker(db).await;
 }

tests/crud/mod.rs

@@ -1,21 +1,80 @@
-use sea_orm::{entity::*, error::*, DbConn, InsertResult};
+use sea_orm::{entity::*, DbConn, InsertResult};
 
 pub use super::bakery_chain::*;
 
-pub async fn create_bakery(db: &DbConn) -> Result<(), DbErr> {
+pub async fn test_create_bakery(db: &DbConn) {
     let seaside_bakery = bakery::ActiveModel {
         name: Set("SeaSide Bakery".to_owned()),
         profit_margin: Set(10.4),
         ..Default::default()
     };
-    let res: InsertResult = Bakery::insert(seaside_bakery).exec(db).await?;
+    let res: InsertResult = Bakery::insert(seaside_bakery)
+        .exec(db)
+        .await
+        .expect("could not insert bakery");
 
-    let bakery: Option<bakery::Model> = Bakery::find_by_id(res.last_insert_id).one(db).await?;
+    let bakery: Option<bakery::Model> = Bakery::find_by_id(res.last_insert_id)
+        .one(db)
+        .await
+        .expect("could not find bakery");
 
     assert!(bakery.is_some());
     let bakery_model = bakery.unwrap();
     assert_eq!(bakery_model.name, "SeaSide Bakery");
     assert_eq!(bakery_model.profit_margin, 10.4);
-
-    Ok(())
+}
+
+pub async fn test_create_baker(db: &DbConn) {
+    let seaside_bakery = bakery::ActiveModel {
+        name: Set("SeaSide Bakery".to_owned()),
+        profit_margin: Set(10.4),
+        ..Default::default()
+    };
+    let bakery_insert_res: InsertResult = Bakery::insert(seaside_bakery)
+        .exec(db)
+        .await
+        .expect("could not insert bakery");
+
+    let baker_bob = baker::ActiveModel {
+        name: Set("Baker Bob".to_owned()),
+        bakery_id: Set(Some(bakery_insert_res.last_insert_id as i32)),
+        ..Default::default()
+    };
+    let res: InsertResult = Baker::insert(baker_bob)
+        .exec(db)
+        .await
+        .expect("could not insert baker");
+
+    let baker: Option<baker::Model> = Baker::find_by_id(res.last_insert_id)
+        .one(db)
+        .await
+        .expect("could not find baker");
+
+    assert!(baker.is_some());
+    let baker_model = baker.unwrap();
+    assert_eq!(baker_model.name, "Baker Bob");
+    assert_eq!(
+        baker_model
+            .find_related(Bakery)
+            .one(db)
+            .await
+            .expect("Bakery not found")
+            .unwrap()
+            .name,
+        "SeaSide Bakery"
+    );
+
+    let bakery: Option<bakery::Model> = Bakery::find_by_id(bakery_insert_res.last_insert_id)
+        .one(db)
+        .await
+        .unwrap();
+
+    let related_bakers: Vec<baker::Model> = bakery
+        .unwrap()
+        .find_related(Baker)
+        .all(db)
+        .await
+        .expect("could not find related bakers");
+    assert_eq!(related_bakers.len(), 1);
+    assert_eq!(related_bakers[0].name, "Baker Bob")
 }

tests/schema/mod.rs

@@ -38,7 +38,7 @@ pub async fn create_baker_table(db: &DbConn) -> Result<ExecResult, DbErr> {
         .primary_key(),
     )
     .col(ColumnDef::new(baker::Column::Name).string())
-    .col(ColumnDef::new(baker::Column::BakeryId).integer().not_null())
+    .col(ColumnDef::new(baker::Column::BakeryId).integer())
     .foreign_key(
       ForeignKey::create()
         .name("FK_baker_bakery")