Merge pull request #1039 from tgnottingham/interp-and-average

Fix `Interpolate` iterator indicating incorrect interpolation and add some tests

Author: Mark-Simulacrum

site/src/average.rs

@@ -43,7 +43,9 @@ where
                 }
                 Some(point) => {
                     count += 1;
-                    sum += point.value().expect("present");
+                    sum += point
+                        .value()
+                        .expect("Uninterpolated iterators are not supported");
                     i += 1;
                     if let Some(t) = &mut first {
                         if point.interpolated() {
@@ -75,3 +77,77 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::average;
+
+    #[test]
+    fn test_no_interpolation_average() {
+        // Test that averaging works without interpolation.
+        use crate::db::Point;
+
+        let v = vec![
+            vec![("a", 0.0), ("b", 200.0)],
+            vec![("a", 100.0), ("b", 300.0)],
+        ];
+
+        let iterators: Vec<_> = v.into_iter().map(|v| v.into_iter()).collect();
+        let mut average = average(iterators);
+
+        let a = average.next().unwrap();
+        assert_eq!(a, ("a", 50.0));
+        assert_eq!(a.interpolated(), false);
+
+        let b = average.next().unwrap();
+        assert_eq!(b, ("b", 250.0));
+        assert_eq!(b.interpolated(), false);
+
+        assert!(average.next().is_none());
+    }
+
+    #[test]
+    fn test_interpolation_average() {
+        // Test that averaging works with interpolation.
+        use crate::db::Point;
+        use crate::interpolate::{Interpolate, Interpolated};
+
+        let v = vec![
+            vec![("a", Some(0.0)), ("b", Some(200.0))],
+            vec![("a", Some(100.0)), ("b", None)],
+        ];
+
+        let iterators: Vec<_> = v
+            .into_iter()
+            .map(|v| Interpolate::new(v.into_iter()))
+            .collect();
+
+        let mut average = average(iterators);
+
+        let a = average.next().unwrap();
+        assert_eq!(a, (("a", Some(50.0)), Interpolated::No));
+        assert_eq!(a.interpolated(), false);
+
+        let b = average.next().unwrap();
+        assert_eq!(b, (("b", Some(150.0)), Interpolated::Yes));
+        assert_eq!(b.interpolated(), true);
+
+        assert!(average.next().is_none());
+    }
+
+    #[test]
+    #[should_panic(expected = "Uninterpolated iterators are not supported")]
+    fn test_uninterpolated_iterator() {
+        let v = vec![vec![("a", Some(1.0)), ("b", Some(2.0))], vec![("a", None)]];
+        let iterators: Vec<_> = v.into_iter().map(|v| v.into_iter()).collect();
+        let _ = average(iterators).next();
+    }
+
+    #[test]
+    #[should_panic(expected = "Not all iterators of the same length")]
+    fn test_unequal_length_iterators() {
+        let v = vec![vec![("a", 1.0), ("b", 2.0)], vec![("a", 3.0)]];
+        let iterators: Vec<_> = v.into_iter().map(|v| v.into_iter()).collect();
+        for _ in average(iterators) {}
+    }
+}

site/src/interpolate.rs

@@ -81,7 +81,12 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(mut item) = self.consumed.pop() {
             item.set_value(self.last_seen.unwrap());
-            return Some((item, Interpolated::Yes));
+            let interpolation = if self.consumed.is_empty() {
+                Interpolated::No
+            } else {
+                Interpolated::Yes
+            };
+            return Some((item, interpolation));
         }
 
         let mut item = self.iterator.next()?;
@@ -131,3 +136,63 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{Interpolate, Interpolated};
+
+    #[test]
+    fn test_no_interpolation() {
+        let v = vec![("a", 1.0), ("b", 2.0)];
+        let mut iter = Interpolate::new(v.into_iter());
+
+        assert_eq!(iter.next().unwrap(), (("a", 1.0), Interpolated::No));
+        assert_eq!(iter.next().unwrap(), (("b", 2.0), Interpolated::No));
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_leading_interpolation() {
+        let v = vec![("a", None), ("b", None), ("c", Some(3.0)), ("d", Some(4.0))];
+        let mut iter = Interpolate::new(v.into_iter());
+
+        assert_eq!(iter.next().unwrap(), (("a", Some(3.0)), Interpolated::Yes));
+        assert_eq!(iter.next().unwrap(), (("b", Some(3.0)), Interpolated::Yes));
+        assert_eq!(iter.next().unwrap(), (("c", Some(3.0)), Interpolated::No));
+        assert_eq!(iter.next().unwrap(), (("d", Some(4.0)), Interpolated::No));
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_inner_interpolation() {
+        let v = vec![
+            ("a", Some(1.0)),
+            ("b", Some(2.0)),
+            ("c", None),
+            ("d", None),
+            ("e", Some(5.0)),
+            ("f", Some(6.0)),
+        ];
+        let mut iter = Interpolate::new(v.into_iter());
+
+        assert_eq!(iter.next().unwrap(), (("a", Some(1.0)), Interpolated::No));
+        assert_eq!(iter.next().unwrap(), (("b", Some(2.0)), Interpolated::No));
+        assert_eq!(iter.next().unwrap(), (("c", Some(2.0)), Interpolated::Yes));
+        assert_eq!(iter.next().unwrap(), (("d", Some(2.0)), Interpolated::Yes));
+        assert_eq!(iter.next().unwrap(), (("e", Some(5.0)), Interpolated::No));
+        assert_eq!(iter.next().unwrap(), (("f", Some(6.0)), Interpolated::No));
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_trailing_interpolation() {
+        let v = vec![("a", Some(1.0)), ("b", Some(2.0)), ("c", None), ("d", None)];
+        let mut iter = Interpolate::new(v.into_iter());
+
+        assert_eq!(iter.next().unwrap(), (("a", Some(1.0)), Interpolated::No));
+        assert_eq!(iter.next().unwrap(), (("b", Some(2.0)), Interpolated::No));
+        assert_eq!(iter.next().unwrap(), (("c", Some(2.0)), Interpolated::Yes));
+        assert_eq!(iter.next().unwrap(), (("d", Some(2.0)), Interpolated::Yes));
+        assert!(iter.next().is_none());
+    }
+}