neiam /gitgud

defmodule GitGud.OrganizationVisibilityTest do
  use GitGud.DataCase, async: false

  alias GitGud.Organizations
  alias GitGud.Organizations.Organization
  alias GitGud.Repositories

  import GitGud.AccountsFixtures

  describe "visibility hierarchy" do
    test "rank: public < internal < private" do
      assert Organization.visibility_rank("public") == 0
      assert Organization.visibility_rank("internal") == 1
      assert Organization.visibility_rank("private") == 2
    end
  end

  describe "create_repository_for_org/3 enforces org visibility" do
    setup do
      admin = user_fixture()
      {:ok, public_org} = Organizations.create_organization(admin, %{"handle" => "vis-pub", "visibility" => "public"})
      {:ok, internal_org} = Organizations.create_organization(admin, %{"handle" => "vis-int", "visibility" => "internal"})
      {:ok, private_org} = Organizations.create_organization(admin, %{"handle" => "vis-priv", "visibility" => "private"})
      {:ok, admin: admin, public: public_org, internal: internal_org, private: private_org}
    end

    test "public org accepts any visibility", %{admin: admin, public: org} do
      for v <- ~w(public internal private) do
        assert {:ok, _} =
                 Repositories.create_repository_for_org(org, admin, %{
                   "name" => "r-" <> v,
                   "visibility" => v
                 })
      end
    end

    test "internal org rejects public repos but allows internal/private", %{admin: admin, internal: org} do
      assert {:error, {:visibility_too_open, "internal"}} =
               Repositories.create_repository_for_org(org, admin, %{"name" => "r-x", "visibility" => "public"})

      assert {:ok, _} =
               Repositories.create_repository_for_org(org, admin, %{"name" => "r-y", "visibility" => "internal"})

      assert {:ok, _} =
               Repositories.create_repository_for_org(org, admin, %{"name" => "r-z", "visibility" => "private"})
    end

    test "private org only allows private repos", %{admin: admin, private: org} do
      assert {:error, {:visibility_too_open, "private"}} =
               Repositories.create_repository_for_org(org, admin, %{"name" => "r-p1", "visibility" => "public"})

      assert {:error, {:visibility_too_open, "private"}} =
               Repositories.create_repository_for_org(org, admin, %{"name" => "r-p2", "visibility" => "internal"})

      assert {:ok, _} =
               Repositories.create_repository_for_org(org, admin, %{"name" => "r-p3", "visibility" => "private"})
    end
  end

  describe "update_organization_visibility/2 cascades" do
    test "tightening to private bumps all over-public repos" do
      admin = user_fixture()
      {:ok, org} = Organizations.create_organization(admin, %{"handle" => "vis-cas", "visibility" => "public"})

      {:ok, pub_repo} =
        Repositories.create_repository_for_org(org, admin, %{"name" => "open", "visibility" => "public"})

      {:ok, int_repo} =
        Repositories.create_repository_for_org(org, admin, %{"name" => "mid", "visibility" => "internal"})

      {:ok, priv_repo} =
        Repositories.create_repository_for_org(org, admin, %{"name" => "tight", "visibility" => "private"})

      {:ok, _} = Organizations.update_organization_visibility(org, "private")

      assert Repo.get!(GitGud.Repositories.Repository, pub_repo.id).visibility == "private"
      assert Repo.get!(GitGud.Repositories.Repository, int_repo.id).visibility == "private"
      # Already private — unchanged.
      assert Repo.get!(GitGud.Repositories.Repository, priv_repo.id).visibility == "private"
    end

    test "tightening to internal leaves private repos alone" do
      admin = user_fixture()
      {:ok, org} = Organizations.create_organization(admin, %{"handle" => "vis-cas2", "visibility" => "public"})

      {:ok, pub_repo} =
        Repositories.create_repository_for_org(org, admin, %{"name" => "open", "visibility" => "public"})

      {:ok, priv_repo} =
        Repositories.create_repository_for_org(org, admin, %{"name" => "tight", "visibility" => "private"})

      {:ok, _} = Organizations.update_organization_visibility(org, "internal")

      assert Repo.get!(GitGud.Repositories.Repository, pub_repo.id).visibility == "internal"
      assert Repo.get!(GitGud.Repositories.Repository, priv_repo.id).visibility == "private"
    end

    test "loosening doesn't change repos" do
      admin = user_fixture()
      {:ok, org} = Organizations.create_organization(admin, %{"handle" => "vis-cas3", "visibility" => "private"})

      {:ok, repo} =
        Repositories.create_repository_for_org(org, admin, %{"name" => "tight", "visibility" => "private"})

      {:ok, _} = Organizations.update_organization_visibility(org, "public")
      assert Repo.get!(GitGud.Repositories.Repository, repo.id).visibility == "private"
    end
  end

  describe "Organizations.member?/2" do
    test "true when membership exists, false otherwise" do
      admin = user_fixture()
      outsider = user_fixture()
      {:ok, org} = Organizations.create_organization(admin, %{"handle" => "mem-test"})

      assert Organizations.member?(org, admin)
      refute Organizations.member?(org, outsider)
      refute Organizations.member?(org, nil)
    end
  end
end