statsig-rust 0.19.1

Statsig Rust SDK for usage in multi-user server environments.
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

use std::collections::HashMap;

use serde_json::json;
use statsig_rust::{dyn_value, test_only_make_eval_value};

#[test]
fn test_own_bool_comparison() {
    let left = test_only_make_eval_value!(true);
    let right = test_only_make_eval_value!(false);
    assert_eq!(left, left);
    assert_ne!(left, right);
}

#[test]
fn test_own_int_comparison() {
    let left = test_only_make_eval_value!(1);
    let right = test_only_make_eval_value!(2);
    assert_eq!(left, left);
    assert_ne!(left, right);
}

#[test]
fn test_own_float_comparison() {
    let left = test_only_make_eval_value!(1.0_f64);
    let right = test_only_make_eval_value!(2.0_f64);
    assert_eq!(left, left);
    assert_ne!(left, right);
}

#[test]
fn test_own_string_comparison() {
    let left = test_only_make_eval_value!("apple");
    let right = test_only_make_eval_value!("banana");
    assert_eq!(left, left);
    assert_ne!(left, right);
}

#[test]
fn test_own_array_comparison() {
    let left = test_only_make_eval_value!([1, 2, 3]);
    let right = test_only_make_eval_value!([4, 5]);

    assert_eq!(left, left);
    assert_ne!(left, right);
}

#[test]
fn test_own_object_comparison() {
    let left = test_only_make_eval_value!(HashMap::from([("1".to_string(), 2)]));
    let right = test_only_make_eval_value!(HashMap::from([("3".to_string(), 4)]));

    println!("{right:?}");

    assert_eq!(left, left);
    assert_ne!(left, right);
}

#[test]
fn test_dyn_value_bool_comparison() {
    let ev_true = test_only_make_eval_value!(true);

    let dv_true = dyn_value!(true);
    let dv_false = dyn_value!(false);

    assert!(ev_true.is_equal_to_dynamic_value(&dv_true));
    assert!(!ev_true.is_equal_to_dynamic_value(&dv_false));
}

#[test]
fn test_dyn_value_int_comparison() {
    let ev_1 = test_only_make_eval_value!(1);

    let dv_1 = dyn_value!(1);
    let dv_2 = dyn_value!(2);

    assert!(ev_1.is_equal_to_dynamic_value(&dv_1));
    assert!(!ev_1.is_equal_to_dynamic_value(&dv_2));
}

#[test]
fn test_dyn_value_float_comparison() {
    let ev_1 = test_only_make_eval_value!(1.0_f64);

    let dv_1 = dyn_value!(1.0_f64);
    let dv_2 = dyn_value!(2.0_f64);

    assert!(ev_1.is_equal_to_dynamic_value(&dv_1));
    assert!(!ev_1.is_equal_to_dynamic_value(&dv_2));
}

#[test]
fn test_dyn_value_string_comparison() {
    let ev_apple = test_only_make_eval_value!("apple");

    let dv_apple = dyn_value!("apple");
    let dv_banana = dyn_value!("banana");

    assert!(ev_apple.is_equal_to_dynamic_value(&dv_apple));
    assert!(!ev_apple.is_equal_to_dynamic_value(&dv_banana));
}

#[test]
fn test_dyn_value_array_comparison() {
    let ev_array = test_only_make_eval_value!([1, 2, 3]);

    let dv_array_1 = dyn_value!(json!(vec![1, 2, 3]));
    let dv_array_2 = dyn_value!(json!(vec![4, 5]));

    assert!(ev_array.is_equal_to_dynamic_value(&dv_array_1));
    assert!(!ev_array.is_equal_to_dynamic_value(&dv_array_2));
}

#[test]
fn test_dyn_value_object_comparison() {
    let ev_object = test_only_make_eval_value!(HashMap::from([("1".to_string(), 2)]));
    let dv_object_1 = dyn_value!(json!({"1": 2}));
    let dv_object_2 = dyn_value!(json!({"3": 4}));

    assert!(ev_object.is_equal_to_dynamic_value(&dv_object_1));
    assert!(!ev_object.is_equal_to_dynamic_value(&dv_object_2));
}