I was thinking an enum (none, FD, if index)

ack. i'll make query (or query_by_ifindex pending resolution of the other comment) take a u32 to avoid the conversion here. conversion can be handled by the caller in the same way as it is for SchedClassifier::attach.

no as this wouldn't be consistent with other Aya APIs that take an interface as a parameter. For example, aya::programs::SchedClassifier::attach

let (foo, bar) = ... to avoid .1 and .0 below

nit: collect::<Result<_, _>>()? to avoid doing the error check below

no it doesn't

Surely we can extract EbpfLoader::new()? this loader is also not a loader at all, it's a Ebpf, so this name is misleading.

why not yield out program as well? that would remove the need for

let default_prog: &SchedClassifier = default.program("tcx_next").unwrap().try_into().unwrap();

below

prefer to do the assertion on the outside so failures produce more information - as written this will stop after the first mismatch.

This isn't possible since program is a borrowed from loader.

Done

does it need clone?

I think you mean it is borrowed from ebpf. Fine. Then can we yield out only program? That seems to be the only thing we actually need.

why the string conversion? can't you write

    assert_eq!(
        got_order.iter().map(|p| p.id()).collect::<Vec<_>>(),
        expected_order
    );

?

We still need to yield the link_id as it's used to test the LinkOrder::before_link and LinkOrder::after_link variants.
Granted, we only need one link_id in particular, but I couldn't reason an easier way to do this.

Right, but link_id is a scalar, no? Perhaps you took me too literally, I meant "yield program instead of ebpf".

Yielding only program won't work since it's borrowed from ebpf which gets dropped when we exit the closure (inside the macro). In borrow checker speak - 'ebpf' dropped here while still borrowed.
We could do that in future if someone where to implement #809

And no link_id is not scalar. It's a composite type.
Specifically it's a TcLinkIdInner::FdLinkId which is a tuple struct containing the RawFd returned from the bpf_prog_attach syscall. There's no easy way to get a list of links from either an ebpf or program. This is the best I can do with the APIs available.

The way you've written this confers no benefit to it being a macro rather than a function. Exploiting the fact that it is a macro we can write (something like):

diff --git a/test/integration-test/src/tests/tcx.rs b/test/integration-test/src/tests/tcx.rs
index f334a02..73dfea8 100644
--- a/test/integration-test/src/tests/tcx.rs
+++ b/test/integration-test/src/tests/tcx.rs
@@ -7,8 +7,8 @@ use test_log::test;
 
 use crate::utils::NetNsGuard;
 
-#[test(tokio::test)]
-async fn tcx() {
+#[test]
+fn tcx() {
     let kernel_version = KernelVersion::current().unwrap();
     if kernel_version < KernelVersion::new(6, 6, 0) {
         eprintln!("skipping tcx_attach test on kernel {kernel_version:?}");
@@ -26,49 +26,60 @@ async fn tcx() {
     //
     // Yields a tuple of the `Ebpf` which must remain in scope for the duration
     // of the test, and the link ID of the attached program.
-    macro_rules! attach_program_with_linkorder {
-        ($link_order:expr) => {{
+    macro_rules! attach_program_with_link_order {
+        ($program_name:ident, $link_id_name:ident, $link_order:expr) => {
             let mut ebpf = Ebpf::load(crate::TCX).unwrap();
-            let program: &mut SchedClassifier =
+            let $program_name: &mut SchedClassifier =
                 ebpf.program_mut("tcx_next").unwrap().try_into().unwrap();
-            program.load().unwrap();
-            let link_id = program
+            $program_name.load().unwrap();
+            let $link_id_name = $program_name
                 .attach_with_options(
                     "lo",
                     TcAttachType::Ingress,
                     TcAttachOptions::TcxOrder($link_order),
                 )
                 .unwrap();
-            (ebpf, link_id)
-        }};
+        };
     }
 
-    let (default, _) = attach_program_with_linkorder!(LinkOrder::default());
-    let (first, _) = attach_program_with_linkorder!(LinkOrder::first());
-    let (mut last, last_link_id) = attach_program_with_linkorder!(LinkOrder::last());
+    attach_program_with_link_order!(default, default_link_id, LinkOrder::default());
+    attach_program_with_link_order!(first, first_link_id, LinkOrder::first());
+    attach_program_with_link_order!(last, last_link_id, LinkOrder::last());
 
-    let default_prog: &SchedClassifier = default.program("tcx_next").unwrap().try_into().unwrap();
-    let first_prog: &SchedClassifier = first.program("tcx_next").unwrap().try_into().unwrap();
-    let last_prog: &mut SchedClassifier = last.program_mut("tcx_next").unwrap().try_into().unwrap();
+    let last_link = last.take_link(last_link_id).unwrap();
 
-    let last_link = last_prog.take_link(last_link_id).unwrap();
-
-    let (before_last, _) =
-        attach_program_with_linkorder!(LinkOrder::before_link(&last_link).unwrap());
-    let (after_last, _) =
-        attach_program_with_linkorder!(LinkOrder::after_link(&last_link).unwrap());
+    attach_program_with_link_order!(
+        before_last,
+        before_last_link_id,
+        LinkOrder::before_link(&last_link).unwrap()
+    );
+    attach_program_with_link_order!(
+        after_last,
+        after_last_link_id,
+        LinkOrder::after_link(&last_link).unwrap()
+    );
 
-    let (before_default, _) =
-        attach_program_with_linkorder!(LinkOrder::before_program(default_prog).unwrap());
-    let (after_default, _) =
-        attach_program_with_linkorder!(LinkOrder::after_program(default_prog).unwrap());
+    attach_program_with_link_order!(
+        before_default,
+        before_default_link_id,
+        LinkOrder::before_program(default_prog).unwrap()
+    );
+    attach_program_with_link_order!(
+        after_default,
+        after_default_link_id,
+        LinkOrder::after_program(default_prog).unwrap()
+    );
 
-    let (before_first, _) = attach_program_with_linkorder!(LinkOrder::before_program_id(unsafe {
-        ProgramId::new(first_prog.info().unwrap().id())
-    }));
-    let (after_first, _) = attach_program_with_linkorder!(LinkOrder::after_program_id(unsafe {
-        ProgramId::new(first_prog.info().unwrap().id())
-    }));
+    attach_program_with_link_order!(
+        before_first,
+        before_first_link_id,
+        LinkOrder::before_program_id(unsafe { ProgramId::new(first.info().unwrap().id()) })
+    );
+    attach_program_with_link_order!(
+        after_first,
+        after_first_link_id,
+        LinkOrder::after_program_id(unsafe { ProgramId::new(first.info().unwrap().id()) })
+    );
 
     let expected_order = [
         before_first

I wasn't able to get the integration tests compiling locally sadly, so this probably doesn't quite compile, but it should be close.