sentry - db - analytics testing:

- Use primitives::sentry::EventType in structs
- Use primitives::analytics::FetchedMetric
- primitives::UnifiedNum - add Mul impls for u64
- sentry - db - analytics - finish query & testing

Author: elpiel

primitives/src/analytics.rs

@@ -1,4 +1,7 @@
-use crate::{Address, CampaignId, ValidatorId, IPFS};
+use crate::{
+    sentry::{EventType, IMPRESSION},
+    Address, CampaignId, ValidatorId, IPFS,
+};
 use parse_display::Display;
 use serde::{Deserialize, Serialize};
 
@@ -16,13 +19,23 @@ pub mod postgres {
     impl AnalyticsQuery {
         pub fn get_key(&self, key: AllowedKey) -> Option<Box<dyn ToSql + Sync + Send>> {
             match key {
-                AllowedKey::CampaignId => self.campaign_id.map(|campaign_id| Box::new(campaign_id) as _),
+                AllowedKey::CampaignId => self
+                    .campaign_id
+                    .map(|campaign_id| Box::new(campaign_id) as _),
                 AllowedKey::AdUnit => self.ad_unit.map(|ad_unit| Box::new(ad_unit) as _),
                 AllowedKey::AdSlot => self.ad_slot.map(|ad_slot| Box::new(ad_slot) as _),
-                AllowedKey::AdSlotType => self.ad_slot_type.clone().map(|ad_slot_type| Box::new(ad_slot_type) as _),
-                AllowedKey::Advertiser => self.advertiser.map(|advertiser| Box::new(advertiser) as _),
+                AllowedKey::AdSlotType => self
+                    .ad_slot_type
+                    .clone()
+                    .map(|ad_slot_type| Box::new(ad_slot_type) as _),
+                AllowedKey::Advertiser => {
+                    self.advertiser.map(|advertiser| Box::new(advertiser) as _)
+                }
                 AllowedKey::Publisher => self.publisher.map(|publisher| Box::new(publisher) as _),
-                AllowedKey::Hostname => self.hostname.clone().map(|hostname| Box::new(hostname) as _),
+                AllowedKey::Hostname => self
+                    .hostname
+                    .clone()
+                    .map(|hostname| Box::new(hostname) as _),
                 AllowedKey::Country => self.country.clone().map(|country| Box::new(country) as _),
                 AllowedKey::OsName => self.os_name.clone().map(|os_name| Box::new(os_name) as _),
             }
@@ -89,7 +102,7 @@ pub struct AnalyticsQuery {
     #[serde(default = "default_limit")]
     pub limit: u32,
     #[serde(default = "default_event_type")]
-    pub event_type: String,
+    pub event_type: EventType,
     #[serde(default = "default_metric")]
     pub metric: Metric,
     pub segment_by: Option<AllowedKey>,
@@ -106,16 +119,6 @@ pub struct AnalyticsQuery {
     pub os_name: Option<OperatingSystem>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(untagged, rename_all = "camelCase")]
-pub enum AnalyticsQueryKey {
-    CampaignId(CampaignId),
-    IPFS(IPFS),
-    String(String),
-    Address(Address),
-    OperatingSystem(OperatingSystem),
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Display, Hash, Eq)]
 #[serde(untagged, into = "String", from = "String")]
 pub enum OperatingSystem {
@@ -128,9 +131,15 @@ pub enum OperatingSystem {
 #[derive(Debug, Clone, Serialize, Deserialize, Display, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub enum Timeframe {
+    /// [`Timeframe::Year`] returns analytics grouped by month.
     Year,
+    /// [`Timeframe::Month`] returns analytics grouped by day.
     Month,
+    /// [`Timeframe::Week`] returns analytics grouped by hour.
+    /// Same as [`Timeframe::Day`].
     Week,
+    /// [`Timeframe::Day`] returns analytics grouped by hour.
+    /// Same as [`Timeframe::Week`].
     Day,
 }
 
@@ -151,10 +160,13 @@ pub enum AuthenticateAs {
 
 impl Metric {
     #[cfg(feature = "postgres")]
-    pub fn column_name(self) -> String {
+    /// Returns the query column name of the [`Metric`].
+    ///
+    /// Available only when the `postgres` feature is enabled.
+    pub fn column_name(self) -> &'static str {
         match self {
-            Metric::Count => "payout_count".to_string(),
-            Metric::Paid => "payout_amount".to_string(),
+            Metric::Count => "payout_count",
+            Metric::Paid => "payout_amount",
         }
     }
 }
@@ -257,8 +269,8 @@ fn default_limit() -> u32 {
     100
 }
 
-fn default_event_type() -> String {
-    "IMPRESSION".into()
+fn default_event_type() -> EventType {
+    IMPRESSION
 }
 
 fn default_metric() -> Metric {

primitives/src/analytics/query.rs

@@ -27,6 +27,18 @@ pub enum AllowedKey {
     OsName,
 }
 
+impl AllowedKey {
+    #[allow(non_snake_case)]
+    /// Helper function to get the [`AllowedKey`] as `camelCase`.
+    pub fn to_camelCase(&self) -> String {
+        serde_json::to_value(self)
+        .expect("AllowedKey should always be serializable!")
+        .as_str()
+        .expect("Serialized AllowedKey should be a string!")
+        .to_string()
+    }
+}
+
 /// All [`AllowedKey`]s should be present in this static variable.
 pub static ALLOWED_KEYS: Lazy<HashSet<AllowedKey>> = Lazy::new(|| {
     vec![
@@ -89,7 +101,7 @@ pub struct Time {
     /// And it should not contain **minutes**, **seconds** or **nanoseconds**
     // TODO: Either Timestamp (number) or DateTime (string) de/serialization
     pub start: DateHour<Utc>,
-    /// End DateHour should be after Start DateHour!
+    /// The End [`DateHour`] which will fetch `analytics_time <= end` and should be after Start [`DateHour`]!
     pub end: Option<DateHour<Utc>>,
     // we can use `chrono_tz` to support more Timezones when needed.
     // #[serde(default = "default_timezone_utc")]
@@ -160,9 +172,9 @@ mod de {
                     let timeframe = timeframe.unwrap_or(Timeframe::Day);
                     let start = start.unwrap_or_else(|| DateHour::now() - &timeframe);
 
-                    // if there is an End time passed, check if End is > Start
+                    // if there is an End DateHour passed, check if End is > Start
                     match end {
-                        Some(end) if start > end => {
+                        Some(end) if start >= end => {
                             return Err(de::Error::custom(
                                 "End time should be larger than the Start time",
                             ));
@@ -178,7 +190,7 @@ mod de {
                 }
             }
 
-            const FIELDS: &'static [&'static str] = &["timeframe", "start", "end"];
+            const FIELDS: &[&str] = &["timeframe", "start", "end"];
             deserializer.deserialize_struct("Time", FIELDS, TimeVisitor)
         }
     }

primitives/src/sentry.rs

@@ -145,9 +145,22 @@ mod event {
     static IMPRESSION_STRING: Lazy<String> = Lazy::new(|| EventType::Impression.to_string());
     static CLICK_STRING: Lazy<String> = Lazy::new(|| EventType::Click.to_string());
 
-    #[derive(Debug, Display, FromStr, Serialize, Deserialize, Hash, Ord, Eq, PartialEq, PartialOrd, Clone, Copy)]
+    #[derive(
+        Debug,
+        Display,
+        FromStr,
+        Serialize,
+        Deserialize,
+        Hash,
+        Ord,
+        Eq,
+        PartialEq,
+        PartialOrd,
+        Clone,
+        Copy,
+    )]
     #[display(style = "SNAKE_CASE")]
-    #[serde(rename_all="SCREAMING_SNAKE_CASE")]
+    #[serde(rename_all = "SCREAMING_SNAKE_CASE")]
     pub enum EventType {
         Impression,
         Click,
@@ -300,7 +313,7 @@ pub struct FetchedAnalytics {
 }
 
 /// The value of the requested analytics [`Metric`].
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
 #[serde(untagged)]
 pub enum FetchedMetric {
     Count(u32),
@@ -355,7 +368,11 @@ impl<Tz: TimeZone, Tz2: TimeZone> PartialEq<DateHour<Tz2>> for DateHour<Tz> {
 
 impl<Tz: TimeZone> Ord for DateHour<Tz> {
     fn cmp(&self, other: &DateHour<Tz>) -> Ordering {
-        self.date.cmp(&other.date)
+        match self.date.cmp(&other.date) {
+            // Only if the two dates are equal, compare the hours too!
+            Ordering::Equal => self.hour.cmp(&other.hour),
+            ordering => ordering,
+        }
     }
 }
 
@@ -365,11 +382,14 @@ impl<Tz: TimeZone, Tz2: TimeZone> PartialOrd<DateHour<Tz2>> for DateHour<Tz> {
     /// See [`DateTime`] implementation of `PartialOrd<DateTime<Tz2>>` for more details.
     fn partial_cmp(&self, other: &DateHour<Tz2>) -> Option<Ordering> {
         if self.date == other.date {
-            if self.hour > other.hour {
-                Some(Ordering::Greater)
-            } else {
-                Some(Ordering::Less)
-            }
+            self.hour.partial_cmp(&other.hour)
+            // if self.hour > other.hour {
+            //     Some(Ordering::Greater)
+            // } else if self.hour == other.hour {
+            //     Some(Ordering::Equal)
+            // } else {
+            //     Some(Ordering::Less)
+            // }
         } else {
             self.date.naive_utc().partial_cmp(&other.date.naive_utc())
         }
@@ -922,7 +942,8 @@ pub mod campaign_create {
 #[cfg(feature = "postgres")]
 mod postgres {
     use super::{
-        Analytics, DateHour, FetchedAnalytics, FetchedMetric, MessageResponse, ValidatorMessage, EventType,
+        Analytics, DateHour, EventType, FetchedAnalytics, FetchedMetric, MessageResponse,
+        ValidatorMessage,
     };
     use crate::{
         analytics::{AnalyticsQuery, Metric},
@@ -1072,7 +1093,7 @@ mod postgres {
             raw: &'a [u8],
         ) -> Result<Self, Box<dyn std::error::Error + Sync + Send>> {
             let event_string = <&str as FromSql>::from_sql(ty, raw)?;
-            
+
             Ok(event_string.parse()?)
         }
         accepts!(VARCHAR, TEXT);
@@ -1129,7 +1150,7 @@ mod test {
     use serde_json::{json, Value};
 
     #[test]
-    pub fn de_serialize_events() {
+    pub fn test_de_serialize_events() {
         let click = Event::Click {
             publisher: ADDRESSES["publisher"],
             ad_unit: Some(DUMMY_IPFS[0]),
@@ -1152,7 +1173,7 @@ mod test {
     }
 
     #[test]
-    fn datehour_subtract_timeframe() {
+    fn test_datehour_subtract_timeframe() {
         // test with End of year
         {
             let datehour = DateHour::from_ymdh(2021, 12, 31, 22);
@@ -1175,7 +1196,7 @@ mod test {
     }
 
     #[test]
-    fn datehour_de_serialize_partial_ord_and_eq() {
+    fn test_datehour_de_serialize_partial_ord_and_eq() {
         let earlier = DateHour::from_ymdh(2021, 12, 1, 16);
         let later = DateHour::from_ymdh(2021, 12, 31, 16);
 
@@ -1189,16 +1210,46 @@ mod test {
         assert_eq!(Some(Ordering::Greater), later.partial_cmp(&earlier));
 
         // Serialize & deserialize
-        let json_datetime = Value::String("2021-12-1T16:00:00+02:00".into());
+        let json_datetime = Value::String("2021-12-01T16:00:00+02:00".into());
         let datehour: DateHour<Utc> =
             serde_json::from_value(json_datetime.clone()).expect("Should deserialize");
         assert_eq!(
-            DateHour::from_ymdh(2021, 12, 1, 12),
+            DateHour::from_ymdh(2021, 12, 1, 14),
             datehour,
             "Deserialized DateHour should be 2 hours earlier to match UTC +0"
         );
 
         let serialized_value = serde_json::to_value(datehour).expect("Should serialize DateHour");
-        assert_eq!(json_datetime, serialized_value);
+        assert_eq!(
+            Value::String("2021-12-01T14:00:00Z".into()),
+            serialized_value,
+            "Json value should always be serialized with Z (UTC+0) timezone"
+        );
+    }
+
+    #[test]
+    fn test_partial_eq_with_same_datehour_but_different_zones() {
+        // Eq & PartialEq with different timezones
+        let json = json!({
+            "UTC+0": "2021-12-16T14:00:00+00:00",
+            "UTC+2": "2021-12-16T16:00:00+02:00",
+        });
+
+        let map: HashMap<String, DateHour<Utc>> =
+            serde_json::from_value(json).expect("Should deserialize");
+
+        assert_eq!(
+            Some(Ordering::Equal),
+            map["UTC+0"].partial_cmp(&map["UTC+2"])
+        );
+
+        assert_eq!(
+            map["UTC+0"], map["UTC+2"],
+            "DateHour should be the same after the second one is made into UTC+0"
+        );
+        assert!(
+            map["UTC+0"] >= map["UTC+2"],
+            "UTC+0 value should be equal to UTC+2"
+        );
     }
 }

primitives/src/test_util.rs

@@ -12,6 +12,7 @@ pub static CREATOR: Lazy<Address> = Lazy::new(|| *ADDRESS_3);
 pub static ADVERTISER: Lazy<Address> = Lazy::new(|| *ADDRESS_4);
 pub static PUBLISHER: Lazy<Address> = Lazy::new(|| *ADDRESS_5);
 pub static GUARDIAN_2: Lazy<Address> = Lazy::new(|| *ADDRESS_6);
+pub static PUBLISHER_2: Lazy<Address> = Lazy::new(|| *ADDRESS_7);
 
 /// passphrase: ganache0
 pub static ADDRESS_0: Lazy<Address> = Lazy::new(|| {

primitives/src/unified_num.rs

@@ -290,13 +290,52 @@ impl Mul<&UnifiedNum> for UnifiedNum {
     }
 }
 
+impl Mul<u64> for &UnifiedNum {
+    type Output = UnifiedNum;
+
+    fn mul(self, rhs: u64) -> Self::Output {
+        UnifiedNum(self.0 * rhs)
+    }
+}
+
+impl Mul<u64> for UnifiedNum {
+    type Output = UnifiedNum;
+
+    fn mul(self, rhs: u64) -> Self::Output {
+        UnifiedNum(self.0 * rhs)
+    }
+}
+
+impl Mul<UnifiedNum> for u64 {
+    type Output = UnifiedNum;
+
+    fn mul(self, rhs: UnifiedNum) -> Self::Output {
+        UnifiedNum(self * rhs.0)
+    }
+}
+
+impl Mul<&UnifiedNum> for u64 {
+    type Output = UnifiedNum;
+
+    fn mul(self, rhs: &UnifiedNum) -> Self::Output {
+        UnifiedNum(self * rhs.0)
+    }
+}
+
 impl<'a> Sum<&'a UnifiedNum> for Option<UnifiedNum> {
     fn sum<I: Iterator<Item = &'a UnifiedNum>>(mut iter: I) -> Self {
         iter.try_fold(0_u64, |acc, unified| acc.checked_add(unified.0))
             .map(UnifiedNum)
     }
 }
 
+impl<'a> Sum<UnifiedNum> for Option<UnifiedNum> {
+    fn sum<I: Iterator<Item = UnifiedNum>>(mut iter: I) -> Self {
+        iter.try_fold(0_u64, |acc, unified| acc.checked_add(unified.0))
+            .map(UnifiedNum)
+    }
+}
+
 impl CheckedAdd for UnifiedNum {
     fn checked_add(&self, v: &Self) -> Option<Self> {
         self.0.checked_add(v.0).map(Self)