put back some tests

Author: hawkw

linkerd/app/inbound/src/accept.rs

@@ -123,75 +123,74 @@ mod tests {
     };
     use linkerd_proxy_server_policy::{Authentication, Authorization, Meta, ServerPolicy};
     use std::sync::Arc;
-    // TODO(eliza): what to actually do with these tests?
-
-    // #[tokio::test(flavor = "current_thread")]
-    // async fn default_allow() {
-    //     let (io, _) = io::duplex(1);
-    //     let policies = Store::for_test(std::iter::once((
-    //         1000,
-    //         ServerPolicy {
-    //             protocol: linkerd_proxy_server_policy::Protocol::Opaque(Arc::new([
-    //                 Authorization {
-    //                     authentication: Authentication::Unauthenticated,
-    //                     networks: vec![Default::default()],
-    //                     meta: Arc::new(Meta::Resource {
-    //                         group: "policy.linkerd.io".into(),
-    //                         kind: "serverauthorization".into(),
-    //                         name: "testsaz".into(),
-    //                     }),
-    //                 },
-    //             ])),
-    //             meta: Arc::new(Meta::Resource {
-    //                 group: "policy.linkerd.io".into(),
-    //                 kind: "server".into(),
-    //                 name: "testsrv".into(),
-    //             }),
-    //         },
-    //     )));
-    //     inbound()
-    //         .with_stack(new_ok())
-    //         .push_accept(999, policies, new_panic("direct stack must not be built"))
-    //         .into_inner()
-    //         .new_service(Target(1000))
-    //         .oneshot(io)
-    //         .await
-    //         .expect("should succeed");
-    // }
-
-    // #[tokio::test(flavor = "current_thread")]
-    // async fn direct() {
-    //     let policies = Store::for_test(std::iter::once((
-    //         1000,
-    //         ServerPolicy {
-    //             protocol: linkerd_proxy_server_policy::Protocol::Opaque(Arc::new([
-    //                 Authorization {
-    //                     authentication: Authentication::Unauthenticated,
-    //                     networks: vec![Default::default()],
-    //                     meta: Arc::new(Meta::Resource {
-    //                         group: "policy.linkerd.io".into(),
-    //                         kind: "serverauthorization".into(),
-    //                         name: "testsaz".into(),
-    //                     }),
-    //                 },
-    //             ])),
-    //             meta: Arc::new(Meta::Resource {
-    //                 group: "policy.linkerd.io".into(),
-    //                 kind: "server".into(),
-    //                 name: "testsrv".into(),
-    //             }),
-    //         },
-    //     )));
-    //     let (io, _) = io::duplex(1);
-    //     inbound()
-    //         .with_stack(new_panic("detect stack must not be built"))
-    //         .push_accept(999, policies, new_ok())
-    //         .into_inner()
-    //         .new_service(Target(999))
-    //         .oneshot(io)
-    //         .await
-    //         .expect("should succeed");
-    // }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn default_allow() {
+        let (io, _) = io::duplex(1);
+        let policies = Store::for_test(std::iter::once((
+            1000,
+            ServerPolicy {
+                protocol: linkerd_proxy_server_policy::Protocol::Opaque(Arc::new([
+                    Authorization {
+                        authentication: Authentication::Unauthenticated,
+                        networks: vec![Default::default()],
+                        meta: Arc::new(Meta::Resource {
+                            group: "policy.linkerd.io".into(),
+                            kind: "serverauthorization".into(),
+                            name: "testsaz".into(),
+                        }),
+                    },
+                ])),
+                meta: Arc::new(Meta::Resource {
+                    group: "policy.linkerd.io".into(),
+                    kind: "server".into(),
+                    name: "testsrv".into(),
+                }),
+            },
+        )));
+        inbound()
+            .with_stack(new_ok())
+            .push_accept(999, policies, new_panic("direct stack must not be built"))
+            .into_inner()
+            .new_service(Target(1000))
+            .oneshot(io)
+            .await
+            .expect("should succeed");
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn direct() {
+        let policies = Store::for_test(std::iter::once((
+            1000,
+            ServerPolicy {
+                protocol: linkerd_proxy_server_policy::Protocol::Opaque(Arc::new([
+                    Authorization {
+                        authentication: Authentication::Unauthenticated,
+                        networks: vec![Default::default()],
+                        meta: Arc::new(Meta::Resource {
+                            group: "policy.linkerd.io".into(),
+                            kind: "serverauthorization".into(),
+                            name: "testsaz".into(),
+                        }),
+                    },
+                ])),
+                meta: Arc::new(Meta::Resource {
+                    group: "policy.linkerd.io".into(),
+                    kind: "server".into(),
+                    name: "testsrv".into(),
+                }),
+            },
+        )));
+        let (io, _) = io::duplex(1);
+        inbound()
+            .with_stack(new_panic("detect stack must not be built"))
+            .push_accept(999, policies, new_ok())
+            .into_inner()
+            .new_service(Target(999))
+            .oneshot(io)
+            .await
+            .expect("should succeed");
+    }
 
     fn inbound() -> Inbound<()> {
         Inbound::new(test_util::default_config(), test_util::runtime().0)