caisin/sea-orm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cargo +nightly fmt

Browse Source
This commit is contained in:
Billy Chan 2021-07-26 14:56:56 +08:00
parent f11f7e1c19
commit 571210748f
No known key found for this signature in database
GPG Key ID: A2D690CAC7DF3CC7
2 changed files with 279 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
tests/crud/create_baker.rs
View File

@ -2,78 +2,78 @@ pub use super::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
pub async fn test_create_baker(db: &DbConn) { pub async fn test_create_baker(db: &DbConn) {
let seaside_bakery = bakery::ActiveModel { let seaside_bakery = bakery::ActiveModel {
name: Set("SeaSide Bakery".to_owned()), name: Set("SeaSide Bakery".to_owned()),
profit_margin: Set(10.4), profit_margin: Set(10.4),
..Default::default() ..Default::default()
}; };
let bakery_insert_res: InsertResult = Bakery::insert(seaside_bakery) let bakery_insert_res: InsertResult = Bakery::insert(seaside_bakery)
.exec(db) .exec(db)
.await .await
.expect("could not insert bakery"); .expect("could not insert bakery");
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
struct ContactDetails { struct ContactDetails {
mobile: String, mobile: String,
home: String, home: String,
address: String, address: String,
} }
let baker_bob_contact = ContactDetails { let baker_bob_contact = ContactDetails {
mobile: "+61424000000".to_owned(), mobile: "+61424000000".to_owned(),
home: "0395555555".to_owned(), home: "0395555555".to_owned(),
address: "12 Test St, Testville, Vic, Australia".to_owned(), address: "12 Test St, Testville, Vic, Australia".to_owned(),
}; };
let baker_bob = baker::ActiveModel { let baker_bob = baker::ActiveModel {
name: Set("Baker Bob".to_owned()), name: Set("Baker Bob".to_owned()),
contact_details: Set(serde_json::json!(baker_bob_contact)), contact_details: Set(serde_json::json!(baker_bob_contact)),
bakery_id: Set(Some(bakery_insert_res.last_insert_id as i32)), bakery_id: Set(Some(bakery_insert_res.last_insert_id as i32)),
..Default::default() ..Default::default()
}; };
let res: InsertResult = Baker::insert(baker_bob) let res: InsertResult = Baker::insert(baker_bob)
.exec(db) .exec(db)
.await .await
.expect("could not insert baker"); .expect("could not insert baker");
let baker: Option<baker::Model> = Baker::find_by_id(res.last_insert_id) let baker: Option<baker::Model> = Baker::find_by_id(res.last_insert_id)
.one(db) .one(db)
.await .await
.expect("could not find baker"); .expect("could not find baker");
assert!(baker.is_some()); assert!(baker.is_some());
let baker_model = baker.unwrap(); let baker_model = baker.unwrap();
assert_eq!(baker_model.name, "Baker Bob"); assert_eq!(baker_model.name, "Baker Bob");
assert_eq!( assert_eq!(
baker_model.contact_details["mobile"], baker_model.contact_details["mobile"],
baker_bob_contact.mobile baker_bob_contact.mobile
); );
assert_eq!(baker_model.contact_details["home"], baker_bob_contact.home); assert_eq!(baker_model.contact_details["home"], baker_bob_contact.home);
assert_eq!( assert_eq!(
baker_model.contact_details["address"], baker_model.contact_details["address"],
baker_bob_contact.address baker_bob_contact.address
); );
assert_eq!( assert_eq!(
baker_model baker_model
.find_related(Bakery) .find_related(Bakery)
.one(db) .one(db)
.await .await
.expect("Bakery not found") .expect("Bakery not found")
.unwrap() .unwrap()
.name, .name,
"SeaSide Bakery" "SeaSide Bakery"
); );
let bakery: Option<bakery::Model> = Bakery::find_by_id(bakery_insert_res.last_insert_id) let bakery: Option<bakery::Model> = Bakery::find_by_id(bakery_insert_res.last_insert_id)
.one(db) .one(db)
.await .await
.unwrap(); .unwrap();
let related_bakers: Vec<baker::Model> = bakery let related_bakers: Vec<baker::Model> = bakery
.unwrap() .unwrap()
.find_related(Baker) .find_related(Baker)
.all(db) .all(db)
.await .await
.expect("could not find related bakers"); .expect("could not find related bakers");
assert_eq!(related_bakers.len(), 1); assert_eq!(related_bakers.len(), 1);
assert_eq!(related_bakers[0].name, "Baker Bob") assert_eq!(related_bakers[0].name, "Baker Bob")
} }

