// use k8s::Condition;
// use k8s_gateway_api::{ParentReference, RouteParentStatus, RouteStatus};
// use k8s_openapi::chrono::Utc;
// use kube::ResourceExt;
// use linkerd_policy_controller_core::POLICY_CONTROLLER_NAME;
// use linkerd_policy_controller_k8s_api as k8s;
// use linkerd_policy_test::{
//     await_condition, await_route_status, create, find_route_condition, mk_route, with_temp_ns,
// };

// #[tokio::test(flavor = "current_thread")]
// async fn accepted_parent() {
//     with_temp_ns(|client, ns| async move {
//         // Create a parent Service
//         let svc_name = "test-service";
//         let svc = k8s::Service {
//             metadata: k8s::ObjectMeta {
//                 namespace: Some(ns.clone()),
//                 name: Some(svc_name.to_string()),
//                 ..Default::default()
//             },
//             spec: Some(k8s::ServiceSpec {
//                 type_: Some("ClusterIP".to_string()),
//                 ports: Some(vec![k8s::ServicePort {
//                     port: 80,
//                     ..Default::default()
//                 }]),
//                 ..Default::default()
//             }),
//             ..k8s::Service::default()
//         };
//         let svc = create(&client, svc).await;
//         let svc_ref = vec![k8s::policy::httproute::ParentReference {
//             group: Some("core".to_string()),
//             kind: Some("Service".to_string()),
//             namespace: svc.namespace(),
//             name: svc.name_unchecked(),
//             section_name: None,
//             port: Some(80),
//         }];

//         // Create a route that references the Service resource.
//         let _route = create(&client, mk_route(&ns, "test-route", Some(svc_ref))).await;
//         // Wait until route is updated with a status
//         let statuses = await_route_status(&client, &ns, "test-route").await.parents;

//         let route_status = statuses
//             .clone()
//             .into_iter()
//             .find(|route_status| route_status.parent_ref.name == svc_name)
//             .expect("must have at least one parent status");

//         // Check status references to parent we have created
//         assert_eq!(route_status.parent_ref.group.as_deref(), Some("core"));
//         assert_eq!(route_status.parent_ref.kind.as_deref(), Some("Service"));

//         // Check status is accepted with a status of 'True'
//         let cond = find_route_condition(&statuses, svc_name)
//             .expect("must have at least one 'Accepted' condition for accepted servuce");
//         assert_eq!(cond.status, "True");
//         assert_eq!(cond.reason, "Accepted")
//     })
//     .await;
// }

// #[tokio::test(flavor = "current_thread")]
// async fn no_cluster_ip() {
//     with_temp_ns(|client, ns| async move {
//         // Create a parent Service
//         let svc = k8s::Service {
//             metadata: k8s::ObjectMeta {
//                 namespace: Some(ns.clone()),
//                 name: Some("test-service".to_string()),
//                 ..Default::default()
//             },
//             spec: Some(k8s::ServiceSpec {
//                 cluster_ip: Some("None".to_string()),
//                 type_: Some("ClusterIP".to_string()),
//                 ports: Some(vec![k8s::ServicePort {
//                     port: 80,
//                     ..Default::default()
//                 }]),
//                 ..Default::default()
//             }),
//             ..k8s::Service::default()
//         };
//         let svc = create(&client, svc).await;
//         let svc_ref = vec![k8s::policy::httproute::ParentReference {
//             group: Some("core".to_string()),
//             kind: Some("Service".to_string()),
//             namespace: svc.namespace(),
//             name: svc.name_unchecked(),
//             section_name: None,
//             port: Some(80),
//         }];

//         // Create a route that references the Service resource.
//         let _route = create(&client, mk_route(&ns, "test-route", Some(svc_ref))).await;
//         // Wait until route is updated with a status
//         let status = await_route_status(&client, &ns, "test-route").await;
//         let cond = find_route_condition(&status.parents, "test-service")
//             .expect("must have at least one 'Accepted' condition set for parent");
//         // Parent with no ClusterIP should not match.
//         assert_eq!(cond.status, "False");
//         assert_eq!(cond.reason, "NoMatchingParent");
//     })
//     .await;
// }

