EventHubBack/test/unit/logic_calendar_tests.erl

-module(logic_calendar_tests).
-include_lib("eunit/include/eunit.hrl").
-include("records.hrl").

setup() ->
  mnesia:start(),
  mnesia:create_table(user, [
    {attributes, record_info(fields, user)},
    {ram_copies, [node()]}
  ]),
  mnesia:create_table(calendar, [
    {attributes, record_info(fields, calendar)},
    {ram_copies, [node()]}
  ]),
  mnesia:create_table(subscription, [
    {attributes, record_info(fields, subscription)},
    {ram_copies, [node()]}
  ]),
  ok.

cleanup(_) ->
  mnesia:delete_table(subscription),
  mnesia:delete_table(calendar),
  mnesia:delete_table(user),
  mnesia:stop(),
  ok.

logic_calendar_test_() ->
  {foreach,
    fun setup/0,
    fun cleanup/1,
    [
      {"Create calendar test", fun test_create_calendar/0},
      {"Create commercial requires subscription", fun test_create_commercial_gate/0},
      {"Get calendar test", fun test_get_calendar/0},
      {"List calendars test", fun test_list_calendars/0},
      {"Update calendar test", fun test_update_calendar/0},
      {"Persist calendar settings (week_patterns)", fun test_update_settings/0},
      {"Reject non-map settings", fun test_update_settings_invalid/0},
      {"Delete calendar test", fun test_delete_calendar/0},
      {"Access control test", fun test_access_control/0},
      {"Ensure default calendar test", fun test_ensure_default_calendar/0}
    ]}.

create_test_user() ->
  UserId = base64:encode(crypto:strong_rand_bytes(16), #{mode => urlsafe, padding => false}),
  User = #user{
    id = UserId,
    email = <<"test@example.com">>,
    password_hash = <<"hash">>,
    role = user,
    status = active,
    nickname = <<>>,
    created_at = calendar:universal_time(),
    updated_at = calendar:universal_time()
  },
  mnesia:dirty_write(User),
  UserId.

