A wiki can start with a push 6e7dfa0a42b9

- **A wiki can start with a push.** Someone who may write to a repository can push the first pages of its wiki to `OWNER/NAME.wiki`, as well as writing them on the web: the hub makes the empty wiki when a writer first reaches that address, and the push gives it its id. Readers still find nothing there until it has pages.

        // A wiki is made, empty and unbound, when someone who may write to

        // its repository first reaches it, so the first page can be pushed

        // as well as written on the web (§6.11); the push gives it its id.

        let (_, is_wiki) = crate::wiki::parent_of(&parsed);

        let may_write = match &caller {

            Caller::Site => true,

            Caller::Token(_, token) => token.has_scope("repo:write") || token.has_scope("repo:admin"),

            _ => false,

        };

        if is_wiki && may_write && auth::roles::allows(role, Access::Write) && !row.archived {

            if let Some(name) = RepoName::new(&row.owner, &row.name) {

                if !self.wikis.exists(&name) {

                    self.wikis

                        .create(&name, None)

                        .map_err(|e| Failure(StatusCode::INTERNAL_SERVER_ERROR, format!("make the wiki: {e}")))?;

                }

            }

        }

/// A wiki can start with a push: someone who may write to the repository

/// reaching `OWNER/NAME.wiki` before it exists gets an empty wiki, which

/// the push fills; a reader still finds nothing there.

#[tokio::test(flavor = "multi_thread")]

async fn a_wiki_can_start_with_a_push() {

    hermetic();

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

    let mut config = Config::load(dir.path()).unwrap();

    config.auth.push_tokens = vec!["site".into()];

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let port = listener.local_addr().unwrap().port();

    config.server.base_url = format!("http://127.0.0.1:{port}");

    let app = oxygenhub::build(config).await.unwrap();

    let router = oxygenhub::router(app.clone());

    tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });

    let base = format!("http://127.0.0.1:{port}");

    let repo = RepoName::parse("andy/docs").unwrap();

    app.repos.create(&repo, None).unwrap();

    db::repos::create(&app.db, "andy", "docs", "", hub_api::Visibility::Public).await.unwrap();

    let url = format!("{base}/andy/docs.wiki");

    // A reader: nothing there, and nothing made.

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

    let u = url.clone();

    let p = anon.path().join("w");

    assert!(tokio::task::spawn_blocking(move || Repo::clone(&u, &p)).await.unwrap().is_err());

    assert!(!app.wikis.exists(&repo));

    // A writer pushes pages it wrote locally.

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

    let mut w = Repo::init(work.path()).unwrap();

    w.config.set("remote.origin.url", &url).unwrap();

    w.config.set("remote.origin.token", "site").unwrap();

    w.save_config().unwrap();

    write(work.path(), "Home.md", b"# Docs\n\nSee [the overview](Overview).\n");

    write(work.path(), "Overview.md", b"# Overview\n\n```mermaid\nflowchart LR\n  A --> B\n```\n");

    w.snapshot("t").unwrap();

    w.commit("First pages", &[]).unwrap();

    let pushed = tokio::task::spawn_blocking(move || w.push("origin", false).unwrap()).await.unwrap();

    assert!(pushed.iter().all(|r| r.ok), "{pushed:?}");

    assert!(app.wikis.exists(&repo));

    let home = send(&app, "GET", "/andy/docs/wiki", None, None).await.body;

    assert!(home.contains("<h1>Docs</h1>") && home.contains("href=\"/andy/docs/wiki/Overview\""), "{home}");

    let overview = send(&app, "GET", "/andy/docs/wiki/Overview", None, None).await.body;

    assert!(overview.contains("class=\"language-mermaid\""), "a diagram block for the page's script to draw: {overview}");

}