EventHubBack/test/unit/logic_booking_tests.erl

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

-define(TABLES, [user, calendar, event, booking, admin]).

setup() ->
  eh_test_support:start_mnesia(),
  eh_test_support:ensure_tables(?TABLES),
  ok.

cleanup(_) ->
  eh_test_support:delete_tables(?TABLES),
  eh_test_support:stop_mnesia(),
  ok.

logic_booking_test_() ->
  {foreach,
    fun setup/0,
    fun cleanup/1,
    [
      {"Create booking returns pending", fun test_create_booking_pending/0},
      {"Create duplicate booking", fun test_create_duplicate_booking/0},
      {"Create booking for missing event", fun test_booking_missing_event/0},
      {"Create booking when event is full", fun test_booking_event_full/0},
      {"Pending bookings do not fill capacity", fun test_pending_does_not_fill/0},
      {"Confirm booking", fun test_confirm_booking/0},
      {"Confirm non-pending booking denied", fun test_confirm_non_pending/0},
      {"Cancel booking by participant", fun test_cancel_booking/0},
      {"Cancel booking access denied", fun test_cancel_access_denied/0},
      {"List event bookings", fun test_list_event_bookings/0},
      {"List event bookings as owner", fun test_list_event_bookings_owner/0},
      {"List event bookings non-owner denied", fun test_list_event_bookings_non_owner/0},
      {"List user bookings", fun test_list_user_bookings/0}
    ]}.

%% Вспомогательные функции
create_test_user(Role) ->
  UserId = base64:encode(crypto:strong_rand_bytes(16), #{mode => urlsafe, padding => false}),
  User = #user{
    id = UserId,
    email = <<UserId/binary, "@test.com">>,
    password_hash = <<"hash">>,
    role = Role,
    status = active,
    created_at = calendar:universal_time(),
    updated_at = calendar:universal_time()
  },
  mnesia:dirty_write(User),
  UserId.

create_test_calendar(OwnerId, Confirmation) ->
  {ok, Calendar} = core_calendar:create(OwnerId, <<"Test Calendar">>, <<"">>, Confirmation),
  Calendar#calendar.id.

create_test_event(CalendarId) ->
  StartTime = eh_test_support:future_start(),
  {ok, Event} = core_event:create(CalendarId, <<"Test Event">>, StartTime, 60),
  Event#event.id.