test_create_calendar() ->
  UserId = create_test_user(),
  Title = <<"Test Calendar">>,
  Description = <<"Test Description">>,
  Confirmation = auto,

  {ok, Calendar} = logic_calendar:create_calendar(UserId, Title, Description, Confirmation),
  ?assertEqual(UserId, Calendar#calendar.owner_id),
  ?assertEqual(Title, Calendar#calendar.title),
  ?assertEqual(personal, Calendar#calendar.type),
  ?assertEqual(Confirmation, Calendar#calendar.confirmation).

test_create_commercial_gate() ->
  UserId = create_test_user(),
  ?assertMatch({error, subscription_required},
    logic_calendar:create_calendar(UserId, <<"Studio">>, <<>>, manual, commercial)),
  {ok, Personal} = logic_calendar:create_calendar(UserId, <<"Personal">>, <<>>, manual, personal),
  ?assertEqual(personal, Personal#calendar.type),
  ?assertMatch({error, subscription_required},
    logic_calendar:update_calendar(UserId, Personal#calendar.id, [{type, commercial}])),
  {ok, _} = logic_subscription:start_trial(UserId),
  {ok, Commercial} = logic_calendar:create_calendar(UserId, <<"Studio">>, <<>>, manual, commercial),
  ?assertEqual(commercial, Commercial#calendar.type).

test_get_calendar() ->
  UserId = create_test_user(),
  {ok, Calendar} = logic_calendar:create_calendar(UserId, <<"Test">>, <<"">>, manual),

  case logic_calendar:get_calendar(UserId, Calendar#calendar.id) of
    {ok, Found} ->
      ?assertEqual(Calendar#calendar.id, Found#calendar.id);
    Other ->
      ?assert(false, {unexpected_result, Other})
  end,

  OtherUserId = create_test_user(),
  ?assertMatch({error, access_denied},
    logic_calendar:get_calendar(OtherUserId, Calendar#calendar.id)).

test_list_calendars() ->
  UserId = create_test_user(),
  {ok, _} = logic_calendar:create_calendar(UserId, <<"Calendar 1">>, <<"">>, manual),
  {ok, _} = logic_calendar:create_calendar(UserId, <<"Calendar 2">>, <<"">>, auto),

  {ok, Calendars} = logic_calendar:list_calendars(UserId),
  ?assertEqual(2, length(Calendars)).

test_update_calendar() ->
  UserId = create_test_user(),
  {ok, Calendar} = logic_calendar:create_calendar(UserId, <<"Original">>, <<"">>, manual),
  {ok, _} = logic_subscription:start_trial(UserId),

  Updates = [{title, <<"Updated">>}, {type, commercial}, {confirmation, auto}],
  {ok, Updated} = logic_calendar:update_calendar(UserId, Calendar#calendar.id, Updates),
  ?assertEqual(<<"Updated">>, Updated#calendar.title),
  ?assertEqual(commercial, Updated#calendar.type),
  ?assertEqual(auto, Updated#calendar.confirmation),

  OtherUserId = create_test_user(),
  ?assertMatch({error, access_denied},
    logic_calendar:update_calendar(OtherUserId, Calendar#calendar.id, Updates)).

test_update_settings() ->
  UserId = create_test_user(),
  {ok, Calendar} = logic_calendar:create_calendar(UserId, <<"Studio">>, <<"">>, manual),
  Patterns = [
    #{
      <<"id">> => <<"p1">>,
      <<"name">> => <<"Weekdays">>,
      <<"updated_at">> => <<"2026-07-29T12:00:00Z">>,
      <<"slots">> => [
        #{<<"weekday">> => 1, <<"time">> => <<"10:00">>, <<"duration">> => 60, <<"title">> => <<"Open">>}
      ]
    }
  ],
  Settings = #{<<"week_patterns">> => Patterns},
  {ok, Updated} = logic_calendar:update_calendar(
    UserId, Calendar#calendar.id, [{settings, Settings}]),
  ?assertEqual(Settings, Updated#calendar.settings),
  {ok, Reloaded} = logic_calendar:get_calendar(UserId, Calendar#calendar.id),
  ?assertEqual(Settings, Reloaded#calendar.settings),
  %% binary key path (as from raw JSON list before convert_field)
  Settings2 = Settings#{<<"foo">> => <<"bar">>},
  {ok, Updated2} = logic_calendar:update_calendar(
    UserId, Calendar#calendar.id, [{<<"settings">>, Settings2}]),
  ?assertEqual(Settings2, Updated2#calendar.settings).

test_update_settings_invalid() ->
  UserId = create_test_user(),
  {ok, Calendar} = logic_calendar:create_calendar(UserId, <<"Studio">>, <<"">>, manual),
  %% non-map settings silently dropped by validate_updates — calendar unchanged
  {ok, Same} = logic_calendar:update_calendar(
    UserId, Calendar#calendar.id, [{settings, [<<"not-a-map">>]}]),
  ?assertEqual(#{}, Same#calendar.settings).

test_delete_calendar() ->
  UserId = create_test_user(),
  {ok, Calendar} = logic_calendar:create_calendar(UserId, <<"Test">>, <<"">>, manual),

  {ok, Deleted} = logic_calendar:delete_calendar(UserId, Calendar#calendar.id),
  ?assertEqual(deleted, Deleted#calendar.status),

  ?assertMatch({error, access_denied}, logic_calendar:get_calendar(UserId, Calendar#calendar.id)).

test_access_control() ->
  OwnerId = create_test_user(),
  OtherId = create_test_user(),

  {ok, PersonalCalendar} = logic_calendar:create_calendar(OwnerId, <<"Personal">>, <<"">>, manual),

  ?assert(logic_calendar:can_edit(OwnerId, PersonalCalendar)),
  ?assertNot(logic_calendar:can_edit(OtherId, PersonalCalendar)),
  ?assertNot(logic_calendar:can_access(OtherId, PersonalCalendar)),

  {ok, _} = logic_subscription:start_trial(OwnerId),
  {ok, CommercialCalendar} = logic_calendar:update_calendar(OwnerId, PersonalCalendar#calendar.id, [{type, commercial}]),
  ?assert(logic_calendar:can_access(OtherId, CommercialCalendar)),
  ?assertNot(logic_calendar:can_edit(OtherId, CommercialCalendar)),

  {ok, Frozen} = core_calendar:update(CommercialCalendar#calendar.id, [{status, frozen}]),
  ?assertNot(logic_calendar:can_access(OtherId, Frozen)),
  ?assertNot(logic_calendar:can_access(OwnerId, Frozen)).

test_ensure_default_calendar() ->
  UserId = create_test_user(),
  ok = logic_calendar:ensure_default_calendar(UserId),
  {ok, Calendars} = logic_calendar:list_calendars(UserId),
  ?assertEqual(1, length(Calendars)),
  Cal = hd(Calendars),
  ?assertEqual(personal, Cal#calendar.type),
  ?assertEqual(<<>>, Cal#calendar.short_name),
  ?assertEqual(active, Cal#calendar.status),
  ?assert(byte_size(Cal#calendar.title) > 0),
  ok = logic_calendar:ensure_default_calendar(UserId),
  {ok, Calendars2} = logic_calendar:list_calendars(UserId),
  ?assertEqual(1, length(Calendars2)).