Delete test/plausible/auth/user_sessions_test.exs with huggingface_hub

test/plausible/auth/user_sessions_test.exs

@@ -1,550 +0,0 @@
-defmodule Plausible.Auth.UserSessionsTest do
-  use Plausible.DataCase, async: true
-
-  import Phoenix.ChannelTest
-
-  alias Plausible.Auth
-  alias Plausible.Auth.UserSessions
-  alias Plausible.Repo
-
-  describe "list_for_user/2" do
-    test "lists user sessions" do
-      user = insert(:user)
-
-      now = NaiveDateTime.utc_now(:second)
-      thirty_minutes_ago = NaiveDateTime.shift(now, minute: -30)
-      ten_hours_ago = NaiveDateTime.shift(now, hour: -10)
-      ten_days_ago = NaiveDateTime.shift(now, day: -10)
-      twenty_days_ago = NaiveDateTime.shift(now, day: -20)
-
-      recent_session = insert_session(user, "Recent Device", thirty_minutes_ago)
-      old_session = insert_session(user, "Old Device", ten_hours_ago)
-      older_session = insert_session(user, "Older Device", ten_days_ago)
-      _expired_session = insert_session(user, "Expired Device", twenty_days_ago)
-      _rogue_session = insert_session(insert(:user), "Unrelated device", now)
-
-      assert [session1, session2, session3] = UserSessions.list_for_user(user, now)
-
-      assert session1.id == recent_session.id
-      assert session2.id == old_session.id
-      assert session3.id == older_session.id
-    end
-  end
-
-  describe "count_for_users/2" do
-    test "counts user sessions" do
-      now = NaiveDateTime.utc_now(:second)
-      thirty_minutes_ago = NaiveDateTime.shift(now, minute: -30)
-
-      u1 = insert(:user)
-      u2 = insert(:user)
-      u3 = insert(:user)
-
-      insert_session(u1, "Recent Device", thirty_minutes_ago)
-      insert_session(u1, "Recent Device 2", thirty_minutes_ago)
-      insert_session(u2, "Recent Device", thirty_minutes_ago)
-
-      assert UserSessions.count_for_users([u1, u2, u3], now) == [{u1.id, 2}, {u2.id, 1}]
-    end
-  end
-
-  on_ee do
-    describe "list_for_sso_team/1,2" do
-      test "lists only SSO member sessions for a given team" do
-        %{team: sso_team, site: site, sso_integration: sso_integration} =
-          setup_do(&create_user/1)
-          |> setup_do(&create_team/1)
-          |> setup_do(&create_site/1)
-          |> setup_do(&setup_sso/1)
-
-        %{team: _other_sso_team, sso_integration: other_sso_integration} =
-          %{domain: "example2.com"}
-          |> setup_do(&create_user/1)
-          |> setup_do(&create_team/1)
-          |> setup_do(&setup_sso/1)
-
-        %{team: _other_team, user: other_member} =
-          setup_do(&create_user/1)
-          |> setup_do(&create_team/1)
-
-        add_guest(site, user: other_member, role: :editor)
-        _other_member_session = Auth.UserSessions.create!(other_member, "Unknown")
-
-        %{user: sso_member} =
-          %{
-            user: %{name: "Jerry Wane", email: "wane@example.com"},
-            sso_integration: sso_integration
-          }
-          |> setup_do(&provision_sso_user/1)
-
-        now = NaiveDateTime.utc_now(:second)
-
-        sso_member_session =
-          insert_session(sso_member, "Unknown", NaiveDateTime.add(now, -1, :hour))
-
-        %{user: sso_member2} =
-          %{
-            user: %{name: "Joan McGuire", email: "joan@example.com"},
-            sso_integration: sso_integration
-          }
-          |> setup_do(&provision_sso_user/1)
-
-        sso_member2_session1 =
-          insert_session(sso_member2, "Unknown", NaiveDateTime.add(now, -2, :hour))
-
-        sso_member2_session2 = insert_session(sso_member2, "Unknown", now)
-
-        in_the_past = NaiveDateTime.add(NaiveDateTime.utc_now(:second), -1, :hour)
-
-        _sso_member2_session_past =
-          Auth.UserSessions.create!(sso_member2, "Unknown", timeout_at: in_the_past)
-
-        team = new_site().team
-        standard_member = add_member(team, role: :editor)
-        _standard_member_session = insert_session(standard_member, "Unknown", now)
-
-        %{user: other_sso_member} =
-          %{
-            user: %{name: "Veronica Dogwright", email: "veronica@example2.com"},
-            sso_integration: other_sso_integration
-          }
-          |> setup_do(&provision_sso_user/1)
-
-        _other_sso_member_session = insert_session(other_sso_member, "Unknown", now)
-
-        %{user: guest_sso_member} =
-          %{
-            user: %{name: "Jimmy Felon", email: "jimmy@example2.com"},
-            sso_integration: other_sso_integration
-          }
-          |> setup_do(&provision_sso_user/1)
-
-        add_guest(site, user: Repo.reload!(guest_sso_member), role: :viewer)
-
-        _guest_sso_member_session = insert_session(guest_sso_member, "Unknown", now)
-
-        assert [s1, s2, s3] = Auth.UserSessions.list_sso_for_team(sso_team)
-
-        assert s1.token == sso_member2_session2.token
-        assert s2.token == sso_member_session.token
-        assert s3.token == sso_member2_session1.token
-      end
-    end
-
-    describe "revoke_sso_by_id/2" do
-      test "deletes and disconnects user session" do
-        %{team: sso_team, sso_integration: sso_integration} =
-          setup_do(&create_user/1)
-          |> setup_do(&create_team/1)
-          |> setup_do(&setup_sso/1)
-
-        %{user: user} =
-          %{
-            user: %{name: "Jerry Wane", email: "wane@example.com"},
-            sso_integration: sso_integration
-          }
-          |> setup_do(&provision_sso_user/1)
-
-        now = NaiveDateTime.utc_now(:second)
-        active_session = insert_session(user, "Unknown", now)
-        another_session = insert_session(user, "Unknown", now)
-
-        live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)
-        Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)
-
-        assert :ok = UserSessions.revoke_sso_by_id(sso_team, active_session.id)
-
-        assert [remaining_session] = Repo.preload(user, :sessions).sessions
-        assert_broadcast "disconnect", %{}
-        assert remaining_session.id == another_session.id
-        refute Repo.reload(active_session)
-        assert Repo.reload(another_session)
-      end
-
-      test "does not delete session of user on another team" do
-        %{team: sso_team, sso_integration: sso_integration} =
-          setup_do(&create_user/1)
-          |> setup_do(&create_team/1)
-          |> setup_do(&setup_sso/1)
-
-        %{team: _other_sso_team, sso_integration: other_sso_integration} =
-          %{domain: "example2.com"}
-          |> setup_do(&create_user/1)
-          |> setup_do(&create_team/1)
-          |> setup_do(&setup_sso/1)
-
-        %{user: user} =
-          %{
-            user: %{name: "Jerry Wane", email: "wane@example.com"},
-            sso_integration: sso_integration
-          }
-          |> setup_do(&provision_sso_user/1)
-
-        now = NaiveDateTime.utc_now(:second)
-
-        active_session = insert_session(user, "Unknown", now)
-
-        %{user: other_user} =
-          %{
-            user: %{name: "Judy Wasteland", email: "judy@example2.com"},
-            sso_integration: other_sso_integration
-          }
-          |> setup_do(&provision_sso_user/1)
-
-        other_session = insert_session(other_user, "Unknown", now)
-
-        assert :ok = UserSessions.revoke_sso_by_id(sso_team, other_session.id)
-
-        assert Repo.reload(active_session)
-        assert Repo.reload(other_session)
-      end
-
-      test "does not revoke session of standard user" do
-        %{team: sso_team} =
-          setup_do(&create_user/1)
-          |> setup_do(&create_team/1)
-          |> setup_do(&setup_sso/1)
-
-        user = add_member(sso_team, role: :editor)
-
-        now = NaiveDateTime.utc_now(:second)
-        active_session = insert_session(user, "Unknown", now)
-
-        assert :ok = UserSessions.revoke_sso_by_id(sso_team, active_session.id)
-
-        assert Repo.reload(active_session)
-      end
-
-      test "does not revoke session of a guest who happens to be SSO user" do
-        %{team: sso_team, site: site} =
-          setup_do(&create_user/1)
-          |> setup_do(&create_site/1)
-          |> setup_do(&create_team/1)
-          |> setup_do(&setup_sso/1)
-
-        %{team: _other_sso_team, sso_integration: other_sso_integration} =
-          %{domain: "example2.com"}
-          |> setup_do(&create_user/1)
-          |> setup_do(&create_team/1)
-          |> setup_do(&setup_sso/1)
-
-        %{user: user} =
-          %{
-            user: %{name: "Judy Wasteland", email: "judy@example2.com"},
-            sso_integration: other_sso_integration
-          }
-          |> setup_do(&provision_sso_user/1)
-
-        user = add_guest(site, user: Repo.reload!(user), role: :editor)
-
-        now = NaiveDateTime.utc_now(:second)
-        active_session = insert_session(user, "Unknown", now)
-
-        assert :ok = UserSessions.revoke_sso_by_id(sso_team, active_session.id)
-
-        assert Repo.reload(active_session)
-      end
-
-      test "executes gracefully when session does not exist" do
-        %{team: sso_team, sso_integration: sso_integration} =
-          setup_do(&create_user/1)
-          |> setup_do(&create_team/1)
-          |> setup_do(&setup_sso/1)
-
-        %{user: user} =
-          %{
-            user: %{name: "Jerry Wane", email: "wane@example.com"},
-            sso_integration: sso_integration
-          }
-          |> setup_do(&provision_sso_user/1)
-
-        now = NaiveDateTime.utc_now(:second)
-        active_session = insert_session(user, "Unknown", now)
-
-        Repo.delete!(active_session)
-
-        assert :ok = UserSessions.revoke_sso_by_id(sso_team, active_session.id)
-      end
-    end
-  end
-
-  describe "last_used_humanize/2" do
-    test "returns humanized relative time" do
-      user = insert(:user)
-      now = NaiveDateTime.utc_now(:second)
-      thirty_minutes_ago = NaiveDateTime.shift(now, minute: -30)
-      ninety_minutes_ago = NaiveDateTime.shift(now, minute: -90)
-      ten_hours_ago = NaiveDateTime.shift(now, hour: -10)
-      twenty_seven_hours_ago = NaiveDateTime.shift(now, hour: -27)
-      fifty_hours_ago = NaiveDateTime.shift(now, hour: -50)
-      ten_days_ago = NaiveDateTime.shift(now, day: -10)
-
-      assert last_used_humanize(user, now) == "Just recently"
-      assert last_used_humanize(user, thirty_minutes_ago) == "Just recently"
-      assert last_used_humanize(user, ninety_minutes_ago) == "1 hour ago"
-      assert last_used_humanize(user, ten_hours_ago) == "10 hours ago"
-      assert last_used_humanize(user, twenty_seven_hours_ago) == "Yesterday"
-      assert last_used_humanize(user, fifty_hours_ago) == "2 days ago"
-      assert last_used_humanize(user, ten_days_ago) == "10 days ago"
-    end
-  end
-
-  describe "get_by_token/1" do
-    setup do
-      user = new_user()
-
-      session =
-        user
-        |> Auth.UserSession.new_session("A Device")
-        |> Repo.insert!()
-
-      {:ok, user: user, session: session}
-    end
-
-    test "fetches token by session", %{session: session, user: user} do
-      user |> subscribe_to_growth_plan()
-      team = team_of(user)
-      assert {:ok, fetched} = UserSessions.get_by_token(session.token)
-
-      assert fetched.id == session.id
-      assert fetched.user.id == user.id
-      assert [ownership] = fetched.user.team_memberships
-      assert ownership.role == :owner
-      assert ownership.team.id == team.id
-      assert ownership.team.subscription.id
-      assert [owner] = ownership.team.owners
-      assert owner.id == user.id
-    end
-
-    test "returns not found when no matching session found" do
-      assert {:error, :not_found} = UserSessions.get_by_token(Ecto.UUID.generate())
-    end
-
-    test "returns expired when the matching session is expired", %{session: session} do
-      now = NaiveDateTime.utc_now(:second)
-      in_the_past = NaiveDateTime.add(now, -1, :hour)
-      session = session |> Ecto.Changeset.change(timeout_at: in_the_past) |> Repo.update!()
-
-      assert {:error, :expired, expired_session} = UserSessions.get_by_token(session.token)
-      assert expired_session.id == session.id
-    end
-  end
-
-  describe "touch/1,2" do
-    setup do
-      user = new_user()
-
-      session =
-        user
-        |> Auth.UserSession.new_session("A Device")
-        |> Repo.insert!()
-
-      {:ok, user: user, session: session}
-    end
-
-    test "refreshes user session timestamps", %{user: user, session: session} do
-      two_days_later =
-        NaiveDateTime.utc_now(:second)
-        |> NaiveDateTime.shift(day: 2)
-
-      assert refreshed_session =
-               %Auth.UserSession{} = UserSessions.touch(session, two_days_later)
-
-      assert refreshed_session.id == session.id
-      assert NaiveDateTime.compare(refreshed_session.last_used_at, two_days_later) == :eq
-      assert NaiveDateTime.compare(Repo.reload(user).last_seen, two_days_later) == :eq
-      assert NaiveDateTime.compare(refreshed_session.timeout_at, session.timeout_at) == :gt
-    end
-
-    test "does not refresh if timestamps were updated less than hour before", %{
-      user: user,
-      session: session
-    } do
-      last_seen = Repo.reload(user).last_seen
-
-      fifty_minutes_later =
-        NaiveDateTime.utc_now(:second)
-        |> NaiveDateTime.shift(minute: 50)
-
-      assert refreshed_session1 =
-               %Auth.UserSession{} =
-               UserSessions.touch(session, fifty_minutes_later)
-
-      assert NaiveDateTime.compare(
-               refreshed_session1.last_used_at,
-               session.last_used_at
-             ) == :eq
-
-      assert NaiveDateTime.compare(Repo.reload(user).last_seen, last_seen) == :eq
-
-      sixty_five_minutes_later =
-        NaiveDateTime.utc_now(:second)
-        |> NaiveDateTime.shift(minute: 65)
-
-      assert refreshed_session2 =
-               %Auth.UserSession{} =
-               UserSessions.touch(session, sixty_five_minutes_later)
-
-      assert NaiveDateTime.compare(
-               refreshed_session2.last_used_at,
-               sixty_five_minutes_later
-             ) == :eq
-
-      assert NaiveDateTime.compare(Repo.reload(user).last_seen, sixty_five_minutes_later) == :eq
-    end
-
-    test "handles concurrent refresh gracefully", %{session: session} do
-      # concurrent update
-      now = NaiveDateTime.utc_now(:second)
-      two_days_later = NaiveDateTime.shift(now, day: 2)
-
-      Repo.update_all(
-        from(us in Auth.UserSession, where: us.token == ^session.token),
-        set: [timeout_at: two_days_later, last_used_at: now]
-      )
-
-      assert refreshed_session = %Auth.UserSession{} = UserSessions.touch(session)
-
-      assert refreshed_session.id == session.id
-      assert Repo.reload(session)
-    end
-
-    test "handles deleted session case gracefully", %{session: session} do
-      Repo.delete!(session)
-
-      assert refreshed_session = %Auth.UserSession{} = UserSessions.touch(session)
-
-      assert refreshed_session.id == session.id
-
-      refute Repo.reload(session)
-    end
-
-    on_ee do
-      test "only records last usage but does not refresh for SSO user", %{
-        user: user,
-        session: session
-      } do
-        sixty_five_minutes_later =
-          NaiveDateTime.utc_now(:second)
-          |> NaiveDateTime.shift(minute: 65)
-
-        user |> Ecto.Changeset.change(type: :sso) |> Repo.update!()
-
-        session = Repo.reload!(session)
-
-        assert refreshed_session =
-                 %Auth.UserSession{} =
-                 UserSessions.touch(session, sixty_five_minutes_later)
-
-        assert refreshed_session.id == session.id
-
-        assert NaiveDateTime.compare(refreshed_session.last_used_at, sixty_five_minutes_later) ==
-                 :eq
-
-        assert NaiveDateTime.compare(refreshed_session.timeout_at, session.timeout_at) == :eq
-      end
-    end
-  end
-
-  describe "revoke_by_id/2" do
-    setup do
-      user = new_user()
-
-      session =
-        user
-        |> Auth.UserSession.new_session("A Device")
-        |> Repo.insert!()
-
-      {:ok, user: user, session: session}
-    end
-
-    test "deletes and disconnects user session", %{user: user, session: active_session} do
-      live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)
-      Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)
-
-      another_session =
-        user
-        |> Auth.UserSession.new_session("Some Device")
-        |> Repo.insert!()
-
-      assert :ok = UserSessions.revoke_by_id(user, active_session.id)
-
-      assert [remaining_session] = Repo.preload(user, :sessions).sessions
-      assert_broadcast "disconnect", %{}
-      assert remaining_session.id == another_session.id
-      refute Repo.reload(active_session)
-      assert Repo.reload(another_session)
-    end
-
-    test "does not delete session of another user", %{user: user, session: active_session} do
-      other_session =
-        insert(:user)
-        |> Auth.UserSession.new_session("Some Device")
-        |> Repo.insert!()
-
-      assert :ok = UserSessions.revoke_by_id(user, other_session.id)
-
-      assert Repo.reload(active_session)
-      assert Repo.reload(other_session)
-    end
-
-    test "executes gracefully when session does not exist", %{user: user, session: active_session} do
-      Repo.delete!(active_session)
-
-      assert :ok = UserSessions.revoke_by_id(user, active_session.id)
-    end
-  end
-
-  describe "revoke_all/1,2" do
-    setup do
-      user = new_user()
-
-      session =
-        user
-        |> Auth.UserSession.new_session("A Device")
-        |> Repo.insert!()
-
-      {:ok, user: user, session: session}
-    end
-
-    test "deletes and disconnects all user's sessions", %{user: user, session: active_session} do
-      live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)
-      Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)
-
-      another_session =
-        user
-        |> Auth.UserSession.new_session("Some Device")
-        |> Repo.insert!()
-
-      unrelated_session =
-        insert(:user)
-        |> Auth.UserSession.new_session("Some Device")
-        |> Repo.insert!()
-
-      assert :ok = UserSessions.revoke_all(user)
-
-      assert [] = Repo.preload(user, :sessions).sessions
-      assert_broadcast "disconnect", %{}
-      refute Repo.reload(another_session)
-      assert Repo.reload(unrelated_session)
-    end
-
-    test "executes gracefully when user has no sessions" do
-      user = insert(:user)
-
-      assert :ok = UserSessions.revoke_all(user)
-    end
-  end
-
-  defp last_used_humanize(user, dt) do
-    user
-    |> insert_session("Some Device", dt)
-    |> UserSessions.last_used_humanize()
-  end
-
-  defp insert_session(user, device_name, now) do
-    user
-    |> Auth.UserSession.new_session(device_name, now: now)
-    |> Repo.insert!()
-  end
-end