EventHubBack/test/api/api_test_runner.erl

-module(api_test_runner).
-export([run_all/0, run/1]).
-export([http_post/2, http_post/3, http_get/1, http_get/2, http_put/3, http_delete/2]).
-export([extract_json/2, extract_json/3, assert_status/2]).
-export([unique_email/1, register_and_login/2, create_calendar/2, create_event/3]).
-export([get_admin_token/0, get_admin_id/0, get_user_token/0, get_user_id/0]).
-export([wait_for_server/0]).

-define(BASE_URL, "http://localhost:8080").
-define(ADMIN_URL, "http://localhost:8445").

%% ============ Глобальные переменные для тестов ============
-define(ADMIN_EMAIL, <<"global_admin@test.com">>).
-define(ADMIN_PASSWORD, <<"admin123">>).
-define(USER_EMAIL, <<"global_user@test.com">>).
-define(USER_PASSWORD, <<"user123">>).

%% ============ Инициализация ============
init_global_users() ->
  case get(admin_token) of
    undefined ->
      io:format("~n=== Initializing global test users ===~n"),

      % Создаём или логиним админа
      AdminToken = register_and_login(?ADMIN_EMAIL, ?ADMIN_PASSWORD),
      {ok, {{_, 200, _}, _, MeResp}} = http_get("/v1/user/me", AdminToken),
      #{<<"id">> := AdminId, <<"role">> := Role} = jsx:decode(list_to_binary(MeResp), [return_maps]),

      io:format("Admin ID: ~s, Current role: ~s~n", [AdminId, Role]),

      % Проверяем, что админ действительно админ
      case Role of
        <<"admin">> ->
          io:format("✓ Admin already has admin role~n"),
          ok;
        _ ->
          io:format("⚠ Admin role is '~s', attempting to promote...~n", [Role]),
          promote_to_admin(AdminToken, AdminId)
      end,

      put(admin_token, AdminToken),
      put(admin_id, AdminId),

      % Создаём или логиним обычного пользователя
      UserToken = register_and_login(?USER_EMAIL, ?USER_PASSWORD),
      {ok, {{_, 200, _}, _, UserMeResp}} = http_get("/v1/user/me", UserToken),
      #{<<"id">> := UserId} = jsx:decode(list_to_binary(UserMeResp), [return_maps]),

      put(user_token, UserToken),
      put(user_id, UserId),

      io:format("User ID: ~s~n", [UserId]),
      io:format("=== Global users initialized ===~n~n"),
      ok;
    _ ->
      io:format("Global users already initialized.~n"),
      ok
  end.

%% Попытка повысить роль через разные методы
promote_to_admin(AdminToken, AdminId) ->
  io:format("Attempting to promote user ~s to admin...~n", [AdminId]),

  % Метод 1: Прямое обновление через core_user (если доступно)
  try
    {ok, _User} = core_user:get_by_id(AdminId),
    core_user:update(AdminId, [{role, admin}]),
    io:format("✓ Promoted via core_user~n")
  catch
    _:_ ->
      io:format("  Method 1 (core_user) failed~n")
  end,

  % Проверяем, сработало ли
  {ok, {{_, 200, _}, _, CheckResp}} = http_get("/v1/user/me", AdminToken),
  #{<<"role">> := NewRole} = jsx:decode(list_to_binary(CheckResp), [return_maps]),

  case NewRole of
    <<"admin">> ->
      io:format("✓ User is now admin~n");
    _ ->
      io:format("⚠ WARNING: User still has role '~s'~n", [NewRole]),
      io:format("  Some admin tests may fail~n")
  end.

get_admin_token() ->
  init_global_users(),
  get(admin_token).

get_admin_id() ->
  init_global_users(),
  get(admin_id).

get_user_token() ->
  init_global_users(),
  get(user_token).

get_user_id() ->
  init_global_users(),
  get(user_id).

%% ============ Главные функции запуска ============
run_all() ->
  inets:start(),
  ssl:start(),

  case wait_for_server() of
    ok -> ok;
    {error, _} -> io:format("❌ Server is not running!~n"), exit(server_not_running)
  end,

  init_global_users(),

  io:format("Starting API tests...~n"),
  Modules = [
    api_auth_tests,
    api_calendar_tests,
    api_event_tests,
    api_booking_tests,
    api_search_tests,
    api_reviews_tests,
    api_moderation_tests,
    api_tickets_tests,
    api_subscription_tests,
    api_admin_tests
  ],
  lists:foreach(fun(M) -> M:test() end, Modules).

