Gateway tests

apps/game_backend/lib/game_backend/units.ex

@@ -137,7 +137,7 @@ defmodule GameBackend.Units do
   def delete_unit(id), do: Repo.get(Unit, id) |> delete_unit()
 
   @doc """
-  Deletes all units in a given list.
+  Deletes all units in a list by ids.
   """
   def delete_units(unit_ids), do: Repo.delete_all(from(u in Unit, where: u.id in ^unit_ids))
 

apps/gateway/test/champions_test.exs

@@ -0,0 +1,251 @@
+defmodule Gateway.Test.Champions do
+  @moduledoc """
+  Test for Champions of Mirra messages.
+  """
+  use ExUnit.Case
+
+  alias Champions.{Units, Users, Utils}
+  alias GameBackend.Repo
+  alias GameBackend.Users.Currencies.CurrencyCost
+  alias GameBackend.Users.Currencies
+
+  alias Gateway.Serialization.{
+    Currency,
+    Error,
+    Unit,
+    UnitAndCurrencies,
+    User,
+    UserCurrency,
+    WebSocketResponse
+  }
+
+  alias Gateway.SocketTester
+
+  setup_all do
+    # Start Phoenix endpoint
+    {:ok, _} =
+      Plug.Cowboy.http(Gateway.Endpoint, [],
+        ip: {127, 0, 0, 1},
+        port: 4001,
+        dispatch: [
+          _: [{"/2", Gateway.ChampionsSocketHandler, []}]
+        ]
+      )
+
+    :ok
+  end
+
+  setup do
+    {:ok, socket_tester} = SocketTester.start_link()
+
+    {:ok, %{socket_tester: socket_tester}}
+  end
+
+  describe "users" do
+    test "users", %{socket_tester: socket_tester} do
+      username = "Username"
+
+      # Create our user
+      :ok = SocketTester.create_user(socket_tester, username)
+      fetch_last_message(socket_tester)
+      %WebSocketResponse{response_type: {:user, %User{} = user}} = get_last_message()
+
+      assert user.username == username
+
+      # Creating another user with the same name fails
+      :ok = SocketTester.create_user(socket_tester, username)
+      fetch_last_message(socket_tester)
+      assert_receive %WebSocketResponse{response_type: {:error, %Error{reason: "username_taken"}}}
+
+      # Get user by name
+      :ok = SocketTester.get_user_by_username(socket_tester, username)
+      fetch_last_message(socket_tester)
+      assert_receive %WebSocketResponse{response_type: {:user, ^user}}
+    end
+  end
+
+  describe "units" do
+    test "unit selection", %{socket_tester: socket_tester} do
+      {:ok, user} = Users.register("SelectUser")
+
+      [unit_to_unselect | _] = user.units
+      slot = unit_to_unselect.slot
+
+      # Unit is selected by default (this will change when we remove sample data in user creation)
+      assert unit_to_unselect.selected
+
+      # Unselect the unit
+      :ok = SocketTester.unselect_unit(socket_tester, user.id, unit_to_unselect.id)
+      fetch_last_message(socket_tester)
+      %WebSocketResponse{response_type: {:unit, %Unit{} = unselected_unit}} = get_last_message()
+
+      assert not unselected_unit.selected
+      # Protobuf doesn't support nil values, returns zero instead
+      assert unselected_unit.slot == 0
+      assert unselected_unit.id == unit_to_unselect.id
+
+      :ok = SocketTester.select_unit(socket_tester, user.id, unselected_unit.id, slot)
+      fetch_last_message(socket_tester)
+      %WebSocketResponse{response_type: {:unit, %Unit{} = selected_unit}} = get_last_message()
+
+      assert selected_unit.selected
+      assert selected_unit.slot == slot
+    end
+
+    test "unit progression", %{socket_tester: socket_tester} do
+      muflus = GameBackend.Units.Characters.get_character_by_name("Muflus")
+      {:ok, user} = Users.register("LevelUpUser")
+      Currencies.add_currency_by_name!(user.id, "Gold", 9999)
+
+      {:ok, unit} =
+        GameBackend.Units.insert_unit(%{
+          user_id: user.id,
+          level: 19,
+          tier: 1,
+          rank: 2,
+          selected: false,
+          character_id: muflus.id
+        })
+
+      gold = Currencies.get_amount_of_currency_by_name(user.id, "Gold")
+      level = unit.level
+
+      #### Level up
+      [%CurrencyCost{currency_id: _gold_id, amount: level_up_cost}] = Units.calculate_level_up_cost(unit)
+
+      :ok = SocketTester.level_up_unit(socket_tester, user.id, unit.id)
+      fetch_last_message(socket_tester)
+
+      %WebSocketResponse{
+        response_type: {:unit_and_currencies, %UnitAndCurrencies{unit: unit, user_currency: [user_currency]}}
+      } = get_last_message()
+
+      assert unit.level == level + 1
+      assert user_currency.currency.name == "Gold"
+      assert user_currency.amount == gold - level_up_cost
+
+      # Cannot level up because unit is level 20 with tier 1
+      assert unit.level == 20
+      assert unit.tier == 1
+      :ok = SocketTester.level_up_unit(socket_tester, user.id, unit.id)
+      fetch_last_message(socket_tester)
+      assert_receive %WebSocketResponse{response_type: {:error, %Error{reason: "cant_level_up"}}}
+
+      #### Tier up
+
+      user_gold = Currencies.get_amount_of_currency_by_name(user.id, "Gold")
+      user_gems = Currencies.get_amount_of_currency_by_name(user.id, "Gems")
+
+      [%CurrencyCost{currency_id: _gold_id, amount: gold_cost}, %CurrencyCost{currency_id: _gems_id, amount: gems_cost}] =
+        Units.calculate_tier_up_cost(unit)
+
+      :ok = SocketTester.tier_up_unit(socket_tester, user.id, unit.id)
+      fetch_last_message(socket_tester)
+
+      %WebSocketResponse{
+        response_type: {:unit_and_currencies, %UnitAndCurrencies{unit: unit, user_currency: user_currencies}}
+      } = get_last_message()
+
+      user_currencies =
+        Enum.into(user_currencies, %{}, fn %UserCurrency{
+                                             currency: %Currency{name: name},
+                                             amount: amount
+                                           } ->
+          {name, amount}
+        end)
+
+      assert unit.level == 20
+      assert unit.tier == 2
+      assert user_currencies["Gold"] == user_gold - gold_cost
+      assert user_currencies["Gems"] == user_gems - gems_cost
+
+      # TODO: Check that we can now level up
+
+      #### Rank up (fuse)
+
+      {:ok, unit} =
+        GameBackend.Units.insert_unit(%{
+          user_id: user.id,
+          level: 220,
+          tier: 8,
+          rank: Units.get_rank(:star5),
+          selected: false,
+          character_id: muflus.id
+        })
+
+      unit = Repo.preload(unit, [:character])
+
+      rank = unit.rank
+      user_units_count = user.id |> GameBackend.Units.get_units() |> Enum.count()
+
+      # Add to-be-consumed units
+
+      {:ok, same_faction_character} =
+        GameBackend.Units.Characters.insert_character(%{
+          game_id: Utils.game_id(),
+          active: true,
+          name: "SameFactionUnit",
+          faction: muflus.faction,
+          quality: Champions.Units.get_quality(:rare)
+        })
+
+      # We will need three 5* Muflus and two i2 of the same faction
+      # For the same faction, we will do one of each unit.
+      units_to_consume = create_units_to_consume(user, muflus, same_faction_character)
+
+      # Characters need a certain quality to rank up
+      assert unit.character.quality == Units.get_quality(:epic)
+
+      # TODO: Check that we cant tier up again without ranking up
+
+      :ok = SocketTester.fuse_unit(socket_tester, user.id, unit.id, units_to_consume)
+      fetch_last_message(socket_tester)
+
+      %WebSocketResponse{
+        response_type: {:unit, %Unit{} = unit}
+      } = get_last_message()
+
+      assert unit.rank == rank + 1
+      assert user_units_count == user.id |> GameBackend.Units.get_units() |> Enum.count()
+    end
+  end
+
+  defp get_last_message() do
+    receive do
+      message ->
+        message
+    after
+      5000 ->
+        raise "No message"
+    end
+  end
+
+  defp fetch_last_message(socket_tester) do
+    :timer.sleep(50)
+    send(socket_tester, {:last_message, self()})
+  end
+
+  defp create_units_to_consume(user, same_character, same_faction) do
+    params = %{
+      user_id: user.id,
+      level: 100,
+      tier: 5,
+      rank: Units.get_rank(:star5),
+      selected: false
+    }
+
+    same_character_ids =
+      Enum.map(1..3, fn _ ->
+        {:ok, unit} = params |> Map.put(:character_id, same_character.id) |> GameBackend.Units.insert_unit()
+        unit.id
+      end)
+
+    same_faction_ids =
+      Enum.map(1..2, fn _ ->
+        {:ok, unit} = params |> Map.put(:character_id, same_faction.id) |> GameBackend.Units.insert_unit()
+        unit.id
+      end)
+
+    same_character_ids ++ same_faction_ids
+  end
+end

apps/gateway/lib/gateway/socket_tester.ex → apps/gateway/test/support/socket_tester.ex

@@ -1,4 +1,4 @@
-defmodule SocketTester do
+defmodule Gateway.SocketTester do
   @moduledoc """
   Module for manually testing the CoM websocket.
   Logs received messages and keeps the last one received in the state.

mix.exs

@@ -26,7 +26,7 @@ defmodule MirraBackend.MixProject do
       setup: ["deps.get", "ecto.setup"],
       "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
       "ecto.reset": ["ecto.drop", "ecto.setup"],
-      test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"]
+      test: ["ecto.reset --quiet", "ecto.migrate --quiet", "run priv/repo/seeds.exs", "test"]
     ]
   end
 end