422
tests/sequential_op_tests.rs
View File

@ -10,260 +10,260 @@ pub use common::{bakery_chain::*, setup::*, TestContext};
#[async_std::test] #[async_std::test]
#[cfg(feature = "sqlx-mysql")] #[cfg(feature = "sqlx-mysql")]
pub async fn test_multiple_operations() { pub async fn test_multiple_operations() {
let ctx = TestContext::new("mysql://root:@localhost", "multiple_sequential_operations").await; let ctx = TestContext::new("mysql://root:@localhost", "multiple_sequential_operations").await;
init_setup(&ctx.db).await; init_setup(&ctx.db).await;
let baker_least_sales = find_baker_least_sales(&ctx.db).await.unwrap(); let baker_least_sales = find_baker_least_sales(&ctx.db).await.unwrap();
assert_eq!(baker_least_sales.name, "Baker 2"); assert_eq!(baker_least_sales.name, "Baker 2");
let new_cake = create_cake(&ctx.db, baker_least_sales).await.unwrap(); let new_cake = create_cake(&ctx.db, baker_least_sales).await.unwrap();
create_order(&ctx.db, new_cake).await; create_order(&ctx.db, new_cake).await;
let baker_least_sales = find_baker_least_sales(&ctx.db).await.unwrap(); let baker_least_sales = find_baker_least_sales(&ctx.db).await.unwrap();
assert_eq!(baker_least_sales.name, "Baker 1"); assert_eq!(baker_least_sales.name, "Baker 1");
} }
async fn init_setup(db: &DatabaseConnection) { async fn init_setup(db: &DatabaseConnection) {
let bakery = bakery::ActiveModel { let bakery = bakery::ActiveModel {
name: Set("SeaSide Bakery".to_owned()), name: Set("SeaSide Bakery".to_owned()),
profit_margin: Set(10.4), profit_margin: Set(10.4),
..Default::default() ..Default::default()
} }
.save(db) .save(db)
.await
.expect("could not insert bakery");
let baker_1 = baker::ActiveModel {
name: Set("Baker 1".to_owned()),
contact_details: Set(serde_json::json!({})),
bakery_id: Set(Some(bakery.id.clone().unwrap())),
..Default::default()
}
.save(db)
.await
.expect("could not insert baker");
let _baker_2 = baker::ActiveModel {
name: Set("Baker 2".to_owned()),
contact_details: Set(serde_json::json!({})),
bakery_id: Set(Some(bakery.id.clone().unwrap())),
..Default::default()
}
.save(db)
.await
.expect("could not insert baker");
let mud_cake = cake::ActiveModel {
name: Set("Mud Cake".to_owned()),
price: Set(dec!(10.25)),
gluten_free: Set(false),
serial: Set(Uuid::new_v4()),
bakery_id: Set(Some(bakery.id.clone().unwrap())),
..Default::default()
};
let cake_insert_res: InsertResult = Cake::insert(mud_cake)
.exec(db)
.await .await
.expect("could not insert cake"); .expect("could not insert bakery");
let cake_baker = cakes_bakers::ActiveModel { let baker_1 = baker::ActiveModel {
cake_id: Set(cake_insert_res.last_insert_id as i32), name: Set("Baker 1".to_owned()),
baker_id: Set(baker_1.id.clone().unwrap()), contact_details: Set(serde_json::json!({})),
..Default::default() bakery_id: Set(Some(bakery.id.clone().unwrap())),
}; ..Default::default()
}
let _cake_baker_res: InsertResult = CakesBakers::insert(cake_baker) .save(db)
.exec(db)
.await .await
.expect("could not insert cake_baker"); .expect("could not insert baker");
let customer_kate = customer::ActiveModel { let _baker_2 = baker::ActiveModel {
name: Set("Kate".to_owned()), name: Set("Baker 2".to_owned()),
..Default::default() contact_details: Set(serde_json::json!({})),
} bakery_id: Set(Some(bakery.id.clone().unwrap())),
.save(db) ..Default::default()
.await }
.expect("could not insert customer"); .save(db)
.await
.expect("could not insert baker");
let kate_order_1 = order::ActiveModel { let mud_cake = cake::ActiveModel {
bakery_id: Set(Some(bakery.id.clone().unwrap())), name: Set("Mud Cake".to_owned()),
customer_id: Set(Some(customer_kate.id.clone().unwrap())), price: Set(dec!(10.25)),
total: Set(dec!(99.95)), gluten_free: Set(false),
placed_at: Set(Utc::now().naive_utc()), serial: Set(Uuid::new_v4()),
bakery_id: Set(Some(bakery.id.clone().unwrap())),
..Default::default()
};
..Default::default() let cake_insert_res: InsertResult = Cake::insert(mud_cake)
} .exec(db)
.save(db) .await
.await .expect("could not insert cake");
.expect("could not insert order");
let _lineitem = lineitem::ActiveModel { let cake_baker = cakes_bakers::ActiveModel {
cake_id: Set(Some(cake_insert_res.last_insert_id as i32)), cake_id: Set(cake_insert_res.last_insert_id as i32),
price: Set(dec!(10.00)), baker_id: Set(baker_1.id.clone().unwrap()),
quantity: Set(12), ..Default::default()
order_id: Set(Some(kate_order_1.id.clone().unwrap())), };
..Default::default()
}
.save(db)
.await
.expect("could not insert order");
let _lineitem2 = lineitem::ActiveModel { let _cake_baker_res: InsertResult = CakesBakers::insert(cake_baker)
cake_id: Set(Some(cake_insert_res.last_insert_id as i32)), .exec(db)
price: Set(dec!(50.00)), .await
quantity: Set(2), .expect("could not insert cake_baker");
order_id: Set(Some(kate_order_1.id.clone().unwrap())),
..Default::default() let customer_kate = customer::ActiveModel {
} name: Set("Kate".to_owned()),
.save(db) ..Default::default()
.await }
.expect("could not insert order"); .save(db)
.await
.expect("could not insert customer");
let kate_order_1 = order::ActiveModel {
bakery_id: Set(Some(bakery.id.clone().unwrap())),
customer_id: Set(Some(customer_kate.id.clone().unwrap())),
total: Set(dec!(99.95)),
placed_at: Set(Utc::now().naive_utc()),
..Default::default()
}
.save(db)
.await
.expect("could not insert order");
let _lineitem = lineitem::ActiveModel {
cake_id: Set(Some(cake_insert_res.last_insert_id as i32)),
price: Set(dec!(10.00)),
quantity: Set(12),
order_id: Set(Some(kate_order_1.id.clone().unwrap())),
..Default::default()
}
.save(db)
.await
.expect("could not insert order");
let _lineitem2 = lineitem::ActiveModel {
cake_id: Set(Some(cake_insert_res.last_insert_id as i32)),
price: Set(dec!(50.00)),
quantity: Set(2),
order_id: Set(Some(kate_order_1.id.clone().unwrap())),
..Default::default()
}
.save(db)
.await
.expect("could not insert order");
} }
async fn find_baker_least_sales(db: &DatabaseConnection) -> Option<baker::Model> { async fn find_baker_least_sales(db: &DatabaseConnection) -> Option<baker::Model> {
#[derive(Debug, FromQueryResult)] #[derive(Debug, FromQueryResult)]
struct SelectResult { struct SelectResult {
id: i32, id: i32,
cakes_sold_opt: Option<Decimal>, cakes_sold_opt: Option<Decimal>,
} }
#[derive(Debug)] #[derive(Debug)]
struct LeastSalesBakerResult { struct LeastSalesBakerResult {
id: i32, id: i32,
cakes_sold: Decimal, cakes_sold: Decimal,
} }
let rel: RelationDef = cakes_bakers::Entity::belongs_to(baker::Entity) let rel: RelationDef = cakes_bakers::Entity::belongs_to(baker::Entity)
.from(cakes_bakers::Column::BakerId) .from(cakes_bakers::Column::BakerId)
.to(baker::Column::Id) .to(baker::Column::Id)
.into(); .into();
let rel2: RelationDef = cakes_bakers::Entity::belongs_to(cake::Entity) let rel2: RelationDef = cakes_bakers::Entity::belongs_to(cake::Entity)
.from(cakes_bakers::Column::CakeId) .from(cakes_bakers::Column::CakeId)
.to(cake::Column::Id) .to(cake::Column::Id)
.into(); .into();
let rel3: RelationDef = cake::Entity::has_many(lineitem::Entity) let rel3: RelationDef = cake::Entity::has_many(lineitem::Entity)
.from(cake::Column::Id) .from(cake::Column::Id)
.to(lineitem::Column::CakeId) .to(lineitem::Column::CakeId)
.into(); .into();
let select = cakes_bakers::Entity::find() let select = cakes_bakers::Entity::find()
.join(JoinType::RightJoin, rel) .join(JoinType::RightJoin, rel)
.join(JoinType::LeftJoin, rel2) .join(JoinType::LeftJoin, rel2)
.join(JoinType::LeftJoin, rel3) .join(JoinType::LeftJoin, rel3)
.select_only() .select_only()
.column(baker::Column::Id) .column(baker::Column::Id)
.column_as(lineitem::Column::Quantity.sum(), "cakes_sold_opt") .column_as(lineitem::Column::Quantity.sum(), "cakes_sold_opt")
.group_by(baker::Column::Id); .group_by(baker::Column::Id);
let mut results: Vec<LeastSalesBakerResult> = select let mut results: Vec<LeastSalesBakerResult> = select
.into_model::<SelectResult>() .into_model::<SelectResult>()
.all(&db) .all(&db)
.await .await
.unwrap() .unwrap()
.into_iter() .into_iter()
.map(|b| LeastSalesBakerResult { .map(|b| LeastSalesBakerResult {
id: b.id.clone(), id: b.id.clone(),
cakes_sold: b.cakes_sold_opt.unwrap_or(dec!(0)), cakes_sold: b.cakes_sold_opt.unwrap_or(dec!(0)),
}) })
.collect(); .collect();
results.sort_by(|a, b| b.cakes_sold.cmp(&a.cakes_sold)); results.sort_by(|a, b| b.cakes_sold.cmp(&a.cakes_sold));
Baker::find_by_id(results.last().unwrap().id) Baker::find_by_id(results.last().unwrap().id)
.one(db) .one(db)
.await .await
.unwrap() .unwrap()
} }
async fn create_cake(db: &DatabaseConnection, baker: baker::Model) -> Option<cake::Model> { async fn create_cake(db: &DatabaseConnection, baker: baker::Model) -> Option<cake::Model> {
let new_cake = cake::ActiveModel { let new_cake = cake::ActiveModel {
name: Set("New Cake".to_owned()), name: Set("New Cake".to_owned()),
price: Set(dec!(8.00)), price: Set(dec!(8.00)),
gluten_free: Set(false), gluten_free: Set(false),
serial: Set(Uuid::new_v4()), serial: Set(Uuid::new_v4()),
bakery_id: Set(Some(baker.bakery_id.clone().unwrap())), bakery_id: Set(Some(baker.bakery_id.clone().unwrap())),
..Default::default() ..Default::default()
}; };
let cake_insert_res: InsertResult = Cake::insert(new_cake) let cake_insert_res: InsertResult = Cake::insert(new_cake)
.exec(db) .exec(db)
.await .await
.expect("could not insert cake"); .expect("could not insert cake");
let cake_baker = cakes_bakers::ActiveModel { let cake_baker = cakes_bakers::ActiveModel {
cake_id: Set(cake_insert_res.last_insert_id as i32), cake_id: Set(cake_insert_res.last_insert_id as i32),
baker_id: Set(baker.id), baker_id: Set(baker.id),
..Default::default() ..Default::default()
}; };
let _cake_baker_res: InsertResult = CakesBakers::insert(cake_baker) let _cake_baker_res: InsertResult = CakesBakers::insert(cake_baker)
.exec(db) .exec(db)
.await .await
.expect("could not insert cake_baker"); .expect("could not insert cake_baker");
Cake::find_by_id(cake_insert_res.last_insert_id) Cake::find_by_id(cake_insert_res.last_insert_id)
.one(db) .one(db)
.await .await
.unwrap() .unwrap()
} }
async fn create_order(db: &DatabaseConnection, cake: cake::Model) { async fn create_order(db: &DatabaseConnection, cake: cake::Model) {
let another_customer = customer::ActiveModel { let another_customer = customer::ActiveModel {
name: Set("John".to_owned()), name: Set("John".to_owned()),
..Default::default() ..Default::default()
} }
.save(db) .save(db)
.await .await
.expect("could not insert customer"); .expect("could not insert customer");
let order = order::ActiveModel { let order = order::ActiveModel {
bakery_id: Set(Some(cake.bakery_id.unwrap())), bakery_id: Set(Some(cake.bakery_id.unwrap())),
customer_id: Set(Some(another_customer.id.clone().unwrap())), customer_id: Set(Some(another_customer.id.clone().unwrap())),
total: Set(dec!(200.00)), total: Set(dec!(200.00)),
placed_at: Set(Utc::now().naive_utc()), placed_at: Set(Utc::now().naive_utc()),
..Default::default() ..Default::default()
} }
.save(db) .save(db)
.await .await
.expect("could not insert order"); .expect("could not insert order");
let _lineitem = lineitem::ActiveModel { let _lineitem = lineitem::ActiveModel {
cake_id: Set(Some(cake.id)), cake_id: Set(Some(cake.id)),
price: Set(dec!(10.00)), price: Set(dec!(10.00)),
quantity: Set(300), quantity: Set(300),
order_id: Set(Some(order.id.clone().unwrap())), order_id: Set(Some(order.id.clone().unwrap())),
..Default::default() ..Default::default()
} }
.save(db) .save(db)
.await .await
.expect("could not insert order"); .expect("could not insert order");
} }
pub async fn test_delete_bakery(db: &DatabaseConnection) { pub async fn test_delete_bakery(db: &DatabaseConnection) {
let initial_bakeries = Bakery::find().all(db).await.unwrap().len(); let initial_bakeries = Bakery::find().all(db).await.unwrap().len();
let bakery = bakery::ActiveModel { let bakery = bakery::ActiveModel {
name: Set("SeaSide Bakery".to_owned()), name: Set("SeaSide Bakery".to_owned()),
profit_margin: Set(10.4), profit_margin: Set(10.4),
..Default::default() ..Default::default()
} }
.save(db) .save(db)
.await .await
.expect("could not insert bakery"); .expect("could not insert bakery");
assert_eq!( assert_eq!(
Bakery::find().all(db).await.unwrap().len(), Bakery::find().all(db).await.unwrap().len(),
initial_bakeries + 1 initial_bakeries + 1
); );
let _result = bakery.delete(db).await.expect("failed to delete bakery"); let _result = bakery.delete(db).await.expect("failed to delete bakery");
assert_eq!( assert_eq!(
Bakery::find().all(db).await.unwrap().len(), Bakery::find().all(db).await.unwrap().len(),
initial_bakeries initial_bakeries
); );
} }