rustrails-record 0.1.2

ORM layer (ActiveRecord equivalent)
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
140
141
142
143
144

/// Timestamp behavior for records with `created_at` and `updated_at` fields.
pub trait Timestamps {
    /// Returns the creation timestamp when present.
    fn created_at(&self) -> Option<chrono::DateTime<chrono::Utc>>;

    /// Returns the last update timestamp when present.
    fn updated_at(&self) -> Option<chrono::DateTime<chrono::Utc>>;

    /// Updates the `updated_at` timestamp to the current time.
    fn touch(&mut self);

    /// Sets the `created_at` timestamp when creating a record.
    fn set_created_at(&mut self);
}

#[cfg(test)]
mod tests {
    use chrono::{Duration, Utc};

    use super::Timestamps;

    #[derive(Debug, Default)]
    struct TimestampedRecord {
        created_at: Option<chrono::DateTime<Utc>>,
        updated_at: Option<chrono::DateTime<Utc>>,
    }

    impl Timestamps for TimestampedRecord {
        fn created_at(&self) -> Option<chrono::DateTime<Utc>> {
            self.created_at
        }

        fn updated_at(&self) -> Option<chrono::DateTime<Utc>> {
            self.updated_at
        }

        fn touch(&mut self) {
            self.updated_at = Some(Utc::now());
        }

        fn set_created_at(&mut self) {
            self.created_at = Some(Utc::now());
        }
    }

    #[tokio::test]
    async fn touch_updates_timestamp() {
        let mut record = TimestampedRecord {
            updated_at: Some(Utc::now() - Duration::minutes(5)),
            ..Default::default()
        };
        let before = record.updated_at().expect("updated_at should be set");

        record.touch();

        assert!(record.updated_at().expect("updated_at should be set") >= before);
    }

    #[tokio::test]
    async fn set_created_at_sets_timestamp() {
        let mut record = TimestampedRecord::default();

        record.set_created_at();

        assert!(record.created_at().is_some());
    }

    #[tokio::test]
    async fn created_and_updated_timestamps_are_independent() {
        let mut record = TimestampedRecord::default();

        record.set_created_at();
        let created_at = record.created_at().expect("created_at should be set");
        record.touch();

        assert_eq!(
            record.created_at().expect("created_at should remain set"),
            created_at
        );
        assert!(record.updated_at().is_some());
    }

    #[tokio::test]
    async fn default_state_has_no_timestamps() {
        let record = TimestampedRecord::default();

        assert!(record.created_at().is_none());
        assert!(record.updated_at().is_none());
    }

    #[tokio::test]
    async fn touch_does_not_set_created_at_when_absent() {
        let mut record = TimestampedRecord::default();

        record.touch();

        assert!(record.created_at().is_none());
        assert!(record.updated_at().is_some());
    }

    #[tokio::test]
    async fn set_created_at_does_not_set_updated_at_when_absent() {
        let mut record = TimestampedRecord::default();

        record.set_created_at();

        assert!(record.created_at().is_some());
        assert!(record.updated_at().is_none());
    }

    #[tokio::test]
    async fn repeated_touch_updates_only_updated_at() {
        let created_at = Utc::now() - Duration::days(1);
        let mut record = TimestampedRecord {
            created_at: Some(created_at),
            updated_at: Some(Utc::now() - Duration::minutes(5)),
        };

        record.touch();
        let first_update = record.updated_at().expect("updated_at should be set");
        record.touch();
        let second_update = record.updated_at().expect("updated_at should stay set");

        assert_eq!(record.created_at(), Some(created_at));
        assert!(second_update >= first_update);
    }

    #[tokio::test]
    async fn repeated_set_created_at_updates_only_created_at() {
        let updated_at = Utc::now() - Duration::hours(1);
        let mut record = TimestampedRecord {
            created_at: Some(Utc::now() - Duration::days(1)),
            updated_at: Some(updated_at),
        };

        record.set_created_at();
        let first_created_at = record.created_at().expect("created_at should be set");
        record.set_created_at();
        let second_created_at = record.created_at().expect("created_at should stay set");

        assert_eq!(record.updated_at(), Some(updated_at));
        assert!(second_created_at >= first_created_at);
    }
}