Fix tests

Author: vtm9

apps/codebattle/assets/js/widgets/middlewares/GroupTournament.js

@@ -12,6 +12,21 @@ export const setTournamentChannel = (tournamentId) => {
   return channel.setupChannel(newChannelName);
 };
 
+const applyInviteUpdate = (dispatch, payload) => {
+  const normalizedData = camelizeKeys(payload);
+  const invite = normalizedData.invite;
+  const externalSetup = normalizedData.externalSetup;
+  const platformError = normalizedData.platformError || null;
+
+  dispatch(actions.updateInviteState(invite.state));
+
+  if (invite.inviteLink) {
+    dispatch(actions.updateInviteLink(invite.inviteLink));
+  }
+
+  dispatch(actions.updateGroupTournamentData({ externalSetup, platformError }));
+};
+
 export const connectToTournament = (currentUserId) => (dispatch) => {
   if (!channel) {
     console.error("Channel not initialized");
@@ -84,6 +99,11 @@ export const connectToTournament = (currentUserId) => (dispatch) => {
     }
   };
 
+  const handleInviteUpdated = (response) => {
+    applyInviteUpdate(dispatch, response);
+  };
+
+  channel.addListener("group_tournament:invite_updated", handleInviteUpdated);
   channel.addListener(channelTopics.groupTournamentRunUpdated, handleRunUpdated);
 
   return channel;
@@ -98,18 +118,7 @@ export const requestInviteUpdate = () => (dispatch) => {
   channel
     .push(channelMethods.requestInviteUpdate, {})
     .receive("ok", (data) => {
-      const normalizedData = camelizeKeys(data);
-      const invite = normalizedData.invite;
-      const externalSetup = normalizedData.externalSetup;
-      const platformError = normalizedData.platformError || null;
-
-      dispatch(actions.updateInviteState(invite.state));
-
-      if (invite.inviteLink) {
-        dispatch(actions.updateInviteLink(invite.inviteLink));
-      }
-
-      dispatch(actions.updateGroupTournamentData({ externalSetup, platformError }));
+      applyInviteUpdate(dispatch, data);
     })
     .receive("error", (error) => {
       console.error("Request invite update failed", error);

apps/codebattle/lib/codebattle/external_platform_invite/advancer.ex

@@ -12,18 +12,31 @@ defmodule Codebattle.ExternalPlatformInvite.Advancer do
 
   @spec advance(map(), map()) :: map()
   def advance(invite, user) do
+    advance(invite, user, 3)
+  end
+
+  defp advance(invite, _user, 0), do: invite
+
+  defp advance(invite, user, attempts_left) do
     alias_name = invite_alias(user)
 
     case invite.state do
-      "pending" -> try_advance(InviteContext.send_invite(invite, alias_name), invite)
-      "creating" -> try_advance(InviteContext.poll_status(invite), invite)
-      "invited" -> try_advance(InviteContext.check_accepted(invite, invite_login(user)), invite)
+      "pending" -> try_advance(InviteContext.send_invite(invite, alias_name), invite, user, attempts_left)
+      "creating" -> try_advance(InviteContext.poll_status(invite), invite, user, attempts_left)
+      "invited" -> try_advance(InviteContext.check_accepted(invite, invite_login(user)), invite, user, attempts_left)
       _ -> invite
     end
   end
 
-  defp try_advance({:ok, updated}, _invite), do: updated
-  defp try_advance({:error, _}, invite), do: invite
+  defp try_advance({:ok, updated}, invite, user, attempts_left) do
+    if updated.state == invite.state do
+      updated
+    else
+      advance(updated, user, attempts_left - 1)
+    end
+  end
+
+  defp try_advance({:error, _}, invite, _user, _attempts_left), do: invite
 
   defp invite_alias(%{external_oauth_login: login}) when is_binary(login) and login != "", do: login
   defp invite_alias(%{name: name}) when is_binary(name) and name != "", do: name

apps/codebattle/lib/codebattle/group_task/context.ex

@@ -417,9 +417,12 @@ defmodule Codebattle.GroupTask.Context do
   end
 
   defp do_update_runs(runs, status, result) do
+    ranking = extract_ranking(result)
+
     Repo.transaction(fn ->
       runs
-      |> Enum.reduce_while([], fn run, acc -> update_run(run, acc, status, result) end)
+      |> Repo.preload(:user_group_tournament)
+      |> Enum.reduce_while([], fn run, acc -> update_run(run, acc, status, result, ranking) end)
       |> Enum.reverse()
     end)
   end
@@ -441,13 +444,28 @@ defmodule Codebattle.GroupTask.Context do
     |> maybe_continue_transaction(acc)
   end
 
-  defp update_run(run, acc, status, result) do
+  defp update_run(run, acc, status, result, ranking) do
+    user_id = run.user_group_tournament.user_id
+    score = extract_score_for_user(ranking, user_id)
+
     run
-    |> UserGroupTournamentRun.changeset(%{status: status, result: result})
+    |> UserGroupTournamentRun.changeset(%{status: status, result: result, score: score})
     |> Repo.update()
     |> maybe_continue_transaction(acc)
   end
 
+  defp extract_ranking(%{"summary" => %{"ranking" => ranking}}) when is_list(ranking), do: ranking
+  defp extract_ranking(_), do: []
+
+  defp extract_score_for_user([], _user_id), do: nil
+
+  defp extract_score_for_user(ranking, user_id) do
+    case Enum.find(ranking, fn entry -> entry["player_id"] == user_id end) do
+      %{"score" => score} when is_integer(score) -> score
+      _ -> nil
+    end
+  end
+
   defp maybe_continue_transaction({:ok, run}, acc), do: {:cont, [run | acc]}
   defp maybe_continue_transaction({:error, changeset}, _acc), do: Repo.rollback(changeset)
 

apps/codebattle/lib/codebattle/tournament/strategy/base.ex

@@ -1327,7 +1327,7 @@ defmodule Codebattle.Tournament.Base do
         tournament
       end
 
-      defp maybe_save_event_results(%{event_id: _event_id} = tournament) do
+      defp maybe_save_event_results(%{event_id: event_id} = tournament) when not is_nil(event_id) do
         Codebattle.UserEvent.Stage.Context.save_tournament_results_async(tournament.id)
         tournament
       end

apps/codebattle/lib/codebattle/user_group_tournament_run.ex

@@ -22,6 +22,7 @@ defmodule Codebattle.UserGroupTournamentRun do
     field(:player_ids, {:array, :integer}, default: [])
     field(:status, :string)
     field(:result, :map, default: %{})
+    field(:score, :integer)
 
     timestamps()
   end
@@ -35,7 +36,8 @@ defmodule Codebattle.UserGroupTournamentRun do
       :run_key,
       :player_ids,
       :status,
-      :result
+      :result,
+      :score
     ])
     |> validate_required([
       :user_group_tournament_id,

apps/codebattle/lib/codebattle_web/channels/group_tournament_channel.ex

@@ -41,6 +41,8 @@ defmodule CodebattleWeb.GroupTournamentChannel do
     {user, platform_error} = maybe_ensure_platform_credentials(current_user, invite, group_tournament)
     external_setup = maybe_ensure_external_setup(user, group_tournament, invite)
 
+    maybe_schedule_invite_refresh(socket, tournament_id, invite)
+
     {:ok,
      %{
        status: group_tournament.state,
@@ -76,6 +78,32 @@ defmodule CodebattleWeb.GroupTournamentChannel do
     {:noreply, socket}
   end
 
+  def handle_info({:refresh_invite, tournament_id, retries_left}, socket) do
+    current_user = socket.assigns.current_user
+    group_tournament = GroupTournamentContext.get_group_tournament!(tournament_id)
+
+    invite =
+      current_user.id
+      |> InviteContext.get_or_create_invite(tournament_id)
+      |> InviteAdvancer.advance(current_user)
+
+    if invite.state in ["creating", "pending"] do
+      maybe_schedule_invite_refresh(socket, tournament_id, invite, retries_left)
+      {:noreply, socket}
+    else
+      {user, platform_error} = maybe_ensure_platform_credentials(current_user, invite, group_tournament)
+      external_setup = maybe_ensure_external_setup(user, group_tournament, invite)
+
+      push(socket, "group_tournament:invite_updated", %{
+        invite: serialize_invite(invite),
+        platform_error: platform_error,
+        external_setup: serialize_external_setup(external_setup, user, group_tournament)
+      })
+
+      {:noreply, socket}
+    end
+  end
+
   def handle_info(_message, socket) do
     {:noreply, socket}
   end
@@ -89,6 +117,9 @@ defmodule CodebattleWeb.GroupTournamentChannel do
       |> InviteAdvancer.advance(current_user)
 
     {user, platform_error} = maybe_ensure_platform_credentials(current_user, invite, group_tournament)
+    response = serialize_invite_reply(user, group_tournament, invite, platform_error)
+
+    maybe_schedule_invite_refresh(socket, tournament_id, invite)
 
     socket =
       if invite.state == "accepted" do
@@ -97,7 +128,7 @@ defmodule CodebattleWeb.GroupTournamentChannel do
         socket
       end
 
-    {:reply, {:ok, serialize_invite_reply(user, group_tournament, invite, platform_error)}, socket}
+    {:reply, {:ok, response}, socket}
   end
 
   defp extract_tournament_id("group_tournament:" <> tournament_id) do
@@ -205,4 +236,15 @@ defmodule CodebattleWeb.GroupTournamentChannel do
       _ -> :error
     end
   end
+
+  defp maybe_schedule_invite_refresh(socket, tournament_id, invite),
+    do: maybe_schedule_invite_refresh(socket, tournament_id, invite, 15)
+
+  defp maybe_schedule_invite_refresh(socket, tournament_id, %{state: state}, retries_left)
+       when state in ["creating", "pending"] and retries_left > 0 do
+    Process.send_after(self(), {:refresh_invite, tournament_id, retries_left - 1}, 1_000)
+    socket
+  end
+
+  defp maybe_schedule_invite_refresh(socket, _tournament_id, _invite, _retries_left), do: socket
 end

apps/codebattle/priv/repo/migrations/20260419110000_add_score_to_user_group_tournament_runs.exs

@@ -0,0 +1,10 @@
+defmodule Codebattle.Repo.Migrations.AddScoreToUserGroupTournamentRuns do
+  @moduledoc false
+  use Ecto.Migration
+
+  def change do
+    alter table(:user_group_tournament_runs) do
+      add(:score, :integer)
+    end
+  end
+end

apps/codebattle/test/codebattle/external_platform_test.exs

@@ -4,11 +4,13 @@ defmodule Codebattle.ExternalPlatformTest do
   alias Codebattle.ExternalPlatform
 
   setup do
+    original_adapter = Application.get_env(:codebattle, :external_platform_adapter)
     original_service_url = Application.get_env(:codebattle, :external_platform_service_url)
     original_org_slug = Application.get_env(:codebattle, :external_platform_org_slug)
     original_auth_req_options = Application.get_env(:codebattle, :auth_req_options)
 
     on_exit(fn ->
+      Application.put_env(:codebattle, :external_platform_adapter, original_adapter)
       Application.put_env(:codebattle, :external_platform_service_url, original_service_url)
       Application.put_env(:codebattle, :external_platform_org_slug, original_org_slug)
       Application.put_env(:codebattle, :auth_req_options, original_auth_req_options)
@@ -18,6 +20,7 @@ defmodule Codebattle.ExternalPlatformTest do
   end
 
   test "create_invite returns an error tuple when external platform url is invalid" do
+    Application.put_env(:codebattle, :external_platform_adapter, nil)
     Application.put_env(:codebattle, :external_platform_service_url, "value")
     Application.put_env(:codebattle, :external_platform_org_slug, "value")
     Application.put_env(:codebattle, :auth_req_options, [])

apps/codebattle/test/codebattle/user_group_tournament/context_test.exs

@@ -63,7 +63,7 @@ defmodule Codebattle.UserGroupTournament.ContextTest do
     assert record.repo_state == "completed"
     assert record.role_state == "completed"
     assert record.secret_state == "completed"
-    assert record.repo_url == "https://external.platform/test-org/source-repo-ext-user"
+    assert record.repo_url == "https://fake-platform.test/test-org/source-repo-ext-user"
     assert Context.repo_slug_for(user, group_tournament) == "source-repo-ext-user"
     assert record.secret_key == "CODEBATTLE_AUTH_TOKEN"
     assert record.secret_group == "ci"

apps/codebattle/test/codebattle_web/channels/group_tournament_channel_test.exs

@@ -30,16 +30,18 @@ defmodule CodebattleWeb.GroupTournamentChannelTest do
     {:ok, %{socket: socket, topic: topic, user: user}}
   end
 
-  test "join sends a pending invite and returns it", %{socket: socket, topic: topic, user: user} do
+  test "join returns a ready invite and returns it", %{socket: socket, topic: topic, user: user} do
     {:ok, response, _socket} = subscribe_and_join(socket, GroupTournamentChannel, topic)
 
-    assert %{invite: %{state: "creating", response: %{"operation_id" => "op-123"}}} = response
+    assert %{invite: %{state: "invited", invite_link: invite_link}} = response
+    assert String.starts_with?(invite_link, "https://fake-platform.test/invite/")
 
     tournament_id = topic |> String.split(":") |> List.last() |> String.to_integer()
     invite = InviteContext.get_invite(user.id, tournament_id)
 
-    assert invite.state == "creating"
-    assert invite.operation_id == "op-123"
+    assert invite.state == "invited"
+    assert String.starts_with?(invite.operation_id, "fake-op-")
+    assert String.starts_with?(invite.invite_link, "https://fake-platform.test/invite/")
   end
 
   test "join rejects an invalid tournament id", %{socket: socket} do