identity export (and every identity lookup) falls back to the key directory in a repository that has not stored the identity yet, checking it hashes to the key; its help names the file it writes e3d071cecfe2

    /// An identity: from this repository's store, or else from the key

    /// directory, where `oxy identity create` keeps the user's own (a new

    /// repository has not stored it yet). The file must hash to `key`.

        match self.store.get_identity(key) {

            Ok(id) => Ok(id),

            Err(e) => {

                let path = self.keys_dir.join(format!("{}.identity", key.to_hex()));

                match fs::read(&path) {

                    Ok(bytes) => {

                        let id = Identity::decode(&bytes)?;

                        if id.hash() != *key {

                            return fail(format!(

                                "{} does not hold identity {}",

                                path.display(),

                                key.short(12)

                            ));

                        }

                        Ok(id)

                    }

                    Err(_) => Err(e.into()),

                }

            }

        }

/// A new repository has not stored the user's identity yet (that happens

/// at the first signed change); looking it up falls back to the key

/// directory, and a file there that does not hash to the key is refused.

#[test]

fn identity_is_found_in_the_key_directory_for_a_new_repository() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let home = dir.path().join("home");

    let mut first = Repo::init(&dir.path().join("a"))

        .unwrap()

        .with_home(home.clone());

    let (key, _) = first

        .create_identity("Ada", "[email protected]", IdentityScope::User)

        .unwrap();

    let fresh = Repo::init(&dir.path().join("b"))

        .unwrap()

        .with_home(home.clone());

    assert!(!fresh.store().has(&key), "nothing stored yet");

    let id = fresh.identity(&key).unwrap();

    assert_eq!((id.name.as_str(), id.hash()), ("Ada", key));

    // A key file that is not this identity is an error, not a wrong answer.

    let keys = fresh.keys_dir.clone();

    let (other, _) = first

        .create_identity("Bob", "[email protected]", IdentityScope::User)

        .unwrap();

    fs::copy(

        keys.join(format!("{}.identity", other.to_hex())),

        keys.join(format!("{}.identity", key.to_hex())),

    )

    .unwrap();

    assert!(fresh

        .identity(&key)

        .unwrap_err()

        .to_string()

        .contains("does not hold identity"));

}

        /// File to write (default: <key>.identity in the current directory)