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::{Deserialize, Result, make_place};
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                _ => <dyn Visitor>::ignore(),
86            })
87        }
88
89        fn deser_default() -> Self {
90            Self {
91                created: Deserialize::default(),
92                deletes_after: Deserialize::default(),
93                frozen_time: Deserialize::default(),
94                id: Deserialize::default(),
95                livemode: Deserialize::default(),
96                name: Deserialize::default(),
97                status: Deserialize::default(),
98                status_details: Deserialize::default(),
99            }
100        }
101
102        fn take_out(&mut self) -> Option<Self::Out> {
103            let (
104                Some(created),
105                Some(deletes_after),
106                Some(frozen_time),
107                Some(id),
108                Some(livemode),
109                Some(name),
110                Some(status),
111                Some(status_details),
112            ) = (
113                self.created,
114                self.deletes_after,
115                self.frozen_time,
116                self.id.take(),
117                self.livemode,
118                self.name.take(),
119                self.status.take(),
120                self.status_details,
121            )
122            else {
123                return None;
124            };
125            Some(Self::Out {
126                created,
127                deletes_after,
128                frozen_time,
129                id,
130                livemode,
131                name,
132                status,
133                status_details,
134            })
135        }
136    }
137
138    impl Map for Builder<'_> {
139        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
140            self.builder.key(k)
141        }
142
143        fn finish(&mut self) -> Result<()> {
144            *self.out = self.builder.take_out();
145            Ok(())
146        }
147    }
148
149    impl ObjectDeser for TestHelpersTestClock {
150        type Builder = TestHelpersTestClockBuilder;
151    }
152
153    impl FromValueOpt for TestHelpersTestClock {
154        fn from_value(v: Value) -> Option<Self> {
155            let Value::Object(obj) = v else {
156                return None;
157            };
158            let mut b = TestHelpersTestClockBuilder::deser_default();
159            for (k, v) in obj {
160                match k.as_str() {
161                    "created" => b.created = FromValueOpt::from_value(v),
162                    "deletes_after" => b.deletes_after = FromValueOpt::from_value(v),
163                    "frozen_time" => b.frozen_time = FromValueOpt::from_value(v),
164                    "id" => b.id = FromValueOpt::from_value(v),
165                    "livemode" => b.livemode = FromValueOpt::from_value(v),
166                    "name" => b.name = FromValueOpt::from_value(v),
167                    "status" => b.status = FromValueOpt::from_value(v),
168                    "status_details" => b.status_details = FromValueOpt::from_value(v),
169                    _ => {}
170                }
171            }
172            b.take_out()
173        }
174    }
175};
176#[cfg(feature = "serialize")]
177impl serde::Serialize for TestHelpersTestClock {
178    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
179        use serde::ser::SerializeStruct;
180        let mut s = s.serialize_struct("TestHelpersTestClock", 9)?;
181        s.serialize_field("created", &self.created)?;
182        s.serialize_field("deletes_after", &self.deletes_after)?;
183        s.serialize_field("frozen_time", &self.frozen_time)?;
184        s.serialize_field("id", &self.id)?;
185        s.serialize_field("livemode", &self.livemode)?;
186        s.serialize_field("name", &self.name)?;
187        s.serialize_field("status", &self.status)?;
188        s.serialize_field("status_details", &self.status_details)?;
189
190        s.serialize_field("object", "test_helpers.test_clock")?;
191        s.end()
192    }
193}
194/// The status of the Test Clock.
195#[derive(Clone, Eq, PartialEq)]
196#[non_exhaustive]
197pub enum TestHelpersTestClockStatus {
198    Advancing,
199    InternalFailure,
200    Ready,
201    /// An unrecognized value from Stripe. Should not be used as a request parameter.
202    Unknown(String),
203}
204impl TestHelpersTestClockStatus {
205    pub fn as_str(&self) -> &str {
206        use TestHelpersTestClockStatus::*;
207        match self {
208            Advancing => "advancing",
209            InternalFailure => "internal_failure",
210            Ready => "ready",
211            Unknown(v) => v,
212        }
213    }
214}
215
216impl std::str::FromStr for TestHelpersTestClockStatus {
217    type Err = std::convert::Infallible;
218    fn from_str(s: &str) -> Result<Self, Self::Err> {
219        use TestHelpersTestClockStatus::*;
220        match s {
221            "advancing" => Ok(Advancing),
222            "internal_failure" => Ok(InternalFailure),
223            "ready" => Ok(Ready),
224            v => {
225                tracing::warn!("Unknown value '{}' for enum '{}'", v, "TestHelpersTestClockStatus");
226                Ok(Unknown(v.to_owned()))
227            }
228        }
229    }
230}
231impl std::fmt::Display for TestHelpersTestClockStatus {
232    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
233        f.write_str(self.as_str())
234    }
235}
236
237impl std::fmt::Debug for TestHelpersTestClockStatus {
238    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
239        f.write_str(self.as_str())
240    }
241}
242#[cfg(feature = "serialize")]
243impl serde::Serialize for TestHelpersTestClockStatus {
244    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
245    where
246        S: serde::Serializer,
247    {
248        serializer.serialize_str(self.as_str())
249    }
250}
251impl miniserde::Deserialize for TestHelpersTestClockStatus {
252    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
253        crate::Place::new(out)
254    }
255}
256
257impl miniserde::de::Visitor for crate::Place<TestHelpersTestClockStatus> {
258    fn string(&mut self, s: &str) -> miniserde::Result<()> {
259        use std::str::FromStr;
260        self.out = Some(TestHelpersTestClockStatus::from_str(s).expect("infallible"));
261        Ok(())
262    }
263}
264
265stripe_types::impl_from_val_with_from_str!(TestHelpersTestClockStatus);
266#[cfg(feature = "deserialize")]
267impl<'de> serde::Deserialize<'de> for TestHelpersTestClockStatus {
268    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
269        use std::str::FromStr;
270        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
271        Ok(Self::from_str(&s).expect("infallible"))
272    }
273}
274impl stripe_types::Object for TestHelpersTestClock {
275    type Id = stripe_shared::TestHelpersTestClockId;
276    fn id(&self) -> &Self::Id {
277        &self.id
278    }
279
280    fn into_id(self) -> Self::Id {
281        self.id
282    }
283}
284stripe_types::def_id!(TestHelpersTestClockId);
stripe_shared/test_helpers_test_clock.rs

stripe_shared/
test_helpers_test_clock.rs
