You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
782 lines
23 KiB
782 lines
23 KiB
use crate::model::cfd::{Cfd, CfdState, Order, OrderId};
|
|
use crate::model::{BitMexPriceEventId, Usd};
|
|
use anyhow::{Context, Result};
|
|
use rocket_db_pools::sqlx;
|
|
use rust_decimal::Decimal;
|
|
use sqlx::pool::PoolConnection;
|
|
use sqlx::{Sqlite, SqlitePool};
|
|
use std::mem;
|
|
use std::str::FromStr;
|
|
use std::time::SystemTime;
|
|
use time::{Duration, OffsetDateTime};
|
|
|
|
pub async fn run_migrations(pool: &SqlitePool) -> anyhow::Result<()> {
|
|
sqlx::migrate!("./migrations").run(pool).await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn insert_order(order: &Order, conn: &mut PoolConnection<Sqlite>) -> anyhow::Result<()> {
|
|
sqlx::query(
|
|
r#"insert into orders (
|
|
uuid,
|
|
trading_pair,
|
|
position,
|
|
initial_price,
|
|
min_quantity,
|
|
max_quantity,
|
|
leverage,
|
|
liquidation_price,
|
|
creation_timestamp_seconds,
|
|
creation_timestamp_nanoseconds,
|
|
term_seconds,
|
|
term_nanoseconds,
|
|
origin,
|
|
oracle_event_id
|
|
) values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)"#,
|
|
)
|
|
.bind(&order.id)
|
|
.bind(&order.trading_pair)
|
|
.bind(&order.position)
|
|
.bind(&order.price.to_string())
|
|
.bind(&order.min_quantity.to_string())
|
|
.bind(&order.max_quantity.to_string())
|
|
.bind(order.leverage.0)
|
|
.bind(&order.liquidation_price.to_string())
|
|
.bind(
|
|
order
|
|
.creation_timestamp
|
|
.duration_since(SystemTime::UNIX_EPOCH)?
|
|
.as_secs() as i64,
|
|
)
|
|
.bind(
|
|
order
|
|
.creation_timestamp
|
|
.duration_since(SystemTime::UNIX_EPOCH)?
|
|
.subsec_nanos() as i32,
|
|
)
|
|
.bind(&order.term.whole_seconds())
|
|
.bind(&order.term.subsec_nanoseconds())
|
|
.bind(&order.origin)
|
|
.bind(&order.oracle_event_id.to_string())
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn load_order_by_id(
|
|
id: OrderId,
|
|
conn: &mut PoolConnection<Sqlite>,
|
|
) -> anyhow::Result<Order> {
|
|
let row = sqlx::query!(
|
|
r#"
|
|
select
|
|
uuid as "uuid: crate::model::cfd::OrderId",
|
|
trading_pair as "trading_pair: crate::model::TradingPair",
|
|
position as "position: crate::model::Position",
|
|
initial_price,
|
|
min_quantity,
|
|
max_quantity,
|
|
leverage as "leverage: crate::model::Leverage",
|
|
liquidation_price,
|
|
creation_timestamp_seconds as "ts_secs: i64",
|
|
creation_timestamp_nanoseconds as "ts_nanos: i32",
|
|
term_seconds as "term_secs: i64",
|
|
term_nanoseconds as "term_nanos: i32",
|
|
origin as "origin: crate::model::cfd::Origin",
|
|
oracle_event_id
|
|
|
|
from orders
|
|
where uuid = $1
|
|
"#,
|
|
id
|
|
)
|
|
.fetch_one(conn)
|
|
.await?;
|
|
|
|
Ok(Order {
|
|
id: row.uuid,
|
|
trading_pair: row.trading_pair,
|
|
position: row.position,
|
|
price: Usd(Decimal::from_str(&row.initial_price)?),
|
|
min_quantity: Usd(Decimal::from_str(&row.min_quantity)?),
|
|
max_quantity: Usd(Decimal::from_str(&row.max_quantity)?),
|
|
leverage: row.leverage,
|
|
liquidation_price: Usd(Decimal::from_str(&row.liquidation_price)?),
|
|
creation_timestamp: convert_to_system_time(row.ts_secs, row.ts_nanos)?,
|
|
term: Duration::new(row.term_secs, row.term_nanos),
|
|
origin: row.origin,
|
|
oracle_event_id: row.oracle_event_id.parse::<BitMexPriceEventId>()?,
|
|
})
|
|
}
|
|
|
|
pub async fn insert_cfd(cfd: Cfd, conn: &mut PoolConnection<Sqlite>) -> anyhow::Result<()> {
|
|
let order_uuid = &cfd.order.id;
|
|
let quantity_usd = &cfd.quantity_usd.to_string();
|
|
let state = serde_json::to_string(&cfd.state)?;
|
|
sqlx::query!(
|
|
r#"
|
|
insert into cfds (
|
|
order_id,
|
|
order_uuid,
|
|
quantity_usd
|
|
)
|
|
select
|
|
id as order_id,
|
|
uuid as order_uuid,
|
|
$2 as quantity_usd
|
|
from orders
|
|
where uuid = $1;
|
|
|
|
insert into cfd_states (
|
|
cfd_id,
|
|
state
|
|
)
|
|
select
|
|
id as cfd_id,
|
|
$3 as state
|
|
from cfds
|
|
order by id desc limit 1;
|
|
"#,
|
|
order_uuid,
|
|
quantity_usd,
|
|
state
|
|
)
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub async fn insert_new_cfd_state_by_order_id(
|
|
order_id: OrderId,
|
|
new_state: &CfdState,
|
|
conn: &mut PoolConnection<Sqlite>,
|
|
) -> anyhow::Result<()> {
|
|
let cfd_id = load_cfd_id_by_order_uuid(order_id, conn).await?;
|
|
let latest_cfd_state_in_db = load_latest_cfd_state(cfd_id, conn)
|
|
.await
|
|
.context("loading latest state failed")?;
|
|
|
|
if mem::discriminant(&latest_cfd_state_in_db) == mem::discriminant(new_state) {
|
|
// Since we have states where we add information this happens quite frequently
|
|
tracing::trace!(
|
|
"Same state transition for cfd with order_id {}: {}",
|
|
order_id,
|
|
latest_cfd_state_in_db
|
|
);
|
|
}
|
|
|
|
let cfd_state = serde_json::to_string(new_state)?;
|
|
|
|
sqlx::query!(
|
|
r#"
|
|
insert into cfd_states (
|
|
cfd_id,
|
|
state
|
|
) values ($1, $2);
|
|
"#,
|
|
cfd_id,
|
|
cfd_state,
|
|
)
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
async fn load_cfd_id_by_order_uuid(
|
|
order_uuid: OrderId,
|
|
conn: &mut PoolConnection<Sqlite>,
|
|
) -> anyhow::Result<i64> {
|
|
let cfd_id = sqlx::query!(
|
|
r#"
|
|
select
|
|
id
|
|
from cfds
|
|
where order_uuid = $1;
|
|
"#,
|
|
order_uuid
|
|
)
|
|
.fetch_one(conn)
|
|
.await?;
|
|
|
|
let cfd_id = cfd_id.id.context("No cfd found")?;
|
|
|
|
Ok(cfd_id)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
async fn load_latest_cfd_state(
|
|
cfd_id: i64,
|
|
conn: &mut PoolConnection<Sqlite>,
|
|
) -> anyhow::Result<CfdState> {
|
|
let latest_cfd_state = sqlx::query!(
|
|
r#"
|
|
select
|
|
state
|
|
from cfd_states
|
|
where cfd_id = $1
|
|
order by id desc
|
|
limit 1;
|
|
"#,
|
|
cfd_id
|
|
)
|
|
.fetch_one(conn)
|
|
.await?;
|
|
|
|
let latest_cfd_state_in_db: CfdState = serde_json::from_str(latest_cfd_state.state.as_str())?;
|
|
|
|
Ok(latest_cfd_state_in_db)
|
|
}
|
|
|
|
pub async fn load_cfd_by_order_id(
|
|
order_id: OrderId,
|
|
conn: &mut PoolConnection<Sqlite>,
|
|
) -> Result<Cfd> {
|
|
let row = sqlx::query!(
|
|
r#"
|
|
with ord as (
|
|
select
|
|
id as order_id,
|
|
uuid,
|
|
trading_pair,
|
|
position,
|
|
initial_price,
|
|
min_quantity,
|
|
max_quantity,
|
|
leverage,
|
|
liquidation_price,
|
|
creation_timestamp_seconds as ts_secs,
|
|
creation_timestamp_nanoseconds as ts_nanos,
|
|
term_seconds as term_secs,
|
|
term_nanoseconds as term_nanos,
|
|
origin,
|
|
oracle_event_id
|
|
from orders
|
|
),
|
|
|
|
cfd as (
|
|
select
|
|
id as cfd_id,
|
|
order_id,
|
|
quantity_usd
|
|
from cfds
|
|
),
|
|
|
|
tmp as (
|
|
select
|
|
id as state_id,
|
|
cfd_id,
|
|
state
|
|
from cfd_states
|
|
),
|
|
|
|
state as (
|
|
select
|
|
tmp.state,
|
|
cfd.order_id,
|
|
cfd.quantity_usd
|
|
from tmp
|
|
inner join cfd on tmp.cfd_id = cfd.cfd_id
|
|
where tmp.state_id in (
|
|
select max(state_id)
|
|
from tmp
|
|
group by state_id
|
|
)
|
|
)
|
|
|
|
select
|
|
ord.uuid as "uuid: crate::model::cfd::OrderId",
|
|
ord.trading_pair as "trading_pair: crate::model::TradingPair",
|
|
ord.position as "position: crate::model::Position",
|
|
ord.initial_price,
|
|
ord.min_quantity,
|
|
ord.max_quantity,
|
|
ord.leverage as "leverage: crate::model::Leverage",
|
|
ord.liquidation_price,
|
|
ord.ts_secs as "ts_secs: i64",
|
|
ord.ts_nanos as "ts_nanos: i32",
|
|
ord.term_secs as "term_secs: i64",
|
|
ord.term_nanos as "term_nanos: i32",
|
|
ord.origin as "origin: crate::model::cfd::Origin",
|
|
ord.oracle_event_id,
|
|
state.quantity_usd,
|
|
state.state
|
|
|
|
from ord
|
|
inner join state on state.order_id = ord.order_id
|
|
|
|
where ord.uuid = $1
|
|
"#,
|
|
order_id
|
|
)
|
|
.fetch_one(conn)
|
|
.await?;
|
|
|
|
let order = Order {
|
|
id: row.uuid,
|
|
trading_pair: row.trading_pair,
|
|
position: row.position,
|
|
price: Usd(Decimal::from_str(&row.initial_price)?),
|
|
min_quantity: Usd(Decimal::from_str(&row.min_quantity)?),
|
|
max_quantity: Usd(Decimal::from_str(&row.max_quantity)?),
|
|
leverage: row.leverage,
|
|
liquidation_price: Usd(Decimal::from_str(&row.liquidation_price)?),
|
|
creation_timestamp: convert_to_system_time(row.ts_secs, row.ts_nanos)?,
|
|
term: Duration::new(row.term_secs, row.term_nanos),
|
|
origin: row.origin,
|
|
oracle_event_id: row.oracle_event_id.parse::<BitMexPriceEventId>()?,
|
|
};
|
|
|
|
// TODO:
|
|
// still have the use of serde_json::from_str() here, which will be dealt with
|
|
// via https://github.com/comit-network/hermes/issues/290
|
|
Ok(Cfd {
|
|
order,
|
|
quantity_usd: Usd(Decimal::from_str(&row.quantity_usd)?),
|
|
state: serde_json::from_str(row.state.as_str())?,
|
|
})
|
|
}
|
|
|
|
/// Loads all CFDs with the latest state as the CFD state
|
|
pub async fn load_all_cfds(conn: &mut PoolConnection<Sqlite>) -> anyhow::Result<Vec<Cfd>> {
|
|
let rows = sqlx::query!(
|
|
r#"
|
|
with ord as (
|
|
select
|
|
id as order_id,
|
|
uuid,
|
|
trading_pair,
|
|
position,
|
|
initial_price,
|
|
min_quantity,
|
|
max_quantity,
|
|
leverage,
|
|
liquidation_price,
|
|
creation_timestamp_seconds as ts_secs,
|
|
creation_timestamp_nanoseconds as ts_nanos,
|
|
term_seconds as term_secs,
|
|
term_nanoseconds as term_nanos,
|
|
origin,
|
|
oracle_event_id
|
|
from orders
|
|
),
|
|
|
|
cfd as (
|
|
select
|
|
id as cfd_id,
|
|
order_id,
|
|
quantity_usd as quantity_usd
|
|
from cfds
|
|
),
|
|
|
|
tmp as (
|
|
select
|
|
id as state_id,
|
|
cfd_id,
|
|
state
|
|
from cfd_states
|
|
),
|
|
|
|
state as (
|
|
select
|
|
tmp.state,
|
|
cfd.order_id,
|
|
cfd.quantity_usd
|
|
from tmp
|
|
inner join cfd on tmp.cfd_id = cfd.cfd_id
|
|
where tmp.state_id in (
|
|
select max(state_id)
|
|
from tmp
|
|
group by state_id
|
|
)
|
|
)
|
|
|
|
select
|
|
ord.uuid as "uuid: crate::model::cfd::OrderId",
|
|
ord.trading_pair as "trading_pair: crate::model::TradingPair",
|
|
ord.position as "position: crate::model::Position",
|
|
ord.initial_price,
|
|
ord.min_quantity,
|
|
ord.max_quantity,
|
|
ord.leverage as "leverage: crate::model::Leverage",
|
|
ord.liquidation_price,
|
|
ord.ts_secs as "ts_secs: i64",
|
|
ord.ts_nanos as "ts_nanos: i32",
|
|
ord.term_secs as "term_secs: i64",
|
|
ord.term_nanos as "term_nanos: i32",
|
|
ord.origin as "origin: crate::model::cfd::Origin",
|
|
ord.oracle_event_id,
|
|
state.quantity_usd,
|
|
state.state
|
|
|
|
from ord
|
|
inner join state on state.order_id = ord.order_id
|
|
"#
|
|
)
|
|
.fetch_all(conn)
|
|
.await?;
|
|
|
|
let cfds = rows
|
|
.into_iter()
|
|
.map(|row| {
|
|
let order = Order {
|
|
id: row.uuid,
|
|
trading_pair: row.trading_pair,
|
|
position: row.position,
|
|
price: Usd(Decimal::from_str(&row.initial_price)?),
|
|
min_quantity: Usd(Decimal::from_str(&row.min_quantity)?),
|
|
max_quantity: Usd(Decimal::from_str(&row.max_quantity)?),
|
|
leverage: row.leverage,
|
|
liquidation_price: Usd(Decimal::from_str(&row.liquidation_price)?),
|
|
creation_timestamp: convert_to_system_time(row.ts_secs, row.ts_nanos)?,
|
|
term: Duration::new(row.term_secs, row.term_nanos),
|
|
origin: row.origin,
|
|
oracle_event_id: row.oracle_event_id.parse::<BitMexPriceEventId>()?,
|
|
};
|
|
|
|
Ok(Cfd {
|
|
order,
|
|
quantity_usd: Usd(Decimal::from_str(&row.quantity_usd)?),
|
|
state: serde_json::from_str(row.state.as_str())?,
|
|
})
|
|
})
|
|
.collect::<Result<Vec<_>>>()?;
|
|
|
|
Ok(cfds)
|
|
}
|
|
|
|
/// Loads all CFDs with the latest state as the CFD state
|
|
pub async fn load_cfds_by_oracle_event_id(
|
|
oracle_event_id: BitMexPriceEventId,
|
|
conn: &mut PoolConnection<Sqlite>,
|
|
) -> anyhow::Result<Vec<Cfd>> {
|
|
let event_id = oracle_event_id.to_string();
|
|
let rows = sqlx::query!(
|
|
r#"
|
|
with ord as (
|
|
select
|
|
id as order_id,
|
|
uuid,
|
|
trading_pair,
|
|
position,
|
|
initial_price,
|
|
min_quantity,
|
|
max_quantity,
|
|
leverage,
|
|
liquidation_price,
|
|
creation_timestamp_seconds as ts_secs,
|
|
creation_timestamp_nanoseconds as ts_nanos,
|
|
term_seconds as term_secs,
|
|
term_nanoseconds as term_nanos,
|
|
origin,
|
|
oracle_event_id
|
|
from orders
|
|
),
|
|
|
|
cfd as (
|
|
select
|
|
id as cfd_id,
|
|
order_id,
|
|
quantity_usd as quantity_usd
|
|
from cfds
|
|
),
|
|
|
|
tmp as (
|
|
select
|
|
id as state_id,
|
|
cfd_id,
|
|
state
|
|
from cfd_states
|
|
),
|
|
|
|
state as (
|
|
select
|
|
tmp.state,
|
|
cfd.order_id,
|
|
cfd.quantity_usd
|
|
from tmp
|
|
inner join cfd on tmp.cfd_id = cfd.cfd_id
|
|
where tmp.state_id in (
|
|
select max(state_id)
|
|
from tmp
|
|
group by state_id
|
|
)
|
|
)
|
|
|
|
select
|
|
ord.uuid as "uuid: crate::model::cfd::OrderId",
|
|
ord.trading_pair as "trading_pair: crate::model::TradingPair",
|
|
ord.position as "position: crate::model::Position",
|
|
ord.initial_price,
|
|
ord.min_quantity,
|
|
ord.max_quantity,
|
|
ord.leverage as "leverage: crate::model::Leverage",
|
|
ord.liquidation_price,
|
|
ord.ts_secs as "ts_secs: i64",
|
|
ord.ts_nanos as "ts_nanos: i32",
|
|
ord.term_secs as "term_secs: i64",
|
|
ord.term_nanos as "term_nanos: i32",
|
|
ord.origin as "origin: crate::model::cfd::Origin",
|
|
ord.oracle_event_id,
|
|
state.quantity_usd,
|
|
state.state
|
|
|
|
from ord
|
|
inner join state on state.order_id = ord.order_id
|
|
|
|
where ord.oracle_event_id = $1
|
|
"#,
|
|
event_id
|
|
)
|
|
.fetch_all(conn)
|
|
.await?;
|
|
|
|
let cfds = rows
|
|
.into_iter()
|
|
.map(|row| {
|
|
let order = Order {
|
|
id: row.uuid,
|
|
trading_pair: row.trading_pair,
|
|
position: row.position,
|
|
price: Usd(Decimal::from_str(&row.initial_price)?),
|
|
min_quantity: Usd(Decimal::from_str(&row.min_quantity)?),
|
|
max_quantity: Usd(Decimal::from_str(&row.max_quantity)?),
|
|
leverage: row.leverage,
|
|
liquidation_price: Usd(Decimal::from_str(&row.liquidation_price)?),
|
|
creation_timestamp: convert_to_system_time(row.ts_secs, row.ts_nanos)?,
|
|
term: Duration::new(row.term_secs, row.term_nanos),
|
|
origin: row.origin,
|
|
oracle_event_id: row.oracle_event_id.parse::<BitMexPriceEventId>()?,
|
|
};
|
|
|
|
Ok(Cfd {
|
|
order,
|
|
quantity_usd: Usd(Decimal::from_str(&row.quantity_usd)?),
|
|
state: serde_json::from_str(row.state.as_str())?,
|
|
})
|
|
})
|
|
.collect::<Result<Vec<_>>>()?;
|
|
|
|
Ok(cfds)
|
|
}
|
|
|
|
fn convert_to_system_time(row_secs: i64, row_nanos: i32) -> Result<SystemTime> {
|
|
let secs = row_secs as i128;
|
|
let nanos = row_nanos as i128;
|
|
let offset_dt = OffsetDateTime::from_unix_timestamp_nanos(secs * 1_000_000_000 + nanos)?;
|
|
|
|
Ok(SystemTime::from(offset_dt))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::fs::File;
|
|
use std::time::SystemTime;
|
|
|
|
use rust_decimal_macros::dec;
|
|
use sqlx::SqlitePool;
|
|
use tempfile::tempdir;
|
|
use time::macros::datetime;
|
|
use time::OffsetDateTime;
|
|
|
|
use crate::db::insert_order;
|
|
use crate::model::cfd::{Cfd, CfdState, CfdStateCommon, Order, Origin};
|
|
use crate::model::Usd;
|
|
|
|
use super::*;
|
|
|
|
#[tokio::test]
|
|
async fn test_insert_and_load_order() {
|
|
let pool = setup_test_db().await;
|
|
let mut conn = pool.acquire().await.unwrap();
|
|
|
|
let order = Order::default();
|
|
insert_order(&order, &mut conn).await.unwrap();
|
|
|
|
let order_loaded = load_order_by_id(order.id, &mut conn).await.unwrap();
|
|
|
|
assert_eq!(order, order_loaded);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_insert_and_load_cfd() {
|
|
let pool = setup_test_db().await;
|
|
let mut conn = pool.acquire().await.unwrap();
|
|
|
|
let cfd = Cfd::default();
|
|
|
|
insert_order(&cfd.order, &mut conn).await.unwrap();
|
|
insert_cfd(cfd.clone(), &mut conn).await.unwrap();
|
|
|
|
let cfds_from_db = load_all_cfds(&mut conn).await.unwrap();
|
|
let cfd_from_db = cfds_from_db.first().unwrap().clone();
|
|
assert_eq!(cfd, cfd_from_db)
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_insert_and_load_cfd_by_order_id() {
|
|
let pool = setup_test_db().await;
|
|
let mut conn = pool.acquire().await.unwrap();
|
|
|
|
let cfd = Cfd::default();
|
|
let order_id = cfd.order.id;
|
|
|
|
insert_order(&cfd.order, &mut conn).await.unwrap();
|
|
insert_cfd(cfd.clone(), &mut conn).await.unwrap();
|
|
|
|
let cfd_from_db = load_cfd_by_order_id(order_id, &mut conn).await.unwrap();
|
|
assert_eq!(cfd, cfd_from_db)
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_insert_and_load_cfd_by_order_id_multiple() {
|
|
let pool = setup_test_db().await;
|
|
let mut conn = pool.acquire().await.unwrap();
|
|
|
|
let cfd = Cfd::default();
|
|
let order_id = cfd.order.id;
|
|
|
|
insert_order(&cfd.order, &mut conn).await.unwrap();
|
|
insert_cfd(cfd.clone(), &mut conn).await.unwrap();
|
|
|
|
let cfd_from_db = load_cfd_by_order_id(order_id, &mut conn).await.unwrap();
|
|
assert_eq!(cfd, cfd_from_db);
|
|
|
|
let cfd = Cfd::default();
|
|
let order_id = cfd.order.id;
|
|
|
|
insert_order(&cfd.order, &mut conn).await.unwrap();
|
|
insert_cfd(cfd.clone(), &mut conn).await.unwrap();
|
|
|
|
let cfd_from_db = load_cfd_by_order_id(order_id, &mut conn).await.unwrap();
|
|
assert_eq!(cfd, cfd_from_db);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_insert_and_load_cfd_by_oracle_event_id() {
|
|
let pool = setup_test_db().await;
|
|
let mut conn = pool.acquire().await.unwrap();
|
|
|
|
let oracle_event_id_1 =
|
|
BitMexPriceEventId::with_20_digits(datetime!(2021-10-13 10:00:00).assume_utc());
|
|
let oracle_event_id_2 =
|
|
BitMexPriceEventId::with_20_digits(datetime!(2021-10-25 18:00:00).assume_utc());
|
|
|
|
let cfd_1 =
|
|
Cfd::default().with_order(Order::default().with_oracle_event_id(oracle_event_id_1));
|
|
|
|
insert_order(&cfd_1.order, &mut conn).await.unwrap();
|
|
insert_cfd(cfd_1.clone(), &mut conn).await.unwrap();
|
|
|
|
let cfd_from_db = load_cfds_by_oracle_event_id(oracle_event_id_1, &mut conn)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(vec![cfd_1.clone()], cfd_from_db);
|
|
|
|
let cfd_2 =
|
|
Cfd::default().with_order(Order::default().with_oracle_event_id(oracle_event_id_1));
|
|
|
|
insert_order(&cfd_2.order, &mut conn).await.unwrap();
|
|
insert_cfd(cfd_2.clone(), &mut conn).await.unwrap();
|
|
|
|
let cfd_from_db = load_cfds_by_oracle_event_id(oracle_event_id_1, &mut conn)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(vec![cfd_1, cfd_2], cfd_from_db);
|
|
|
|
let cfd_3 =
|
|
Cfd::default().with_order(Order::default().with_oracle_event_id(oracle_event_id_2));
|
|
|
|
insert_order(&cfd_3.order, &mut conn).await.unwrap();
|
|
insert_cfd(cfd_3.clone(), &mut conn).await.unwrap();
|
|
|
|
let cfd_from_db = load_cfds_by_oracle_event_id(oracle_event_id_2, &mut conn)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(vec![cfd_3], cfd_from_db);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_insert_new_cfd_state() {
|
|
let pool = setup_test_db().await;
|
|
let mut conn = pool.acquire().await.unwrap();
|
|
|
|
let mut cfd = Cfd::default();
|
|
|
|
insert_order(&cfd.order, &mut conn).await.unwrap();
|
|
insert_cfd(cfd.clone(), &mut conn).await.unwrap();
|
|
|
|
cfd.state = CfdState::Accepted {
|
|
common: CfdStateCommon {
|
|
transition_timestamp: SystemTime::now(),
|
|
},
|
|
};
|
|
insert_new_cfd_state_by_order_id(cfd.order.id, &cfd.state, &mut conn)
|
|
.await
|
|
.unwrap();
|
|
|
|
let cfds_from_db = load_all_cfds(&mut conn).await.unwrap();
|
|
let cfd_from_db = cfds_from_db.last().unwrap().clone();
|
|
assert_eq!(cfd, cfd_from_db)
|
|
}
|
|
|
|
async fn setup_test_db() -> SqlitePool {
|
|
let temp_db = tempdir().unwrap().into_path().join("tempdb");
|
|
|
|
// file has to exist in order to connect with sqlite
|
|
File::create(temp_db.clone()).unwrap();
|
|
|
|
let pool = SqlitePool::connect(format!("sqlite:{}", temp_db.display()).as_str())
|
|
.await
|
|
.unwrap();
|
|
|
|
run_migrations(&pool).await.unwrap();
|
|
|
|
pool
|
|
}
|
|
|
|
impl Default for Cfd {
|
|
fn default() -> Self {
|
|
Cfd::new(
|
|
Order::default(),
|
|
Usd(dec!(1000)),
|
|
CfdState::OutgoingOrderRequest {
|
|
common: CfdStateCommon {
|
|
transition_timestamp: SystemTime::now(),
|
|
},
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Cfd {
|
|
pub fn with_order(mut self, order: Order) -> Self {
|
|
self.order = order;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Default for Order {
|
|
fn default() -> Self {
|
|
Order::new(
|
|
Usd(dec!(1000)),
|
|
Usd(dec!(100)),
|
|
Usd(dec!(1000)),
|
|
Origin::Theirs,
|
|
BitMexPriceEventId::with_20_digits(OffsetDateTime::now_utc()),
|
|
)
|
|
.unwrap()
|
|
}
|
|
}
|
|
|
|
impl Order {
|
|
pub fn with_oracle_event_id(mut self, oracle_event_id: BitMexPriceEventId) -> Self {
|
|
self.oracle_event_id = oracle_event_id;
|
|
self
|
|
}
|
|
}
|
|
}
|
|
|