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

stripe_shared/
test_helpers_test_clock.rs
