valobj 0.1.2

A Rust library for defining value objects using procedural macros.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::convert::AsRef;
use valobj::value_object;

// Test getter implementation with String type
#[value_object]
pub struct ApiKey(String);

#[test]
fn test_getter_string_get_returns_str_reference() {
    let key = ApiKey::from("sk-1234567890abcdef".to_string());
    let key_ref: &str = key.get();
    assert_eq!(key_ref, "sk-1234567890abcdef");
}

#[test]
fn test_getter_string_get_returns_correct_type() {
    let key = ApiKey::from("secret-key".to_string());
    let key_ref = key.get();
    // Verify it's &str by checking string methods are available
    assert_eq!(key_ref.len(), 10);
}

#[test]
fn test_getter_string_as_ref_returns_str() {
    let key = ApiKey::from("my-api-key".to_string());
    let key_ref: &str = key.as_ref();
    assert_eq!(key_ref, "my-api-key");
}

#[test]
fn test_getter_string_as_ref_trait_works() {
    let key = ApiKey::from("test-key".to_string());
    // Test that AsRef<str> is properly implemented
    fn requires_as_ref<T: AsRef<str>>(t: T) -> usize {
        t.as_ref().len()
    }
    assert_eq!(requires_as_ref(&key), 8);
}

#[test]
fn test_getter_string_get_and_as_ref_equivalent() {
    let key = ApiKey::from("identical-key".to_string());
    assert_eq!(key.get(), key.as_ref());
}

// Test getter implementation with primitive type (i32)
#[value_object]
pub struct Score(i32);

#[test]
fn test_getter_i32_get_returns_copy() {
    let score = Score::from(100i32);
    let value: i32 = score.get();
    assert_eq!(value, 100i32);
}

#[test]
fn test_getter_i32_get_copyable_multiple_calls() {
    let score = Score::from(42i32);
    let val1 = score.get();
    let val2 = score.get(); // Can call get() multiple times
    assert_eq!(val1, val2);
}

#[test]
fn test_getter_i32_as_ref_returns_reference() {
    let score = Score::from(75i32);
    let score_ref: &i32 = score.as_ref();
    assert_eq!(*score_ref, 75i32);
}

#[test]
fn test_getter_i32_as_ref_trait_works() {
    let score = Score::from(88i32);
    fn requires_as_ref<T: AsRef<i32>>(t: T) -> i32 {
        *t.as_ref()
    }
    assert_eq!(requires_as_ref(&score), 88i32);
}

#[test]
fn test_getter_i32_get_returns_value() {
    let score = Score::from(50i32);
    let value = score.get();
    // For primitives, get() returns the value directly
    assert_eq!(value, 50i32);
}

// Test getter with f64
#[value_object]
pub struct Rating(f64);

#[test]
fn test_getter_f64_get_returns_value() {
    let rating = Rating::from(4.5);
    let value: f64 = rating.get();
    assert_eq!(value, 4.5);
}

#[test]
fn test_getter_f64_as_ref_returns_reference() {
    let rating = Rating::from(3.7);
    let rating_ref: &f64 = rating.as_ref();
    assert_eq!(*rating_ref, 3.7);
}

#[test]
fn test_getter_f64_as_ref_trait_works() {
    let rating = Rating::from(2.9);
    fn requires_as_ref<T: AsRef<f64>>(t: T) -> f64 {
        *t.as_ref()
    }
    assert_eq!(requires_as_ref(&rating), 2.9);
}

// Test getter with u64
#[value_object]
pub struct Timestamp(u64);

#[test]
fn test_getter_u64_get_returns_value() {
    let ts = Timestamp::from(1234567890u64);
    let value: u64 = ts.get();
    assert_eq!(value, 1234567890u64);
}

#[test]
fn test_getter_u64_get_multiple_calls() {
    let ts = Timestamp::from(9876543210u64);
    assert_eq!(ts.get(), ts.get());
    assert_eq!(ts.get(), 9876543210u64);
}

#[test]
fn test_getter_u64_as_ref_returns_reference() {
    let ts = Timestamp::from(5555555555u64);
    let ts_ref: &u64 = ts.as_ref();
    assert_eq!(*ts_ref, 5555555555u64);
}