|> assign(:project, project)

     |> assign(:items, items)

     |> assign(:issue_options, issue_options)

     # The board columns are read as `@statuses` inside ~H, where `@` means

     # `assigns.statuses`, not the module attribute. Without this assign every

     # render raised KeyError and the route was unreachable.

     |> assign(:statuses, @statuses)

     |> assign(:status_options, Enum.map(@statuses, &{&1, &1}))

     |> assign(:form, to_form(ProjectItem.changeset(%ProjectItem{}, %{}), as: "item"))}

  end

defmodule OpenAgentsWeb.AssigneeIndexLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  alias OpenAgents.Issues

  setup %{conn: conn} do

    {:ok, conn: log_in_github_user(conn, "assignee-index")}

  end

  test "mounts with an honest empty state when no issue has an assignee", %{conn: conn} do

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/assignees")

    assert html =~ "Assignees"

    assert has_element?(view, ~s{[role="status"]}, "No assignees have been assigned")

    refute has_element?(view, "#assignees")

  end

  test "tallies assignees across open and closed issues, most-assigned first", %{conn: conn} do

    {:ok, _first} = Issues.create_issue(%{"title" => "First", "assignees" => ["ada", "grace"]})

    {:ok, _second} = Issues.create_issue(%{"title" => "Second", "assignees" => ["ada"]})

    {:ok, third} = Issues.create_issue(%{"title" => "Third", "assignees" => ["ada"]})

    # A closed issue still counts: the view lists `state: "all"`.

    {:ok, _} = Issues.update_issue(third, %{"state" => "closed"})

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/assignees")

    assert has_element?(view, "#assignees")

    refute html =~ "No assignees have been assigned"

    # Rows are sorted by descending count, so `ada` (3) precedes `grace` (1).

    assert has_element?(view, "#assignees tr:first-child td:first-child", "ada")

    assert has_element?(view, "#assignees tr:first-child td:nth-child(2)", "3")

    assert has_element?(view, "#assignees tr:nth-child(2) td:first-child", "grace")

    assert has_element?(view, "#assignees tr:nth-child(2) td:nth-child(2)", "1")

    refute has_element?(view, "#assignees tr:nth-child(3)")

  end

  test "an anonymous visitor is redirected away from the assignee list" do

    assert {:error, {:redirect, %{to: to}}} =

             live(build_conn(), ~p"/OpenAgentsInc/sarah/assignees")

    refute to == "/OpenAgentsInc/sarah/assignees"

  end

end

