mod existing {
    use git_testtools::hex_to_id;

    use crate::file::store_at;

    #[test]
    fn with_packed_refs() -> crate::Result {
        let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
        let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
        let packed = store.packed()?;
        let r = store.find_existing("main", packed.as_ref())?;
        assert_eq!(r.target().borrow().as_id().expect("peeled"), c1);
        assert_eq!(r.name().as_bstr(), "refs/heads/main");
        Ok(())
    }
}

mod loose {
    use crate::file::store;

    mod existing {
        use std::path::Path;

        use crate::file::store;

        #[test]
        fn success_and_failure() -> crate::Result {
            let store = store()?;
            for (partial_name, expected_path) in &[("main", Some("refs/heads/main")), ("does-not-exist", None)] {
                let reference = store.loose_find_existing(*partial_name);
                match expected_path {
                    Some(expected_path) => assert_eq!(reference?.name.as_bstr(), expected_path),
                    None => match reference {
                        Ok(_) => panic!("Expected error"),
                        Err(git_ref::file::find::existing::Error::NotFound(name)) => {
                            assert_eq!(name, Path::new(*partial_name));
                        }
                        Err(err) => panic!("Unexpected err: {:?}", err),
                    },
                }
            }
            Ok(())
        }
    }

    #[test]
    fn success() -> crate::Result {
        let store = store()?;
        for (partial_name, expected_path, expected_ref_kind) in &[
            ("dt1", "refs/tags/dt1", git_ref::Kind::Peeled), // tags before heads
            ("heads/dt1", "refs/heads/dt1", git_ref::Kind::Peeled),
            ("d1", "refs/d1", git_ref::Kind::Peeled), // direct refs before heads
            ("heads/d1", "refs/heads/d1", git_ref::Kind::Peeled),
            ("HEAD", "HEAD", git_ref::Kind::Symbolic), // it finds shortest paths first
            ("origin", "refs/remotes/origin/HEAD", git_ref::Kind::Symbolic),
            ("origin/HEAD", "refs/remotes/origin/HEAD", git_ref::Kind::Symbolic),
            ("origin/main", "refs/remotes/origin/main", git_ref::Kind::Peeled),
            ("t1", "refs/tags/t1", git_ref::Kind::Peeled),
            ("main", "refs/heads/main", git_ref::Kind::Peeled),
            ("heads/main", "refs/heads/main", git_ref::Kind::Peeled),
            ("refs/heads/main", "refs/heads/main", git_ref::Kind::Peeled),
        ] {
            let reference = store.loose_find(*partial_name)?.expect("exists");
            assert_eq!(reference.name.as_bstr(), expected_path);
            assert_eq!(reference.target.borrow().kind(), *expected_ref_kind);
        }
        Ok(())
    }

    #[test]
    fn failure() -> crate::Result {
        let store = store()?;
        for (partial_name, reason, is_err) in &[
            ("foobar", "does not exist", false),
            ("broken", "does not parse", true),
            ("../escaping", "an invalid ref name", true),
        ] {
            let reference = store.loose_find(*partial_name);
            if *is_err {
                assert!(reference.is_err(), "{}", reason);
            } else {
                let reference = reference?;
                assert!(reference.is_none(), "{}", reason);
            }
        }
        Ok(())
    }
}