stripe_shared/
test_helpers_test_clock.rs

1/// A test clock enables deterministic control over objects in testmode.
2/// With a test clock, you can create.
3/// objects at a frozen time in the past or future, and advance to a specific future time to observe webhooks and state changes.
4/// After the clock advances,.
5/// you can either validate the current state of your scenario (and test your assumptions), change the current state of your scenario (and test more complex scenarios), or keep advancing forward in time.
6#[derive(Clone, Eq, PartialEq)]
7#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
8#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
9pub struct TestHelpersTestClock {
10    /// Time at which the object was created. Measured in seconds since the Unix epoch.
11    pub created: stripe_types::Timestamp,
12    /// Time at which this clock is scheduled to auto delete.
13    pub deletes_after: stripe_types::Timestamp,
14    /// Time at which all objects belonging to this clock are frozen.
15    pub frozen_time: stripe_types::Timestamp,
16    /// Unique identifier for the object.
17    pub id: stripe_shared::TestHelpersTestClockId,
18    /// If the object exists in live mode, the value is `true`.
19    /// If the object exists in test mode, the value is `false`.
20    pub livemode: bool,
21    /// The custom name supplied at creation.
22    pub name: Option<String>,
23    /// The status of the Test Clock.
24    pub status: TestHelpersTestClockStatus,
25    pub status_details: stripe_shared::BillingClocksResourceStatusDetailsStatusDetails,
26}
27#[cfg(feature = "redact-generated-debug")]
28impl std::fmt::Debug for TestHelpersTestClock {
29    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
30        f.debug_struct("TestHelpersTestClock").finish_non_exhaustive()
31    }
32}
33#[doc(hidden)]
34pub struct TestHelpersTestClockBuilder {
35    created: Option<stripe_types::Timestamp>,
36    deletes_after: Option<stripe_types::Timestamp>,
37    frozen_time: Option<stripe_types::Timestamp>,
38    id: Option<stripe_shared::TestHelpersTestClockId>,
39    livemode: Option<bool>,
40    name: Option<Option<String>>,
41    status: Option<TestHelpersTestClockStatus>,
42    status_details: Option<stripe_shared::BillingClocksResourceStatusDetailsStatusDetails>,
43}
44
45#[allow(
46    unused_variables,
47    irrefutable_let_patterns,
48    clippy::let_unit_value,
49    clippy::match_single_binding,
50    clippy::single_match
51)]
52const _: () = {
53    use miniserde::de::{Map, Visitor};
54    use miniserde::json::Value;
55    use miniserde::{Deserialize, Result, make_place};
56    use stripe_types::miniserde_helpers::FromValueOpt;
57    use stripe_types::{MapBuilder, ObjectDeser};
58
59    make_place!(Place);
60
61    impl Deserialize for TestHelpersTestClock {
62        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
63            Place::new(out)
64        }
65    }
66
67    struct Builder<'a> {
68        out: &'a mut Option<TestHelpersTestClock>,
69        builder: TestHelpersTestClockBuilder,
70    }
71
72    impl Visitor for Place<TestHelpersTestClock> {
73        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
74            Ok(Box::new(Builder {
75                out: &mut self.out,
76                builder: TestHelpersTestClockBuilder::deser_default(),
77            }))
78        }
79    }
80
81    impl MapBuilder for TestHelpersTestClockBuilder {
82        type Out = TestHelpersTestClock;
83        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
84            Ok(match k {
85                "created" => Deserialize::begin(&mut self.created),
86                "deletes_after" => Deserialize::begin(&mut self.deletes_after),
87                "frozen_time" => Deserialize::begin(&mut self.frozen_time),
88                "id" => Deserialize::begin(&mut self.id),
89                "livemode" => Deserialize::begin(&mut self.livemode),
90                "name" => Deserialize::begin(&mut self.name),
91                "status" => Deserialize::begin(&mut self.status),
92                "status_details" => Deserialize::begin(&mut self.status_details),
93                _ => <dyn Visitor>::ignore(),
94            })
95        }
96
97        fn deser_default() -> Self {
98            Self {
99                created: None,
100                deletes_after: None,
101                frozen_time: None,
102                id: None,
103                livemode: None,
104                name: Some(None),
105                status: None,
106                status_details: None,
107            }
108        }
109
110        fn take_out(&mut self) -> Option<Self::Out> {
111            let (
112                Some(created),
113                Some(deletes_after),
114                Some(frozen_time),
115                Some(id),
116                Some(livemode),
117                Some(name),
118                Some(status),
119                Some(status_details),
120            ) = (
121                self.created,
122                self.deletes_after,
123                self.frozen_time,
124                self.id.take(),
125                self.livemode,
126                self.name.take(),
127                self.status.take(),
128                self.status_details,
129            )
130            else {
131                return None;
132            };
133            Some(Self::Out {
134                created,
135                deletes_after,
136                frozen_time,
137                id,
138                livemode,
139                name,
140                status,
141                status_details,
142            })
143        }
144    }
145
146    impl Map for Builder<'_> {
147        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
148            self.builder.key(k)
149        }
150
151        fn finish(&mut self) -> Result<()> {
152            *self.out = self.builder.take_out();
153            Ok(())
154        }
155    }
156
157    impl ObjectDeser for TestHelpersTestClock {
158        type Builder = TestHelpersTestClockBuilder;
159    }
160
161    impl FromValueOpt for TestHelpersTestClock {
162        fn from_value(v: Value) -> Option<Self> {
163            let Value::Object(obj) = v else {
164                return None;
165            };
166            let mut b = TestHelpersTestClockBuilder::deser_default();
167            for (k, v) in obj {
168                match k.as_str() {
169                    "created" => b.created = FromValueOpt::from_value(v),
170                    "deletes_after" => b.deletes_after = FromValueOpt::from_value(v),
171                    "frozen_time" => b.frozen_time = FromValueOpt::from_value(v),
172                    "id" => b.id = FromValueOpt::from_value(v),
173                    "livemode" => b.livemode = FromValueOpt::from_value(v),
174                    "name" => b.name = FromValueOpt::from_value(v),
175                    "status" => b.status = FromValueOpt::from_value(v),
176                    "status_details" => b.status_details = FromValueOpt::from_value(v),
177                    _ => {}
178                }
179            }
180            b.take_out()
181        }
182    }
183};
184#[cfg(feature = "serialize")]
185impl serde::Serialize for TestHelpersTestClock {
186    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
187        use serde::ser::SerializeStruct;
188        let mut s = s.serialize_struct("TestHelpersTestClock", 9)?;
189        s.serialize_field("created", &self.created)?;
190        s.serialize_field("deletes_after", &self.deletes_after)?;
191        s.serialize_field("frozen_time", &self.frozen_time)?;
192        s.serialize_field("id", &self.id)?;
193        s.serialize_field("livemode", &self.livemode)?;
194        s.serialize_field("name", &self.name)?;
195        s.serialize_field("status", &self.status)?;
196        s.serialize_field("status_details", &self.status_details)?;
197
198        s.serialize_field("object", "test_helpers.test_clock")?;
199        s.end()
200    }
201}
202/// The status of the Test Clock.
203#[derive(Clone, Eq, PartialEq)]
204#[non_exhaustive]
205pub enum TestHelpersTestClockStatus {
206    Advancing,
207    InternalFailure,
208    Ready,
209    /// An unrecognized value from Stripe. Should not be used as a request parameter.
210    Unknown(String),
211}
212impl TestHelpersTestClockStatus {
213    pub fn as_str(&self) -> &str {
214        use TestHelpersTestClockStatus::*;
215        match self {
216            Advancing => "advancing",
217            InternalFailure => "internal_failure",
218            Ready => "ready",
219            Unknown(v) => v,
220        }
221    }
222}
223
224impl std::str::FromStr for TestHelpersTestClockStatus {
225    type Err = std::convert::Infallible;
226    fn from_str(s: &str) -> Result<Self, Self::Err> {
227        use TestHelpersTestClockStatus::*;
228        match s {
229            "advancing" => Ok(Advancing),
230            "internal_failure" => Ok(InternalFailure),
231            "ready" => Ok(Ready),
232            v => {
233                tracing::warn!("Unknown value '{}' for enum '{}'", v, "TestHelpersTestClockStatus");
234                Ok(Unknown(v.to_owned()))
235            }
236        }
237    }
238}
239impl std::fmt::Display for TestHelpersTestClockStatus {
240    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
241        f.write_str(self.as_str())
242    }
243}
244
245#[cfg(not(feature = "redact-generated-debug"))]
246impl std::fmt::Debug for TestHelpersTestClockStatus {
247    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
248        f.write_str(self.as_str())
249    }
250}
251#[cfg(feature = "redact-generated-debug")]
252impl std::fmt::Debug for TestHelpersTestClockStatus {
253    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
254        f.debug_struct(stringify!(TestHelpersTestClockStatus)).finish_non_exhaustive()
255    }
256}
257#[cfg(feature = "serialize")]
258impl serde::Serialize for TestHelpersTestClockStatus {
259    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
260    where
261        S: serde::Serializer,
262    {
263        serializer.serialize_str(self.as_str())
264    }
265}
266impl miniserde::Deserialize for TestHelpersTestClockStatus {
267    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
268        crate::Place::new(out)
269    }
270}
271
272impl miniserde::de::Visitor for crate::Place<TestHelpersTestClockStatus> {
273    fn string(&mut self, s: &str) -> miniserde::Result<()> {
274        use std::str::FromStr;
275        self.out = Some(TestHelpersTestClockStatus::from_str(s).expect("infallible"));
276        Ok(())
277    }
278}
279
280stripe_types::impl_from_val_with_from_str!(TestHelpersTestClockStatus);
281#[cfg(feature = "deserialize")]
282impl<'de> serde::Deserialize<'de> for TestHelpersTestClockStatus {
283    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
284        use std::str::FromStr;
285        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
286        Ok(Self::from_str(&s).expect("infallible"))
287    }
288}
289impl stripe_types::Object for TestHelpersTestClock {
290    type Id = stripe_shared::TestHelpersTestClockId;
291    fn id(&self) -> &Self::Id {
292        &self.id
293    }
294
295    fn into_id(self) -> Self::Id {
296        self.id
297    }
298}
299stripe_types::def_id!(TestHelpersTestClockId);
stripe_shared/test_helpers_test_clock.rs

stripe_shared/
test_helpers_test_clock.rs