defmodule OpenAgentsWeb.IssueIndexLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  import OpenAgents.LabelsFixtures

  alias OpenAgents.Issues

  setup %{conn: conn} do

    {:ok, conn: log_in_github_user(conn, "issue-index")}

  end

  test "mounts with zeroed counts and an empty state", %{conn: conn} do

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/issues")

    assert html =~ "No open issues"

    assert html =~ "Issues will show up here once they are created."

    refute has_element?(view, "#issues")

    # The default filter is `open`, and it is the one marked current.

    assert has_element?(view, ~s{a[href="/OpenAgentsInc/sarah/issues?state=open"][aria-current]})

    refute has_element?(

             view,

             ~s{a[href="/OpenAgentsInc/sarah/issues?state=closed"][aria-current]}

           )

    assert has_element?(view, ~s{a[href="/OpenAgentsInc/sarah/issues/new"]}, "New issue")

  end

  test "lists open issues with their number, author, labels, and assignees", %{conn: conn} do

    label_fixture(%{name: "bug", color: "d73a4a"})

    {:ok, issue} =

      Issues.create_issue(%{

        "title" => "Streaming stalls",

        "user" => %{"login" => "ada"},

        "labels" => ["bug"],

        "assignees" => ["grace"]

      })

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/issues")

    refute html =~ "No open issues"

    assert has_element?(view, "#issues")

    assert has_element?(

             view,

             ~s{a[href="/OpenAgentsInc/sarah/issues/#{issue.number}"]},

             "Streaming stalls"

           )

    assert html =~ "##{issue.number}"

    assert html =~ "ada"

    assert html =~ "bug"

    assert has_element?(view, ~s{[title="grace"]})

  end

  test "an issue with no author falls back to anonymous", %{conn: conn} do

    {:ok, _} = Issues.create_issue(%{"title" => "Orphaned"})

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/sarah/issues")

    assert html =~ "Orphaned"

    assert html =~ "anonymous"

  end

  test "the comment count only renders once an issue has comments", %{conn: conn} do

    {:ok, issue} = Issues.create_issue(%{"title" => "Chatty"})

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/sarah/issues")

    refute html =~ "hero-chat-bubble-left"

    {:ok, _} =

      Issues.create_comment(%{

        issue_id: issue.id,

        body: "First",

        user: %{"login" => "ada"}

      })

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/sarah/issues")

    assert html =~ "hero-chat-bubble-left"

  end

  test "patching to the closed filter swaps the stream and the current marker", %{conn: conn} do

    {:ok, _open} = Issues.create_issue(%{"title" => "Open one"})

    {:ok, closed} = Issues.create_issue(%{"title" => "Closed one"})

    {:ok, _} = Issues.update_issue(closed, %{"state" => "closed"})

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/issues")

    assert html =~ "Open one"

    refute html =~ "Closed one"

    html =

      view

      |> element(~s{a[href="/OpenAgentsInc/sarah/issues?state=closed"]})

      |> render_click()

    assert html =~ "Closed one"

    refute html =~ "Open one"

    assert has_element?(

             view,

             ~s{a[href="/OpenAgentsInc/sarah/issues?state=closed"][aria-current]}

           )

    refute has_element?(view, ~s{a[href="/OpenAgentsInc/sarah/issues?state=open"][aria-current]})

  end

  test "the closed filter has its own empty-state wording", %{conn: conn} do

    {:ok, _open} = Issues.create_issue(%{"title" => "Open one"})

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/sarah/issues?state=closed")

    assert html =~ "No closed issues"

    refute html =~ "No open issues"

  end

  test "the open and closed counts stay visible on both filters", %{conn: conn} do

    {:ok, _} = Issues.create_issue(%{"title" => "A"})

    {:ok, _} = Issues.create_issue(%{"title" => "B"})

    {:ok, c} = Issues.create_issue(%{"title" => "C"})

    {:ok, _} = Issues.update_issue(c, %{"state" => "closed"})

    for state <- ["open", "closed"] do

      {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/issues?state=#{state}")

      assert has_element?(

               view,

               ~s{a[href="/OpenAgentsInc/sarah/issues?state=open"]},

               "2 Open"

             )

      assert has_element?(

               view,

               ~s{a[href="/OpenAgentsInc/sarah/issues?state=closed"]},

               "1 Closed"

             )

    end

  end

  test "an anonymous visitor is redirected away from the issue list" do

    assert {:error, {:redirect, %{to: to}}} = live(build_conn(), ~p"/OpenAgentsInc/sarah/issues")

    refute to == "/OpenAgentsInc/sarah/issues"

  end

end

defmodule OpenAgentsWeb.IssueNewLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  import OpenAgents.LabelsFixtures

  import OpenAgents.MilestonesFixtures

  alias OpenAgents.Issues

  setup %{conn: conn} do

    {:ok, conn: log_in_github_user(conn, "issue-new")}

  end

  test "mounts with an empty form and a cancel link back to the list", %{conn: conn} do

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/issues/new")

    assert html =~ "New issue"

    assert has_element?(view, "#new-issue-form")

    assert has_element?(view, "#issue_title")

    assert has_element?(view, "#issue_body")

    assert has_element?(view, ~s{a[href="/OpenAgentsInc/sarah/issues"]}, "Cancel")

  end

  test "the milestone and label selects offer the seeded records", %{conn: conn} do

    milestone = milestone_fixture(%{title: "v1.0", due_on: nil})

    label_fixture(%{name: "bug", color: "d73a4a"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/issues/new")

    assert has_element?(view, ~s{#issue_milestone option[value="#{milestone.number}"]}, "v1.0")

    assert has_element?(view, ~s{#issue_labels option[value="bug"]}, "bug")

    assert has_element?(view, ~s{#issue_milestone option[value=""]}, "Select a milestone")

  end

  test "with no milestones or labels the selects render only the prompt", %{conn: conn} do

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/issues/new")

    assert has_element?(view, "#issue_milestone")

    refute has_element?(view, ~s{#issue_labels option})

  end

  test "submitting a title creates the issue and navigates to it", %{conn: conn} do

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/issues/new")

    result =

      view

      |> form("#new-issue-form", issue: %{title: "Add a runbook", body: "Please"})

      |> render_submit()

    assert [issue] = Issues.list_issues()

    assert issue.title == "Add a runbook"

    assert issue.body == "Please"

    {:ok, _show, html} =

      follow_redirect(result, conn, ~p"/OpenAgentsInc/sarah/issues/#{issue.number}")

    assert html =~ "Issue created"

    assert html =~ "Add a runbook"

  end

  test "a submitted label and milestone are applied to the new issue", %{conn: conn} do

    milestone = milestone_fixture(%{title: "v1.0", due_on: nil})

    label_fixture(%{name: "bug", color: "d73a4a"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/issues/new")

    assert {:error, {:live_redirect, _}} =

             view

             |> form("#new-issue-form",

               issue: %{

                 title: "Tagged",

                 body: "",

                 milestone: to_string(milestone.number),

                 labels: ["bug"]

               }

             )

             |> render_submit()

    assert [issue] = Issues.list_issues()

    assert [%{"name" => "bug", "color" => "d73a4a"}] = issue.labels

    assert issue.milestone["title"] == "v1.0"

    assert issue.milestone["number"] == milestone.number

  end

  test "an empty label and milestone selection leaves the issue bare", %{conn: conn} do

    label_fixture(%{name: "bug", color: "d73a4a"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/issues/new")

    assert {:error, {:live_redirect, _}} =

             view

             |> form("#new-issue-form",

               issue: %{title: "Bare", body: "", milestone: "", labels: []}

             )

             |> render_submit()

    assert [issue] = Issues.list_issues()

    assert issue.labels == []

    assert issue.milestone == nil

  end

  test "a blank title re-renders the form with an error and creates nothing", %{conn: conn} do

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/issues/new")

    html =

      view

      |> form("#new-issue-form", issue: %{title: "", body: "no title"})

      |> render_submit()

    assert html =~ "can't be blank"

    assert has_element?(view, "#new-issue-form")

    assert Issues.list_issues(state: "all") == []

  end

end

defmodule OpenAgentsWeb.IssueShowLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  import OpenAgents.LabelsFixtures

  import OpenAgents.MilestonesFixtures

  alias OpenAgents.Issues

  setup %{conn: conn} do

    {:ok, conn: log_in_github_user(conn, "issue-show")}

  end

  defp issue!(attrs) do

    {:ok, issue} = Issues.create_issue(attrs)

    issue

  end

  defp path(issue), do: ~p"/OpenAgentsInc/sarah/issues/#{issue.number}"

  test "mounts and renders the title, number, state, and body", %{conn: conn} do

    issue =

      issue!(%{

        "title" => "Streaming stalls",

        "body" => "It hangs",

        "user" => %{"login" => "ada"}

      })

    {:ok, view, html} = live(conn, path(issue))

    assert html =~ "Streaming stalls"

    assert html =~ "##{issue.number}"

    assert html =~ "It hangs"

    assert html =~ "ada"

    assert has_element?(view, ~s{button[phx-click="close"]}, "Close issue")

    refute has_element?(view, ~s{button[phx-click="reopen"]})

  end

  test "an issue with no body says so rather than rendering blank", %{conn: conn} do

    issue = issue!(%{"title" => "Bare"})

    {:ok, _view, html} = live(conn, path(issue))

    assert html =~ "No description provided."

    assert html =~ "anonymous"

  end

  test "the sidebar only renders sections the issue actually has", %{conn: conn} do

    bare = issue!(%{"title" => "Bare"})

    {:ok, _view, html} = live(conn, path(bare))

    refute html =~ "Labels"

    refute html =~ "Assignees"

    refute html =~ "Milestone"

    label_fixture(%{name: "bug", color: "d73a4a"})

    milestone = milestone_fixture(%{title: "v1.0", due_on: nil})

    rich = issue!(%{"title" => "Rich", "labels" => ["bug"], "assignees" => ["grace"]})

    {:ok, rich} = Issues.set_milestone(rich, milestone.number)

    {:ok, view, html} = live(conn, path(rich))

    assert html =~ "Labels"

    assert html =~ "bug"

    assert html =~ "Assignees"

    assert has_element?(view, ~s{[title="grace"]})

    assert has_element?(view, ~s{a[href="/OpenAgentsInc/sarah/milestones"]}, "v1.0")

  end

  test "a missing issue number raises rather than rendering an empty page", %{conn: conn} do

    assert_raise Ecto.NoResultsError, fn ->

      live(conn, ~p"/OpenAgentsInc/sarah/issues/9999")

    end

  end

  test "closing then reopening an issue swaps the action buttons", %{conn: conn} do

    issue = issue!(%{"title" => "Toggle me"})

    {:ok, view, _html} = live(conn, path(issue))

    html = view |> element(~s{button[phx-click="close"]}) |> render_click()

    assert html =~ "Issue closed"

    assert has_element?(view, ~s{button[phx-click="reopen"]}, "Reopen issue")

    refute has_element?(view, ~s{button[phx-click="close"]})

    closed = Issues.get_issue!(issue.id)

    assert closed.state == "closed"

    assert closed.state_reason == "completed"

    assert closed.closed_at

    html = view |> element(~s{button[phx-click="reopen"]}) |> render_click()

    assert html =~ "Issue reopened"

    assert has_element?(view, ~s{button[phx-click="close"]}, "Close issue")

    reopened = Issues.get_issue!(issue.id)

    assert reopened.state == "open"

    assert reopened.closed_at == nil

  end

  test "the edit toggle swaps the header for the edit form and back", %{conn: conn} do

    issue = issue!(%{"title" => "Editable", "body" => "Before"})

    {:ok, view, _html} = live(conn, path(issue))

    refute has_element?(view, "#issue-edit-form")

    view |> element(~s{button[phx-click="toggle_edit"]}) |> render_click()

    assert has_element?(view, "#issue-edit-form")

    refute has_element?(view, ~s{button[phx-click="close"]})

    view |> element(~s{#issue-edit-form button[phx-click="toggle_edit"]}) |> render_click()

    refute has_element?(view, "#issue-edit-form")

    assert has_element?(view, ~s{button[phx-click="close"]})

  end

  test "saving the edit form updates the issue and leaves edit mode", %{conn: conn} do

    issue = issue!(%{"title" => "Editable", "body" => "Before"})

    {:ok, view, _html} = live(conn, path(issue))

    view |> element(~s{button[phx-click="toggle_edit"]}) |> render_click()

    html =

      view

      |> form("#issue-edit-form", issue: %{title: "Edited", body: "After"})

      |> render_submit()

    assert html =~ "Issue updated"

    assert html =~ "Edited"

    assert html =~ "After"

    refute has_element?(view, "#issue-edit-form")

    updated = Issues.get_issue!(issue.id)

    assert updated.title == "Edited"

    assert updated.body == "After"

  end

  test "clearing the title in the edit form keeps the form and shows the error", %{conn: conn} do

    issue = issue!(%{"title" => "Editable"})

    {:ok, view, _html} = live(conn, path(issue))

    view |> element(~s{button[phx-click="toggle_edit"]}) |> render_click()

    html =

      view

      |> form("#issue-edit-form", issue: %{title: "", body: "still here"})

      |> render_submit()

    assert html =~ "can't be blank"

    assert has_element?(view, "#issue-edit-form")

    assert Issues.get_issue!(issue.id).title == "Editable"

  end

  test "adding a comment appends it to the thread and bumps the count", %{conn: conn} do

    issue = issue!(%{"title" => "Discuss"})

    {:ok, view, html} = live(conn, path(issue))

    assert has_element?(view, "#comment-form")

    refute html =~ "Looks good to me"

    html =

      view

      |> form("#comment-form", comment: %{body: "Looks good to me"})

      |> render_submit()

    assert html =~ "Comment added"

    assert html =~ "Looks good to me"

    assert html =~ "anonymous"

    assert [comment] = Issues.list_comments(issue.id)

    assert comment.body == "Looks good to me"

    assert Issues.get_issue!(issue.id).comments == 1

  end

  test "an empty comment body is rejected and nothing is stored", %{conn: conn} do

    issue = issue!(%{"title" => "Discuss"})

    {:ok, view, _html} = live(conn, path(issue))

    html =

      view

      |> form("#comment-form", comment: %{body: ""})

      |> render_submit()

    assert html =~ "can't be blank"

    assert Issues.list_comments(issue.id) == []

    assert Issues.get_issue!(issue.id).comments == 0

  end

  test "existing comments render with their author on mount", %{conn: conn} do

    issue = issue!(%{"title" => "Discuss"})

    {:ok, _} =

      Issues.create_comment(%{

        issue_id: issue.id,

        body: "Earlier note",

        user: %{"login" => "ada"}

      })

    {:ok, _view, html} = live(conn, path(issue))

    assert html =~ "Earlier note"

    assert html =~ "ada"

  end

  test "an anonymous visitor is redirected away from an issue page" do

    issue = issue!(%{"title" => "Private"})

    assert {:error, {:redirect, %{to: to}}} = live(build_conn(), path(issue))

    refute to == "/OpenAgentsInc/sarah/issues/#{issue.number}"

  end

end

defmodule OpenAgentsWeb.LabelIndexLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  import OpenAgents.LabelsFixtures

  alias OpenAgents.Labels

  setup %{conn: conn} do

    {:ok, conn: log_in_github_user(conn, "label-index")}

  end

  test "mounts with the create form and an empty state", %{conn: conn} do

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/labels")

    assert html =~ "Labels"

    assert has_element?(view, "#new-label-form")

    assert has_element?(view, ~s{[role="status"]}, "No labels yet")

    refute has_element?(view, "#labels")

  end

  test "lists seeded labels with their descriptions", %{conn: conn} do

    label_fixture(%{name: "bug", color: "d73a4a", description: "Something is broken"})

    label_fixture(%{name: "docs", color: "0075ca", description: nil})

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/labels")

    refute html =~ "No labels yet"

    assert has_element?(view, "#labels")

    assert has_element?(view, "#labels td", "bug")

    assert has_element?(view, "#labels td", "Something is broken")

    assert has_element?(view, "#labels td", "docs")

    # A label with no description renders the em-dash placeholder, not "".

    assert has_element?(view, "#labels td", "—")

  end

  test "submitting the form creates a label and re-renders the table", %{conn: conn} do

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/labels")

    html =

      view

      |> form("#new-label-form", label: %{name: "enhancement", color: "a2eeef"})

      |> render_submit()

    assert html =~ "Label created"

    assert has_element?(view, "#labels td", "enhancement")

    assert [%Labels.Label{name: "enhancement"}] = Labels.list_labels()

  end

  test "a label missing its required color re-renders the form with an error", %{conn: conn} do

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/labels")

    html =

      view

      |> form("#new-label-form", label: %{name: "no-color", color: ""})

      |> render_submit()

    assert html =~ "can't be blank"

    assert has_element?(view, "#new-label-form")

    assert Labels.list_labels() == []

  end

  test "deleting a label removes it and returns the empty state", %{conn: conn} do

    label = label_fixture(%{name: "wontfix", color: "ffffff"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/labels")

    assert has_element?(view, "#labels td", "wontfix")

    html =

      view

      |> element(~s{#labels button[phx-value-id="#{label.id}"]})

      |> render_click()

    assert html =~ "Label deleted"

    assert has_element?(view, ~s{[role="status"]}, "No labels yet")

    assert Labels.list_labels() == []

  end

end

defmodule OpenAgentsWeb.MilestoneIndexLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  import OpenAgents.MilestonesFixtures

  alias OpenAgents.Issues

  alias OpenAgents.Milestones

  setup %{conn: conn} do

    {:ok, conn: log_in_github_user(conn, "milestone-index")}

  end

  test "mounts with the create form and an empty state", %{conn: conn} do

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/milestones")

    assert html =~ "Milestones"

    assert has_element?(view, "#new-milestone-form")

    assert has_element?(view, ~s{[role="status"]}, "No milestones yet")

  end

  test "lists seeded milestones with their state and due date", %{conn: conn} do

    milestone_fixture(%{title: "v1.0", state: "open", due_on: "2026-12-31", description: "Ship"})

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/sarah/milestones")

    refute html =~ "No milestones yet"

    assert html =~ "v1.0"

    assert html =~ "Ship"

    assert html =~ "Due 2026-12-31"

  end

  test "the progress meter reports the closed-to-total ratio", %{conn: conn} do

    milestone = milestone_fixture(%{title: "Beta", state: "open", due_on: nil})

    {:ok, open_issue} = Issues.create_issue(%{"title" => "Still open"})

    {:ok, _} = Issues.set_milestone(open_issue, milestone.number)

    {:ok, done_issue} = Issues.create_issue(%{"title" => "Finished"})

    {:ok, done_issue} = Issues.set_milestone(done_issue, milestone.number)

    {:ok, _} = Issues.update_issue(done_issue, %{"state" => "closed"})

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/milestones")

    assert has_element?(

             view,

             ~s{[role="progressbar"][aria-label="Beta progress"][aria-valuenow="50"]}

           )

    assert html =~ "1 open"

    assert html =~ "1 closed"

    assert html =~ "2 total"

    assert html =~ "50%"

  end

  test "a milestone with no issues reports zero progress", %{conn: conn} do

    milestone_fixture(%{title: "Empty", due_on: nil})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/milestones")

    assert has_element?(

             view,

             ~s{[role="progressbar"][aria-label="Empty progress"][aria-valuenow="0"]}

           )

  end

  test "submitting the form creates a milestone", %{conn: conn} do

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/milestones")

    html =

      view

      |> form("#new-milestone-form",

        milestone: %{title: "v2.0", due_on: "2027-01-01", description: "Next"}

      )

      |> render_submit()

    assert html =~ "Milestone created"

    assert html =~ "v2.0"

    assert [%Milestones.Milestone{title: "v2.0", number: 1}] = Milestones.list_milestones()

  end

  test "a milestone with no title re-renders the form with an error", %{conn: conn} do

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/milestones")

    html =

      view

      |> form("#new-milestone-form", milestone: %{title: "", due_on: "", description: ""})

      |> render_submit()

    assert html =~ "can't be blank"

    assert Milestones.list_milestones() == []

  end

  test "closing a milestone flips its state and hides the close button", %{conn: conn} do

    milestone = milestone_fixture(%{title: "Closeable", state: "open", due_on: nil})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/milestones")

    assert has_element?(view, ~s{button[phx-click="close"][phx-value-id="#{milestone.id}"]})

    html =

      view

      |> element(~s{button[phx-click="close"][phx-value-id="#{milestone.id}"]})

      |> render_click()

    assert html =~ "Milestone closed"

    refute has_element?(view, ~s{button[phx-click="close"][phx-value-id="#{milestone.id}"]})

    assert Milestones.get_milestone!(milestone.id).state == "closed"

  end

  test "deleting a milestone returns the empty state", %{conn: conn} do

    milestone = milestone_fixture(%{title: "Deletable", due_on: nil})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/milestones")

    html =

      view

      |> element(~s{button[phx-click="delete"][phx-value-id="#{milestone.id}"]})

      |> render_click()

    assert html =~ "Milestone deleted"

    assert has_element?(view, ~s{[role="status"]}, "No milestones yet")

    assert Milestones.list_milestones() == []

  end

end

defmodule OpenAgentsWeb.ProjectIndexLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  import OpenAgents.ProjectsFixtures

  alias OpenAgents.Projects

  setup %{conn: conn} do

    {:ok, conn: log_in_github_user(conn, "project-index")}

  end

  test "mounts with the create form and an empty state", %{conn: conn} do

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/projects")

    assert html =~ "Projects"

    assert has_element?(view, "#new-project-form")

    assert has_element?(view, ~s{[role="status"]}, "No projects yet")

  end

  test "lists projects owned by the URL owner and links to each board", %{conn: conn} do

    project = project_fixture(%{title: "Roadmap", owner: "OpenAgentsInc", state: "open"})

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/sarah/projects")

    refute html =~ "No projects yet"

    assert html =~ "Roadmap"

    assert has_element?(

             view,

             ~s{a[href="/OpenAgentsInc/sarah/projects/#{project.number}"]},

             "Roadmap"

           )

    assert has_element?(

             view,

             ~s{a[href="/OpenAgentsInc/sarah/projects/#{project.number}"]},

             "View"

           )

  end

  test "a project owned by someone else is filtered out", %{conn: conn} do

    project_fixture(%{title: "Someone elses", owner: "other-org"})

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/sarah/projects")

    refute html =~ "Someone elses"

    assert html =~ "No projects yet"

  end

  test "submitting the form creates a project owned by the URL owner", %{conn: conn} do

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/projects")

    html =

      view

      |> form("#new-project-form", project: %{title: "Q3 delivery"})

      |> render_submit()

    assert html =~ "Project created"

    assert html =~ "Q3 delivery"

    assert [project] = Projects.list_projects()

    assert project.title == "Q3 delivery"

    assert project.owner == "OpenAgentsInc"

    assert project.state == "open"

  end

  test "a project with no title re-renders the form with an error", %{conn: conn} do

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/projects")

    html =

      view

      |> form("#new-project-form", project: %{title: ""})

      |> render_submit()

    assert html =~ "can't be blank"

    assert has_element?(view, "#new-project-form")

    assert Projects.list_projects() == []

  end

  test "deleting a project returns the empty state", %{conn: conn} do

    project = project_fixture(%{title: "Doomed", owner: "OpenAgentsInc"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/sarah/projects")

    html =

      view

      |> element(~s{button[phx-click="delete"][phx-value-id="#{project.id}"]})

      |> render_click()

    assert html =~ "Project deleted"

    assert has_element?(view, ~s{[role="status"]}, "No projects yet")

    assert Projects.list_projects() == []

  end

end

defmodule OpenAgentsWeb.ProjectShowLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  import OpenAgents.LabelsFixtures

  import OpenAgents.ProjectItemsFixtures

  import OpenAgents.ProjectsFixtures

  alias OpenAgents.Issues

  alias OpenAgents.Projects

  setup %{conn: conn} do

    {:ok, conn: log_in_github_user(conn, "project-show")}

  end

  defp project!, do: project_fixture(%{title: "Roadmap", owner: "OpenAgentsInc"})

  defp path(project), do: ~p"/OpenAgentsInc/sarah/projects/#{project.number}"

  test "mounts and renders every board column plus the add form", %{conn: conn} do

    project = project!()

    {:ok, view, html} = live(conn, path(project))

    assert html =~ "Roadmap"

    assert html =~ "To Do"

    assert html =~ "In Progress"

    assert html =~ "Done"

    assert has_element?(view, "#new-project-item-form")

    assert has_element?(view, ~s{a[href="/OpenAgentsInc/sarah/projects"]}, "Back to projects")

  end

  test "an empty board renders the columns with no cards", %{conn: conn} do

    project = project!()

    {:ok, view, _html} = live(conn, path(project))

    refute has_element?(view, ~s{a[href^="/OpenAgentsInc/sarah/issues/"]})

    # With no issues in the repo the issue select carries only its prompt.

    refute has_element?(view, ~s{#item_issue_number option:not([value=""])})

  end

  test "the issue select offers every issue, open or closed", %{conn: conn} do

    project = project!()

    {:ok, open} = Issues.create_issue(%{"title" => "Still open"})

    {:ok, closed} = Issues.create_issue(%{"title" => "All done"})

    {:ok, _} = Issues.update_issue(closed, %{"state" => "closed"})

    {:ok, view, _html} = live(conn, path(project))

    assert has_element?(

             view,

             ~s{#item_issue_number option[value="#{open.number}"]},

             "##{open.number} Still open"

           )

    assert has_element?(

             view,

             ~s{#item_issue_number option[value="#{closed.number}"]},

             "##{closed.number} All done"

           )

    for status <- ["To Do", "In Progress", "Done"] do

      assert has_element?(view, ~s{#item_status option[value="#{status}"]}, status)

    end

  end

  test "an existing item renders as a card in its status column", %{conn: conn} do

    project = project!()

    label_fixture(%{name: "bug", color: "d73a4a"})

    {:ok, issue} = Issues.create_issue(%{"title" => "Fix the parser", "labels" => ["bug"]})

    {:ok, _item} =

      Projects.create_project_item(

        %{"issue_number" => issue.number, "values" => %{"Status" => "In Progress"}},

        project.id

      )

    {:ok, view, html} = live(conn, path(project))

    assert html =~ "Fix the parser"

    assert html =~ "bug"

    assert has_element?(

             view,

             ~s{a[href="/OpenAgentsInc/sarah/issues/#{issue.number}"]},

             "Fix the parser"

           )

  end

  test "an item with no recorded status falls back to To Do", %{conn: conn} do

    project = project!()

    {:ok, issue} = Issues.create_issue(%{"title" => "Unsorted"})

    {:ok, _item} =

      Projects.create_project_item(

        %{"issue_number" => issue.number, "values" => %{}},

        project.id

      )

    {:ok, _view, html} = live(conn, path(project))

    assert html =~ "Unsorted"

  end

  test "submitting the form adds the issue to the board", %{conn: conn} do

    project = project!()

    {:ok, issue} = Issues.create_issue(%{"title" => "Ship the runbook"})

    {:ok, view, html} = live(conn, path(project))

    refute html =~ "Ship the runbook</a>"

    html =

      view

      |> form("#new-project-item-form",

        item: %{issue_number: to_string(issue.number), status: "Done"}

      )

      |> render_submit()

    assert html =~ "Issue added to project"

    assert has_element?(

             view,

             ~s{a[href="/OpenAgentsInc/sarah/issues/#{issue.number}"]},

             "Ship the runbook"

           )

    assert [item] = Projects.list_project_items(project.id)

    assert item.issue_id == issue.id

    assert item.values == %{"Status" => "Done"}

  end

  test "a fixture-built item lands in the column named by its Status value", %{conn: conn} do

    project = project!()

    {:ok, issue} = Issues.create_issue(%{"title" => "Fixture-placed"})

    item =

      project_item_fixture(%{

        project_id: project.id,

        issue_id: issue.id,

        values: %{"Status" => "Done"}

      })

    assert item.project_id == project.id

    {:ok, view, _html} = live(conn, path(project))

    # Cards are grouped by column; the "Done" column is the third section.

    assert has_element?(

             view,

             ~s{section:nth-of-type(3) a[href="/OpenAgentsInc/sarah/issues/#{issue.number}"]},

             "Fixture-placed"

           )