BitcoinCash/riftenlabs-indexer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Migrate candlestick tests to bitcoincash 0.32 API

Browse source 
The candlestick module was authored against bitcoincash 0.29 before master
upgraded to 0.32. Adapt the rebased test files to the new API:

- Hash constructors: from_inner -> from_byte_array
- sqlx connection passing: &mut *conn -> &mut conn
- TokenID hex display: token.to_hex() -> token.to_string()
  (drop the now-unused bitcoin_hashes::hex::ToHex import)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Jakob Notland 2026-06-23 16:10:18 +02:00
parent 4a16fa0ffe
commit 51cb5d788c
2 changed files with 84 additions and 85 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
src/db/cauldron/candlestick/tests.rs
View file

@ -52,9 +52,9 @@ async fn insert_trade_at(
sats_delta: i64, sats_delta: i64,
token_delta: i64, token_delta: i64,
) { ) {
let txid = Txid::from_inner([txid_byte; 32]); let txid = Txid::from_byte_array([txid_byte; 32]);
let utxo = OutPointHash::from_inner([txid_byte; 32]); let utxo = OutPointHash::from_byte_array([txid_byte; 32]);
let pool_hash = OutPointHash::from_inner([txid_byte.wrapping_add(0x80); 32]); let pool_hash = OutPointHash::from_byte_array([txid_byte.wrapping_add(0x80); 32]);
let block = BlockHash::all_zeros(); let block = BlockHash::all_zeros();
let cauldron = dummy_cauldron( let cauldron = dummy_cauldron(
@ -89,7 +89,7 @@ async fn insert_trade_at(
#[tokio::test] #[tokio::test]
async fn test_fetch_last_close_before_no_trades() { async fn test_fetch_last_close_before_no_trades() {
let db = mock_db_pool(setup_db).await; let db = mock_db_pool(setup_db).await;
let token = TokenID::from_inner([0xAA; 32]); let token = TokenID::from_byte_array([0xAA; 32]);
let token_blob = token.to_blob(); let token_blob = token.to_blob();
let result = super::fetch_last_close_before(&db.cauldron_r, &token_blob, 2_000_000_000) let result = super::fetch_last_close_before(&db.cauldron_r, &token_blob, 2_000_000_000)
@ -101,7 +101,7 @@ async fn test_fetch_last_close_before_no_trades() {
#[tokio::test] #[tokio::test]
async fn test_fetch_last_close_before_only_future_trades() { async fn test_fetch_last_close_before_only_future_trades() {
let db = mock_db_pool(setup_db).await; let db = mock_db_pool(setup_db).await;
let token = TokenID::from_inner([0xAB; 32]); let token = TokenID::from_byte_array([0xAB; 32]);
let token_blob = token.to_blob(); let token_blob = token.to_blob();
let mut conn = db.cauldron_w.acquire().await.unwrap(); let mut conn = db.cauldron_w.acquire().await.unwrap();
@ -116,7 +116,7 @@ async fn test_fetch_last_close_before_only_future_trades() {
#[tokio::test] #[tokio::test]
async fn test_fetch_last_close_before_returns_most_recent() { async fn test_fetch_last_close_before_returns_most_recent() {
let db = mock_db_pool(setup_db).await; let db = mock_db_pool(setup_db).await;
let token = TokenID::from_inner([0xAC; 32]); let token = TokenID::from_byte_array([0xAC; 32]);
let token_blob = token.to_blob(); let token_blob = token.to_blob();
let mut conn = db.cauldron_w.acquire().await.unwrap(); let mut conn = db.cauldron_w.acquire().await.unwrap();
@ -138,7 +138,7 @@ async fn test_fetch_last_close_before_returns_most_recent() {
#[tokio::test] #[tokio::test]
async fn test_fetch_last_close_before_boundary_excluded() { async fn test_fetch_last_close_before_boundary_excluded() {
let db = mock_db_pool(setup_db).await; let db = mock_db_pool(setup_db).await;
let token = TokenID::from_inner([0xAD; 32]); let token = TokenID::from_byte_array([0xAD; 32]);
let token_blob = token.to_blob(); let token_blob = token.to_blob();
let mut conn = db.cauldron_w.acquire().await.unwrap(); let mut conn = db.cauldron_w.acquire().await.unwrap();
@ -156,7 +156,7 @@ async fn test_fetch_last_close_before_boundary_excluded() {
#[tokio::test] #[tokio::test]
async fn test_fetch_last_close_before_skips_net_zero_token_trades() { async fn test_fetch_last_close_before_skips_net_zero_token_trades() {
let db = mock_db_pool(setup_db).await; let db = mock_db_pool(setup_db).await;
let token = TokenID::from_inner([0xAE; 32]); let token = TokenID::from_byte_array([0xAE; 32]);
let token_blob = token.to_blob(); let token_blob = token.to_blob();
let mut conn = db.cauldron_w.acquire().await.unwrap(); let mut conn = db.cauldron_w.acquire().await.unwrap();
@ -180,8 +180,8 @@ async fn test_fetch_last_close_before_skips_net_zero_token_trades() {
#[tokio::test] #[tokio::test]
async fn test_fetch_last_close_before_token_isolation() { async fn test_fetch_last_close_before_token_isolation() {
let db = mock_db_pool(setup_db).await; let db = mock_db_pool(setup_db).await;
let token_a = TokenID::from_inner([0xAF; 32]); let token_a = TokenID::from_byte_array([0xAF; 32]);
let token_b = TokenID::from_inner([0xBF; 32]); let token_b = TokenID::from_byte_array([0xBF; 32]);
let token_a_blob = token_a.to_blob(); let token_a_blob = token_a.to_blob();
let mut conn = db.cauldron_w.acquire().await.unwrap(); let mut conn = db.cauldron_w.acquire().await.unwrap();

149
src/rpc/candlesticks/tests.rs
View file

@ -13,7 +13,6 @@ use crate::utiltest::mock_db_pool;
use crate::OhlcvState; use crate::OhlcvState;
use crate::timeutil::time_now; use crate::timeutil::time_now;
use bitcoin_hashes::hex::ToHex;
use bitcoin_hashes::Hash; use bitcoin_hashes::Hash;
use bitcoincash::{BlockHash, PubkeyHash, TokenID, Txid}; use bitcoincash::{BlockHash, PubkeyHash, TokenID, Txid};
use riftenlabs_defi::{cauldron::ParsedContract, chainutil::OutPointHash}; use riftenlabs_defi::{cauldron::ParsedContract, chainutil::OutPointHash};
@ -74,58 +73,58 @@ async fn setup_mock_db(pool: sqlx::SqlitePool) {
let token_zero = TokenID::all_zeros(); let token_zero = TokenID::all_zeros();
let pkh_zero = PubkeyHash::all_zeros(); let pkh_zero = PubkeyHash::all_zeros();
let txid1 = Txid::from_inner([0xf1; 32]); let txid1 = Txid::from_byte_array([0xf1; 32]);
let txid2 = Txid::from_inner([0xf2; 32]); let txid2 = Txid::from_byte_array([0xf2; 32]);
let txid3 = Txid::from_inner([0xf3; 32]); let txid3 = Txid::from_byte_array([0xf3; 32]);
let txid4 = Txid::from_inner([0xf4; 32]); let txid4 = Txid::from_byte_array([0xf4; 32]);
let utxo1 = OutPointHash::from_inner([0xe1; 32]); let utxo1 = OutPointHash::from_byte_array([0xe1; 32]);
let utxo2 = OutPointHash::from_inner([0xe2; 32]); let utxo2 = OutPointHash::from_byte_array([0xe2; 32]);
let utxo3 = OutPointHash::from_inner([0xe3; 32]); let utxo3 = OutPointHash::from_byte_array([0xe3; 32]);
let utxo4 = OutPointHash::from_inner([0xe4; 32]); let utxo4 = OutPointHash::from_byte_array([0xe4; 32]);
let cauldron1 = dummy_cauldron(&txid1, &utxo1, &token_zero, 80_000, 2_000, &pkh_zero); let cauldron1 = dummy_cauldron(&txid1, &utxo1, &token_zero, 80_000, 2_000, &pkh_zero);
let cauldron2 = dummy_cauldron(&txid2, &utxo2, &token_zero, 120_000, 2_000, &pkh_zero); let cauldron2 = dummy_cauldron(&txid2, &utxo2, &token_zero, 120_000, 2_000, &pkh_zero);
let cauldron3 = dummy_cauldron(&txid3, &utxo3, &token_zero, 160_000, 2_000, &pkh_zero); let cauldron3 = dummy_cauldron(&txid3, &utxo3, &token_zero, 160_000, 2_000, &pkh_zero);
let cauldron4 = dummy_cauldron(&txid4, &utxo4, &token_zero, 200_000, 2_000, &pkh_zero); let cauldron4 = dummy_cauldron(&txid4, &utxo4, &token_zero, 200_000, 2_000, &pkh_zero);
insert_utxo_funding(&mut *conn, &vec![cauldron1.clone()], &txid1) insert_utxo_funding(&mut conn, &vec![cauldron1.clone()], &txid1)
.await .await
.unwrap(); .unwrap();
insert_utxo_funding(&mut *conn, &vec![cauldron2.clone()], &txid2) insert_utxo_funding(&mut conn, &vec![cauldron2.clone()], &txid2)
.await .await
.unwrap(); .unwrap();
insert_utxo_funding(&mut *conn, &vec![cauldron3.clone()], &txid3) insert_utxo_funding(&mut conn, &vec![cauldron3.clone()], &txid3)
.await .await
.unwrap(); .unwrap();
insert_utxo_funding(&mut *conn, &vec![cauldron4.clone()], &txid4) insert_utxo_funding(&mut conn, &vec![cauldron4.clone()], &txid4)
.await .await
.unwrap(); .unwrap();
let block_zero = BlockHash::all_zeros(); let block_zero = BlockHash::all_zeros();
insert_mempool_tx(&mut *conn, &txid1, TIME_1).await.unwrap(); insert_mempool_tx(&mut conn, &txid1, TIME_1).await.unwrap();
insert_block_tx(&mut *conn, &txid1, &block_zero, TIME_1 as i64) insert_block_tx(&mut conn, &txid1, &block_zero, TIME_1 as i64)
.await .await
.unwrap(); .unwrap();
insert_mempool_tx(&mut *conn, &txid2, TIME_2).await.unwrap(); insert_mempool_tx(&mut conn, &txid2, TIME_2).await.unwrap();
insert_block_tx(&mut *conn, &txid2, &block_zero, TIME_2 as i64) insert_block_tx(&mut conn, &txid2, &block_zero, TIME_2 as i64)
.await .await
.unwrap(); .unwrap();
insert_mempool_tx(&mut *conn, &txid3, TIME_3).await.unwrap(); insert_mempool_tx(&mut conn, &txid3, TIME_3).await.unwrap();
insert_block_tx(&mut *conn, &txid3, &block_zero, TIME_3 as i64) insert_block_tx(&mut conn, &txid3, &block_zero, TIME_3 as i64)
.await .await
.unwrap(); .unwrap();
insert_mempool_tx(&mut *conn, &txid4, TIME_4).await.unwrap(); insert_mempool_tx(&mut conn, &txid4, TIME_4).await.unwrap();
insert_block_tx(&mut *conn, &txid4, &block_zero, TIME_4 as i64) insert_block_tx(&mut conn, &txid4, &block_zero, TIME_4 as i64)
.await .await
.unwrap(); .unwrap();
let pool1 = OutPointHash::from_inner([0x0a; 32]); let pool1 = OutPointHash::from_byte_array([0x0a; 32]);
let pool2 = OutPointHash::from_inner([0x0b; 32]); let pool2 = OutPointHash::from_byte_array([0x0b; 32]);
let pool3 = OutPointHash::from_inner([0x0c; 32]); let pool3 = OutPointHash::from_byte_array([0x0c; 32]);
let pool4 = OutPointHash::from_inner([0x0d; 32]); let pool4 = OutPointHash::from_byte_array([0x0d; 32]);
pool::insert_pool_history_entry( pool::insert_pool_history_entry(
&mut *conn, &mut conn,
&pool1, &pool1,
&cauldron1, &cauldron1,
Some(TIME_1), Some(TIME_1),
@ -136,7 +135,7 @@ async fn setup_mock_db(pool: sqlx::SqlitePool) {
.await .await
.unwrap(); .unwrap();
pool::insert_pool_history_entry( pool::insert_pool_history_entry(
&mut *conn, &mut conn,
&pool2, &pool2,
&cauldron2, &cauldron2,
Some(TIME_2), Some(TIME_2),
@ -147,7 +146,7 @@ async fn setup_mock_db(pool: sqlx::SqlitePool) {
.await .await
.unwrap(); .unwrap();
pool::insert_pool_history_entry( pool::insert_pool_history_entry(
&mut *conn, &mut conn,
&pool3, &pool3,
&cauldron3, &cauldron3,
Some(TIME_3), Some(TIME_3),
@ -158,7 +157,7 @@ async fn setup_mock_db(pool: sqlx::SqlitePool) {
.await .await
.unwrap(); .unwrap();
pool::insert_pool_history_entry( pool::insert_pool_history_entry(
&mut *conn, &mut conn,
&pool4, &pool4,
&cauldron4, &cauldron4,
Some(TIME_4), Some(TIME_4),
@ -169,28 +168,28 @@ async fn setup_mock_db(pool: sqlx::SqlitePool) {
.await .await
.unwrap(); .unwrap();
let token1 = TokenID::from_inner([0xda; 32]); let token1 = TokenID::from_byte_array([0xda; 32]);
let pkh1 = PubkeyHash::from_inner([0xca; 20]); let pkh1 = PubkeyHash::from_byte_array([0xca; 20]);
insert_new_pool( insert_new_pool(
&mut *conn, &mut conn,
&dummy_cauldron(&Txid::all_zeros(), &pool1, &token1, 0, 0, &pkh1), &dummy_cauldron(&Txid::all_zeros(), &pool1, &token1, 0, 0, &pkh1),
) )
.await .await
.unwrap(); .unwrap();
insert_new_pool( insert_new_pool(
&mut *conn, &mut conn,
&dummy_cauldron(&Txid::all_zeros(), &pool2, &token1, 0, 0, &pkh1), &dummy_cauldron(&Txid::all_zeros(), &pool2, &token1, 0, 0, &pkh1),
) )
.await .await
.unwrap(); .unwrap();
insert_new_pool( insert_new_pool(
&mut *conn, &mut conn,
&dummy_cauldron(&Txid::all_zeros(), &pool3, &token1, 0, 0, &pkh1), &dummy_cauldron(&Txid::all_zeros(), &pool3, &token1, 0, 0, &pkh1),
) )
.await .await
.unwrap(); .unwrap();
insert_new_pool( insert_new_pool(
&mut *conn, &mut conn,
&dummy_cauldron(&Txid::all_zeros(), &pool4, &token1, 0, 0, &pkh1), &dummy_cauldron(&Txid::all_zeros(), &pool4, &token1, 0, 0, &pkh1),
) )
.await .await
@ -215,9 +214,9 @@ async fn insert_trade_at(
sats_delta: i64, sats_delta: i64,
token_delta: i64, token_delta: i64,
) { ) {
let txid = Txid::from_inner([txid_byte; 32]); let txid = Txid::from_byte_array([txid_byte; 32]);
let utxo = OutPointHash::from_inner([txid_byte; 32]); let utxo = OutPointHash::from_byte_array([txid_byte; 32]);
let pool_hash = OutPointHash::from_inner([txid_byte.wrapping_add(0x80); 32]); let pool_hash = OutPointHash::from_byte_array([txid_byte.wrapping_add(0x80); 32]);
let block = BlockHash::all_zeros(); let block = BlockHash::all_zeros();
let cauldron = dummy_cauldron( let cauldron = dummy_cauldron(
@ -387,14 +386,14 @@ async fn test_single_swap_multiple_pools() {
let token_zero = TokenID::all_zeros(); let token_zero = TokenID::all_zeros();
let pkh_zero = PubkeyHash::all_zeros(); let pkh_zero = PubkeyHash::all_zeros();
let txid_multi = Txid::from_inner([0xaa; 32]); let txid_multi = Txid::from_byte_array([0xaa; 32]);
let block_zero = BlockHash::all_zeros(); let block_zero = BlockHash::all_zeros();
let mut pools = Vec::new(); let mut pools = Vec::new();
let times = [TIME_1, TIME_2]; let times = [TIME_1, TIME_2];
for (i, &time) in times.iter().enumerate() { for (i, &time) in times.iter().enumerate() {
let utxo = OutPointHash::from_inner([0xe1 + i as u8; 32]); let utxo = OutPointHash::from_byte_array([0xe1 + i as u8; 32]);
let pool_hash = OutPointHash::from_inner([0x0a + i as u8; 32]); let pool_hash = OutPointHash::from_byte_array([0x0a + i as u8; 32]);
let cauldron = dummy_cauldron( let cauldron = dummy_cauldron(
&txid_multi, &txid_multi,
&utxo, &utxo,
@ -405,18 +404,18 @@ async fn test_single_swap_multiple_pools() {
); );
pools.push(pool_hash); pools.push(pool_hash);
insert_utxo_funding(&mut *conn, &vec![cauldron.clone()], &txid_multi) insert_utxo_funding(&mut conn, &vec![cauldron.clone()], &txid_multi)
.await .await
.unwrap(); .unwrap();
insert_block_tx(&mut *conn, &txid_multi, &block_zero, time as i64) insert_block_tx(&mut conn, &txid_multi, &block_zero, time as i64)
.await .await
.unwrap(); .unwrap();
insert_mempool_tx(&mut *conn, &txid_multi, time) insert_mempool_tx(&mut conn, &txid_multi, time)
.await .await
.unwrap(); .unwrap();
pool::insert_pool_history_entry( pool::insert_pool_history_entry(
&mut *conn, &mut conn,
&pool_hash, &pool_hash,
&cauldron, &cauldron,
Some(time), Some(time),
@ -428,11 +427,11 @@ async fn test_single_swap_multiple_pools() {
.unwrap(); .unwrap();
} }
let token1 = TokenID::from_inner([0xda; 32]); let token1 = TokenID::from_byte_array([0xda; 32]);
let pkh1 = PubkeyHash::from_inner([0xca; 20]); let pkh1 = PubkeyHash::from_byte_array([0xca; 20]);
for pool_hash in &pools { for pool_hash in &pools {
insert_new_pool( insert_new_pool(
&mut *conn, &mut conn,
&dummy_cauldron(&Txid::all_zeros(), pool_hash, &token1, 0, 0, &pkh1), &dummy_cauldron(&Txid::all_zeros(), pool_hash, &token1, 0, 0, &pkh1),
) )
.await .await
@ -491,14 +490,14 @@ async fn test_candle_carries_price_when_net_zero_tokens_but_has_volume() {
let block_zero = BlockHash::all_zeros(); let block_zero = BlockHash::all_zeros();
// Two pools (identities) // Two pools (identities)
let pool_a = OutPointHash::from_inner([0x1a; 32]); let pool_a = OutPointHash::from_byte_array([0x1a; 32]);
let pool_b = OutPointHash::from_inner([0x1b; 32]); let pool_b = OutPointHash::from_byte_array([0x1b; 32]);
// Register pools in `pool` table // Register pools in `pool` table
let token1 = TokenID::from_inner([0xda; 32]); let token1 = TokenID::from_byte_array([0xda; 32]);
let pkh1 = PubkeyHash::from_inner([0xca; 20]); let pkh1 = PubkeyHash::from_byte_array([0xca; 20]);
insert_new_pool( insert_new_pool(
&mut *conn, &mut conn,
&ParsedContract { &ParsedContract {
pkh: pkh1, pkh: pkh1,
is_withdrawn: false, is_withdrawn: false,
@ -514,7 +513,7 @@ async fn test_candle_carries_price_when_net_zero_tokens_but_has_volume() {
.await .await
.unwrap(); .unwrap();
insert_new_pool( insert_new_pool(
&mut *conn, &mut conn,
&ParsedContract { &ParsedContract {
pkh: pkh1, pkh: pkh1,
is_withdrawn: false, is_withdrawn: false,
@ -536,8 +535,8 @@ async fn test_candle_carries_price_when_net_zero_tokens_but_has_volume() {
let t1: u64 = t0 + step; let t1: u64 = t0 + step;
// -------- Candle #1 (normal priceable trade) -------- // -------- Candle #1 (normal priceable trade) --------
let txid_price = Txid::from_inner([0x90; 32]); let txid_price = Txid::from_byte_array([0x90; 32]);
let utxo_p = OutPointHash::from_inner([0x21; 32]); let utxo_p = OutPointHash::from_byte_array([0x21; 32]);
let cauldron_p = ParsedContract { let cauldron_p = ParsedContract {
pkh: pkh_zero, pkh: pkh_zero,
is_withdrawn: false, is_withdrawn: false,
@ -549,18 +548,18 @@ async fn test_candle_carries_price_when_net_zero_tokens_but_has_volume() {
sats: Some(0), sats: Some(0),
token_amount: Some(0), token_amount: Some(0),
}; };
insert_utxo_funding(&mut *conn, &vec![cauldron_p.clone()], &txid_price) insert_utxo_funding(&mut conn, &vec![cauldron_p.clone()], &txid_price)
.await .await
.unwrap(); .unwrap();
insert_block_tx(&mut *conn, &txid_price, &block_zero, t0 as i64) insert_block_tx(&mut conn, &txid_price, &block_zero, t0 as i64)
.await .await
.unwrap(); .unwrap();
insert_mempool_tx(&mut *conn, &txid_price, t0) insert_mempool_tx(&mut conn, &txid_price, t0)
.await .await
.unwrap(); .unwrap();
// sats_delta=+10_000, token_delta=+200 -> price = 10000/200 = 50 // sats_delta=+10_000, token_delta=+200 -> price = 10000/200 = 50
pool::insert_pool_history_entry( pool::insert_pool_history_entry(
&mut *conn, &mut conn,
&pool_a, &pool_a,
&cauldron_p, &cauldron_p,
Some(t0), Some(t0),
@ -572,9 +571,9 @@ async fn test_candle_carries_price_when_net_zero_tokens_but_has_volume() {
.unwrap(); .unwrap();
// -------- Candle #2 (net zero tokens but non-zero volume) -------- // -------- Candle #2 (net zero tokens but non-zero volume) --------
let txid_net0 = Txid::from_inner([0x91; 32]); let txid_net0 = Txid::from_byte_array([0x91; 32]);
let utxo_a1 = OutPointHash::from_inner([0x22; 32]); let utxo_a1 = OutPointHash::from_byte_array([0x22; 32]);
let utxo_b1 = OutPointHash::from_inner([0x23; 32]); let utxo_b1 = OutPointHash::from_byte_array([0x23; 32]);
let ca_a1 = ParsedContract { let ca_a1 = ParsedContract {
pkh: pkh_zero, pkh: pkh_zero,
@ -593,19 +592,19 @@ async fn test_candle_carries_price_when_net_zero_tokens_but_has_volume() {
..ca_a1 ..ca_a1
}; };
insert_utxo_funding(&mut *conn, &vec![ca_a1.clone()], &txid_net0) insert_utxo_funding(&mut conn, &vec![ca_a1.clone()], &txid_net0)
.await .await
.unwrap(); .unwrap();
insert_utxo_funding(&mut *conn, &vec![ca_b1.clone()], &txid_net0) insert_utxo_funding(&mut conn, &vec![ca_b1.clone()], &txid_net0)
.await .await
.unwrap(); .unwrap();
insert_block_tx(&mut *conn, &txid_net0, &block_zero, t1 as i64) insert_block_tx(&mut conn, &txid_net0, &block_zero, t1 as i64)
.await .await
.unwrap(); .unwrap();
insert_mempool_tx(&mut *conn, &txid_net0, t1).await.unwrap(); insert_mempool_tx(&mut conn, &txid_net0, t1).await.unwrap();
pool::insert_pool_history_entry( pool::insert_pool_history_entry(
&mut *conn, &mut conn,
&pool_a, &pool_a,
&ca_a1, &ca_a1,
Some(t1), Some(t1),
@ -617,7 +616,7 @@ async fn test_candle_carries_price_when_net_zero_tokens_but_has_volume() {
.unwrap(); .unwrap();
// Opposite deltas within the same tx // Opposite deltas within the same tx
pool::insert_pool_history_entry( pool::insert_pool_history_entry(
&mut *conn, &mut conn,
&pool_b, &pool_b,
&ca_b1, &ca_b1,
Some(t1), Some(t1),
@ -872,7 +871,7 @@ async fn test_ohlcv_skipped_for_non_aligned_start() {
/// all candles are flat gap-fill at the prior close price. /// all candles are flat gap-fill at the prior close price.
#[rocket::async_test] #[rocket::async_test]
async fn test_raw_path_seeded_gap_fill_no_in_window_trades() { async fn test_raw_path_seeded_gap_fill_no_in_window_trades() {
let token = TokenID::from_inner([0xBA; 32]); let token = TokenID::from_byte_array([0xBA; 32]);
let token_copy = token; let token_copy = token;
let db = mock_db_pool(move |pool: sqlx::SqlitePool| async move { let db = mock_db_pool(move |pool: sqlx::SqlitePool| async move {
@ -891,7 +890,7 @@ async fn test_raw_path_seeded_gap_fill_no_in_window_trades() {
let resp = client let resp = client
.get(format!( .get(format!(
"/api/price/{}/candlesticks?start=2000&end=3000&stepsize=500", "/api/price/{}/candlesticks?start=2000&end=3000&stepsize=500",
token.to_hex() token.to_string()
)) ))
.dispatch() .dispatch()
.await; .await;
@ -916,7 +915,7 @@ async fn test_raw_path_seeded_gap_fill_no_in_window_trades() {
/// then real candle and post-trade gap-fill use the in-window close. /// then real candle and post-trade gap-fill use the in-window close.
#[rocket::async_test] #[rocket::async_test]
async fn test_raw_path_seeded_gap_fill_then_in_window_trade() { async fn test_raw_path_seeded_gap_fill_then_in_window_trade() {
let token = TokenID::from_inner([0xBB; 32]); let token = TokenID::from_byte_array([0xBB; 32]);
let token_copy = token; let token_copy = token;
let db = mock_db_pool(move |pool: sqlx::SqlitePool| async move { let db = mock_db_pool(move |pool: sqlx::SqlitePool| async move {
@ -936,7 +935,7 @@ async fn test_raw_path_seeded_gap_fill_then_in_window_trade() {
let resp = client let resp = client
.get(format!( .get(format!(
"/api/price/{}/candlesticks?start=2000&end=3500&stepsize=500", "/api/price/{}/candlesticks?start=2000&end=3500&stepsize=500",
token.to_hex() token.to_string()
)) ))
.dispatch() .dispatch()
.await; .await;
@ -976,7 +975,7 @@ async fn test_raw_path_seeded_gap_fill_then_in_window_trade() {
/// Without a pre-window trade no candles appear before the first in-window trade. /// Without a pre-window trade no candles appear before the first in-window trade.
#[rocket::async_test] #[rocket::async_test]
async fn test_raw_path_no_seed_no_prefill() { async fn test_raw_path_no_seed_no_prefill() {
let token = TokenID::from_inner([0xBC; 32]); let token = TokenID::from_byte_array([0xBC; 32]);
let token_copy = token; let token_copy = token;
let db = mock_db_pool(move |pool: sqlx::SqlitePool| async move { let db = mock_db_pool(move |pool: sqlx::SqlitePool| async move {
@ -995,7 +994,7 @@ async fn test_raw_path_no_seed_no_prefill() {
let resp = client let resp = client
.get(format!( .get(format!(
"/api/price/{}/candlesticks?start=2000&end=3500&stepsize=500", "/api/price/{}/candlesticks?start=2000&end=3500&stepsize=500",
token.to_hex() token.to_string()
)) ))
.dispatch() .dispatch()
.await; .await;