Finish switch to time crate

spk · spk · commit 3b4b7f0ccaa1 · 2021-12-09T19:44:40.000+01:00
Fix perform_{in,at} calc_at broken in commit de8b088
diff --git a/src/sidekiq/mod.rs b/src/sidekiq/mod.rs
@@ -113,7 +113,7 @@ impl Default for JobOpts {
 /// use sidekiq::{Job, JobOpts};
 ///
 /// // Create a job
-/// let class = "MyClass".to_string();
+/// let class = "Maman".to_string();
 /// let job_opts = JobOpts {
 ///     queue: "test".to_string(),
 ///     ..Default::default()
@@ -167,6 +167,7 @@ pub struct Client {
 ///
 /// use sidekiq::{Job, Value};
 /// use sidekiq::{Client, ClientOpts, create_redis_pool};
+/// use time::{OffsetDateTime, Duration};
 ///
 /// let ns = "test";
 /// let client_opts = ClientOpts {
@@ -175,14 +176,30 @@ pub struct Client {
 /// };
 /// let pool = create_redis_pool().unwrap();
 /// let client = Client::new(pool, client_opts);
-/// let class = "MyClass".to_string();
-/// let job = Job::new(class, vec![sidekiq::Value::Null], Default::default());
+/// let class = "Maman";
+/// let job = Job::new(class.to_string(), vec![sidekiq::Value::Null], Default::default());
 /// match client.push(job) {
 ///     Ok(_) => {},
 ///     Err(err) => {
 ///         println!("Sidekiq push failed: {}", err);
 ///     },
 /// }
+/// let job = Job::new(class.to_string(), vec![sidekiq::Value::Null], Default::default());
+/// let interval = Duration::hours(1);
+/// match client.perform_in(interval, job) {
+///     Ok(_) => {},
+///     Err(err) => {
+///         println!("Sidekiq push failed: {}", err);
+///     },
+/// }
+/// let job = Job::new(class.to_string(), vec![sidekiq::Value::Null], Default::default());
+/// let start_at = OffsetDateTime::now_utc().checked_add(Duration::HOUR).unwrap();
+/// match client.perform_at(start_at, job) {
+///     Ok(_) => {},
+///     Err(err) => {
+///         println!("Sidekiq push failed: {}", err);
+///     },
+/// }
 /// ```
 impl Client {
     pub fn new(redis_pool: RedisPool, opts: ClientOpts) -> Client {
@@ -202,14 +219,9 @@ impl Client {
     }
 
     fn calc_at(&self, target_millsec_number: f64) -> Option<f64> {
-        let div: f64 = 1_000_f64;
         let maximum_target: f64 = 1_000_000_000_f64;
-        let target_millsec: f64 = target_millsec_number / div;
-        let now_millisec = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_secs() as f64
-            / div;
+        let target_millsec: f64 = target_millsec_number;
+        let now_millisec = OffsetDateTime::now_utc().unix_timestamp() as f64;
 
         let start_at: f64 = if target_millsec < maximum_target {
             now_millisec + target_millsec
@@ -224,22 +236,14 @@ impl Client {
         }
     }
 
-    fn convert_duration_to_millsec(&self, interval: Duration) -> Option<f64> {
-        let interval_millsec: f64 = interval.subsec_milliseconds() as f64;
-        self.calc_at(interval_millsec)
-    }
-
-    fn convert_datetime_to_millsec(&self, datetime: OffsetDateTime) -> Option<f64> {
-        let timestamp_millsec: f64 = datetime.millisecond() as f64;
-        self.calc_at(timestamp_millsec)
-    }
-
     pub fn perform_in(&self, interval: Duration, job: Job) -> Result<(), ClientError> {
-        self.raw_push(&[job], self.convert_duration_to_millsec(interval))
+        let interval: f64 = interval.whole_seconds() as f64;
+        self.raw_push(&[job], self.calc_at(interval))
     }
 
-    pub fn perform_at(&self, local_datetime: OffsetDateTime, job: Job) -> Result<(), ClientError> {
-        self.raw_push(&[job], self.convert_datetime_to_millsec(local_datetime))
+    pub fn perform_at(&self, datetime: OffsetDateTime, job: Job) -> Result<(), ClientError> {
+        let timestamp: f64 = datetime.unix_timestamp() as f64;
+        self.raw_push(&[job], self.calc_at(timestamp))
     }
 
     pub fn push(&self, job: Job) -> Result<(), ClientError> {
diff --git a/tests/lib.rs b/tests/lib.rs
@@ -44,7 +44,7 @@ fn time_ok(time: u64) -> bool {
 
 #[test]
 fn test_job_format_with_default() {
-    let class = "MyClass".to_string();
+    let class = "Maman".to_string();
     let job = Job::new(class.clone(), args(), Default::default());
     assert_eq!(job.class, class);
     assert_eq!(job.retry, 25);
@@ -55,8 +55,8 @@ fn test_job_format_with_default() {
 }
 
 #[test]
-fn test_client_push() {
-    let class = "MyClass".to_string();
+fn test_client_push_single() {
+    let class = "Maman".to_string();
     let job = Job::new(class, args(), Default::default());
     let client = get_client();
     match client.push(job) {
@@ -70,7 +70,7 @@ fn test_client_push() {
 
 #[test]
 fn test_client_push_bulk() {
-    let class = "MyClass".to_string();
+    let class = "Maman".to_string();
     let jobs = &vec![
         Job::new(class.clone(), args(), Default::default()),
         Job::new(class, args(), Default::default()),
@@ -87,22 +87,10 @@ fn test_client_push_bulk() {
 
 #[test]
 fn test_client_perform_in() {
-    let class = "MyClass".to_string();
+    let class = "Maman".to_string();
     let job = Job::new(class, args(), Default::default());
     let client = get_client();
-    let interval = Duration::hours(1);
-    match client.perform_in(interval, job) {
-        Ok(_) => {}
-        Err(err) => {
-            println!("Sidekiq push failed: {}", err);
-            unreachable!()
-        }
-    }
-
-    let class = "MyClass".to_string();
-    let job = Job::new(class, args(), Default::default());
-    let client = get_client();
-    let interval = Duration::hours(0);
+    let interval = Duration::minutes(1);
     match client.perform_in(interval, job) {
         Ok(_) => {}
         Err(err) => {
@@ -114,23 +102,11 @@ fn test_client_perform_in() {
 
 #[test]
 fn test_client_perform_at() {
-    let class = "MyClass".to_string();
-    let job = Job::new(class, args(), Default::default());
-    let client = get_client();
-    let start_at = OffsetDateTime::now_utc();
-    match client.perform_at(start_at, job) {
-        Ok(_) => {}
-        Err(err) => {
-            println!("Sidekiq push failed: {}", err);
-            unreachable!()
-        }
-    }
-
-    let class = "MyClass".to_string();
+    let class = "Maman".to_string();
     let job = Job::new(class, args(), Default::default());
     let client = get_client();
     let start_at = OffsetDateTime::now_utc()
-        .checked_add(Duration::HOUR)
+        .checked_add(Duration::MINUTE)
         .unwrap();
     match client.perform_at(start_at, job) {
         Ok(_) => {}
