neiam /gitgud

defmodule GitGudWeb.PageLive.HomeTest do
  @moduledoc """
  `/` serves two different pages: the marketing landing to logged-out
  visitors, a personal dashboard to signed-in ones.
  """

  use GitGudWeb.ConnCase, async: false

  import Phoenix.LiveViewTest
  import GitGud.AccountsFixtures
  import GitGud.ForgeFixtures

  alias GitGud.Organizations
  alias GitGud.PullRequests
  alias GitGud.PullRequests.PullRequest

  # PR *creation* needs real refs on disk; the dashboard only reads
  # rows. Insert them directly so these tests exercise the queries
  # rather than git plumbing.
  defp open_pr!(repo, author, title) do
    GitGud.Repo.insert!(%PullRequest{
      repository_id: repo.id,
      author_id: author.id,
      number: System.unique_integer([:positive]),
      title: title,
      state: "open",
      source_ref: "feature",
      target_ref: "main",
      head_sha: :crypto.strong_rand_bytes(20),
      base_sha: :crypto.strong_rand_bytes(20)
    })
  end

  describe "logged out" do
    test "GET / still renders the landing without a socket", %{conn: conn} do
      html = conn |> get(~p"/") |> html_response(200)

      assert html =~ "GITGUD"
      assert html =~ "Self-hosted code forge"
      assert html =~ "Browse repositories"
      assert html =~ "Get an account"
    end

    test "the feature grid is intact", %{conn: conn} do
      {:ok, _lv, html} = live(conn, ~p"/")

      assert html =~ "Self-hosted code forge"
      assert html =~ "Forgejo Actions CI"
      assert html =~ "Federation that works"
      assert html =~ "Invite-gated signups"
    end

    test "no dashboard leaks to anonymous visitors", %{conn: conn} do
      {:ok, _lv, html} = live(conn, ~p"/")

      refute html =~ "Welcome back"
      refute html =~ "Needs your review"
    end
  end

  describe "signed in" do
    setup :register_and_log_in_user

    test "the advertising grid is replaced by a dashboard", %{conn: conn, user: user} do
      {:ok, _lv, html} = live(conn, ~p"/")

      assert html =~ "Welcome back"
      assert html =~ user.handle

      # The marketing cards are gone.
      refute html =~ "Self-hosted code forge"
      refute html =~ "Forgejo Actions CI"
      refute html =~ "Get an account"
    end

    test "empty panels say so rather than rendering blank", %{conn: conn} do
      {:ok, _lv, html} = live(conn, ~p"/")

      assert html =~ "Nothing waiting on you."
      assert html =~ "No open pull requests."
      assert html =~ "No open issues."
    end

    test "your open issues appear", %{conn: conn, user: user} do
      {_user, repo} = repository_fixture(%{owner: user, name: "dash-issues"})
      issue = issue_fixture(repo, user, %{"title" => "Something is broken"})

      {:ok, _lv, html} = live(conn, ~p"/")

      assert html =~ "Something is broken"
      assert html =~ "dash-issues##{issue.number}"
    end

    test "a closed issue drops off the dashboard", %{conn: conn, user: user} do
      {_user, repo} = repository_fixture(%{owner: user, name: "dash-closed"})
      issue = issue_fixture(repo, user, %{"title" => "Already handled"})

      {:ok, _lv, html} = live(conn, ~p"/")
      assert html =~ "Already handled"

      {:ok, _issue} = GitGud.Issues.set_state(issue, "closed")

      {:ok, _lv, html} = live(conn, ~p"/")
      refute html =~ "Already handled"
    end

    test "someone else's PR on a repo you own lands in the review queue", %{
      conn: conn,
      user: user
    } do
      {_user, repo} = repository_fixture(%{owner: user, name: "dash-review"})

      outsider = user_fixture()
      pr = open_pr!(repo, outsider, "Please look")

      {:ok, _lv, html} = live(conn, ~p"/")

      assert html =~ "Please look"
      assert html =~ "by #{outsider.handle}"
      assert html =~ "dash-review##{pr.number}"
    end

    test "your own PR is not in your review queue", %{conn: conn, user: user} do
      {_user, repo} = repository_fixture(%{owner: user, name: "dash-own-pr"})
      _pr = open_pr!(repo, user, "My own work")

      {:ok, _lv, html} = live(conn, ~p"/")

      # Present once, under "Your pull requests" — never under review.
      assert html =~ "My own work"
      assert html =~ "Nothing waiting on you."
    end

    test "a PR on a repo you don't maintain stays out of the queue", %{conn: conn} do
      other = user_fixture()
      {_other, repo} = repository_fixture(%{owner: other, visibility: "public"})

      third = user_fixture()
      _pr = open_pr!(repo, third, "Not yours")

      {:ok, _lv, html} = live(conn, ~p"/")

      refute html =~ "Not yours"
      assert html =~ "Nothing waiting on you."
    end

    test "org admins get their org's PRs in the review queue", %{conn: conn, user: user} do
      {:ok, org} =
        Organizations.create_organization(user, %{
          "handle" => "dash-org",
          "visibility" => "public"
        })

      {:ok, repo} =
        GitGud.Repositories.create_repository_for_org(org, user, %{
          "name" => "org-repo",
          "visibility" => "public"
        })

      outsider = user_fixture()
      _pr = open_pr!(repo, outsider, "Org review")

      {:ok, _lv, html} = live(conn, ~p"/")

      assert html =~ "Org review"
      assert html =~ "dash-org"
    end

    test "plain org members do not inherit the review queue", %{conn: conn, user: user} do
      admin = user_fixture()

      {:ok, org} =
        Organizations.create_organization(admin, %{
          "handle" => "dash-org-member",
          "visibility" => "public"
        })

      _ = Organizations.add_member(org, user, "member")

      {:ok, repo} =
        GitGud.Repositories.create_repository_for_org(org, admin, %{
          "name" => "member-repo",
          "visibility" => "public"
        })

      outsider = user_fixture()
      _pr = open_pr!(repo, outsider, "Admins only")

      {:ok, _lv, html} = live(conn, ~p"/")

      refute html =~ "Admins only"
    end

    test "a merged PR leaves the queue", %{conn: conn, user: user} do
      {_user, repo} = repository_fixture(%{owner: user, name: "dash-merged"})

      outsider = user_fixture()
      pr = open_pr!(repo, outsider, "Will merge")

      {:ok, _lv, html} = live(conn, ~p"/")
      assert html =~ "Will merge"

      {:ok, _pr} =
        pr |> Ecto.Changeset.change(state: "merged") |> GitGud.Repo.update()

      {:ok, _lv, html} = live(conn, ~p"/")
      refute html =~ "Will merge"
    end

    test "your organizations are listed", %{conn: conn, user: user} do
      {:ok, _org} =
        Organizations.create_organization(user, %{"handle" => "dash-listed-org"})

      {:ok, _lv, html} = live(conn, ~p"/")

      assert html =~ "Your organizations"
      assert html =~ "dash-listed-org"
    end

    test "settings quick links survive the rewrite", %{conn: conn} do
      {:ok, _lv, html} = live(conn, ~p"/")

      assert html =~ "SSH keys"
      assert html =~ "Two-factor auth"
      assert html =~ "Account settings"
    end

    test "PR count feeds the panel badge", %{conn: conn, user: user} do
      {_user, repo} = repository_fixture(%{owner: user, name: "dash-count"})
      _ = open_pr!(repo, user, "First")
      _ = open_pr!(repo, user, "Second")

      {:ok, _lv, html} = live(conn, ~p"/")

      assert html =~ "First"
      assert html =~ "Second"
      assert length(PullRequests.list_open_authored_by(user.id, [repo.id])) == 2
    end
  end
end