fts-sqlite 0.2.1

A simple, reference backend for `fts` implemented with SQLite
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

mod common;

use common::TestApp;
use fts_core::{
    models::PortfolioRecord,
    ports::{Application, PortfolioRepository, ProductRepository as _},
};
use fts_sqlite::{
    Db,
    config::SqliteConfig,
    types::{BidderId, DateTime},
};

#[tokio::test]
async fn test_product_expansion() -> anyhow::Result<()> {
    let now = time::OffsetDateTime::now_utc();

    let database = Db::open(&SqliteConfig::default(), now.into()).await?;
    let app = TestApp(database);

    let db = app.database();

    let bidder_id = BidderId(uuid::Uuid::new_v4());

    let food = app.generate_product_id(&());
    let fruit = app.generate_product_id(&());
    let apple = app.generate_product_id(&());
    let banana = app.generate_product_id(&());
    let vegetable = app.generate_product_id(&());
    let carrot = app.generate_product_id(&());
    let daikon = app.generate_product_id(&());

    db.create_product(food, (), now.into()).await?;

    let portfolio_id = app.generate_portfolio_id(&());
    db.create_portfolio(
        portfolio_id,
        bidder_id,
        (),
        Default::default(),
        std::iter::once((food, 1.0)).into_iter().collect(),
        (now + std::time::Duration::from_secs(1)).into(),
    )
    .await?;

    db.partition_product(
        food,
        vec![(fruit, (), 2.0), (vegetable, (), 3.0)],
        (now + std::time::Duration::from_secs(2)).into(),
    )
    .await?;

    db.partition_product(
        fruit,
        vec![(apple, (), 5.0), (banana, (), 7.0)],
        (now + std::time::Duration::from_secs(4)).into(),
    )
    .await?;

    db.partition_product(
        vegetable,
        vec![(carrot, (), 11.0), (daikon, (), 13.0)],
        (now + std::time::Duration::from_secs(6)).into(),
    )
    .await?;

    // Test at different time points
    for i in 0u64..=7 {
        let as_of = DateTime::from(now + std::time::Duration::from_secs(i));
        let PortfolioRecord { product_group, .. } =
            <Db as PortfolioRepository<()>>::get_portfolio(db, portfolio_id, as_of)
                .await?
                .unwrap();

        // Additional assertions based on the time point
        match i {
            0 => {
                // Before any product expansion
                assert_eq!(product_group.len(), 0);
            }
            1 => {
                // After portfolio creation but before partition
                assert_eq!(product_group.len(), 1);
                assert!(product_group.contains_key(&food));
                assert_eq!(product_group.get(&food), Some(&1.0));
            }
            2 | 3 => {
                // After first partition
                assert_eq!(product_group.len(), 2);
                assert!(product_group.contains_key(&fruit));
                assert!(product_group.contains_key(&vegetable));
                assert_eq!(product_group.get(&fruit), Some(&2.0));
                assert_eq!(product_group.get(&vegetable), Some(&3.0));
            }
            4 | 5 => {
                // After fruit partition
                assert_eq!(product_group.len(), 3);
                assert!(product_group.contains_key(&vegetable));
                assert!(product_group.contains_key(&apple));
                assert!(product_group.contains_key(&banana));
                assert_eq!(product_group.get(&vegetable), Some(&3.0));
                assert_eq!(product_group.get(&apple), Some(&10.0));
                assert_eq!(product_group.get(&banana), Some(&14.0));
            }
            6 | 7 => {
                // After vegetable partition
                assert_eq!(product_group.len(), 4);
                assert!(product_group.contains_key(&apple));
                assert!(product_group.contains_key(&banana));
                assert!(product_group.contains_key(&carrot));
                assert!(product_group.contains_key(&daikon));
                assert_eq!(product_group.get(&apple), Some(&10.0));
                assert_eq!(product_group.get(&banana), Some(&14.0));
                assert_eq!(product_group.get(&carrot), Some(&33.0));
                assert_eq!(product_group.get(&daikon), Some(&39.0));
            }
            _ => {}
        }
    }

    Ok(())
}