create_test_event_with_capacity(CalendarId, Capacity) ->
  StartTime = eh_test_support:future_start(),
  {ok, Event} = core_event:create(CalendarId, <<"Test Event">>, StartTime, 60),
  {ok, Updated} = core_event:update(Event#event.id, [{capacity, Capacity}]),
  Updated#event.id.

%% Тесты
test_create_booking_pending() ->
  OwnerId = create_test_user(user),
  ParticipantId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, auto),
  EventId = create_test_event(CalendarId),

  {ok, Booking} = logic_booking:create_booking(ParticipantId, EventId),
  ?assertEqual(pending, Booking#booking.status),

  {ok, Stored} = core_booking:get_by_id(Booking#booking.id),
  ?assertEqual(pending, Stored#booking.status).

test_create_duplicate_booking() ->
  OwnerId = create_test_user(user),
  ParticipantId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event(CalendarId),

  {ok, _} = logic_booking:create_booking(ParticipantId, EventId),
  {error, already_booked} = logic_booking:create_booking(ParticipantId, EventId).

test_booking_missing_event() ->
  ParticipantId = create_test_user(user),
  {error, not_found} = logic_booking:create_booking(ParticipantId, <<"nonexistent">>).

test_booking_event_full() ->
  OwnerId = create_test_user(user),
  Participant1Id = create_test_user(user),
  Participant2Id = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event_with_capacity(CalendarId, 1),

  {ok, B1} = logic_booking:create_booking(Participant1Id, EventId),
  {ok, _} = logic_booking:confirm_booking(Participant1Id, B1#booking.id, confirm),
  {error, full} = logic_booking:create_booking(Participant2Id, EventId).

test_pending_does_not_fill() ->
  OwnerId = create_test_user(user),
  Participant1Id = create_test_user(user),
  Participant2Id = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event_with_capacity(CalendarId, 1),

  {ok, _} = logic_booking:create_booking(Participant1Id, EventId),
  {ok, B2} = logic_booking:create_booking(Participant2Id, EventId),
  ?assertEqual(pending, B2#booking.status).

test_confirm_booking() ->
  OwnerId = create_test_user(user),
  ParticipantId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event(CalendarId),

  {ok, Booking} = logic_booking:create_booking(ParticipantId, EventId),
  {ok, Confirmed} = logic_booking:confirm_booking(OwnerId, Booking#booking.id, confirm),
  ?assertEqual(confirmed, Confirmed#booking.status).

test_confirm_non_pending() ->
  OwnerId = create_test_user(user),
  ParticipantId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event(CalendarId),

  {ok, Booking} = logic_booking:create_booking(ParticipantId, EventId),
  {ok, _} = logic_booking:confirm_booking(OwnerId, Booking#booking.id, confirm),
  {error, access_denied} = logic_booking:confirm_booking(OwnerId, Booking#booking.id, confirm).

test_cancel_booking() ->
  OwnerId = create_test_user(user),
  ParticipantId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event(CalendarId),

  {ok, Booking} = logic_booking:create_booking(ParticipantId, EventId),
  {ok, Cancelled} = logic_booking:cancel_booking(ParticipantId, Booking#booking.id, cancel),
  ?assertEqual(cancelled, Cancelled#booking.status).

test_cancel_access_denied() ->
  OwnerId = create_test_user(user),
  ParticipantId = create_test_user(user),
  OtherId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event(CalendarId),

  {ok, Booking} = logic_booking:create_booking(ParticipantId, EventId),
  {error, access_denied} = logic_booking:cancel_booking(OtherId, Booking#booking.id, cancel).

test_list_event_bookings() ->
  OwnerId = create_test_user(user),
  Participant1Id = create_test_user(user),
  Participant2Id = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event(CalendarId),

  {ok, _} = logic_booking:create_booking(Participant1Id, EventId),
  {ok, _} = logic_booking:create_booking(Participant2Id, EventId),

  {ok, Bookings} = logic_booking:list_event_bookings(EventId),
  ?assertEqual(2, length(Bookings)).

test_list_event_bookings_owner() ->
  OwnerId = create_test_user(user),
  Participant1Id = create_test_user(user),
  Participant2Id = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event(CalendarId),

  {ok, _} = logic_booking:create_booking(Participant1Id, EventId),
  {ok, _} = logic_booking:create_booking(Participant2Id, EventId),

  {ok, Bookings} = logic_booking:list_event_bookings(OwnerId, EventId),
  ?assertEqual(2, length(Bookings)).

test_list_event_bookings_non_owner() ->
  OwnerId = create_test_user(user),
  ParticipantId = create_test_user(user),
  StrangerId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId = create_test_event(CalendarId),

  {ok, _} = logic_booking:create_booking(ParticipantId, EventId),

  {error, access_denied} = logic_booking:list_event_bookings(StrangerId, EventId),
  {error, access_denied} = logic_booking:list_event_bookings(ParticipantId, EventId).

test_list_user_bookings() ->
  OwnerId = create_test_user(user),
  ParticipantId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId, manual),
  EventId1 = create_test_event(CalendarId),
  EventId2 = create_test_event(CalendarId),

  {ok, _} = logic_booking:create_booking(ParticipantId, EventId1),
  {ok, _} = logic_booking:create_booking(ParticipantId, EventId2),

  {ok, Bookings} = logic_booking:list_user_bookings(ParticipantId),
  ?assertEqual(2, length(Bookings)).