// #[tokio::test(flavor = "current_thread")]
// async fn external_name() {
//     with_temp_ns(|client, ns| async move {
//         // Create a parent Service
//         let svc = k8s::Service {
//             metadata: k8s::ObjectMeta {
//                 namespace: Some(ns.clone()),
//                 name: Some("test-service".to_string()),
//                 ..Default::default()
//             },
//             spec: Some(k8s::ServiceSpec {
//                 type_: Some("ExternalName".to_string()),
//                 external_name: Some("linkerd.io".to_string()),
//                 ports: Some(vec![k8s::ServicePort {
//                     port: 80,
//                     ..Default::default()
//                 }]),
//                 ..Default::default()
//             }),
//             ..k8s::Service::default()
//         };
//         let svc = create(&client, svc).await;
//         let svc_ref = vec![k8s::policy::httproute::ParentReference {
//             group: Some("core".to_string()),
//             kind: Some("Service".to_string()),
//             namespace: svc.namespace(),
//             name: svc.name_unchecked(),
//             section_name: None,
//             port: Some(80),
//         }];

//         // Create a route that references the Service resource.
//         let _route = create(&client, mk_route(&ns, "test-route", Some(svc_ref))).await;
//         // Wait until route is updated with a status
//         let status = await_route_status(&client, &ns, "test-route").await;
//         let cond = find_route_condition(&status.parents, "test-service")
//             .expect("must have at least one 'Accepted' condition set for parent");
//         // Parent with ExternalName should not match.
//         assert_eq!(cond.status, "False");
//         assert_eq!(cond.reason, "NoMatchingParent");
//     })
//     .await;
// }

// #[tokio::test(flavor = "current_thread")]
// async fn multiple_statuses() {
//     with_temp_ns(|client, ns| async move {
//         // Create a parent Service
//         let svc_name = "test-service";
//         let svc = k8s::Service {
//             metadata: k8s::ObjectMeta {
//                 namespace: Some(ns.clone()),
//                 name: Some(svc_name.to_string()),
//                 ..Default::default()
//             },
//             spec: Some(k8s::ServiceSpec {
//                 type_: Some("ClusterIP".to_string()),
//                 ports: Some(vec![k8s::ServicePort {
//                     port: 80,
//                     ..Default::default()
//                 }]),
//                 ..Default::default()
//             }),
//             ..k8s::Service::default()
//         };
//         let svc = create(&client, svc).await;
//         let svc_ref = vec![k8s::policy::httproute::ParentReference {
//             group: Some("core".to_string()),
//             kind: Some("Service".to_string()),
//             namespace: svc.namespace(),
//             name: svc.name_unchecked(),
//             section_name: None,
//             port: Some(80),
//         }];

//         // Create a route that references the Service resource.
//         let _route = create(&client, mk_route(&ns, "test-route", Some(svc_ref))).await;

//         // Patch a status onto the HttpRoute.
//         let value = serde_json::json!({
//             "apiVersion": "policy.linkerd.io",
//                 "kind": "HTTPRoute",
//                 "name": "test-route",
//                 "status": k8s::policy::httproute::HttpRouteStatus {
//                     inner: RouteStatus {
//                         parents: vec![RouteParentStatus {
//                             conditions: vec![Condition {
//                                 last_transition_time: k8s::Time(Utc::now()),
//                                 message: "".to_string(),
//                                 observed_generation: None,
//                                 reason: "Accepted".to_string(),
//                                 status: "True".to_string(),
//                                 type_: "Accepted".to_string(),
//                             }],
//                             controller_name: "someone/else".to_string(),
//                             parent_ref: ParentReference {
//                                 group: Some("gateway.networking.k8s.io".to_string()),
//                                 name: "foo".to_string(),
//                                 kind: Some("Gateway".to_string()),
//                                 namespace: Some("bar".to_string()),
//                                 port: None,
//                                 section_name: None,
//                             },
//                         }],
//                     },
//                 },
//         });
//         let patch = k8s::Patch::Merge(value);
//         let patch_params = k8s::PatchParams::apply("someone/else");
//         let api = k8s::Api::<k8s::policy::HttpRoute>::namespaced(client.clone(), &ns);
//         api.patch_status("test-route", &patch_params, &patch)
//             .await
//             .expect("failed to patch status");

//         await_condition(
//             &client,
//             &ns,
//             "test-route",
//             |obj: Option<&k8s::policy::HttpRoute>| -> bool {
//                 obj.and_then(|route| route.status.as_ref())
//                     .map(|status| {
//                         let statuses = &status.parents;

//                         let other_status_found = statuses
//                             .iter()
//                             .any(|route_status| route_status.controller_name == "someone/else");

//                         let linkerd_status_found = statuses.iter().any(|route_status| {
//                             route_status.controller_name == POLICY_CONTROLLER_NAME
//                         });

//                         other_status_found && linkerd_status_found
//                     })
//                     .unwrap_or(false)
//             },
//         )
//         .await
//         .expect("must have both statuses");
//     })
//     .await;
// }
