actually get maybe-async to work!

We already used it via `git-protocol`, which also solves the `issync`
feature toggle issue we encountered earlier.
Next step is to unify the tests where possible.

git-repository/tests/remote/connect.rs

@@ -50,24 +50,3 @@ mod blocking_io {
         }
     }
 }
-
-#[cfg(feature = "async-network-client-async-std")]
-mod async_io_via_async_std {
-    use git_features::progress;
-    use git_repository::remote::Direction::Fetch;
-
-    use crate::remote;
-    use crate::remote::into_daemon_remote;
-
-    #[async_std::test]
-    async fn connect_only() -> crate::Result {
-        let repo = remote::repo("protocol_file_user");
-        let daemon = git_testtools::spawn_git_daemon(repo.git_dir())?;
-        let remote = into_daemon_remote(repo.find_remote("origin")?, &daemon.url, None);
-        remote
-            .connect(Fetch, progress::Discard)
-            .await
-            .expect("connection succeeds");
-        Ok(())
-    }
-}

git-repository/tests/remote/ref_map.rs

@@ -42,3 +42,59 @@ mod blocking_io {
         Ok(())
     }
 }
+
+#[cfg(feature = "async-network-client-async-std")]
+mod async_io {
+    use git_features::progress;
+    use git_repository as git;
+    use git_repository::remote::Direction::Fetch;
+    use git_testtools::spawn_git_daemon;
+
+    use crate::remote;
+    use crate::remote::into_daemon_remote;
+    use git_protocol::maybe_async;
+
+    #[maybe_async::test(
+        feature = "blocking-network-client",
+        async(feature = "async-network-client-async-std", async_std::test)
+    )]
+    async fn all() -> crate::Result {
+        let daemon = spawn_git_daemon(remote::repo_path("base"))?;
+        for (version, expected_remote_refs) in [
+            (None, 11),
+            (Some(git::protocol::transport::Protocol::V2), 11),
+            (Some(git::protocol::transport::Protocol::V1), 14), // V1 doesn't support prefiltering.
+        ] {
+            let mut repo = remote::repo("clone");
+            if let Some(version) = version {
+                repo.config_snapshot_mut().set_raw_value(
+                    "protocol",
+                    None,
+                    "version",
+                    (version as u8).to_string().as_str(),
+                )?;
+            }
+
+            let remote = into_daemon_remote(repo.find_remote("origin")?, &daemon.url, None);
+            let map = remote
+                .connect(Fetch, progress::Discard)
+                .await?
+                .ref_map(Default::default())
+                .await?;
+            assert_eq!(
+                map.remote_refs.len(),
+                expected_remote_refs,
+                "{:?}: it gets all remote refs, independently of the refspec. But we use a prefix so pre-filter them.",
+                version
+            );
+
+            assert_eq!(map.fixes.len(), 0);
+            assert_eq!(
+                map.mappings.len(),
+                11,
+                "mappings are only a sub-set of all remotes due to refspec matching, tags are filtered out."
+            );
+        }
+        Ok(())
+    }
+}