run(Module) ->
  inets:start(),
  ssl:start(),
  init_global_users(),
  Module:test().

%% ============ HTTP запросы ============
http_post(Url, Body) -> http_post(Url, Body, undefined).
http_post(Url, Body, Token) ->
  Headers = case Token of
              undefined -> [{"Content-Type", "application/json"}];
              _ -> [{"Content-Type", "application/json"}, {"Authorization", "Bearer " ++ binary_to_list(Token)}]
            end,
  httpc:request(post, {?BASE_URL ++ Url, Headers, "application/json", jsx:encode(Body)}, [], []).

http_get(Url) -> http_get(Url, undefined).
http_get(Url, Token) ->
  Headers = case Token of
              undefined -> [];
              _ -> [{"Authorization", "Bearer " ++ binary_to_list(Token)}]
            end,
  httpc:request(get, {?BASE_URL ++ Url, Headers}, [], []).

http_put(Url, Body, Token) ->
  Headers = [{"Content-Type", "application/json"}, {"Authorization", "Bearer " ++ binary_to_list(Token)}],
  httpc:request(put, {?BASE_URL ++ Url, Headers, "application/json", jsx:encode(Body)}, [], []).

http_delete(Url, Token) ->
  Headers = [{"Authorization", "Bearer " ++ binary_to_list(Token)}],
  httpc:request(delete, {?BASE_URL ++ Url, Headers}, [], []).

%% ============ Утилиты ============

extract_json({ok, {{_, 200, _}, _, Body}}, Field) ->
  Map = jsx:decode(list_to_binary(Body), [return_maps]),
  maps:get(Field, Map);
extract_json({ok, {{_, 201, _}, _, Body}}, Field) ->
  Map = jsx:decode(list_to_binary(Body), [return_maps]),
  maps:get(Field, Map);
extract_json(Response, _Field) ->
  error({unexpected_response, Response}).

extract_json(Response, Field, ExpectedStatus) ->
  case Response of
    {ok, {{_, ExpectedStatus, _}, _, Body}} ->
      Map = jsx:decode(list_to_binary(Body), [return_maps]),
      maps:get(Field, Map);
    _ ->
      error({unexpected_response, Response})
  end.

assert_status(Status, {ok, {{_, Status, _}, _, _}}) -> ok;
assert_status(Expected, {ok, {{_, Got, _}, _, _}}) ->
  error({expected_status, Expected, got, Got}).

unique_email(Prefix) ->
  list_to_binary([Prefix, "_", integer_to_binary(os:system_time(millisecond)), "@test.com"]).

register_and_login(Email, Password) ->
  RegBody = #{email => Email, password => Password},
  case http_post("/v1/register", RegBody) of
    {ok, {{_, 201, _}, _, RegResp}} ->
      Map = jsx:decode(list_to_binary(RegResp), [return_maps]),
      maps:get(<<"token">>, Map);
    {ok, {{_, 409, _}, _, _}} ->
      % Уже существует - логинимся
      LoginBody = #{email => Email, password => Password},
      {ok, {{_, 200, _}, _, LoginResp}} = http_post("/v1/login", LoginBody),
      Map = jsx:decode(list_to_binary(LoginResp), [return_maps]),
      maps:get(<<"token">>, Map)
  end.

create_calendar(Token, Params) ->
  Id = extract_json(http_post("/v1/calendars", Params, Token), <<"id">>),
  Id.

create_event(Token, CalId, Params) ->
  Url = "/v1/calendars/" ++ binary_to_list(CalId) ++ "/events",
  Id = extract_json(http_post(Url, Params, Token), <<"id">>),
  Id.

wait_for_server() -> wait_for_server(30).
wait_for_server(0) -> {error, timeout};
wait_for_server(Attempts) ->
  case httpc:request(get, {?BASE_URL ++ "/health", []}, [], [{timeout, 1000}]) of
    {ok, {{_, 200, _}, _, _}} -> ok;
    _ -> timer:sleep(1000), wait_for_server(Attempts - 1)
  end.