From 728b944360e38706de8100c9d2294e46374c2f39 Mon Sep 17 00:00:00 2001
From: zero-systems <60021149+zero-systems@users.noreply.github.com>
Date: Fri, 7 Feb 2020 17:08:25 +1000
Subject: [PATCH] Extensions module improvement and tests. (#1297)

* replace get.is_some to contains_key

* Add tests

* remove unnecessary box cast

* fix missing uints

* asserts fix

Co-authored-by: Yuki Okushi <huyuumi.dev@gmail.com>
---
 actix-http/src/extensions.rs | 101 +++++++++++++++++++++++++++++++----
 1 file changed, 92 insertions(+), 9 deletions(-)

diff --git a/actix-http/src/extensions.rs b/actix-http/src/extensions.rs
index d85ca184d..5114ce140 100644
--- a/actix-http/src/extensions.rs
+++ b/actix-http/src/extensions.rs
@@ -28,33 +28,30 @@ impl Extensions {
 
     /// Check if container contains entry
     pub fn contains<T: 'static>(&self) -> bool {
-        self.map.get(&TypeId::of::<T>()).is_some()
+        self.map.contains_key(&TypeId::of::<T>())
     }
 
     /// Get a reference to a type previously inserted on this `Extensions`.
     pub fn get<T: 'static>(&self) -> Option<&T> {
         self.map
             .get(&TypeId::of::<T>())
-            .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref())
+            .and_then(|boxed| boxed.downcast_ref())
     }
 
     /// Get a mutable reference to a type previously inserted on this `Extensions`.
     pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
         self.map
             .get_mut(&TypeId::of::<T>())
-            .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
+            .and_then(|boxed| boxed.downcast_mut())
     }
 
     /// Remove a type from this `Extensions`.
     ///
     /// If a extension of this type existed, it will be returned.
     pub fn remove<T: 'static>(&mut self) -> Option<T> {
-        self.map.remove(&TypeId::of::<T>()).and_then(|boxed| {
-            (boxed as Box<dyn Any + 'static>)
-                .downcast()
-                .ok()
-                .map(|boxed| *boxed)
-        })
+        self.map
+            .remove(&TypeId::of::<T>())
+            .and_then(|boxed| boxed.downcast().ok().map(|boxed| *boxed))
     }
 
     /// Clear the `Extensions` of all inserted extensions.
@@ -70,6 +67,92 @@ impl fmt::Debug for Extensions {
     }
 }
 
+#[test]
+fn test_remove() {
+    let mut map = Extensions::new();
+
+    map.insert::<i8>(123);
+    assert!(map.get::<i8>().is_some());
+
+    map.remove::<i8>();
+    assert!(map.get::<i8>().is_none());
+}
+
+#[test]
+fn test_clear() {
+    let mut map = Extensions::new();
+
+    map.insert::<i8>(8);
+    map.insert::<i16>(16);
+    map.insert::<i32>(32);
+
+    assert!(map.contains::<i8>());
+    assert!(map.contains::<i16>());
+    assert!(map.contains::<i32>());
+
+    map.clear();
+
+    assert!(!map.contains::<i8>());
+    assert!(!map.contains::<i16>());
+    assert!(!map.contains::<i32>());
+
+    map.insert::<i8>(10);
+    assert_eq!(*map.get::<i8>().unwrap(), 10);
+}
+
+#[test]
+fn test_integers() {
+    let mut map = Extensions::new();
+
+    map.insert::<i8>(8);
+    map.insert::<i16>(16);
+    map.insert::<i32>(32);
+    map.insert::<i64>(64);
+    map.insert::<i128>(128);
+    map.insert::<u8>(8);
+    map.insert::<u16>(16);
+    map.insert::<u32>(32);
+    map.insert::<u64>(64);
+    map.insert::<u128>(128);
+    assert!(map.get::<i8>().is_some());
+    assert!(map.get::<i16>().is_some());
+    assert!(map.get::<i32>().is_some());
+    assert!(map.get::<i64>().is_some());
+    assert!(map.get::<i128>().is_some());
+    assert!(map.get::<u8>().is_some());
+    assert!(map.get::<u16>().is_some());
+    assert!(map.get::<u32>().is_some());
+    assert!(map.get::<u64>().is_some());
+    assert!(map.get::<u128>().is_some());
+}
+
+#[test]
+fn test_composition() {
+    struct Magi<T>(pub T);
+
+    struct Madoka {
+        pub god: bool,
+    }
+
+    struct Homura {
+        pub attempts: usize,
+    }
+
+    struct Mami {
+        pub guns: usize,
+    }
+
+    let mut map = Extensions::new();
+
+    map.insert(Magi(Madoka { god: false }));
+    map.insert(Magi(Homura { attempts: 0 }));
+    map.insert(Magi(Mami { guns: 999 }));
+
+    assert!(!map.get::<Magi<Madoka>>().unwrap().0.god);
+    assert_eq!(0, map.get::<Magi<Homura>>().unwrap().0.attempts);
+    assert_eq!(999, map.get::<Magi<Mami>>().unwrap().0.guns);
+}
+
 #[test]
 fn test_extensions() {
     #[derive(Debug, PartialEq)]