nautilus_serialization/arrow/instrument/
betting.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Arrow serialization for BettingInstrument instruments.
17
18use std::{collections::HashMap, str::FromStr, sync::Arc};
19
20#[allow(unused_imports)]
21use arrow::{
22    array::{
23        Array, BinaryArray, BinaryBuilder, Float64Array, Float64Builder, Int64Array, Int64Builder,
24        StringArray, StringBuilder, UInt8Array, UInt64Array,
25    },
26    datatypes::{DataType, Field, Schema},
27    error::ArrowError,
28    record_batch::RecordBatch,
29};
30#[allow(unused_imports)]
31use nautilus_core::Params;
32use nautilus_model::{
33    identifiers::{InstrumentId, Symbol},
34    instruments::betting::BettingInstrument,
35    types::{money::Money, price::Price, quantity::Quantity},
36};
37#[allow(unused)]
38use rust_decimal::Decimal;
39#[allow(unused)]
40use serde_json::Value;
41use ustr::Ustr;
42
43use crate::arrow::{
44    ArrowSchemaProvider, EncodeToRecordBatch, EncodingError, KEY_INSTRUMENT_ID,
45    KEY_PRICE_PRECISION, KEY_SIZE_PRECISION, extract_column, extract_column_by_name_or_index,
46    extract_optional_string_column_by_name, optional_ustr_value,
47};
48
49impl ArrowSchemaProvider for BettingInstrument {
50    fn get_schema(metadata: Option<HashMap<String, String>>) -> Schema {
51        let fields = vec![
52            Field::new("id", DataType::Utf8, false),
53            Field::new("raw_symbol", DataType::Utf8, false),
54            Field::new("venue_name", DataType::Utf8, false),
55            Field::new("currency", DataType::Utf8, false),
56            Field::new("event_type_id", DataType::UInt64, false),
57            Field::new("event_type_name", DataType::Utf8, false),
58            Field::new("competition_id", DataType::UInt64, false),
59            Field::new("competition_name", DataType::Utf8, false),
60            Field::new("event_id", DataType::UInt64, false),
61            Field::new("event_name", DataType::Utf8, false),
62            Field::new("event_country_code", DataType::Utf8, false),
63            Field::new("event_open_date", DataType::UInt64, false),
64            Field::new("betting_type", DataType::Utf8, false),
65            Field::new("market_id", DataType::Utf8, false),
66            Field::new("market_name", DataType::Utf8, false),
67            Field::new("market_type", DataType::Utf8, false),
68            Field::new("market_start_time", DataType::UInt64, false),
69            Field::new("selection_id", DataType::UInt64, false),
70            Field::new("selection_name", DataType::Utf8, false),
71            Field::new("selection_handicap", DataType::Float64, false),
72            Field::new("price_precision", DataType::UInt8, false),
73            Field::new("size_precision", DataType::UInt8, false),
74            Field::new("price_increment", DataType::Utf8, false),
75            Field::new("size_increment", DataType::Utf8, false),
76            Field::new("max_quantity", DataType::Utf8, true), // nullable
77            Field::new("min_quantity", DataType::Utf8, true), // nullable
78            Field::new("max_notional", DataType::Utf8, true), // nullable
79            Field::new("min_notional", DataType::Utf8, true), // nullable
80            Field::new("max_price", DataType::Utf8, true),    // nullable
81            Field::new("min_price", DataType::Utf8, true),    // nullable
82            Field::new("margin_init", DataType::Utf8, false),
83            Field::new("margin_maint", DataType::Utf8, false),
84            Field::new("maker_fee", DataType::Utf8, false),
85            Field::new("taker_fee", DataType::Utf8, false),
86            Field::new("tick_scheme", DataType::Utf8, true),
87            Field::new("info", DataType::Binary, true), // nullable
88            Field::new("ts_event", DataType::UInt64, false),
89            Field::new("ts_init", DataType::UInt64, false),
90        ];
91
92        let mut final_metadata = HashMap::new();
93        final_metadata.insert("class".to_string(), "BettingInstrument".to_string());
94
95        if let Some(meta) = metadata {
96            final_metadata.extend(meta);
97        }
98
99        Schema::new_with_metadata(fields, final_metadata)
100    }
101}
102
103impl EncodeToRecordBatch for BettingInstrument {
104    fn encode_batch(
105        #[allow(unused)] metadata: &HashMap<String, String>,
106        data: &[Self],
107    ) -> Result<RecordBatch, ArrowError> {
108        let mut id_builder = StringBuilder::new();
109        let mut raw_symbol_builder = StringBuilder::new();
110        let mut venue_name_builder = StringBuilder::new();
111        let mut currency_builder = StringBuilder::new();
112        let mut event_type_id_builder = UInt64Array::builder(data.len());
113        let mut event_type_name_builder = StringBuilder::new();
114        let mut competition_id_builder = UInt64Array::builder(data.len());
115        let mut competition_name_builder = StringBuilder::new();
116        let mut event_id_builder = UInt64Array::builder(data.len());
117        let mut event_name_builder = StringBuilder::new();
118        let mut event_country_code_builder = StringBuilder::new();
119        let mut event_open_date_builder = UInt64Array::builder(data.len());
120        let mut betting_type_builder = StringBuilder::new();
121        let mut market_id_builder = StringBuilder::new();
122        let mut market_name_builder = StringBuilder::new();
123        let mut market_type_builder = StringBuilder::new();
124        let mut market_start_time_builder = UInt64Array::builder(data.len());
125        let mut selection_id_builder = UInt64Array::builder(data.len());
126        let mut selection_name_builder = StringBuilder::new();
127        let mut selection_handicap_builder = Float64Array::builder(data.len());
128        let mut price_precision_builder = UInt8Array::builder(data.len());
129        let mut size_precision_builder = UInt8Array::builder(data.len());
130        let mut price_increment_builder = StringBuilder::new();
131        let mut size_increment_builder = StringBuilder::new();
132        let mut max_quantity_builder = StringBuilder::new();
133        let mut min_quantity_builder = StringBuilder::new();
134        let mut max_notional_builder = StringBuilder::new();
135        let mut min_notional_builder = StringBuilder::new();
136        let mut max_price_builder = StringBuilder::new();
137        let mut min_price_builder = StringBuilder::new();
138        let mut margin_init_builder = StringBuilder::new();
139        let mut margin_maint_builder = StringBuilder::new();
140        let mut maker_fee_builder = StringBuilder::new();
141        let mut taker_fee_builder = StringBuilder::new();
142        let mut tick_scheme_builder = StringBuilder::new();
143        let mut info_builder = BinaryBuilder::new();
144        let mut ts_event_builder = UInt64Array::builder(data.len());
145        let mut ts_init_builder = UInt64Array::builder(data.len());
146
147        for bi in data {
148            id_builder.append_value(bi.id.to_string());
149            raw_symbol_builder.append_value(bi.raw_symbol);
150            // Extract venue_name from instrument_id (format: "SYMBOL.VENUE")
151            let venue_name = bi.id.venue.to_string();
152            venue_name_builder.append_value(venue_name);
153            currency_builder.append_value(bi.currency.to_string());
154            event_type_id_builder.append_value(bi.event_type_id);
155            event_type_name_builder.append_value(bi.event_type_name);
156            competition_id_builder.append_value(bi.competition_id);
157            competition_name_builder.append_value(bi.competition_name);
158            event_id_builder.append_value(bi.event_id);
159            event_name_builder.append_value(bi.event_name);
160            event_country_code_builder.append_value(bi.event_country_code);
161            event_open_date_builder.append_value(bi.event_open_date.as_u64());
162            betting_type_builder.append_value(bi.betting_type);
163            market_id_builder.append_value(bi.market_id);
164            market_name_builder.append_value(bi.market_name);
165            market_type_builder.append_value(bi.market_type);
166            market_start_time_builder.append_value(bi.market_start_time.as_u64());
167            selection_id_builder.append_value(bi.selection_id);
168            selection_name_builder.append_value(bi.selection_name);
169            selection_handicap_builder.append_value(bi.selection_handicap);
170            price_precision_builder.append_value(bi.price_precision);
171            size_precision_builder.append_value(bi.size_precision);
172            price_increment_builder.append_value(bi.price_increment.to_string());
173            size_increment_builder.append_value(bi.size_increment.to_string());
174
175            if let Some(max_quantity) = bi.max_quantity {
176                max_quantity_builder.append_value(max_quantity.to_string());
177            } else {
178                max_quantity_builder.append_null();
179            }
180
181            if let Some(min_quantity) = bi.min_quantity {
182                min_quantity_builder.append_value(min_quantity.to_string());
183            } else {
184                min_quantity_builder.append_null();
185            }
186
187            if let Some(max_notional) = bi.max_notional {
188                max_notional_builder.append_value(max_notional.to_string());
189            } else {
190                max_notional_builder.append_null();
191            }
192
193            if let Some(min_notional) = bi.min_notional {
194                min_notional_builder.append_value(min_notional.to_string());
195            } else {
196                min_notional_builder.append_null();
197            }
198
199            if let Some(max_price) = bi.max_price {
200                max_price_builder.append_value(max_price.to_string());
201            } else {
202                max_price_builder.append_null();
203            }
204
205            if let Some(min_price) = bi.min_price {
206                min_price_builder.append_value(min_price.to_string());
207            } else {
208                min_price_builder.append_null();
209            }
210
211            margin_init_builder.append_value(bi.margin_init.to_string());
212            margin_maint_builder.append_value(bi.margin_maint.to_string());
213            maker_fee_builder.append_value(bi.maker_fee.to_string());
214            taker_fee_builder.append_value(bi.taker_fee.to_string());
215
216            if let Some(tick_scheme) = bi.tick_scheme {
217                tick_scheme_builder.append_value(tick_scheme);
218            } else {
219                tick_scheme_builder.append_null();
220            }
221
222            // Encode info dict as JSON bytes (matching Python's msgspec.json.encode)
223            if let Some(ref info) = bi.info {
224                match serde_json::to_vec(info) {
225                    Ok(json_bytes) => {
226                        info_builder.append_value(json_bytes);
227                    }
228                    Err(e) => {
229                        return Err(ArrowError::InvalidArgumentError(format!(
230                            "Failed to serialize info dict to JSON: {e}"
231                        )));
232                    }
233                }
234            } else {
235                info_builder.append_null();
236            }
237
238            ts_event_builder.append_value(bi.ts_event.as_u64());
239            ts_init_builder.append_value(bi.ts_init.as_u64());
240        }
241
242        let mut final_metadata = metadata.clone();
243        final_metadata.insert("class".to_string(), "BettingInstrument".to_string());
244
245        RecordBatch::try_new(
246            Self::get_schema(Some(final_metadata)).into(),
247            vec![
248                Arc::new(id_builder.finish()),
249                Arc::new(raw_symbol_builder.finish()),
250                Arc::new(venue_name_builder.finish()),
251                Arc::new(currency_builder.finish()),
252                Arc::new(event_type_id_builder.finish()),
253                Arc::new(event_type_name_builder.finish()),
254                Arc::new(competition_id_builder.finish()),
255                Arc::new(competition_name_builder.finish()),
256                Arc::new(event_id_builder.finish()),
257                Arc::new(event_name_builder.finish()),
258                Arc::new(event_country_code_builder.finish()),
259                Arc::new(event_open_date_builder.finish()),
260                Arc::new(betting_type_builder.finish()),
261                Arc::new(market_id_builder.finish()),
262                Arc::new(market_name_builder.finish()),
263                Arc::new(market_type_builder.finish()),
264                Arc::new(market_start_time_builder.finish()),
265                Arc::new(selection_id_builder.finish()),
266                Arc::new(selection_name_builder.finish()),
267                Arc::new(selection_handicap_builder.finish()),
268                Arc::new(price_precision_builder.finish()),
269                Arc::new(size_precision_builder.finish()),
270                Arc::new(price_increment_builder.finish()),
271                Arc::new(size_increment_builder.finish()),
272                Arc::new(max_quantity_builder.finish()),
273                Arc::new(min_quantity_builder.finish()),
274                Arc::new(max_notional_builder.finish()),
275                Arc::new(min_notional_builder.finish()),
276                Arc::new(max_price_builder.finish()),
277                Arc::new(min_price_builder.finish()),
278                Arc::new(margin_init_builder.finish()),
279                Arc::new(margin_maint_builder.finish()),
280                Arc::new(maker_fee_builder.finish()),
281                Arc::new(taker_fee_builder.finish()),
282                Arc::new(tick_scheme_builder.finish()),
283                Arc::new(info_builder.finish()),
284                Arc::new(ts_event_builder.finish()),
285                Arc::new(ts_init_builder.finish()),
286            ],
287        )
288    }
289
290    fn metadata(&self) -> HashMap<String, String> {
291        let mut metadata = HashMap::new();
292        metadata.insert(KEY_INSTRUMENT_ID.to_string(), self.id.to_string());
293        metadata.insert(
294            KEY_PRICE_PRECISION.to_string(),
295            self.price_precision.to_string(),
296        );
297        metadata.insert(
298            KEY_SIZE_PRECISION.to_string(),
299            self.size_precision.to_string(),
300        );
301        metadata
302    }
303}
304
305/// Helper function to decode BettingInstrument from RecordBatch
306/// (Cannot implement DecodeFromRecordBatch trait due to `Into<Data>` bound)
307///
308/// # Errors
309///
310/// Returns an `EncodingError` if the RecordBatch cannot be decoded.
311pub fn decode_betting_instrument_batch(
312    #[allow(unused)] metadata: &HashMap<String, String>,
313    record_batch: &RecordBatch,
314) -> Result<Vec<BettingInstrument>, EncodingError> {
315    let cols = record_batch.columns();
316    let num_rows = record_batch.num_rows();
317
318    let id_values = extract_column::<StringArray>(cols, "id", 0, DataType::Utf8)?;
319    let raw_symbol_values = extract_column::<StringArray>(cols, "raw_symbol", 1, DataType::Utf8)?;
320    let _venue_name_values = extract_column::<StringArray>(cols, "venue_name", 2, DataType::Utf8)?; // Not used, extracted from id
321    let currency_values = extract_column::<StringArray>(cols, "currency", 3, DataType::Utf8)?;
322    let event_type_id_values =
323        extract_column::<UInt64Array>(cols, "event_type_id", 4, DataType::UInt64)?;
324    let event_type_name_values =
325        extract_column::<StringArray>(cols, "event_type_name", 5, DataType::Utf8)?;
326    let competition_id_values =
327        extract_column::<UInt64Array>(cols, "competition_id", 6, DataType::UInt64)?;
328    let competition_name_values =
329        extract_column::<StringArray>(cols, "competition_name", 7, DataType::Utf8)?;
330    let event_id_values = extract_column::<UInt64Array>(cols, "event_id", 8, DataType::UInt64)?;
331    let event_name_values = extract_column::<StringArray>(cols, "event_name", 9, DataType::Utf8)?;
332    let event_country_code_values =
333        extract_column::<StringArray>(cols, "event_country_code", 10, DataType::Utf8)?;
334    let event_open_date_values =
335        extract_column::<UInt64Array>(cols, "event_open_date", 11, DataType::UInt64)?;
336    let betting_type_values =
337        extract_column::<StringArray>(cols, "betting_type", 12, DataType::Utf8)?;
338    let market_id_values = extract_column::<StringArray>(cols, "market_id", 13, DataType::Utf8)?;
339    let market_name_values =
340        extract_column::<StringArray>(cols, "market_name", 14, DataType::Utf8)?;
341    let market_type_values =
342        extract_column::<StringArray>(cols, "market_type", 15, DataType::Utf8)?;
343    let market_start_time_values =
344        extract_column::<UInt64Array>(cols, "market_start_time", 16, DataType::UInt64)?;
345    let selection_id_values =
346        extract_column::<UInt64Array>(cols, "selection_id", 17, DataType::UInt64)?;
347    let selection_name_values =
348        extract_column::<StringArray>(cols, "selection_name", 18, DataType::Utf8)?;
349    let selection_handicap_values =
350        extract_column::<Float64Array>(cols, "selection_handicap", 19, DataType::Float64)?;
351    let price_precision_values =
352        extract_column::<UInt8Array>(cols, "price_precision", 20, DataType::UInt8)?;
353    let size_precision_values =
354        extract_column::<UInt8Array>(cols, "size_precision", 21, DataType::UInt8)?;
355    let price_increment_values =
356        extract_column::<StringArray>(cols, "price_increment", 22, DataType::Utf8)?;
357    let size_increment_values =
358        extract_column::<StringArray>(cols, "size_increment", 23, DataType::Utf8)?;
359    let max_quantity_values = extract_optional_string_column_by_name(record_batch, "max_quantity")?;
360    let min_quantity_values = extract_optional_string_column_by_name(record_batch, "min_quantity")?;
361    let max_notional_values = extract_optional_string_column_by_name(record_batch, "max_notional")?;
362    let min_notional_values = extract_optional_string_column_by_name(record_batch, "min_notional")?;
363    let max_price_values = extract_optional_string_column_by_name(record_batch, "max_price")?;
364    let min_price_values = extract_optional_string_column_by_name(record_batch, "min_price")?;
365    let margin_init_values =
366        extract_column::<StringArray>(cols, "margin_init", 30, DataType::Utf8)?;
367    let margin_maint_values =
368        extract_column::<StringArray>(cols, "margin_maint", 31, DataType::Utf8)?;
369    let maker_fee_values = extract_column::<StringArray>(cols, "maker_fee", 32, DataType::Utf8)?;
370    let taker_fee_values = extract_column::<StringArray>(cols, "taker_fee", 33, DataType::Utf8)?;
371    let tick_scheme_values = extract_optional_string_column_by_name(record_batch, "tick_scheme")?;
372    let info_values =
373        extract_column_by_name_or_index::<BinaryArray>(record_batch, "info", 35, DataType::Binary)?;
374    let ts_event_values = extract_column_by_name_or_index::<UInt64Array>(
375        record_batch,
376        "ts_event",
377        36,
378        DataType::UInt64,
379    )?;
380    let ts_init_values = extract_column_by_name_or_index::<UInt64Array>(
381        record_batch,
382        "ts_init",
383        37,
384        DataType::UInt64,
385    )?;
386
387    let mut result = Vec::with_capacity(num_rows);
388
389    for i in 0..num_rows {
390        let id = InstrumentId::from_str(id_values.value(i))
391            .map_err(|e| EncodingError::ParseError("id", format!("row {i}: {e}")))?;
392        let raw_symbol = Symbol::from(raw_symbol_values.value(i));
393        let currency = super::decode_currency(
394            currency_values.value(i),
395            "currency",
396            "betting_instrument.currency",
397            i,
398        )?;
399        let event_type_id = event_type_id_values.value(i);
400        let event_type_name = Ustr::from(event_type_name_values.value(i));
401        let competition_id = competition_id_values.value(i);
402        let competition_name = Ustr::from(competition_name_values.value(i));
403        let event_id = event_id_values.value(i);
404        let event_name = Ustr::from(event_name_values.value(i));
405        let event_country_code = Ustr::from(event_country_code_values.value(i));
406        let event_open_date = nautilus_core::UnixNanos::from(event_open_date_values.value(i));
407        let betting_type = Ustr::from(betting_type_values.value(i));
408        let market_id = Ustr::from(market_id_values.value(i));
409        let market_name = Ustr::from(market_name_values.value(i));
410        let market_type = Ustr::from(market_type_values.value(i));
411        let market_start_time = nautilus_core::UnixNanos::from(market_start_time_values.value(i));
412        let selection_id = selection_id_values.value(i);
413        let selection_name = Ustr::from(selection_name_values.value(i));
414        let selection_handicap = selection_handicap_values.value(i);
415        let price_prec = price_precision_values.value(i);
416        let size_prec = size_precision_values.value(i);
417
418        let price_increment = Price::from_str(price_increment_values.value(i))
419            .map_err(|e| EncodingError::ParseError("price_increment", format!("row {i}: {e}")))?;
420        let size_increment = Quantity::from_str(size_increment_values.value(i))
421            .map_err(|e| EncodingError::ParseError("size_increment", format!("row {i}: {e}")))?;
422
423        let margin_init = Decimal::from_str(margin_init_values.value(i))
424            .map_err(|e| EncodingError::ParseError("margin_init", format!("row {i}: {e}")))?;
425        let margin_maint = Decimal::from_str(margin_maint_values.value(i))
426            .map_err(|e| EncodingError::ParseError("margin_maint", format!("row {i}: {e}")))?;
427        let maker_fee = Decimal::from_str(maker_fee_values.value(i))
428            .map_err(|e| EncodingError::ParseError("maker_fee", format!("row {i}: {e}")))?;
429        let taker_fee = Decimal::from_str(taker_fee_values.value(i))
430            .map_err(|e| EncodingError::ParseError("taker_fee", format!("row {i}: {e}")))?;
431
432        // Decode info dict from JSON bytes (matching Python's msgspec.json.decode)
433        let info = if info_values.is_null(i) {
434            None
435        } else {
436            let info_bytes = info_values
437                .as_any()
438                .downcast_ref::<BinaryArray>()
439                .ok_or_else(|| EncodingError::ParseError("info", format!("row {i}: invalid type")))?
440                .value(i);
441
442            match serde_json::from_slice::<Params>(info_bytes) {
443                Ok(info_dict) => Some(info_dict),
444                Err(e) => {
445                    return Err(EncodingError::ParseError(
446                        "info",
447                        format!("row {i}: failed to deserialize JSON: {e}"),
448                    ));
449                }
450            }
451        };
452
453        let ts_event = nautilus_core::UnixNanos::from(ts_event_values.value(i));
454        let ts_init = nautilus_core::UnixNanos::from(ts_init_values.value(i));
455
456        let tick_scheme = optional_ustr_value(tick_scheme_values, i);
457
458        let max_notional = match max_notional_values {
459            Some(column) if !column.is_null(i) => {
460                Some(Money::from_str(column.value(i)).map_err(|e| {
461                    EncodingError::ParseError("max_notional", format!("row {i}: {e}"))
462                })?)
463            }
464            _ => None,
465        };
466
467        let min_notional = match min_notional_values {
468            Some(column) if !column.is_null(i) => {
469                Some(Money::from_str(column.value(i)).map_err(|e| {
470                    EncodingError::ParseError("min_notional", format!("row {i}: {e}"))
471                })?)
472            }
473            _ => None,
474        };
475
476        let betting_instrument = BettingInstrument::new_checked(
477            id,
478            raw_symbol,
479            event_type_id,
480            event_type_name,
481            competition_id,
482            competition_name,
483            event_id,
484            event_name,
485            event_country_code,
486            event_open_date,
487            betting_type,
488            market_id,
489            market_name,
490            market_type,
491            market_start_time,
492            selection_id,
493            selection_name,
494            selection_handicap,
495            currency,
496            price_prec,
497            size_prec,
498            price_increment,
499            size_increment,
500            super::optional_quantity_value(max_quantity_values, "max_quantity", i)?,
501            super::optional_quantity_value(min_quantity_values, "min_quantity", i)?,
502            max_notional,
503            min_notional,
504            super::optional_price_value(max_price_values, "max_price", i)?,
505            super::optional_price_value(min_price_values, "min_price", i)?,
506            Some(margin_init),
507            Some(margin_maint),
508            Some(maker_fee),
509            Some(taker_fee),
510            tick_scheme,
511            info,
512            ts_event,
513            ts_init,
514        )
515        .map_err(|e| super::instrument_validation_error::<BettingInstrument>(i, e))?;
516
517        result.push(betting_instrument);
518    }
519
520    Ok(result)
521}
522
523#[cfg(test)]
524mod tests {
525    use std::{collections::HashMap, sync::Arc};
526
527    use arrow::{array::UInt8Array, record_batch::RecordBatch};
528    use nautilus_model::instruments::stubs::betting;
529    use rstest::rstest;
530
531    use super::*;
532    use crate::arrow::EncodeToRecordBatch;
533
534    const PRICE_PRECISION_COLUMN: usize = 20;
535    const SIZE_PRECISION_COLUMN: usize = 21;
536
537    fn betting_batch_with_precision(column_index: usize, precision: u8) -> RecordBatch {
538        betting_batch_with_precision_values(column_index, &[precision])
539    }
540
541    fn betting_batch_with_precision_values(column_index: usize, precisions: &[u8]) -> RecordBatch {
542        let instruments = vec![betting(); precisions.len()];
543        let batch = BettingInstrument::encode_batch(&HashMap::new(), &instruments).unwrap();
544        let mut columns = batch.columns().to_vec();
545        columns[column_index] = Arc::new(UInt8Array::from(precisions.to_vec()));
546
547        RecordBatch::try_new(batch.schema(), columns).unwrap()
548    }
549
550    #[rstest]
551    fn decode_betting_instrument_invalid_price_precision_returns_error() {
552        let batch = betting_batch_with_precision(PRICE_PRECISION_COLUMN, u8::MAX);
553        let error = decode_betting_instrument_batch(&HashMap::new(), &batch).unwrap_err();
554
555        match error {
556            EncodingError::ParseError(field, message) => {
557                assert_eq!(field, super::super::INSTRUMENT_VALIDATION_FIELD);
558                assert!(message.starts_with("row 0:"));
559                assert!(message.contains("price_increment"));
560                assert!(message.contains("precision"));
561            }
562            _ => panic!("Expected instrument parse error, was: {error}"),
563        }
564    }
565
566    #[rstest]
567    fn decode_betting_instrument_invalid_second_row_precision_reports_row_index() {
568        let batch = betting_batch_with_precision_values(PRICE_PRECISION_COLUMN, &[2, u8::MAX]);
569        let error = decode_betting_instrument_batch(&HashMap::new(), &batch).unwrap_err();
570
571        match error {
572            EncodingError::ParseError(field, message) => {
573                assert_eq!(field, super::super::INSTRUMENT_VALIDATION_FIELD);
574                assert!(message.starts_with("row 1:"));
575                assert!(message.contains("price_increment"));
576                assert!(message.contains("precision"));
577            }
578            _ => panic!("Expected instrument parse error, was: {error}"),
579        }
580    }
581
582    #[rstest]
583    fn decode_betting_instrument_invalid_size_precision_returns_error() {
584        let batch = betting_batch_with_precision(SIZE_PRECISION_COLUMN, u8::MAX);
585        let error = decode_betting_instrument_batch(&HashMap::new(), &batch).unwrap_err();
586
587        match error {
588            EncodingError::ParseError(field, message) => {
589                assert_eq!(field, super::super::INSTRUMENT_VALIDATION_FIELD);
590                assert!(message.starts_with("row 0:"));
591                assert!(message.contains("size_increment"));
592                assert!(message.contains("precision"));
593            }
594            _ => panic!("Expected instrument parse error, was: {error}"),
595        }
596    }
597
598    #[rstest]
599    fn decode_betting_instrument_invalid_default_price_increment_returns_error() {
600        let batch = betting_batch_with_precision(PRICE_PRECISION_COLUMN, 1);
601        let error = decode_betting_instrument_batch(&HashMap::new(), &batch).unwrap_err();
602
603        match error {
604            EncodingError::ParseError(field, message) => {
605                assert_eq!(field, super::super::INSTRUMENT_VALIDATION_FIELD);
606                assert!(message.starts_with("row 0:"));
607                assert!(message.contains("BettingInstrument"));
608                assert!(message.contains("price_increment"));
609            }
610            _ => panic!("Expected instrument parse error, was: {error}"),
611        }
612    }
613}
nautilus_serialization/arrow/instrument/betting.rs

nautilus_serialization/arrow/instrument/
betting.rs
