Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

test(gateway): remove community eunit suites and inline tests

Hampus171d9fbf6420
diff --git a/fluxer_gateway/src/guild/guild_availability.erl b/fluxer_gateway/src/guild/guild_availability.erl
index ef2e5bf9a..6b799cd30 100644
--- a/fluxer_gateway/src/guild/guild_availability.erl
+++ b/fluxer_gateway/src/guild/guild_availability.erl
@@ -232,42 +232,3 @@ handle_recheck_transition(OldMode, available, GuildId, State) when OldMode =/= a
send_guild_create_to_sessions(State, GuildId);
handle_recheck_transition(_OldMode, _CurrentMode, _GuildId, State) ->
State.
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-handle_recheck_transition_clears_cache_on_recovery_test() ->
- GuildId = 99001,
- State = #{
- id => GuildId,
- sessions => #{},
- data => #{<<"guild">> => #{<<"features">> => []}}
- },
- guild_availability_cache:set_cached_unavailability_mode(GuildId, unavailable_for_everyone),
- try
- _ = handle_recheck_transition(unavailable_for_everyone, available, GuildId, State),
- ?assertEqual(
- available, guild_availability_cache:get_cached_unavailability_mode(GuildId)
- )
- after
- guild_availability_cache:set_cached_unavailability_mode(GuildId, available)
- end.
-
-handle_recheck_transition_no_change_when_still_unavailable_test() ->
- GuildId = 99002,
- State = #{
- id => GuildId,
- sessions => #{},
- data => #{<<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}}
- },
- guild_availability_cache:set_cached_unavailability_mode(GuildId, unavailable_for_everyone),
- try
- Result = handle_recheck_transition(
- unavailable_for_everyone, unavailable_for_everyone, GuildId, State
- ),
- ?assertEqual(State, Result)
- after
- guild_availability_cache:set_cached_unavailability_mode(GuildId, available)
- end.
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_availability_check.erl b/fluxer_gateway/src/guild/guild_availability_check.erl
index ac2e83360..3ee4470b3 100644
--- a/fluxer_gateway/src/guild/guild_availability_check.erl
+++ b/fluxer_gateway/src/guild/guild_availability_check.erl
@@ -1,9 +1,6 @@
%% SPDX-License-Identifier: AGPL-3.0-or-later
-module(guild_availability_check).
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
--endif.
-typing([eqwalizer]).
@@ -148,98 +145,3 @@ transition_result(unavailable_for_everyone, unavailable_for_everyone_but_staff)
{unavailable_enabled, true};
transition_result(_, _) ->
no_change.
-
--ifdef(TEST).
-
-get_unavailability_mode_available_test() ->
- State = #{data => #{<<"guild">> => #{<<"features">> => []}}},
- ?assertEqual(available, get_unavailability_mode_from_state(State)).
-
-get_unavailability_mode_for_everyone_test() ->
- State = #{data => #{<<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}}},
- ?assertEqual(unavailable_for_everyone, get_unavailability_mode_from_state(State)).
-
-get_unavailability_mode_for_everyone_but_staff_test() ->
- Features = [<<"UNAVAILABLE_FOR_EVERYONE_BUT_STAFF">>],
- State = #{data => #{<<"guild">> => #{<<"features">> => Features}}},
- ?assertEqual(
- unavailable_for_everyone_but_staff,
- get_unavailability_mode_from_state(State)
- ).
-
-is_unavailable_hidden_enabled_test() ->
- HiddenFeatures = [<<"UNAVAILABLE_FOR_EVERYONE">>, <<"UNAVAILABLE_HIDDEN">>],
- StateHidden = #{data => #{<<"guild">> => #{<<"features">> => HiddenFeatures}}},
- NotHiddenFeatures = [<<"UNAVAILABLE_HIDDEN">>],
- StateNotHidden = #{data => #{<<"guild">> => #{<<"features">> => NotHiddenFeatures}}},
- ?assertEqual(true, is_unavailable_hidden_enabled(StateHidden)),
- ?assertEqual(false, is_unavailable_hidden_enabled(StateNotHidden)).
-
-check_unavailability_transition_no_change_test() ->
- State = #{data => #{<<"guild">> => #{<<"features">> => []}}},
- ?assertEqual(no_change, check_unavailability_transition(State, State)).
-
-check_unavailability_transition_enabled_test() ->
- Old = #{data => #{<<"guild">> => #{<<"features">> => []}}},
- New = #{data => #{<<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}}},
- ?assertEqual({unavailable_enabled, false}, check_unavailability_transition(Old, New)).
-
-check_unavailability_transition_disabled_test() ->
- Old = #{data => #{<<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}}},
- New = #{data => #{<<"guild">> => #{<<"features">> => []}}},
- ?assertEqual(unavailable_disabled, check_unavailability_transition(Old, New)).
-
-is_user_staff_from_user_data_test() ->
- ?assertEqual(true, is_user_staff_from_user_data(#{<<"is_staff">> => true})),
- ?assertEqual(false, is_user_staff_from_user_data(#{<<"is_staff">> => false})),
- ?assertEqual(true, is_user_staff_from_user_data(#{<<"flags">> => 1})),
- ?assertEqual(false, is_user_staff_from_user_data(#{<<"flags">> => 0})),
- ?assertEqual(false, is_user_staff_from_user_data(#{})).
-
-parse_is_staff_value_test() ->
- ?assertEqual(true, parse_is_staff_value(true)),
- ?assertEqual(false, parse_is_staff_value(false)),
- ?assertEqual(true, parse_is_staff_value(<<"true">>)),
- ?assertEqual(false, parse_is_staff_value(<<"false">>)),
- ?assertEqual(undefined, parse_is_staff_value(something)).
-
-is_user_staff_ignores_injected_member_data_test() ->
- UserId = 42,
- Sessions = #{
- <<"sess1">> => #{
- session_id => <<"sess1">>,
- user_id => UserId,
- is_staff => false
- }
- },
- InjectedMember = #{
- <<"user">> => #{<<"id">> => <<"42">>, <<"is_staff">> => true, <<"flags">> => <<"0">>}
- },
- State = #{
- sessions => Sessions,
- data => #{
- <<"members">> => [InjectedMember],
- <<"guild">> => #{<<"features">> => []}
- }
- },
- ?assertEqual(false, is_user_staff(UserId, State)).
-
-is_user_staff_trusts_session_identity_test() ->
- UserId = 99,
- Sessions = #{
- <<"sess2">> => #{
- session_id => <<"sess2">>,
- user_id => UserId,
- is_staff => true
- }
- },
- State = #{
- sessions => Sessions,
- data => #{
- <<"members">> => [],
- <<"guild">> => #{<<"features">> => []}
- }
- },
- ?assertEqual(true, is_user_staff(UserId, State)).
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_broadcaster.erl b/fluxer_gateway/src/guild/guild_broadcaster.erl
index f75f83ffd..633dda4f3 100644
--- a/fluxer_gateway/src/guild/guild_broadcaster.erl
+++ b/fluxer_gateway/src/guild/guild_broadcaster.erl
@@ -154,72 +154,3 @@ maybe_schedule_gc(#{broadcaster_gc_ref := Ref} = State) when is_reference(Ref) -
maybe_schedule_gc(State) ->
Ref = erlang:send_after(?IDLE_GC_DELAY_MS, self(), run_broadcaster_gc),
State#{broadcaster_gc_ref => Ref}.
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-blocker_process(Parent) ->
- receive
- go -> ok
- after 30000 -> ok
- end,
- Parent ! done.
-
-maybe_cast_sheds_when_mailbox_full_test() ->
- Parent = self(),
- Blocker = spawn(fun() -> blocker_process(Parent) end),
- lists:foreach(
- fun(I) -> Blocker ! {filler, I} end,
- lists:seq(1, ?MAX_MAILBOX + 10)
- ),
- ?assertEqual(false, maybe_cast(Blocker, {should_be_shed})),
- Blocker ! go,
- receive
- done -> ok
- after 1000 -> ok
- end.
-
-event_broadcast_handler_dispatches_test() ->
- {ok, Broadcaster} = gen_server:start_link(
- ?MODULE,
- [42, self()],
- [{spawn_opt, [{message_queue_data, off_heap}]}]
- ),
- Parent = self(),
- Receiver = spawn(fun() -> event_receiver_loop(Parent) end),
- EncodedPayload = {pre_encoded, <<"test_payload">>},
- gen_server:cast(Broadcaster, {event_broadcast, typing_start, EncodedPayload, [Receiver]}),
- receive
- {received_dispatch, typing_start, {pre_encoded, <<"test_payload">>}} -> ok
- after 2000 ->
- ?assert(false)
- end,
- gen_server:stop(Broadcaster),
- Receiver ! stop.
-
-event_broadcast_handler_survives_crash_test() ->
- {ok, Broadcaster} = gen_server:start_link(
- ?MODULE,
- [99, self()],
- [{spawn_opt, [{message_queue_data, off_heap}]}]
- ),
- BadPids = [not_a_pid],
- gen_server:cast(Broadcaster, {event_broadcast, fake_event, {pre_encoded, <<>>}, BadPids}),
- ok = gateway_retry_timer:wait(50),
- ?assert(is_process_alive(Broadcaster)),
- gen_server:stop(Broadcaster).
-
-event_receiver_loop(Parent) ->
- receive
- stop ->
- ok;
- {'$gen_cast', {dispatch, Event, Payload}} ->
- Parent ! {received_dispatch, Event, Payload},
- event_receiver_loop(Parent);
- _Other ->
- event_receiver_loop(Parent)
- after 30000 ->
- ok
- end.
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_client.erl b/fluxer_gateway/src/guild/guild_client.erl
index ca5332491..f4f52f8e9 100644
--- a/fluxer_gateway/src/guild/guild_client.erl
+++ b/fluxer_gateway/src/guild/guild_client.erl
@@ -1,9 +1,6 @@
%% SPDX-License-Identifier: AGPL-3.0-or-later
-module(guild_client).
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
--endif.
-typing([eqwalizer]).
@@ -216,63 +213,3 @@ require_success_response(#{success := true} = Response) ->
-spec require_rejection_response(map()) -> voice_state_update_rejection().
require_rejection_response(#{success := false, ack := Ack} = Response) when is_map(Ack) ->
Response.
-
--ifdef(TEST).
-
-do_call_ok_reply_returns_error_test() ->
- Pid = start_test_call_server(ok),
- ?assertEqual({error, unknown, internal_error}, do_call(Pid, #{}, 1000)),
- stop_test_call_server(Pid).
-
-do_call_success_map_reply_returns_ok_test() ->
- Reply = #{success => true, token => <<"abc">>},
- Pid = start_test_call_server(Reply),
- ?assertEqual({ok, Reply}, do_call(Pid, #{}, 1000)),
- stop_test_call_server(Pid).
-
-do_call_rejected_ack_map_reply_returns_ok_test() ->
- Reply = #{success => false, ack => #{<<"status">> => <<"rejected">>}},
- Pid = start_test_call_server(Reply),
- ?assertEqual({ok, Reply}, do_call(Pid, #{}, 1000)),
- stop_test_call_server(Pid).
-
-do_call_error_tuple_reply_passthrough_test() ->
- Reply = {error, validation_error, voice_member_not_found},
- Pid = start_test_call_server(Reply),
- ?assertEqual(Reply, do_call(Pid, #{}, 1000)),
- stop_test_call_server(Pid).
-
-do_call_nested_error_tuple_reply_passthrough_test() ->
- Reply = {error, {validation_error, voice_member_not_found}},
- Pid = start_test_call_server(Reply),
- ?assertEqual({error, validation_error, voice_member_not_found}, do_call(Pid, #{}, 1000)),
- stop_test_call_server(Pid).
-
-do_call_not_owner_error_tuple_reply_normalized_test() ->
- Reply = {error, {not_owner, '[email protected]'}},
- Pid = start_test_call_server(Reply),
- ?assertEqual({error, not_owner, '[email protected]'}, do_call(Pid, #{}, 1000)),
- stop_test_call_server(Pid).
-
--spec start_test_call_server(term()) -> pid().
-start_test_call_server(Reply) ->
- spawn(fun() -> test_call_server_loop(Reply) end).
-
--spec stop_test_call_server(pid()) -> ok.
-stop_test_call_server(Pid) ->
- Pid ! stop,
- ok.
-
--spec test_call_server_loop(term()) -> ok.
-test_call_server_loop(Reply) ->
- receive
- {'$gen_call', From, {voice_state_update, _Request}} ->
- gen_server:reply(From, Reply),
- test_call_server_loop(Reply);
- stop ->
- ok
- after 30000 ->
- ok
- end.
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_client_circuit_breaker.erl b/fluxer_gateway/src/guild/guild_client_circuit_breaker.erl
index d1b4ffa38..7b7e83c46 100644
--- a/fluxer_gateway/src/guild/guild_client_circuit_breaker.erl
+++ b/fluxer_gateway/src/guild/guild_client_circuit_breaker.erl
@@ -1,9 +1,6 @@
%% SPDX-License-Identifier: AGPL-3.0-or-later
-module(guild_client_circuit_breaker).
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
--endif.
-typing([eqwalizer]).
@@ -219,94 +216,3 @@ safe_lookup(GuildPid) ->
catch
error:badarg -> []
end.
-
--ifdef(TEST).
-
-safe_delete_test_table() ->
- try ets:delete(?CIRCUIT_BREAKER_TABLE) of
- _ -> ok
- catch
- error:badarg -> ok
- end.
-
-spawn_test_pid() ->
- spawn(fun test_waiter/0).
-
-test_waiter() ->
- receive
- done -> ok
- after 30000 -> ok
- end.
-
-circuit_test_setup() ->
- ensure_table(),
- Pid = spawn_test_pid(),
- ets:delete_all_objects(?CIRCUIT_BREAKER_TABLE),
- Pid.
-
-get_circuit_state_open_test() ->
- Pid = circuit_test_setup(),
- Now = erlang:system_time(millisecond),
- ets:insert(
- ?CIRCUIT_BREAKER_TABLE,
- {Pid, #{
- state => open,
- failures => 5,
- concurrent => 0,
- opened_at => Now
- }}
- ),
- ?assertEqual(open, get_circuit_state(Pid)),
- Pid ! done.
-
-get_circuit_state_half_open_test() ->
- Pid = circuit_test_setup(),
- OldTime = erlang:system_time(millisecond) - ?RECOVERY_TIMEOUT_MS - 1000,
- ets:insert(
- ?CIRCUIT_BREAKER_TABLE,
- {Pid, #{
- state => open,
- failures => 5,
- concurrent => 0,
- opened_at => OldTime
- }}
- ),
- ?assertEqual(half_open, get_circuit_state(Pid)),
- Pid ! done.
-
-record_failure_opens_circuit_test() ->
- Pid = circuit_test_setup(),
- ets:insert(
- ?CIRCUIT_BREAKER_TABLE,
- {Pid, #{
- state => closed,
- failures => ?FAILURE_THRESHOLD - 1,
- concurrent => 0
- }}
- ),
- record_failure(Pid),
- [{Pid, State}] = ets:lookup(?CIRCUIT_BREAKER_TABLE, Pid),
- ?assertEqual(open, maps:get(state, State)),
- Pid ! done.
-
-record_failure_recreates_missing_table_test() ->
- safe_delete_test_table(),
- Pid = spawn_test_pid(),
- ?assertEqual(ok, record_failure(Pid)),
- [{Pid, State}] = ets:lookup(?CIRCUIT_BREAKER_TABLE, Pid),
- ?assertEqual(1, maps:get(failures, State)),
- Pid ! done.
-
-is_success_result_test() ->
- ?assertEqual(true, is_success_result({ok, #{success => true}})),
- ?assertEqual(false, is_success_result({error, timeout})),
- ?assertEqual(false, is_success_result({error, noproc})),
- ?assertEqual(
- true, is_success_result({error, validation_error, voice_missing_connection_id})
- ),
- ?assertEqual(true, is_success_result({error, not_found, voice_member_not_found})),
- ?assertEqual(true, is_success_result({error, permission_denied, voice_permission_denied})),
- ?assertEqual(false, is_success_result({error, unknown, internal_error})),
- ?assertEqual(false, is_success_result({error, timeout, timeout})).
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_dispatch_config.erl b/fluxer_gateway/src/guild/guild_dispatch_config.erl
index 7a1bb0e12..7e57b4d19 100644
--- a/fluxer_gateway/src/guild/guild_dispatch_config.erl
+++ b/fluxer_gateway/src/guild/guild_dispatch_config.erl
@@ -32,34 +32,3 @@ is_guild_operation_disabled(State, OperationMask) ->
Guild = maps:get(<<"guild">>, Data, #{}),
DisabledOperations = bitset:parse(maps:get(<<"disabled_operations">>, Guild, 0)),
bitset:has(DisabledOperations, OperationMask).
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
--spec disabled_operations_state(integer() | binary()) -> guild_state().
-disabled_operations_state(Value) ->
- #{data => #{<<"guild">> => #{<<"disabled_operations">> => Value}}}.
-
-should_send_push_notifications_respects_flag_test() ->
- ?assertEqual(true, should_send_push_notifications(disabled_operations_state(0))),
- PushFlag = ?GUILD_DISABLED_OP_PUSH_NOTIFICATIONS,
- ?assertEqual(
- false,
- should_send_push_notifications(disabled_operations_state(PushFlag))
- ).
-
-member_list_updates_enabled_respects_flag_test() ->
- ?assertEqual(true, is_member_list_updates_enabled(disabled_operations_state(<<"0">>))),
- DisabledState = #{
- disable_member_list_updates => true,
- data => #{<<"guild">> => #{}}
- },
- ?assertEqual(false, is_member_list_updates_enabled(DisabledState)),
- ?assertEqual(
- false,
- is_member_list_updates_enabled(
- disabled_operations_state(integer_to_binary(?GUILD_DISABLED_OP_MEMBER_LIST_UPDATES))
- )
- ).
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_dispatch_decorate.erl b/fluxer_gateway/src/guild/guild_dispatch_decorate.erl
index 3a890f524..9619f57e7 100644
--- a/fluxer_gateway/src/guild/guild_dispatch_decorate.erl
+++ b/fluxer_gateway/src/guild/guild_dispatch_decorate.erl
@@ -106,30 +106,3 @@ parse_snowflake(FieldName, Value) ->
-spec parse_snowflake_binary(binary(), term()) -> binary().
parse_snowflake_binary(FieldName, Value) ->
integer_to_binary(validation:snowflake_or_throw(FieldName, Value)).
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-decorate_member_data_message_delete_author_id_test() ->
- Member = #{<<"user">> => #{<<"id">> => <<"123">>}, <<"roles">> => []},
- State = #{data => #{<<"members">> => [Member]}},
- Data = #{<<"author_id">> => <<"123">>},
- Decorated = decorate_member_data(message_delete, Data, State),
- ?assert(maps:is_key(<<"member">>, Decorated)),
- ?assertEqual(false, maps:is_key(<<"user">>, maps:get(<<"member">>, Decorated))).
-
-decorate_member_data_typing_start_test() ->
- Member = #{<<"user">> => #{<<"id">> => <<"456">>}, <<"roles">> => []},
- State = #{data => #{<<"members">> => [Member]}},
- Data = #{<<"user_id">> => <<"456">>},
- Decorated = decorate_member_data(typing_start, Data, State),
- ?assert(maps:is_key(<<"member">>, Decorated)),
- ?assert(maps:is_key(<<"user">>, maps:get(<<"member">>, Decorated))).
-
-decorate_member_data_guild_event_no_decoration_test() ->
- State = #{data => #{<<"members">> => []}},
- Data = #{<<"name">> => <<"test">>},
- Decorated = decorate_member_data(guild_update, Data, State),
- ?assertEqual(false, maps:is_key(<<"member">>, Decorated)).
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_dispatch_filter.erl b/fluxer_gateway/src/guild/guild_dispatch_filter.erl
index 544cdbccf..08c2ad776 100644
--- a/fluxer_gateway/src/guild/guild_dispatch_filter.erl
+++ b/fluxer_gateway/src/guild/guild_dispatch_filter.erl
@@ -207,71 +207,3 @@ extract_channel_id(Event, FinalData) when
extract_channel_id(_, FinalData) ->
ChannelIdBin = maps:get(<<"channel_id">>, FinalData, undefined),
validation:snowflake_or_throw(<<"channel_id">>, ChannelIdBin).
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-is_channel_scoped_event_test() ->
- ?assertEqual(true, is_channel_scoped_event(message_create)),
- ?assertEqual(true, is_channel_scoped_event(channel_update)),
- ?assertEqual(true, is_channel_scoped_event(typing_start)),
- ?assertEqual(false, is_channel_scoped_event(guild_update)),
- ?assertEqual(false, is_channel_scoped_event(guild_member_add)).
-
-is_message_access_filtered_event_test() ->
- ?assertEqual(true, is_message_access_filtered_event(message_update)),
- ?assertEqual(true, is_message_access_filtered_event(message_delete)),
- ?assertEqual(true, is_message_access_filtered_event(message_reaction_add)),
- ?assertEqual(true, is_message_access_filtered_event(message_reaction_remove)),
- ?assertEqual(true, is_message_access_filtered_event(message_reaction_remove_all)),
- ?assertEqual(true, is_message_access_filtered_event(message_reaction_remove_emoji)),
- ?assertEqual(false, is_message_access_filtered_event(message_create)),
- ?assertEqual(false, is_message_access_filtered_event(message_delete_bulk)),
- ?assertEqual(false, is_message_access_filtered_event(typing_start)),
- ?assertEqual(false, is_message_access_filtered_event(channel_create)).
-
-extract_channel_id_message_create_uses_channel_id_field_test() ->
- Data = #{<<"channel_id">> => <<"42">>},
- ?assertEqual(42, extract_channel_id(message_create, Data)).
-
-filter_sessions_for_event_guild_wide_goes_to_all_sessions_test() ->
- S1 = #{session_id => <<"s1">>, user_id => 10, pid => self()},
- S2 = #{session_id => <<"s2">>, user_id => 11, pid => self()},
- Sessions = #{<<"s1">> => S1, <<"s2">> => S2},
- State = #{sessions => Sessions, data => #{<<"members">> => #{}}},
- Result = filter_sessions_for_event(guild_member_add, #{}, undefined, Sessions, State),
- ?assertEqual(2, length(Result)).
-
-filter_sessions_for_event_audit_log_requires_view_permission_test() ->
- {Sessions, State, Allowed} = audit_log_test_fixture(),
- Result = filter_sessions_for_event(
- guild_audit_log_entry_create, #{}, undefined, Sessions, State
- ),
- ?assertEqual([{<<"allowed">>, Allowed}], Result).
-
-audit_log_test_fixture() ->
- GuildId = 1,
- GIdBin = integer_to_binary(GuildId),
- AuditPerm = integer_to_binary(constants:view_audit_log_permission()),
- Allowed = #{session_id => <<"allowed">>, user_id => 2001, pid => self()},
- Denied = #{session_id => <<"denied">>, user_id => 2002, pid => self()},
- Sessions = #{<<"allowed">> => Allowed, <<"denied">> => Denied},
- Guild = #{<<"id">> => GIdBin, <<"owner_id">> => <<"999">>, <<"features">> => []},
- State = #{
- id => GuildId,
- sessions => Sessions,
- data => #{
- <<"guild">> => Guild,
- <<"roles">> => [
- #{<<"id">> => GIdBin, <<"permissions">> => <<"0">>},
- #{<<"id">> => <<"300">>, <<"permissions">> => AuditPerm}
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => <<"2001">>}, <<"roles">> => [<<"300">>]},
- #{<<"user">> => #{<<"id">> => <<"2002">>}, <<"roles">> => []}
- ]
- }
- },
- {Sessions, State, Allowed}.
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_ets_owner.erl b/fluxer_gateway/src/guild/guild_ets_owner.erl
index 87fb3f379..da3bfaa78 100644
--- a/fluxer_gateway/src/guild/guild_ets_owner.erl
+++ b/fluxer_gateway/src/guild/guild_ets_owner.erl
@@ -177,71 +177,3 @@ safe_table_name(Tab) ->
catch
error:badarg -> unknown
end.
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-safe_delete_test_table(TableName) ->
- try ets:delete(TableName) of
- _ -> ok
- catch
- error:badarg -> ok
- end.
-
-ensure_table_creates_table_owned_by_owner_test() ->
- TableName = guild_ets_owner_test_table,
- safe_delete_test_table(TableName),
- {ok, Pid} = start_link(),
- try
- ok = ensure_table(TableName, [named_table, public, set]),
- ?assertEqual(Pid, ets:info(TableName, owner))
- after
- gen_server:stop(?MODULE),
- safe_delete_test_table(TableName)
- end.
-
-core_voice_tables_are_owned_by_owner_on_start_test() ->
- lists:foreach(
- fun safe_delete_test_table/1,
- [
- guild_voice_registry,
- voice_state_count_connections,
- voice_state_count_regions,
- voice_state_count_servers,
- guild_unavailability_cache,
- guild_circuit_breaker,
- guild_permission_cache,
- voice_update_queue,
- voice_update_rate_limit
- ]
- ),
- {ok, Pid} = start_link(),
- try
- ?assertEqual(Pid, ets:info(guild_voice_registry, owner)),
- ?assertEqual(Pid, ets:info(voice_state_count_connections, owner)),
- ?assertEqual(Pid, ets:info(voice_state_count_regions, owner)),
- ?assertEqual(Pid, ets:info(voice_state_count_servers, owner)),
- ?assertEqual(Pid, ets:info(guild_unavailability_cache, owner)),
- ?assertEqual(Pid, ets:info(guild_circuit_breaker, owner)),
- ?assertEqual(Pid, ets:info(guild_permission_cache, owner)),
- ?assertEqual(Pid, ets:info(voice_update_queue, owner)),
- ?assertEqual(Pid, ets:info(voice_update_rate_limit, owner))
- after
- gen_server:stop(?MODULE)
- end.
-
-orphan_sweep_is_scheduled_and_rearmed_test() ->
- {ok, Pid} = start_link(),
- try
- #{sweep_timer := Ref} = sys:get_state(Pid),
- ?assert(is_reference(Ref)),
- Pid ! sweep_orphan_tables,
- #{sweep_timer := NextRef} = sys:get_state(Pid),
- ?assert(is_reference(NextRef)),
- ?assertNotEqual(Ref, NextRef),
- ?assertEqual(Pid, ets:info(guild_voice_registry, owner))
- after
- gen_server:stop(?MODULE)
- end.
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_manager_shard_fetch.erl b/fluxer_gateway/src/guild/guild_manager_shard_fetch.erl
index 6f5babbb7..7de482120 100644
--- a/fluxer_gateway/src/guild/guild_manager_shard_fetch.erl
+++ b/fluxer_gateway/src/guild/guild_manager_shard_fetch.erl
@@ -158,47 +158,3 @@ maybe_put_after(undefined, RpcRequest) ->
RpcRequest;
maybe_put_after(AfterUserId, RpcRequest) when is_binary(AfterUserId) ->
RpcRequest#{<<"after_user_id">> => AfterUserId}.
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-parse_members_result_final_page_test() ->
- Members = [
- #{<<"user">> => #{<<"id">> => <<"1">>}}
- ],
- ?assertEqual(
- {ok, Members},
- parse_members_result(42, Members, false, null, [])
- ).
-
-parse_members_result_invalid_cursor_test() ->
- Members = [
- #{<<"user">> => #{<<"id">> => <<"1">>}}
- ],
- ?assertEqual(
- {error, invalid_members_collection_cursor},
- parse_members_result(42, Members, true, null, [])
- ).
-
-parse_channels_response_control_is_unchanged_test() ->
- Channels = [#{<<"id">> => <<"1">>}],
- ?assertEqual(
- {ok, Channels}, parse_channels_response({ok, #{<<"channels">> => Channels}})
- ),
- ?assertEqual(
- {error, {invalid_collection_response, <<"channels">>}},
- parse_channels_response({ok, #{}})
- ).
-
-parse_channels_response_carries_the_thread_gate_test() ->
- Response = #{
- <<"channels">> => [],
- <<"thread_gate">> => #{<<"active">> => false, <<"config_version">> => 2},
- <<"thread_tainted">> => true
- },
- ?assertEqual(
- {ok, [], #{thread_gate => #{active => false, version => 2}, thread_tainted => true}},
- parse_channels_response({ok, Response})
- ).
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_presence.erl b/fluxer_gateway/src/guild/guild_presence.erl
index 3fbcaf421..bfae01a60 100644
--- a/fluxer_gateway/src/guild/guild_presence.erl
+++ b/fluxer_gateway/src/guild/guild_presence.erl
@@ -1,9 +1,6 @@
%% SPDX-License-Identifier: AGPL-3.0-or-later
-module(guild_presence).
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
--endif.
-typing([eqwalizer]).
@@ -421,171 +418,3 @@ store_member_presence(UserId, PresenceMap, State) ->
ets:insert(Tab, {UserId, PresenceMap}),
ok = guild_member_list_read:note_presence_write(UserId),
State.
-
--ifdef(TEST).
-
-handle_bus_presence_non_member_noop_test() ->
- Payload = #{<<"status">> => <<"online">>, <<"user">> => #{<<"id">> => <<"99">>}},
- State = #{data => #{<<"members">> => []}, sessions => #{}},
- {noreply, NewState} = handle_bus_presence(99, Payload, State),
- ?assertEqual(State, NewState).
-
-handle_bus_presence_unchanged_payload_is_noop_test() ->
- State = presence_test_state(),
- Payload = #{
- <<"status">> => <<"online">>,
- <<"mobile">> => true,
- <<"afk">> => false,
- <<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"Alpha">>}
- },
- Member = #{} = guild_permissions_check:find_member_by_user_id(1, State),
- PresenceMap = build_presence_map(Payload, Member),
- ets:insert(maps:get(member_presence, State), {1, PresenceMap}),
- {noreply, NewState} = handle_bus_presence(1, Payload, State),
- ?assertEqual(State, NewState).
-
-handle_bus_presence_user_update_test() ->
- State = presence_test_state(),
- UserData = #{<<"id">> => <<"1">>, <<"username">> => <<"Updated">>},
- Payload = #{<<"user">> => UserData, <<"user_update">> => true},
- {noreply, NewState} = handle_bus_presence(1, Payload, State),
- Data = maps:get(data, NewState),
- Member = maps:get(1, maps:get(<<"members">>, Data)),
- ?assertEqual(<<"Updated">>, maps:get(<<"username">>, maps:get(<<"user">>, Member))).
-
-normalize_presence_status_test() ->
- ?assertEqual(<<"offline">>, normalize_presence_status(<<"invisible">>)),
- ?assertEqual(<<"online">>, normalize_presence_status(<<"online">>)),
- ?assertEqual(<<"idle">>, normalize_presence_status(<<"idle">>)),
- ?assertEqual(<<"offline">>, normalize_presence_status(undefined)).
-
-presence_test_state() ->
- #{
- id => 42,
- data => #{
- <<"members">> => #{
- 1 => #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"Alpha">>}}
- }
- },
- sessions => #{},
- member_presence => ets:new(test_member_presence, [set, public]),
- member_list_subscriptions => guild_member_list_subs:new()
- }.
-
-online_payload() ->
- #{
- <<"status">> => <<"online">>,
- <<"mobile">> => true,
- <<"afk">> => false,
- <<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"Alpha">>}
- }.
-
-idle_session() ->
- receive
- stop -> ok
- after 60000 -> ok
- end.
-
-handle_bus_presence_casts_presence_update_to_broadcaster_test() ->
- Subscriber = spawn(fun idle_session/0),
- try
- MemberSubs = guild_subscriptions:subscribe(
- <<"s2">>, 1, guild_subscriptions:init_state()
- ),
- State = (presence_test_state())#{
- broadcaster_pid => self(),
- member_subscriptions => MemberSubs,
- sessions => #{
- <<"s1">> => #{user_id => 1, pid => self(), viewable_channels => #{100 => true}},
- <<"s2">> => #{
- user_id => 2, pid => Subscriber, viewable_channels => #{100 => true}
- }
- }
- },
- {noreply, _NewState} = handle_bus_presence(1, online_payload(), State),
- receive
- {'$gen_cast', {event_broadcast, presence_update, Update, Pids}} ->
- ?assertEqual([Subscriber], Pids),
- ?assertEqual(<<"42">>, maps:get(<<"guild_id">>, Update)),
- ?assertEqual(<<"online">>, maps:get(<<"status">>, Update))
- after 1000 ->
- ?assert(false)
- end
- after
- exit(Subscriber, kill)
- end.
-
-handle_bus_presence_skips_broadcaster_without_subscribers_test() ->
- State = (presence_test_state())#{broadcaster_pid => self()},
- {noreply, _NewState} = handle_bus_presence(1, online_payload(), State),
- receive
- {'$gen_cast', {event_broadcast, presence_update, _, _}} -> ?assert(false)
- after 100 ->
- ok
- end.
-
-view_trim_test_state(Tab) ->
- #{
- id => 42,
- member_count => 10,
- voice_states => #{},
- virtual_channel_access => #{1 => sets:from_list([100])},
- data => #{
- members_ets => Tab,
- <<"members">> => #{1 => #{<<"user">> => #{<<"id">> => <<"1">>}}},
- members_normalized => #{1 => #{<<"user">> => #{<<"id">> => <<"1">>}}},
- <<"member_role_index">> => #{1 => []},
- members_sorted_ids => [1],
- <<"channels">> => [],
- <<"roles">> => []
- },
- sessions => #{
- <<"s1">> => #{
- user_id => 1,
- pid => self(),
- viewable_channels => #{100 => true},
- active_guilds => [42],
- pending_connect => false
- }
- }
- }.
-
-presence_view_trims_member_data_by_default_test() ->
- application:set_env(fluxer_gateway, presence_snapshot_trim_member_threshold, 2),
- Tab = ets:new(view_trim_members, [set, public]),
- try
- State = view_trim_test_state(Tab),
- View = presence_view(State),
- ViewData = maps:get(data, View),
- ?assertEqual(maps:without(?HEAVY_MEMBER_DATA_KEYS, maps:get(data, State)), ViewData),
- ?assertEqual(Tab, maps:get(members_ets, ViewData)),
- ?assertEqual(maps:get(sessions, State), maps:get(sessions, View)),
- ?assertEqual([data, id, sessions], lists:sort(maps:keys(View)))
- after
- application:unset_env(fluxer_gateway, presence_snapshot_trim_member_threshold),
- ets:delete(Tab)
- end.
-
-presence_view_keeps_member_data_when_trim_disabled_test() ->
- application:set_env(fluxer_gateway, presence_snapshot_trim_enabled, false),
- Tab = ets:new(view_notrim_members, [set, public]),
- try
- State = (view_trim_test_state(Tab))#{member_count => 100000},
- ?assertEqual(maps:get(data, State), maps:get(data, presence_view(State)))
- after
- application:unset_env(fluxer_gateway, presence_snapshot_trim_enabled),
- ets:delete(Tab)
- end.
-
-presence_view_keeps_member_data_below_threshold_test() ->
- application:set_env(fluxer_gateway, presence_snapshot_trim_member_threshold, 50000),
- Tab = ets:new(view_below_members, [set, public]),
- try
- State = view_trim_test_state(Tab),
- ?assertEqual(maps:get(data, State), maps:get(data, presence_view(State)))
- after
- application:unset_env(fluxer_gateway, presence_snapshot_trim_member_threshold),
- ets:delete(Tab)
- end.
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_presence_sync.erl b/fluxer_gateway/src/guild/guild_presence_sync.erl
index d75097708..6796addd0 100644
--- a/fluxer_gateway/src/guild/guild_presence_sync.erl
+++ b/fluxer_gateway/src/guild/guild_presence_sync.erl
@@ -1,9 +1,6 @@
%% SPDX-License-Identifier: AGPL-3.0-or-later
-module(guild_presence_sync).
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
--endif.
-typing([eqwalizer]).
@@ -130,29 +127,6 @@ session_channel_list_shares(SessionUserId, TargetChannelMap, State) ->
),
lists:any(fun(Ch) -> maps:is_key(Ch, TargetChannelMap) end, SessionChannelList).
--spec maps_share_any_key(map(), map()) -> boolean().
-maps_share_any_key(MapA, MapB) ->
- {Smaller, Larger} =
- case map_size(MapA) =< map_size(MapB) of
- true -> {MapA, MapB};
- false -> {MapB, MapA}
- end,
- maps_share_any_key_iter(maps:iterator(Smaller), Larger).
-
--spec maps_share_any_key_iter(maps:iterator(), map()) -> boolean().
-maps_share_any_key_iter(Iterator, LargerMap) ->
- case maps:next(Iterator) of
- none -> false;
- {Key, _, NextIterator} -> key_matches_or_continue(Key, NextIterator, LargerMap)
- end.
-
--spec key_matches_or_continue(term(), maps:iterator(), map()) -> boolean().
-key_matches_or_continue(Key, NextIterator, LargerMap) ->
- case maps:is_key(Key, LargerMap) of
- true -> true;
- false -> maps_share_any_key_iter(NextIterator, LargerMap)
- end.
-
-spec get_user_viewable_channel_map(user_id(), map(), guild_state()) -> map().
get_user_viewable_channel_map(UserId, Sessions, State) ->
case find_session_viewable_channels_for_user(UserId, Sessions) of
@@ -210,149 +184,3 @@ session_data_pid(SessionData) ->
Pid when is_pid(Pid) -> {true, Pid};
_ -> false
end.
-
--ifdef(TEST).
-
-get_user_viewable_channel_map_uses_session_cache_test() ->
- Sessions = #{
- <<"s1">> => #{user_id => 10, viewable_channels => #{100 => true, 200 => true}},
- <<"s2">> => #{user_id => 20, viewable_channels => #{300 => true}}
- },
- State = #{sessions => Sessions, data => #{<<"members">> => #{}}},
- Result = get_user_viewable_channel_map(10, Sessions, State),
- ?assertEqual(#{100 => true, 200 => true}, Result).
-
-get_user_viewable_channel_map_skips_session_without_cache_test() ->
- Sessions = #{
- <<"s1">> => #{user_id => 10},
- <<"s2">> => #{user_id => 10, viewable_channels => #{100 => true}}
- },
- State = #{sessions => Sessions, data => #{<<"members">> => #{}}},
- Result = get_user_viewable_channel_map(10, Sessions, State),
- ?assertEqual(#{100 => true}, Result).
-
-session_shares_channels_uses_cached_viewable_test() ->
- SessionData = #{user_id => 20, viewable_channels => #{100 => true, 200 => true}},
- TargetChannelMap = #{200 => true, 300 => true},
- State = #{sessions => #{}, data => #{<<"members">> => #{}}},
- ?assertEqual(true, session_shares_channels(SessionData, 20, TargetChannelMap, State)).
-
-session_shares_channels_no_overlap_test() ->
- SessionData = #{user_id => 20, viewable_channels => #{100 => true}},
- TargetChannelMap = #{200 => true, 300 => true},
- State = #{sessions => #{}, data => #{<<"members">> => #{}}},
- ?assertEqual(false, session_shares_channels(SessionData, 20, TargetChannelMap, State)).
-
-partition_subscribed_sessions_uses_cached_channels_test() ->
- Sessions = #{
- <<"s1">> => #{user_id => 20, pid => self(), viewable_channels => #{100 => true}},
- <<"s2">> => #{user_id => 30, pid => self(), viewable_channels => #{200 => true}}
- },
- TargetChannelMap = #{100 => true, 300 => true},
- State = #{sessions => Sessions, data => #{<<"members">> => #{}}},
- {Valid, Invalid} = partition_subscribed_sessions(
- [<<"s1">>, <<"s2">>], Sessions, TargetChannelMap, 10, State
- ),
- ?assertEqual([<<"s1">>], Valid),
- ?assertEqual([<<"s2">>], Invalid).
-
-partition_subscribed_sessions_excludes_target_user_test() ->
- Sessions = #{
- <<"s1">> => #{user_id => 10, pid => self(), viewable_channels => #{100 => true}}
- },
- assert_partition_result(Sessions, #{100 => true}, [], [<<"s1">>]).
-
-partition_subscribed_sessions_missing_session_test() ->
- assert_partition_result(#{}, #{100 => true}, [], [<<"s1">>]).
-
-sync_member_data_updates_loaded_channel_engines_test() ->
- GuildId = 100,
- UserId = 10,
- ChannelId = 500,
- BotsRoleId = 200,
- CountingRoleId = 300,
- DefaultRef = guild_member_list_engine:new(),
- ChannelRef = guild_member_list_engine:new(),
- try
- ok = load_sync_member_test_ref(DefaultRef, UserId, CountingRoleId, BotsRoleId),
- ok = load_sync_member_test_ref(ChannelRef, UserId, CountingRoleId, BotsRoleId),
- State = sync_member_data_test_state(
- GuildId, UserId, ChannelId, BotsRoleId, CountingRoleId, DefaultRef, ChannelRef
- ),
- ?assertEqual(stale_groups(BotsRoleId), guild_member_list_engine:get_groups(ChannelRef)),
- ok = sync_member_data(UserId, State),
- ?assertEqual(
- hoisted_groups(BotsRoleId), guild_member_list_engine:get_groups(ChannelRef)
- )
- after
- guild_member_list_engine:destroy(DefaultRef),
- guild_member_list_engine:destroy(ChannelRef)
- end.
-
-assert_partition_result(Sessions, TargetChannelMap, ExpectedValid, ExpectedInvalid) ->
- State = #{sessions => Sessions, data => #{<<"members">> => #{}}},
- {Valid, Invalid} = partition_subscribed_sessions(
- [<<"s1">>], Sessions, TargetChannelMap, 10, State
- ),
- ?assertEqual(ExpectedValid, Valid),
- ?assertEqual(ExpectedInvalid, Invalid).
-
--spec load_sync_member_test_ref(
- guild_member_list_store:store_ref(), integer(), integer(), integer()
-) -> ok.
-load_sync_member_test_ref(Ref, UserId, MemberRoleId, HoistedRoleId) ->
- guild_member_list_engine:bulk_load(
- Ref, [{UserId, <<"counting">>, [MemberRoleId], true}], [HoistedRoleId]
- ).
-
-sync_member_data_test_state(
- GuildId, UserId, ChannelId, BotsRoleId, CountingRoleId, DefaultRef, ChannelRef
-) ->
- Data = guild_data_index:normalize_data(#{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(UserId)},
- <<"roles">> => [
- role(GuildId, <<"everyone">>, false, 0),
- role(BotsRoleId, <<"bots">>, true, 1),
- role(CountingRoleId, <<"Counting">>, false, 1)
- ],
- <<"members">> => [
- #{
- <<"user">> => #{
- <<"id">> => integer_to_binary(UserId),
- <<"username">> => <<"Counting">>
- },
- <<"roles">> => [
- integer_to_binary(BotsRoleId), integer_to_binary(CountingRoleId)
- ]
- }
- ],
- <<"channels">> => [
- #{<<"id">> => integer_to_binary(ChannelId), <<"permission_overwrites">> => []}
- ]
- }),
- #{
- id => GuildId,
- data => Data,
- sessions => #{},
- member_presence => #{UserId => #{<<"status">> => <<"online">>}},
- connected_user_ids => sets:from_list([UserId]),
- member_list_engine => DefaultRef,
- channel_member_list_engines => #{integer_to_binary(ChannelId) => ChannelRef}
- }.
-
-role(RoleId, Name, Hoist, Position) ->
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"name">> => Name,
- <<"hoist">> => Hoist,
- <<"position">> => Position,
- <<"permissions">> => <<"0">>
- }.
-
-stale_groups(RoleId) ->
- [{integer_to_binary(RoleId), 0}, {<<"online">>, 1}, {<<"offline">>, 0}].
-
-hoisted_groups(RoleId) ->
- [{integer_to_binary(RoleId), 1}, {<<"online">>, 0}, {<<"offline">>, 0}].
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_sessions_presence.erl b/fluxer_gateway/src/guild/guild_sessions_presence.erl
index 07a651cd9..cb4918c6c 100644
--- a/fluxer_gateway/src/guild/guild_sessions_presence.erl
+++ b/fluxer_gateway/src/guild/guild_sessions_presence.erl
@@ -129,121 +129,3 @@ safe_presence_cache_get(UserId) ->
exit:_ -> not_found;
throw:_ -> not_found
end.
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-subscribe_unsubscribe_presence_test_() ->
- {setup, fun ensure_test_deps/0, fun(_) -> stop_test_deps() end, fun(_) ->
- [fun subscribe_unsubscribe_body/0]
- end}.
-
-subscribe_unsubscribe_body() ->
- State0 = #{presence_subscriptions => #{}},
- State1 = subscribe_to_user_presence(10, State0),
- Subs1 = maps:get(presence_subscriptions, State1),
- ?assertEqual(1, maps:get(10, Subs1)),
- State2 = subscribe_to_user_presence(10, State1),
- Subs2 = maps:get(presence_subscriptions, State2),
- ?assertEqual(2, maps:get(10, Subs2)),
- State3 = unsubscribe_from_user_presence(10, State2),
- Subs3 = maps:get(presence_subscriptions, State3),
- ?assertEqual(1, maps:get(10, Subs3)),
- State4 = unsubscribe_from_user_presence(10, State3),
- Subs4 = maps:get(presence_subscriptions, State4),
- ?assertEqual(false, maps:is_key(10, Subs4)).
-
-unsubscribe_from_user_presence_zero_count_noop_test() ->
- State = #{presence_subscriptions => #{10 => 0}},
- Result = unsubscribe_from_user_presence(10, State),
- ?assertEqual(State, Result).
-
-unsubscribe_from_user_presence_missing_user_noop_test() ->
- State = #{presence_subscriptions => #{}},
- Result = unsubscribe_from_user_presence(999, State),
- ?assertEqual(State, Result).
-
-unsubscribe_many_from_user_presence_decrements_once_test() ->
- State = #{presence_subscriptions => #{10 => 5}},
- Result = unsubscribe_many_from_user_presence(10, 3, State),
- ?assertEqual(#{10 => 2}, maps:get(presence_subscriptions, Result)).
-
-unsubscribe_many_from_user_presence_removes_when_exhausted_test() ->
- State = #{presence_subscriptions => #{10 => 2}},
- Result = unsubscribe_many_from_user_presence(10, 3, State),
- ?assertEqual(#{}, maps:get(presence_subscriptions, Result)).
-
-handle_user_offline_nonzero_count_noop_test() ->
- Tab = make_presence_tab(#{10 => #{<<"status">> => <<"online">>}}),
- State = #{
- presence_subscriptions => #{10 => 1},
- member_presence => Tab
- },
- Result = handle_user_offline(10, State),
- ?assertEqual(State, Result).
-
-handle_user_offline_missing_user_cleans_member_presence_test() ->
- Tab = make_presence_tab(#{999 => #{<<"status">> => <<"online">>}}),
- State = #{
- presence_subscriptions => #{},
- member_presence => Tab
- },
- Result = handle_user_offline(999, State),
- ?assertEqual([], ets:tab2list(maps:get(member_presence, Result))),
- ?assertEqual(#{}, maps:get(presence_subscriptions, Result)).
-
-ensure_test_deps() ->
- ensure_mock_registered(presence_bus),
- ensure_mock_registered(presence_cache).
-
-stop_test_deps() ->
- stop_mock_registered(presence_bus),
- stop_mock_registered(presence_cache).
-
-ensure_mock_registered(Name) ->
- case whereis(Name) of
- undefined ->
- Pid = spawn(fun mock_gen_server_loop/0),
- register(Name, Pid),
- Pid;
- Pid ->
- Pid
- end.
-
-stop_mock_registered(Name) ->
- case whereis(Name) of
- undefined -> ok;
- Pid -> stop_mock_pid(Name, Pid)
- end.
-
-stop_mock_pid(Name, Pid) ->
- try
- unregister(Name)
- catch
- error:_ -> ok
- end,
- Pid ! stop,
- ok.
-
-mock_gen_server_loop() ->
- receive
- {'$gen_call', From, {get, _}} ->
- gen_server:reply(From, not_found),
- mock_gen_server_loop();
- {'$gen_call', From, _Msg} ->
- gen_server:reply(From, ok),
- mock_gen_server_loop();
- stop ->
- ok;
- _ ->
- mock_gen_server_loop()
- after 5000 ->
- ok
- end.
-
-make_presence_tab(Map) ->
- Tab = ets:new(test_member_presence, [set, public]),
- maps:foreach(fun(K, V) -> ets:insert(Tab, {K, V}) end, Map),
- Tab.
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_subscription_handler.erl b/fluxer_gateway/src/guild/guild_subscription_handler.erl
index f94f29e0c..4a1e2d7e0 100644
--- a/fluxer_gateway/src/guild/guild_subscription_handler.erl
+++ b/fluxer_gateway/src/guild/guild_subscription_handler.erl
@@ -1,9 +1,6 @@
%% SPDX-License-Identifier: AGPL-3.0-or-later
-module(guild_subscription_handler).
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
--endif.
-typing([eqwalizer]).
@@ -441,376 +438,3 @@ handle_removed_subscriptions(Removed, State) ->
State,
Removed
).
-
--ifdef(TEST).
-
--spec disabled_operations_state(integer() | binary()) -> guild_state().
-disabled_operations_state(Value) ->
- #{data => #{<<"guild">> => #{<<"disabled_operations">> => Value}}}.
-
-should_ignore_member_list_subscribe_ignores_non_empty_ranges_when_disabled_test() ->
- ?assertEqual(
- true,
- should_ignore_member_list_subscribe(
- [{0, 99}],
- disabled_operations_state(1 bsl 6)
- )
- ).
-
-should_ignore_member_list_subscribe_allows_empty_ranges_when_disabled_test() ->
- ?assertEqual(
- false,
- should_ignore_member_list_subscribe(
- [],
- disabled_operations_state(1 bsl 6)
- )
- ).
-
-buffer_lazy_subscribe_creates_buffer_entry_test() ->
- State = #{},
- Request = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- NewState = buffer_lazy_subscribe(Request, State),
- Buffer = maps:get(lazy_subscribe_buffer, NewState),
- ?assertEqual(Request, maps:get({<<"s1">>, 500}, Buffer)),
- ?assertEqual([{<<"s1">>, 500}], maps:get(lazy_subscribe_order, NewState)),
- ?assertNotEqual(undefined, maps:get(lazy_subscribe_timer, NewState, undefined)).
-
-buffer_lazy_subscribe_merges_older_request_ranges_test() ->
- State = #{},
- Request1 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 1}]},
- State1 = buffer_lazy_subscribe(Request1, State),
- Request2 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{2, 99}]},
- State2 = buffer_lazy_subscribe(Request2, State1),
- Buffer = maps:get(lazy_subscribe_buffer, State2),
- ?assertEqual(Request2#{ranges := [{0, 99}]}, maps:get({<<"s1">>, 500}, Buffer)),
- ?assertEqual(1, map_size(Buffer)),
- ?assertEqual([{<<"s1">>, 500}], maps:get(lazy_subscribe_order, State2)).
-
-buffer_lazy_subscribe_empty_ranges_replace_buffered_subscribe_test() ->
- State = #{},
- Request1 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- State1 = buffer_lazy_subscribe(Request1, State),
- Request2 = #{session_id => <<"s1">>, channel_id => 500, ranges => []},
- State2 = buffer_lazy_subscribe(Request2, State1),
- Buffer = maps:get(lazy_subscribe_buffer, State2),
- ?assertEqual(Request2, maps:get({<<"s1">>, 500}, Buffer)),
- ?assertEqual(1, map_size(Buffer)),
- ?assertEqual([{<<"s1">>, 500}], maps:get(lazy_subscribe_order, State2)).
-
-buffer_lazy_subscribe_keeps_separate_sessions_test() ->
- State = #{},
- Request1 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- State1 = buffer_lazy_subscribe(Request1, State),
- Request2 = #{session_id => <<"s2">>, channel_id => 500, ranges => [{0, 50}]},
- State2 = buffer_lazy_subscribe(Request2, State1),
- Buffer = maps:get(lazy_subscribe_buffer, State2),
- ?assertEqual(2, map_size(Buffer)),
- ?assertEqual(Request1, maps:get({<<"s1">>, 500}, Buffer)),
- ?assertEqual(Request2, maps:get({<<"s2">>, 500}, Buffer)),
- ?assertEqual([{<<"s1">>, 500}, {<<"s2">>, 500}], maps:get(lazy_subscribe_order, State2)).
-
-buffer_lazy_subscribe_moves_replaced_key_to_tail_test() ->
- State = #{},
- Request1 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- State1 = buffer_lazy_subscribe(Request1, State),
- Request2 = #{session_id => <<"s1">>, channel_id => 600, ranges => [{0, 99}]},
- State2 = buffer_lazy_subscribe(Request2, State1),
- Request3 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{100, 199}]},
- State3 = buffer_lazy_subscribe(Request3, State2),
- ?assertEqual([{<<"s1">>, 600}, {<<"s1">>, 500}], maps:get(lazy_subscribe_order, State3)),
- ?assertEqual(
- [{<<"s1">>, 600}, {<<"s1">>, 500}],
- ordered_lazy_subscribe_keys(State3, maps:get(lazy_subscribe_buffer, State3))
- ).
-
-buffer_lazy_subscribe_keeps_newest_ranges_over_limit_test() ->
- Existing = [{Start * 200, Start * 200 + 99} || Start <- lists:seq(0, 9)],
- Request1 = #{session_id => <<"s1">>, channel_id => 500, ranges => Existing},
- State1 = buffer_lazy_subscribe(Request1, #{}),
- Request2 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}, {5000, 5099}]},
- State2 = buffer_lazy_subscribe(Request2, State1),
- Buffer = maps:get(lazy_subscribe_buffer, State2),
- ?assertEqual(
- Request2#{ranges := [{0, 99}, {5000, 5099}]}, maps:get({<<"s1">>, 500}, Buffer)
- ).
-
-buffer_lazy_subscribe_caps_merged_ranges_test() ->
- Existing = [{Start * 200, Start * 200 + 99} || Start <- lists:seq(0, 9)],
- Request1 = #{session_id => <<"s1">>, channel_id => 500, ranges => Existing},
- State1 = buffer_lazy_subscribe(Request1, #{}),
- Ranges2 = [{Start * 200, Start * 200 + 99} || Start <- lists:seq(20, 30)],
- Request2 = #{session_id => <<"s1">>, channel_id => 500, ranges => Ranges2},
- State2 = buffer_lazy_subscribe(Request2, State1),
- Buffer = maps:get(lazy_subscribe_buffer, State2),
- #{ranges := Merged} = maps:get({<<"s1">>, 500}, Buffer),
- ?assertEqual(?MAX_BUFFERED_LAZY_SUBSCRIBE_RANGES, length(Merged)),
- ?assertEqual(lists:sublist(Ranges2, ?MAX_BUFFERED_LAZY_SUBSCRIBE_RANGES), Merged).
-
-flush_lazy_subscribe_buffer_clears_state_test() ->
- Buffer = #{{<<"s1">>, 500} => #{session_id => <<"s1">>, channel_id => 500, ranges => []}},
- State = #{lazy_subscribe_buffer => Buffer, lazy_subscribe_timer => make_ref()},
- NewState = flush_lazy_subscribe_buffer(State),
- ?assertEqual(error, maps:find(lazy_subscribe_buffer, NewState)),
- ?assertEqual(error, maps:find(lazy_subscribe_order, NewState)),
- ?assertEqual(error, maps:find(lazy_subscribe_timer, NewState)).
-
-warm_list_state(ChannelId) ->
- ListId = integer_to_binary(ChannelId),
- #{
- data => #{
- <<"channel_index">> => #{
- ChannelId => #{<<"id">> => ListId}
- }
- },
- ?ENGINES_KEY => #{ListId => warm_list_state_engine_ref}
- }.
-
-dispatch_immediately_requires_idle_window_test() ->
- Request = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- Warm = warm_list_state(500),
- ?assertEqual(true, dispatch_immediately(Request, Warm)),
- ?assertEqual(
- false, dispatch_immediately(Request, Warm#{lazy_subscribe_timer => make_ref()})
- ),
- ?assertEqual(
- false,
- dispatch_immediately(Request, Warm#{
- lazy_subscribe_buffer => #{{<<"s2">>, 501} => Request}
- })
- ).
-
-warm_subscribe_records_the_dispatched_request_test() ->
- Request = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- NewState = buffer_lazy_subscribe(Request, warm_list_state(500)),
- Buffer = maps:get(lazy_subscribe_buffer, NewState),
- ?assertEqual(Request#{?DISPATCHED_KEY => true}, maps:get({<<"s1">>, 500}, Buffer)),
- ?assertEqual([{<<"s1">>, 500}], maps:get(lazy_subscribe_order, NewState)),
- ?assertNotEqual(undefined, maps:get(lazy_subscribe_timer, NewState, undefined)).
-
-subscribe_behind_a_warm_dispatch_is_coalesced_test() ->
- Request1 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- State1 = buffer_lazy_subscribe(Request1, warm_list_state(500)),
- Request2 = #{session_id => <<"s2">>, channel_id => 500, ranges => [{0, 99}]},
- State2 = buffer_lazy_subscribe(Request2, State1),
- Buffer = maps:get(lazy_subscribe_buffer, State2),
- ?assertEqual(Request2, maps:get({<<"s2">>, 500}, Buffer)),
- ?assertEqual(Request1#{?DISPATCHED_KEY => true}, maps:get({<<"s1">>, 500}, Buffer)),
- ?assertEqual(2, map_size(Buffer)).
-
-%% Reference oracle: what enqueue_lazy_subscribe/2 buffered for a repeated
-%% {session, channel} before the leading-edge dispatch existed.
-reference_coalesced_request(Request1, Request2) ->
- merge_lazy_subscribe_request(Request1, Request2).
-
-repeated_warm_subscribe_merges_like_the_pre_leading_edge_path_test() ->
- Request1 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- Request2 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{100, 199}]},
- State1 = buffer_lazy_subscribe(Request1, warm_list_state(500)),
- State2 = buffer_lazy_subscribe(Request2, State1),
- Buffer = maps:get(lazy_subscribe_buffer, State2),
- Merged = maps:get({<<"s1">>, 500}, Buffer),
- ?assertEqual(1, map_size(Buffer)),
- ?assertEqual(reference_coalesced_request(Request1, Request2), Merged),
- ?assertNot(maps:is_key(?DISPATCHED_KEY, Merged)),
- ?assertEqual([{<<"s1">>, 500}], maps:get(lazy_subscribe_order, State2)).
-
-repeated_warm_subscribe_with_empty_ranges_replaces_test() ->
- Request1 = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- Request2 = #{session_id => <<"s1">>, channel_id => 500, ranges => []},
- State1 = buffer_lazy_subscribe(Request1, warm_list_state(500)),
- State2 = buffer_lazy_subscribe(Request2, State1),
- Merged = maps:get({<<"s1">>, 500}, maps:get(lazy_subscribe_buffer, State2)),
- ?assertEqual(reference_coalesced_request(Request1, Request2), Merged),
- ?assertNot(maps:is_key(?DISPATCHED_KEY, Merged)).
-
-dispatched_entry_state() ->
- Key = {<<"s1">>, 500},
- Dispatched = #{session_id => <<"s1">>, channel_id => 500, ?DISPATCHED_KEY => true},
- State = #{
- lazy_subscribe_buffer => #{Key => Dispatched},
- lazy_subscribe_order => [Key],
- lazy_subscribe_timer => make_ref()
- },
- {Key, Dispatched, State}.
-
-flush_skips_an_already_dispatched_entry_test() ->
- {_Key, _Dispatched, State} = dispatched_entry_state(),
- NewState = flush_lazy_subscribe_buffer(State),
- ?assertEqual(error, maps:find(lazy_subscribe_buffer, NewState)),
- ?assertEqual(error, maps:find(lazy_subscribe_order, NewState)),
- ?assertEqual(error, maps:find(lazy_subscribe_timer, NewState)).
-
-flush_processes_the_same_entry_once_unmarked_test() ->
- {Key, Dispatched, State} = dispatched_entry_state(),
- Unmarked = maps:remove(?DISPATCHED_KEY, Dispatched),
- ?assertError(
- {badmatch, _},
- flush_lazy_subscribe_buffer(State#{lazy_subscribe_buffer => #{Key => Unmarked}})
- ).
-
-failed_warm_dispatch_is_not_re_enqueued_test() ->
- Warm = warm_list_state(500),
- Broken = #{session_id => <<"s1">>, channel_id => 500},
- ?assertEqual(Warm, buffer_lazy_subscribe(Broken, Warm)).
-
-failed_warm_dispatch_does_not_escape_handle_call_test() ->
- Warm = warm_list_state(500),
- Broken = #{session_id => <<"s1">>, channel_id => 500},
- From = {self(), make_ref()},
- ?assertEqual({reply, ok, Warm}, handle_call({lazy_subscribe, Broken}, From, Warm)).
-
-cold_list_still_uses_the_coalesce_buffer_test() ->
- Request = #{session_id => <<"s1">>, channel_id => 500, ranges => [{0, 99}]},
- State = maps:put(?ENGINES_KEY, #{}, warm_list_state(500)),
- NewState = buffer_lazy_subscribe(Request, State),
- Buffer = maps:get(lazy_subscribe_buffer, NewState),
- ?assertEqual(Request, maps:get({<<"s1">>, 500}, Buffer)).
-
-member_subscription_test_member(UserId, RoleIds) ->
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [integer_to_binary(RoleId) || RoleId <- RoleIds]
- }.
-
-member_subscription_test_presence(UserId) ->
- #{<<"status">> => <<"online">>, <<"user">> => #{<<"id">> => integer_to_binary(UserId)}}.
-
-member_subscription_test_state() ->
- GuildId = 42,
- View = integer_to_binary(constants:view_channel_permission()),
- Channels = [
- #{
- <<"id">> => <<"500">>,
- <<"type">> => 0,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => <<"3000">>,
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => View
- }
- ]
- }
- ],
- Members = maps:from_list(
- [{Id, member_subscription_test_member(Id, [])} || Id <- [10 | lists:seq(20, 27)]] ++
- [{31, member_subscription_test_member(31, [3000])}]
- ),
- Tab = ets:new(member_subscription_test_presence, [set, public]),
- ets:insert(
- Tab,
- {23,
- presence_payload:build(
- maps:get(<<"user">>, maps:get(23, Members)), <<"online">>, false, false, null
- )}
- ),
- Subs = lists:foldl(
- fun(UserId, Acc) -> guild_subscriptions:subscribe(<<"s1">>, UserId, Acc) end,
- guild_subscriptions:init_state(),
- [20, 27]
- ),
- #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"7">>},
- <<"roles">> => [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => View},
- #{<<"id">> => <<"3000">>, <<"permissions">> => <<"0">>}
- ],
- <<"members">> => Members,
- <<"channels">> => Channels,
- <<"channel_index">> => guild_data_index:build_id_index(Channels)
- },
- sessions => #{
- <<"s1">> => #{user_id => 10, pid => self(), viewable_channels => #{500 => true}}
- },
- member_subscriptions => Subs,
- presence_subscriptions => #{20 => 1, 21 => 1, 22 => 2, 27 => 1},
- member_presence => Tab
- }.
-
-reference_update_member_subscriptions(SessionId, MemberIds, State) ->
- #{user_id := Viewer, viewable_channels := SessionMap} = maps:get(
- SessionId, maps:get(sessions, State)
- ),
- Filtered = [
- MemberId
- || MemberId <- MemberIds,
- MemberId =/= Viewer,
- lists:any(
- fun(ChannelId) -> maps:is_key(ChannelId, SessionMap) end,
- guild_visibility_channels:get_user_viewable_channels(MemberId, State)
- )
- ],
- {NewSubs, Added, Removed} = guild_subscriptions:update_subscriptions_with_delta(
- SessionId, Filtered, maps:get(member_subscriptions, State)
- ),
- State1 = lists:foldl(
- fun(UserId, Acc) ->
- StateWithPresence = guild_sessions_presence:subscribe_to_user_presence(UserId, Acc),
- guild_presence:send_cached_presence_to_session(UserId, SessionId, StateWithPresence)
- end,
- State#{member_subscriptions => NewSubs},
- Added
- ),
- handle_removed_subscriptions(Removed, State1).
-
-drain_mailbox(Acc) ->
- receive
- {'$gen_cast', _} = Msg -> drain_mailbox([Msg | Acc])
- after 50 -> lists:reverse(Acc)
- end.
-
-ensure_started(Name, Start) ->
- case whereis(Name) of
- undefined ->
- case Start() of
- {ok, _} -> ok;
- {error, {already_started, _}} -> ok
- end;
- _ ->
- ok
- end.
-
-update_member_subscriptions_matches_reference_test() ->
- ensure_started(presence_bus, fun presence_bus:start_link/0),
- ensure_started(presence_cache, fun presence_cache:start_link/0),
- [ok = presence_cache:put(Id, member_subscription_test_presence(Id)) || Id <- [20, 21, 23]],
- _ = sys:get_state(presence_cache),
- ?assertMatch({ok, _}, presence_cache:get(21)),
- MemberIds = [20, 21, 22, 23, 24, 25, 31, 99, 10, 21],
- _ = drain_mailbox([]),
- Expected = reference_update_member_subscriptions(
- <<"s1">>, MemberIds, member_subscription_test_state()
- ),
- ExpectedDispatches = drain_mailbox([]),
- Actual = handle_update_member_subscriptions_local(
- 42, <<"s1">>, MemberIds, member_subscription_test_state()
- ),
- ActualDispatches = drain_mailbox([]),
- Strip = fun(S) -> maps:without([member_presence], S) end,
- ?assertEqual(Strip(Expected), Strip(Actual)),
- ?assertEqual(ExpectedDispatches, ActualDispatches),
- ?assertEqual(2, length(ActualDispatches)),
- ?assertEqual(
- [20, 21, 22, 23, 24, 25],
- lists:sort(
- sets:to_list(
- guild_subscriptions:get_user_ids_for_session(
- <<"s1">>, maps:get(member_subscriptions, Actual)
- )
- )
- )
- ).
-
-cached_presences_reports_every_requested_user_test() ->
- ensure_started(presence_cache, fun presence_cache:start_link/0),
- ok = presence_cache:put(61, member_subscription_test_presence(61)),
- _ = sys:get_state(presence_cache),
- ?assertEqual(
- #{61 => presence_cache_safe:get(61), 62 => not_found},
- guild_presence:cached_presences([61, 62])
- ),
- ?assertEqual(#{}, guild_presence:cached_presences([])).
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_user_data.erl b/fluxer_gateway/src/guild/guild_user_data.erl
index 782e8b9c2..f92f85382 100644
--- a/fluxer_gateway/src/guild/guild_user_data.erl
+++ b/fluxer_gateway/src/guild/guild_user_data.erl
@@ -1,9 +1,6 @@
%% SPDX-License-Identifier: AGPL-3.0-or-later
-module(guild_user_data).
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
--endif.
-typing([eqwalizer]).
@@ -123,74 +120,3 @@ maybe_handle_changed_author_data(UserId, AuthorData, Member, State) ->
true -> handle_user_data_update(UserId, AuthorData, State);
false -> State
end.
-
--ifdef(TEST).
-
-handle_user_data_update_no_change_test() ->
- State = test_state(),
- UserData = #{<<"id">> => <<"100">>, <<"username">> => <<"alice">>},
- NewState = handle_user_data_update(100, UserData, State),
- ?assertEqual(State, NewState).
-
-message_create_equivalent_author_data_does_not_dispatch_member_update_test() ->
- drain_test_mailbox(),
- State = normalized_test_state(),
- Author = #{
- <<"id">> => <<"100">>,
- <<"username">> => <<"alice">>,
- <<"discriminator">> => <<"0001">>,
- <<"global_name">> => null,
- <<"avatar">> => null,
- <<"avatar_color">> => null,
- <<"flags">> => 0
- },
- NewState = maybe_update_cached_user_data(message_create, #{<<"author">> => Author}, State),
- ?assertEqual(State, NewState),
- assert_no_member_update_dispatch().
-
-test_state() ->
- #{
- id => 42,
- data => #{
- <<"members">> => #{
- 100 => #{<<"user">> => #{<<"id">> => <<"100">>, <<"username">> => <<"alice">>}}
- }
- }
- }.
-
-normalized_test_state() ->
- #{
- id => 42,
- data => guild_data_index_members:put_member(
- #{
- <<"user">> => #{
- <<"id">> => <<"100">>,
- <<"username">> => <<"alice">>,
- <<"discriminator">> => <<"0001">>,
- <<"global_name">> => null,
- <<"avatar">> => null,
- <<"avatar_color">> => null,
- <<"flags">> => 0
- },
- <<"roles">> => []
- },
- #{}
- )
- }.
-
-drain_test_mailbox() ->
- receive
- _ -> drain_test_mailbox()
- after 0 ->
- ok
- end.
-
-assert_no_member_update_dispatch() ->
- receive
- {'$gen_cast', {dispatch, #{event := guild_member_update}}} ->
- ?assert(false)
- after 50 ->
- ok
- end.
-
--endif.
diff --git a/fluxer_gateway/test/channel_threads_config_tests.erl b/fluxer_gateway/test/channel_threads_config_tests.erl
deleted file mode 100644
index 27bec7cb5..000000000
--- a/fluxer_gateway/test/channel_threads_config_tests.erl
+++ /dev/null
@@ -1,273 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(channel_threads_config_tests).
--typing([eqwalizer]).
--include_lib("eunit/include/eunit.hrl").
-
--define(KEY, channel_threads_config).
--define(PULLED_KEY, {channel_threads_config, pulled}).
-
-config_fails_closed_when_nothing_is_stored_test() ->
- with_stored(undefined, fun() ->
- ?assertEqual(channel_threads_config:default_config(), channel_threads_config:config()),
- ?assertEqual(0, channel_threads_config:version()),
- ?assertNot(channel_threads_config:ever_enabled()),
- ?assertNot(channel_threads_config:guild_active(1)),
- ?assertNot(channel_threads_config:user_active(1)),
- ?assertNot(channel_threads_config:user_excluded(1))
- end).
-
-validate_accepts_a_full_wire_config_test() ->
- {ok, Config} = channel_threads_config:validate_config(full_wire()),
- ?assertMatch(
- #{
- enabled := true,
- config_version := 7,
- ever_enabled := true,
- guild_basis_points := 250,
- guild_salt := <<"guild salt">>,
- user_basis_points := 10000,
- user_salt := <<"user-salt">>
- },
- Config
- ),
- ?assertEqual(#{<<"10">> => true, <<"11">> => true}, maps:get(enabled_guilds, Config)),
- ?assertEqual(#{<<"12">> => true}, maps:get(disabled_guilds, Config)),
- ?assertEqual(#{<<"20">> => true}, maps:get(included_users, Config)),
- ?assertEqual(#{<<"21">> => true}, maps:get(excluded_users, Config)).
-
-validate_fills_defaults_and_ignores_unknown_keys_test() ->
- {ok, Config} = channel_threads_config:validate_config(#{
- <<"enabled">> => true, <<"future_field">> => 1
- }),
- Default = channel_threads_config:default_config(),
- ?assertEqual(Default#{enabled := true}, Config),
- ?assertEqual(<<"channel-threads-guild-v1">>, maps:get(guild_salt, Config)),
- ?assertEqual(<<"channel-threads-user-v1">>, maps:get(user_salt, Config)).
-
-validate_rejects_every_malformed_field_test() ->
- Invalid = [
- {<<"enabled">>, <<"true">>},
- {<<"ever_enabled">>, 1},
- {<<"config_version">>, -1},
- {<<"config_version">>, 1.5},
- {<<"guild_basis_points">>, 10001},
- {<<"user_basis_points">>, -1},
- {<<"guild_salt">>, <<>>},
- {<<"user_salt">>, binary:copy(<<"a">>, 65)},
- {<<"guild_salt">>, <<"caf", 16#c3, 16#a9>>},
- {<<"user_salt">>, <<"tab\there">>},
- {<<"enabled_guild_ids">>, <<"1">>},
- {<<"disabled_guild_ids">>, [1]},
- {<<"included_user_ids">>, [<<"12a">>]},
- {<<"excluded_user_ids">>, [<<>>]},
- {<<"included_user_ids">>, [binary:copy(<<"1">>, 21)]},
- {<<"enabled_guild_ids">>, [integer_to_binary(N) || N <- lists:seq(1, 1001)]}
- ],
- lists:foreach(
- fun({Key, Value} = Case) ->
- ?assertMatch(
- {Case, {error, {invalid_field, Key, _}}},
- {Case, channel_threads_config:validate_config(#{Key => Value})}
- )
- end,
- Invalid
- ).
-
-validate_accepts_the_boundaries_test() ->
- {ok, _} = channel_threads_config:validate_config(#{
- <<"guild_basis_points">> => 10000,
- <<"user_basis_points">> => 0,
- <<"guild_salt">> => binary:copy(<<"~">>, 64),
- <<"included_user_ids">> => [<<"18446744073709551615">>],
- <<"disabled_guild_ids">> => [integer_to_binary(N) || N <- lists:seq(1, 1000)]
- }).
-
-guild_precedence_is_excluded_then_included_then_bucket_test() ->
- Config = config(#{
- <<"guild_basis_points">> => 10000,
- <<"enabled_guild_ids">> => [<<"5">>],
- <<"disabled_guild_ids">> => [<<"5">>, <<"6">>]
- }),
- ?assertNot(channel_threads_config:guild_active(Config, 5)),
- ?assertNot(channel_threads_config:guild_active(Config, 6)),
- ?assert(channel_threads_config:guild_active(Config, 7)),
- Included = config(#{<<"enabled_guild_ids">> => [<<"8">>]}),
- ?assert(channel_threads_config:guild_active(Included, 8)),
- ?assertNot(channel_threads_config:guild_active(Included, 9)).
-
-guild_bucket_threshold_matches_the_shared_vectors_test() ->
- ?assertNot(
- channel_threads_config:guild_active(config(#{<<"guild_basis_points">> => 6741}), 1)
- ),
- ?assert(
- channel_threads_config:guild_active(config(#{<<"guild_basis_points">> => 6742}), 1)
- ),
- ?assertNot(
- channel_threads_config:guild_active(config(#{<<"guild_basis_points">> => 9122}), 0)
- ),
- ?assert(
- channel_threads_config:guild_active(config(#{<<"guild_basis_points">> => 9123}), 0)
- ).
-
-user_bucket_threshold_matches_the_shared_vectors_test() ->
- ?assertNot(
- channel_threads_config:user_active(config(#{<<"user_basis_points">> => 3403}), 1)
- ),
- ?assert(channel_threads_config:user_active(config(#{<<"user_basis_points">> => 3404}), 1)).
-
-user_precedence_and_exclusion_test() ->
- Config = config(#{
- <<"user_basis_points">> => 10000,
- <<"included_user_ids">> => [<<"1">>],
- <<"excluded_user_ids">> => [<<"1">>, <<"2">>]
- }),
- ?assertNot(channel_threads_config:user_active(Config, 1)),
- ?assertNot(channel_threads_config:user_active(Config, 2)),
- ?assert(channel_threads_config:user_active(Config, 3)),
- ?assert(channel_threads_config:user_excluded(Config, 2)),
- ?assertNot(channel_threads_config:user_excluded(Config, 3)).
-
-disabled_config_is_inactive_for_everyone_test() ->
- {ok, Config} = channel_threads_config:validate_config(
- (full_wire())#{<<"enabled">> => false}
- ),
- ?assertNot(channel_threads_config:guild_active(Config, 10)),
- ?assertNot(channel_threads_config:user_active(Config, 20)),
- ?assert(channel_threads_config:user_excluded(Config, 21)).
-
-zero_basis_points_never_buckets_in_test() ->
- Config = config(#{}),
- ?assertEqual([], [
- Id
- || Id <- lists:seq(1, 2000), channel_threads_config:guild_active(Config, Id)
- ]),
- ?assertEqual([], [
- Id
- || Id <- lists:seq(1, 2000), channel_threads_config:user_active(Config, Id)
- ]).
-
-store_keeps_the_version_monotonic_test() ->
- with_stored(undefined, fun() ->
- V5 = config(#{<<"config_version">> => 5}),
- V4 = config(#{<<"config_version">> => 4, <<"enabled">> => false}),
- Default = channel_threads_config:default_config(),
- ?assertEqual(updated, channel_threads_config:store_validated_config(Default, V5, nats)),
- ?assertEqual(5, channel_threads_config:version()),
- ?assertEqual(stale, channel_threads_config:store_validated_config(V5, V4, api)),
- ?assertEqual(5, channel_threads_config:version()),
- ?assert(maps:get(enabled, channel_threads_config:config())),
- ?assertEqual(unchanged, channel_threads_config:store_validated_config(V5, V5, api))
- end).
-
-store_keeps_ever_enabled_sticky_test() ->
- with_stored(undefined, fun() ->
- Enabled = config(#{<<"config_version">> => 1, <<"ever_enabled">> => true}),
- Killed = config(#{
- <<"config_version">> => 2, <<"enabled">> => false, <<"ever_enabled">> => false
- }),
- Default = channel_threads_config:default_config(),
- updated = channel_threads_config:store_validated_config(Default, Enabled, api),
- updated = channel_threads_config:store_validated_config(Enabled, Killed, api),
- ?assert(channel_threads_config:ever_enabled()),
- ?assertNot(maps:get(enabled, channel_threads_config:config())),
- ?assertEqual(
- unchanged,
- channel_threads_config:store_validated_config(
- channel_threads_config:config(), Killed, api
- )
- )
- end).
-
-nats_payload_is_validated_before_it_is_stored_test() ->
- with_stored(undefined, fun() ->
- Payload = iolist_to_binary(
- json:encode(#{
- <<"type">> => <<"channel_threads_config">>,
- <<"config">> => #{<<"enabled">> => true, <<"config_version">> => 3}
- })
- ),
- ?assertEqual(updated, channel_threads_config:apply_nats_payload(Payload)),
- ?assertEqual(3, channel_threads_config:version()),
- Bad = iolist_to_binary(
- json:encode(#{
- <<"config">> => #{<<"enabled">> => <<"yes">>, <<"config_version">> => 9}
- })
- ),
- ?assertEqual(rejected, channel_threads_config:apply_nats_payload(Bad)),
- ?assertEqual(rejected, channel_threads_config:apply_nats_payload(<<"not json">>)),
- ?assertEqual(rejected, channel_threads_config:apply_nats_payload(<<"[1]">>)),
- ?assertEqual(3, channel_threads_config:version())
- end).
-
-a_default_pull_counts_as_loaded_test() ->
- with_stored(undefined, fun() ->
- ?assertNot(channel_threads_config:loaded()),
- Default = iolist_to_binary(
- json:encode(#{<<"config">> => #{<<"enabled">> => false, <<"config_version">> => 0}})
- ),
- ?assertEqual(unchanged, channel_threads_config:apply_nats_payload(Default)),
- ?assertEqual(channel_threads_config:default_config(), channel_threads_config:config()),
- ?assert(channel_threads_config:loaded()),
- ?assertNot(channel_threads_config:enabled())
- end).
-
-a_rejected_pull_is_not_loaded_test() ->
- with_stored(undefined, fun() ->
- ?assertEqual(rejected, channel_threads_config:apply_nats_payload(<<"not json">>)),
- ?assertNot(channel_threads_config:loaded())
- end).
-
-fields_changed_are_split_by_dimension_test() ->
- Base = config(#{}),
- GuildOnly = config(#{<<"enabled_guild_ids">> => [<<"1">>]}),
- UserOnly = config(#{<<"user_basis_points">> => 5}),
- VersionOnly = config(#{<<"config_version">> => 9}),
- Disabled = config(#{<<"enabled">> => false}),
- ?assert(channel_threads_config:guild_fields_changed(Base, GuildOnly)),
- ?assertNot(channel_threads_config:user_fields_changed(Base, GuildOnly)),
- ?assert(channel_threads_config:user_fields_changed(Base, UserOnly)),
- ?assertNot(channel_threads_config:guild_fields_changed(Base, UserOnly)),
- ?assertNot(channel_threads_config:guild_fields_changed(Base, VersionOnly)),
- ?assertNot(channel_threads_config:user_fields_changed(Base, VersionOnly)),
- ?assert(channel_threads_config:guild_fields_changed(Base, Disabled)),
- ?assert(channel_threads_config:user_fields_changed(Base, Disabled)).
-
-config(Overrides) ->
- {ok, Config} = channel_threads_config:validate_config(
- maps:merge(#{<<"enabled">> => true}, Overrides)
- ),
- Config.
-
-full_wire() ->
- #{
- <<"enabled">> => true,
- <<"config_version">> => 7,
- <<"ever_enabled">> => true,
- <<"guild_basis_points">> => 250,
- <<"guild_salt">> => <<"guild salt">>,
- <<"enabled_guild_ids">> => [<<"10">>, <<"11">>],
- <<"disabled_guild_ids">> => [<<"12">>],
- <<"user_basis_points">> => 10000,
- <<"user_salt">> => <<"user-salt">>,
- <<"included_user_ids">> => [<<"20">>],
- <<"excluded_user_ids">> => [<<"21">>]
- }.
-
-with_stored(Value, Fun) ->
- Previous = persistent_term:get(?KEY, undefined),
- PreviousPulled = persistent_term:get(?PULLED_KEY, undefined),
- restore(?KEY, Value),
- restore(?PULLED_KEY, undefined),
- try
- Fun()
- after
- restore(?KEY, Previous),
- restore(?PULLED_KEY, PreviousPulled)
- end.
-
-restore(Key, undefined) ->
- _ = persistent_term:erase(Key),
- ok;
-restore(Key, Value) ->
- persistent_term:put(Key, Value).
diff --git a/fluxer_gateway/test/channel_threads_flip_tests.erl b/fluxer_gateway/test/channel_threads_flip_tests.erl
deleted file mode 100644
index eb7fc2bc4..000000000
--- a/fluxer_gateway/test/channel_threads_flip_tests.erl
+++ /dev/null
@@ -1,296 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(channel_threads_flip_tests).
--typing([eqwalizer]).
--include_lib("eunit/include/eunit.hrl").
-
-guild_fan_out_touches_only_guilds_whose_activity_changed_test() ->
- Previous = config(#{<<"enabled_guild_ids">> => [<<"1">>, <<"2">>]}),
- Current = config(#{<<"enabled_guild_ids">> => [<<"2">>, <<"3">>]}),
- Candidates = [{guild, Id, self()} || Id <- [1, 2, 3, 4]] ++ [{user, 1, self()}],
- ?assertEqual(
- [{guild, 1, self()}, {guild, 3, self()}],
- channel_threads_flip:affected_targets(Previous, Current, Candidates)
- ).
-
-user_fan_out_touches_only_users_whose_activity_or_exclusion_changed_test() ->
- Previous = config(#{<<"included_user_ids">> => [<<"1">>]}),
- Current = config(#{
- <<"included_user_ids">> => [<<"1">>, <<"2">>], <<"excluded_user_ids">> => [<<"3">>]
- }),
- Candidates = [{user, Id, self()} || Id <- [1, 2, 3, 4]] ++ [{guild, 2, self()}],
- ?assertEqual(
- [{user, 2, self()}, {user, 3, self()}],
- channel_threads_flip:affected_targets(Previous, Current, Candidates)
- ).
-
-user_only_change_also_recomputes_active_guilds_test() ->
- Previous = config(#{<<"enabled_guild_ids">> => [<<"1">>]}),
- Current = Previous#{excluded_users := #{<<"7">> => true}, config_version := 2},
- Candidates = [{guild, 1, self()}, {guild, 2, self()}, {user, 7, self()}],
- ?assertEqual(
- [{viewers, 1, self()}, {user, 7, self()}],
- channel_threads_flip:affected_targets(Previous, Current, Candidates)
- ).
-
-guild_flip_is_not_queued_behind_a_viewer_sweep_test() ->
- Sweep = [{viewers, Id, self()} || Id <- lists:seq(1, 100)],
- Pending0 = channel_threads_flip:schedule(Sweep, 0, empty(), fun() -> 0 end),
- Pending1 = channel_threads_flip:schedule([{guild, 500, self()}], 10, Pending0, fun() ->
- 0
- end),
- {Due, _Pending2} = channel_threads_flip:take_due(Pending1, 10, limits(10, 1000)),
- ?assert(lists:member({guild, 500, self()}, Due)),
- ?assertEqual(10, length([T || {viewers, _, _} = T <- Due])).
-
-first_load_flips_guilds_but_not_users_test() ->
- Previous = channel_threads_config:default_config(),
- Current = config(#{
- <<"config_version">> => 3,
- <<"enabled_guild_ids">> => [<<"1">>],
- <<"user_basis_points">> => 10000
- }),
- Candidates = [{guild, 1, self()}, {guild, 2, self()}, {user, 7, self()}],
- ?assertEqual(
- [{guild, 1, self()}],
- channel_threads_flip:affected_targets(Previous, Current, Candidates)
- ).
-
-version_only_change_touches_nothing_test() ->
- Previous = config(#{<<"guild_basis_points">> => 10000, <<"user_basis_points">> => 10000}),
- Current = Previous#{config_version := 42},
- Candidates =
- [{guild, Id, self()} || Id <- lists:seq(1, 50)] ++
- [{user, Id, self()} || Id <- lists:seq(1, 50)],
- ?assertEqual([], channel_threads_flip:affected_targets(Previous, Current, Candidates)).
-
-changes_while_disabled_touch_nothing_test() ->
- Previous = config(#{<<"enabled">> => false}),
- Current = config(#{
- <<"enabled">> => false,
- <<"enabled_guild_ids">> => [<<"1">>],
- <<"included_user_ids">> => [<<"1">>],
- <<"excluded_user_ids">> => [<<"2">>]
- }),
- Candidates = [{guild, 1, self()}, {user, 1, self()}, {user, 2, self()}],
- ?assertEqual([], channel_threads_flip:affected_targets(Previous, Current, Candidates)).
-
-disabled_config_change_skips_registry_scan_test() ->
- process_registry:init(),
- Entries = [{{guild, 9200001}, self()}, {{presence, 9200001}, self()}],
- ets:insert(process_registry_table, Entries),
- try
- Previous = config(#{<<"enabled">> => false}),
- Current = config(#{
- <<"enabled">> => false,
- <<"enabled_guild_ids">> => [<<"9200001">>],
- <<"included_user_ids">> => [<<"9200001">>]
- }),
- State0 = #{pending => empty(), timer => undefined, healed => #{}},
- ?assertEqual(
- {noreply, State0},
- channel_threads_flip:handle_cast({config_changed, Previous, Current}, State0)
- )
- after
- [ets:delete(process_registry_table, Key) || {Key, _} <- Entries]
- end.
-
-global_kill_flips_every_active_guild_test() ->
- Previous = config(#{<<"guild_basis_points">> => 10000}),
- Current = Previous#{enabled := false, config_version := 2},
- Candidates = [{guild, Id, self()} || Id <- lists:seq(1, 20)],
- ?assertEqual(
- Candidates, channel_threads_flip:affected_targets(Previous, Current, Candidates)
- ).
-
-schedule_applies_jitter_and_dedupes_targets_test() ->
- Jitters = counter_jitter([500, 100, 900]),
- Pending0 = channel_threads_flip:schedule(
- [{guild, 1, self()}, {guild, 2, self()}, {guild, 1, self()}, {user, 1, self()}],
- 1000,
- empty(),
- Jitters
- ),
- ?assertEqual(#{{guild, 1} => 1500, {guild, 2} => 1100, {user, 1} => 1900}, keys(Pending0)),
- {Due, Pending1} = channel_threads_flip:take_due(Pending0, 1600, limits(10, 10)),
- ?assertEqual([{guild, 2, self()}, {guild, 1, self()}], Due),
- ?assertEqual(#{{user, 1} => 1900}, keys(Pending1)).
-
-rescheduling_a_restarted_process_keeps_its_slot_and_takes_the_new_pid_test() ->
- Stale = spawn(fun() -> ok end),
- Pending0 = channel_threads_flip:schedule([{guild, 1, Stale}], 0, empty(), fun() -> 500 end),
- Pending1 = channel_threads_flip:schedule([{guild, 1, self()}], 100, Pending0, fun() ->
- 900
- end),
- ?assertEqual(#{{guild, 1} => 500}, keys(Pending1)),
- ?assertEqual(
- {[{guild, 1, self()}], empty()},
- channel_threads_flip:take_due(Pending1, 500, limits(10, 10))
- ).
-
-take_due_respects_the_batch_size_test() ->
- Pending0 = channel_threads_flip:schedule(
- [{guild, Id, self()} || Id <- lists:seq(1, 25)], 0, empty(), fun() -> 0 end
- ),
- {First, Pending1} = channel_threads_flip:take_due(Pending0, 0, limits(10, 1000)),
- {Second, Pending2} = channel_threads_flip:take_due(Pending1, 0, limits(10, 1000)),
- {Third, Pending3} = channel_threads_flip:take_due(Pending2, 0, limits(10, 1000)),
- ?assertEqual([10, 10, 5], [length(First), length(Second), length(Third)]),
- ?assertEqual(#{}, keys(Pending3)),
- ?assertEqual(
- lists:seq(1, 25), lists:sort([Id || {guild, Id, _} <- First ++ Second ++ Third])
- ).
-
-user_flips_drain_in_large_batches_behind_throttled_guilds_test() ->
- Targets =
- [{guild, Id, self()} || Id <- lists:seq(1, 50)] ++
- [{user, Id, self()} || Id <- lists:seq(1, 2500)],
- Pending0 = channel_threads_flip:schedule(Targets, 0, empty(), fun() -> 0 end),
- {First, Pending1} = channel_threads_flip:take_due(Pending0, 0, limits(10, 1000)),
- ?assertEqual({10, 1000}, kind_counts(First)),
- {Second, Pending2} = channel_threads_flip:take_due(Pending1, 0, limits(10, 1000)),
- {Third, Pending3} = channel_threads_flip:take_due(Pending2, 0, limits(10, 1000)),
- ?assertEqual([{10, 1000}, {10, 500}], [kind_counts(Second), kind_counts(Third)]),
- ?assertEqual(20, map_size(keys(Pending3))),
- ?assert(lists:all(fun({Kind, _Id}) -> Kind =:= guild end, maps:keys(keys(Pending3)))).
-
-self_heal_flips_immediately_once_per_cooldown_test() ->
- Pending0 = channel_threads_flip:schedule(
- [{guild, 7, self()}, {guild, 8, self()}], 0, empty(), fun() -> 50000 end
- ),
- State0 = #{pending => Pending0, timer => undefined, healed => #{}},
- {Healed1, Pending1} = channel_threads_flip:heal(7, self(), 1000, State0),
- ?assertEqual(ok, receive_flip()),
- ?assertEqual(#{{guild, 8} => 50000}, keys(Pending1)),
- State1 = State0#{healed := Healed1, pending := Pending1},
- {Healed2, Pending2} = channel_threads_flip:heal(7, self(), 20000, State1),
- ?assertEqual(none, receive_flip()),
- ?assertEqual(Pending1, Pending2),
- {_Healed3, _Pending3} = channel_threads_flip:heal(
- 7, self(), 40000, State1#{healed := Healed2}
- ),
- ?assertEqual(ok, receive_flip()).
-
-config_change_flips_only_local_registry_targets_test() ->
- process_registry:init(),
- Parent = self(),
- [LocalGuild, OtherGuild, LocalUser, ExcludedUser, Session] =
- [spawn(fun() -> forward(Parent) end) || _ <- lists:seq(1, 5)],
- Remote = remote_pid(),
- Entries = [
- {{guild, 9100001}, LocalGuild},
- {{guild, 9100002}, Remote},
- {{guild, 9100003}, OtherGuild},
- {{guild, 9100004}, loading},
- {{guild, <<"9100005">>}, OtherGuild},
- {{presence, 9100001}, LocalUser},
- {{presence, 9100002}, ExcludedUser},
- {{presence, 9100003}, Remote},
- {{session, 9100001}, Session}
- ],
- ets:insert(process_registry_table, Entries),
- try
- Previous = config(#{}),
- Current = config(#{
- <<"enabled_guild_ids">> => [<<"9100001">>, <<"9100002">>, <<"9100004">>],
- <<"included_user_ids">> => [<<"9100001">>, <<"9100003">>],
- <<"excluded_user_ids">> => [<<"9100002">>]
- }),
- State0 = #{pending => empty(), timer => undefined, healed => #{}},
- {noreply, #{pending := Scheduled, timer := Timer}} =
- channel_threads_flip:handle_cast({config_changed, Previous, Current}, State0),
- _ = erlang:cancel_timer(Timer),
- Expected = [
- {guild, 9100001, LocalGuild},
- {user, 9100001, LocalUser},
- {user, 9100002, ExcludedUser}
- ],
- ?assertEqual(lists:sort(Expected), lists:sort(ours(Scheduled))),
- Due = channel_threads_flip:schedule(
- Expected, erlang:monotonic_time(millisecond), empty(), fun() -> 0 end
- ),
- {noreply, #{pending := Rest}} =
- channel_threads_flip:handle_info(flip_tick, State0#{pending := Due}),
- ?assertEqual(#{}, keys(Rest)),
- Version = channel_threads_config:version(),
- ?assertEqual(
- lists:sort([
- {LocalGuild, {thread_gate_flip, Version}},
- {LocalUser, {thread_user_flip, Version}},
- {ExcludedUser, {thread_user_flip, Version}}
- ]),
- lists:sort(collect(3))
- ),
- ?assertEqual([], collect(1))
- after
- [ets:delete(process_registry_table, Key) || {Key, _} <- Entries],
- [exit(Pid, kill) || Pid <- [LocalGuild, OtherGuild, LocalUser, ExcludedUser, Session]]
- end.
-
-ours(#{due := Due}) ->
- [
- {Kind, Id, Pid}
- || KindDue <- maps:values(Due),
- {_At, {Kind, Id}, Pid} <- gb_sets:to_list(KindDue),
- Id div 100 =:= 91000
- ].
-
-limits(Guilds, Users) ->
- #{guild => Guilds, viewers => Guilds, user => Users}.
-
-kind_counts(Targets) ->
- {length([T || {guild, _, _} = T <- Targets]), length([T || {user, _, _} = T <- Targets])}.
-
-forward(Parent) ->
- receive
- Msg ->
- Parent ! {self(), Msg},
- forward(Parent)
- end.
-
-collect(0) ->
- [];
-collect(N) ->
- receive
- {Pid, {Tag, _} = Msg} when
- is_pid(Pid), (Tag =:= thread_gate_flip orelse Tag =:= thread_user_flip)
- ->
- [{Pid, Msg} | collect(N - 1)]
- after 200 -> []
- end.
-
-remote_pid() ->
- Node = <<"remote@nowhere">>,
- binary_to_term(
- <<131, 88, 119, (byte_size(Node)), Node/binary, 1:32, 0:32, 1:32>>
- ).
-
-receive_flip() ->
- receive
- {thread_gate_flip, Version} when is_integer(Version) -> ok
- after 0 -> none
- end.
-
-counter_jitter(Values) ->
- Ref = make_ref(),
- put(Ref, Values),
- fun() ->
- [Next | Rest] = get(Ref),
- put(Ref, Rest),
- Next
- end.
-
-empty() ->
- #{
- due => #{guild => gb_sets:new(), viewers => gb_sets:new(), user => gb_sets:new()},
- keys => #{}
- }.
-
-keys(#{keys := Keys}) ->
- maps:map(fun(_Key, {At, _Pid}) -> At end, Keys).
-
-config(Overrides) ->
- {ok, Config} = channel_threads_config:validate_config(
- maps:merge(#{<<"enabled">> => true}, Overrides)
- ),
- Config.
diff --git a/fluxer_gateway/test/guild_availability_tests.erl b/fluxer_gateway/test/guild_availability_tests.erl
deleted file mode 100644
index 9d5b92283..000000000
--- a/fluxer_gateway/test/guild_availability_tests.erl
+++ /dev/null
@@ -1,287 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_availability_tests).
--typing([eqwalizer]).
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
--spec cleanup_unavailability_cache(integer()) -> ok.
-cleanup_unavailability_cache(GuildId) ->
- guild_availability_cache:set_cached_unavailability_mode(GuildId, available).
-
-disconnect_ineligible_sessions_staff_only_test() ->
- Parent = self(),
- GuildId = 99001,
- NonStaffPid = start_session_capture(non_staff, Parent),
- StaffPid = start_session_capture(staff, Parent),
- try
- BaseState = state_for_unavailability_transition_test(GuildId, NonStaffPid, StaffPid),
- NewState = BaseState#{
- data => #{
- <<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE_BUT_STAFF">>]},
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => <<"1001">>, <<"flags">> => <<"0">>}},
- #{<<"user">> => #{<<"id">> => <<"1002">>, <<"flags">> => <<"1">>}}
- ]
- }
- },
- UpdatedState = guild_availability:handle_unavailability_transition(BaseState, NewState),
- Sessions = maps:get(sessions, UpdatedState, #{}),
- ?assertEqual(1, map_size(Sessions)),
- ?assert(maps:is_key(<<"staff">>, Sessions)),
- ?assertEqual(
- unavailable_for_everyone_but_staff,
- guild_availability_cache:get_cached_unavailability_mode(GuildId)
- ),
- receive
- {non_staff, {'$gen_cast', {guild_leave, GuildId, forced_unavailable}}} -> ok
- after 1000 -> ?assert(false)
- end,
- receive
- {staff, {'$gen_cast', {guild_leave, GuildId, forced_unavailable}}} -> ?assert(false)
- after 200 -> ok
- end
- after
- cleanup_unavailability_cache(GuildId),
- NonStaffPid ! stop,
- StaffPid ! stop
- end.
-
-disconnect_ineligible_sessions_everyone_test() ->
- Parent = self(),
- GuildId = 99002,
- UserOnePid = start_session_capture(user_one, Parent),
- UserTwoPid = start_session_capture(user_two, Parent),
- try
- BaseState = state_for_unavailability_transition_test(GuildId, UserOnePid, UserTwoPid),
- NewState = BaseState#{
- data => #{
- <<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]},
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => <<"1001">>, <<"flags">> => <<"0">>}},
- #{<<"user">> => #{<<"id">> => <<"1002">>, <<"flags">> => <<"1">>}}
- ]
- }
- },
- UpdatedState = guild_availability:handle_unavailability_transition(BaseState, NewState),
- ?assertEqual(#{}, maps:get(sessions, UpdatedState, #{})),
- ?assertEqual(
- unavailable_for_everyone,
- guild_availability_cache:get_cached_unavailability_mode(GuildId)
- ),
- receive
- {user_one, {'$gen_cast', {guild_leave, GuildId, forced_unavailable}}} -> ok
- after 1000 -> ?assert(false)
- end,
- receive
- {user_two, {'$gen_cast', {guild_leave, GuildId, forced_unavailable}}} -> ok
- after 1000 -> ?assert(false)
- end
- after
- cleanup_unavailability_cache(GuildId),
- UserOnePid ! stop,
- UserTwoPid ! stop
- end.
-
-disconnect_ineligible_sessions_everyone_hidden_test() ->
- Parent = self(),
- GuildId = 99004,
- NonStaffPid = start_session_capture(non_staff_hidden, Parent),
- StaffPid = start_session_capture(staff_hidden, Parent),
- try
- BaseState = state_for_unavailability_transition_test(GuildId, NonStaffPid, StaffPid),
- NewState = BaseState#{
- data => #{
- <<"guild">> => #{
- <<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>, <<"UNAVAILABLE_HIDDEN">>]
- },
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => <<"1001">>, <<"flags">> => <<"0">>}},
- #{<<"user">> => #{<<"id">> => <<"1002">>, <<"flags">> => <<"1">>}}
- ]
- }
- },
- UpdatedState = guild_availability:handle_unavailability_transition(BaseState, NewState),
- ?assertEqual(#{}, maps:get(sessions, UpdatedState, #{})),
- ?assertEqual(
- unavailable_for_everyone,
- guild_availability_cache:get_cached_unavailability_mode(GuildId)
- ),
- ?assertEqual(
- true, guild_availability:is_unavailable_hidden_enabled_from_cache(GuildId)
- ),
- receive
- {non_staff_hidden, {'$gen_cast', {guild_leave, GuildId, forced_unavailable, true}}} ->
- ok
- after 1000 -> ?assert(false)
- end,
- receive
- {staff_hidden, {'$gen_cast', {guild_leave, GuildId, forced_unavailable, true}}} ->
- ok
- after 1000 -> ?assert(false)
- end
- after
- cleanup_unavailability_cache(GuildId),
- NonStaffPid ! stop,
- StaffPid ! stop
- end.
-
-is_guild_unavailable_for_user_from_cache_is_staff_test() ->
- GuildId = 99003,
- try
- guild_availability_cache:set_cached_unavailability_mode(
- GuildId, unavailable_for_everyone_but_staff
- ),
- ?assertEqual(
- true,
- guild_availability:is_guild_unavailable_for_user_from_cache(GuildId, #{
- <<"is_staff">> => false
- })
- ),
- ?assertEqual(
- false,
- guild_availability:is_guild_unavailable_for_user_from_cache(GuildId, #{
- <<"is_staff">> => true
- })
- )
- after
- cleanup_unavailability_cache(GuildId)
- end.
-
-is_unavailable_hidden_enabled_from_cache_test() ->
- GuildId = 99005,
- HiddenUnavailableState = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{
- <<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>, <<"UNAVAILABLE_HIDDEN">>]
- }
- }
- },
- HiddenOnlyState = #{
- id => GuildId,
- data => #{<<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_HIDDEN">>]}}
- },
- try
- _ = guild_availability:update_unavailability_cache_for_state(HiddenUnavailableState),
- ?assertEqual(
- true, guild_availability_check:is_unavailable_hidden_enabled(HiddenUnavailableState)
- ),
- ?assertEqual(
- true, guild_availability:is_unavailable_hidden_enabled_from_cache(GuildId)
- ),
- _ = guild_availability:update_unavailability_cache_for_state(HiddenOnlyState),
- ?assertEqual(
- false, guild_availability_check:is_unavailable_hidden_enabled(HiddenOnlyState)
- ),
- ?assertEqual(
- false, guild_availability:is_unavailable_hidden_enabled_from_cache(GuildId)
- )
- after
- cleanup_unavailability_cache(GuildId)
- end.
-
-is_guild_unavailable_for_user_unavailable_for_everyone_test() ->
- State = #{
- data => #{
- <<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]},
- <<"members">> => []
- }
- },
- ?assertEqual(true, guild_availability:is_guild_unavailable_for_user(123, State)).
-
--spec start_session_capture(atom(), pid()) -> pid().
-start_session_capture(Tag, Parent) ->
- spawn(fun() -> session_capture_loop(Tag, Parent) end).
-
--spec session_capture_loop(atom(), pid()) -> ok.
-session_capture_loop(Tag, Parent) ->
- receive
- stop ->
- ok;
- {'$gen_cast', Msg} ->
- Parent ! {Tag, {'$gen_cast', Msg}},
- session_capture_loop(Tag, Parent);
- _Other ->
- session_capture_loop(Tag, Parent)
- after infinity ->
- ok
- end.
-
--spec state_for_unavailability_transition_test(integer(), pid(), pid()) -> map().
-state_for_unavailability_transition_test(GuildId, NonStaffPid, StaffPid) ->
- #{
- id => GuildId,
- sessions => #{
- <<"non_staff">> => #{
- session_id => <<"non_staff">>,
- user_id => 1001,
- pid => NonStaffPid,
- mref => make_ref(),
- active_guilds => sets:new(),
- user_roles => [],
- bot => false,
- is_staff => false
- },
- <<"staff">> => #{
- session_id => <<"staff">>,
- user_id => 1002,
- pid => StaffPid,
- mref => make_ref(),
- active_guilds => sets:new(),
- user_roles => [],
- bot => false,
- is_staff => true
- }
- },
- presence_subscriptions => #{},
- member_list_subscriptions => guild_member_list_subs:new(),
- member_subscriptions => guild_subscriptions:init_state(),
- connected_user_ids => sets:new(),
- user_session_counts => #{},
- data => #{
- <<"guild">> => #{<<"features">> => []},
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => <<"1001">>, <<"flags">> => <<"0">>}},
- #{<<"user">> => #{<<"id">> => <<"1002">>, <<"flags">> => <<"1">>}}
- ]
- },
- voice_states => #{},
- pending_voice_connections => #{}
- }.
-
--endif.
-
-guild_create_resend_carries_threads_only_for_viewers_test() ->
- Tab = guild_thread_store:new(),
- try
- Data = guild_data_index:normalize_map(#{
- <<"guild">> => #{<<"id">> => <<"77">>, <<"owner_id">> => <<"1">>},
- <<"roles">> => [#{<<"id">> => <<"77">>, <<"permissions">> => <<"1024">>}],
- <<"channels">> => [#{<<"id">> => <<"5">>, <<"type">> => 0}],
- <<"members">> => [#{<<"user">> => #{<<"id">> => <<"9">>}, <<"roles">> => []}],
- <<"emojis">> => [],
- <<"stickers">> => []
- }),
- State = #{
- id => 77,
- data => Data#{thread_store => Tab, thread_gate => #{active => true, version => 1}}
- },
- Viewer = #{user_id => 9, pid => self(), thread_viewer => true},
- ok = guild_availability:send_guild_create_to_session(Viewer, 77, State, []),
- ?assert(maps:is_key(<<"threads">>, received_guild_create())),
- ok = guild_availability:send_guild_create_to_session(
- Viewer#{thread_viewer => false}, 77, State, []
- ),
- ?assertNot(maps:is_key(<<"threads">>, received_guild_create()))
- after
- guild_thread_store:destroy(Tab)
- end.
-
-received_guild_create() ->
- receive
- {'$gen_cast', {dispatch, guild_create, GuildState}} when is_map(GuildState) ->
- GuildState
- after 1000 -> erlang:error(guild_create_not_sent)
- end.
diff --git a/fluxer_gateway/test/guild_channel_move_equivalence_tests.erl b/fluxer_gateway/test/guild_channel_move_equivalence_tests.erl
deleted file mode 100644
index 7ed5371c1..000000000
--- a/fluxer_gateway/test/guild_channel_move_equivalence_tests.erl
+++ /dev/null
@@ -1,1939 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_channel_move_equivalence_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(GUILD_ID, 7100000).
--define(USER_BASE, 7200000).
--define(CHAN_BASE, 7300000).
--define(ROLE_BASE, 7400000).
--define(DANGLING_PARENT, 7399999).
--define(RECORDER, guild_channel_move_equivalence_recorder).
--define(MODE, guild_channel_move_equivalence_mode).
--define(DEFAULT_SEEDS, 300).
-
-equivalence_test_() ->
- {timeout, 1800, fun() ->
- with_harness(fun() ->
- First = env_int("CHMOVE_FIRST_SEED", 1),
- lists:foreach(fun check_seed/1, lists:seq(First, First + seed_count() - 1))
- end)
- end}.
-
-move_into_public_category_does_no_per_member_work_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = ticker_spec(),
- [Moved | _] = ticker_ids(),
- Event = bulk_event(
- move_channels([Moved], {parent, ticker_category()}, layout(Spec))
- ),
- Results = check_spec(Spec, [Event]),
- [#{counts := Counts}] = maps:get(optimized, Results),
- [#{counts := RefCounts}] = maps:get(reference, Results),
- ?assertEqual(0, count(bulk_load, Counts)),
- ?assertEqual(1, count(voice_fetch, Counts)),
- ?assert(count(bulk_load, RefCounts) > 0),
- ?assert(count(voice_fetch, RefCounts) >= 1),
- ?assert(count(can_view, Counts) * 4 < count(can_view, RefCounts))
- end)
- end}.
-
-position_only_bulk_rebuilds_no_member_list_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = ticker_spec(),
- Results = check_spec(Spec, [position_move(Spec)]),
- [#{counts := Counts}] = maps:get(optimized, Results),
- [#{counts := RefCounts}] = maps:get(reference, Results),
- ?assertEqual(0, count(bulk_load, Counts)),
- ?assert(count(bulk_load, RefCounts) > 0),
- ?assertEqual(1, count(prune, Counts)),
- ?assertEqual(1, count(visibility, Counts))
- end)
- end}.
-
-overwrite_change_on_a_subscribed_list_rebuilds_and_syncs_it_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = ticker_spec(),
- Text = ticker_category() + 1,
- Changed = (find(Text, layout(Spec)))#{
- <<"permission_overwrites">> => [overwrite(role_id(1), 0, 0, view())]
- },
- Results = check_spec(Spec, [{channel_update, Changed}]),
- [#{log := Log, counts := Counts}] = maps:get(optimized, Results),
- ?assertEqual(1, count(bulk_load, Counts)),
- ?assert(lists:member(guild_member_list_update, [relay_event(E) || E <- Log]))
- end)
- end}.
-
-created_channel_is_in_the_bulk_after_a_move_into_a_category_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = (create_spec())#{hooks => [{channel_create, new_public_channel()}]},
- Layout = layout(Spec) ++ [new_public_channel()],
- Event = bulk_event(renumber(move_channels([new_id()], {parent, cat_id()}, Layout))),
- Results = check_spec(Spec, [Event]),
- [#{log := Log, state := {_, State}}] = maps:get(optimized, Results),
- Bulks = [
- Ids
- || {relay, _, [_, channel_update_bulk, Payload | _]} <- Log,
- Ids <- [payload_channel_ids(Payload)]
- ],
- ?assertMatch([_ | _], Bulks),
- [?assert(lists:member(new_id(), Ids)) || Ids <- Bulks],
- [
- ?assert(maps:is_key(new_id(), session_map(session_id(L), State)))
- || L <- [1, 2, 3]
- ]
- end)
- end}.
-
-created_channel_survives_a_position_only_move_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = (create_spec())#{hooks => [{channel_create, new_public_channel()}]},
- Layout = layout(Spec) ++ [new_public_channel()],
- Results = check_spec(Spec, [bulk_event(renumber(lists:reverse(Layout)))]),
- [#{state := {_, State}}] = maps:get(optimized, Results),
- ?assert(maps:is_key(new_id(), session_map(session_id(3), State)))
- end)
- end}.
-
-old_owner_does_not_receive_channels_it_lost_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = (owner_spec())#{hooks => [{owner, user_id(2)}]},
- Results = check_spec(Spec, [position_move(Spec)]),
- [#{log := Log, state := {_, State}}] = maps:get(optimized, Results),
- ToOldOwner = [
- E
- || {relay, _, [Targets, channel_update_bulk | _]} = E <- Log,
- lists:member({session_pid, 1}, lists:flatten([Targets]))
- ],
- ?assertEqual([], ToOldOwner),
- ?assertEqual(#{}, session_map(session_id(1), State)),
- ?assertNot(maps:is_key(user_id(4), maps:get(member_subscriptions, State)))
- end)
- end}.
-
-virtual_access_flip_leaves_no_stale_member_row_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = flip_spec(),
- Results = check_spec(Spec, [position_move(Spec)]),
- [#{state := {Engines, _}, counts := Counts}] = maps:get(optimized, Results),
- ?assertEqual(1, count(bulk_load, Counts)),
- ?assertNot(lists:member(user_id(4), engine_user_ids(flip_channel(), Engines)))
- end)
- end}.
-
-owner_flip_leaves_no_stale_member_row_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = (flip_spec())#{
- hooks => owner_flip_hooks()
- },
- Results = check_spec(Spec, [position_move(Spec)]),
- [#{state := {Engines, _}}] = maps:get(optimized, Results),
- ?assert(lists:member(user_id(1), engine_user_ids(flip_channel(), Engines)))
- end)
- end}.
-
-role_flip_on_an_unsubscribed_list_leaves_no_stale_member_row_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = (flip_spec())#{
- list_subscriptions => [],
- hooks => [
- {ensure_list, flip_channel()},
- {role_permissions, 1, 0},
- {member_update, user_id(2)},
- {role_permissions, 1, view()}
- ]
- },
- Results = check_spec(Spec, [position_move(Spec)]),
- [#{state := {Engines, _}}] = maps:get(optimized, Results),
- ?assert(lists:member(user_id(2), engine_user_ids(flip_channel(), Engines)))
- end)
- end}.
-
-single_update_then_bulk_rebuilds_the_category_it_left_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec0 = gap_spec(?CHAN_BASE + 500),
- Spec = Spec0#{
- list_subscriptions => [{session_id(1), integer_to_binary(?CHAN_BASE + 500)}]
- },
- Moved = (find(?CHAN_BASE + 501, layout(Spec)))#{
- <<"parent_id">> => integer_to_binary(?CHAN_BASE + 500)
- },
- After = replace(Moved, layout(Spec)),
- Events = [{channel_update, Moved}, bulk_event(renumber(lists:reverse(After)))],
- Results = check_spec(Spec, Events),
- [_, #{counts := Counts, log := Log}] = maps:get(optimized, Results),
- ?assertEqual(1, count(bulk_load, Counts)),
- ?assert(lists:member(guild_member_list_update, [relay_event(E) || E <- Log]))
- end)
- end}.
-
-category_flip_between_single_updates_leaves_no_stale_member_row_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- {Spec, Events} = category_flip_case(),
- Results = check_spec(Spec, Events),
- [_, _, _, #{state := {Engines, _}, counts := Counts}] = maps:get(
- optimized, Results
- ),
- ?assertEqual(1, count(bulk_load, Counts)),
- ?assert(lists:member(user_id(2), engine_user_ids(?CHAN_BASE + 500, Engines)))
- end)
- end}.
-
-reload_with_changed_member_roles_rebuilds_every_list_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- {Spec, Events} = reload_case(),
- Results = check_spec(Spec, Events),
- [#{state := {Engines, _}, counts := Counts}] = maps:get(optimized, Results),
- ?assertEqual(1, count(bulk_load, Counts)),
- ?assertNot(lists:member(user_id(2), engine_user_ids(flip_channel(), Engines)))
- end)
- end}.
-
-reload_case() ->
- Spec0 = flip_spec(),
- Data = maps:get(data, Spec0),
- Target = integer_to_binary(user_id(2)),
- Reloaded = Data#{
- <<"members">> => [
- case M of
- #{<<"user">> := #{<<"id">> := Target}} -> M#{<<"roles">> => []};
- _ -> M
- end
- || M <- maps:get(<<"members">>, Data)
- ]
- },
- Spec = Spec0#{hooks => [{reload, Reloaded}]},
- {Spec, [position_move(Spec)]}.
-
-category_flip_case() ->
- Spec = (gap_spec(?CHAN_BASE + 501))#{
- list_subscriptions => [{session_id(1), integer_to_binary(?CHAN_BASE + 500)}]
- },
- Child = find(?CHAN_BASE + 501, layout(Spec)),
- {Spec, [
- {channel_update, Child#{<<"parent_id">> => null}},
- {hook, {member_update, user_id(2)}},
- {channel_update, Child},
- position_move(Spec)
- ]}.
-
-bulk_category_flip_leaves_no_stale_member_row_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- {Spec, Events} = bulk_category_flip_case(),
- Results = check_spec(Spec, Events),
- [_, _, _, #{state := {Engines, _}, counts := Counts}] = maps:get(
- optimized, Results
- ),
- ?assertEqual(1, count(bulk_load, Counts)),
- ?assert(lists:member(user_id(2), engine_user_ids(?CHAN_BASE + 500, Engines)))
- end)
- end}.
-
-bulk_category_flip_case() ->
- Spec = (gap_spec(?CHAN_BASE + 501))#{
- list_subscriptions => [{session_id(1), integer_to_binary(?CHAN_BASE + 500)}]
- },
- Child = find(?CHAN_BASE + 501, layout(Spec)),
- {Spec, [
- bulk_event([Child#{<<"parent_id">> => null}]),
- {hook, {member_update, user_id(2)}},
- bulk_event([Child]),
- position_move(Spec)
- ]}.
-
-everyone_patch_flip_leaves_no_stale_member_row_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- {Spec, Events} = everyone_patch_flip_case(),
- Results = check_spec(Spec, Events),
- [#{state := {Engines, _}, counts := Counts}] = maps:get(optimized, Results),
- ?assertEqual(1, count(bulk_load, Counts)),
- ?assertNot(lists:member(user_id(4), engine_user_ids(flip_channel(), Engines)))
- end)
- end}.
-
-everyone_patch_flip_case() ->
- Spec = (flip_spec())#{
- list_subscriptions => [],
- hooks => [
- {ensure_list, flip_channel()},
- {patch_everyone, view()},
- {member_update, user_id(4)},
- {everyone_permissions, members_view() bor connect() bor speak()}
- ]
- },
- {Spec, [position_move(Spec)]}.
-
-created_child_flip_leaves_no_stale_member_row_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- {Spec, Events} = created_child_flip_case(),
- Results = check_spec(Spec, Events),
- [_, #{state := {Engines, _}, counts := Counts}] = maps:get(optimized, Results),
- ?assertEqual(1, count(bulk_load, Counts)),
- ?assertNot(lists:member(user_id(4), engine_user_ids(?CHAN_BASE + 500, Engines)))
- end)
- end}.
-
-created_child_flip_case() ->
- Spec0 = (owner_spec())#{
- data => owner_data(
- renumber([
- channel(?CHAN_BASE + 10, 0, null, []),
- channel(?CHAN_BASE + 500, 4, null, [])
- ])
- ),
- member_subscriptions => []
- },
- Child = channel(new_id(), 0, ?CHAN_BASE + 500, [overwrite(?GUILD_ID, 0, view(), 0)]),
- Spec = Spec0#{
- hooks => [
- {ensure_list, ?CHAN_BASE + 500},
- {channel_create, Child},
- {member_update, user_id(4)}
- ]
- },
- Moved = Child#{<<"parent_id">> => null},
- {Spec, [
- {channel_update, Moved},
- bulk_event(renumber(lists:reverse(layout(Spec0) ++ [Moved])))
- ]}.
-
-subscribed_hidden_voice_list_is_rebuilt_after_access_is_granted_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- {Spec, Events} = subscribed_hidden_voice_case(),
- Results = check_spec(Spec, Events),
- [#{state := {Engines, _}}] = maps:get(optimized, Results),
- ?assert(lists:member(user_id(5), engine_user_ids(?CHAN_BASE + 202, Engines)))
- end)
- end}.
-
-subscribed_hidden_voice_case() ->
- Spec0 = hidden_voice_spec(),
- Spec = Spec0#{
- list_subscriptions => [{session_id(1), integer_to_binary(?CHAN_BASE + 202)}]
- },
- {Spec, [position_move(Spec)]}.
-
-bulk_move_resyncs_voice_permissions_in_every_voice_channel_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec0 = ticker_spec(),
- Voice = maps:merge(
- gen_voice_states([user_id(I) || I <- lists:seq(1, 10)], [ticker_category() + 2]),
- maps:from_list([
- {<<"t", (integer_to_binary(I))/binary>>, #{
- <<"user_id">> => integer_to_binary(user_id(20 + I)),
- <<"channel_id">> => integer_to_binary(Id),
- <<"guild_id">> => integer_to_binary(?GUILD_ID),
- <<"connection_id">> => <<"t", (integer_to_binary(I))/binary>>,
- <<"session_id">> => <<"ts", (integer_to_binary(I))/binary>>,
- <<"deaf">> => false
- }}
- || {I, Id} <- lists:zip(lists:seq(1, 3), ticker_ids())
- ])
- ),
- Spec = Spec0#{voice_states => Voice},
- Results = check_spec(Spec, [position_move(Spec)]),
- [#{log := Log}] = maps:get(optimized, Results),
- Synced = lists:usort([Conn || {voice_hook, _, _, _, Conn, _} <- Log]),
- ?assertEqual(lists:sort(maps:keys(Voice)), Synced)
- end)
- end}.
-
-voice_user_without_view_is_granted_access_like_the_full_pass_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = hidden_voice_spec(),
- Results = check_spec(Spec, [position_move(Spec)]),
- [#{state := {_, State}, log := Log}] = maps:get(optimized, Results),
- ?assert(lists:any(fun(E) -> element(1, E) =:= voice_hook end, Log)),
- ?assert(
- guild_virtual_channel_access:has_virtual_access(
- user_id(5), ?CHAN_BASE + 202, State
- )
- )
- end)
- end}.
-
-members_sharing_a_role_set_with_the_owner_see_their_own_channels_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- ?assertEqual(
- [{session_pid, 3}, {session_pid, 4}],
- shared_roles_deletes(
- shared_roles_case(user_allow(), [hidden_overwrite() | user_allow()])
- )
- )
- end)
- end}.
-
-user_overwrite_added_by_the_event_is_not_shared_through_the_role_memo_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- ?assertEqual(
- [{session_pid, 3}, {session_pid, 4}],
- shared_roles_deletes(shared_roles_case([], [hidden_overwrite() | user_allow()]))
- )
- end)
- end}.
-
-user_overwrite_removed_by_the_event_is_not_shared_through_the_role_memo_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- ?assertEqual(
- [{session_pid, 2}],
- shared_roles_deletes(
- shared_roles_case([hidden_overwrite() | user_allow()], [hidden_overwrite()])
- )
- )
- end)
- end}.
-
-shared_roles_deletes({Spec, Events}) ->
- Results = check_spec(Spec, Events),
- [#{log := Log}] = maps:get(optimized, Results),
- lists:sort([Target || {relay, dispatch, [Target, channel_delete, _, _]} <- Log]).
-
-user_allow() ->
- [overwrite(user_id(2), 1, view(), 0)].
-
-stale_detection_tracks_every_permission_input_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = (flip_spec())#{list_subscriptions => []},
- {State0, Env} = materialize(Spec),
- ListId = integer_to_binary(flip_channel()),
- State = guild_member_list_channel_engine:ensure(ListId, State0),
- try
- ?assertNot(guild_member_list_engine_inputs:is_stale(ListId, State)),
- ?assertEqual(
- [],
- [
- Name
- || {Name, Change} <- input_changes(),
- not guild_member_list_engine_inputs:is_stale(ListId, Change(State))
- ]
- ),
- ?assert(
- guild_member_list_engine_inputs:is_stale(
- ListId,
- guild_member_list_engine_inputs:mark_stale(flip_channel(), State)
- )
- ),
- ?assertNot(
- guild_member_list_engine_inputs:is_stale(
- ListId, guild_member_list_engine_inputs:latch_stale(State)
- )
- ),
- [
- ?assert(
- guild_member_list_engine_inputs:is_stale(
- ListId,
- (guild_member_list_engine_inputs:latch_stale(Change(State)))#{
- data => maps:get(data, State),
- virtual_channel_access => maps:get(
- virtual_channel_access, State
- )
- }
- )
- )
- || {_Name, Change} <- input_changes()
- ],
- ?assertNot(
- guild_member_list_engine_inputs:is_stale(
- ListId,
- with_channels(
- fun(C) -> C#{<<"name">> => <<"x">>, <<"position">> => 99} end, State
- )
- )
- )
- after
- teardown(State, Env)
- end
- end)
- end}.
-
-twin_channel_engines_match_a_fresh_build_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- {State0, Env} = materialize(twin_spec()),
- Lists = twin_lists(),
- State = lists:foldl(fun guild_member_list_channel_engine:ensure/2, State0, Lists),
- Refs = [guild_member_list_channel_engine:ref(L, State) || L <- Lists],
- ?assertEqual(length(Lists), length(lists:usort(Refs))),
- Final = lists:foldl(fun assert_engine_matches_fresh_build/2, State, Lists),
- teardown(Final, Env)
- end)
- end}.
-
-stale_twin_engine_is_not_cloned_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- {State0, Env} = materialize(twin_spec()),
- [A, B | _] = twin_lists(),
- State1 = guild_member_list_channel_engine:ensure(A, State0),
- Hidden = with_channels(
- fun(C) ->
- case integer_to_binary(channel_int_id(C)) of
- A -> C#{<<"permission_overwrites">> => [hidden_overwrite()]};
- _ -> C
- end
- end,
- State1
- ),
- [
- ok = guild_member_list_channel_engine:update_user(user_id(I), A, Hidden)
- || I <- lists:seq(1, 60)
- ],
- State2 = guild_member_list_channel_engine:ensure(B, Hidden),
- ?assert(guild_member_list_engine_inputs:is_stale(A, State2)),
- ?assertNotEqual(engine_content(A, State2), engine_content(B, State2)),
- teardown(assert_engine_matches_fresh_build(B, State2), Env)
- end)
- end}.
-
-twin_spec() ->
- Restricted = [overwrite(role_id(1), 0, 0, view())],
- single_session_spec(
- renumber([
- channel(?CHAN_BASE + 700, 0, null, []),
- channel(?CHAN_BASE + 701, 0, null, []),
- channel(?CHAN_BASE + 702, 0, null, Restricted),
- channel(?CHAN_BASE + 703, 0, null, Restricted)
- ])
- ).
-
-twin_lists() ->
- [integer_to_binary(?CHAN_BASE + I) || I <- [700, 701, 702, 703]].
-
-assert_engine_matches_fresh_build(ListId, State) ->
- Built = engine_content(ListId, State),
- Rebuilt = guild_member_list_channel_engine:rebuild(ListId, State),
- ?assertEqual(engine_content(ListId, Rebuilt), Built),
- Rebuilt.
-
-engine_content(ListId, State) ->
- Ref = guild_member_list_channel_engine:ref(ListId, State),
- Items = guild_member_list_engine:get_all_item_keys(Ref),
- Members = [UserId || {member, UserId} <- Items],
- {
- guild_member_list_engine:get_counts(Ref),
- guild_member_list_engine:get_groups(Ref),
- Items,
- [{U, guild_member_list_engine:is_member_online(Ref, U)} || U <- Members]
- }.
-
-input_changes() ->
- Flip = flip_channel(),
- [
- {owner,
- with_data(fun(D) ->
- G = maps:get(<<"guild">>, D),
- D#{<<"guild">> => G#{<<"owner_id">> => integer_to_binary(user_id(2))}}
- end)},
- {roles,
- with_data(fun(D) ->
- [E | Rest] = guild_data_index_roles:role_list(D),
- guild_data_index:put_roles([E#{<<"permissions">> => <<"0">>} | Rest], D)
- end)},
- {role_order,
- with_data(fun(D) -> D#{<<"roles">> => lists:reverse(maps:get(<<"roles">>, D))} end)},
- {role_index, with_data(fun(D) -> D#{<<"role_index">> => #{}} end)},
- {indexed_overwrites_only,
- with_data(fun(D) ->
- Index = maps:get(<<"channel_index">>, D),
- Channel = maps:get(Flip, Index),
- D#{
- <<"channel_index">> => Index#{
- Flip => Channel#{<<"permission_overwrites">> => [hidden_overwrite()]}
- }
- }
- end)},
- {role_perms_cache, with_data(fun(D) -> D#{role_perms_cache => #{}} end)},
- {own_overwrites,
- with_channels(fun(C) ->
- case channel_int_id(C) of
- Flip -> C#{<<"permission_overwrites">> => [hidden_overwrite()]};
- _ -> C
- end
- end)},
- {own_type,
- with_channels(fun(C) ->
- case channel_int_id(C) of
- Flip -> C#{<<"type">> => 0};
- _ -> C
- end
- end)},
- {overwrite_cache,
- with_data(fun(D) ->
- D#{
- overwrite_perms_cache => maps:remove(
- Flip, maps:get(overwrite_perms_cache, D)
- )
- }
- end)},
- {virtual_access, fun(S) ->
- S#{virtual_channel_access => #{user_id(9) => sets:from_list([Flip])}}
- end}
- ].
-
-category_children_are_permission_inputs_test_() ->
- {timeout, 120, fun() ->
- with_harness(fun() ->
- Spec = (gap_spec(?CHAN_BASE + 501))#{list_subscriptions => []},
- {State0, Env} = materialize(Spec),
- ListId = integer_to_binary(?CHAN_BASE + 500),
- State = guild_member_list_channel_engine:ensure(ListId, State0),
- try
- ?assertNot(guild_member_list_engine_inputs:is_stale(ListId, State)),
- Reparented = with_channels(
- fun(C) ->
- case channel_int_id(C) of
- 501 + ?CHAN_BASE -> C#{<<"parent_id">> => null};
- _ -> C
- end
- end,
- State
- ),
- ?assert(guild_member_list_engine_inputs:is_stale(ListId, Reparented)),
- ChildOverwrites = with_channels(
- fun(C) ->
- case channel_int_id(C) of
- 501 + ?CHAN_BASE ->
- C#{<<"permission_overwrites">> => [hidden_overwrite()]};
- _ ->
- C
- end
- end,
- State
- ),
- ?assert(guild_member_list_engine_inputs:is_stale(ListId, ChildOverwrites))
- after
- teardown(State, Env)
- end
- end)
- end}.
-
-with_data(Fun) ->
- fun(State) -> with_data(Fun, State) end.
-
-with_data(Fun, State) ->
- State#{data => Fun(maps:get(data, State))}.
-
-with_channels(Fun) ->
- fun(State) -> with_channels(Fun, State) end.
-
-with_channels(Fun, State) ->
- with_data(
- fun(D) ->
- guild_data_index:put_channels(
- [Fun(C) || C <- guild_data_index_channels:channel_list(D)], D
- )
- end,
- State
- ).
-
-engine_user_ids(ChannelId, Engines) ->
- {_, UserIds, _, _} = maps:get(integer_to_binary(ChannelId), Engines),
- UserIds.
-
-payload_channel_ids(#{<<"channels">> := Channels}) ->
- [channel_int_id(C) || C <- Channels];
-payload_channel_ids({pre_encoded, Bin}) ->
- payload_channel_ids(json:decode(Bin));
-payload_channel_ids(_) ->
- [].
-
-new_id() -> ?CHAN_BASE + 950.
-
-cat_id() -> ?CHAN_BASE + 1.
-
-new_public_channel() ->
- channel(new_id(), 0, null, [overwrite(?GUILD_ID, 0, view(), 0)]).
-
-create_spec() ->
- (owner_spec())#{
- data => owner_data(
- renumber([
- channel(cat_id(), 4, null, [overwrite(?GUILD_ID, 0, view(), 0)]),
- channel(?CHAN_BASE + 10, 0, null, []),
- channel(?CHAN_BASE + 30, 0, null, [overwrite(user_id(4), 1, view(), 0)]),
- channel(?CHAN_BASE + 40, 0, null, [overwrite(?GUILD_ID, 0, view(), 0)])
- ])
- ),
- sessions => [
- #{label => 1, user_id => user_id(1), pending => false},
- #{label => 2, user_id => user_id(2), pending => false},
- #{label => 3, user_id => user_id(4), pending => false}
- ]
- }.
-
-owner_spec() ->
- #{
- data => owner_data(
- renumber([
- channel(?CHAN_BASE + 10, 0, null, []),
- channel(?CHAN_BASE + 30, 0, null, [overwrite(user_id(4), 1, view(), 0)])
- ])
- ),
- sessions => [
- #{label => 1, user_id => user_id(1), pending => false},
- #{label => 2, user_id => user_id(2), pending => false}
- ],
- virtual_access => #{},
- voice_states => #{},
- list_subscriptions => [],
- member_subscriptions => [{session_id(1), user_id(4)}],
- dm_partners => []
- }.
-
-owner_data(Channels) ->
- #{
- <<"guild">> => guild(user_id(1)),
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(?GUILD_ID),
- <<"name">> => <<"@everyone">>,
- <<"permissions">> => integer_to_binary(
- members_view() bor connect() bor speak()
- ),
- <<"position">> => 0,
- <<"hoist">> => false
- },
- (plain_role(1, role_id(1)))#{<<"permissions">> => integer_to_binary(view())}
- ],
- <<"members">> => [
- member(user_id(1), []),
- member(user_id(2), [role_id(1)]),
- member(user_id(3), [role_id(1)]),
- member(user_id(4), [])
- ],
- <<"channels">> => Channels,
- <<"emojis">> => [],
- <<"stickers">> => []
- }.
-
-guild(Owner) ->
- #{
- <<"id">> => integer_to_binary(?GUILD_ID),
- <<"name">> => <<"equivalence">>,
- <<"owner_id">> => integer_to_binary(Owner),
- <<"features">> => [],
- <<"disabled_operations">> => 0
- }.
-
-flip_channel() -> ?CHAN_BASE + 20.
-
-owner_flip_hooks() ->
- [
- {owner, user_id(1)},
- {role_permissions, 1, view()},
- {owner, user_id(3)},
- {member_update, user_id(1)},
- {owner, user_id(1)}
- ].
-
-flip_spec() ->
- Hidden = flip_channel(),
- (owner_spec())#{
- data => owner_data(
- renumber([
- channel(?CHAN_BASE + 10, 0, null, []),
- channel(Hidden, 2, null, [])
- ])
- ),
- sessions => [#{label => 1, user_id => user_id(2), pending => false}],
- list_subscriptions => [{session_id(1), integer_to_binary(Hidden)}],
- member_subscriptions => [],
- hooks => [
- {add_virtual_channel_access, user_id(4), Hidden},
- {member_update, user_id(4)},
- {remove_virtual_channel_access, user_id(4), Hidden}
- ]
- }.
-
-shared_roles_case(Before, After) ->
- Spec = single_session_spec(
- renumber([
- channel(?CHAN_BASE + 600, 0, null, []),
- channel(?CHAN_BASE + 601, 0, null, Before)
- ])
- ),
- Data = maps:get(data, Spec),
- {
- Spec#{
- data => Data#{
- <<"guild">> => guild(user_id(1)),
- <<"members">> => [member(user_id(I), []) || I <- lists:seq(1, 4)]
- },
- sessions => [
- #{label => L, user_id => user_id(L), pending => false}
- || L <- [1, 2, 3, 4]
- ]
- },
- [{channel_update, channel(?CHAN_BASE + 601, 0, null, After)}]
- }.
-
-check_seed(Seed) ->
- Spec = gen_spec(Seed),
- Events = gen_events(Seed, spec_layout_after_hooks(Spec)),
- try
- check_spec(Spec, Events)
- catch
- Class:Reason:Stack ->
- io:format(
- user, "~nchannel move equivalence failed: seed=~p hooks=~p events=~p~n", [
- Seed, maps:get(hooks, Spec, []), [summarize_event(E) || E <- Events]
- ]
- ),
- erlang:raise(Class, Reason, Stack)
- end.
-
-spec_layout_after_hooks(Spec) ->
- layout(Spec) ++ [C || {channel_create, C} <- maps:get(hooks, Spec, [])].
-
-check_spec(Spec, Events) ->
- {RefHooks, Reference} = run(Spec, Events, reference),
- {CandHooks, Candidate} = run(Spec, Events, optimized),
- assert_same(hooks, log, RefHooks, CandHooks),
- compare_runs(Reference, Candidate, Events, 1),
- #{reference => Reference, optimized => Candidate}.
-
-compare_runs([], [], [], _N) ->
- ok;
-compare_runs([F | Fs], [O | Os], [Event | Events], N) ->
- Context = {event, N, summarize_event(Event)},
- lists:foreach(
- fun(Key) -> assert_same(Context, Key, maps:get(Key, F), maps:get(Key, O)) end,
- [state, log, direct, perm_cache]
- ),
- compare_runs(Fs, Os, Events, N + 1).
-
-assert_same(Context, Key, Full, Optimized) ->
- case first_difference(Full, Optimized, []) of
- none -> ok;
- {Path, A, B} -> erlang:error({Context, Key, Path, trim(A), trim(B)})
- end.
-
-trim(Term) ->
- lists:flatten(io_lib:format("~P", [Term, 12])).
-
-first_difference(Same, Same, _Path) ->
- none;
-first_difference(A, B, Path) when is_map(A), is_map(B) ->
- Keys = lists:usort(maps:keys(A) ++ maps:keys(B)),
- first_of(
- fun(K) ->
- first_difference(maps:get(K, A, '$missing'), maps:get(K, B, '$missing'), [K | Path])
- end,
- Keys
- );
-first_difference(A, B, Path) when is_tuple(A), is_tuple(B), tuple_size(A) =:= tuple_size(B) ->
- first_difference(tuple_to_list(A), tuple_to_list(B), Path);
-first_difference(A, B, Path) when is_list(A), is_list(B), length(A) =:= length(B) ->
- first_of(
- fun({I, X, Y}) -> first_difference(X, Y, [I | Path]) end,
- lists:zip3(lists:seq(1, length(A)), A, B)
- );
-first_difference(A, B, Path) ->
- {lists:reverse(Path), A, B}.
-
-first_of(_Fun, []) ->
- none;
-first_of(Fun, [H | T]) ->
- case Fun(H) of
- none -> first_of(Fun, T);
- Found -> Found
- end.
-
-run(Spec, Events, Mode) ->
- put(?MODE, Mode),
- try
- {State00, Env} = materialize(Spec),
- {State0, HookLog} = apply_hooks(maps:get(hooks, Spec, []), State00, Env),
- {StateN, Results} = lists:foldl(
- fun({Kind, Data}, {S, Acc}) ->
- {S1, Result} = run_event(Kind, Data, S, Env),
- {S1, [Result | Acc]}
- end,
- {State0, []},
- Events
- ),
- teardown(StateN, Env),
- {HookLog, lists:reverse(Results)}
- after
- erase(?MODE)
- end.
-
-apply_hooks(Hooks, State, Env) ->
- State1 = lists:foldl(fun apply_hook/2, State, Hooks),
- State2 = guild_member_list_write:flush_pending_member_list_syncs(State1),
- {Log, Direct, _Fetches} = take_log(Env),
- {State2, {normalize(Log, Env), normalize(Direct, Env)}}.
-
-apply_hook({Action, UserId, ChannelId}, State) when
- Action =:= add_virtual_channel_access; Action =:= remove_virtual_channel_access
-->
- {noreply, Next} = guild:handle_cast({Action, UserId, ChannelId}, State),
- Next;
-apply_hook({channel_create, Channel}, State) ->
- guild:dispatch_event(channel_create, Channel, State);
-apply_hook({owner, UserId}, State) ->
- guild:dispatch_event(guild_update, #{<<"owner_id">> => integer_to_binary(UserId)}, State);
-apply_hook({member_update, UserId}, State) ->
- Member = guild_data_index_members:get_member(UserId, maps:get(data, State)),
- Nick =
- case maps:get(<<"nick">>, Member, null) of
- Previous when is_binary(Previous) -> <<Previous/binary, "x">>;
- _ -> <<"n">>
- end,
- guild:dispatch_event(
- guild_member_update, member_payload(Member#{<<"nick">> => Nick}), State
- );
-apply_hook({role_permissions, Index, Perms}, State) ->
- Role = maps:get(role_id(Index), guild_data_index_roles:role_index(maps:get(data, State))),
- guild:dispatch_event(
- guild_role_update,
- #{<<"role">> => Role#{<<"permissions">> => integer_to_binary(Perms)}},
- State
- );
-apply_hook({patch_everyone, Bit}, State) ->
- {noreply, Next} = guild:handle_cast({patch_everyone_perms, Bit}, State),
- Next;
-apply_hook({everyone_permissions, Perms}, State) ->
- Role = maps:get(?GUILD_ID, guild_data_index_roles:role_index(maps:get(data, State))),
- guild:dispatch_event(
- guild_role_update,
- #{<<"role">> => Role#{<<"permissions">> => integer_to_binary(Perms)}},
- State
- );
-apply_hook({reload, Data}, State) ->
- {reply, ok, Next} = guild:handle_call({reload, Data}, {self(), make_ref()}, State),
- Next;
-apply_hook({ensure_list, ChannelId}, State) ->
- guild_member_list_channel_engine:ensure(integer_to_binary(ChannelId), State).
-
-member_payload(Member) ->
- maps:with([<<"user">>, <<"roles">>, <<"nick">>, <<"joined_at">>], Member).
-
-run_event(Kind, Data, State, Env) ->
- reset_counters(),
- State1 =
- case Kind of
- hook -> apply_hook(Data, State);
- _ -> guild:dispatch_event(Kind, Data, State)
- end,
- State2 = guild_member_list_write:flush_pending_member_list_syncs(State1),
- {Log, Direct, Fetches} = take_log(Env),
- Counts = read_counters(),
- Result = #{
- log => normalize(Log, Env),
- direct => normalize(Direct, Env),
- counts => Counts#{voice_fetch => Fetches},
- state => normalize_state(State2, Env),
- perm_cache => normalize(guild_permission_cache:get_snapshot(?GUILD_ID), Env)
- },
- {State2, Result}.
-
-with_harness(Fun) ->
- Recorder = spawn(fun() -> recorder_loop(empty_log()) end),
- register(?RECORDER, Recorder),
- meck:new(gateway_dispatch_relay, [no_link, no_history]),
- Record = fun(Name, Args) ->
- ?RECORDER ! {rec, self(), {relay, Name, Args}},
- ok
- end,
- meck:expect(gateway_dispatch_relay, dispatch, fun(A, B, C) ->
- Record(dispatch, [A, B, C])
- end),
- meck:expect(gateway_dispatch_relay, dispatch, fun(A, B, C, D) ->
- Record(dispatch, [A, B, C, D])
- end),
- meck:expect(gateway_dispatch_relay, dispatch_many, fun(A, B, C) ->
- Record(dispatch_many, [A, B, C])
- end),
- meck:expect(gateway_dispatch_relay, dispatch_many, fun(A, B, C, D) ->
- Record(dispatch_many, [A, B, C, D])
- end),
- meck:expect(gateway_dispatch_relay, dispatch_direct, fun(A, B, C) ->
- Record(dispatch_direct, [A, B, C])
- end),
- meck:expect(gateway_dispatch_relay, dispatch_grouped, fun(A, B, C, D) ->
- Record(dispatch_grouped, [A, B, C, D])
- end),
- install_modes(),
- ok = start_counters(),
- try
- Fun()
- after
- stop_counters(),
- meck:unload([
- gateway_dispatch_relay, guild_visibility_memo, guild_member_list_engine_inputs
- ]),
- unregister(?RECORDER),
- exit(Recorder, kill)
- end.
-
-install_modes() ->
- meck:new(guild_visibility_memo, [no_link, passthrough, no_history]),
- meck:expect(guild_visibility_memo, new, fun(Ids, Old, New) ->
- case get(?MODE) of
- reference -> disabled;
- _ -> meck:passthrough([Ids, Old, New])
- end
- end),
- meck:new(guild_member_list_engine_inputs, [no_link, passthrough, no_history]),
- meck:expect(guild_member_list_engine_inputs, is_stale, fun(ListId, State) ->
- case get(?MODE) of
- reference -> true;
- _ -> meck:passthrough([ListId, State])
- end
- end).
-
-empty_log() ->
- #{main => [], direct => #{}, fetches => 0}.
-
-recorder_loop(Log = #{main := Main, direct := Direct, fetches := Fetches}) ->
- receive
- {rec, _From, Entry} ->
- recorder_loop(Log#{main := [Entry | Main]});
- {direct, Label, Msg} ->
- recorder_loop(Log#{direct := Direct#{Label => [Msg | maps:get(Label, Direct, [])]}});
- voice_fetch ->
- recorder_loop(Log#{fetches := Fetches + 1});
- {take, From} ->
- From ! {log, Log},
- recorder_loop(empty_log())
- end.
-
-take_log(#{collectors := Collectors}) ->
- lists:foreach(
- fun(Pid) ->
- Ref = make_ref(),
- Pid ! {barrier, self(), Ref},
- receive
- {barrier_done, Ref} -> ok
- after 5000 -> error(collector_timeout)
- end
- end,
- Collectors
- ),
- ?RECORDER ! {take, self()},
- receive
- {log, #{main := Main, direct := Direct, fetches := Fetches}} ->
- {lists:reverse(Main), maps:map(fun(_, V) -> lists:reverse(V) end, Direct), Fetches}
- after 5000 -> error(recorder_timeout)
- end.
-
-collector_loop(Label) ->
- receive
- stop ->
- ok;
- {barrier, From, Ref} ->
- From ! {barrier_done, Ref},
- collector_loop(Label);
- Msg ->
- ?RECORDER ! {direct, Label, Msg},
- collector_loop(Label)
- end.
-
-voice_server_loop(VoiceStates) ->
- receive
- {'$gen_call', From, {get_voice_states_map}} ->
- ?RECORDER ! voice_fetch,
- gen_server:reply(From, VoiceStates),
- voice_server_loop(VoiceStates);
- stop ->
- ok;
- _ ->
- voice_server_loop(VoiceStates)
- end.
-
--define(COUNTED, [
- {bulk_load, {guild_member_list_engine, bulk_load, 3}},
- {perm_put, {guild_permission_cache, put_state, 1}},
- {visibility,
- {guild_visibility_overwrites, compute_and_dispatch_visibility_changes_for_channels, 3}},
- {prune, {guild_maintenance, prune_invalid_member_subscriptions, 1}},
- {can_view, {guild_permissions_check, can_view_channel, 4}}
-]).
-
-start_counters() ->
- [erlang:trace_pattern(MFA, true, [local, call_count]) || {_, MFA} <- ?COUNTED],
- _ = erlang:trace(self(), true, [call]),
- ok.
-
-stop_counters() ->
- _ = erlang:trace(self(), false, [call]),
- [erlang:trace_pattern(MFA, false, [local, call_count]) || {_, MFA} <- ?COUNTED],
- ok.
-
-reset_counters() ->
- [erlang:trace_pattern(MFA, restart, [local, call_count]) || {_, MFA} <- ?COUNTED],
- ok.
-
-read_counters() ->
- maps:from_list([
- {Name, count_or_zero(element(2, erlang:trace_info(MFA, call_count)))}
- || {Name, MFA} <- ?COUNTED
- ]).
-
-count(Name, Counts) ->
- maps:get(Name, Counts).
-
-count_or_zero(N) when is_integer(N) -> N;
-count_or_zero(_) -> 0.
-
-relay_event({relay, _Name, [_Target, Event | _]}) -> Event;
-relay_event(Other) -> Other.
-
-materialize(Spec) ->
- #{
- data := Data,
- sessions := SessionSpecs,
- virtual_access := VirtualAccess,
- voice_states := VoiceStates,
- list_subscriptions := ListSubs,
- member_subscriptions := MemberSubs,
- dm_partners := DmPartners
- } = Spec,
- Collectors = maps:from_list([
- {Label, spawn(fun() -> collector_loop(Label) end)}
- || #{label := Label} <- SessionSpecs
- ]),
- VoicePid = spawn(fun() -> voice_server_loop(VoiceStates) end),
- Base = guild_init:init_base_state(#{
- id => ?GUILD_ID,
- data => Data,
- sessions => #{},
- voice_states => VoiceStates,
- disable_permission_cache_updates => false,
- disable_guild_count_cache_updates => true
- }),
- S1 = guild_init:init_member_list(Base),
- S2 = S1#{
- virtual_channel_access => maps:map(
- fun(_, Chs) -> sets:from_list(Chs) end, VirtualAccess
- ),
- voice_server_pid => VoicePid,
- test_permission_sync_fun => fun(G, C, U, Conn, P) ->
- ?RECORDER ! {rec, self(), {voice_hook, G, C, U, Conn, P}},
- ok
- end
- },
- S3 = lists:foldl(
- fun(SessionSpec, Acc) -> add_session(SessionSpec, Collectors, Acc) end, S2, SessionSpecs
- ),
- S4 = lists:foldl(
- fun({Sid, ListId}, Acc) ->
- {Acc1, _, _} = guild_member_list_subscribe:subscribe_ranges(
- Sid, ListId, [{0, 99}], Acc
- ),
- Acc1
- end,
- S3,
- ListSubs
- ),
- S5 = S4#{
- member_subscriptions => lists:foldl(
- fun({Sid, UserId}, Acc) -> guild_subscriptions:subscribe(Sid, UserId, Acc) end,
- guild_subscriptions:init_state(),
- MemberSubs
- ),
- dm_partners => maps:from_list([
- {Sid, #{
- user_id => UserId,
- pid => maps:get(Label, Collectors),
- partners => maps:from_keys(Partners, true),
- eligible => #{}
- }}
- || {Sid, Label, UserId, Partners} <- DmPartners
- ])
- },
- S6 = guild_dm_partners:maybe_reevaluate(
- guild_role_update,
- #{},
- #{},
- guild_maintenance:maybe_prune_invalid_member_subscriptions(
- guild_role_update, guild_member_list_write:flush_pending_member_list_syncs(S5)
- )
- ),
- ok = guild_permission_cache:put_state(S6),
- Labels = maps:merge(
- maps:from_list([{Pid, {session_pid, Label}} || {Label, Pid} <- maps:to_list(Collectors)]),
- #{VoicePid => voice_server, self() => guild}
- ),
- Env = #{collectors => maps:values(Collectors), labels => Labels, voice_pid => VoicePid},
- _ = take_log(Env),
- {S6, Env}.
-
-add_session(#{label := Label, user_id := UserId, pending := Pending}, Collectors, State) ->
- Sid = session_id(Label),
- Pid = maps:get(Label, Collectors),
- Viewable =
- case Pending of
- true ->
- #{};
- false ->
- guild_sessions:build_viewable_channel_map(
- guild_visibility_channels:get_user_viewable_channels(UserId, State)
- )
- end,
- Session = #{
- session_id => Sid,
- user_id => UserId,
- pid => Pid,
- mref => make_ref(),
- active_guilds => sets:new(),
- user_roles => [],
- bot => false,
- is_staff => false,
- pending_connect => Pending,
- viewable_channels => Viewable
- },
- ets:insert(maps:get(member_presence, State), {UserId, #{<<"status">> => <<"online">>}}),
- Sessions = maps:get(sessions, State, #{}),
- Counts = maps:get(user_session_counts, State, #{}),
- State#{
- sessions => Sessions#{Sid => Session},
- connected_user_ids => sets:add_element(UserId, maps:get(connected_user_ids, State)),
- user_session_counts => Counts#{UserId => maps:get(UserId, Counts, 0) + 1}
- }.
-
-teardown(State, #{collectors := Collectors, voice_pid := VoicePid}) ->
- _ = guild_member_list_channel_engine:destroy_all(State),
- Data = maps:get(data, State),
- lists:foreach(
- fun(Tab) -> catch ets:delete(Tab) end,
- [
- maps:get(members_ets, Data),
- maps:get(member_presence, State),
- maps:get(member_list_subscriptions, State),
- maps:get(viewable_channels_cache, State)
- ]
- ),
- [Pid ! stop || Pid <- Collectors],
- VoicePid ! stop,
- guild_permission_cache:delete(?GUILD_ID),
- ok.
-
-normalize_state(State, Env) ->
- Engines = maps:get(channel_member_list_engines, State, #{}),
- EngineSnapshots = maps:map(
- fun(ListId, Ref) ->
- {
- guild_member_list_read:member_list_snapshot(ListId, State),
- guild_member_list_engine:get_sorted_user_ids(Ref),
- guild_member_list_engine:get_counts(Ref),
- guild_member_list_engine:get_groups(Ref)
- }
- end,
- Engines
- ),
- Stripped = maps:without(
- [
- channel_member_list_engines,
- channel_member_list_engine_inputs,
- member_list_engine,
- test_permission_sync_fun
- ],
- State
- ),
- {EngineSnapshots, normalize(Stripped, Env)}.
-
-normalize(Term, #{labels := Labels}) ->
- normalize_term(Term, Labels).
-
-normalize_term(Pid, Labels) when is_pid(Pid) ->
- maps:get(Pid, Labels, pid);
-normalize_term(Ref, Labels) when is_reference(Ref) ->
- case catch ets:tab2list(Ref) of
- Rows when is_list(Rows) -> {ets, lists:sort(normalize_term(Rows, Labels))};
- _ -> ref
- end;
-normalize_term(Fun, _Labels) when is_function(Fun) ->
- 'fun';
-normalize_term({relay, dispatch_many, [Pids | Rest]}, Labels) when is_list(Pids) ->
- {relay, dispatch_many, [
- lists:sort(normalize_term(Pids, Labels)) | normalize_term(Rest, Labels)
- ]};
-normalize_term(List, Labels) when is_list(List) ->
- [normalize_term(E, Labels) || E <- List];
-normalize_term(Tuple, Labels) when is_tuple(Tuple) ->
- list_to_tuple(normalize_term(tuple_to_list(Tuple), Labels));
-normalize_term(Map, Labels) when is_map(Map) ->
- maps:from_list([
- {normalize_term(K, Labels), normalize_term(V, Labels)}
- || {K, V} <- maps:to_list(Map)
- ]);
-normalize_term(Other, _Labels) ->
- Other.
-
-summarize_event({channel_update, Data}) ->
- {channel_update, maps:get(<<"id">>, Data)};
-summarize_event({channel_update_bulk, #{<<"channels">> := Channels}}) ->
- {channel_update_bulk, length(Channels)};
-summarize_event({hook, Hook}) ->
- {hook, Hook};
-summarize_event({Kind, Data}) ->
- {Kind, Data}.
-
-seed_count() ->
- env_int("CHMOVE_SEEDS", ?DEFAULT_SEEDS).
-
-env_int(Name, Default) ->
- case os:getenv(Name) of
- false -> Default;
- "" -> Default;
- Value -> list_to_integer(Value)
- end.
-
-session_id(Label) ->
- <<"s", (integer_to_binary(Label))/binary>>.
-
-session_map(Sid, State) ->
- maps:get(viewable_channels, maps:get(Sid, maps:get(sessions, State))).
-
-user_id(I) -> ?USER_BASE + I.
-
-role_id(I) -> ?ROLE_BASE + I.
-
-view() -> constants:view_channel_permission().
-connect() -> constants:connect_permission().
-speak() -> constants:speak_permission().
-stream() -> constants:stream_permission().
-members_view() -> constants:view_channel_members_permission().
-admin() -> constants:administrator_permission().
-
-hidden_overwrite() ->
- overwrite(?GUILD_ID, 0, 0, view()).
-
-position_move(Spec) ->
- bulk_event(renumber(lists:reverse(spec_layout_after_hooks(Spec)))).
-
-gap_spec(InitialParent) ->
- Hidden = ?CHAN_BASE + 500,
- Parent =
- case InitialParent of
- Hidden -> null;
- _ -> Hidden
- end,
- Layout = renumber([
- channel(Hidden, 4, null, [overwrite(?GUILD_ID, 0, 0, view())]),
- channel(?CHAN_BASE + 501, 0, Parent, [])
- ]),
- single_session_spec(Layout).
-
-single_session_spec(Layout) ->
- Spec = ticker_spec(),
- Data = maps:get(data, Spec),
- Spec#{
- data => Data#{<<"channels">> => Layout},
- voice_states => #{},
- list_subscriptions => [],
- sessions => [
- #{label => 1, user_id => user_id(2), pending => false}
- ],
- member_subscriptions => []
- }.
-
-replace(Channel, Layout) ->
- Id = channel_int_id(Channel),
- [
- case channel_int_id(C) of
- Id -> Channel;
- _ -> C
- end
- || C <- Layout
- ].
-
-gen_spec(Seed) ->
- rand:seed(exsss, {Seed, 104729, 7919}),
- NumRoles = between(3, 8),
- NumMembers = between(20, 150),
- RoleIds = [role_id(R) || R <- lists:seq(1, NumRoles)],
- UserIds = [user_id(I) || I <- lists:seq(1, NumMembers)],
- Roles = [
- everyone_role() | [role(R, Id) || {R, Id} <- lists:zip(lists:seq(1, NumRoles), RoleIds)]
- ],
- Members = [member(U, pick_subset(RoleIds, 0.25)) || U <- UserIds],
- Layout = gen_layout(RoleIds, UserIds),
- Data = #{
- <<"guild">> => guild(user_id(1)),
- <<"roles">> => Roles,
- <<"members">> => Members,
- <<"channels">> => Layout,
- <<"emojis">> => [],
- <<"stickers">> => []
- },
- ChannelIds = [channel_int_id(C) || C <- Layout],
- VoiceChannelIds = [channel_int_id(C) || C <- Layout, maps:get(<<"type">>, C) =:= 2],
- SessionSpecs = [gen_session(L, UserIds) || L <- lists:seq(1, between(5, 40))],
- SessionUsers = [U || #{user_id := U} <- SessionSpecs],
- VirtualAccess = gen_virtual_access(SessionUsers, ChannelIds),
- #{
- data => Data,
- sessions => SessionSpecs,
- virtual_access => VirtualAccess,
- hooks => gen_hooks(VirtualAccess, SessionUsers, UserIds, NumRoles, Layout),
- voice_states => gen_voice_states(SessionUsers ++ UserIds, VoiceChannelIds),
- list_subscriptions => [
- {session_id(L), integer_to_binary(pick(ChannelIds))}
- || #{label := L} <- SessionSpecs, rand:uniform() < 0.5
- ],
- member_subscriptions => [
- {session_id(L), pick(UserIds)}
- || #{label := L} <- SessionSpecs, _ <- lists:seq(1, between(0, 4))
- ],
- dm_partners => [
- {session_id(L), L, U, [pick(UserIds) || _ <- lists:seq(1, between(1, 5))]}
- || #{label := L, user_id := U} <- SessionSpecs, rand:uniform() < 0.3
- ]
- }.
-
-layout(#{data := #{<<"channels">> := Layout}}) ->
- Layout.
-
-everyone_role() ->
- Base = view() bor members_view() bor connect() bor speak(),
- Perms =
- case rand:uniform() < 0.15 of
- true -> Base band bnot view();
- false -> Base
- end,
- #{
- <<"id">> => integer_to_binary(?GUILD_ID),
- <<"name">> => <<"@everyone">>,
- <<"permissions">> => integer_to_binary(Perms),
- <<"position">> => 0,
- <<"hoist">> => false
- }.
-
-role(Position, Id) ->
- #{
- <<"id">> => integer_to_binary(Id),
- <<"name">> => <<"r", (integer_to_binary(Position))/binary>>,
- <<"permissions">> => integer_to_binary(random_role_permissions()),
- <<"position">> => Position,
- <<"hoist">> => rand:uniform() < 0.4,
- <<"color">> => 0
- }.
-
-random_role_permissions() ->
- Bits = lists:foldl(
- fun(Bit, Acc) -> Acc bor Bit end,
- 0,
- pick_subset([view(), connect(), speak(), stream(), members_view()], 0.4)
- ),
- case rand:uniform() < 0.05 of
- true -> Bits bor admin();
- false -> Bits
- end.
-
-plain_role(Position, Id) ->
- (role(Position, Id))#{<<"permissions">> => <<"0">>, <<"hoist">> => false}.
-
-member(UserId, Roles) ->
- #{
- <<"user">> => #{
- <<"id">> => integer_to_binary(UserId),
- <<"username">> => <<"u", (integer_to_binary(UserId))/binary>>,
- <<"global_name">> => null,
- <<"avatar">> => null,
- <<"discriminator">> => <<"0001">>,
- <<"bot">> => false
- },
- <<"roles">> => [integer_to_binary(R) || R <- Roles],
- <<"nick">> => null,
- <<"joined_at">> => <<"2026-08-01T00:00:00Z">>
- }.
-
-gen_layout(RoleIds, UserIds) ->
- NumCats = between(2, 4),
- Top = [
- channel(?CHAN_BASE + 10 + I, pick([0, 0, 2]), null, gen_overwrites(RoleIds, UserIds))
- || I <- lists:seq(1, between(1, 3))
- ],
- Cats = lists:append([
- gen_category(C, RoleIds, UserIds)
- || C <- lists:seq(1, NumCats)
- ]),
- Odd =
- case rand:uniform() < 0.3 of
- true ->
- [TopParent | _] = Top,
- [
- channel(
- ?CHAN_BASE + 900,
- 0,
- pick([channel_int_id(TopParent), ?DANGLING_PARENT]),
- gen_overwrites(RoleIds, UserIds)
- )
- ];
- false ->
- []
- end,
- renumber(Top ++ Cats ++ Odd).
-
-gen_category(C, RoleIds, UserIds) ->
- CatId = ?CHAN_BASE + 100 * C,
- CatOverwrites =
- case rand:uniform() < 0.4 of
- true -> [overwrite(?GUILD_ID, 0, 0, view())];
- false -> gen_overwrites(RoleIds, UserIds)
- end,
- Children = [
- channel(CatId + I, pick([0, 2]), CatId, gen_child_overwrites(RoleIds, UserIds))
- || I <- lists:seq(1, between(0, 4))
- ],
- [channel(CatId, 4, null, CatOverwrites) | Children].
-
-gen_child_overwrites(RoleIds, UserIds) ->
- case rand:uniform() of
- X when X < 0.2 ->
- [overwrite(pick(RoleIds), 0, view(), 0)];
- X when X < 0.3 ->
- [overwrite(pick(UserIds), 1, view(), 0)];
- _ ->
- gen_overwrites(RoleIds, UserIds)
- end.
-
-gen_overwrites(RoleIds, UserIds) ->
- [gen_overwrite(RoleIds, UserIds) || _ <- lists:seq(1, between(0, 3))].
-
-gen_overwrite(RoleIds, UserIds) ->
- {Id, Type} =
- case rand:uniform(3) of
- 1 -> {?GUILD_ID, 0};
- 2 -> {pick(RoleIds), 0};
- 3 -> {pick(UserIds), 1}
- end,
- Bits = [view(), connect(), speak(), stream()],
- Allow = lists:foldl(fun(B, A) -> A bor B end, 0, pick_subset(Bits, 0.3)),
- Deny = lists:foldl(fun(B, A) -> A bor B end, 0, pick_subset(Bits, 0.3)) band bnot Allow,
- overwrite(Id, Type, Allow, Deny).
-
-overwrite(Id, Type, Allow, Deny) ->
- #{
- <<"id">> => integer_to_binary(Id),
- <<"type">> => Type,
- <<"allow">> => integer_to_binary(Allow),
- <<"deny">> => integer_to_binary(Deny)
- }.
-
-channel(Id, Type, Parent, Overwrites) ->
- Base = #{
- <<"id">> => integer_to_binary(Id),
- <<"guild_id">> => integer_to_binary(?GUILD_ID),
- <<"type">> => Type,
- <<"name">> => <<"ch-", (integer_to_binary(Id))/binary>>,
- <<"position">> => 0,
- <<"permission_overwrites">> => Overwrites
- },
- case Type of
- 4 -> Base;
- _ -> Base#{<<"parent_id">> => parent_bin(Parent)}
- end.
-
-parent_bin(null) -> null;
-parent_bin(Id) -> integer_to_binary(Id).
-
-channel_int_id(Channel) ->
- snowflake_id:parse_maybe(maps:get(<<"id">>, Channel)).
-
-channel_parent(Channel) ->
- case maps:get(<<"parent_id">>, Channel, null) of
- null -> null;
- P -> binary_to_integer(P)
- end.
-
-renumber(Layout) ->
- [C#{<<"position">> => P} || {P, C} <- lists:zip(lists:seq(1, length(Layout)), Layout)].
-
-gen_session(Label, UserIds) ->
- #{
- label => Label,
- user_id => pick(UserIds),
- pending => rand:uniform() < 0.05
- }.
-
-gen_virtual_access(UserIds, ChannelIds) ->
- maps:from_list([
- {pick(UserIds), [pick(ChannelIds) || _ <- lists:seq(1, between(1, 2))]}
- || _ <- lists:seq(1, between(0, 4))
- ]).
-
-gen_hooks(VirtualAccess, SessionUsers, UserIds, NumRoles, Layout) ->
- ChannelIds = [channel_int_id(C) || C <- Layout],
- Held = [{U, C} || {U, Cs} <- maps:to_list(VirtualAccess), C <- Cs],
- lists:append([
- gen_hook(Held, SessionUsers, UserIds, NumRoles, Layout, ChannelIds, I)
- || I <- lists:seq(1, pick([0, 0, 1, 2, 3]))
- ]).
-
-gen_hook(Held, SessionUsers, UserIds, NumRoles, Layout, ChannelIds, I) ->
- case rand:uniform(10) of
- 1 when Held =/= [] ->
- {U, C} = pick(Held),
- [{remove_virtual_channel_access, U, C}];
- 2 ->
- [{add_virtual_channel_access, pick(UserIds), pick(ChannelIds)}];
- 3 ->
- U = pick(UserIds),
- C = pick(ChannelIds),
- [
- {add_virtual_channel_access, U, C},
- {member_update, U},
- {remove_virtual_channel_access, U, C}
- ];
- 4 ->
- [{owner, pick(SessionUsers ++ UserIds)}];
- 5 ->
- Other = pick(UserIds),
- [
- {owner, user_id(1)},
- {role_permissions, 1, random_role_permissions()},
- {owner, Other},
- {member_update, user_id(1)},
- {member_update, Other},
- {owner, user_id(1)}
- ];
- 6 ->
- [{channel_create, created_channel(Layout, I)}];
- 7 ->
- [{ensure_list, pick(ChannelIds)}];
- 8 ->
- Index = between(1, NumRoles),
- [
- {role_permissions, Index, random_role_permissions()},
- {member_update, pick(UserIds)}
- ];
- 9 ->
- [{member_update, pick(UserIds)}];
- _ ->
- [
- {ensure_list, pick(ChannelIds)},
- {add_virtual_channel_access, pick(SessionUsers ++ UserIds), pick(ChannelIds)}
- ]
- end.
-
-created_channel(Layout, I) ->
- Cats = [channel_int_id(C) || C <- Layout, maps:get(<<"type">>, C) =:= 4],
- Parent =
- case Cats of
- [] -> null;
- _ -> pick([null | Cats])
- end,
- RoleIds = [role_id(R) || R <- lists:seq(1, 3)],
- UserIds = [user_id(U) || U <- lists:seq(1, 20)],
- channel(?CHAN_BASE + 950 + I, pick([0, 2]), Parent, gen_overwrites(RoleIds, UserIds)).
-
-gen_voice_states(_UserIds, []) ->
- #{};
-gen_voice_states(UserIds, VoiceChannelIds) ->
- maps:from_list([
- begin
- Conn = <<"c", (integer_to_binary(I))/binary>>,
- {Conn, #{
- <<"user_id">> => integer_to_binary(pick(UserIds)),
- <<"channel_id">> => integer_to_binary(pick(VoiceChannelIds)),
- <<"guild_id">> => integer_to_binary(?GUILD_ID),
- <<"connection_id">> => Conn,
- <<"session_id">> => <<"vs", (integer_to_binary(I))/binary>>,
- <<"self_mute">> => false,
- <<"self_deaf">> => false,
- <<"self_stream">> => rand:uniform() < 0.3,
- <<"self_video">> => false,
- <<"deaf">> => false,
- <<"mute">> => false
- }}
- end
- || I <- lists:seq(1, between(0, 8))
- ]).
-
-gen_events(Seed, Layout0) ->
- rand:seed(exsss, {Seed, 15485863, 32452843}),
- {Events, _} = lists:foldl(
- fun(_, {Acc, Layout}) ->
- {Event, Layout1} = gen_event(Layout),
- Interleaved =
- case rand:uniform() < 0.25 of
- true -> [Event, {hook, {member_update, user_id(between(1, 20))}}];
- false -> [Event]
- end,
- {lists:reverse(Interleaved, Acc), Layout1}
- end,
- {[], Layout0},
- lists:seq(1, between(1, 4))
- ),
- lists:reverse(Events).
-
-gen_event(Layout) ->
- NonCats = [C || C <- Layout, maps:get(<<"type">>, C) =/= 4],
- Kinds =
- [position_only, noop, overwrite, name, subset, category_overwrite] ++
- case NonCats of
- [] ->
- [];
- _ ->
- [
- move,
- move,
- move,
- single_move,
- single_move,
- subset_move,
- type_change,
- mixed
- ]
- end,
- gen_event(pick(Kinds), Layout, NonCats).
-
-gen_event(position_only, Layout, _NonCats) ->
- New = renumber(rotate(Layout)),
- {bulk_event(New), New};
-gen_event(noop, Layout, _NonCats) ->
- {bulk_event(Layout), Layout};
-gen_event(move, Layout, NonCats) ->
- Ids = lists:usort([channel_int_id(pick(NonCats)) || _ <- lists:seq(1, between(1, 3))]),
- New = move_channels(Ids, pick_target(Layout), Layout),
- {bulk_event(New), New};
-gen_event(single_move, Layout, NonCats) ->
- Id = channel_int_id(pick(NonCats)),
- New = move_channels([Id], pick_target(Layout), Layout),
- {{channel_update, find(Id, New)}, New};
-gen_event(subset_move, Layout, NonCats) ->
- Ids = lists:usort([channel_int_id(pick(NonCats)) || _ <- lists:seq(1, between(1, 3))]),
- New = move_channels(Ids, pick_target(Layout), Layout),
- {bulk_event([C || C <- New, lists:member(channel_int_id(C), Ids)]), New};
-gen_event(overwrite, Layout, _NonCats) ->
- Id = channel_int_id(pick(Layout)),
- New = update_channel(
- Id, fun(C) -> C#{<<"permission_overwrites">> => random_overwrites(Layout)} end, Layout
- ),
- single_or_bulk(Id, New);
-gen_event(category_overwrite, Layout, _NonCats) ->
- case [C || C <- Layout, maps:get(<<"type">>, C) =:= 4] of
- [] ->
- {bulk_event(Layout), Layout};
- Cats ->
- Id = channel_int_id(pick(Cats)),
- Toggle = fun(C) ->
- case maps:get(<<"permission_overwrites">>, C) of
- [] ->
- C#{<<"permission_overwrites">> => [overwrite(?GUILD_ID, 0, 0, view())]};
- _ ->
- C#{<<"permission_overwrites">> => []}
- end
- end,
- single_or_bulk(Id, update_channel(Id, Toggle, Layout))
- end;
-gen_event(name, Layout, _NonCats) ->
- Id = channel_int_id(pick(Layout)),
- New = update_channel(Id, fun(C) -> C#{<<"name">> => <<"renamed">>} end, Layout),
- single_or_bulk(Id, New);
-gen_event(type_change, Layout, NonCats) ->
- Id = channel_int_id(pick(NonCats)),
- Flip = fun(C) ->
- case maps:get(<<"type">>, C) of
- 0 -> C#{<<"type">> => 2};
- _ -> C#{<<"type">> => 0}
- end
- end,
- single_or_bulk(Id, update_channel(Id, Flip, Layout));
-gen_event(subset, Layout, _NonCats) ->
- Subset = pick_subset(Layout, 0.4),
- SubsetIds = [channel_int_id(C) || C <- Subset],
- New = renumber(rotate(Layout)),
- {
- bulk_event([C || C <- New, lists:member(channel_int_id(C), SubsetIds)]),
- merge_subset(Layout, New, SubsetIds)
- };
-gen_event(mixed, Layout, NonCats) ->
- Id = channel_int_id(pick(NonCats)),
- Moved = move_channels([Id], pick_target(Layout), Layout),
- Other = channel_int_id(pick(Moved)),
- New = update_channel(
- Other, fun(C) -> C#{<<"permission_overwrites">> => random_overwrites(Moved)} end, Moved
- ),
- {bulk_event(New), New}.
-
-single_or_bulk(Id, New) ->
- case rand:uniform() < 0.5 of
- true -> {{channel_update, find(Id, New)}, New};
- false -> {bulk_event(New), New}
- end.
-
-bulk_event(Channels) ->
- {channel_update_bulk, #{<<"channels">> => Channels}}.
-
-merge_subset(Old, New, SubsetIds) ->
- [
- case lists:member(channel_int_id(C), SubsetIds) of
- true -> find(channel_int_id(C), New);
- false -> C
- end
- || C <- Old
- ].
-
-random_overwrites(Layout) ->
- RoleIds = [role_id(R) || R <- lists:seq(1, 3)],
- UserIds = [user_id(I) || I <- lists:seq(1, 20)],
- case rand:uniform() < 0.2 of
- true ->
- Existing = maps:get(<<"permission_overwrites">>, pick(Layout)),
- Existing;
- false ->
- gen_overwrites(RoleIds, UserIds)
- end.
-
-pick_target(Layout) ->
- Cats = [channel_int_id(C) || C <- Layout, maps:get(<<"type">>, C) =:= 4],
- NonCats = [channel_int_id(C) || C <- Layout, maps:get(<<"type">>, C) =/= 4],
- case rand:uniform() of
- X when X < 0.65, Cats =/= [] -> {parent, pick(Cats)};
- X when X < 0.85 -> {parent, null};
- X when X < 0.93, NonCats =/= [] -> {parent, pick(NonCats)};
- _ -> {parent, ?DANGLING_PARENT}
- end.
-
-move_channels(Ids, {parent, Target}, Layout) ->
- Moving = [
- C#{<<"parent_id">> => parent_bin(Target)}
- || C <- Layout, lists:member(channel_int_id(C), Ids)
- ],
- Rest = [C || C <- Layout, not lists:member(channel_int_id(C), Ids)],
- renumber(insert_after(Target, Moving, Rest)).
-
-insert_after(Target, Moving, Rest) ->
- case lists:splitwith(fun(C) -> channel_int_id(C) =/= Target end, Rest) of
- {Before, [T | After]} ->
- {Kids, Tail} = lists:splitwith(fun(C) -> channel_parent(C) =:= Target end, After),
- Before ++ [T | Kids] ++ Moving ++ Tail;
- {_, []} ->
- Moving ++ Rest
- end.
-
-update_channel(Id, Fun, Layout) ->
- [
- case channel_int_id(C) of
- Id -> Fun(C);
- _ -> C
- end
- || C <- Layout
- ].
-
-find(Id, Layout) ->
- hd([C || C <- Layout, channel_int_id(C) =:= Id]).
-
-rotate([]) -> [];
-rotate([H | T]) -> T ++ [H].
-
-between(Lo, Hi) ->
- Lo + rand:uniform(Hi - Lo + 1) - 1.
-
-pick(List) ->
- lists:nth(rand:uniform(length(List)), List).
-
-pick_subset(List, P) ->
- [E || E <- List, rand:uniform() < P].
-
-ticker_category() ->
- ?CHAN_BASE + 100.
-
-ticker_ids() ->
- [?CHAN_BASE + 60 + I || I <- lists:seq(1, 3)].
-
-ticker_spec() ->
- rand:seed(exsss, {1, 2, 3}),
- UserIds = [user_id(I) || I <- lists:seq(1, 60)],
- RoleIds = [role_id(1), role_id(2)],
- Tickers = [
- channel(Id, 2, null, [overwrite(?GUILD_ID, 0, 0, connect())])
- || Id <- ticker_ids()
- ],
- Public = [
- channel(ticker_category(), 4, null, []),
- channel(ticker_category() + 1, 0, ticker_category(), []),
- channel(ticker_category() + 2, 2, ticker_category(), [])
- ],
- Private = [
- channel(?CHAN_BASE + 200, 4, null, [overwrite(?GUILD_ID, 0, 0, view())]),
- channel(?CHAN_BASE + 201, 0, ?CHAN_BASE + 200, [
- overwrite(?GUILD_ID, 0, 0, view()), overwrite(role_id(1), 0, view(), 0)
- ])
- ],
- Layout = renumber(Tickers ++ Public ++ Private),
- Sessions = [
- #{label => L, user_id => user_id(L), pending => false}
- || L <- lists:seq(1, 20)
- ],
- #{
- data => #{
- <<"guild">> => guild(user_id(1)),
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(?GUILD_ID),
- <<"permissions">> => integer_to_binary(
- view() bor members_view() bor connect() bor speak()
- ),
- <<"position">> => 0
- }
- | [role(P, Id) || {P, Id} <- lists:zip([1, 2], RoleIds)]
- ],
- <<"members">> => [member(U, pick_subset(RoleIds, 0.3)) || U <- UserIds],
- <<"channels">> => Layout,
- <<"emojis">> => [],
- <<"stickers">> => []
- },
- sessions => Sessions,
- virtual_access => #{},
- voice_states => gen_voice_states(UserIds, [ticker_category() + 2]),
- list_subscriptions => [
- {
- session_id(L),
- integer_to_binary(pick([ticker_category() + 1, ticker_category() + 2]))
- }
- || L <- lists:seq(1, 20)
- ],
- member_subscriptions => [{session_id(L), pick(UserIds)} || L <- lists:seq(1, 20)],
- dm_partners => []
- }.
-
-hidden_voice_spec() ->
- Spec = ticker_spec(),
- Hidden = ?CHAN_BASE + 202,
- Data = maps:get(data, Spec),
- Layout = renumber(
- maps:get(<<"channels">>, Data) ++
- [channel(Hidden, 2, ?CHAN_BASE + 200, [overwrite(?GUILD_ID, 0, 0, view())])]
- ),
- Voice = #{
- <<"hv">> => #{
- <<"user_id">> => integer_to_binary(user_id(5)),
- <<"channel_id">> => integer_to_binary(Hidden),
- <<"guild_id">> => integer_to_binary(?GUILD_ID),
- <<"connection_id">> => <<"hv">>,
- <<"session_id">> => <<"hvs">>,
- <<"self_stream">> => true,
- <<"deaf">> => false
- }
- },
- Spec#{data => Data#{<<"channels">> => Layout}, voice_states => Voice}.
diff --git a/fluxer_gateway/test/guild_connect_async_tests.erl b/fluxer_gateway/test/guild_connect_async_tests.erl
deleted file mode 100644
index acb5fb401..000000000
--- a/fluxer_gateway/test/guild_connect_async_tests.erl
+++ /dev/null
@@ -1,383 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_connect_async_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-finalize_pending_session_tracks_connected_user_test() ->
- SessionId = <<"s1">>,
- UserId = 10,
- Attempt = 3,
- State0 = finalize_state(SessionId, UserId, Attempt, true, #{}, sets:new(), #{UserId => 1}),
- State1 = finalize_session(SessionId, UserId, Attempt, State0),
- ?assertEqual(#{UserId => 1}, maps:get(user_session_counts, State1)),
- ?assertEqual(true, sets:is_element(UserId, maps:get(connected_user_ids, State1))),
- ?assertEqual(2, maps:get(UserId, maps:get(presence_subscriptions, State1))),
- flush_connect_result().
-
-finalize_records_the_thread_viewer_flag_test() ->
- Key = channel_threads_config,
- Previous = persistent_term:get(Key, undefined),
- persistent_term:put(Key, (channel_threads_config:default_config())#{
- enabled => true, included_users => #{<<"10">> => true}
- }),
- try
- SessionId = <<"s-thread">>,
- Attempt = 2,
- State0 = finalize_state(SessionId, 10, Attempt, true, #{}, sets:new(), #{}),
- State1 = State0#{data => #{thread_gate => #{active => true, version => 1}}},
- Computed0 = finalize_computed(SessionId, 10),
- Request = (maps:get(request, Computed0))#{thread_channels_capable => true},
- Computed = Computed0#{request => Request, thread_viewer => true},
- State2 = guild_connect_async:finalize_session_connect_async(
- SessionId, Attempt, {ok, #{}}, Computed, State1
- ),
- Session = maps:get(SessionId, maps:get(sessions, State2)),
- ?assertEqual(true, maps:get(thread_viewer, Session)),
- ?assertEqual(true, maps:get(thread_capable, Session)),
- receive
- {thread_flip_resend, SessionId} -> ?assert(false)
- after 0 -> ok
- end,
- flush_connect_result()
- after
- case Previous of
- undefined -> persistent_term:erase(Key);
- _ -> persistent_term:put(Key, Previous)
- end
- end.
-
-finalize_connected_session_does_not_double_count_test() ->
- SessionId = <<"s1">>,
- UserId = 10,
- Attempt = 4,
- State0 = finalize_state(
- SessionId,
- UserId,
- Attempt,
- false,
- #{UserId => 1},
- sets:from_list([UserId]),
- #{UserId => 1}
- ),
- State1 = finalize_session(SessionId, UserId, Attempt, State0),
- ?assertEqual(#{UserId => 1}, maps:get(user_session_counts, State1)),
- ?assertEqual(true, sets:is_element(UserId, maps:get(connected_user_ids, State1))),
- ?assertEqual(1, maps:get(UserId, maps:get(presence_subscriptions, State1))),
- flush_connect_result().
-
-finalize_not_member_discards_pending_session_test() ->
- SessionId = <<"s-nm">>,
- UserId = 777,
- Attempt = 1,
- Pending = #{
- session_id => SessionId,
- user_id => UserId,
- pid => self(),
- mref => make_ref(),
- pending_connect => true,
- active_guilds => sets:new()
- },
- State0 = #{
- id => 42,
- sessions => #{SessionId => Pending},
- session_connect_pending => #{SessionId => Attempt},
- session_connect_inflight => 1,
- session_connect_queue => queue:new(),
- user_session_counts => #{},
- connected_user_ids => sets:new(),
- presence_subscriptions => #{}
- },
- State1 = guild_connect_async:finalize_session_connect_async(
- SessionId,
- Attempt,
- {error, not_member},
- finalize_computed(SessionId, UserId),
- State0
- ),
- ?assertEqual(#{}, maps:get(sessions, State1)),
- ?assertEqual(0, maps:get(UserId, maps:get(user_session_counts, State1), 0)),
- ?assertNot(sets:is_element(UserId, maps:get(connected_user_ids, State1))),
- receive
- {guild_connect_result, 42, Attempt, {error, not_member}} -> ok
- after 0 ->
- ?assert(false, not_member_result_not_relayed)
- end.
-
-enqueue_session_connect_async_drops_oldest_waiter_when_queue_full_test() ->
- OldSessionId = <<"s-old">>,
- NewSessionId = <<"s-new">>,
- GuildId = 42,
- OldAttempt = 1,
- NewAttempt = 2,
- State0 = saturated_connect_state(GuildId, OldSessionId, OldAttempt, 1),
- Request = connect_request(NewSessionId, 20),
- State1 = guild_connect_async:enqueue_session_connect_async(
- GuildId, NewAttempt, Request, #{}, State0
- ),
- Pending = maps:get(session_connect_pending, State1),
- ?assertEqual(false, maps:is_key(OldSessionId, Pending)),
- ?assertEqual(NewAttempt, maps:get(NewSessionId, Pending)),
- ?assertEqual(false, maps:is_key(OldSessionId, maps:get(sessions, State1))),
- ?assertEqual(true, maps:is_key(NewSessionId, maps:get(sessions, State1))),
- QueueItems = queue:to_list(maps:get(session_connect_queue, State1)),
- ?assertEqual([NewSessionId], queued_session_ids(QueueItems)),
- receive
- {guild_connect_result, GuildId, OldAttempt, {error, overloaded}} -> ok
- after 0 ->
- ?assert(false, overflow_drop_was_not_reported)
- end.
-
-enqueue_session_connect_async_allows_immediate_start_when_wait_queue_disabled_test() ->
- SessionId = <<"s-start">>,
- GuildId = 42,
- Attempt = 1,
- State0 = #{
- id => GuildId,
- sessions => #{},
- session_connect_queue => queue:new(),
- session_connect_pending => #{},
- session_connect_inflight => 0,
- session_connect_max_queue => 0,
- data => #{},
- member_count => 0,
- voice_states => #{},
- member_list_engine => undefined,
- virtual_channel_access => #{}
- },
- State1 = guild_connect_async:enqueue_session_connect_async(
- GuildId, Attempt, connect_request(SessionId, 30), #{}, State0
- ),
- ?assertEqual(1, maps:get(session_connect_inflight, State1)),
- ?assertEqual([], queue:to_list(maps:get(session_connect_queue, State1))),
- ?assertEqual(Attempt, maps:get(SessionId, maps:get(session_connect_pending, State1))),
- WorkerRefs = maps:get(session_connect_worker_refs, State1, #{}),
- cleanup_worker_refs(WorkerRefs).
-
-finalize_batch_upserts_every_result_and_frees_one_worker_test() ->
- UserId = 10,
- Sessions = [<<"s1">>, <<"s2">>],
- State0 = (finalize_state(<<"s1">>, UserId, 1, true, #{}, sets:new(), #{UserId => 1}))#{
- sessions => maps:from_list([{S, pending_entry(S, UserId)} || S <- Sessions]),
- session_connect_pending => maps:from_list([{S, 1} || S <- Sessions]),
- session_connect_inflight => 2
- },
- State1 = guild_connect_async:finalize_session_connect_batch(
- [{S, 1, {ok, #{}}, finalize_computed(S, UserId)} || S <- Sessions], State0
- ),
- ?assertEqual(1, maps:get(session_connect_inflight, State1)),
- ?assertEqual(#{}, maps:get(session_connect_pending, State1)),
- [
- ?assertEqual(false, maps:get(pending_connect, maps:get(S, maps:get(sessions, State1))))
- || S <- Sessions
- ],
- ?assertEqual(#{UserId => 2}, maps:get(user_session_counts, State1)),
- ?assertEqual(3, maps:get(UserId, maps:get(presence_subscriptions, State1))),
- ?assertEqual(2, length(flush_connect_results())).
-
-finalize_batch_skips_stale_attempts_test() ->
- UserId = 11,
- State0 = finalize_state(<<"s1">>, UserId, 2, true, #{}, sets:new(), #{UserId => 1}),
- State1 = guild_connect_async:finalize_session_connect_batch(
- [{<<"s1">>, 1, {ok, #{}}, finalize_computed(<<"s1">>, UserId)}], State0
- ),
- ?assertEqual(#{<<"s1">> => 2}, maps:get(session_connect_pending, State1)),
- ?assertEqual(
- true, maps:get(pending_connect, maps:get(<<"s1">>, maps:get(sessions, State1)))
- ),
- ?assertEqual([], flush_connect_results()).
-
-full_guild_reconnect_fits_the_connect_queue_test() ->
- GuildId = 42,
- State0 = (saturated_connect_state(GuildId, <<"s-0">>, 0, 1))#{
- session_connect_queue => queue:new(),
- session_connect_pending => #{},
- sessions => #{}
- },
- State1 = lists:foldl(
- fun(N, Acc) ->
- SessionId = integer_to_binary(N),
- guild_connect_async:enqueue_session_connect_async(
- GuildId,
- 0,
- connect_request(SessionId, N),
- #{},
- maps:remove(session_connect_max_queue, Acc)
- )
- end,
- State0,
- lists:seq(1, 3000)
- ),
- ?assertEqual(3000, queue:len(maps:get(session_connect_queue, State1))),
- ?assertEqual(3000, map_size(maps:get(session_connect_pending, State1))),
- receive
- {guild_connect_result, GuildId, _, {error, overloaded}} ->
- ?assert(false, connect_dropped)
- after 0 ->
- ok
- end.
-
-queued_connects_spread_over_batched_workers_test() ->
- ok = flush_batches(),
- GuildId = 42,
- Requests = [connect_request(integer_to_binary(N), N) || N <- lists:seq(1, 20)],
- State0 = #{
- id => GuildId,
- sessions => #{},
- session_connect_queue => queue:from_list([
- #{guild_id => GuildId, attempt => 0, request => R, reply_via_pid => undefined}
- || R <- Requests
- ]),
- session_connect_pending => #{},
- session_connect_inflight => 0,
- data => #{},
- member_count => 0,
- voice_states => #{},
- member_list_engine => undefined,
- virtual_channel_access => #{}
- },
- State1 = guild_connect_async:maybe_start_session_connect_workers(State0),
- WorkerRefs = maps:get(session_connect_worker_refs, State1),
- ?assertEqual(8, maps:get(session_connect_inflight, State1)),
- ?assertEqual(8, map_size(WorkerRefs)),
- ?assertEqual(0, queue:len(maps:get(session_connect_queue, State1))),
- Batches = [receive_batch() || _ <- lists:seq(1, 8)],
- ?assertEqual(
- lists:sort([maps:get(session_id, R) || R <- Requests]),
- lists:sort([SessionId || Batch <- Batches, {SessionId, 0, _, _} <- Batch])
- ),
- cleanup_worker_refs(WorkerRefs).
-
-pending_entry(SessionId, UserId) ->
- #{
- session_id => SessionId,
- user_id => UserId,
- pid => self(),
- mref => make_ref(),
- pending_connect => true,
- active_guilds => sets:new()
- }.
-
-receive_batch() ->
- receive
- {'$gen_cast', {session_connect_worker_batch_done, Results}} -> Results
- after 5000 ->
- ?assert(false, connect_batch_not_received)
- end.
-
-flush_batches() ->
- receive
- {'$gen_cast', {session_connect_worker_batch_done, _Results}} -> flush_batches()
- after 100 ->
- ok
- end.
-
-flush_connect_results() ->
- receive
- {guild_connect_result, _GuildId, _Attempt, _Reply} = Msg ->
- [Msg | flush_connect_results()]
- after 0 ->
- []
- end.
-
-finalize_state(SessionId, UserId, Attempt, PendingConnect, Counts, Connected, PresenceSubs) ->
- Existing = #{
- session_id => SessionId,
- user_id => UserId,
- pid => self(),
- mref => make_ref(),
- pending_connect => PendingConnect,
- active_guilds => sets:new()
- },
- #{
- id => 42,
- sessions => #{SessionId => Existing},
- session_connect_pending => #{SessionId => Attempt},
- session_connect_inflight => 1,
- session_connect_queue => queue:new(),
- user_session_counts => Counts,
- connected_user_ids => Connected,
- presence_subscriptions => PresenceSubs,
- member_presence => #{}
- }.
-
-saturated_connect_state(GuildId, SessionId, Attempt, MaxQueue) ->
- PendingSession = #{
- session_id => SessionId,
- user_id => 10,
- pid => self(),
- mref => make_ref(),
- pending_connect => true,
- active_guilds => sets:new()
- },
- #{
- id => GuildId,
- sessions => #{SessionId => PendingSession},
- session_connect_pending => #{SessionId => Attempt},
- session_connect_queue => queue:from_list([
- #{
- guild_id => GuildId,
- attempt => Attempt,
- request => connect_request(SessionId, 10),
- reply_via_pid => undefined
- }
- ]),
- session_connect_inflight => 8,
- session_connect_max_queue => MaxQueue,
- user_session_counts => #{},
- connected_user_ids => sets:new(),
- presence_subscriptions => #{},
- member_presence => #{}
- }.
-
-connect_request(SessionId, UserId) ->
- #{
- session_id => SessionId,
- user_id => UserId,
- session_pid => self(),
- bot => false,
- is_staff => false,
- active_guilds => sets:new()
- }.
-
-queued_session_ids(Items) ->
- [maps:get(session_id, maps:get(request, Item, #{}), undefined) || Item <- Items].
-
-cleanup_worker_refs(WorkerRefs) ->
- maps:foreach(
- fun(Ref, _Value) ->
- receive
- {'DOWN', Ref, process, _Pid, _Reason} -> ok
- after 1000 ->
- ?assert(false, async_connect_worker_did_not_exit)
- end
- end,
- WorkerRefs
- ).
-
-finalize_computed(SessionId, UserId) ->
- #{
- request => #{session_id => SessionId, user_id => UserId, session_pid => self()},
- user_roles => [],
- viewable_channels => #{},
- should_mark_guild_synced => false,
- initial_last_message_ids => #{},
- initial_channel_versions => #{}
- }.
-
-finalize_session(SessionId, UserId, Attempt, State) ->
- guild_connect_async:finalize_session_connect_async(
- SessionId,
- Attempt,
- {ok, #{}},
- finalize_computed(SessionId, UserId),
- State
- ).
-
-flush_connect_result() ->
- receive
- {guild_connect_result, _GuildId, _Attempt, _Reply} -> ok
- after 0 ->
- ok
- end.
diff --git a/fluxer_gateway/test/guild_data_index_members_tests.erl b/fluxer_gateway/test/guild_data_index_members_tests.erl
deleted file mode 100644
index 157bc86db..000000000
--- a/fluxer_gateway/test/guild_data_index_members_tests.erl
+++ /dev/null
@@ -1,98 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_data_index_members_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-member_map_edge_cases_test() ->
- ?assertEqual(#{}, guild_data_index_members:member_map(invalid_guild_data())),
- ?assertEqual(#{}, guild_data_index_members:member_map(#{<<"members">> => <<"invalid">>})),
- ?assertEqual(
- #{},
- guild_data_index_members:member_map(#{<<"members">> => [#{<<"nick">> => <<"orphan">>}]})
- ).
-
-member_map_duplicate_user_ids_last_wins_test() ->
- Data = #{
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => <<"1">>}, <<"nick">> => <<"first">>},
- #{<<"user">> => #{<<"id">> => <<"1">>}, <<"nick">> => <<"second">>}
- ]
- },
- MemberMap = guild_data_index_members:member_map(Data),
- ?assertEqual(<<"second">>, maps:get(<<"nick">>, maps:get(1, MemberMap))).
-
-member_map_rejects_malformed_snowflake_ids_test() ->
- Data = #{
- <<"members">> => #{
- <<"001">> => #{<<"user">> => #{<<"id">> => <<"001">>}},
- <<"2">> => #{<<"user">> => #{<<"id">> => <<"02">>}},
- <<"bad">> => #{<<"user">> => #{<<"id">> => <<"3">>}}
- }
- },
- ?assertEqual(
- #{3 => #{<<"user">> => #{<<"id">> => 3}}}, guild_data_index_members:member_map(Data)
- ).
-
-member_list_uses_cache_consistently_test() ->
- Base = guild_data_index_members:put_member_map(
- #{
- 5 => #{<<"user">> => #{<<"id">> => <<"5">>}},
- 1 => #{<<"user">> => #{<<"id">> => <<"1">>}}
- },
- #{<<"members">> => #{}}
- ),
- ?assert(maps:is_key(members_sorted_ids, Base)),
- ?assertEqual([1, 5], [member_id(M) || M <- guild_data_index_members:member_list(Base)]),
- Added = guild_data_index_members:put_member(
- #{<<"user">> => #{<<"id">> => <<"3">>}}, Base
- ),
- ?assertNot(maps:is_key(members_sorted_ids, Added)),
- ?assertEqual([1, 3, 5], [member_id(M) || M <- guild_data_index_members:member_list(Added)]),
- Removed = guild_data_index_members:remove_member(1, Added),
- ?assertEqual([3, 5], [member_id(M) || M <- guild_data_index_members:member_list(Removed)]).
-
-member_id(Member) ->
- maps:get(<<"id">>, maps:get(<<"user">>, Member)).
-
-member_role_index_test() ->
- ?assertEqual(#{}, guild_data_index_members:member_role_index(invalid_guild_data())),
- Data = #{
- <<"members">> => #{
- 1 => #{<<"user">> => #{<<"id">> => <<"1">>}, <<"roles">> => [<<"10">>, <<"11">>]},
- 2 => #{<<"user">> => #{<<"id">> => <<"2">>}, <<"roles">> => [<<"11">>]}
- }
- },
- Index = guild_data_index_members:member_role_index(Data),
- ?assertEqual(#{1 => true}, maps:get(10, Index)),
- ?assertEqual(#{1 => true, 2 => true}, maps:get(11, Index)),
- ?assertEqual(
- #{},
- guild_data_index_members:member_role_index(#{
- <<"members">> => #{
- 1 => #{<<"user">> => #{<<"id">> => <<"1">>}}
- }
- })
- ).
-
-role_index_sync_test() ->
- Data0 = #{
- <<"members">> => #{
- 3 => #{<<"user">> => #{<<"id">> => <<"3">>}, <<"roles">> => [<<"20">>]}
- }
- },
- Data1 = guild_data_index_members:put_member(
- #{<<"user">> => #{<<"id">> => <<"3">>}, <<"roles">> => [<<"30">>]}, Data0
- ),
- ?assertEqual(
- undefined, maps:get(20, guild_data_index_members:member_role_index(Data1), undefined)
- ),
- ?assertEqual(#{3 => true}, maps:get(30, guild_data_index_members:member_role_index(Data1))),
- Data2 = guild_data_index_members:remove_member(3, Data1),
- ?assertEqual(
- undefined, maps:get(30, guild_data_index_members:member_role_index(Data2), undefined)
- ).
-
-invalid_guild_data() ->
- eqwalizer:dynamic_cast(not_a_map).
diff --git a/fluxer_gateway/test/guild_data_normalize_tests.erl b/fluxer_gateway/test/guild_data_normalize_tests.erl
deleted file mode 100644
index d62f29f46..000000000
--- a/fluxer_gateway/test/guild_data_normalize_tests.erl
+++ /dev/null
@@ -1,212 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_data_normalize_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-snowflake_uses_fluxer_response_shape_test() ->
- ?assertEqual(123, snowflake_id:parse(<<"123">>)),
- ?assertEqual(123, snowflake_id:parse(123)),
- ?assertError({invalid_snowflake, <<"0">>}, snowflake_id:parse(<<"0">>)),
- ?assertError({invalid_snowflake, 0}, snowflake_id:parse(0)),
- ?assertError({invalid_snowflake, <<"001">>}, snowflake_id:parse(<<"001">>)),
- ?assertError({invalid_snowflake, <<"+1">>}, snowflake_id:parse(<<"+1">>)),
- ?assertError({invalid_snowflake, <<"-1">>}, snowflake_id:parse(<<"-1">>)),
- ?assertError({invalid_snowflake, null}, snowflake_id:parse(null)).
-
-permission_accepts_unsigned_decimal_strings_test() ->
- ?assertEqual(0, bitset:parse(<<"0">>)),
- ?assertEqual(1, bitset:parse(<<"001">>)),
- ?assertEqual(42, bitset:parse(42)),
- ?assertError({invalid_bitset, <<"+1">>}, bitset:parse(<<"+1">>)),
- ?assertError({invalid_bitset, <<"-1">>}, bitset:parse(<<"-1">>)).
-
-member_role_ids_are_integer_keyed_in_memory_test() ->
- Member = normalized_member(#{
- <<"user">> => #{<<"id">> => <<"42">>},
- <<"roles">> => [<<"10">>, 20]
- }),
- ?assertEqual(42, maps:get(<<"id">>, maps:get(<<"user">>, Member))),
- ?assertEqual([10, 20], maps:get(<<"roles">>, Member)).
-
-member_role_ids_reject_invalid_snowflakes_test() ->
- ?assertError(
- {invalid_snowflake, <<"001">>},
- normalized_member(#{<<"user">> => #{<<"id">> => <<"42">>}, <<"roles">> => [<<"001">>]})
- ).
-
-role_permissions_are_integer_in_memory_test() ->
- Role = normalized_role(#{
- <<"id">> => <<"55">>,
- <<"permissions">> => <<"1024">>
- }),
- ?assertEqual(55, maps:get(<<"id">>, Role)),
- ?assertEqual(1024, maps:get(<<"permissions">>, Role)).
-
-int_fields_follow_fluxer_non_negative_int32_schema_test() ->
- Guild = #{
- <<"id">> => <<"10">>,
- <<"owner_id">> => <<"20">>,
- <<"member_count">> => <<"0">>,
- <<"online_count">> => <<"-1">>,
- <<"banner_width">> => -1
- },
- Normalized = maps:get(<<"guild">>, normalized_guild_data(#{<<"guild">> => Guild})),
- ?assertEqual(0, maps:get(<<"member_count">>, Normalized)),
- ?assertNot(maps:is_key(<<"online_count">>, Normalized)),
- ?assertNot(maps:is_key(<<"banner_width">>, Normalized)).
-
-guild_normalizes_only_fluxer_response_snowflakes_test() ->
- Guild = #{
- <<"id">> => <<"10">>,
- <<"owner_id">> => <<"20">>,
- <<"system_channel_id">> => null,
- <<"rules_channel_id">> => <<"30">>,
- <<"permissions">> => <<"8">>
- },
- ?assertEqual(
- #{
- <<"id">> => 10,
- <<"owner_id">> => 20,
- <<"system_channel_id">> => null,
- <<"rules_channel_id">> => 30,
- <<"permissions">> => 8
- },
- maps:get(<<"guild">>, normalized_guild_data(#{<<"guild">> => Guild}))
- ).
-
-guild_rejects_invalid_snowflake_fields_test() ->
- Guild = #{
- <<"id">> => <<"10">>,
- <<"owner_id">> => <<"20">>,
- <<"afk_channel_id">> => <<"invalid">>
- },
- ?assertError(
- {invalid_snowflake, <<"invalid">>}, normalized_guild_data(#{<<"guild">> => Guild})
- ).
-
-channel_normalizes_required_optional_and_nullable_ids_test() ->
- Channel = normalized_channel(#{
- <<"id">> => <<"100">>,
- <<"guild_id">> => null,
- <<"owner_id">> => null,
- <<"parent_id">> => <<"200">>,
- <<"last_message_id">> => <<"300">>
- }),
- ?assertEqual(100, maps:get(<<"id">>, Channel)),
- ?assertNot(maps:is_key(<<"guild_id">>, Channel)),
- ?assertEqual(null, maps:get(<<"owner_id">>, Channel)),
- ?assertEqual(200, maps:get(<<"parent_id">>, Channel)),
- ?assertEqual(300, maps:get(<<"last_message_id">>, Channel)).
-
-channel_rejects_invalid_nullable_snowflake_test() ->
- ?assertError(
- {invalid_snowflake, <<"001">>},
- normalized_channel(#{<<"id">> => <<"100">>, <<"last_message_id">> => <<"001">>})
- ).
-
-channel_rejects_invalid_permission_overwrites_test() ->
- ?assertError(
- {invalid_snowflake, <<"011">>},
- normalized_channel(#{
- <<"id">> => <<"100">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => <<"011">>,
- <<"type">> => 0,
- <<"allow">> => <<"1">>,
- <<"deny">> => <<"0">>
- }
- ]
- })
- ),
- ?assertError(
- {invalid_bitset, <<"bad">>},
- normalized_channel(#{
- <<"id">> => <<"100">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => <<"12">>,
- <<"type">> => 0,
- <<"allow">> => <<"bad">>,
- <<"deny">> => <<"0">>
- }
- ]
- })
- ).
-
-channel_filters_non_permission_overwrite_schema_test() ->
- Channel = normalized_channel(#{
- <<"id">> => <<"100">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => <<"10">>,
- <<"type">> => 0,
- <<"allow">> => <<"1">>,
- <<"deny">> => <<"0">>
- },
- #{<<"type">> => 0, <<"allow">> => <<"1">>, <<"deny">> => <<"0">>},
- #{<<"id">> => <<"13">>, <<"type">> => 0, <<"allow">> => <<"1">>},
- #{<<"id">> => <<"14">>, <<"type">> => 0, <<"deny">> => <<"0">>},
- #{
- <<"id">> => <<"15">>,
- <<"type">> => 2,
- <<"allow">> => <<"1">>,
- <<"deny">> => <<"0">>
- }
- ]
- }),
- ?assertEqual(
- [
- #{<<"id">> => 10, <<"type">> => 0, <<"allow">> => 1, <<"deny">> => 0}
- ],
- maps:get(<<"permission_overwrites">>, Channel)
- ).
-
-channel_overwrites_keep_only_fluxer_schema_fields_test() ->
- Channel = normalized_channel(#{
- <<"id">> => <<"100">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => <<"10">>,
- <<"type">> => 1,
- <<"allow">> => <<"2048">>,
- <<"deny">> => <<"0">>,
- <<"extra">> => <<"drop">>
- }
- ]
- }),
- ?assertEqual(
- [
- #{<<"id">> => 10, <<"type">> => 1, <<"allow">> => 2048, <<"deny">> => 0}
- ],
- maps:get(<<"permission_overwrites">>, Channel)
- ).
-
-nicks_are_integer_keyed_in_memory_test() ->
- Channel = normalized_channel(#{
- <<"id">> => <<"100">>,
- <<"nicks">> => #{<<"10">> => <<"Ada">>}
- }),
- ?assertEqual(#{10 => <<"Ada">>}, maps:get(<<"nicks">>, Channel)).
-
-nicks_reject_invalid_snowflake_keys_test() ->
- ?assertError(
- {invalid_snowflake, <<"bad">>},
- normalized_channel(#{
- <<"id">> => <<"100">>, <<"nicks">> => #{<<"bad">> => <<"ignored">>}
- })
- ).
-
-normalized_member(Member) ->
- #{} = guild_data_normalize:member(Member).
-
-normalized_role(Role) ->
- #{} = guild_data_normalize:role(Role).
-
-normalized_guild_data(Data) ->
- #{} = guild_data_normalize:guild_data(Data).
-
-normalized_channel(Channel) ->
- #{} = guild_data_normalize:channel(Channel).
diff --git a/fluxer_gateway/test/guild_data_tests.erl b/fluxer_gateway/test/guild_data_tests.erl
deleted file mode 100644
index 8fd2c78e1..000000000
--- a/fluxer_gateway/test/guild_data_tests.erl
+++ /dev/null
@@ -1,658 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_data_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-read_model_preserves_query_results_test() ->
- State = read_model_state(),
- try
- ok = guild_read_model:put_state(State),
- lists:foreach(
- fun({Tag, Request, Handler}) ->
- {reply, Expected, _} = Handler(Request, State),
- ?assertEqual({ok, Expected}, guild_read_model:query(100, {Tag, Request}))
- end,
- [
- {get_guild_data, #{user_id => 200}, fun guild_data:get_guild_data/2},
- {get_guild_data, #{user_id => 999}, fun guild_data:get_guild_data/2},
- {get_guild_data, #{user_id => null}, fun guild_data:get_guild_data/2},
- {get_guild_auth_context, #{user_id => 200, channel_id => 500},
- fun guild_data:get_auth_context/2},
- {get_guild_auth_context, #{user_id => 999, channel_id => null},
- fun guild_data:get_auth_context/2},
- {get_guild_member, #{user_id => 200},
- fun guild_data_members:get_guild_member/2},
- {get_guild_member, #{user_id => 999},
- fun guild_data_members:get_guild_member/2},
- {has_member, #{user_id => 200}, fun guild_data_members:has_member/2}
- ]
- )
- after
- cleanup_read_model(State)
- end.
-
-read_model_resolves_thread_channels_test() ->
- State0 = read_model_state(),
- Store = guild_thread_store:new(),
- ok = guild_thread_store:put_thread(Store, #{
- <<"id">> => <<"600">>, <<"parent_id">> => <<"500">>, <<"type">> => 11
- }),
- #{data := Data} = State0,
- State = State0#{
- data => Data#{thread_gate => #{active => true, version => 1}, thread_store => Store}
- },
- Request = #{user_id => 200, channel_id => 600},
- try
- ok = guild_read_model:put_state(State),
- {reply, Expected, _} = guild_data:get_auth_context(Request, State),
- ?assertMatch(
- #{auth_context := #{<<"parent_channel">> := #{<<"id">> := 500}}}, Expected
- ),
- ?assertEqual(
- {ok, Expected}, guild_read_model:query(100, {get_guild_auth_context, Request})
- )
- after
- cleanup_read_model(State),
- guild_thread_store:destroy(Store)
- end.
-
-read_model_uses_live_member_rows_without_copying_members_test() ->
- State = read_model_state(),
- #{data := #{members_ets := Tab}} = State,
- try
- ok = guild_read_model:put_state(State),
- [{100, _, #{data := SnapshotData}}] = ets:lookup(guild_read_model, 100),
- ?assertEqual(#{}, maps:get(<<"members">>, SnapshotData)),
- [{200, Member}] = ets:lookup(Tab, 200),
- Updated = Member#{
- <<"nick">> => <<"new nickname">>, <<"communication_disabled_until">> => null
- },
- ets:insert(Tab, {200, Updated}),
- ?assertEqual(
- {ok, #{success => true, member_data => Updated}},
- guild_read_model:query(100, {get_guild_member, #{user_id => 200}})
- ),
- ets:delete(Tab, 200),
- ?assertEqual(
- {ok, #{has_member => false}},
- guild_read_model:query(100, {has_member, #{user_id => 200}})
- ),
- ?assertMatch(
- {ok, #{guild_data := null}},
- guild_read_model:query(100, {get_guild_data, #{user_id => 200}})
- )
- after
- cleanup_read_model(State)
- end.
-
-read_model_observes_role_and_collection_changes_test() ->
- State = read_model_state(),
- try
- ok = guild_read_model:put_state(State),
- Data = maps:get(data, State),
- UpdatedData = guild_data_index:normalize_map(Data#{
- <<"roles">> => [#{<<"id">> => 100, <<"permissions">> => 0}],
- <<"emojis">> => [#{<<"id">> => 700, <<"name">> => <<"new">>}]
- }),
- Updated = State#{data => UpdatedData},
- ok = guild_read_model:update(State, Updated),
- {reply, Expected, _} = guild_data:get_guild_data(#{user_id => 200}, Updated),
- ?assertEqual(
- {ok, Expected}, guild_read_model:query(100, {get_guild_data, #{user_id => 200}})
- ),
- #{guild_data := GuildData} = Expected,
- ?assertEqual([], maps:get(<<"channels">>, GuildData))
- after
- cleanup_read_model(State)
- end.
-
-read_model_observes_last_message_and_pin_advances_test() ->
- State = read_model_state(),
- try
- ok = guild_read_model:put_state(State),
- Data = maps:get(data, State),
- Advanced = guild_state_channels:handle_message_create(
- #{<<"channel_id">> => <<"500">>, <<"id">> => <<"900">>}, Data
- ),
- Pinned = guild_state_channels:handle_channel_pins_update(
- #{
- <<"channel_id">> => <<"500">>,
- <<"last_pin_timestamp">> => <<"2026-10-02T00:00:00Z">>
- },
- Advanced
- ),
- Updated = State#{data => Pinned},
- ok = guild_read_model:update(State, Updated),
- {reply, Expected, _} = guild_data:get_guild_data(#{user_id => 200}, Updated),
- ?assertEqual(
- {ok, Expected}, guild_read_model:query(100, {get_guild_data, #{user_id => 200}})
- ),
- #{guild_data := #{<<"channels">> := Channels}} = Expected,
- [Channel] = [C || C <- Channels, maps:get(<<"id">>, C) =:= 500],
- ?assertEqual(900, maps:get(<<"last_message_id">>, Channel)),
- ?assertEqual(<<"2026-10-02T00:00:00Z">>, maps:get(<<"last_pin_timestamp">>, Channel))
- after
- cleanup_read_model(State)
- end.
-
-read_model_survives_blocked_owner_and_rejects_dead_tables_test() ->
- State = read_model_state(),
- Self = self(),
- Owner = spawn(fun() ->
- ok = guild_read_model:put_state(State),
- Self ! published,
- receive
- stop -> ok
- end
- end),
- try
- receive
- published -> ok
- after 1000 -> error(publish_timeout)
- end,
- ?assertMatch(
- {ok, #{auth_context := #{}}},
- guild_read_model:query(
- 100, {get_guild_auth_context, #{user_id => 200, channel_id => 500}}
- )
- ),
- ?assertEqual({message_queue_len, 0}, process_info(Owner, message_queue_len)),
- ets:delete(maps:get(members_ets, maps:get(data, State))),
- ?assertEqual(miss, guild_read_model:query(100, {has_member, #{user_id => 200}}))
- after
- Owner ! stop,
- cleanup_read_model(State)
- end.
-
-read_model_state() ->
- State = test_state(),
- Data = guild_data_index:normalize_map(maps:get(data, State)),
- Members = guild_data_index_members:member_map(Data),
- Tab = ets:new(read_model_members, [set, public]),
- ets:insert(Tab, maps:to_list(Members)),
- State#{member_count => map_size(Members), data => Data#{members_ets => Tab}}.
-
-cleanup_read_model(#{data := Data} = State) ->
- guild_read_model:delete(100),
- catch ets:delete(maps:get(members_ets, Data)),
- ets:delete(maps:get(member_presence, State)).
-
-get_guild_data_membership_gate_test() ->
- State = test_state(),
- {reply, Reply1, _} = guild_data:get_guild_data(#{user_id => 999}, State),
- ?assertEqual(null, maps:get(guild_data, Reply1)),
- ?assertEqual(<<"forbidden">>, maps:get(error_reason, Reply1)),
- {reply, Reply2, _} = guild_data:get_guild_data(#{user_id => 200}, State),
- Guild = maps:get(guild_data, Reply2),
- ?assertEqual(<<"Fluxer">>, maps:get(<<"name">>, Guild)),
- Roles = maps:get(<<"roles">>, Guild, []),
- ?assertMatch([_ | _], Roles).
-
-get_auth_context_membership_gate_test() ->
- State = test_state(),
- {reply, Reply1, _} = guild_data:get_auth_context(
- #{user_id => 999, channel_id => null}, State
- ),
- ?assertEqual(null, maps:get(auth_context, Reply1)),
- ?assertEqual(<<"forbidden">>, maps:get(error_reason, Reply1)),
- {reply, Reply2, _} = guild_data:get_auth_context(
- #{user_id => 200, channel_id => null}, State
- ),
- Context = maps:get(auth_context, Reply2),
- Guild = maps:get(<<"guild">>, Context),
- ?assertEqual(<<"Fluxer">>, maps:get(<<"name">>, Guild)),
- ?assertMatch([_ | _], maps:get(<<"roles">>, Guild, [])),
- ?assertEqual(null, maps:get(<<"parent_channel">>, Context)).
-
-get_auth_context_omits_collections_test() ->
- State = test_state(),
- {reply, Reply, _} = guild_data:get_auth_context(
- #{user_id => 200, channel_id => null}, State
- ),
- Guild = maps:get(<<"guild">>, maps:get(auth_context, Reply)),
- ?assertNot(maps:is_key(<<"channels">>, Guild)),
- ?assertNot(maps:is_key(<<"emojis">>, Guild)),
- ?assertNot(maps:is_key(<<"stickers">>, Guild)).
-
-get_auth_context_resolves_requested_channel_test() ->
- State = test_state(),
- {reply, Reply, _} = guild_data:get_auth_context(
- #{user_id => 200, channel_id => 500}, State
- ),
- Parent = maps:get(<<"parent_channel">>, maps:get(auth_context, Reply)),
- ?assertEqual(500, maps:get(<<"id">>, Parent)),
- ?assertEqual(0, maps:get(<<"type">>, Parent)).
-
-get_auth_context_unknown_channel_is_null_test() ->
- State = test_state(),
- {reply, Reply, _} = guild_data:get_auth_context(
- #{user_id => 200, channel_id => 999}, State
- ),
- ?assertEqual(null, maps:get(<<"parent_channel">>, maps:get(auth_context, Reply))).
-
-get_auth_context_null_user_skips_membership_test() ->
- State = test_state(),
- {reply, Reply, _} = guild_data:get_auth_context(
- #{user_id => null, channel_id => null}, State
- ),
- Guild = maps:get(<<"guild">>, maps:get(auth_context, Reply)),
- ?assertEqual(<<"Fluxer">>, maps:get(<<"name">>, Guild)).
-
-get_auth_context_matches_get_data_scalars_test() ->
- State = test_state(),
- {reply, DataReply, _} = guild_data:get_guild_data(#{user_id => 200}, State),
- {reply, ContextReply, _} = guild_data:get_auth_context(
- #{user_id => 200, channel_id => null}, State
- ),
- Full = maps:get(guild_data, DataReply),
- Lean = maps:get(<<"guild">>, maps:get(auth_context, ContextReply)),
- Collections = [<<"channels">>, <<"emojis">>, <<"stickers">>],
- Expected = maps:without(Collections, Full),
- ?assertEqual(Expected, Lean).
-
-get_auth_context_is_reachable_through_the_query_handler_test() ->
- State = test_state(),
- Request = {get_guild_auth_context, #{user_id => 200, channel_id => 500}},
- {reply, #{auth_context := #{<<"parent_channel">> := #{<<"id">> := ParentChannelId}}}, _} =
- guild_query_handler:handle_call(Request, {self(), make_ref()}, State),
- ?assertEqual(500, ParentChannelId).
-
-get_guild_state_filters_channels_test() ->
- State = test_state(),
- GuildState = guild_data:get_guild_state(200, State),
- Channels = maps:get(<<"channels">>, GuildState),
- ?assert(lists:any(fun(Chan) -> maps:get(<<"id">>, Chan) =:= 500 end, Channels)),
- ?assertEqual(<<"2024-01-01T00:00:00Z">>, maps:get(<<"joined_at">>, GuildState)).
-
-has_own_member(UserId, GuildState) ->
- Bin = integer_to_binary(UserId),
- lists:any(
- fun(M) -> maps:get(<<"id">>, maps:get(<<"user">>, M, #{}), undefined) =:= Bin end,
- maps:get(<<"members">>, GuildState, [])
- ).
-
-get_guild_state_non_member_returns_partial_guild_create_test() ->
- State = test_state(),
- MemberView = guild_data:get_guild_state(200, State),
- NonMemberView = guild_data:get_guild_state(999, State),
- ?assert(has_own_member(200, MemberView)),
- ?assertMatch([_ | _], maps:get(<<"channels">>, MemberView, [])),
- ?assertNot(has_own_member(999, NonMemberView)),
- ?assertEqual([], maps:get(<<"channels">>, NonMemberView, [])),
- ?assertEqual(false, maps:get(<<"unavailable">>, NonMemberView, false)),
- {reply, Reply, _} = guild_data:get_guild_data(#{user_id => 999}, State),
- ?assertEqual(<<"forbidden">>, maps:get(error_reason, Reply)).
-
-find_everyone_viewable_text_channel_test() ->
- State = test_state(),
- Data = guild_data_index:ensure_data_map(State),
- Channels = maps:get(<<"channels">>, Data),
- ChannelId = guild_data_channels:find_everyone_viewable_text_channel(Channels, State),
- ?assertEqual(500, ChannelId).
-
-find_everyone_viewable_text_channel_uses_category_order_test() ->
- GuildId = 100,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- },
- Channels = [
- #{
- <<"id">> => <<"10">>,
- <<"type">> => 4,
- <<"position">> => 1,
- <<"permission_overwrites">> => []
- },
- #{
- <<"id">> => <<"20">>,
- <<"type">> => 4,
- <<"position">> => 2,
- <<"permission_overwrites">> => []
- },
- #{
- <<"id">> => <<"21">>,
- <<"type">> => 0,
- <<"parent_id">> => <<"20">>,
- <<"position">> => 3,
- <<"permission_overwrites">> => []
- },
- #{
- <<"id">> => <<"11">>,
- <<"type">> => 0,
- <<"parent_id">> => <<"10">>,
- <<"position">> => 50,
- <<"permission_overwrites">> => []
- }
- ],
- ChannelId = guild_data_channels:find_everyone_viewable_text_channel(Channels, State),
- ?assertEqual(11, ChannelId).
-
-find_everyone_viewable_text_channel_prefers_root_before_categories_test() ->
- GuildId = 100,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- },
- Channels = [
- #{
- <<"id">> => <<"10">>,
- <<"type">> => 4,
- <<"position">> => 1,
- <<"permission_overwrites">> => []
- },
- #{
- <<"id">> => <<"11">>,
- <<"type">> => 0,
- <<"parent_id">> => <<"10">>,
- <<"position">> => 2,
- <<"permission_overwrites">> => []
- },
- #{
- <<"id">> => <<"9">>,
- <<"type">> => 0,
- <<"position">> => 50,
- <<"permission_overwrites">> => []
- }
- ],
- ChannelId = guild_data_channels:find_everyone_viewable_text_channel(Channels, State),
- ?assertEqual(9, ChannelId).
-
-find_everyone_viewable_text_channel_skips_invalid_channel_id_test() ->
- GuildId = 100,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- },
- Channels = [
- #{
- <<"id">> => <<"001">>,
- <<"type">> => 0,
- <<"position">> => 1,
- <<"permission_overwrites">> => []
- },
- #{
- <<"id">> => <<"12">>,
- <<"type">> => 0,
- <<"position">> => 2,
- <<"permission_overwrites">> => []
- }
- ],
- ChannelId = guild_data_channels:find_everyone_viewable_text_channel(Channels, State),
- ?assertEqual(12, ChannelId).
-
-find_everyone_viewable_text_channel_ignores_user_overwrite_for_guild_id_test() ->
- GuildId = 100,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- },
- Channels = [
- #{
- <<"id">> => <<"12">>,
- <<"type">> => 0,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"type">> => 1,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- ],
- ChannelId = guild_data_channels:find_everyone_viewable_text_channel(Channels, State),
- ?assertEqual(12, ChannelId).
-
-find_everyone_viewable_text_channel_accepts_voice_when_no_text_channel_test() ->
- GuildId = 100,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- },
- Channels = [
- #{<<"id">> => <<"501">>, <<"type">> => 2, <<"permission_overwrites">> => []}
- ],
- ChannelId = guild_data_channels:find_everyone_viewable_text_channel(Channels, State),
- ?assertEqual(501, ChannelId).
-
-find_everyone_viewable_text_channel_skips_link_channel_test() ->
- GuildId = 100,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- },
- Channels = [
- #{<<"id">> => <<"998">>, <<"type">> => 998, <<"permission_overwrites">> => []}
- ],
- ChannelId = guild_data_channels:find_everyone_viewable_text_channel(Channels, State),
- ?assertEqual(null, ChannelId).
-
-find_everyone_viewable_text_channel_accepts_announcement_channel_test() ->
- GuildId = 100,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- },
- Channels = [
- #{
- <<"id">> => <<"501">>,
- <<"type">> => 2,
- <<"position">> => 0,
- <<"permission_overwrites">> => []
- },
- #{
- <<"id">> => <<"502">>,
- <<"type">> => 5,
- <<"position">> => 1,
- <<"permission_overwrites">> => []
- }
- ],
- ChannelId = guild_data_channels:find_everyone_viewable_text_channel(Channels, State),
- ?assertEqual(502, ChannelId).
-
-search_guild_members_limits_prefix_matches_without_paginating_all_test() ->
- State = #{
- data => #{
- <<"members">> => [
- member(1, <<"Alice">>),
- member(2, <<"Alicia">>),
- member(3, <<"Bob">>)
- ]
- }
- },
- {reply, Reply, _State} = guild_data_members:search_guild_members(
- #{query => <<"ali">>, limit => 1}, State
- ),
- Members = maps:get(members, Reply),
- ?assertEqual(1, length(Members)),
- ?assertEqual(3, maps:get(total, Reply)),
- ?assert(
- lists:all(
- fun(Member) ->
- guild_request_members_search:member_matches_normalized_query(Member, <<"ali">>)
- end,
- Members
- )
- ).
-
-search_guild_members_matches_username_of_nicknamed_member_test() ->
- Nicknamed = (member(1, <<"jiralite">>))#{<<"nick">> => <<"Specsaver engineer">>},
- State = #{data => #{<<"members">> => [Nicknamed, member(2, <<"Bob">>)]}},
- {reply, Reply, _State} = guild_data_members:search_guild_members(
- #{query => <<"jiralite">>, limit => 25}, State
- ),
- ?assertEqual(
- [1],
- [guild_request_members_search:extract_user_id(M) || M <- maps:get(members, Reply)]
- ).
-
-get_guild_state_includes_parent_category_when_child_channel_is_visible_test() ->
- GuildId = 50,
- UserId = 300,
- RoleId = 77,
- CategoryId = 600,
- ChannelId = 601,
- ViewPerm = constants:view_channel_permission(),
- State = parent_category_visible_state(
- GuildId, UserId, RoleId, CategoryId, ChannelId, ViewPerm
- ),
- GuildState = guild_data:get_guild_state(UserId, State),
- Channels = maps:get(<<"channels">>, GuildState),
- ChannelIds = guild_state_channel_ids(Channels),
- ?assertEqual([CategoryId, ChannelId], ChannelIds).
-
-parent_category_visible_state(GuildId, UserId, RoleId, CategoryId, ChannelId, ViewPerm) ->
- #{
- id => GuildId,
- member_presence => ets:new(test_member_presence, [set, public]),
- data => #{
- <<"guild">> => #{<<"name">> => <<"Test Guild">>},
- <<"roles">> => [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => <<"0">>},
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"channels">> => [
- parent_category_channel(CategoryId, RoleId, ViewPerm),
- child_visible_channel(ChannelId, CategoryId, RoleId, ViewPerm)
- ],
- <<"members">> => [
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [integer_to_binary(RoleId)],
- <<"joined_at">> => <<"2024-01-01T00:00:00Z">>
- }
- ],
- <<"emojis">> => [],
- <<"stickers">> => []
- }
- }.
-
-parent_category_channel(CategoryId, RoleId, ViewPerm) ->
- #{
- <<"id">> => integer_to_binary(CategoryId),
- <<"type">> => 4,
- <<"permission_overwrites">> => [
- role_overwrite(RoleId, <<"0">>, integer_to_binary(ViewPerm))
- ]
- }.
-
-child_visible_channel(ChannelId, CategoryId, RoleId, ViewPerm) ->
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"type">> => 0,
- <<"parent_id">> => integer_to_binary(CategoryId),
- <<"permission_overwrites">> => [
- role_overwrite(RoleId, integer_to_binary(ViewPerm), <<"0">>)
- ]
- }.
-
-role_overwrite(RoleId, Allow, Deny) ->
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"type">> => 0,
- <<"allow">> => Allow,
- <<"deny">> => Deny
- }.
-
-guild_state_channel_ids(Channels) ->
- lists:sort([snowflake_id:parse(maps:get(<<"id">>, C)) || C <- Channels]).
-
-member(UserId, Username) ->
- #{
- <<"user">> => #{
- <<"id">> => integer_to_binary(UserId),
- <<"username">> => Username
- },
- <<"roles">> => []
- }.
-
-test_state() ->
- GuildId = 100,
- ViewPerm = constants:view_channel_permission(),
- #{
- id => GuildId,
- member_presence => ets:new(test_member_presence, [set, public]),
- data => #{
- <<"guild">> => #{<<"name">> => <<"Fluxer">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"channels">> => [
- #{<<"id">> => <<"500">>, <<"type">> => 0, <<"permission_overwrites">> => []},
- #{<<"id">> => <<"501">>, <<"type">> => 2, <<"permission_overwrites">> => []}
- ],
- <<"members">> => [
- #{
- <<"user">> => #{<<"id">> => <<"200">>},
- <<"roles">> => [integer_to_binary(GuildId)],
- <<"joined_at">> => <<"2024-01-01T00:00:00Z">>
- }
- ],
- <<"emojis">> => [],
- <<"stickers">> => []
- }
- }.
diff --git a/fluxer_gateway/test/guild_data_wire_tests.erl b/fluxer_gateway/test/guild_data_wire_tests.erl
deleted file mode 100644
index 0a08b3eaa..000000000
--- a/fluxer_gateway/test/guild_data_wire_tests.erl
+++ /dev/null
@@ -1,279 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_data_wire_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-payload_strips_non_schema_channel_recipient_ids_test() ->
- Payload = payload(#{
- <<"id">> => 100,
- <<"recipient_ids">> => [10, 20],
- <<"recipients">> => [
- #{<<"id">> => 10, <<"username">> => <<"ada">>},
- #{<<"id">> => 20, <<"username">> => <<"grace">>}
- ]
- }),
- ?assertNot(maps:is_key(<<"recipient_ids">>, Payload)),
- ?assertEqual(
- [
- #{<<"id">> => <<"10">>, <<"username">> => <<"ada">>},
- #{<<"id">> => <<"20">>, <<"username">> => <<"grace">>}
- ],
- maps:get(<<"recipients">>, Payload)
- ).
-
-payload_strips_gateway_internal_indexes_and_caches_test() ->
- Payload = payload(#{
- <<"id">> => 100,
- <<"role_index">> => #{10 => #{}},
- <<"channel_index">> => #{20 => #{}},
- <<"member_role_index">> => #{30 => #{}},
- role_perms_cache => #{10 => 1},
- overwrite_perms_cache => #{20 => [{10, 0, 1, 0}]}
- }),
- ?assertEqual(<<"100">>, maps:get(<<"id">>, Payload)),
- ?assertNot(maps:is_key(<<"role_index">>, Payload)),
- ?assertNot(maps:is_key(<<"channel_index">>, Payload)),
- ?assertNot(maps:is_key(<<"member_role_index">>, Payload)),
- ?assertNot(maps:is_key(<<"role_perms_cache">>, Payload)),
- ?assertNot(maps:is_key(<<"overwrite_perms_cache">>, Payload)).
-
-payload_stringifies_schema_ids_and_permissions_test() ->
- Payload = payload(#{
- <<"id">> => 100,
- <<"guild_id">> => 200,
- <<"owner_id">> => null,
- <<"roles">> => [300, <<"400">>],
- <<"permissions">> => 1024,
- <<"permission_overwrites">> => [
- #{<<"id">> => 500, <<"type">> => 0, <<"allow">> => 1, <<"deny">> => 0}
- ],
- <<"nicks">> => #{10 => <<"Ada">>}
- }),
- ?assertEqual(<<"100">>, maps:get(<<"id">>, Payload)),
- ?assertEqual(<<"200">>, maps:get(<<"guild_id">>, Payload)),
- ?assertEqual(null, maps:get(<<"owner_id">>, Payload)),
- ?assertEqual([<<"300">>, <<"400">>], maps:get(<<"roles">>, Payload)),
- ?assertEqual(<<"1024">>, maps:get(<<"permissions">>, Payload)),
- ?assertEqual(
- [
- #{
- <<"id">> => <<"500">>,
- <<"type">> => 0,
- <<"allow">> => <<"1">>,
- <<"deny">> => <<"0">>
- }
- ],
- maps:get(<<"permission_overwrites">>, Payload)
- ),
- ?assertEqual(#{<<"10">> => <<"Ada">>}, maps:get(<<"nicks">>, Payload)).
-
-payload_stringifies_rpc_atom_keys_and_schema_id_lists_test() ->
- Payload = payload(#{
- channel_id => 100,
- message_id => 200,
- user_id => 300,
- session_id => <<"session-a">>,
- connection_id => <<"conn-a">>,
- ringing => [400, <<"500">>],
- recipients => [600, <<"700">>],
- mention_roles => [800],
- pinned_dms => [1000],
- permissions => 8
- }),
- ?assertEqual(<<"100">>, maps:get(<<"channel_id">>, Payload)),
- ?assertEqual(<<"200">>, maps:get(<<"message_id">>, Payload)),
- ?assertEqual(<<"300">>, maps:get(<<"user_id">>, Payload)),
- ?assertEqual(<<"session-a">>, maps:get(<<"session_id">>, Payload)),
- ?assertEqual(<<"conn-a">>, maps:get(<<"connection_id">>, Payload)),
- ?assertEqual([<<"400">>, <<"500">>], maps:get(<<"ringing">>, Payload)),
- ?assertEqual([<<"600">>, <<"700">>], maps:get(<<"recipients">>, Payload)),
- ?assertEqual([<<"800">>], maps:get(<<"mention_roles">>, Payload)),
- ?assertEqual([<<"1000">>], maps:get(<<"pinned_dms">>, Payload)),
- ?assertEqual(<<"8">>, maps:get(<<"permissions">>, Payload)).
-
-payload_preserves_fluxer_object_lists_and_non_snowflake_ids_test() ->
- Payload = payload(#{
- <<"roles">> => [#{<<"id">> => 10, <<"name">> => <<"admin">>}],
- <<"mentions">> => [#{<<"id">> => 20, <<"username">> => <<"ada">>}],
- <<"recipients">> => [#{<<"id">> => 30, <<"username">> => <<"grace">>}],
- <<"guild_folders">> => [#{<<"id">> => -1, <<"guild_ids">> => [40]}],
- <<"rtc_regions">> => [#{<<"id">> => <<"us-east">>, <<"name">> => <<"East">>}]
- }),
- ?assertEqual(
- [#{<<"id">> => <<"10">>, <<"name">> => <<"admin">>}], maps:get(<<"roles">>, Payload)
- ),
- ?assertEqual(
- [#{<<"id">> => <<"20">>, <<"username">> => <<"ada">>}],
- maps:get(<<"mentions">>, Payload)
- ),
- ?assertEqual(
- [#{<<"id">> => <<"30">>, <<"username">> => <<"grace">>}],
- maps:get(<<"recipients">>, Payload)
- ),
- ?assertEqual(
- [#{<<"id">> => -1, <<"guild_ids">> => [<<"40">>]}],
- maps:get(<<"guild_folders">>, Payload)
- ),
- ?assertEqual(
- [#{<<"id">> => <<"us-east">>, <<"name">> => <<"East">>}],
- maps:get(<<"rtc_regions">>, Payload)
- ).
-
-payload_stringifies_snowflake_record_list_values_test() ->
- Payload = payload(#{100 => [200, <<"300">>]}),
- ?assertEqual([<<"200">>, <<"300">>], maps:get(<<"100">>, Payload)).
-
-payload_normalizes_presence_event_test() ->
- ?assertEqual(presence_event_wire(), payload(presence_event_data())).
-
-payload_normalizes_message_event_test() ->
- ?assertEqual(message_event_wire(), payload(message_event_data())).
-
-presence_event_data() ->
- #{
- <<"user">> => #{
- <<"id">> => 100000000000000001,
- <<"username">> => <<"ada">>,
- <<"global_name">> => <<"Ada">>,
- <<"avatar">> => null,
- <<"public_flags">> => 64
- },
- <<"guild_id">> => 200000000000000002,
- <<"status">> => <<"online">>,
- <<"client_status">> => #{<<"desktop">> => <<"online">>, <<"mobile">> => <<"idle">>},
- <<"activities">> => [
- #{
- <<"name">> => <<"Fluxer">>,
- <<"type">> => 0,
- <<"application_id">> => 300000000000000003,
- <<"session_id">> => <<"3ab8fa1c">>,
- <<"created_at">> => 1756500000000,
- <<"party">> => #{<<"id">> => <<"party-a">>, <<"size">> => [2, 5]}
- }
- ],
- <<"roles">> => [400000000000000004, <<"500000000000000005">>],
- <<"nick">> => <<"Ada">>,
- <<"premium_since">> => null,
- <<"member_role_index">> => #{400000000000000004 => true},
- <<"role_perms_cache">> => #{400000000000000004 => 8},
- 600000000000000006 => [700000000000000007, <<"800000000000000008">>],
- presence_seq => 42
- }.
-
-presence_event_wire() ->
- #{
- <<"user">> => #{
- <<"id">> => <<"100000000000000001">>,
- <<"username">> => <<"ada">>,
- <<"global_name">> => <<"Ada">>,
- <<"avatar">> => null,
- <<"public_flags">> => 64
- },
- <<"guild_id">> => <<"200000000000000002">>,
- <<"status">> => <<"online">>,
- <<"client_status">> => #{<<"desktop">> => <<"online">>, <<"mobile">> => <<"idle">>},
- <<"activities">> => [
- #{
- <<"name">> => <<"Fluxer">>,
- <<"type">> => 0,
- <<"application_id">> => <<"300000000000000003">>,
- <<"session_id">> => <<"3ab8fa1c">>,
- <<"created_at">> => 1756500000000,
- <<"party">> => #{<<"id">> => <<"party-a">>, <<"size">> => [2, 5]}
- }
- ],
- <<"roles">> => [<<"400000000000000004">>, <<"500000000000000005">>],
- <<"nick">> => <<"Ada">>,
- <<"premium_since">> => null,
- <<"600000000000000006">> => [<<"700000000000000007">>, <<"800000000000000008">>],
- <<"presence_seq">> => 42
- }.
-
-message_event_data() ->
- #{
- <<"id">> => 900000000000000009,
- <<"channel_id">> => 100000000000000010,
- <<"guild_id">> => 200000000000000002,
- <<"author">> => #{
- <<"id">> => 100000000000000001,
- <<"username">> => <<"ada">>,
- <<"avatar">> => <<"a1b2c3">>,
- <<"bot">> => false
- },
- <<"member">> => #{
- <<"roles">> => [400000000000000004],
- <<"joined_at">> => <<"2026-08-01T00:00:00Z">>,
- <<"deaf">> => false
- },
- <<"content">> => <<"hey">>,
- <<"timestamp">> => <<"2026-08-30T12:00:00Z">>,
- <<"edited_timestamp">> => null,
- <<"mention_everyone">> => false,
- <<"mentions">> => [#{<<"id">> => 100000000000000001, <<"username">> => <<"ada">>}],
- <<"mention_roles">> => [400000000000000004],
- <<"attachments">> => [
- #{
- <<"id">> => 110000000000000011,
- <<"filename">> => <<"shot.png">>,
- <<"size">> => 20480
- }
- ],
- <<"embeds">> => [],
- <<"type">> => 0,
- <<"nonce">> => <<"120000000000000012">>,
- <<"session_id">> => <<"3ab8fa1c">>,
- <<"target_id">> => <<"ref-a">>,
- <<"permissions">> => 137411140374081,
- <<"recipient_ids">> => [100000000000000001],
- <<"nicks">> => #{
- <<"130000000000000013">> => <<"Ada">>, 170000000000000017 => <<"Grace">>
- }
- }.
-
-message_event_wire() ->
- #{
- <<"id">> => <<"900000000000000009">>,
- <<"channel_id">> => <<"100000000000000010">>,
- <<"guild_id">> => <<"200000000000000002">>,
- <<"author">> => #{
- <<"id">> => <<"100000000000000001">>,
- <<"username">> => <<"ada">>,
- <<"avatar">> => <<"a1b2c3">>,
- <<"bot">> => false
- },
- <<"member">> => #{
- <<"roles">> => [<<"400000000000000004">>],
- <<"joined_at">> => <<"2026-08-01T00:00:00Z">>,
- <<"deaf">> => false
- },
- <<"content">> => <<"hey">>,
- <<"timestamp">> => <<"2026-08-30T12:00:00Z">>,
- <<"edited_timestamp">> => null,
- <<"mention_everyone">> => false,
- <<"mentions">> => [
- #{<<"id">> => <<"100000000000000001">>, <<"username">> => <<"ada">>}
- ],
- <<"mention_roles">> => [<<"400000000000000004">>],
- <<"attachments">> => [
- #{
- <<"id">> => <<"110000000000000011">>,
- <<"filename">> => <<"shot.png">>,
- <<"size">> => 20480
- }
- ],
- <<"embeds">> => [],
- <<"type">> => 0,
- <<"nonce">> => <<"120000000000000012">>,
- <<"session_id">> => <<"3ab8fa1c">>,
- <<"target_id">> => <<"ref-a">>,
- <<"permissions">> => <<"137411140374081">>,
- <<"nicks">> => #{
- <<"130000000000000013">> => <<"Ada">>,
- <<"170000000000000017">> => <<"Grace">>
- }
- }.
-
-payload(Data) ->
- #{} = guild_data_wire:payload(Data).
diff --git a/fluxer_gateway/test/guild_dispatch_send_ordering_tests.erl b/fluxer_gateway/test/guild_dispatch_send_ordering_tests.erl
deleted file mode 100644
index 552e59bd3..000000000
--- a/fluxer_gateway/test/guild_dispatch_send_ordering_tests.erl
+++ /dev/null
@@ -1,132 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_dispatch_send_ordering_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(SATURATION_FILL, 600).
--define(RECEIVE_TIMEOUT_MS, 600).
--define(BROADCASTER_IDLE_TIMEOUT_MS, 30000).
-
-saturated_broadcaster_keeps_dispatch_ordered_test_() ->
- {timeout, 30, fun saturated_broadcaster_keeps_dispatch_ordered/0}.
-
-healthy_broadcaster_keeps_dispatch_ordered_test_() ->
- {timeout, 30, fun healthy_broadcaster_keeps_dispatch_ordered/0}.
-
-absent_broadcaster_dispatches_through_relay_test_() ->
- {timeout, 30, fun absent_broadcaster_dispatches_through_relay/0}.
-
-saturated_broadcaster_keeps_dispatch_ordered() ->
- Broadcaster = spawn_idle_broadcaster(),
- try
- saturate(Broadcaster),
- ?assertEqual(false, cast_event(Broadcaster)),
- QueueBefore = queue_len(Broadcaster),
- flush_dispatches(),
- dispatch(Broadcaster),
- ?assertNot(received_relay_dispatch()),
- ?assertEqual(QueueBefore + 1, queue_len(Broadcaster))
- after
- stop_broadcaster(Broadcaster)
- end.
-
-healthy_broadcaster_keeps_dispatch_ordered() ->
- Broadcaster = spawn_draining_broadcaster(),
- try
- flush_dispatches(),
- dispatch(Broadcaster),
- ?assertNot(received_relay_dispatch())
- after
- stop_broadcaster(Broadcaster)
- end.
-
-absent_broadcaster_dispatches_through_relay() ->
- flush_dispatches(),
- dispatch(undefined),
- ?assert(received_relay_dispatch()).
-
-dispatch(Broadcaster) ->
- _ = guild_dispatch_send:dispatch_to_sessions(
- [session()], message_update, event_data(), state(Broadcaster)
- ),
- ok.
-
-cast_event(Broadcaster) ->
- guild_broadcaster:cast_event(Broadcaster, message_update, {pre_encoded, <<"{}">>}, [self()]).
-
-saturate(Broadcaster) ->
- lists:foreach(
- fun(N) -> Broadcaster ! {filler, N} end,
- lists:seq(1, ?SATURATION_FILL)
- ).
-
-spawn_idle_broadcaster() ->
- spawn(fun idle_broadcaster/0).
-
-idle_broadcaster() ->
- receive
- stop -> ok
- after ?BROADCASTER_IDLE_TIMEOUT_MS -> ok
- end.
-
-spawn_draining_broadcaster() ->
- spawn(fun draining_broadcaster/0).
-
-draining_broadcaster() ->
- receive
- stop -> ok;
- _Other -> draining_broadcaster()
- after ?BROADCASTER_IDLE_TIMEOUT_MS -> ok
- end.
-
-stop_broadcaster(Broadcaster) ->
- Broadcaster ! stop,
- ok.
-
-queue_len(Pid) ->
- {message_queue_len, Len} = erlang:process_info(Pid, message_queue_len),
- Len.
-
-received_relay_dispatch() ->
- receive
- {'$gen_cast', {dispatch, message_update, _Payload}} -> true
- after ?RECEIVE_TIMEOUT_MS -> false
- end.
-
-flush_dispatches() ->
- receive
- {'$gen_cast', _Cast} -> flush_dispatches()
- after 0 -> ok
- end.
-
-state(undefined) ->
- base_state();
-state(Broadcaster) ->
- (base_state())#{broadcaster_pid => Broadcaster}.
-
-base_state() ->
- #{
- id => 42,
- member_count => 100,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [],
- <<"members">> => [],
- <<"channels">> => []
- }
- }.
-
-session() ->
- {<<"ordered">>, #{
- session_id => <<"ordered">>,
- user_id => 10,
- pid => self(),
- active_guilds => sets:new(),
- bot => false,
- viewable_channels => #{100 => true}
- }}.
-
-event_data() ->
- #{<<"guild_id">> => <<"42">>, <<"id">> => <<"7">>, <<"channel_id">> => <<"100">>}.
diff --git a/fluxer_gateway/test/guild_dm_partners_tests.erl b/fluxer_gateway/test/guild_dm_partners_tests.erl
deleted file mode 100644
index 9298c7b68..000000000
--- a/fluxer_gateway/test/guild_dm_partners_tests.erl
+++ /dev/null
@@ -1,212 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_dm_partners_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(GUILD_ID, 42).
--define(VIEWER_ROLE, 1000).
--define(OTHER_ROLE, 2000).
--define(SESSION, <<"session-10">>).
--define(FLAG, dm_presence_mutual_context).
-
-registration_notifies_mutual_partners_test() ->
- with_flag(true, fun() ->
- State = register_partners(state(), [20, 30, 777]),
- ?assertEqual({dm_partner_mutual, ?GUILD_ID, [20]}, receive_mutual()),
- ?assert(maps:is_key(?SESSION, maps:get(dm_partners, State)))
- end).
-
-unknown_session_is_not_registered_test() ->
- with_flag(true, fun() ->
- {noreply, State} = guild_dm_partners:handle_cast(
- {update_dm_partners, <<"missing">>, [20]}, state()
- ),
- ?assertEqual(#{}, maps:get(dm_partners, State, #{})),
- ?assertEqual(none, receive_mutual())
- end).
-
-disabled_flag_does_not_register_test() ->
- with_flag(false, fun() ->
- State = register_partners(state(), [20]),
- ?assertEqual(#{}, maps:get(dm_partners, State, #{})),
- ?assertEqual(none, receive_mutual())
- end).
-
-unchanged_eligibility_is_not_sent_again_test() ->
- with_flag(true, fun() ->
- State = register_partners(state(), [20]),
- {dm_partner_mutual, _, [20]} = receive_mutual(),
- _ = register_partners(State, [20, 777]),
- ?assertEqual(none, receive_mutual())
- end).
-
-partner_leaving_the_guild_withdraws_the_partner_test() ->
- with_flag(true, fun() ->
- Before = register_partners(state(), [20]),
- {dm_partner_mutual, _, [20]} = receive_mutual(),
- After = without_member(20, Before),
- _ = guild_dm_partners:maybe_reevaluate(
- guild_member_remove, #{<<"user">> => #{<<"id">> => <<"20">>}}, Before, After
- ),
- ?assertEqual({dm_partner_mutual, ?GUILD_ID, []}, receive_mutual())
- end).
-
-guild_wide_event_without_visibility_change_does_nothing_test() ->
- with_flag(true, fun() ->
- Before = register_partners(state(), [20]),
- {dm_partner_mutual, _, [20]} = receive_mutual(),
- Renamed = with_channels(
- [
- (channel(500, viewer_overwrites()))#{<<"name">> => <<"renamed">>},
- channel(600, other_overwrites())
- ],
- Before
- ),
- _ = guild_dm_partners:maybe_reevaluate(channel_update, #{}, Before, Renamed),
- ?assertEqual(none, receive_mutual())
- end).
-
-guild_wide_visibility_change_reevaluates_test() ->
- with_flag(true, fun() ->
- Before = register_partners(state(), [30]),
- ?assertEqual(none, receive_mutual()),
- Opened = with_channels(
- [
- channel(500, viewer_overwrites() ++ [overwrite(?OTHER_ROLE, 0)]),
- channel(600, other_overwrites())
- ],
- Before
- ),
- _ = guild_dm_partners:maybe_reevaluate(channel_update, #{}, Before, Opened),
- ?assertEqual({dm_partner_mutual, ?GUILD_ID, [30]}, receive_mutual())
- end).
-
-partner_role_change_after_registration_reevaluates_test() ->
- with_flag(true, fun() ->
- Before = register_partners(state(), [30]),
- ?assertEqual(none, receive_mutual()),
- After = with_member(member(30, [?VIEWER_ROLE]), Before),
- _ = guild_dm_partners:maybe_reevaluate(
- guild_member_update, #{<<"user">> => #{<<"id">> => <<"30">>}}, Before, After
- ),
- ?assertEqual({dm_partner_mutual, ?GUILD_ID, [30]}, receive_mutual())
- end).
-
-disconnected_sessions_are_dropped_on_reevaluation_test() ->
- with_flag(true, fun() ->
- Before = register_partners(state(), [20]),
- {dm_partner_mutual, _, [20]} = receive_mutual(),
- Gone = Before#{sessions => #{}},
- After = guild_dm_partners:maybe_reevaluate(guild_role_delete, #{}, Before, Gone#{
- virtual_channel_access => #{1 => sets:new()}
- }),
- ?assertEqual(#{}, maps:get(dm_partners, After))
- end).
-
-register_partners(State, PartnerIds) ->
- {noreply, NewState} = guild_dm_partners:handle_cast(
- {update_dm_partners, ?SESSION, PartnerIds}, State
- ),
- NewState.
-
-state() ->
- Base = #{
- id => ?GUILD_ID,
- virtual_channel_access => #{},
- data => data(
- [channel(500, viewer_overwrites()), channel(600, other_overwrites())], members()
- )
- },
- Viewable = guild_sessions:build_viewable_channel_map(
- guild_visibility_channels:get_user_viewable_channels(10, Base)
- ),
- Base#{
- sessions => #{
- ?SESSION => #{user_id => 10, pid => self(), viewable_channels => Viewable}
- }
- }.
-
-data(Channels, Members) ->
- #{
- <<"guild">> => #{<<"owner_id">> => <<"7">>},
- <<"roles">> => [role(?GUILD_ID), role(?VIEWER_ROLE), role(?OTHER_ROLE)],
- <<"members">> => Members,
- <<"channels">> => Channels,
- <<"channel_index">> => guild_data_index:build_id_index(Channels)
- }.
-
-members() ->
- maps:from_list(
- [{7, member(7, [])}] ++
- [{Id, member(Id, [?VIEWER_ROLE])} || Id <- [10, 20]] ++
- [{30, member(30, [?OTHER_ROLE])}]
- ).
-
-without_member(UserId, #{data := Data} = State) ->
- State#{data => Data#{<<"members">> => maps:remove(UserId, maps:get(<<"members">>, Data))}}.
-
-with_member(Member, #{data := Data} = State) ->
- #{<<"user">> := #{<<"id">> := RawId}} = Member,
- Members = maps:get(<<"members">>, Data),
- State#{data => Data#{<<"members">> => Members#{binary_to_integer(RawId) => Member}}}.
-
-with_channels(Channels, #{data := Data} = State) ->
- State#{
- data => Data#{
- <<"channels">> => Channels,
- <<"channel_index">> => guild_data_index:build_id_index(Channels)
- }
- }.
-
-role(RoleId) ->
- #{<<"id">> => integer_to_binary(RoleId), <<"permissions">> => <<"0">>}.
-
-member(UserId, RoleIds) ->
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [integer_to_binary(RoleId) || RoleId <- RoleIds]
- }.
-
-viewer_overwrites() ->
- [overwrite(?VIEWER_ROLE, 0)].
-
-other_overwrites() ->
- [overwrite(?OTHER_ROLE, 0)].
-
-overwrite(TargetId, Type) ->
- #{
- <<"id">> => integer_to_binary(TargetId),
- <<"type">> => Type,
- <<"allow">> => integer_to_binary(constants:view_channel_permission()),
- <<"deny">> => <<"0">>
- }.
-
-channel(ChannelId, Overwrites) ->
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"type">> => 0,
- <<"permission_overwrites">> => Overwrites
- }.
-
-receive_mutual() ->
- receive
- {dm_partner_mutual, _, _} = Msg -> Msg
- after 100 ->
- none
- end.
-
-with_flag(Value, Fun) ->
- Previous = application:get_env(fluxer_gateway, ?FLAG),
- application:set_env(fluxer_gateway, ?FLAG, Value),
- try
- Fun()
- after
- restore_flag(Previous)
- end.
-
-restore_flag(undefined) ->
- application:unset_env(fluxer_gateway, ?FLAG);
-restore_flag({ok, Value}) ->
- application:set_env(fluxer_gateway, ?FLAG, Value).
diff --git a/fluxer_gateway/test/guild_handoff_freeze_tests.erl b/fluxer_gateway/test/guild_handoff_freeze_tests.erl
deleted file mode 100644
index 702a405a4..000000000
--- a/fluxer_gateway/test/guild_handoff_freeze_tests.erl
+++ /dev/null
@@ -1,523 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_handoff_freeze_tests).
--behaviour(gen_server).
-
--include_lib("eunit/include/eunit.hrl").
-
--export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2]).
-
--define(GUILD_ID, 4242).
--define(SHARD_TABLE, guild_manager_shard_table).
--define(SINK, guild_handoff_freeze_tests_sink).
-
-transfer_test_() ->
- {foreach, fun setup/0, fun cleanup/1, [
- instantiate(fun frozen_backlog_reaches_target_and_source_applies_nothing/1),
- instantiate(fun final_window_call_fails_unapplied_and_cast_is_kept/1),
- instantiate(fun route_failure_restores_routes_resumes_source_and_stops_target/1),
- instantiate(fun controller_death_before_start_resumes_source/1),
- instantiate(fun controller_death_after_start_kills_target_and_resumes_source/1),
- instantiate(fun target_death_before_commit_keeps_source/1),
- instantiate(fun sessions_stay_behind_when_not_transferred/1),
- instantiate(fun cast_during_source_terminate_reaches_target/1),
- instantiate(fun monitor_flush_in_source_terminate_loses_no_cast/1),
- instantiate(fun connect_worker_results_stay_with_the_source/1),
- instantiate(fun abort_after_forwarding_reports_the_forwarded_count/1),
- instantiate(fun late_source_stop_keeps_the_committed_target/1),
- instantiate(fun controller_death_after_commit_keeps_the_target/1),
- instantiate(fun lost_guard_aborts_before_other_nodes_route_to_the_target/1),
- instantiate(fun thread_state_survives_the_frozen_export/1),
- instantiate(fun stale_thread_sessions_do_not_break_a_sessionless_restore/1)
- ]}.
-
-instantiate(Test) ->
- fun(Ctx) -> {timeout, 30, fun() -> Test(Ctx) end} end.
-
-frozen_backlog_reaches_target_and_source_applies_nothing(#{src := Src, src_shard := SrcShard}) ->
- Test = self(),
- BeforeStart = fun() ->
- gen_server:cast(Src, {append, b}),
- spawn(fun() -> Test ! {call_reply, gen_server:call(Src, {append_call, c}, 30000)} end),
- wait_mailbox(Src, 2)
- end,
- Result = guild_handoff_freeze:transfer(
- ?GUILD_ID, Src, SrcShard, node(), #{before_start => BeforeStart}
- ),
- ?assertMatch({ok, #{new_pid := _}}, Result),
- {ok, #{new_pid := NewPid}} = Result,
- ?assertEqual({call_reply, {ok, NewPid}}, receive_tagged(call_reply)),
- ?assertEqual([{Src, {shutdown, handoff}, [a]}], ets:lookup(?SINK, Src)),
- ?assertEqual([a, b, c], gen_server:call(NewPid, get_log)),
- ?assertEqual(false, is_process_alive(Src)).
-
-final_window_call_fails_unapplied_and_cast_is_kept(#{src := Src, src_shard := SrcShard}) ->
- Test = self(),
- BeforeStart = fun() ->
- gen_server:cast(Src, {append, b}),
- spawn(fun() -> Test ! {call_reply, call_or_exit(Src, {append_call, c})} end),
- wait_mailbox(Src, 2)
- end,
- Opts = #{before_start => BeforeStart, forward_rounds => 0},
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts),
- ?assertMatch({ok, #{final := #{cast := 1, dropped_call := 1}}}, Result),
- {ok, #{new_pid := NewPid}} = Result,
- ?assertMatch({call_reply, {exit, {{shutdown, handoff}, _}}}, receive_tagged(call_reply)),
- ?assertEqual([a, b], gen_server:call(NewPid, get_log)).
-
-route_failure_restores_routes_resumes_source_and_stops_target(#{
- src := Src, src_shard := SrcShard, dst_shard := DstShard
-}) ->
- Test = self(),
- Opts = #{
- before_start => fun() -> gen_server:cast(Src, {append, b}) end,
- after_start => fun(_NewPid) -> {error, route_rejected} end,
- on_abort => fun() ->
- Test ! routes_restored,
- ok
- end
- },
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts),
- ?assertMatch({error, #{phase := after_start, reason := route_rejected}}, Result),
- ?assertEqual(routes_restored, receive_tagged(routes_restored)),
- ?assertEqual({error, not_found}, gen_server:call(DstShard, {lookup, ?GUILD_ID})),
- ?assertEqual([a, b], gen_server:call(Src, get_log)),
- ?assertEqual(false, guild_handoff_freeze:is_frozen(Src)).
-
-controller_death_before_start_resumes_source(#{src := Src, src_shard := SrcShard}) ->
- Opts = #{
- before_start => fun() ->
- gen_server:cast(Src, {append, b}),
- exit(self(), kill)
- end
- },
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts),
- ?assertMatch({error, #{phase := crashed, reason := killed}}, Result),
- ?assertEqual([a, b], gen_server:call(Src, get_log, 5000)).
-
-controller_death_after_start_kills_target_and_resumes_source(#{
- src := Src, src_shard := SrcShard, dst_shard := DstShard
-}) ->
- Test = self(),
- Opts = #{
- after_start => fun(NewPid) ->
- Test ! {target, NewPid},
- exit(self(), kill)
- end,
- on_abort => fun() ->
- Test ! routes_restored,
- ok
- end
- },
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts),
- ?assertMatch({error, #{phase := crashed, abort := #{routes := ok, target := ok}}}, Result),
- ?assertEqual(routes_restored, receive_tagged(routes_restored)),
- {target, NewPid} = receive_tagged(target),
- ?assertEqual(ok, wait_dead(NewPid)),
- ?assertEqual({error, not_found}, gen_server:call(DstShard, {lookup, ?GUILD_ID})),
- ?assertEqual([a], gen_server:call(Src, get_log, 5000)).
-
-target_death_before_commit_keeps_source(#{src := Src, src_shard := SrcShard}) ->
- Opts = #{
- after_start => fun(NewPid) ->
- exit(NewPid, kill),
- wait_dead(NewPid)
- end
- },
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts),
- ?assertMatch({error, #{phase := target_died, reason := killed}}, Result),
- ?assertEqual([a], gen_server:call(Src, get_log, 5000)),
- ?assertEqual(false, guild_handoff_freeze:is_frozen(Src)).
-
-sessions_stay_behind_when_not_transferred(#{src := Src, src_shard := SrcShard}) ->
- ok = gen_server:call(Src, {put_session, <<"s1">>, #{pid => self(), user_id => 7}}),
- Opts = #{transfer_sessions => false},
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts),
- ?assertMatch({ok, #{new_pid := _}}, Result),
- {ok, #{new_pid := NewPid}} = Result,
- ?assertEqual(#{}, gen_server:call(NewPid, get_sessions)),
- ?assertEqual([a], gen_server:call(NewPid, get_log)).
-
-cast_during_source_terminate_reaches_target(#{src := Src, src_shard := SrcShard}) ->
- ok = gen_server:call(Src, cast_late_on_terminate),
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), #{}),
- ?assertMatch({ok, #{final := #{cast := 1}}}, Result),
- {ok, #{new_pid := NewPid}} = Result,
- ?assertEqual([a, late], gen_server:call(NewPid, get_log)).
-
-monitor_flush_in_source_terminate_loses_no_cast(#{src := Src, src_shard := SrcShard}) ->
- ok = gen_server:call(Src, flush_down_on_terminate),
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), #{}),
- ?assertMatch({ok, #{final := #{cast := 1}}}, Result),
- {ok, #{new_pid := NewPid}} = Result,
- ?assertEqual([a, late], gen_server:call(NewPid, get_log)).
-
-connect_worker_results_stay_with_the_source(#{src := Src, src_shard := SrcShard}) ->
- BeforeStart = fun() ->
- gen_server:cast(Src, {session_connect_worker_done, <<"s1">>, 1, {ok, #{}}, #{}}),
- gen_server:cast(
- Src, {session_connect_worker_batch_done, [{<<"s1">>, 1, {ok, #{}}, #{}}]}
- ),
- gen_server:cast(Src, {append, b}),
- wait_mailbox(Src, 3)
- end,
- Result = guild_handoff_freeze:transfer(
- ?GUILD_ID, Src, SrcShard, node(), #{before_start => BeforeStart}
- ),
- ?assertMatch({ok, #{new_pid := _}}, Result),
- {ok, #{new_pid := NewPid}} = Result,
- ?assertEqual([a, b], gen_server:call(NewPid, get_log)).
-
-abort_after_forwarding_reports_the_forwarded_count(#{src := Src, src_shard := SrcShard}) ->
- BeforeStart = fun() ->
- gen_server:cast(Src, crash),
- wait_mailbox(Src, 1)
- end,
- Result = guild_handoff_freeze:transfer(
- ?GUILD_ID, Src, SrcShard, node(), #{before_start => BeforeStart}
- ),
- ?assertMatch(
- {error, #{phase := target_died, abort := #{forwarded := 1, thaw := ok}}}, Result
- ).
-
-late_source_stop_keeps_the_committed_target(#{
- src := Src, src_shard := SrcShard, dst_shard := DstShard
-}) ->
- Opts = #{
- stop_timeout => 100,
- after_start => fun(_NewPid) -> hold(SrcShard, 600) end
- },
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts),
- ?assertMatch({ok, #{new_pid := _}}, Result),
- {ok, #{new_pid := NewPid}} = Result,
- ?assertEqual(ok, wait_dead(Src)),
- ?assert(is_process_alive(NewPid)),
- ?assertEqual({ok, NewPid}, gen_server:call(DstShard, {lookup, ?GUILD_ID})),
- ?assertEqual([a], gen_server:call(NewPid, get_log)).
-
-controller_death_after_commit_keeps_the_target(#{
- src := Src, src_shard := SrcShard, dst_shard := DstShard
-}) ->
- Test = self(),
- Opts = #{
- after_start => fun(NewPid) ->
- Test ! {started, self(), NewPid},
- hold(SrcShard, 1000)
- end
- },
- spawn(fun() ->
- Test ! {result, guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts)}
- end),
- {started, Controller, NewPid} = receive_tagged(started),
- ok = wait_mailbox(SrcShard, 1),
- exit(Controller, kill),
- {result, Result} = receive_tagged(result),
- ?assertMatch({error, #{phase := crashed, committed := true}}, Result),
- ?assertEqual(ok, wait_dead(Src)),
- ?assert(is_process_alive(NewPid)),
- ?assertEqual({ok, NewPid}, gen_server:call(DstShard, {lookup, ?GUILD_ID})).
-
-lost_guard_aborts_before_other_nodes_route_to_the_target(#{
- src := Src, src_shard := SrcShard, dst_shard := DstShard
-}) ->
- Test = self(),
- Opts = #{
- before_start => fun() ->
- {monitored_by, Watchers} = process_info(self(), monitored_by),
- [exit(W, kill) || W <- Watchers, W =/= Test],
- ok
- end,
- after_start => fun(_NewPid) ->
- Test ! routed,
- ok
- end
- },
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts),
- ?assertMatch(
- {error, #{
- phase := after_start, reason := {guard_lost, killed}, abort := #{exposed := false}
- }},
- Result
- ),
- ?assertEqual({timeout, routed}, receive_tagged(routed, 200)),
- ?assertEqual({error, not_found}, gen_server:call(DstShard, {lookup, ?GUILD_ID})),
- ?assertEqual(false, guild_handoff_freeze:is_frozen(Src)),
- ?assertEqual([a], gen_server:call(Src, get_log, 5000)).
-
-thread_state_survives_the_frozen_export(#{src := Src, src_shard := SrcShard}) ->
- ok = gen_server:call(Src, {put_session, <<"s1">>, #{pid => self(), user_id => 7}}),
- ok = gen_server:call(Src, install_threads),
- Result = guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), #{}),
- ?assertMatch({ok, #{new_pid := _}}, Result),
- {ok, #{new_pid := NewPid}} = Result,
- ?assertEqual(ok, wait_dead(Src)),
- State = guild_init:init_base_state(gen_server:call(NewPid, get_export)),
- try
- ?assertMatch(#{<<"id">> := 10}, guild_thread_gate:thread(10, State)),
- ?assert(guild_thread_gate:active(State)),
- ?assertEqual([<<"s1">>], maps:keys(maps:get(thread_resend_pending, State))),
- ?assertEqual([<<"s1">>], maps:keys(maps:get(thread_sync_pending, State))),
- ?assertEqual([10], maps:keys(maps:get(thread_list_dirty, State))),
- ?assertEqual(
- thread_member_list_flush, receive_tagged(thread_member_list_flush, 2000)
- )
- after
- guild_thread_store:destroy(guild_thread_gate:store(State))
- end.
-
-stale_thread_sessions_do_not_break_a_sessionless_restore(#{src := Src, src_shard := SrcShard}) ->
- ok = gen_server:call(Src, {put_session, <<"s1">>, #{pid => self(), user_id => 7}}),
- ok = gen_server:call(Src, install_threads),
- Opts = #{transfer_sessions => false},
- {ok, #{new_pid := NewPid}} =
- guild_handoff_freeze:transfer(?GUILD_ID, Src, SrcShard, node(), Opts),
- Export = gen_server:call(NewPid, get_export),
- ?assertEqual(#{}, maps:get(sessions, Export)),
- ?assertEqual([<<"s1">>], maps:get(thread_handoff_resends, Export)),
- State = guild_init:init_base_state(Export),
- try
- ?assertMatch(#{<<"id">> := 10}, guild_thread_gate:thread(10, State)),
- Resent = guild_thread_flip:resend(<<"s1">>, State),
- ?assertNot(maps:is_key(thread_resend_pending, Resent)),
- Synced = guild_thread_subscriptions:handle_tick(<<"s1">>, Resent),
- ?assertNot(maps:is_key(thread_sync_pending, Synced))
- after
- guild_thread_store:destroy(guild_thread_gate:store(State))
- end.
-
-hold(Pid, Ms) ->
- Test = self(),
- spawn(fun() ->
- true = erlang:suspend_process(Pid),
- Test ! {held, Pid},
- timer:sleep(Ms),
- true = erlang:resume_process(Pid)
- end),
- receive
- {held, Pid} -> ok
- end.
-
-export_drops_only_keys_the_importer_rebuilds_test() ->
- Raw = #{
- <<"guild">> => #{<<"id">> => <<"4242">>},
- <<"roles">> => [#{<<"id">> => <<"4242">>, <<"permissions">> => <<"1024">>}],
- <<"channels">> => [#{<<"id">> => <<"77">>, <<"type">> => 0}],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => <<"5">>}, <<"roles">> => []},
- #{<<"user">> => #{<<"id">> => <<"6">>}, <<"roles">> => [<<"4242">>]}
- ]
- },
- Full = guild_data_index:normalize_map(Raw),
- State = #{id => ?GUILD_ID, data => Full#{members_ets => make_ref()}, sessions => #{}},
- Slim = maps:get(data, guild_handoff:export_handoff_state(State)),
- ?assertEqual([], [K || K <- guild_handoff:derived_data_keys(), maps:is_key(K, Slim)]),
- Rebuild = fun(D) ->
- maps:remove(member_list_revision, guild_data_index:normalize_map(D))
- end,
- ?assertEqual(Rebuild(Full), Rebuild(Slim)).
-
-export_keeps_channel_fields_that_only_the_index_holds_test() ->
- Raw = #{
- <<"guild">> => #{<<"id">> => <<"4242">>},
- <<"channels">> => [
- #{<<"id">> => <<"77">>, <<"type">> => 0, <<"last_message_id">> => <<"10">>}
- ]
- },
- Full = guild_state_channels:handle_message_create(
- #{<<"channel_id">> => <<"77">>, <<"id">> => <<"900">>},
- guild_data_index:normalize_map(Raw)
- ),
- State = #{id => ?GUILD_ID, data => Full, sessions => #{}},
- Slim = maps:get(data, guild_handoff:export_handoff_state(State)),
- ?assertMatch({rebuilt, _}, bounded_rebuild(Slim)),
- {rebuilt, Rebuilt} = bounded_rebuild(Slim),
- [Channel] = guild_data_index_channels:channel_list(Rebuilt),
- ?assertEqual(900, maps:get(<<"last_message_id">>, Channel)).
-
-bounded_rebuild(Data) ->
- {Pid, Ref} = spawn_monitor(fun() ->
- process_flag(max_heap_size, #{size => 4000000, kill => true, error_logger => false}),
- exit({rebuilt, guild_data_index:normalize_map(Data)})
- end),
- receive
- {'DOWN', Ref, process, Pid, Reason} -> Reason
- after 10000 ->
- exit(Pid, kill),
- timeout
- end.
-
-setup() ->
- ets:new(?SHARD_TABLE, [named_table, public, set]),
- ets:new(?SINK, [named_table, public, set]),
- {ok, SrcShard} = gen_server:start(?MODULE, shard, []),
- {ok, DstShard} = gen_server:start(?MODULE, shard, []),
- Index = guild_manager_shards:select_shard(?GUILD_ID, 1),
- ets:insert(?SHARD_TABLE, [{shard_count, 1}, {{shard_pid, Index}, DstShard}]),
- {ok, Src} = gen_server:call(
- SrcShard, {start_transferred, ?GUILD_ID, guild_export([a])}
- ),
- #{src => Src, src_shard => SrcShard, dst_shard => DstShard}.
-
-cleanup(#{src_shard := SrcShard, dst_shard := DstShard}) ->
- Guilds = lists:append([gen_server:call(S, all_guilds) || S <- [SrcShard, DstShard]]),
- [exit(G, kill) || G <- Guilds],
- [gen_server:stop(S) || S <- [SrcShard, DstShard]],
- ets:delete(?SHARD_TABLE),
- ets:delete(?SINK),
- flush().
-
-guild_export(Log) ->
- #{
- id => ?GUILD_ID,
- data => #{<<"log">> => Log},
- sessions => #{},
- voice_states => #{}
- }.
-
-init(shard) ->
- {ok, #{role => shard, guilds => #{}}};
-init({guild, Export}) ->
- process_flag(trap_exit, true),
- {ok, Export#{role => guild}}.
-
-handle_call({start_transferred, GuildId, Export}, _From, #{role := shard} = State) ->
- {ok, Pid} = gen_server:start(?MODULE, {guild, Export}, []),
- {reply, {ok, Pid}, put_guild(GuildId, Pid, State)};
-handle_call({stop_guild, GuildId}, From, #{role := shard} = State) ->
- handle_call({stop_guild, GuildId, normal}, From, State);
-handle_call({stop_guild, GuildId, Reason}, _From, #{role := shard, guilds := Guilds} = State) ->
- case maps:get(GuildId, Guilds, undefined) of
- Pid when is_pid(Pid) -> stop_quietly(Pid, Reason);
- undefined -> ok
- end,
- {reply, ok, State#{guilds => maps:remove(GuildId, Guilds)}};
-handle_call({lookup, GuildId}, _From, #{role := shard, guilds := Guilds} = State) ->
- case maps:get(GuildId, Guilds, undefined) of
- Pid when is_pid(Pid) ->
- case is_process_alive(Pid) of
- true -> {reply, {ok, Pid}, State};
- false -> {reply, {error, not_found}, State}
- end;
- undefined ->
- {reply, {error, not_found}, State}
- end;
-handle_call(all_guilds, _From, #{role := shard, guilds := Guilds} = State) ->
- {reply, maps:values(Guilds), State};
-handle_call({get_guild_id}, _From, #{role := guild, id := Id} = State) ->
- {reply, Id, State};
-handle_call({put_session, Id, Session}, _From, #{role := guild, sessions := Sessions} = State) ->
- {reply, ok, State#{sessions => Sessions#{Id => Session}}};
-handle_call(flush_down_on_terminate, _From, #{role := guild} = State) ->
- Helper = spawn(fun() ->
- receive
- stop -> ok
- end
- end),
- {reply, ok, State#{flush_down => {Helper, erlang:monitor(process, Helper)}}};
-handle_call(cast_late_on_terminate, _From, #{role := guild} = State) ->
- {reply, ok, State#{cast_late => true}};
-handle_call(install_threads, _From, #{role := guild, data := Data} = State) ->
- Tab = guild_thread_store:new(),
- ok = guild_thread_store:put_thread(Tab, #{<<"id">> => 10, <<"parent_id">> => 1}),
- {reply, ok, State#{
- data => Data#{thread_store => Tab, thread_gate => #{active => true, version => 1}},
- thread_load => #{status => ready, queue => [], queued => 0, attempt => 0},
- thread_resend_pending => #{<<"s1">> => true},
- thread_sync_pending => #{<<"s1">> => scheduled},
- thread_list_dirty => #{10 => true}
- }};
-handle_call(get_export, _From, #{role := guild} = State) ->
- {reply, maps:remove(role, State), State};
-handle_call(get_sessions, _From, #{role := guild, sessions := Sessions} = State) ->
- {reply, Sessions, State};
-handle_call(get_log, _From, #{role := guild} = State) ->
- {reply, log(State), State};
-handle_call({append_call, Item}, _From, #{role := guild} = State) ->
- {reply, {ok, self()}, append(Item, State)}.
-
-handle_cast({append, Item}, #{role := guild} = State) ->
- {noreply, append(Item, State)};
-handle_cast(crash, #{role := guild} = State) ->
- {stop, crashed, State}.
-
-handle_info({'EXIT', _Pid, Reason}, #{role := guild} = State) ->
- {stop, Reason, State};
-handle_info(_Msg, State) ->
- {noreply, State}.
-
-terminate(Reason, #{role := guild} = State) ->
- ets:insert(?SINK, {self(), Reason, log(State)}),
- case maps:get(cast_late, State, false) of
- true ->
- gen_server:cast(self(), {append, late}),
- timer:sleep(200);
- false ->
- ok
- end,
- case maps:get(flush_down, State, undefined) of
- {Helper, Ref} ->
- exit(Helper, kill),
- timer:sleep(100),
- erlang:demonitor(Ref, [flush]),
- gen_server:cast(self(), {append, late}),
- timer:sleep(200);
- undefined ->
- ok
- end;
-terminate(_Reason, _State) ->
- ok.
-
-put_guild(GuildId, Pid, #{guilds := Guilds} = State) ->
- State#{guilds => Guilds#{GuildId => Pid}}.
-
-log(#{data := Data}) ->
- maps:get(<<"log">>, Data).
-
-append(Item, #{data := Data} = State) ->
- State#{data => Data#{<<"log">> => log(State) ++ [Item]}}.
-
-call_or_exit(Pid, Request) ->
- try
- gen_server:call(Pid, Request, 30000)
- catch
- exit:Reason -> {exit, Reason}
- end.
-
-stop_quietly(Pid, Reason) ->
- try
- gen_server:stop(Pid, Reason, 5000)
- catch
- exit:_ -> ok
- end.
-
-wait_mailbox(Pid, N) ->
- case process_info(Pid, message_queue_len) of
- {message_queue_len, Len} when Len >= N ->
- ok;
- _ ->
- timer:sleep(5),
- wait_mailbox(Pid, N)
- end.
-
-wait_dead(Pid) ->
- Ref = erlang:monitor(process, Pid),
- receive
- {'DOWN', Ref, process, Pid, _} -> ok
- after 5000 -> still_alive
- end.
-
-receive_tagged(Tag) ->
- receive_tagged(Tag, 10000).
-
-receive_tagged(Tag, Timeout) ->
- receive
- Msg when element(1, Msg) =:= Tag -> Msg;
- Tag -> Tag
- after Timeout -> {timeout, Tag}
- end.
-
-flush() ->
- receive
- _ -> flush()
- after 0 -> ok
- end.
diff --git a/fluxer_gateway/test/guild_handoff_tests.erl b/fluxer_gateway/test/guild_handoff_tests.erl
deleted file mode 100644
index 573974000..000000000
--- a/fluxer_gateway/test/guild_handoff_tests.erl
+++ /dev/null
@@ -1,158 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_handoff_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-remonitor_transferred_sessions_replaces_stale_refs_test() ->
- Pid = spawn(fun session_loop/0),
- OldRef = make_ref(),
- State0 = #{
- sessions => #{
- <<"s1">> => #{pid => Pid, mref => OldRef, user_id => 10},
- <<"missing_pid">> => #{user_id => 11},
- <<"bad">> => bad_session
- }
- },
- State1 = guild_handoff:remonitor_transferred_sessions(State0),
- Sessions = maps:get(sessions, State1),
- ?assertEqual(false, maps:is_key(<<"missing_pid">>, Sessions)),
- ?assertEqual(false, maps:is_key(<<"bad">>, Sessions)),
- Session = maps:get(<<"s1">>, Sessions),
- NewRef = maps:get(mref, Session),
- ?assert(is_reference(NewRef)),
- ?assertNotEqual(OldRef, NewRef),
- Pid ! stop,
- receive
- {'DOWN', NewRef, process, Pid, _Reason} -> ok
- after 1000 ->
- ?assert(false)
- end.
-
-restore_transferred_session_state_rebuilds_connected_counts_test() ->
- UserId = 10,
- Sessions = #{
- <<"s1">> => #{pid => self(), user_id => UserId},
- <<"s2">> => #{pid => self(), user_id => UserId, pending_connect => false},
- <<"pending">> => #{pid => self(), user_id => 11, pending_connect => true},
- <<"bad">> => #{user_id => 12},
- <<"reconnecting">> => #{
- pid => self(),
- user_id => 13,
- pending_connect => true,
- owns_connected_tracking => true
- }
- },
- State0 = #{
- sessions => Sessions,
- connected_user_ids => sets:new(),
- user_session_counts => #{},
- presence_subscriptions => #{UserId => 1}
- },
- State1 = guild_handoff:restore_transferred_session_state(State0),
- ?assertEqual(#{UserId => 2, 13 => 1}, maps:get(user_session_counts, State1)),
- Connected = maps:get(connected_user_ids, State1),
- ?assertEqual(true, sets:is_element(UserId, Connected)),
- ?assertEqual(false, sets:is_element(11, Connected)),
- ?assertEqual(true, sets:is_element(13, Connected)),
- ?assertEqual(3, maps:get(UserId, maps:get(presence_subscriptions, State1))).
-
-export_handoff_state_contains_all_required_keys_test() ->
- State = #{
- id => 12345,
- data => #{<<"guild">> => #{<<"id">> => <<"12345">>}},
- sessions => #{
- <<"s1">> => #{pid => self(), user_id => 10, mref => make_ref()}
- },
- voice_states => #{<<"conn1">> => #{<<"user_id">> => 10}},
- virtual_channel_access => #{},
- virtual_channel_access_pending => #{},
- virtual_channel_access_preserve => #{},
- virtual_channel_access_move_pending => #{}
- },
- Exported = guild_handoff:export_handoff_state(State),
- ?assertEqual(ok, guild_handoff:validate_handoff_state(Exported)),
- ?assertEqual(12345, maps:get(id, Exported)),
- ?assert(is_map(maps:get(data, Exported))),
- ?assert(is_map(maps:get(sessions, Exported))),
- ?assert(is_map(maps:get(voice_states, Exported))),
- Session = maps:get(<<"s1">>, maps:get(sessions, Exported)),
- ?assertEqual(false, maps:is_key(mref, Session)).
-
-export_handoff_state_omits_pending_member_list_batch_test() ->
- State = #{
- id => 12345,
- data => #{<<"guild">> => #{<<"id">> => <<"12345">>}},
- sessions => #{},
- voice_states => #{},
- pending_member_list_sync_batch => #{
- timer_ref => make_ref(),
- pending_list_ids => #{<<"500">> => true}
- }
- },
- Exported = guild_handoff:export_handoff_state(State),
- ?assertNot(maps:is_key(pending_member_list_sync_batch, Exported)).
-
-session_loop() ->
- receive
- stop -> ok
- after infinity ->
- ok
- end.
-
-export_handoff_state_replaces_the_thread_store_with_rows_test() ->
- Tab = guild_thread_store:new(),
- ok = guild_thread_store:put_thread(Tab, #{<<"id">> => 10, <<"parent_id">> => 1}),
- try
- State = #{
- id => 12345,
- data => #{thread_store => Tab, thread_gate => #{active => true, version => 1}},
- sessions => #{}
- },
- Data = maps:get(data, guild_handoff:export_handoff_state(State)),
- ?assertNot(maps:is_key(thread_store, Data)),
- ?assertEqual(#{active => true, version => 1}, maps:get(thread_gate, Data)),
- ?assertEqual(guild_thread_store:export(Tab), maps:get(thread_rows, Data)),
- ?assert(is_integer(maps:get(thread_rows_at, Data)))
- after
- guild_thread_store:destroy(Tab)
- end.
-
-init_from_export_queues_a_flip_when_the_gate_disagrees_with_config_test() ->
- Tab = guild_thread_store:new(),
- ok = guild_thread_store:put_thread(Tab, #{<<"id">> => 10, <<"parent_id">> => 1}),
- Key = channel_threads_config,
- Previous = persistent_term:get(Key, undefined),
- try
- Exported = guild_handoff:export_handoff_state(#{
- id => 12345,
- data => #{thread_store => Tab, thread_gate => #{active => true, version => 4}},
- sessions => #{}
- }),
- persistent_term:put(Key, (channel_threads_config:default_config())#{
- enabled => true, config_version => 5
- }),
- _ = guild_init:init_base_state(Exported),
- ?assertEqual([5], drain_flips([])),
- persistent_term:put(Key, (channel_threads_config:default_config())#{
- enabled => true, config_version => 5, enabled_guilds => #{<<"12345">> => true}
- }),
- _ = guild_init:init_base_state(Exported),
- ?assertEqual([], drain_flips([])),
- persistent_term:erase(Key),
- _ = guild_init:init_base_state(Exported),
- ?assertEqual([], drain_flips([]))
- after
- guild_thread_store:destroy(Tab),
- case Previous of
- undefined -> persistent_term:erase(Key);
- _ -> persistent_term:put(Key, Previous)
- end
- end.
-
-drain_flips(Acc) ->
- receive
- {thread_gate_flip, Version} -> drain_flips([Version | Acc])
- after 0 -> lists:reverse(Acc)
- end.
diff --git a/fluxer_gateway/test/guild_manager_cache_tests.erl b/fluxer_gateway/test/guild_manager_cache_tests.erl
deleted file mode 100644
index 593248846..000000000
--- a/fluxer_gateway/test/guild_manager_cache_tests.erl
+++ /dev/null
@@ -1,48 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_manager_cache_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-cleanup_guild_from_cache_deletes_all_matches_test() ->
- guild_manager_cache:ensure_guild_pid_cache(),
- Pid = self(),
- ets:insert(guild_pid_cache, {101, Pid}),
- ets:insert(guild_pid_cache, {102, Pid}),
- ets:insert(guild_pid_cache, {103, spawn(fun() -> ok end)}),
- try
- ok = guild_manager_cache:cleanup_guild_from_cache(Pid),
- ?assertEqual([], ets:lookup(guild_pid_cache, 101)),
- ?assertEqual([], ets:lookup(guild_pid_cache, 102))
- after
- ets:delete(guild_pid_cache, 101),
- ets:delete(guild_pid_cache, 102),
- ets:delete(guild_pid_cache, 103)
- end.
-
-lookup_cached_guild_pid_requires_registration_test() ->
- process_registry:init(),
- guild_manager_cache:ensure_guild_pid_cache(),
- GuildId = 20201,
- GuildPid = spawn(fun() ->
- receive
- stop -> ok
- after infinity ->
- ok
- end
- end),
- timer:sleep(10),
- ets:insert(guild_pid_cache, {GuildId, GuildPid}),
- try
- ?assertEqual(not_found, guild_manager_cache:lookup_cached_guild_pid(GuildId)),
- ?assertEqual([], ets:lookup(guild_pid_cache, GuildId)),
- GuildKey = process_registry:build_process_key(guild, GuildId),
- ets:insert(guild_pid_cache, {GuildId, GuildPid}),
- ets:insert(process_registry_table, {GuildKey, GuildPid}),
- ?assertEqual({ok, GuildPid}, guild_manager_cache:lookup_cached_guild_pid(GuildId)),
- process_registry:registry_unregister(GuildKey)
- after
- ets:delete(guild_pid_cache, GuildId),
- GuildPid ! stop
- end.
diff --git a/fluxer_gateway/test/guild_manager_shard_lifecycle_tests.erl b/fluxer_gateway/test/guild_manager_shard_lifecycle_tests.erl
deleted file mode 100644
index 0fdf3ff10..000000000
--- a/fluxer_gateway/test/guild_manager_shard_lifecycle_tests.erl
+++ /dev/null
@@ -1,92 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_manager_shard_lifecycle_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-start_new_guild_skips_start_when_already_registered_test() ->
- process_registry:init(),
- GuildId = 77777,
- GuildKey = process_registry:build_process_key(guild, GuildId),
- ExistingPid = spawn(fun mock_guild_loop/0),
- ets:insert(process_registry_table, {GuildKey, ExistingPid}),
- try
- State0 = #{guilds => #{}, pending_requests => #{}, shard_index => 0},
- Data = #{<<"guild">> => #{<<"id">> => <<"77777">>, <<"features">> => []}},
- Result = guild_manager_shard_lifecycle:start_new_guild(GuildId, Data, GuildKey, State0),
- ?assertMatch({ok, ExistingPid, _}, Result),
- {ok, RetPid, _NewState} = Result,
- ?assertEqual(ExistingPid, RetPid)
- after
- process_registry:registry_unregister(GuildKey),
- ExistingPid ! stop
- end.
-
-normalize_transferred_guild_state_keeps_only_transferable_fields_test() ->
- GuildId = 99998,
- TransferState = #{
- id => 1,
- data => #{<<"guild">> => #{<<"id">> => <<"99998">>}},
- sessions => #{<<"s1">> => #{pid => self()}},
- voice_states => #{<<"v1">> => #{}},
- virtual_channel_access => #{10 => sets:from_list([20])},
- thread_handoff_resends => [<<"s1">>],
- thread_handoff_syncs => [<<"s2">>],
- thread_handoff_lists => [30],
- thread_resend_pending => #{<<"s1">> => true},
- member_list_engine => make_ref(),
- channel_member_list_engines => #{<<"500">> => make_ref()},
- voice_server_pid => self()
- },
- Normalized = guild_manager_shard_lifecycle:normalize_transferred_guild_state(
- GuildId, TransferState
- ),
- ?assertEqual(GuildId, maps:get(id, Normalized)),
- ?assertEqual(#{<<"guild">> => #{<<"id">> => <<"99998">>}}, maps:get(data, Normalized)),
- ?assertEqual(#{<<"s1">> => #{pid => self()}}, maps:get(sessions, Normalized)),
- ?assertEqual(#{<<"v1">> => #{}}, maps:get(voice_states, Normalized)),
- ?assertNot(maps:is_key(member_list_engine, Normalized)),
- ?assertNot(maps:is_key(channel_member_list_engines, Normalized)),
- ?assertEqual([<<"s1">>], maps:get(thread_handoff_resends, Normalized)),
- ?assertEqual([<<"s2">>], maps:get(thread_handoff_syncs, Normalized)),
- ?assertEqual([30], maps:get(thread_handoff_lists, Normalized)),
- ?assertNot(maps:is_key(thread_resend_pending, Normalized)),
- ?assertNot(maps:is_key(voice_server_pid, Normalized)).
-
-shard_terminate_drains_pending_requests_test() ->
- ReplyRef1 = make_ref(),
- ReplyRef2 = make_ref(),
- State = #{
- guilds => #{111 => loading, 222 => loading},
- pending_requests => #{
- 111 => [{self(), ReplyRef1}],
- 222 => [{self(), ReplyRef2}]
- },
- fetch_workers => #{},
- shard_index => 0
- },
- guild_manager_shard:terminate(shutdown, State),
- receive
- {ReplyRef1, {error, shard_shutdown}} -> ok
- after 100 ->
- ?assert(false)
- end,
- receive
- {ReplyRef2, {error, shard_shutdown}} -> ok
- after 100 ->
- ?assert(false)
- end.
-
-mock_guild_loop() ->
- receive
- {'$gen_call', From, _Msg} ->
- gen_server:reply(From, ok),
- mock_guild_loop();
- stop ->
- ok;
- _Other ->
- mock_guild_loop()
- after infinity ->
- ok
- end.
diff --git a/fluxer_gateway/test/guild_manager_shard_lookup_tests.erl b/fluxer_gateway/test/guild_manager_shard_lookup_tests.erl
deleted file mode 100644
index b936472f7..000000000
--- a/fluxer_gateway/test/guild_manager_shard_lookup_tests.erl
+++ /dev/null
@@ -1,72 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_manager_shard_lookup_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-do_start_or_lookup_loading_deduplicates_requests_test() ->
- GuildId = 4444,
- From1 = {self(), make_ref()},
- From2 = {self(), make_ref()},
- State0 = #{guilds => #{GuildId => loading}, pending_requests => #{}, shard_index => 0},
- {noreply, State1} = guild_manager_shard_lookup:do_start_or_lookup(GuildId, From1, State0),
- Pending1 = maps:get(pending_requests, State1),
- ?assertEqual([From1], maps:get(GuildId, Pending1)),
- {noreply, State2} = guild_manager_shard_lookup:do_start_or_lookup(GuildId, From2, State1),
- Requests = maps:get(GuildId, maps:get(pending_requests, State2)),
- ?assertEqual(2, length(Requests)),
- ?assert(lists:member(From1, Requests)),
- ?assert(lists:member(From2, Requests)).
-
-lookup_or_fetch_rejects_zero_guild_rollout_test() ->
- process_registry:init(),
- OldConfig = gateway_rollout_config:get(),
- persistent_term:put(gateway_rollout_config, OldConfig#{<<"guild_rollout_percentage">> => 0}),
- GuildId = 99999,
- From = {self(), make_ref()},
- State = #{guilds => #{}, pending_requests => #{}, shard_index => 0},
- try
- Result = guild_manager_shard_lookup:lookup_or_fetch(GuildId, From, State),
- ?assertMatch({reply, {error, not_eligible}, _}, Result)
- after
- persistent_term:put(gateway_rollout_config, OldConfig)
- end.
-
-stale_fetch_success_uses_superseding_tracked_guild_test() ->
- GuildId = 7321,
- ReplyRef = make_ref(),
- WorkerRef = make_ref(),
- FetchToken = make_ref(),
- SupersedingPid = spawn(fun() ->
- receive
- stop -> ok
- after infinity ->
- ok
- end
- end),
- timer:sleep(10),
- State0 = #{
- guilds => #{GuildId => {SupersedingPid, make_ref()}},
- pending_requests => #{GuildId => [{self(), ReplyRef}]},
- fetch_workers => #{WorkerRef => {GuildId, self(), FetchToken}},
- shard_index => 0
- },
- try
- {noreply, State1} = guild_manager_shard_lookup:handle_guild_data_fetched(
- GuildId,
- FetchToken,
- {ok, #{<<"guild">> => #{<<"id">> => <<"7321">>, <<"features">> => []}}},
- State0
- ),
- {TrackedPid, _Ref} = maps:get(GuildId, maps:get(guilds, State1)),
- ?assertEqual(SupersedingPid, TrackedPid),
- ?assertEqual(#{}, maps:get(pending_requests, State1)),
- receive
- {ReplyRef, {ok, SupersedingPid}} -> ok
- after 100 ->
- ?assert(false)
- end
- after
- SupersedingPid ! stop
- end.
diff --git a/fluxer_gateway/test/guild_manager_tests.erl b/fluxer_gateway/test/guild_manager_tests.erl
deleted file mode 100644
index dfc2915b0..000000000
--- a/fluxer_gateway/test/guild_manager_tests.erl
+++ /dev/null
@@ -1,116 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_manager_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-handoff_guild_ids_counts_attempts_and_successes_test() ->
- LocalNode = '[email protected]',
- OwnerResolver = fun
- (1) -> LocalNode;
- (2) -> '[email protected]';
- end,
- HandoffFun = fun
- (2, '[email protected]', AccState) -> {true, AccState#{shard_count := 2}};
- (3, '[email protected]', AccState) -> {false, AccState#{shard_count := 3}}
- end,
- {Result, FinalState} = guild_manager_handoff:handoff_guild_ids(
- [1, 2, 3], LocalNode, OwnerResolver, HandoffFun, empty_handoff_state()
- ),
- ?assertEqual(#{attempted => 2, handed_off => 1}, Result),
- ?assertEqual(3, maps:get(shard_count, FinalState)).
-
-handoff_to_topology_keeps_guild_the_router_owns_here_test() ->
- GuildId = 77,
- ShardPid = spawn(fun() -> local_ids_stub_loop([GuildId]) end),
- State = #{shards => #{0 => #{pid => ShardPid, ref => make_ref()}}, shard_count => 1},
- persistent_term:put({gateway_cluster_membership, members}, [node()]),
- persistent_term:put({gateway_cluster_membership, members_by_role}, #{guilds => [node()]}),
- try
- {Result, _State} = guild_manager_handoff:perform_handoff_to_topology(
- ['[email protected]'], State
- ),
- ?assertEqual(#{attempted => 0, handed_off => 0}, Result)
- after
- ShardPid ! stop,
- persistent_term:erase({gateway_cluster_membership, members}),
- persistent_term:erase({gateway_cluster_membership, members_by_role})
- end.
-
-local_ids_stub_loop(GuildIds) ->
- receive
- stop ->
- ok;
- {'$gen_call', From, get_local_guild_ids} ->
- gen_server:reply(From, {ok, GuildIds}),
- local_ids_stub_loop(GuildIds);
- {'$gen_call', From, _Request} ->
- gen_server:reply(From, {error, not_found}),
- local_ids_stub_loop(GuildIds)
- end.
-
-empty_handoff_state() ->
- #{shards => #{}, shard_count => 1}.
-
-cleanup_guild_from_cache_does_not_remove_new_pid_test() ->
- delete_table(guild_pid_cache),
- guild_manager_cache:ensure_guild_pid_cache(),
- try
- OldPid = spawn(fun() -> ok end),
- timer:sleep(10),
- NewPid = spawn(fun() -> timer:sleep(1000) end),
- ets:insert(guild_pid_cache, {42, NewPid}),
- guild_manager_cache:cleanup_guild_from_cache(OldPid),
- [{42, FoundPid}] = ets:lookup(guild_pid_cache, 42),
- ?assertEqual(NewPid, FoundPid)
- after
- delete_table(guild_pid_cache)
- end.
-
-start_or_lookup_does_not_bypass_manager_owner_gate_test_() ->
- {timeout, 10, fun() ->
- delete_table(guild_pid_cache),
- delete_table(guild_manager_shard_table),
- guild_manager_cache:ensure_guild_pid_cache(),
- guild_manager_cache:ensure_shard_table(),
- GuildId = 101,
- GuildPid = spawn(fun() -> timer:sleep(1000) end),
- ShardPid = spawn(fun() -> shard_stub_loop(GuildId, GuildPid) end),
- ets:insert(guild_manager_shard_table, {shard_count, 1}),
- ets:insert(guild_manager_shard_table, {{shard_pid, 0}, ShardPid}),
- try
- ?assertEqual({error, unavailable}, guild_manager:start_or_lookup(GuildId))
- after
- ShardPid ! stop,
- delete_table(guild_manager_shard_table),
- delete_table(guild_pid_cache)
- end
- end}.
-
-delete_table(Name) ->
- try ets:delete(Name) of
- _ -> ok
- catch
- error:badarg -> ok
- end.
-
-shard_stub_loop(GuildId, GuildPid) ->
- receive
- stop ->
- ok;
- {'$gen_call', From, {start_or_lookup, GuildId}} ->
- gen_server:reply(From, {ok, GuildPid}),
- shard_stub_loop(GuildId, GuildPid);
- {'$gen_call', From, {lookup, GuildId}} ->
- gen_server:reply(From, {ok, GuildPid}),
- shard_stub_loop(GuildId, GuildPid);
- {'$gen_call', From, _Request} ->
- gen_server:reply(From, {error, unsupported}),
- shard_stub_loop(GuildId, GuildPid);
- _ ->
- shard_stub_loop(GuildId, GuildPid)
- after infinity ->
- ok
- end.
diff --git a/fluxer_gateway/test/guild_member_list_channel_perm_tests.erl b/fluxer_gateway/test/guild_member_list_channel_perm_tests.erl
deleted file mode 100644
index 8e892dc73..000000000
--- a/fluxer_gateway/test/guild_member_list_channel_perm_tests.erl
+++ /dev/null
@@ -1,89 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_member_list_channel_perm_tests).
--typing([eqwalizer]).
--include_lib("eunit/include/eunit.hrl").
-
-session_can_view_channel_members_grants_when_bit_set_test() ->
- Bit = constants:view_channel_members_permission(),
- View = constants:view_channel_permission(),
- GuildId = 700,
- UserId = 800,
- OwnerId = 999,
- Combined = Bit bor View,
- State = perm_state(GuildId, UserId, OwnerId, Combined),
- ?assert(
- guild_member_list_connected:session_can_view_channel_members(
- #{user_id => UserId}, 123, State
- )
- ).
-
-session_can_view_channel_members_denies_when_bit_unset_test() ->
- View = constants:view_channel_permission(),
- GuildId = 701,
- UserId = 801,
- OwnerId = 998,
- State = perm_state(GuildId, UserId, OwnerId, View),
- ?assertNot(
- guild_member_list_connected:session_can_view_channel_members(
- #{user_id => UserId}, 123, State
- )
- ).
-
-session_can_view_channel_members_denies_when_cant_view_channel_test() ->
- Bit = constants:view_channel_members_permission(),
- GuildId = 702,
- UserId = 802,
- OwnerId = 997,
- State = perm_state(GuildId, UserId, OwnerId, Bit),
- ?assertNot(
- guild_member_list_connected:session_can_view_channel_members(
- #{user_id => UserId}, 123, State
- )
- ).
-
-session_can_view_channel_members_invalid_channel_id_test() ->
- ?assertNot(
- guild_member_list_connected:session_can_view_channel_members(
- #{user_id => 1}, invalid_channel_id(), #{}
- )
- ),
- ?assertNot(
- guild_member_list_connected:session_can_view_channel_members(
- #{user_id => 1}, 0, #{}
- )
- ),
- ?assertNot(
- guild_member_list_connected:session_can_view_channel_members(
- #{user_id => 1}, -1, #{}
- )
- ).
-
-session_can_view_channel_members_no_user_id_test() ->
- ?assertNot(guild_member_list_connected:session_can_view_channel_members(#{}, 5, #{})).
-
-perm_state(GuildId, UserId, OwnerId, Perms) ->
- #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(Perms)
- }
- ],
- <<"members">> => [
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => []
- }
- ],
- <<"channels">> => [
- #{<<"id">> => <<"123">>, <<"permission_overwrites">> => []}
- ]
- }
- }.
-
-invalid_channel_id() ->
- eqwalizer:dynamic_cast(not_an_integer).
diff --git a/fluxer_gateway/test/guild_member_list_chaos_tests.erl b/fluxer_gateway/test/guild_member_list_chaos_tests.erl
deleted file mode 100644
index 2e8fb1dec..000000000
--- a/fluxer_gateway/test/guild_member_list_chaos_tests.erl
+++ /dev/null
@@ -1,893 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_member_list_chaos_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(GUILD_ID, 900100).
--define(PUBLIC_CHANNEL_ID, 900500).
--define(PRIVATE_CHANNEL_ID, 900501).
--define(HOISTED_ROLE_ID, 900200).
--define(PRIVATE_ROLE_ID, 900201).
--define(NEW_HOISTED_ROLE_ID, 900202).
--define(INITIAL_MEMBER_COUNT, 480).
--define(SESSION_COUNT, 24).
--define(WORKER_COUNT, 24).
-
-guild_member_add_batched_sync_test_() ->
- {timeout, 30, fun guild_member_add_batched_sync/0}.
-
-concurrent_member_role_channel_chaos_stress_test_() ->
- {timeout, 120, fun concurrent_member_role_channel_chaos_stress/0}.
-
-guild_member_add_batched_sync() ->
- Parent = self(),
- SessionPid = start_capture(Parent),
- try
- InitialMembers = [
- internal_member(1000 + I, I, roles_for_member(I))
- || I <- lists:seq(1, 32)
- ],
- State = base_state(InitialMembers, [{<<"s1">>, 1001, SessionPid}]),
- with_guild(State, fun(GuildPid) ->
- subscribe_and_drain(GuildPid, [
- {<<"s1">>, ?PUBLIC_CHANNEL_ID, [{0, 99}]}
- ]),
- JoinedUserId = 199999,
- JoinedMember = event_member(JoinedUserId, 0, []),
- ok = dispatch_event(GuildPid, guild_member_add, JoinedMember),
- StateAfterAdd = get_guild_state(GuildPid),
- AddedMember = guild_data_index_members:get_member(
- JoinedUserId, maps:get(data, StateAfterAdd, #{})
- ),
- ?assert(
- guild_permissions_check:can_view_channel(
- JoinedUserId, ?PUBLIC_CHANNEL_ID, AddedMember, StateAfterAdd
- )
- ),
- assert_engine_has_user(default, JoinedUserId, StateAfterAdd),
- assert_engine_has_user(?PUBLIC_CHANNEL_ID, JoinedUserId, StateAfterAdd),
- Payload = wait_for_member_list_payload(
- fun(P) ->
- payload_channel_id(P) =:= ?PUBLIC_CHANNEL_ID andalso
- payload_has_member(JoinedUserId, P)
- end,
- 2000
- ),
- ?assertEqual(length(InitialMembers) + 1, maps:get(<<"member_count">>, Payload)),
- FinalState = get_guild_state(GuildPid),
- assert_default_engine_consistent(FinalState),
- assert_channel_engine_consistent(?PUBLIC_CHANNEL_ID, FinalState)
- end)
- after
- SessionPid ! stop,
- flush_captures()
- end.
-
-concurrent_member_role_channel_chaos_stress() ->
- Parent = self(),
- CapturePids = [start_capture(Parent) || _ <- lists:seq(1, ?SESSION_COUNT)],
- try
- InitialMembers = [
- internal_member(100000 + I, I, roles_for_member(I))
- || I <- lists:seq(1, ?INITIAL_MEMBER_COUNT)
- ],
- Sessions = build_sessions(CapturePids),
- State = base_state(InitialMembers, Sessions),
- with_guild(State, fun(GuildPid) ->
- subscribe_and_drain(GuildPid, subscription_requests(Sessions)),
- Ops = chaos_ops(),
- StartedAt = erlang:monotonic_time(millisecond),
- apply_concurrent_ops(GuildPid, Ops, ?WORKER_COUNT),
- ElapsedMs = erlang:monotonic_time(millisecond) - StartedAt,
- FinalState = get_guild_state(GuildPid),
- Captures = collect_captures(1500),
- MemberListUpdates = [
- Payload
- || {member_list_capture, _Pid, guild_member_list_update, Payload} <- Captures
- ],
- ?assertMatch([_ | _], MemberListUpdates),
- ?assert(payloads_include_channel(?PUBLIC_CHANNEL_ID, MemberListUpdates)),
- ?assert(payloads_include_channel(?PRIVATE_CHANNEL_ID, MemberListUpdates)),
- ?assert(ElapsedMs < 60000),
- assert_default_engine_consistent(FinalState),
- assert_channel_engine_consistent(?PUBLIC_CHANNEL_ID, FinalState),
- assert_channel_engine_consistent(?PRIVATE_CHANNEL_ID, FinalState),
- assert_removed_members_absent(FinalState),
- assert_added_members_present(FinalState)
- end)
- after
- lists:foreach(fun(Pid) -> Pid ! stop end, CapturePids),
- flush_captures()
- end.
-
-with_guild(State, Fun) ->
- {ok, GuildPid} = guild:start_link(State),
- try
- Fun(GuildPid)
- after
- safe_stop_guild(GuildPid)
- end.
-
-safe_stop_guild(GuildPid) ->
- try gen_server:call(GuildPid, {terminate}, 5000) of
- _ -> ok
- catch
- exit:_ -> ok
- end.
-
-start_capture(Parent) ->
- spawn_link(fun() -> capture_loop(Parent) end).
-
-capture_loop(Parent) ->
- receive
- stop ->
- ok;
- {'$gen_cast', {dispatch, Event, Payload}} ->
- Parent ! {member_list_capture, self(), Event, decode_payload(Payload)},
- capture_loop(Parent);
- _Other ->
- capture_loop(Parent)
- after 30000 ->
- ok
- end.
-
-decode_payload({pre_encoded, Bin}) when is_binary(Bin) ->
- json:decode(Bin);
-decode_payload(Payload) ->
- Payload.
-
-subscribe_and_drain(GuildPid, Requests) ->
- lists:foreach(
- fun({SessionId, ChannelId, Ranges}) ->
- ok = gen_server:call(
- GuildPid,
- {lazy_subscribe, #{
- session_id => SessionId,
- channel_id => ChannelId,
- ranges => Ranges
- }},
- 30000
- )
- end,
- Requests
- ),
- SubscribedState = drain_lazy_subscribe_buffer(GuildPid),
- assert_requests_subscribed(Requests, SubscribedState),
- await_initial_syncs(Requests, SubscribedState),
- _ = collect_captures(100),
- ok.
-
-assert_requests_subscribed(Requests, State) ->
- ExpectedRequests = retained_subscription_requests(Requests),
- SubsTab = maps:get(member_list_subscriptions, State),
- lists:foreach(
- fun({SessionId, ChannelId, Ranges}) ->
- case Ranges of
- [] ->
- ok;
- _ ->
- ListId = integer_to_binary(ChannelId),
- ?assert(
- guild_member_list_subs:is_subscribed(ListId, SessionId, SubsTab),
- {not_subscribed, SessionId, ChannelId}
- )
- end
- end,
- ExpectedRequests
- ).
-
-retained_subscription_requests(Requests) ->
- maps:values(lists:foldl(fun retain_subscription_request/2, #{}, Requests)).
-
-retain_subscription_request({SessionId, ChannelId, []}, Acc) ->
- case maps:get(SessionId, Acc, undefined) of
- {SessionId, ChannelId, _Ranges} -> maps:remove(SessionId, Acc);
- _ -> Acc
- end;
-retain_subscription_request({SessionId, _ChannelId, _Ranges} = Request, Acc) ->
- Acc#{SessionId => Request}.
-
-await_initial_syncs(Requests, State) ->
- Expected = initial_sync_expectations(Requests, State),
- Deadline = erlang:monotonic_time(millisecond) + 5000,
- wait_for_initial_syncs(Expected, Deadline, []).
-
-initial_sync_expectations(Requests, State) ->
- SubsTab = maps:get(member_list_subscriptions, State),
- lists:sort(
- lists:filtermap(
- fun({SessionId, ChannelId, Ranges}) ->
- initial_sync_expectation(SessionId, ChannelId, Ranges, SubsTab, State)
- end,
- Requests
- )
- ).
-
-initial_sync_expectation(_SessionId, _ChannelId, [], _SubsTab, _State) ->
- false;
-initial_sync_expectation(SessionId, ChannelId, _Ranges, SubsTab, State) ->
- ListId = integer_to_binary(ChannelId),
- case guild_member_list_subs:is_subscribed(ListId, SessionId, SubsTab) of
- true -> {true, {ChannelId, length(expected_channel_member_ids(ChannelId, State))}};
- false -> false
- end.
-
-wait_for_initial_syncs([], _Deadline, _Seen) ->
- ok;
-wait_for_initial_syncs(Expected, Deadline, Seen) ->
- Remaining = max(0, Deadline - erlang:monotonic_time(millisecond)),
- receive
- {member_list_capture, _Pid, guild_member_list_update, Payload} ->
- case take_initial_sync_match(Payload, Expected) of
- {matched, RemainingExpected} ->
- wait_for_initial_syncs(RemainingExpected, Deadline, [Payload | Seen]);
- unmatched ->
- wait_for_initial_syncs(Expected, Deadline, [Payload | Seen])
- end;
- _Other ->
- wait_for_initial_syncs(Expected, Deadline, Seen)
- after Remaining ->
- erlang:error(
- {initial_member_list_syncs_not_received, Expected, summarize_payloads(Seen)}
- )
- end.
-
-take_initial_sync_match(_Payload, []) ->
- unmatched;
-take_initial_sync_match(Payload, [{ChannelId, MemberCount} | Rest]) ->
- case
- payload_channel_id(Payload) =:= ChannelId andalso
- payload_member_count(Payload) =:= MemberCount
- of
- true ->
- {matched, Rest};
- false ->
- case take_initial_sync_match(Payload, Rest) of
- {matched, Remaining} -> {matched, [{ChannelId, MemberCount} | Remaining]};
- unmatched -> unmatched
- end
- end.
-
-dispatch_event(GuildPid, Event, Data) ->
- gen_server:call(GuildPid, {dispatch, #{event => Event, data => Data}}, 60000).
-
-presence_update(GuildPid, UserId, Status) ->
- GuildPid ! {presence, UserId, #{<<"status">> => Status, <<"mobile">> => false}},
- _ = gen_server:call(GuildPid, {get_counts}, 60000),
- ok.
-
-drain_lazy_subscribe_buffer(GuildPid) ->
- GuildPid ! flush_lazy_subscribe_buffer,
- State = get_guild_state(GuildPid),
- case maps:is_key(lazy_subscribe_buffer, State) of
- true -> drain_lazy_subscribe_buffer(GuildPid);
- false -> State
- end.
-
-get_guild_state(GuildPid) ->
- gen_server:call(GuildPid, {get_sessions}, 60000).
-
-apply_concurrent_ops(GuildPid, Ops, WorkerCount) ->
- Parent = self(),
- Chunks = chunk_round_robin(Ops, WorkerCount),
- Workers = [spawn_chaos_worker(Parent, GuildPid, Chunk) || Chunk <- Chunks],
- lists:foreach(fun(Pid) -> Pid ! go end, Workers),
- wait_workers(Workers).
-
-spawn_chaos_worker(Parent, GuildPid, Chunk) ->
- spawn_link(fun() -> chaos_worker_loop(Parent, GuildPid, Chunk) end).
-
-chaos_worker_loop(Parent, GuildPid, Chunk) ->
- receive
- go ->
- Parent ! {chaos_worker_done, self(), apply_ops_safely(GuildPid, Chunk)}
- after 60000 ->
- Parent ! {chaos_worker_done, self(), {error, start_timeout}}
- end.
-
-apply_ops_safely(GuildPid, Ops) ->
- try apply_ops(GuildPid, Ops) of
- ok -> ok
- catch
- Class:Reason:Stacktrace -> {error, {Class, Reason, Stacktrace}}
- end.
-
-apply_ops(GuildPid, Ops) ->
- lists:foreach(fun(Op) -> apply_op(GuildPid, Op) end, Ops).
-
-apply_op(GuildPid, {presence, UserId, Status}) ->
- presence_update(GuildPid, UserId, Status);
-apply_op(GuildPid, {Event, Data}) ->
- ok = dispatch_event(GuildPid, Event, Data).
-
-wait_workers([]) ->
- ok;
-wait_workers(Workers) ->
- receive
- {chaos_worker_done, Pid, ok} ->
- wait_workers(lists:delete(Pid, Workers));
- {chaos_worker_done, _Pid, {error, Reason}} ->
- ?assert(false, {chaos_worker_failed, Reason});
- {chaos_worker_done, _Pid, Other} ->
- ?assert(false, {chaos_worker_returned, Other})
- after 60000 ->
- ?assert(false, {chaos_workers_timed_out, length(Workers)})
- end.
-
-chunk_round_robin(Ops, Count) ->
- Indexed = lists:zip(lists:seq(1, length(Ops)), Ops),
- [
- [Op || {Idx, Op} <- Indexed, (Idx - 1) rem Count =:= Worker]
- || Worker <- lists:seq(0, Count - 1)
- ].
-
-wait_for_member_list_payload(Pred, TimeoutMs) ->
- Deadline = erlang:monotonic_time(millisecond) + TimeoutMs,
- wait_for_member_list_payload_until(Pred, Deadline, []).
-
-wait_for_member_list_payload_until(Pred, Deadline, Seen) ->
- Remaining = max(0, Deadline - erlang:monotonic_time(millisecond)),
- receive
- {member_list_capture, _Pid, guild_member_list_update, Payload} ->
- case Pred(Payload) of
- true -> Payload;
- false -> wait_for_member_list_payload_until(Pred, Deadline, [Payload | Seen])
- end;
- _Other ->
- wait_for_member_list_payload_until(Pred, Deadline, Seen)
- after Remaining ->
- erlang:error(
- {member_list_update_not_received, summarize_payloads(lists:reverse(Seen)),
- summarize_captures(collect_captures(0))}
- )
- end.
-
-collect_captures(QuietMs) ->
- collect_captures(QuietMs, []).
-
-collect_captures(QuietMs, Acc) ->
- receive
- {member_list_capture, _Pid, _Event, _Payload} = Msg ->
- collect_captures(QuietMs, [Msg | Acc]);
- _Other ->
- collect_captures(QuietMs, Acc)
- after QuietMs ->
- lists:reverse(Acc)
- end.
-
-flush_captures() ->
- receive
- {member_list_capture, _Pid, _Event, _Payload} ->
- flush_captures();
- _Other ->
- flush_captures()
- after 0 ->
- ok
- end.
-
-payload_channel_id(Payload) ->
- case maps:get(<<"channel_id">>, Payload, undefined) of
- Bin when is_binary(Bin) -> snowflake_id:parse(Bin);
- Int when is_integer(Int) -> Int;
- _ -> undefined
- end.
-
-payload_member_count(Payload) ->
- maps:get(<<"member_count">>, Payload, undefined).
-
-payloads_include_channel(ChannelId, Payloads) ->
- lists:any(fun(Payload) -> payload_channel_id(Payload) =:= ChannelId end, Payloads).
-
-payload_has_member(UserId, Payload) ->
- lists:any(
- fun(Op) -> op_has_member(UserId, Op) end,
- maps:get(<<"ops">>, Payload, [])
- ).
-
-op_has_member(UserId, Op) ->
- lists:any(
- fun(Item) -> item_user_id(Item) =:= UserId end,
- maps:get(<<"items">>, Op, [])
- ).
-
-item_user_id(#{<<"member">> := Member}) ->
- guild_member_list_common:get_member_user_id(Member);
-item_user_id(_) ->
- undefined.
-
-summarize_captures(Captures) ->
- [
- {Event, summarize_payload(Payload)}
- || {member_list_capture, _Pid, Event, Payload} <- Captures
- ].
-
-summarize_payloads(Payloads) ->
- [summarize_payload(Payload) || Payload <- Payloads].
-
-summarize_payload(Payload) ->
- #{
- channel_id => payload_channel_id(Payload),
- member_count => payload_member_count(Payload),
- op_count => length(maps:get(<<"ops">>, Payload, [])),
- sample_user_ids => lists:sublist(payload_member_ids(Payload), 8)
- }.
-
-payload_member_ids(Payload) ->
- [
- UserId
- || Op <- maps:get(<<"ops">>, Payload, []),
- Item <- maps:get(<<"items">>, Op, []),
- UserId <- [item_user_id(Item)],
- is_integer(UserId)
- ].
-
-assert_default_engine_consistent(State) ->
- Data = maps:get(data, State, #{}),
- MemberMap = guild_data_index_members:member_map(Data),
- Ref = maps:get(member_list_engine, State),
- assert_engine_matches_ids(<<"0">>, Ref, maps:keys(MemberMap), State).
-
-assert_channel_engine_consistent(ChannelId, State) ->
- ListId = integer_to_binary(ChannelId),
- Engines = maps:get(channel_member_list_engines, State, #{}),
- ?assert(maps:is_key(ListId, Engines)),
- Ref = maps:get(ListId, Engines),
- ExpectedIds = expected_channel_member_ids(ChannelId, State),
- assert_engine_matches_ids(ListId, Ref, ExpectedIds, State).
-
-assert_engine_has_user(default, UserId, State) ->
- Ref = maps:get(member_list_engine, State),
- assert_ref_has_user(default, Ref, UserId, State);
-assert_engine_has_user(ChannelId, UserId, State) ->
- ListId = integer_to_binary(ChannelId),
- Engines = maps:get(channel_member_list_engines, State, #{}),
- Ref = maps:get(ListId, Engines),
- assert_ref_has_user(ChannelId, Ref, UserId, State).
-
-assert_ref_has_user(Label, Ref, UserId, State) ->
- Ids = guild_member_list_engine:get_sorted_user_ids(Ref),
- case lists:member(UserId, Ids) of
- true ->
- ok;
- false ->
- Data = maps:get(data, State, #{}),
- erlang:error({
- engine_missing_user,
- Label,
- UserId,
- guild_data_index_members:get_member(UserId, Data),
- guild_member_list_engine:get_counts(Ref),
- lists:sublist(lists:sort(Ids), 10)
- })
- end.
-
-assert_engine_matches_ids(ListId, Ref, ExpectedIds0, State) ->
- ExpectedIds = lists:sort(ExpectedIds0),
- ActualIds = lists:sort(guild_member_list_engine:get_sorted_user_ids(Ref)),
- ?assertEqual(ExpectedIds, ActualIds),
- ExpectedOnline = length([U || U <- ExpectedIds, expected_online(U, State)]),
- ?assertEqual(
- {length(ExpectedIds), ExpectedOnline},
- guild_member_list_engine:get_counts(Ref)
- ),
- ?assertEqual(
- expected_groups(ExpectedIds, State),
- guild_member_list_engine:get_groups(Ref)
- ),
- assert_snapshot_matches_engine(ListId, Ref, State).
-
-assert_snapshot_matches_engine(ListId, Ref, State) ->
- {Total, Online} = guild_member_list_engine:get_counts(Ref),
- {SnapshotTotal, SnapshotOnline, SnapshotGroups, SnapshotItems} =
- guild_member_list_read:member_list_snapshot(ListId, State),
- ?assertEqual(Total, SnapshotTotal),
- ?assertEqual(Online, SnapshotOnline),
- ?assertEqual(
- visible_groups(guild_member_list_engine:get_groups(Ref)),
- SnapshotGroups
- ),
- SnapshotIds = lists:sort([
- UserId
- || #{<<"member">> := Member} <- SnapshotItems,
- UserId <- [guild_member_list_common:get_member_user_id(Member)],
- is_integer(UserId)
- ]),
- ?assertEqual(SnapshotIds, lists:usort(SnapshotIds)).
-
-visible_groups(Groups) ->
- Threshold = guild_member_list_offline:threshold(),
- [
- #{<<"id">> => Id, <<"count">> => Count}
- || {Id, Count} <- Groups,
- Count > 0,
- Id =/= <<"offline">> orelse Count =< Threshold
- ].
-
-expected_channel_member_ids(ChannelId, State) ->
- Data = maps:get(data, State, #{}),
- MemberMap = guild_data_index_members:member_map(Data),
- [
- UserId
- || {UserId, Member} <- maps:to_list(MemberMap),
- can_view_channel(UserId, ChannelId, Member, State)
- ].
-
-can_view_channel(UserId, ChannelId, Member, State) ->
- try guild_permissions_check:can_view_channel(UserId, ChannelId, Member, State) of
- Bool when is_boolean(Bool) -> Bool;
- _ -> false
- catch
- _:_ -> false
- end.
-
-expected_groups(ExpectedIds, State) ->
- Data = maps:get(data, State, #{}),
- Roles = guild_data_index_roles:role_list(Data),
- HoistedRoleIds = guild_member_list_store:prepare_hoisted_role_ids(
- Roles, maps:get(id, State, undefined)
- ),
- InitialCounts = maps:from_list(
- [{integer_to_binary(RoleId), 0} || RoleId <- HoistedRoleIds] ++
- [{<<"online">>, 0}, {<<"offline">>, 0}]
- ),
- Counts = lists:foldl(
- fun(UserId, Acc) ->
- Member = guild_data_index_members:get_member(UserId, Data),
- GroupId = expected_group_id(Member, HoistedRoleIds, UserId, State),
- maps:update_with(GroupId, fun(N) -> N + 1 end, 1, Acc)
- end,
- InitialCounts,
- ExpectedIds
- ),
- [
- {integer_to_binary(RoleId), maps:get(integer_to_binary(RoleId), Counts, 0)}
- || RoleId <- HoistedRoleIds
- ] ++
- [
- {<<"online">>, maps:get(<<"online">>, Counts, 0)},
- {<<"offline">>, maps:get(<<"offline">>, Counts, 0)}
- ].
-
-expected_group_id(Member, _HoistedRoleIds, _UserId, _State) when not is_map(Member) ->
- <<"offline">>;
-expected_group_id(Member, HoistedRoleIds, UserId, State) ->
- case expected_online(UserId, State) of
- false ->
- <<"offline">>;
- true ->
- RoleIds = guild_member_list_store:extract_role_ids(Member),
- case guild_member_list_groups:find_top_hoisted_role(RoleIds, HoistedRoleIds) of
- undefined -> <<"online">>;
- RoleId -> integer_to_binary(RoleId)
- end
- end.
-
-expected_online(UserId, State) ->
- Connected = maps:get(connected_user_ids, State, sets:new()),
- Presence = guild_state_member:lookup_presence(maps:get(member_presence, State), UserId),
- Status = maps:get(<<"status">>, Presence, <<"offline">>),
- sets:is_element(UserId, Connected) andalso
- Status =/= <<"offline">> andalso Status =/= <<"invisible">>.
-
-assert_removed_members_absent(State) ->
- Data = maps:get(data, State, #{}),
- lists:foreach(
- fun(UserId) ->
- ?assertEqual(undefined, guild_data_index_members:get_member(UserId, Data))
- end,
- removed_user_ids()
- ).
-
-assert_added_members_present(State) ->
- Data = maps:get(data, State, #{}),
- lists:foreach(
- fun(UserId) ->
- ?assertMatch(#{}, guild_data_index_members:get_member(UserId, Data))
- end,
- added_user_ids()
- ).
-
-chaos_ops() ->
- AddOps = [
- {guild_member_add, event_member(UserId, UserId - 200000, add_roles(UserId))}
- || UserId <- added_user_ids()
- ],
- UpdateOps = [
- {guild_member_update, updated_member(UserId, Seq)}
- || {UserId, Seq} <- lists:zip(updated_user_ids(), lists:seq(1, length(updated_user_ids())))
- ],
- RemoveOps = [
- {guild_member_remove, #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}}}
- || UserId <- removed_user_ids()
- ],
- PresenceOps = [
- {presence, UserId, presence_status(Seq)}
- || {UserId, Seq} <- lists:zip(session_user_ids(), lists:seq(1, ?SESSION_COUNT))
- ],
- RoleOps = role_ops(),
- ChannelOps = channel_ops(),
- interleave_ops([AddOps, UpdateOps, RemoveOps, PresenceOps, RoleOps, ChannelOps]).
-
-interleave_ops(OpLists) ->
- interleave_ops(OpLists, []).
-
-interleave_ops(OpLists, Acc) ->
- Heads = [Head || [Head | _Tail] <- OpLists],
- Tails = [Tail || [_Head | Tail] <- OpLists, Tail =/= []],
- case Heads of
- [] -> lists:reverse(Acc);
- _ -> interleave_ops(Tails, lists:reverse(Heads) ++ Acc)
- end.
-
-added_user_ids() ->
- lists:seq(200001, 200060).
-
-updated_user_ids() ->
- lists:seq(100220, 100299).
-
-removed_user_ids() ->
- lists:seq(100120, 100159).
-
-session_user_ids() ->
- [100000 + I || I <- lists:seq(1, ?SESSION_COUNT)].
-
-role_ops() ->
- View = constants:view_channel_permission(),
- ViewMembers = constants:view_channel_members_permission(),
- [
- {guild_role_update, #{
- <<"role">> =>
- event_role(?HOISTED_ROLE_ID, <<"Signal">>, View bor ViewMembers, true, 80)
- }},
- {guild_role_update, #{
- <<"role">> =>
- event_role(?PRIVATE_ROLE_ID, <<"Operators">>, View bor ViewMembers, true, 75)
- }},
- {guild_role_create, #{
- <<"role">> =>
- event_role(
- ?NEW_HOISTED_ROLE_ID,
- <<"New arrivals">>,
- View bor ViewMembers,
- true,
- 5
- )
- }},
- {guild_role_delete, #{<<"role_id">> => integer_to_binary(?NEW_HOISTED_ROLE_ID)}}
- ].
-
-channel_ops() ->
- [
- {channel_update,
- event_private_channel(?PRIVATE_CHANNEL_ID, ?PRIVATE_ROLE_ID, ?HOISTED_ROLE_ID)}
- ].
-
-presence_status(Seq) when Seq rem 5 =:= 0 ->
- <<"offline">>;
-presence_status(Seq) when Seq rem 3 =:= 0 ->
- <<"dnd">>;
-presence_status(Seq) when Seq rem 2 =:= 0 ->
- <<"idle">>;
-presence_status(_Seq) ->
- <<"online">>.
-
-subscription_requests(Sessions) ->
- Public = [
- {SessionId, ?PUBLIC_CHANNEL_ID, [{0, 99}, {100, 199}]}
- || {SessionId, _UserId, _Pid} <- Sessions
- ],
- Private = [
- {SessionId, ?PRIVATE_CHANNEL_ID, [{0, 99}]}
- || {SessionId, UserId, _Pid} <- Sessions,
- lists:member(?PRIVATE_ROLE_ID, roles_for_user_id(UserId))
- ],
- Public ++ Private.
-
-build_sessions(CapturePids) ->
- UserIds = session_user_ids(),
- [
- {session_id(I), UserId, Pid}
- || {I, UserId, Pid} <- zip3(lists:seq(1, length(CapturePids)), UserIds, CapturePids)
- ].
-
-base_state(Members, Sessions) ->
- #{
- id => ?GUILD_ID,
- member_count => length(Members),
- sessions => maps:from_list([
- {SessionId, #{
- user_id => UserId,
- pid => Pid,
- active_guilds => sets:from_list([?GUILD_ID])
- }}
- || {SessionId, UserId, Pid} <- Sessions
- ]),
- data => #{
- <<"guild">> => #{
- <<"id">> => ?GUILD_ID,
- <<"owner_id">> => 100001,
- <<"features">> => [],
- <<"member_count">> => length(Members)
- },
- <<"roles">> => initial_roles(),
- <<"channels">> => initial_channels(),
- <<"members">> => Members
- }
- }.
-
-initial_roles() ->
- View = constants:view_channel_permission(),
- ViewMembers = constants:view_channel_members_permission(),
- [
- internal_role(?GUILD_ID, <<"everyone">>, View bor ViewMembers, false, 0),
- internal_role(?HOISTED_ROLE_ID, <<"Signal">>, View bor ViewMembers, true, 60),
- internal_role(?PRIVATE_ROLE_ID, <<"Operators">>, View bor ViewMembers, true, 70)
- ].
-
-initial_channels() ->
- [
- #{
- <<"id">> => ?PUBLIC_CHANNEL_ID,
- <<"name">> => <<"general">>,
- <<"type">> => 0,
- <<"permission_overwrites">> => []
- },
- internal_private_channel(?PRIVATE_CHANNEL_ID, ?PRIVATE_ROLE_ID, undefined)
- ].
-
-internal_private_channel(ChannelId, AllowRoleId, ExtraAllowRoleId) ->
- View = constants:view_channel_permission(),
- ViewMembers = constants:view_channel_members_permission(),
- AllowBits = View bor ViewMembers,
- RoleOverwrites =
- [
- internal_role_overwrite(AllowRoleId, AllowBits, 0)
- || is_integer(AllowRoleId)
- ] ++
- [
- internal_role_overwrite(ExtraAllowRoleId, AllowBits, 0)
- || is_integer(ExtraAllowRoleId)
- ],
- #{
- <<"id">> => ChannelId,
- <<"name">> => <<"ops">>,
- <<"type">> => 0,
- <<"permission_overwrites">> =>
- [internal_role_overwrite(?GUILD_ID, 0, View) | RoleOverwrites]
- }.
-
-event_private_channel(ChannelId, AllowRoleId, ExtraAllowRoleId) ->
- View = constants:view_channel_permission(),
- ViewMembers = constants:view_channel_members_permission(),
- AllowBits = View bor ViewMembers,
- RoleOverwrites =
- [
- event_role_overwrite(AllowRoleId, AllowBits, 0)
- || is_integer(AllowRoleId)
- ] ++
- [
- event_role_overwrite(ExtraAllowRoleId, AllowBits, 0)
- || is_integer(ExtraAllowRoleId)
- ],
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"name">> => <<"ops">>,
- <<"type">> => 0,
- <<"permission_overwrites">> =>
- [event_role_overwrite(?GUILD_ID, 0, View) | RoleOverwrites]
- }.
-
-internal_role_overwrite(RoleId, Allow, Deny) ->
- #{
- <<"id">> => RoleId,
- <<"type">> => 0,
- <<"allow">> => Allow,
- <<"deny">> => Deny
- }.
-
-event_role_overwrite(RoleId, Allow, Deny) ->
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"type">> => 0,
- <<"allow">> => integer_to_binary(Allow),
- <<"deny">> => integer_to_binary(Deny)
- }.
-
-internal_role(RoleId, Name, Permissions, Hoist, Position) ->
- #{
- <<"id">> => RoleId,
- <<"name">> => Name,
- <<"permissions">> => Permissions,
- <<"hoist">> => Hoist,
- <<"position">> => Position
- }.
-
-event_role(RoleId, Name, Permissions, Hoist, Position) ->
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"name">> => Name,
- <<"permissions">> => integer_to_binary(Permissions),
- <<"hoist">> => Hoist,
- <<"position">> => Position
- }.
-
-internal_member(UserId, Seq, Roles) ->
- #{
- <<"user">> => #{
- <<"id">> => UserId,
- <<"username">> => username(Seq),
- <<"global_name">> => display_name(Seq),
- <<"bot">> => Seq rem 37 =:= 0
- },
- <<"nick">> => nick(Seq),
- <<"roles">> => Roles,
- <<"joined_at">> => joined_at(Seq)
- }.
-
-event_member(UserId, Seq, Roles) ->
- #{
- <<"user">> => #{
- <<"id">> => integer_to_binary(UserId),
- <<"username">> => username(Seq),
- <<"global_name">> => display_name(Seq),
- <<"bot">> => Seq rem 37 =:= 0
- },
- <<"nick">> => nick(Seq),
- <<"roles">> => [integer_to_binary(RoleId) || RoleId <- Roles],
- <<"joined_at">> => joined_at(Seq)
- }.
-
-updated_member(UserId, Seq) ->
- Base = event_member(UserId, 7000 + Seq, update_roles(Seq)),
- Base#{<<"nick">> => <<"renamed_", (integer_to_binary(Seq))/binary>>}.
-
-roles_for_member(Seq) ->
- roles_from_flags(Seq rem 5 =:= 0, Seq rem 7 =:= 0).
-
-roles_for_user_id(UserId) ->
- roles_for_member(UserId - 100000).
-
-add_roles(UserId) ->
- Seq = UserId - 200000,
- roles_from_flags(Seq rem 4 =:= 0, Seq rem 6 =:= 0).
-
-update_roles(Seq) ->
- roles_from_flags(Seq rem 3 =:= 0, Seq rem 4 =:= 0).
-
-roles_from_flags(HasHoisted, HasPrivate) ->
- MaybeHoisted =
- case HasHoisted of
- true -> [?HOISTED_ROLE_ID];
- false -> []
- end,
- MaybePrivate =
- case HasPrivate of
- true -> [?PRIVATE_ROLE_ID];
- false -> []
- end,
- MaybeHoisted ++ MaybePrivate.
-
-username(Seq) ->
- iolist_to_binary(io_lib:format("member_~6..0B", [Seq])).
-
-display_name(Seq) ->
- iolist_to_binary(io_lib:format("Member ~6..0B", [Seq])).
-
-nick(Seq) when Seq rem 4 =:= 0 ->
- iolist_to_binary(io_lib:format("Team ~6..0B", [Seq]));
-nick(_Seq) ->
- null.
-
-joined_at(Seq) ->
- Day = (Seq rem 28) + 1,
- iolist_to_binary(io_lib:format("2026-05-~2..0BT12:00:00Z", [Day])).
-
-session_id(I) ->
- <<"s", (integer_to_binary(I))/binary>>.
-
-zip3([A | As], [B | Bs], [C | Cs]) ->
- [{A, B, C} | zip3(As, Bs, Cs)];
-zip3([], [], []) ->
- [].
diff --git a/fluxer_gateway/test/guild_member_list_connected_tests.erl b/fluxer_gateway/test/guild_member_list_connected_tests.erl
deleted file mode 100644
index 7465edf52..000000000
--- a/fluxer_gateway/test/guild_member_list_connected_tests.erl
+++ /dev/null
@@ -1,60 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_member_list_connected_tests).
--typing([eqwalizer]).
--include_lib("eunit/include/eunit.hrl").
-
-session_can_view_channel_uses_cached_visibility_test() ->
- SessionData = #{user_id => 12, viewable_channels => #{500 => true}},
- State = #{data => #{<<"members">> => #{}}},
- ?assertEqual(
- true, guild_member_list_connected:session_can_view_channel(SessionData, 500, State)
- ).
-
-session_can_view_channel_rejects_when_cache_misses_and_user_missing_test() ->
- SessionData = #{user_id => 99, viewable_channels => #{}},
- State = #{data => #{<<"members">> => #{}}},
- ?assertEqual(
- false, guild_member_list_connected:session_can_view_channel(SessionData, 500, State)
- ).
-
-session_can_view_channel_non_integer_channel_test() ->
- SessionData = #{user_id => 1, viewable_channels => #{}},
- State = #{data => #{<<"members">> => #{}}},
- ?assertEqual(
- false,
- guild_member_list_connected:session_can_view_channel(
- SessionData, invalid_channel_id(), State
- )
- ).
-
-session_can_view_channel_zero_channel_test() ->
- SessionData = #{user_id => 1, viewable_channels => #{}},
- State = #{data => #{<<"members">> => #{}}},
- ?assertEqual(
- false, guild_member_list_connected:session_can_view_channel(SessionData, 0, State)
- ).
-
-session_can_view_channel_negative_channel_test() ->
- SessionData = #{user_id => 1, viewable_channels => #{}},
- State = #{data => #{<<"members">> => #{}}},
- ?assertEqual(
- false, guild_member_list_connected:session_can_view_channel(SessionData, -5, State)
- ).
-
-session_can_view_channel_no_user_id_test() ->
- SessionData = #{},
- State = #{data => #{<<"members">> => #{}}},
- ?assertEqual(
- false, guild_member_list_connected:session_can_view_channel(SessionData, 500, State)
- ).
-
-session_can_view_channel_no_viewable_channels_map_test() ->
- SessionData = #{user_id => 1},
- State = #{data => #{<<"members">> => #{}}},
- ?assertEqual(
- false, guild_member_list_connected:session_can_view_channel(SessionData, 500, State)
- ).
-
-invalid_channel_id() ->
- eqwalizer:dynamic_cast(not_an_integer).
diff --git a/fluxer_gateway/test/guild_member_list_engine_tests.erl b/fluxer_gateway/test/guild_member_list_engine_tests.erl
deleted file mode 100644
index bc3f6c473..000000000
--- a/fluxer_gateway/test/guild_member_list_engine_tests.erl
+++ /dev/null
@@ -1,456 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_member_list_engine_tests).
--typing([eqwalizer]).
--include_lib("eunit/include/eunit.hrl").
-
-add_rejects_invalid_user_id_test() ->
- Ref = guild_member_list_engine:new(),
- ok = guild_member_list_engine:add_member(Ref, 0, <<"zero">>, [], true),
- ok = guild_member_list_engine:add_member(Ref, -1, <<"neg">>, [], true),
- ?assertEqual({0, 0}, guild_member_list_engine:get_counts(Ref)),
- guild_member_list_engine:destroy(Ref).
-
-add_replaces_existing_member_test() ->
- Ref = guild_member_list_engine:new(),
- ok = guild_member_list_engine:add_member(Ref, 1, <<"alice">>, [], false),
- ok = guild_member_list_engine:add_member(Ref, 1, <<"alice_new">>, [], true),
- ?assertEqual({1, 1}, guild_member_list_engine:get_counts(Ref)),
- guild_member_list_engine:destroy(Ref).
-
-set_online_moves_to_online_section_test() ->
- Ref = guild_member_list_engine:new(),
- ok = guild_member_list_engine:add_member(Ref, 1, <<"alice">>, [], false),
- ?assertEqual({1, 0}, guild_member_list_engine:get_counts(Ref)),
- ok = guild_member_list_engine:set_online(Ref, 1, true),
- ?assertEqual({1, 1}, guild_member_list_engine:get_counts(Ref)),
- assert_groups(default_groups(1, 0), Ref),
- guild_member_list_engine:destroy(Ref).
-
-bulk_load_test() ->
- Ref = guild_member_list_engine:new(),
- Members = [
- {1, <<"alice">>, [], true},
- {2, <<"bob">>, [], false},
- {3, <<"charlie">>, [], true}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, []),
- ?assertEqual({3, 2}, guild_member_list_engine:get_counts(Ref)),
- assert_groups(default_groups(2, 1), Ref),
- guild_member_list_engine:destroy(Ref).
-
-bulk_load_with_hoisted_roles_test() ->
- Ref = guild_member_list_engine:new(),
- RoleA = 100,
- Members = [
- {1, <<"alice">>, [RoleA], true},
- {2, <<"bob">>, [], true},
- {3, <<"charlie">>, [RoleA], false}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, [RoleA]),
- ?assertEqual({3, 2}, guild_member_list_engine:get_counts(Ref)),
- Groups = guild_member_list_engine:get_groups(Ref),
- ?assertEqual([{<<"100">>, 1}, {<<"online">>, 1}, {<<"offline">>, 1}], Groups),
- guild_member_list_engine:destroy(Ref).
-
-bulk_load_filters_invalid_ids_test() ->
- Ref = guild_member_list_engine:new(),
- Members = [
- {0, <<"zero">>, [], true},
- {-1, <<"neg">>, [], true},
- {1, <<"valid">>, [], true}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, []),
- ?assertEqual({1, 1}, guild_member_list_engine:get_counts(Ref)),
- guild_member_list_engine:destroy(Ref).
-
-get_items_full_range_test() ->
- Ref = guild_member_list_engine:new(),
- Members = alice_online_bob_offline(),
- ok = guild_member_list_engine:bulk_load(Ref, Members, []),
- Items = guild_member_list_engine:get_items(Ref, 0, 100),
- ?assertEqual(
- [
- {group, <<"online">>, 1},
- {member, 1},
- {group, <<"offline">>, 1},
- {member, 2}
- ],
- Items
- ),
- guild_member_list_engine:destroy(Ref).
-
-get_items_partial_range_test() ->
- Ref = guild_member_list_engine:new(),
- Members = [
- {1, <<"alice">>, [], true},
- {2, <<"bob">>, [], true},
- {3, <<"charlie">>, [], true},
- {4, <<"dave">>, [], false},
- {5, <<"eve">>, [], false}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, []),
- Items = guild_member_list_engine:get_items(Ref, 2, 5),
- ?assertEqual(
- [
- {member, 2},
- {member, 3},
- {group, <<"offline">>, 2},
- {member, 4}
- ],
- Items
- ),
- guild_member_list_engine:destroy(Ref).
-
-get_items_with_hoisted_roles_test() ->
- Ref = guild_member_list_engine:new(),
- RoleA = 100,
- RoleB = 200,
- Members = [
- {1, <<"alice">>, [RoleA], true},
- {2, <<"bob">>, [RoleB], true},
- {3, <<"charlie">>, [], true},
- {4, <<"dave">>, [], false}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, [RoleA, RoleB]),
- Items = guild_member_list_engine:get_items(Ref, 0, 100),
- ?assertEqual(
- [
- {group, <<"100">>, 1},
- {member, 1},
- {group, <<"200">>, 1},
- {member, 2},
- {group, <<"online">>, 1},
- {member, 3},
- {group, <<"offline">>, 1},
- {member, 4}
- ],
- Items
- ),
- guild_member_list_engine:destroy(Ref).
-
-get_items_sort_order_test() ->
- Ref = guild_member_list_engine:new(),
- Members = [
- {3, <<"charlie">>, [], true},
- {1, <<"alice">>, [], true},
- {2, <<"bob">>, [], true}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, []),
- Items = guild_member_list_engine:get_items(Ref, 1, 3),
- ?assertEqual([{member, 1}, {member, 2}, {member, 3}], Items),
- guild_member_list_engine:destroy(Ref).
-
-set_hoisted_roles_assigns_sections_test() ->
- Ref = guild_member_list_engine:new(),
- Members = [
- {1, <<"alice">>, [100], true},
- {2, <<"bob">>, [200], true},
- {3, <<"charlie">>, [], true}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, []),
- assert_groups(default_groups(3, 0), Ref),
- _ = guild_member_list_engine:set_hoisted_roles(Ref, [100, 200]),
- assert_groups(role_groups([{100, 1}, {200, 1}], 1, 0), Ref),
- ?assertEqual({3, 3}, guild_member_list_engine:get_counts(Ref)),
- guild_member_list_engine:destroy(Ref).
-
-set_hoisted_roles_offline_stays_offline_test() ->
- Ref = guild_member_list_engine:new(),
- Members = [
- {1, <<"alice">>, [100], false},
- {2, <<"bob">>, [100], true}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, [100]),
- Groups = guild_member_list_engine:get_groups(Ref),
- ?assertEqual([{<<"100">>, 1}, {<<"online">>, 0}, {<<"offline">>, 1}], Groups),
- guild_member_list_engine:destroy(Ref).
-
-set_hoisted_roles_same_is_noop_test() ->
- Ref = guild_member_list_engine:new(),
- ok = guild_member_list_engine:bulk_load(Ref, [{1, <<"a">>, [100], true}], [100]),
- _ = guild_member_list_engine:set_hoisted_roles(Ref, [100]),
- ?assertEqual({1, 1}, guild_member_list_engine:get_counts(Ref)),
- guild_member_list_engine:destroy(Ref).
-
-set_hoisted_roles_reports_changed_unchanged_test() ->
- Ref = guild_member_list_engine:new(),
- ok = guild_member_list_engine:bulk_load(Ref, [], []),
- ?assertEqual(changed, guild_member_list_engine:set_hoisted_roles(Ref, [100, 200])),
- ?assertEqual(unchanged, guild_member_list_engine:set_hoisted_roles(Ref, [100, 200])),
- ?assertEqual(changed, guild_member_list_engine:set_hoisted_roles(Ref, [200, 100])),
- ?assertEqual(changed, guild_member_list_engine:set_hoisted_roles(Ref, [200])),
- ?assertEqual(unchanged, guild_member_list_engine:set_hoisted_roles(Ref, [200])),
- guild_member_list_engine:destroy(Ref).
-
-set_hoisted_roles_remove_roles_test() ->
- Ref = guild_member_list_engine:new(),
- Members = [{1, <<"a">>, [100], true}, {2, <<"b">>, [], true}],
- ok = guild_member_list_engine:bulk_load(Ref, Members, [100]),
- assert_groups(role_groups([{100, 1}], 1, 0), Ref),
- _ = guild_member_list_engine:set_hoisted_roles(Ref, []),
- assert_groups(default_groups(2, 0), Ref),
- guild_member_list_engine:destroy(Ref).
-
-set_hoisted_roles_picks_highest_priority_test() ->
- Ref = guild_member_list_engine:new(),
- ok = guild_member_list_engine:bulk_load(Ref, [{1, <<"a">>, [200, 100], true}], [100, 200]),
- Groups = guild_member_list_engine:get_groups(Ref),
- ?assertEqual(
- [{<<"100">>, 1}, {<<"200">>, 0}, {<<"online">>, 0}, {<<"offline">>, 0}], Groups
- ),
- guild_member_list_engine:destroy(Ref).
-
-ordering_10k_test() ->
- Ref = guild_member_list_engine:new(),
- N = 10000,
- Members = [
- {I, iolist_to_binary(io_lib:format("user_~6..0B", [I])), [], I rem 3 =/= 0}
- || I <- lists:seq(1, N)
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, []),
- {Total, Online} = guild_member_list_engine:get_counts(Ref),
- ?assertEqual(N, Total),
- ExpectedOnline = length([1 || I <- lists:seq(1, N), I rem 3 =/= 0]),
- ?assertEqual(ExpectedOnline, Online),
- Items = guild_member_list_engine:get_items(Ref, 0, 20),
- [{group, <<"online">>, OnlineCount} | MemberItems] = Items,
- ?assertEqual(ExpectedOnline, OnlineCount),
- MemberIds = [Id || {member, Id} <- MemberItems],
- ?assertEqual(MemberIds, lists:sort(MemberIds)),
- guild_member_list_engine:destroy(Ref).
-
-ordering_preserves_sort_key_order_test() ->
- Ref = guild_member_list_engine:new(),
- Members = [
- {5, <<"eve">>, [], true},
- {1, <<"alice">>, [], true},
- {4, <<"dave">>, [], true},
- {2, <<"bob">>, [], true},
- {3, <<"charlie">>, [], true}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, []),
- Items = guild_member_list_engine:get_items(Ref, 1, 5),
- Ids = [Id || {member, Id} <- Items],
- ?assertEqual([1, 2, 3, 4, 5], Ids),
- guild_member_list_engine:destroy(Ref).
-
-rapid_add_remove_test() ->
- Ref = guild_member_list_engine:new(),
- lists:foreach(
- fun(I) ->
- guild_member_list_engine:add_member(Ref, I, <<"u">>, [], true)
- end,
- lists:seq(1, 100)
- ),
- ?assertEqual({100, 100}, guild_member_list_engine:get_counts(Ref)),
- lists:foreach(
- fun(I) ->
- guild_member_list_engine:remove_member(Ref, I)
- end,
- lists:seq(1, 50)
- ),
- ?assertEqual({50, 50}, guild_member_list_engine:get_counts(Ref)),
- guild_member_list_engine:destroy(Ref).
-
-rapid_online_toggle_test() ->
- Ref = guild_member_list_engine:new(),
- ok = guild_member_list_engine:add_member(Ref, 1, <<"a">>, [], false),
- lists:foreach(
- fun(I) ->
- guild_member_list_engine:set_online(Ref, 1, I rem 2 =:= 0)
- end,
- lists:seq(1, 1000)
- ),
- {1, _} = guild_member_list_engine:get_counts(Ref),
- guild_member_list_engine:destroy(Ref).
-
-set_hoisted_roles_preserves_all_indexed_members_test() ->
- Ref = guild_member_list_engine:new(),
- try
- Members = [
- {UserId, engine_sort_key(UserId), engine_roles_for_test_member(UserId), true}
- || UserId <- lists:seq(1, 1000)
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, [10]),
- ?assertEqual(
- lists:seq(1, 1000), lists:sort(guild_member_list_engine:get_sorted_user_ids(Ref))
- ),
- ?assertEqual(changed, guild_member_list_engine:set_hoisted_roles(Ref, [20, 10])),
- ?assertEqual(
- lists:seq(1, 1000), lists:sort(guild_member_list_engine:get_sorted_user_ids(Ref))
- ),
- ?assertEqual({1000, 1000}, guild_member_list_engine:get_counts(Ref))
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-update_member_preserves_bulk_loaded_members_test() ->
- Ref = guild_member_list_engine:new(),
- try
- InitialMembers = [
- {100000 + I, engine_sort_key(I), engine_roles_for_test_member(I), false}
- || I <- lists:seq(1, 480)
- ],
- ok = guild_member_list_engine:bulk_load(Ref, InitialMembers, [10]),
- lists:foreach(
- fun(I) ->
- UserId = 200000 + I,
- ok = guild_member_list_engine:update_member(
- Ref, UserId, engine_sort_key(I), engine_roles_for_test_member(I), false
- )
- end,
- lists:seq(1, 60)
- ),
- Expected = lists:seq(100001, 100480) ++ lists:seq(200001, 200060),
- ?assertEqual(Expected, lists:sort(guild_member_list_engine:get_sorted_user_ids(Ref))),
- ?assertEqual({540, 0}, guild_member_list_engine:get_counts(Ref))
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-default_groups(OnlineCount, OfflineCount) ->
- [{<<"online">>, OnlineCount}, {<<"offline">>, OfflineCount}].
-
-role_groups(RoleCounts, OnlineCount, OfflineCount) ->
- RoleGroups = [{integer_to_binary(RoleId), Count} || {RoleId, Count} <- RoleCounts],
- RoleGroups ++ default_groups(OnlineCount, OfflineCount).
-
-alice_online_bob_offline() ->
- [
- {1, <<"alice">>, [], true},
- {2, <<"bob">>, [], false}
- ].
-
-assert_groups(Expected, Ref) ->
- ?assertEqual(Expected, guild_member_list_engine:get_groups(Ref)).
-
-index_of_matches_display_position_test() ->
- Ref = guild_member_list_engine:new(),
- Hoisted = [100, 200],
- Members = [
- {1, <<"alice">>, [100], true},
- {2, <<"bob">>, [], true},
- {3, <<"carol">>, [200], true},
- {4, <<"dave">>, [], false},
- {5, <<"eve">>, [100], false},
- {6, <<"frank">>, [], true},
- {7, <<"grace">>, [200], true}
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, Hoisted),
- assert_index_of_matches(Ref, Members),
- ?assertEqual(not_found, guild_member_list_engine:index_of(Ref, 9999)),
- guild_member_list_engine:destroy(Ref).
-
-index_of_random_test_() ->
- {timeout, 60, fun() ->
- rand:seed(exsss, {51, 52, 53}),
- lists:foreach(fun(_) -> run_index_of_random() end, lists:seq(1, 5))
- end}.
-
-run_index_of_random() ->
- Ref = guild_member_list_engine:new(),
- Hoisted = [100, 200, 300],
- N = 200 + rand:uniform(300),
- Members = [
- {Id, idx_sort_key(Id), idx_rand_roles(), rand:uniform(3) =/= 1}
- || Id <- lists:seq(1, N)
- ],
- ok = guild_member_list_engine:bulk_load(Ref, Members, Hoisted),
- assert_index_of_matches(Ref, Members),
- guild_member_list_engine:destroy(Ref).
-
-assert_index_of_matches(Ref, Members) ->
- Items = guild_member_list_engine:get_items(Ref, 0, 1000000),
- Positions = item_positions(Items),
- lists:foreach(
- fun({UserId, _, _, _}) ->
- Exp = maps:get(UserId, Positions, not_in_list),
- ?assertEqual(
- {UserId, Exp}, {UserId, guild_member_list_engine:index_of(Ref, UserId)}
- )
- end,
- Members
- ).
-
-item_positions(Items) ->
- {_, Map} = lists:foldl(
- fun
- ({member, UserId}, {I, Acc}) -> {I + 1, Acc#{UserId => I}};
- ({group, _, _}, {I, Acc}) -> {I + 1, Acc}
- end,
- {0, #{}},
- Items
- ),
- Map.
-
-idx_sort_key(Id) ->
- integer_to_binary(rand:uniform(1000000) * 100 + (Id rem 100)).
-
-idx_rand_roles() ->
- case rand:uniform(4) of
- 1 -> [100];
- 2 -> [200];
- 3 -> [300];
- 4 -> []
- end.
-
-engine_sort_key(UserId) ->
- iolist_to_binary(io_lib:format("member_~4..0B", [UserId])).
-
-engine_roles_for_test_member(UserId) when UserId rem 3 =:= 0 ->
- [10];
-engine_roles_for_test_member(UserId) when UserId rem 5 =:= 0 ->
- [20];
-engine_roles_for_test_member(_UserId) ->
- [].
-
-version_bumps_on_every_mutation_test() ->
- Ref = guild_member_list_engine:new(),
- try
- V0 = guild_member_list_engine:version(Ref),
- ok = guild_member_list_engine:bulk_load(Ref, [{1, <<"a">>, [], true}], []),
- V1 = guild_member_list_engine:version(Ref),
- ok = guild_member_list_engine:add_member(Ref, 2, <<"b">>, [], false),
- V2 = guild_member_list_engine:version(Ref),
- ok = guild_member_list_engine:update_member(Ref, 2, <<"c">>, [], false),
- V3 = guild_member_list_engine:version(Ref),
- ok = guild_member_list_engine:set_online(Ref, 2, true),
- V4 = guild_member_list_engine:version(Ref),
- changed = guild_member_list_engine:set_hoisted_roles(Ref, [7]),
- V5 = guild_member_list_engine:version(Ref),
- ok = guild_member_list_engine:remove_member(Ref, 1),
- V6 = guild_member_list_engine:version(Ref),
- Versions = [V0, V1, V2, V3, V4, V5, V6],
- ?assertEqual(Versions, lists:usort(Versions)),
- ?assertEqual(7, length(lists:usort(Versions)))
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-version_is_stable_for_noop_mutations_test() ->
- Ref = guild_member_list_engine:new(),
- try
- ok = guild_member_list_engine:add_member(Ref, 1, <<"a">>, [], true),
- V = guild_member_list_engine:version(Ref),
- ok = guild_member_list_engine:set_online(Ref, 1, true),
- ok = guild_member_list_engine:set_online(Ref, 99, false),
- ok = guild_member_list_engine:remove_member(Ref, 99),
- unchanged = guild_member_list_engine:set_hoisted_roles(Ref, []),
- _ = guild_member_list_engine:get_items(Ref, 0, 10),
- ?assertEqual(V, guild_member_list_engine:version(Ref))
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-version_survives_tables_without_a_version_row_test() ->
- Ref = guild_member_list_engine:new(),
- try
- true = ets:delete(Ref, version),
- ?assertEqual(undefined, guild_member_list_engine:version(Ref)),
- ok = guild_member_list_engine:add_member(Ref, 1, <<"a">>, [], true),
- ?assertEqual(1, guild_member_list_engine:version(Ref))
- after
- guild_member_list_engine:destroy(Ref)
- end,
- ?assertEqual(undefined, guild_member_list_engine:version(Ref)).
diff --git a/fluxer_gateway/test/guild_member_list_fanout_tests.erl b/fluxer_gateway/test/guild_member_list_fanout_tests.erl
deleted file mode 100644
index bb0d39db1..000000000
--- a/fluxer_gateway/test/guild_member_list_fanout_tests.erl
+++ /dev/null
@@ -1,204 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_member_list_fanout_tests).
--typing([eqwalizer]).
--include_lib("eunit/include/eunit.hrl").
-
-batched_member_list_fanout_coalesces_test_() ->
- {timeout, 180, fun() ->
- with_batched_fanout_relay_mock(fun() ->
- batched_fanout_case(identical_ranges, 16, 128, 5000),
- batched_fanout_case(unique_ranges, 16, 128, 5000)
- end)
- end}.
-
-batched_fanout_case(RangeMode, ChannelCount, SessionsPerChannel, MemberCount) ->
- {State, SubsTab} = batched_fanout_state(
- RangeMode, ChannelCount, SessionsPerChannel, MemberCount
- ),
- ExpectedDispatches = expected_batched_fanout_dispatches(
- RangeMode, ChannelCount, SessionsPerChannel
- ),
- try
- {ok, QueuedState} = guild_member_list_write:broadcast_all_member_list_updates(State),
- FlushedState = guild_member_list_write:flush_pending_member_list_syncs(QueuedState),
- {Dispatches, Recipients, Bytes} = collect_batched_fanout_dispatches(
- ExpectedDispatches
- ),
- assert_no_batched_fanout_dispatch(),
- ?assertEqual(ExpectedDispatches, Dispatches),
- ?assertEqual(ChannelCount * SessionsPerChannel, Recipients),
- ?assert(Bytes > 0),
- FlushedState
- after
- guild_member_list_subs:destroy(SubsTab),
- guild_member_list_channel_engine:destroy_all(State)
- end.
-
-expected_batched_fanout_dispatches(identical_ranges, ChannelCount, _SessionsPerChannel) ->
- ChannelCount;
-expected_batched_fanout_dispatches(unique_ranges, ChannelCount, SessionsPerChannel) ->
- ChannelCount * SessionsPerChannel.
-
-batched_fanout_state(RangeMode, ChannelCount, SessionsPerChannel, MemberCount) ->
- GuildId = 424242,
- ChannelIds = lists:seq(700000, 700000 + ChannelCount - 1),
- MemberIds = lists:seq(1, MemberCount),
- Members = [fanout_member(UserId) || UserId <- MemberIds],
- SubsTab = guild_member_list_subs:new(),
- Sessions = batched_fanout_sessions(
- RangeMode, ChannelIds, SessionsPerChannel, SubsTab, MemberIds
- ),
- State = #{
- id => GuildId,
- member_count => MemberCount,
- sessions => Sessions,
- connected_user_ids => sets:from_list(MemberIds),
- member_presence => maps:from_list([
- {UserId, #{<<"status">> => <<"online">>, <<"mobile">> => false}}
- || UserId <- MemberIds
- ]),
- member_list_subscriptions => SubsTab,
- data => #{
- <<"guild">> => #{
- <<"id">> => integer_to_binary(GuildId),
- <<"owner_id">> => <<"1">>,
- <<"features">> => [],
- <<"member_count">> => MemberCount
- },
- <<"roles">> => [fanout_everyone_role(GuildId)],
- <<"channels">> => [fanout_channel(ChannelId) || ChannelId <- ChannelIds],
- <<"members">> => Members
- },
- channel_member_list_engines => #{}
- },
- {State, SubsTab}.
-
-batched_fanout_sessions(RangeMode, ChannelIds, SessionsPerChannel, SubsTab, MemberIds) ->
- ViewableChannels = maps:from_list([{ChannelId, true} || ChannelId <- ChannelIds]),
- maps:from_list(
- lists:append([
- batched_fanout_channel_sessions(
- RangeMode, ChannelId, SessionsPerChannel, SubsTab, MemberIds, ViewableChannels
- )
- || ChannelId <- ChannelIds
- ])
- ).
-
-batched_fanout_channel_sessions(
- RangeMode, ChannelId, SessionsPerChannel, SubsTab, MemberIds, ViewableChannels
-) ->
- [
- batched_fanout_session_entry(
- RangeMode, ChannelId, SessionIdx, SubsTab, MemberIds, ViewableChannels
- )
- || SessionIdx <- lists:seq(1, SessionsPerChannel)
- ].
-
-batched_fanout_session_entry(
- RangeMode, ChannelId, SessionIdx, SubsTab, MemberIds, ViewableChannels
-) ->
- SessionId = batched_fanout_session_id(ChannelId, SessionIdx),
- Ranges = batched_fanout_ranges(RangeMode, SessionIdx),
- {_OldRanges, _ShouldSync} = guild_member_list_subs:subscribe(
- SessionId, integer_to_binary(ChannelId), Ranges, SubsTab
- ),
- {SessionId, #{
- pid => self(),
- user_id => lists:nth(((SessionIdx - 1) rem length(MemberIds)) + 1, MemberIds),
- viewable_channels => ViewableChannels
- }}.
-
-batched_fanout_session_id(ChannelId, SessionIdx) ->
- <<"fanout_", (integer_to_binary(ChannelId))/binary, "_",
- (integer_to_binary(SessionIdx))/binary>>.
-
-batched_fanout_ranges(identical_ranges, _SessionIdx) ->
- [{0, 99}];
-batched_fanout_ranges(unique_ranges, SessionIdx) ->
- Start = SessionIdx * 2,
- [{Start, Start}].
-
-fanout_everyone_role(GuildId) ->
- #{
- <<"id">> => GuildId,
- <<"name">> => <<"everyone">>,
- <<"permissions">> =>
- constants:view_channel_permission() bor constants:view_channel_members_permission(),
- <<"hoist">> => false,
- <<"position">> => 0
- }.
-
-fanout_channel(ChannelId) ->
- #{
- <<"id">> => ChannelId,
- <<"name">> => <<"fanout">>,
- <<"type">> => 0,
- <<"permission_overwrites">> => []
- }.
-
-fanout_member(UserId) ->
- UserIdBin = integer_to_binary(UserId),
- #{
- <<"user">> => #{
- <<"id">> => UserIdBin,
- <<"username">> => <<"fanout_user_", UserIdBin/binary>>
- },
- <<"roles">> => []
- }.
-
-with_batched_fanout_relay_mock(Fun) ->
- meck:new(gateway_dispatch_relay, [passthrough, no_link]),
- Parent = self(),
- Ref = make_ref(),
- put(batched_fanout_ref, Ref),
- meck:expect(
- gateway_dispatch_relay,
- dispatch_many,
- fun(Pids, guild_member_list_update, Payload, _GuildId) ->
- Parent ! {batched_fanout_dispatch, Ref, length(Pids), payload_bytes(Payload)},
- ok
- end
- ),
- try
- Fun()
- after
- erase(batched_fanout_ref),
- meck:unload(gateway_dispatch_relay)
- end.
-
-payload_bytes({pre_encoded, Bin}) when is_binary(Bin) ->
- byte_size(Bin);
-payload_bytes(Bin) when is_binary(Bin) ->
- byte_size(Bin);
-payload_bytes(_) ->
- 0.
-
-collect_batched_fanout_dispatches(ExpectedCount) ->
- Ref = get(batched_fanout_ref),
- collect_batched_fanout_dispatches(ExpectedCount, Ref, 0, 0, 0).
-
-collect_batched_fanout_dispatches(0, _Ref, Dispatches, Recipients, Bytes) ->
- {Dispatches, Recipients, Bytes};
-collect_batched_fanout_dispatches(ExpectedCount, Ref, Dispatches, Recipients, Bytes) ->
- receive
- {batched_fanout_dispatch, Ref, PidCount, PayloadBytes} ->
- collect_batched_fanout_dispatches(
- ExpectedCount - 1,
- Ref,
- Dispatches + 1,
- Recipients + PidCount,
- Bytes + PayloadBytes
- )
- after 30000 ->
- error({batched_fanout_dispatch_timeout, ExpectedCount})
- end.
-
-assert_no_batched_fanout_dispatch() ->
- Ref = get(batched_fanout_ref),
- receive
- {batched_fanout_dispatch, Ref, PidCount, PayloadBytes} ->
- ?assert(false, {unexpected_batched_fanout_dispatch, PidCount, PayloadBytes})
- after 100 ->
- ok
- end.
diff --git a/fluxer_gateway/test/guild_member_list_oset_tests.erl b/fluxer_gateway/test/guild_member_list_oset_tests.erl
deleted file mode 100644
index 067264f14..000000000
--- a/fluxer_gateway/test/guild_member_list_oset_tests.erl
+++ /dev/null
@@ -1,264 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_member_list_oset_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
-empty_test() ->
- O = guild_member_list_oset:new(),
- ?assertEqual(0, guild_member_list_oset:size(O)),
- ?assertEqual(none, guild_member_list_oset:at(O, 0)),
- ?assertEqual(none, guild_member_list_oset:at(O, -1)),
- ?assertEqual(not_found, guild_member_list_oset:rank(O, key(<<"a">>, 1))),
- ?assertEqual(not_found, guild_member_list_oset:delete(O, key(<<"a">>, 1))),
- ?assertEqual([], guild_member_list_oset:range(O, 0, 10)),
- ?assertEqual([], guild_member_list_oset:to_list(O)),
- guild_member_list_oset:destroy(O).
-
-single_test() ->
- O = guild_member_list_oset:new(),
- ?assertEqual(0, guild_member_list_oset:insert(O, key(<<"b">>, 2))),
- ?assertEqual(1, guild_member_list_oset:size(O)),
- ?assertEqual(0, guild_member_list_oset:rank(O, key(<<"b">>, 2))),
- ?assertEqual(key(<<"b">>, 2), guild_member_list_oset:at(O, 0)),
- ?assertEqual(none, guild_member_list_oset:at(O, 1)),
- ?assertEqual([key(<<"b">>, 2)], guild_member_list_oset:range(O, 0, 10)),
- ?assertEqual(0, guild_member_list_oset:insert(O, key(<<"b">>, 2))),
- ?assertEqual(1, guild_member_list_oset:size(O)),
- ?assertEqual(0, guild_member_list_oset:delete(O, key(<<"b">>, 2))),
- ?assertEqual(0, guild_member_list_oset:size(O)),
- ?assertEqual(not_found, guild_member_list_oset:delete(O, key(<<"b">>, 2))),
- guild_member_list_oset:destroy(O).
-
-ordering_and_index_test() ->
- O = ordering_oset(),
- ?assertEqual(ordering_expected(), guild_member_list_oset:to_list(O)),
- ?assertEqual(3, guild_member_list_oset:rank(O, key(<<"n">>, 6))),
- ?assertEqual(key(<<"m">>, 5), guild_member_list_oset:at(O, 2)),
- ?assertEqual([key(<<"b">>, 2), key(<<"m">>, 5)], guild_member_list_oset:range(O, 1, 2)),
- guild_member_list_oset:destroy(O).
-
-delete_reindexes_test() ->
- O = ordering_oset(),
- ?assertEqual(2, guild_member_list_oset:delete(O, key(<<"m">>, 5))),
- ?assertEqual(
- [key(<<"a">>, 1), key(<<"b">>, 2), key(<<"n">>, 6), key(<<"z">>, 9)],
- guild_member_list_oset:to_list(O)
- ),
- ?assertEqual(2, guild_member_list_oset:rank(O, key(<<"n">>, 6))),
- guild_member_list_oset:destroy(O).
-
-range_edges_test() ->
- O = from_list([key(<<"k">>, N) || N <- lists:seq(1, 10)]),
- ?assertEqual(
- [key(<<"k">>, 1), key(<<"k">>, 2), key(<<"k">>, 3)],
- guild_member_list_oset:range(O, 0, 3)
- ),
- ?assertEqual([key(<<"k">>, 9), key(<<"k">>, 10)], guild_member_list_oset:range(O, 8, 100)),
- ?assertEqual([], guild_member_list_oset:range(O, 10, 5)),
- ?assertEqual([], guild_member_list_oset:range(O, 100, 5)),
- ?assertEqual([], guild_member_list_oset:range(O, 0, 0)),
- ?assertEqual([key(<<"k">>, 1), key(<<"k">>, 2)], guild_member_list_oset:range(O, -3, 5)),
- guild_member_list_oset:destroy(O).
-
-range_pages_large_requested_count_test() ->
- Keys = [key(<<"k">>, N) || N <- lists:seq(1, 70000)],
- O = from_sorted_oset(Keys),
- try
- Got = guild_member_list_oset:range(O, 0, 1000000),
- ?assertEqual(70000, length(Got)),
- ?assertEqual(Keys, Got),
- ?assertEqual(
- [key(<<"k">>, N) || N <- lists:seq(65530, 65540)],
- guild_member_list_oset:range(O, 65529, 11)
- )
- after
- guild_member_list_oset:destroy(O)
- end.
-
-prop_small_keyspace_test_() ->
- {timeout, 120, fun() -> run_prop({1, 2, 3}, 200, 8000) end}.
-
-prop_large_keyspace_test_() ->
- {timeout, 120, fun() -> run_prop({4, 5, 6}, 20000, 8000) end}.
-
-large_build_test_() ->
- {timeout, 120, fun() ->
- N = 100000,
- O = guild_member_list_oset:new(),
- Keys = [key(<<"u">>, K) || K <- shuffled(lists:seq(1, N), {7, 8, 9})],
- lists:foreach(fun(K) -> guild_member_list_oset:insert(O, K) end, Keys),
- ?assertEqual(N, guild_member_list_oset:size(O)),
- ?assertEqual(key(<<"u">>, 1), guild_member_list_oset:at(O, 0)),
- ?assertEqual(key(<<"u">>, N), guild_member_list_oset:at(O, N - 1)),
- ?assertEqual(N - 1, guild_member_list_oset:rank(O, key(<<"u">>, N))),
- ?assertEqual(49999, guild_member_list_oset:rank(O, key(<<"u">>, 50000))),
- ?assertEqual(
- [key(<<"u">>, 50001), key(<<"u">>, 50002)],
- guild_member_list_oset:range(O, 50000, 2)
- ),
- ?assertEqual(none, guild_member_list_oset:at(O, N)),
- guild_member_list_oset:destroy(O)
- end}.
-
-from_sorted_equivalence_test() ->
- rand:seed(exsss, {31, 32, 33}),
- Keys = [key(<<"k">>, K) || K <- lists:seq(1, 500)],
- OBulk = from_sorted_oset(Keys),
- OIns = from_list(shuffled(Keys, {34, 35, 36})),
- ?assertEqual(Keys, guild_member_list_oset:to_list(OBulk)),
- ?assertEqual(guild_member_list_oset:to_list(OIns), guild_member_list_oset:to_list(OBulk)),
- assert_consistent(OBulk, Keys),
- guild_member_list_oset:destroy(OBulk),
- guild_member_list_oset:destroy(OIns).
-
-from_sorted_then_mutate_test_() ->
- {timeout, 120, fun() ->
- rand:seed(exsss, {41, 42, 43}),
- InitKeys = [key(<<"k">>, K) || K <- lists:seq(1, 1000)],
- O = from_sorted_oset(InitKeys),
- assert_consistent(O, InitKeys),
- Ref = run_ops(O, InitKeys, 2000, 6000),
- assert_consistent(O, Ref),
- guild_member_list_oset:destroy(O)
- end}.
-
-from_sorted_scale_test_() ->
- {timeout, 120, fun() ->
- N = 100000,
- Keys = [key(<<"u">>, K) || K <- lists:seq(1, N)],
- O = from_sorted_oset(Keys),
- ?assertEqual(N, guild_member_list_oset:size(O)),
- ?assertEqual(key(<<"u">>, 1), guild_member_list_oset:at(O, 0)),
- ?assertEqual(key(<<"u">>, N), guild_member_list_oset:at(O, N - 1)),
- ?assertEqual(N - 1, guild_member_list_oset:rank(O, key(<<"u">>, N))),
- ?assertEqual(49999, guild_member_list_oset:rank(O, key(<<"u">>, 50000))),
- ?assertEqual(
- [key(<<"u">>, 50001), key(<<"u">>, 50002)],
- guild_member_list_oset:range(O, 50000, 2)
- ),
- ?assertEqual(50000, guild_member_list_oset:delete(O, key(<<"u">>, 50001))),
- ?assertEqual(N - 1, guild_member_list_oset:size(O)),
- ?assertEqual(50000, guild_member_list_oset:insert(O, key(<<"u">>, 50001))),
- ?assertEqual(N, guild_member_list_oset:size(O)),
- guild_member_list_oset:destroy(O)
- end}.
-
-from_sorted_empty_test() ->
- O = guild_member_list_oset:new(),
- ok = guild_member_list_oset:from_sorted(O, []),
- ?assertEqual(0, guild_member_list_oset:size(O)),
- ?assertEqual(0, guild_member_list_oset:insert(O, key(<<"a">>, 1))),
- ?assertEqual([key(<<"a">>, 1)], guild_member_list_oset:to_list(O)),
- guild_member_list_oset:destroy(O).
-
-run_prop(Seed, KeySpace, Ops) ->
- rand:seed(exsss, Seed),
- O = guild_member_list_oset:new(),
- Ref = run_ops(O, [], KeySpace, Ops),
- assert_consistent(O, Ref),
- guild_member_list_oset:destroy(O).
-
-run_ops(_O, Ref, _KeySpace, 0) ->
- Ref;
-run_ops(O, Ref, KeySpace, N) ->
- Key = key(<<"k">>, rand:uniform(KeySpace)),
- Ref1 =
- case rand:uniform(2) of
- 1 ->
- Idx = guild_member_list_oset:insert(O, Key),
- {ExpIdx, R} = ref_insert(Ref, Key),
- ?assertEqual({insert, Key, ExpIdx}, {insert, Key, Idx}),
- R;
- 2 ->
- Res = guild_member_list_oset:delete(O, Key),
- {ExpRes, R} = ref_delete(Ref, Key),
- ?assertEqual({delete, Key, ExpRes}, {delete, Key, Res}),
- R
- end,
- case N rem 250 of
- 0 -> assert_consistent(O, Ref1);
- _ -> ok
- end,
- run_ops(O, Ref1, KeySpace, N - 1).
-
-assert_consistent(O, Ref) ->
- ?assertEqual(length(Ref), guild_member_list_oset:size(O)),
- ?assertEqual(Ref, guild_member_list_oset:to_list(O)),
- lists:foldl(
- fun(Key, I) ->
- ?assertEqual({rank, Key, I}, {rank, Key, guild_member_list_oset:rank(O, Key)}),
- ?assertEqual({at, I, Key}, {at, I, guild_member_list_oset:at(O, I)}),
- I + 1
- end,
- 0,
- Ref
- ),
- case Ref of
- [] ->
- ok;
- _ ->
- L = length(Ref),
- Start = rand:uniform(L) - 1,
- Count = rand:uniform(L),
- ?assertEqual(
- lists:sublist(Ref, Start + 1, Count),
- guild_member_list_oset:range(O, Start, Count)
- )
- end.
-
-ref_insert(Ref, Key) ->
- case index_of(Key, Ref, 0) of
- {found, I} -> {I, Ref};
- notfound -> ref_insert_sorted(Ref, Key, 0, [])
- end.
-
-ref_insert_sorted([H | T], Key, I, Acc) when H < Key ->
- ref_insert_sorted(T, Key, I + 1, [H | Acc]);
-ref_insert_sorted(Rest, Key, I, Acc) ->
- {I, lists:reverse(Acc) ++ [Key | Rest]}.
-
-ref_delete(Ref, Key) ->
- case index_of(Key, Ref, 0) of
- {found, I} -> {I, lists:delete(Key, Ref)};
- notfound -> {not_found, Ref}
- end.
-
-index_of(_Key, [], _I) -> notfound;
-index_of(Key, [Key | _], I) -> {found, I};
-index_of(Key, [_ | T], I) -> index_of(Key, T, I + 1).
-
-from_list(Keys) ->
- O = guild_member_list_oset:new(),
- lists:foreach(fun(K) -> guild_member_list_oset:insert(O, K) end, Keys),
- O.
-
-from_sorted_oset(SortedKeys) ->
- O = guild_member_list_oset:new(),
- guild_member_list_oset:from_sorted(O, SortedKeys),
- O.
-
-ordering_oset() ->
- from_list([
- key(<<"m">>, 5),
- key(<<"a">>, 1),
- key(<<"z">>, 9),
- key(<<"n">>, 6),
- key(<<"b">>, 2)
- ]).
-
-ordering_expected() ->
- [
- key(<<"a">>, 1),
- key(<<"b">>, 2),
- key(<<"m">>, 5),
- key(<<"n">>, 6),
- key(<<"z">>, 9)
- ].
-
-shuffled(L, Seed) ->
- rand:seed(exsss, Seed),
- [X || {_, X} <- lists:sort([{rand:uniform(), E} || E <- L])].
-
-key(SortKey, UserId) ->
- {0, SortKey, UserId}.
diff --git a/fluxer_gateway/test/guild_member_list_tests.erl b/fluxer_gateway/test/guild_member_list_tests.erl
deleted file mode 100644
index 263caa0f4..000000000
--- a/fluxer_gateway/test/guild_member_list_tests.erl
+++ /dev/null
@@ -1,594 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_member_list_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-get_members_cursor_returns_atom_keys_test() ->
- Member1 = #{<<"user">> => #{<<"id">> => <<"2">>}},
- Member2 = #{<<"user">> => #{<<"id">> => <<"1">>}},
- State = #{data => #{<<"members">> => [Member1, Member2]}},
- {reply, Reply, _NewState} = guild_member_list_read:get_members_cursor(
- #{<<"limit">> => 1}, State
- ),
- ?assert(maps:is_key(members, Reply)),
- ?assert(maps:is_key(total, Reply)),
- ?assertNot(maps:is_key(<<"members">>, Reply)),
- ?assertNot(maps:is_key(<<"total">>, Reply)).
-
-get_members_cursor_with_after_test() ->
- Members = [
- #{<<"user">> => #{<<"id">> => <<"1">>}},
- #{<<"user">> => #{<<"id">> => <<"2">>}},
- #{<<"user">> => #{<<"id">> => <<"3">>}}
- ],
- State = #{data => #{<<"members">> => Members}},
- {reply, Reply, _} = guild_member_list_read:get_members_cursor(
- #{<<"limit">> => 10, <<"after">> => 1}, State
- ),
- ReturnedMembers = maps:get(members, Reply),
- ?assertEqual(2, length(ReturnedMembers)),
- Ids = [guild_member_list_common:get_member_user_id(M) || M <- ReturnedMembers],
- ?assert(lists:all(fun(Id) -> Id > 1 end, Ids)).
-
-get_members_cursor_empty_guild_test() ->
- State = #{data => #{<<"members">> => []}},
- {reply, Reply, _} = guild_member_list_read:get_members_cursor(#{<<"limit">> => 10}, State),
- ?assertEqual([], maps:get(members, Reply)),
- ?assertEqual(0, maps:get(total, Reply)).
-
-get_members_cursor_zero_limit_test() ->
- Members = [#{<<"user">> => #{<<"id">> => <<"1">>}}],
- State = #{data => #{<<"members">> => Members}},
- {reply, Reply, _} = guild_member_list_read:get_members_cursor(#{<<"limit">> => 0}, State),
- ?assertEqual([], maps:get(members, Reply)).
-
-get_members_cursor_after_last_member_test() ->
- Members = [
- #{<<"user">> => #{<<"id">> => <<"1">>}},
- #{<<"user">> => #{<<"id">> => <<"2">>}}
- ],
- State = #{data => #{<<"members">> => Members}},
- {reply, Reply, _} = guild_member_list_read:get_members_cursor(
- #{<<"limit">> => 10, <<"after">> => 999}, State
- ),
- ?assertEqual([], maps:get(members, Reply)).
-
-subscribe_builds_channel_store_lazily_test() ->
- State = base_state(make_subs_tab()),
- {NewState, ShouldSync, Ranges} =
- guild_member_list_subscribe:subscribe_ranges(<<"s1">>, <<"500">>, [{0, 99}], State),
- try
- Engines = maps:get(channel_member_list_engines, NewState, #{}),
- ?assertEqual(true, ShouldSync),
- ?assertEqual([{0, 99}], Ranges),
- ?assert(maps:is_key(<<"500">>, Engines)),
- ?assertEqual(#{}, maps:get(channel_member_list_engines, State, #{}))
- after
- guild_member_list_channel_engine:destroy_all(NewState)
- end.
-
-subscribe_prunes_other_session_channel_lists_test() ->
- SubsTab = make_subs_tab(),
- State0 = base_state(SubsTab),
- {State1, true, [{0, 99}]} =
- guild_member_list_subscribe:subscribe_ranges(<<"s1">>, <<"500">>, [{0, 99}], State0),
- {State2, true, [{10, 20}]} =
- guild_member_list_subscribe:subscribe_ranges(<<"s1">>, <<"600">>, [{10, 20}], State1),
- try
- Engines = maps:get(channel_member_list_engines, State2, #{}),
- ?assertNot(guild_member_list_subs:is_subscribed(<<"500">>, <<"s1">>, SubsTab)),
- ?assert(guild_member_list_subs:is_subscribed(<<"600">>, <<"s1">>, SubsTab)),
- ?assertNot(maps:is_key(<<"500">>, Engines)),
- ?assert(maps:is_key(<<"600">>, Engines))
- after
- guild_member_list_channel_engine:destroy_all(State2)
- end.
-
-unsubscribe_last_session_drops_channel_store_test() ->
- Ref = guild_member_list_engine:new(),
- State = (base_state(make_subs_tab([{<<"500">>, <<"s1">>, [{0, 99}]}])))#{
- channel_member_list_engines => #{<<"500">> => Ref}
- },
- NewState = guild_member_list_subscribe:unsubscribe_session(<<"s1">>, State),
- Engines = maps:get(channel_member_list_engines, NewState, #{}),
- ?assertNot(maps:is_key(<<"500">>, Engines)),
- ?assertEqual(undefined, ets:info(Ref, name)).
-
-empty_ranges_subscribe_drops_channel_engine_test() ->
- Ref = guild_member_list_engine:new(),
- State = (base_state(make_subs_tab([{<<"500">>, <<"s1">>, [{0, 99}]}])))#{
- channel_member_list_engines => #{<<"500">> => Ref}
- },
- {NewState, _ShouldSync, _Ranges} = guild_member_list_subscribe:subscribe_ranges(
- <<"s1">>, <<"500">>, [], State
- ),
- Engines = maps:get(channel_member_list_engines, NewState, #{}),
- ?assertNot(maps:is_key(<<"500">>, Engines)),
- ?assertEqual(undefined, ets:info(Ref, name)).
-
-broadcast_channel_list_dispatches_sync_immediately_test() ->
- with_sync_dispatch_mock(fun run_broadcast_channel_list_dispatches_sync_immediately/0).
-
-run_broadcast_channel_list_dispatches_sync_immediately() ->
- Ref = guild_member_list_engine:new(),
- try
- Member = #{
- <<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"one">>},
- <<"roles">> => []
- },
- ok = guild_member_list_engine:bulk_load(Ref, [{1, <<"one">>, [], true}], []),
- OldState = channel_list_state(Ref, make_subs_tab([{<<"500">>, <<"s1">>, [{0, 99}]}]), [
- Member
- ]),
- NewState = OldState#{member_presence => #{1 => #{<<"status">> => <<"online">>}}},
- {ok, QueuedState} = guild_member_list_write:broadcast_member_list_updates(
- 1, OldState, NewState
- ),
- ?assertNot(maps:is_key(pending_member_list_sync_batch, QueuedState)),
- assert_single_channel_sync_dispatch(NewState, QueuedState),
- FlushedState = guild_member_list_write:flush_pending_member_list_syncs(QueuedState),
- ?assertNot(maps:is_key(pending_member_list_sync_batch, FlushedState)),
- assert_no_sync_dispatch()
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-broadcast_channel_list_fans_out_repeated_syncs_test() ->
- with_sync_dispatch_mock(fun run_broadcast_channel_list_fans_out_repeated_syncs/0).
-
-run_broadcast_channel_list_fans_out_repeated_syncs() ->
- Ref = guild_member_list_engine:new(),
- try
- Members = [
- #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"one">>}},
- #{<<"user">> => #{<<"id">> => <<"2">>, <<"username">> => <<"two">>}}
- ],
- ok = guild_member_list_engine:bulk_load(
- Ref, [{1, <<"one">>, [], true}, {2, <<"two">>, [], true}], []
- ),
- OldState = channel_list_state(
- Ref, make_subs_tab([{<<"500">>, <<"s1">>, [{0, 99}]}]), Members
- ),
- NewState1 = OldState#{coalesce_marker => first},
- {ok, QueuedState1} = guild_member_list_write:broadcast_member_list_updates(
- 1, OldState, NewState1
- ),
- ?assertNot(maps:is_key(pending_member_list_sync_batch, QueuedState1)),
- assert_channel_sync_dispatch_marker(first, QueuedState1),
- NewState2 = QueuedState1#{coalesce_marker => final},
- {ok, QueuedState2} = guild_member_list_write:broadcast_member_list_updates(
- 2, QueuedState1, NewState2
- ),
- ?assertNot(maps:is_key(pending_member_list_sync_batch, QueuedState2)),
- assert_channel_sync_dispatch_marker(final, QueuedState2),
- FlushedState = guild_member_list_write:flush_pending_member_list_syncs(QueuedState2),
- ?assertEqual(QueuedState2, FlushedState),
- assert_no_sync_dispatch()
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-sync_batch_fans_out_each_subscribed_channel_list_test() ->
- with_sync_dispatch_mock(fun run_sync_batch_fans_out_each_subscribed_channel_list/0).
-
-run_sync_batch_fans_out_each_subscribed_channel_list() ->
- Ref500 = guild_member_list_engine:new(),
- Ref600 = guild_member_list_engine:new(),
- try
- SubsTab = make_subs_tab([
- {<<"500">>, <<"s1">>, [{0, 99}]},
- {<<"600">>, <<"s2">>, [{10, 20}]}
- ]),
- State = two_channel_list_state(SubsTab, Ref500, Ref600),
- SyncedState = guild_member_list_sync_batch:queue_subscribed_list_syncs(State, SubsTab),
- ?assertEqual(State, SyncedState),
- ?assertNot(maps:is_key(pending_member_list_sync_batch, SyncedState)),
- Dispatches = collect_sync_dispatches(2),
- assert_no_sync_dispatch(),
- assert_channel_sync_dispatches(Dispatches)
- after
- guild_member_list_engine:destroy(Ref500),
- guild_member_list_engine:destroy(Ref600)
- end.
-
-sync_batch_fans_out_before_subscription_churn_test() ->
- with_sync_dispatch_mock(fun run_sync_batch_fans_out_before_subscription_churn/0).
-
-run_sync_batch_fans_out_before_subscription_churn() ->
- SubsTab = make_subs_tab(),
- State0 = base_state(SubsTab),
- {State1, true, [{0, 10}]} =
- guild_member_list_subscribe:subscribe_ranges(<<"s1">>, <<"500">>, [{0, 10}], State0),
- SyncedState = guild_member_list_sync_batch:queue_list_sync(<<"500">>, State1),
- assert_single_channel_sync_dispatch_with_ranges([{0, 10}], SyncedState),
- UnsubscribedState = guild_member_list_subscribe:unsubscribe_session(<<"s1">>, SyncedState),
- ?assertNot(
- maps:is_key(<<"500">>, maps:get(channel_member_list_engines, UnsubscribedState, #{}))
- ),
- {ResubscribedState, true, [{20, 30}]} =
- guild_member_list_subscribe:subscribe_ranges(
- <<"s1">>, <<"500">>, [{20, 30}], UnsubscribedState
- ),
- try
- FlushedState = guild_member_list_sync_batch:flush_pending_syncs(ResubscribedState),
- ?assertEqual(ResubscribedState, FlushedState),
- assert_no_sync_dispatch()
- after
- guild_member_list_channel_engine:destroy_all(ResubscribedState)
- end.
-
-sync_batch_skips_unsubscribed_lists_at_queue_time_test() ->
- with_sync_dispatch_mock(fun run_sync_batch_skips_unsubscribed_lists_at_queue_time/0).
-
-run_sync_batch_skips_unsubscribed_lists_at_queue_time() ->
- SubsTab = make_subs_tab(),
- State0 = base_state(SubsTab),
- {State1, true, _Ranges} =
- guild_member_list_subscribe:subscribe_ranges(<<"s1">>, <<"500">>, [{0, 99}], State0),
- _SyncedState = guild_member_list_sync_batch:queue_list_sync(<<"500">>, State1),
- _ = collect_sync_dispatches(1),
- UnsubscribedState = guild_member_list_subscribe:unsubscribe_session(<<"s1">>, State1),
- ResyncedState = guild_member_list_sync_batch:queue_list_sync(<<"500">>, UnsubscribedState),
- ?assertNot(maps:is_key(pending_member_list_sync_batch, ResyncedState)),
- ?assertNot(
- maps:is_key(<<"500">>, maps:get(channel_member_list_engines, ResyncedState, #{}))
- ),
- assert_no_sync_dispatch().
-
-guild_handle_info_flushes_stale_pending_member_list_batch_test() ->
- with_sync_dispatch_mock(
- fun run_guild_handle_info_flushes_stale_pending_member_list_batch/0
- ).
-
-run_guild_handle_info_flushes_stale_pending_member_list_batch() ->
- Ref = guild_member_list_engine:new(),
- try
- State = channel_list_state(Ref, make_subs_tab([{<<"500">>, <<"s1">>, [{0, 99}]}]), []),
- QueuedState = State#{
- pending_member_list_sync_batch => #{
- pending_list_ids => #{<<"500">> => true}
- }
- },
- {noreply, FlushedState} = guild:handle_info(flush_member_list_sync_batch, QueuedState),
- ?assertNot(maps:is_key(pending_member_list_sync_batch, FlushedState)),
- assert_single_channel_sync_dispatch(State, FlushedState),
- assert_no_sync_dispatch()
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-sync_batch_fans_out_large_subscribed_set_immediately_test() ->
- with_sync_dispatch_mock(fun run_sync_batch_fans_out_large_subscribed_set_immediately/0).
-
-run_sync_batch_fans_out_large_subscribed_set_immediately() ->
- ChannelIds = lists:seq(1000, 1063),
- {State, Refs} = stress_channel_list_state(ChannelIds, 4),
- SubsTab = maps:get(member_list_subscriptions, State),
- try
- SyncedState = guild_member_list_sync_batch:queue_subscribed_list_syncs(State, SubsTab),
- ?assertNot(maps:is_key(pending_member_list_sync_batch, SyncedState)),
- Dispatches = collect_sync_dispatches(length(ChannelIds)),
- assert_no_sync_dispatch(),
- assert_channel_sync_dispatches_for_ids(ChannelIds, Dispatches)
- after
- lists:foreach(fun guild_member_list_engine:destroy/1, Refs)
- end.
-
-broadcast_afk_only_change_skips_sync_test() ->
- with_sync_dispatch_mock(fun run_broadcast_afk_only_change_skips_sync/0).
-
-run_broadcast_afk_only_change_skips_sync() ->
- Ref = guild_member_list_engine:new(),
- try
- State = presence_delta_state(Ref),
- {ok, NewState} = guild_member_list_write:broadcast_member_list_updates(
- 1,
- State,
- State,
- presence_map(<<"online">>, false, false, null),
- presence_map(<<"online">>, false, true, null)
- ),
- ?assertEqual(State, NewState),
- assert_no_sync_dispatch()
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-broadcast_status_change_dispatches_sync_test() ->
- with_sync_dispatch_mock(fun run_broadcast_status_change_dispatches_sync/0).
-
-run_broadcast_status_change_dispatches_sync() ->
- Ref = guild_member_list_engine:new(),
- try
- State = presence_delta_state(Ref),
- {ok, NewState} = guild_member_list_write:broadcast_member_list_updates(
- 1,
- State,
- State,
- presence_map(<<"online">>, false, null),
- presence_map(<<"idle">>, false, null)
- ),
- assert_single_channel_sync_dispatch(State, NewState),
- assert_no_sync_dispatch()
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-broadcast_custom_status_change_dispatches_sync_test() ->
- with_sync_dispatch_mock(fun run_broadcast_custom_status_change_dispatches_sync/0).
-
-run_broadcast_custom_status_change_dispatches_sync() ->
- Ref = guild_member_list_engine:new(),
- try
- State = presence_delta_state(Ref),
- {ok, NewState} = guild_member_list_write:broadcast_member_list_updates(
- 1,
- State,
- State,
- presence_map(<<"online">>, false, null),
- presence_map(<<"online">>, false, #{<<"text">> => <<"hi">>})
- ),
- assert_single_channel_sync_dispatch(State, NewState),
- assert_no_sync_dispatch()
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-broadcast_offline_transition_dispatches_sync_test() ->
- with_sync_dispatch_mock(fun run_broadcast_offline_transition_dispatches_sync/0).
-
-run_broadcast_offline_transition_dispatches_sync() ->
- Ref = guild_member_list_engine:new(),
- try
- State = presence_delta_state(Ref),
- {ok, NewState} = guild_member_list_write:broadcast_member_list_updates(
- 1,
- State,
- State,
- presence_map(<<"online">>, false, null),
- presence_map(<<"offline">>, false, null)
- ),
- assert_single_channel_sync_dispatch(State, NewState),
- assert_no_sync_dispatch()
- after
- guild_member_list_engine:destroy(Ref)
- end.
-
-presence_delta_state(Ref) ->
- Member = #{
- <<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"one">>},
- <<"roles">> => []
- },
- ok = guild_member_list_engine:bulk_load(Ref, [{1, <<"one">>, [], true}], []),
- channel_list_state(Ref, make_subs_tab([{<<"500">>, <<"s1">>, [{0, 99}]}]), [Member]).
-
-presence_map(Status, Mobile, CustomStatus) ->
- presence_map(Status, Mobile, false, CustomStatus).
-
-presence_map(Status, Mobile, Afk, CustomStatus) ->
- #{
- <<"status">> => Status,
- <<"mobile">> => Mobile,
- <<"afk">> => Afk,
- <<"custom_status">> => CustomStatus
- }.
-
-channel_list_state(Ref, SubsTab, Members) ->
- (base_state(SubsTab))#{
- data => #{
- <<"members">> => Members,
- <<"channels">> => [#{<<"id">> => <<"500">>}]
- },
- channel_member_list_engines => #{<<"500">> => Ref}
- }.
-
-two_channel_list_state(SubsTab, Ref500, Ref600) ->
- (base_state(SubsTab))#{
- data => #{
- <<"channels">> => [#{<<"id">> => <<"500">>}, #{<<"id">> => <<"600">>}],
- <<"members">> => []
- },
- channel_member_list_engines => #{<<"500">> => Ref500, <<"600">> => Ref600}
- }.
-
-stress_channel_list_state(ChannelIds, SessionsPerChannel) ->
- SubEntries = stress_sub_entries(ChannelIds, SessionsPerChannel),
- SubsTab = make_subs_tab(SubEntries),
- RefsByListId = maps:from_list([
- {integer_to_binary(ChannelId), guild_member_list_engine:new()}
- || ChannelId <- ChannelIds
- ]),
- State = (base_state(SubsTab))#{
- data => #{
- <<"channels">> => [
- #{<<"id">> => integer_to_binary(ChannelId)}
- || ChannelId <- ChannelIds
- ],
- <<"members">> => []
- },
- channel_member_list_engines => RefsByListId,
- sessions => stress_sessions(SubEntries)
- },
- {State, maps:values(RefsByListId)}.
-
-stress_sub_entries(ChannelIds, SessionsPerChannel) ->
- [
- {
- integer_to_binary(ChannelId),
- stress_session_id(ChannelId, SessionIdx),
- stress_ranges(SessionIdx)
- }
- || ChannelId <- ChannelIds,
- SessionIdx <- lists:seq(1, SessionsPerChannel)
- ].
-
-stress_sessions(SubEntries) ->
- maps:from_list([
- {SessionId, #{pid => self(), user_id => 200000 + Idx}}
- || {Idx, {_ListId, SessionId, _Ranges}} <- lists:zip(
- lists:seq(1, length(SubEntries)), SubEntries
- )
- ]).
-
-stress_session_id(ChannelId, SessionIdx) ->
- <<"stress_", (integer_to_binary(ChannelId))/binary, "_",
- (integer_to_binary(SessionIdx))/binary>>.
-
-stress_ranges(SessionIdx) ->
- case SessionIdx rem 3 of
- 0 -> [{0, 20}, {15, 35}];
- 1 -> [{10, 30}];
- _ -> [{40, 55}, {56, 70}]
- end.
-
-assert_single_channel_sync_dispatch(NewState, FlushedState) ->
- receive
- {sync_dispatch, ListSubs, Sessions, 500, 100, DispatchState, SyncFun} ->
- ?assertEqual(#{<<"s1">> => [{0, 99}]}, ListSubs),
- ?assertEqual(maps:get(sessions, NewState), Sessions),
- ?assertEqual(FlushedState, DispatchState),
- Payload = SyncFun([{0, 99}]),
- ?assertEqual(<<"500">>, maps:get(<<"channel_id">>, Payload)),
- [Op] = maps:get(<<"ops">>, Payload),
- ?assertEqual(<<"SYNC">>, maps:get(<<"op">>, Op)),
- ?assertEqual([0, 99], maps:get(<<"range">>, Op))
- after 1000 ->
- ?assert(false)
- end.
-
-assert_single_channel_sync_dispatch_with_ranges(ExpectedRanges, FlushedState) ->
- receive
- {sync_dispatch, ListSubs, _Sessions, 500, 100, DispatchState, SyncFun} ->
- ?assertEqual(#{<<"s1">> => ExpectedRanges}, ListSubs),
- ?assertEqual(FlushedState, DispatchState),
- Payload = SyncFun(ExpectedRanges),
- [Op] = maps:get(<<"ops">>, Payload),
- [ExpectedRange] = ExpectedRanges,
- {Start, End} = ExpectedRange,
- ?assertEqual([Start, End], maps:get(<<"range">>, Op))
- after 1000 ->
- ?assert(false)
- end.
-
-assert_channel_sync_dispatch_marker(ExpectedMarker, ExpectedState) ->
- receive
- {sync_dispatch, _ListSubs, _Sessions, 500, 100, DispatchState, _SyncFun} ->
- ?assertEqual(ExpectedMarker, maps:get(coalesce_marker, DispatchState)),
- ?assertEqual(ExpectedState, DispatchState)
- after 1000 ->
- ?assert(false)
- end.
-
-assert_channel_sync_dispatches(Dispatches) ->
- ChannelIds = lists:sort([
- ChannelId
- || {sync_dispatch, _ListSubs, _Sessions, ChannelId, 100, _State, _SyncFun} <-
- Dispatches
- ]),
- ?assertEqual([500, 600], ChannelIds),
- lists:foreach(fun assert_channel_sync_dispatch/1, Dispatches).
-
-assert_channel_sync_dispatches_for_ids(ExpectedChannelIds, Dispatches) ->
- ChannelIds = lists:sort([
- ChannelId
- || {sync_dispatch, _ListSubs, _Sessions, ChannelId, 100, _State, _SyncFun} <-
- Dispatches
- ]),
- ?assertEqual(ExpectedChannelIds, ChannelIds),
- lists:foreach(fun assert_stress_channel_sync_dispatch/1, Dispatches).
-
-with_sync_dispatch_mock(Fun) ->
- meck:new(guild_member_list_subscribe, [passthrough, no_link]),
- meck:expect(
- guild_member_list_subscribe,
- dispatch_sync_to_subscribed_list,
- fun dispatch_sync_to_subscribed_list_mock/7
- ),
- try
- Fun()
- after
- meck:unload(guild_member_list_subscribe)
- end.
-
-dispatch_sync_to_subscribed_list_mock(
- ListId, SubsTab, Sessions, ChannelId, GuildId, State, SyncFun
-) ->
- ListSubs = guild_member_list_subs:get_list_subs(ListId, SubsTab),
- maybe_send_sync_dispatch(ListSubs, Sessions, ChannelId, GuildId, State, SyncFun),
- ok.
-
-maybe_send_sync_dispatch(ListSubs, _Sessions, _ChannelId, _GuildId, _State, _SyncFun) when
- map_size(ListSubs) =:= 0
-->
- ok;
-maybe_send_sync_dispatch(ListSubs, Sessions, ChannelId, GuildId, State, SyncFun) ->
- self() ! {sync_dispatch, ListSubs, Sessions, ChannelId, GuildId, State, SyncFun},
- ok.
-
-assert_channel_sync_dispatch(
- {sync_dispatch, ListSubs, _Sessions, ChannelId, 100, _State, SyncFun}
-) ->
- ListId = integer_to_binary(ChannelId),
- [Ranges] = maps:values(ListSubs),
- Payload = SyncFun(Ranges),
- ?assertEqual(ListId, maps:get(<<"id">>, Payload)),
- ?assertEqual(ListId, maps:get(<<"channel_id">>, Payload)),
- [Op] = maps:get(<<"ops">>, Payload),
- [Range] = Ranges,
- {Start, End} = Range,
- ?assertEqual([Start, End], maps:get(<<"range">>, Op)).
-
-assert_stress_channel_sync_dispatch(
- {sync_dispatch, ListSubs, _Sessions, ChannelId, 100, _State, SyncFun}
-) ->
- ?assertEqual(4, map_size(ListSubs)),
- Payload = SyncFun([{0, 20}, {40, 70}]),
- ListId = integer_to_binary(ChannelId),
- ?assertEqual(ListId, maps:get(<<"id">>, Payload)),
- ?assertEqual(ListId, maps:get(<<"channel_id">>, Payload)),
- ?assertEqual(2, length(maps:get(<<"ops">>, Payload))).
-
-collect_sync_dispatches(Count) ->
- collect_sync_dispatches(Count, []).
-
-collect_sync_dispatches(0, Acc) ->
- lists:reverse(Acc);
-collect_sync_dispatches(Count, Acc) ->
- receive
- {sync_dispatch, _ListSubs, _Sessions, _ChannelId, _GuildId, _State, _SyncFun} = Msg ->
- collect_sync_dispatches(Count - 1, [Msg | Acc])
- after 1000 ->
- ?assert(false)
- end.
-
-assert_no_sync_dispatch() ->
- receive
- {sync_dispatch, _ListSubs, _Sessions, _ChannelId, _GuildId, _State, _SyncFun} = Msg ->
- ?assert(false, {unexpected_sync_dispatch, Msg})
- after 0 ->
- ok
- end.
-
-make_subs_tab() ->
- guild_member_list_subs:new().
-
-make_subs_tab(Entries) ->
- Tab = guild_member_list_subs:new(),
- lists:foreach(
- fun({ListId, SessionId, Ranges}) ->
- guild_member_list_subs:subscribe(SessionId, ListId, Ranges, Tab)
- end,
- Entries
- ),
- Tab.
-
-base_state(SubsTab) ->
- #{
- id => 100,
- data => #{<<"channels">> => [#{<<"id">> => <<"500">>}], <<"members">> => []},
- sessions => #{},
- member_presence => #{},
- member_list_subscriptions => SubsTab
- }.
diff --git a/fluxer_gateway/test/guild_members_tests.erl b/fluxer_gateway/test/guild_members_tests.erl
deleted file mode 100644
index 679c4a6b8..000000000
--- a/fluxer_gateway/test/guild_members_tests.erl
+++ /dev/null
@@ -1,168 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_members_tests).
--typing([eqwalizer]).
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-get_members_with_role_test() ->
- State = test_state(),
- {reply, #{user_ids := UserIds}, _} = guild_members_query:get_members_with_role(
- #{role_id => 200}, State
- ),
- ?assertEqual([2], UserIds).
-
-get_members_with_role_rejects_malformed_role_id_test() ->
- State = test_state(),
- {reply, #{user_ids := UserIds}, _} = guild_members_query:get_members_with_role(
- #{role_id => <<"0200">>}, State
- ),
- ?assertEqual([], UserIds).
-
-resolve_channel_mentions_skips_invalid_channel_ids_test() ->
- State = channel_mentions_state([]),
- {reply, #{channels := Channels}, _} = guild_members_mutation:resolve_channel_mentions(
- #{channel_ids => [<<"001">>, <<"500">>]},
- State
- ),
- ?assertEqual([#{id => 500, name => <<"general">>, type => 0}], Channels).
-
-resolve_channel_mentions_ignores_user_zero_overwrite_test() ->
- ViewPerm = constants:view_channel_permission(),
- Overwrites = [
- #{
- <<"id">> => <<"0">>,
- <<"type">> => 1,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(ViewPerm)
- }
- ],
- State = channel_mentions_state(Overwrites),
- {reply, #{channels := Channels}, _} = guild_members_mutation:resolve_channel_mentions(
- #{channel_ids => [<<"500">>]},
- State
- ),
- ?assertEqual([#{id => 500, name => <<"general">>, type => 0}], Channels).
-
-get_assignable_roles_owner_test() ->
- State = test_state(),
- {reply, #{role_ids := RoleIds}, _} = guild_members_roles:get_assignable_roles(
- #{user_id => 1}, State
- ),
- ?assertEqual(lists:sort([100, 200, 201]), lists:sort(RoleIds)).
-
-get_viewable_channels_skips_malformed_channel_id_test() ->
- State0 = test_state(),
- Data0 = maps:get(data, State0),
- Channels = maps:get(<<"channels">>, Data0),
- BadChannel = #{<<"id">> => <<"0502">>, <<"type">> => 0, <<"permission_overwrites">> => []},
- State = State0#{data => Data0#{<<"channels">> => [BadChannel | Channels]}},
- {reply, #{channel_ids := ChannelIds}, _} = guild_members_query:get_viewable_channels(
- #{user_id => 1}, State
- ),
- ?assert(lists:member(500, ChannelIds)),
- ?assertNot(lists:member(502, ChannelIds)).
-
-check_target_member_test() ->
- State = test_state(),
- {reply, #{can_manage := true}, _} = guild_members_roles:check_target_member(
- #{user_id => 1, target_user_id => 2}, State
- ),
- {reply, #{can_manage := false}, _} = guild_members_roles:check_target_member(
- #{user_id => 2, target_user_id => 1}, State
- ).
-
-test_state() ->
- GuildId = 100,
- OwnerId = 1,
- MemberId = 2,
- OtherId = 3,
- ChannelId = 500,
- RoleMod = 200,
- RoleHigh = 201,
- ViewPerm = constants:view_channel_permission(),
- ManageRoles = constants:manage_roles_permission(),
- #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm bor ManageRoles),
- <<"position">> => 0
- },
- #{
- <<"id">> => integer_to_binary(RoleMod),
- <<"permissions">> => integer_to_binary(ViewPerm),
- <<"position">> => 10
- },
- #{
- <<"id">> => integer_to_binary(RoleHigh),
- <<"permissions">> => integer_to_binary(ViewPerm),
- <<"position">> => 20
- }
- ],
- <<"channels">> => [
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"type">> => 0,
- <<"permission_overwrites">> => []
- },
- #{
- <<"id">> => integer_to_binary(ChannelId + 1),
- <<"type">> => 2,
- <<"permission_overwrites">> => []
- }
- ],
- <<"members">> => [
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [integer_to_binary(GuildId)]
- },
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(MemberId)},
- <<"roles">> => [integer_to_binary(RoleMod)],
- <<"joined_at">> => <<"2024-01-01T00:00:00Z">>
- },
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(OtherId)},
- <<"roles">> => [integer_to_binary(RoleHigh)],
- <<"joined_at">> => <<"2024-01-02T00:00:00Z">>
- }
- ]
- }
- }.
-
-channel_mentions_state(Overwrites) ->
- GuildId = 100,
- ViewPerm = constants:view_channel_permission(),
- #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"1">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"channels">> => [
- #{
- <<"id">> => <<"500">>,
- <<"name">> => <<"general">>,
- <<"type">> => 0,
- <<"permission_overwrites">> => Overwrites
- },
- #{
- <<"id">> => <<"001">>,
- <<"name">> => <<"bad">>,
- <<"type">> => 0,
- <<"permission_overwrites">> => []
- }
- ],
- <<"members">> => []
- }
- }.
-
--endif.
diff --git a/fluxer_gateway/test/guild_passive_sync_tests.erl b/fluxer_gateway/test/guild_passive_sync_tests.erl
deleted file mode 100644
index 223fec23f..000000000
--- a/fluxer_gateway/test/guild_passive_sync_tests.erl
+++ /dev/null
@@ -1,198 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_passive_sync_tests).
--typing([eqwalizer]).
--include_lib("eunit/include/eunit.hrl").
-
-compute_delta_empty_previous_test() ->
- Current = #{<<"1">> => <<"100">>, <<"2">> => <<"200">>},
- Previous = #{},
- Delta = guild_passive_sync:compute_delta(Current, Previous),
- ?assertEqual(Current, Delta).
-
-compute_delta_no_changes_test() ->
- Current = #{<<"1">> => <<"100">>, <<"2">> => <<"200">>},
- Previous = #{<<"1">> => <<"100">>, <<"2">> => <<"200">>},
- Delta = guild_passive_sync:compute_delta(Current, Previous),
- ?assertEqual(#{}, Delta).
-
-compute_delta_partial_changes_test() ->
- Current = #{<<"1">> => <<"101">>, <<"2">> => <<"200">>, <<"3">> => <<"300">>},
- Previous = #{<<"1">> => <<"100">>, <<"2">> => <<"200">>},
- Delta = guild_passive_sync:compute_delta(Current, Previous),
- ?assertEqual(#{<<"1">> => <<"101">>, <<"3">> => <<"300">>}, Delta).
-
-compute_delta_only_new_channels_test() ->
- Current = #{<<"1">> => <<"100">>, <<"2">> => <<"200">>, <<"3">> => <<"300">>},
- Previous = #{<<"1">> => <<"100">>, <<"2">> => <<"200">>},
- Delta = guild_passive_sync:compute_delta(Current, Previous),
- ?assertEqual(#{<<"3">> => <<"300">>}, Delta).
-
-compute_delta_ignores_removed_channels_test() ->
- Current = #{<<"1">> => <<"100">>},
- Previous = #{<<"1">> => <<"100">>, <<"2">> => <<"200">>},
- Delta = guild_passive_sync:compute_delta(Current, Previous),
- ?assertEqual(#{}, Delta).
-
-send_passive_updates_uses_permission_capable_state_test() ->
- passive_sync_registry:init(),
- GuildId = 1427764661718740994,
- UserId = 1130650140672000000,
- SessionId = <<"passive-session">>,
- ChannelId = 1497639278555484216,
- MessageId = 1500000000000000000,
- State = #{
- id => GuildId,
- member_count => 300,
- sessions => #{
- SessionId => #{
- session_id => SessionId,
- user_id => UserId,
- pid => self(),
- active_guilds => sets:new(),
- bot => false
- }
- },
- data => #{
- <<"guild">> => #{<<"id">> => GuildId, <<"owner_id">> => UserId},
- <<"channels">> => [#{<<"id">> => ChannelId, <<"last_message_id">> => MessageId}],
- <<"members">> => [#{<<"user">> => #{<<"id">> => UserId}, <<"roles">> => []}],
- <<"roles">> => []
- },
- voice_states => #{}
- },
- guild_passive_sync:send_passive_updates_to_sessions(State),
- RegState = passive_sync_registry:lookup(SessionId, GuildId),
- ?assertEqual(
- #{integer_to_binary(ChannelId) => integer_to_binary(MessageId)},
- maps:get(previous_passive_updates, RegState)
- ).
-
-send_passive_updates_uses_current_channel_index_and_message_only_payload_test() ->
- flush_dispatches(),
- passive_sync_registry:init(),
- GuildId = 1427764661718740994,
- UserId = 1130650140672000000,
- SessionId = <<"passive-session-current">>,
- ChannelId = 1497639278555484216,
- OldMessageId = 1500000000000000000,
- NewMessageId = 1500000000000000001,
- Data0 = guild_data_index:normalize_map(#{
- <<"guild">> => #{<<"id">> => GuildId, <<"owner_id">> => UserId},
- <<"channels">> => [#{<<"id">> => ChannelId, <<"last_message_id">> => OldMessageId}],
- <<"members">> => [#{<<"user">> => #{<<"id">> => UserId}, <<"roles">> => []}],
- <<"roles">> => []
- }),
- ChannelIndex0 = maps:get(<<"channel_index">>, Data0),
- Channel0 = maps:get(ChannelId, ChannelIndex0),
- Data = Data0#{
- <<"channel_index">> => ChannelIndex0#{
- ChannelId => Channel0#{<<"last_message_id">> => NewMessageId}
- },
- channels_stale => true
- },
- passive_sync_registry:store(SessionId, GuildId, #{
- previous_passive_updates => #{
- integer_to_binary(ChannelId) => integer_to_binary(OldMessageId)
- },
- previous_passive_channel_versions => #{},
- previous_passive_voice_states => #{}
- }),
- State = #{
- id => GuildId,
- member_count => 300,
- sessions => #{
- SessionId => #{
- session_id => SessionId,
- user_id => UserId,
- pid => self(),
- active_guilds => sets:new(),
- bot => false
- }
- },
- data => Data,
- voice_states => #{}
- },
- guild_passive_sync:send_passive_updates_to_sessions(State),
- Payload = receive_passive_payload(),
- ?assertEqual(
- #{integer_to_binary(ChannelId) => integer_to_binary(NewMessageId)},
- maps:get(<<"channels">>, Payload)
- ),
- ?assertNot(maps:is_key(<<"created_channels">>, Payload)),
- ?assertNot(maps:is_key(<<"updated_channels">>, Payload)),
- ?assertNot(maps:is_key(<<"deleted_channel_ids">>, Payload)).
-
-receive_passive_payload() ->
- receive
- {'$gen_cast', {dispatch, passive_updates, Payload}} when is_map(Payload) ->
- Payload
- after 1000 ->
- ?assert(false, passive_payload_not_received)
- end.
-
-flush_dispatches() ->
- receive
- {'$gen_cast', {dispatch, passive_updates, _Payload}} ->
- flush_dispatches()
- after 0 ->
- ok
- end.
-
-compute_voice_state_updates_reports_changes_test() ->
- PrevVoiceState = #{
- <<"connection_id">> => <<"conn1">>,
- <<"channel_id">> => <<"100">>,
- <<"user_id">> => <<"200">>,
- <<"version">> => 1
- },
- CurrentVoiceState = PrevVoiceState#{<<"version">> => 2},
- Current = #{<<"conn1">> => CurrentVoiceState},
- Previous = #{<<"conn1">> => PrevVoiceState},
- Updates = guild_passive_sync_voice:compute_voice_state_updates(Current, Previous, 999),
- ?assertEqual(1, length(Updates)),
- Update = hd(Updates),
- ?assertEqual(<<"conn1">>, maps:get(<<"connection_id">>, Update)),
- ?assertEqual(integer_to_binary(999), maps:get(<<"guild_id">>, Update)).
-
-compute_voice_state_updates_reports_removal_test() ->
- RemovedVoiceState = #{
- <<"connection_id">> => <<"conn2">>,
- <<"channel_id">> => <<"200">>,
- <<"user_id">> => <<"300">>,
- <<"version">> => 3
- },
- Current = #{},
- Previous = #{<<"conn2">> => RemovedVoiceState},
- Updates = guild_passive_sync_voice:compute_voice_state_updates(Current, Previous, 101),
- ?assertEqual(1, length(Updates)),
- Update = hd(Updates),
- ?assertEqual(null, maps:get(<<"channel_id">>, Update)),
- ?assertEqual(integer_to_binary(101), maps:get(<<"guild_id">>, Update)).
-
-compute_voice_state_updates_sanitizes_internal_fields_test() ->
- PrevVoiceState = #{
- <<"connection_id">> => <<"conn1">>,
- <<"channel_id">> => <<"100">>,
- <<"user_id">> => <<"200">>,
- <<"version">> => 1
- },
- CurrentVoiceState = PrevVoiceState#{
- <<"version">> => 2,
- <<"latitude">> => <<"1.0">>,
- <<"longitude">> => <<"2.0">>,
- <<"region_id">> => <<"us-east">>,
- <<"server_id">> => <<"voice-1">>
- },
- Current = #{<<"conn1">> => CurrentVoiceState},
- Previous = #{<<"conn1">> => PrevVoiceState},
- Updates = guild_passive_sync_voice:compute_voice_state_updates(Current, Previous, 999),
- ?assertEqual(1, length(Updates)),
- Update = hd(Updates),
- ?assertNot(maps:is_key(<<"latitude">>, Update)),
- ?assertNot(maps:is_key(<<"longitude">>, Update)),
- ?assertNot(maps:is_key(<<"region_id">>, Update)),
- ?assertNot(maps:is_key(<<"server_id">>, Update)),
- ?assertEqual(2, maps:get(<<"version">>, Update)),
- ?assertEqual(false, maps:get(<<"suppress">>, Update)),
- ?assertEqual(null, maps:get(<<"member">>, Update)).
diff --git a/fluxer_gateway/test/guild_permission_cache_member_table_tests.erl b/fluxer_gateway/test/guild_permission_cache_member_table_tests.erl
deleted file mode 100644
index 882c60244..000000000
--- a/fluxer_gateway/test/guild_permission_cache_member_table_tests.erl
+++ /dev/null
@@ -1,127 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_permission_cache_member_table_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(MEMO, guild_permission_cache_stripped_members).
--define(CHANNEL_ID, 500).
-
-snapshot_points_at_the_member_table_test() ->
- with_guild(908, [set, public], fun(GuildId, Tab, _Data) ->
- {ok, Snapshot} = guild_permission_cache:get_snapshot(GuildId),
- SnapshotData = maps:get(data, Snapshot),
- ?assertEqual(Tab, maps:get(members_ets, SnapshotData)),
- ?assertEqual(#{}, maps:get(<<"members">>, SnapshotData)),
- ?assertEqual(undefined, erlang:get(?MEMO))
- end).
-
-member_reads_match_the_stripped_members_snapshot_test() ->
- Data = member_data(),
- GuildId = 909,
- memo_reset(),
- Tab = member_table(Data, [set, public]),
- try
- ok = guild_permission_cache:put_normalized_data(GuildId, Data),
- Expected = member_reads(GuildId),
- ok = guild_permission_cache:put_normalized_data(GuildId, Data#{members_ets => Tab}),
- ?assertEqual(Expected, member_reads(GuildId))
- after
- cleanup(GuildId, Tab)
- end.
-
-deleted_member_table_reports_not_found_test() ->
- with_guild(910, [set, public], fun(GuildId, Tab, _Data) ->
- true = ets:delete(Tab),
- ?assertEqual({error, not_found}, guild_permission_cache:get_snapshot(GuildId)),
- ?assertEqual(
- {error, not_found}, guild_permission_cache:get_permissions(GuildId, 1, ?CHANNEL_ID)
- ),
- ?assertEqual({error, not_found}, guild_permission_cache:has_member(GuildId, 1)),
- ?assertEqual({error, not_found}, guild_permission_cache:get_member(GuildId, 1))
- end).
-
-private_member_table_keeps_the_stripped_members_test() ->
- with_guild(911, [set, private], fun(GuildId, _Tab, Data) ->
- {ok, Snapshot} = guild_permission_cache:get_snapshot(GuildId),
- SnapshotData = maps:get(data, Snapshot),
- ?assertNot(maps:is_key(members_ets, SnapshotData)),
- ?assertEqual(
- map_size(maps:get(<<"members">>, Data)),
- map_size(maps:get(<<"members">>, SnapshotData))
- )
- end).
-
-disabled_flag_keeps_the_stripped_members_test() ->
- application:set_env(fluxer_gateway, permission_cache_members_ets, false),
- try
- with_guild(912, [set, public], fun(GuildId, _Tab, Data) ->
- {ok, Snapshot} = guild_permission_cache:get_snapshot(GuildId),
- SnapshotData = maps:get(data, Snapshot),
- ?assertNot(maps:is_key(members_ets, SnapshotData)),
- ?assertEqual(
- map_size(maps:get(<<"members">>, Data)),
- map_size(maps:get(<<"members">>, SnapshotData))
- )
- end)
- after
- application:unset_env(fluxer_gateway, permission_cache_members_ets)
- end.
-
-with_guild(GuildId, Options, Fun) ->
- memo_reset(),
- Data = member_data(),
- Tab = member_table(Data, Options),
- try
- ok = guild_permission_cache:put_normalized_data(GuildId, Data#{members_ets => Tab}),
- Fun(GuildId, Tab, Data)
- after
- cleanup(GuildId, Tab)
- end.
-
-cleanup(GuildId, Tab) ->
- try
- ets:delete(Tab)
- catch
- error:badarg -> true
- end,
- ok = guild_permission_cache:delete(GuildId),
- memo_reset().
-
-member_reads(GuildId) ->
- [
- {UserId, guild_permission_cache:get_permissions(GuildId, UserId, ?CHANNEL_ID),
- guild_permission_cache:has_member(GuildId, UserId),
- guild_permission_cache:get_member(GuildId, UserId)}
- || UserId <- [1, 2, 3]
- ].
-
-member_data() ->
- guild_data_index:normalize_data(#{
- <<"guild">> => #{<<"owner_id">> => <<"1">>},
- <<"roles">> => [#{<<"id">> => <<"42">>, <<"permissions">> => <<"1024">>}],
- <<"members">> => [member(1, [<<"42">>]), member(2, [])],
- <<"channels">> => [
- #{<<"id">> => integer_to_binary(?CHANNEL_ID), <<"permission_overwrites">> => []}
- ]
- }).
-
-member(UserId, Roles) ->
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId), <<"username">> => <<"u">>},
- <<"roles">> => Roles,
- <<"nick">> => <<"n">>
- }.
-
-member_table(Data, Options) ->
- Tab = ets:new(guild_permission_cache_member_table_tests, Options),
- maps:foreach(
- fun(UserId, Member) -> true = ets:insert(Tab, {UserId, Member}) end,
- maps:get(<<"members">>, Data)
- ),
- Tab.
-
-memo_reset() ->
- _ = erlang:erase(?MEMO),
- ok.
diff --git a/fluxer_gateway/test/guild_permissions_tests.erl b/fluxer_gateway/test/guild_permissions_tests.erl
deleted file mode 100644
index 73ea47fc8..000000000
--- a/fluxer_gateway/test/guild_permissions_tests.erl
+++ /dev/null
@@ -1,380 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_permissions_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-owner_receives_full_permissions_test() ->
- OwnerId = 1,
- GuildId = 100,
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => <<"0">>}
- ]
- }
- },
- ?assertEqual(
- all_permissions(), guild_permissions:get_member_permissions(OwnerId, undefined, State)
- ).
-
-channel_scope_permissions_test() ->
- GuildId = 42,
- UserId = 600,
- ChannelId = 700,
- RoleId = 800,
- View = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(GuildId + 1)},
- <<"roles">> => [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => <<"0">>},
- #{<<"id">> => integer_to_binary(RoleId), <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [integer_to_binary(RoleId)]
- }
- ],
- <<"channels">> => [
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => <<"0">>
- },
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"type">> => 0,
- <<"allow">> => integer_to_binary(View),
- <<"deny">> => <<"0">>
- }
- ]
- }
- ]
- }
- },
- ?assertEqual(0, guild_permissions:get_member_permissions(UserId, undefined, State)),
- ChannelPerms = guild_permissions:get_member_permissions(UserId, ChannelId, State),
- ?assert((ChannelPerms band View) =/= 0).
-
-administrator_role_grants_all_permissions_test() ->
- Admin = constants:administrator_permission(),
- GuildId = 100,
- UserId = 200,
- ChannelId = 300,
- OwnerId = 999,
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(Admin)
- }
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{<<"id">> => integer_to_binary(ChannelId), <<"permission_overwrites">> => []}
- ]
- }
- },
- ?assertEqual(
- all_permissions(), guild_permissions:get_member_permissions(UserId, undefined, State)
- ),
- ?assertEqual(
- all_permissions(), guild_permissions:get_member_permissions(UserId, ChannelId, State)
- ),
- ?assert(guild_permissions_check:can_view_channel(UserId, ChannelId, undefined, State)).
-
-cached_role_permissions_matches_uncached_test() ->
- Roles = [
- #{<<"id">> => <<"100">>, <<"permissions">> => <<"1024">>},
- #{<<"id">> => <<"200">>, <<"permissions">> => <<"8">>},
- #{<<"id">> => <<"300">>, <<"permissions">> => <<"2048">>}
- ],
- RoleIndex = guild_data_index:build_id_index(Roles),
- Cache = guild_data_index_roles:build_role_perms_cache(Roles),
- MemberRoles = [100, 200, 300],
- Uncached = uncached_role_permissions(MemberRoles, RoleIndex, 0),
- Cached = guild_permissions:aggregate_role_permissions_cached(
- MemberRoles, Cache, RoleIndex, 0
- ),
- ?assertEqual(Uncached, Cached).
-
-cached_role_permissions_with_base_test() ->
- Roles = [
- #{<<"id">> => <<"5">>, <<"permissions">> => <<"64">>},
- #{<<"id">> => <<"10">>, <<"permissions">> => <<"128">>}
- ],
- RoleIndex = guild_data_index:build_id_index(Roles),
- Cache = guild_data_index_roles:build_role_perms_cache(Roles),
- BasePerms = 64,
- MemberRoles = [10],
- Uncached = uncached_role_permissions(MemberRoles, RoleIndex, BasePerms),
- Cached = guild_permissions:aggregate_role_permissions_cached(
- MemberRoles, Cache, RoleIndex, BasePerms
- ),
- ?assertEqual(Uncached, Cached).
-
-uncached_role_permissions(MemberRoles, RoleIndex, BasePerms) ->
- lists:foldl(
- fun(RoleId, Acc) -> add_role_permissions(RoleId, RoleIndex, Acc) end,
- BasePerms,
- MemberRoles
- ).
-
-add_role_permissions(RoleId, RoleIndex, Acc) ->
- case guild_permissions_check:find_role_by_id(RoleId, RoleIndex) of
- undefined -> Acc;
- Role -> Acc bor guild_permissions_common:role_permissions(Role)
- end.
-
-cached_full_permission_computation_matches_uncached_test() ->
- View = constants:view_channel_permission(),
- GuildId = 100,
- UserId = 42,
- Roles = [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => integer_to_binary(View)},
- #{<<"id">> => <<"200">>, <<"permissions">> => <<"8">>}
- ],
- Channels = [
- #{
- <<"id">> => <<"500">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(View)
- },
- #{
- <<"id">> => <<"200">>,
- <<"type">> => 0,
- <<"allow">> => integer_to_binary(View),
- <<"deny">> => <<"0">>
- }
- ]
- }
- ],
- Members = #{
- UserId => #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [<<"200">>]
- }
- },
- RawData = #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => Roles,
- <<"channels">> => Channels,
- <<"members">> => Members
- },
- RawState = #{id => GuildId, data => RawData},
- UncachedPerms = guild_permissions:get_member_permissions(UserId, 500, RawState),
- NormData = guild_data_index:normalize_data(RawData),
- CachedState = #{id => GuildId, data => NormData},
- CachedPerms = guild_permissions:get_member_permissions(UserId, 500, CachedState),
- ?assertEqual(UncachedPerms, CachedPerms),
- ?assert(UncachedPerms > 0).
-
-can_view_channel_members_grants_when_bit_set_test() ->
- Bit = constants:view_channel_members_permission(),
- GuildId = 100,
- UserId = 200,
- OwnerId = 999,
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(Bit)
- }
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [#{<<"id">> => <<"500">>, <<"permission_overwrites">> => []}]
- }
- },
- ?assert(guild_permissions_check:can_view_channel_members(UserId, 500, undefined, State)).
-
-can_view_channel_members_denies_when_bit_unset_test() ->
- GuildId = 101,
- UserId = 201,
- OwnerId = 998,
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [#{<<"id">> => <<"500">>, <<"permission_overwrites">> => []}]
- }
- },
- ?assertNot(guild_permissions_check:can_view_channel_members(UserId, 500, undefined, State)).
-
-can_view_channel_members_owner_always_true_test() ->
- GuildId = 102,
- OwnerId = 102,
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(OwnerId)}, <<"roles">> => []}
- ],
- <<"channels">> => [#{<<"id">> => <<"500">>, <<"permission_overwrites">> => []}]
- }
- },
- ?assert(guild_permissions_check:can_view_channel_members(OwnerId, 500, undefined, State)).
-
-can_view_channel_members_admin_grants_test() ->
- Admin = constants:administrator_permission(),
- GuildId = 103,
- UserId = 203,
- OwnerId = 997,
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(Admin)
- }
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [#{<<"id">> => <<"500">>, <<"permission_overwrites">> => []}]
- }
- },
- ?assert(guild_permissions_check:can_view_channel_members(UserId, 500, undefined, State)).
-
-can_view_channel_members_channel_deny_overwrite_blocks_test() ->
- Bit = constants:view_channel_members_permission(),
- View = constants:view_channel_permission(),
- GuildId = 104,
- UserId = 204,
- OwnerId = 996,
- Base = Bit bor View,
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(Base)
- }
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{
- <<"id">> => <<"500">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(Bit)
- }
- ]
- }
- ]
- }
- },
- ?assertNot(guild_permissions_check:can_view_channel_members(UserId, 500, undefined, State)).
-
-can_access_message_with_read_history_test() ->
- ReadHistory = constants:read_message_history_permission(),
- State = #{data => #{<<"guild">> => #{}}},
- ?assertEqual(
- true,
- guild_permissions_check:can_access_message_by_permissions(ReadHistory, <<"100">>, State)
- ).
-
-can_access_message_no_read_history_no_cutoff_test() ->
- State = #{data => #{<<"guild">> => #{}}},
- ?assertEqual(
- false, guild_permissions_check:can_access_message_by_permissions(0, <<"100">>, State)
- ).
-
-can_access_message_no_read_history_null_cutoff_test() ->
- State = #{data => #{<<"guild">> => #{<<"message_history_cutoff">> => null}}},
- ?assertEqual(
- false, guild_permissions_check:can_access_message_by_permissions(0, <<"100">>, State)
- ).
-
-can_access_message_no_read_history_message_before_cutoff_test() ->
- CutoffMs = 1704067200000,
- BeforeCutoffTimestamp = CutoffMs - 60000,
- FluxerEpoch = 1420070400000,
- RelativeTs = BeforeCutoffTimestamp - FluxerEpoch,
- Snowflake = RelativeTs bsl 22,
- MessageId = integer_to_binary(Snowflake),
- State = #{data => #{<<"guild">> => #{<<"message_history_cutoff">> => CutoffMs}}},
- ?assertEqual(
- false, guild_permissions_check:can_access_message_by_permissions(0, MessageId, State)
- ).
-
-can_access_message_no_read_history_message_after_cutoff_test() ->
- CutoffMs = 1704067200000,
- AfterCutoffTimestamp = CutoffMs + 60000,
- FluxerEpoch = 1420070400000,
- RelativeTs = AfterCutoffTimestamp - FluxerEpoch,
- Snowflake = RelativeTs bsl 22,
- MessageId = integer_to_binary(Snowflake),
- State = #{data => #{<<"guild">> => #{<<"message_history_cutoff">> => CutoffMs}}},
- ?assertEqual(
- true, guild_permissions_check:can_access_message_by_permissions(0, MessageId, State)
- ).
-
-can_access_message_no_read_history_message_at_cutoff_test() ->
- CutoffMs = 1704067200000,
- FluxerEpoch = 1420070400000,
- RelativeTs = CutoffMs - FluxerEpoch,
- Snowflake = RelativeTs bsl 22,
- MessageId = integer_to_binary(Snowflake),
- State = #{data => #{<<"guild">> => #{<<"message_history_cutoff">> => CutoffMs}}},
- ?assertEqual(
- true, guild_permissions_check:can_access_message_by_permissions(0, MessageId, State)
- ).
-
-can_access_message_with_rfc3339_cutoff_test() ->
- CutoffBin = <<"2024-01-01T00:00:00Z">>,
- CutoffMs = calendar:rfc3339_to_system_time("2024-01-01T00:00:00Z", [{unit, millisecond}]),
- AfterCutoffTimestamp = CutoffMs + 60000,
- FluxerEpoch = 1420070400000,
- RelativeTs = AfterCutoffTimestamp - FluxerEpoch,
- Snowflake = RelativeTs bsl 22,
- MessageId = integer_to_binary(Snowflake),
- State = #{data => #{<<"guild">> => #{<<"message_history_cutoff">> => CutoffBin}}},
- ?assertEqual(
- true, guild_permissions_check:can_access_message_by_permissions(0, MessageId, State)
- ).
-
-all_permissions() ->
- 16#FFFFFFFFFFFFFFFF.
diff --git a/fluxer_gateway/test/guild_push_engagement_tests.erl b/fluxer_gateway/test/guild_push_engagement_tests.erl
deleted file mode 100644
index c498f759f..000000000
--- a/fluxer_gateway/test/guild_push_engagement_tests.erl
+++ /dev/null
@@ -1,451 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_push_engagement_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(GUILD_ID, 7000).
--define(CHANNEL_ID, 7100).
--define(USER, 10).
--define(AUTHOR, 20).
--define(MSG, 7200).
--define(GRACE_MS, 200).
-
-desktop_active() ->
- #{status => online, afk => false, mobile => false}.
-
-phone_backgrounded() ->
- #{status => online, afk => true, mobile => true}.
-
-desktop_invisible() ->
- #{status => invisible, afk => false, mobile => false}.
-
-user_data() ->
- #{<<"id">> => integer_to_binary(?USER), <<"username">> => <<"reader">>}.
-
-published_presence(PresenceSessions) ->
- presence_payload:build(
- user_data(),
- presence_status:get_current_status(PresenceSessions),
- presence_status:get_flattened_mobile(PresenceSessions),
- presence_status:get_flattened_afk(PresenceSessions),
- null
- ).
-
-guild_state(SessionPids) ->
- #{
- id => ?GUILD_ID,
- data => #{
- <<"guild">> => #{
- <<"id">> => ?GUILD_ID,
- <<"name">> => <<"Guild">>,
- <<"owner_id">> => ?USER,
- <<"default_message_notifications">> => 0
- },
- <<"members">> => #{?USER => #{<<"user">> => user_data(), <<"roles">> => []}},
- <<"channels">> => [#{<<"id">> => ?CHANNEL_ID, <<"name">> => <<"general">>}],
- <<"channel_index">> => #{
- ?CHANNEL_ID => #{<<"id">> => ?CHANNEL_ID, <<"name">> => <<"general">>}
- },
- <<"roles">> => [],
- <<"role_index">> => #{}
- },
- sessions => maps:map(
- fun(Sid, Pid) -> #{session_id => Sid, user_id => ?USER, pid => Pid} end,
- SessionPids
- ),
- member_presence => ets:new(test_member_presence, [set, public]),
- presence_subscriptions => #{?USER => 1},
- member_list_subscriptions => guild_member_list_subs:new()
- }.
-
-apply_presence(PresenceSessions, State) ->
- {noreply, NewState} = guild_presence:handle_bus_presence(
- ?USER, published_presence(PresenceSessions), State
- ),
- NewState.
-
-report_push_holds(PresenceSessions, State) ->
- maps:fold(fun report_push_hold/3, State, PresenceSessions).
-
-report_push_hold(SessionId, PresenceSession, State) ->
- ok = session_lifecycle:send_guild_push_hold(
- {self(), make_ref()}, PresenceSession#{id => SessionId}
- ),
- receive
- {'$gen_cast', Msg} ->
- {noreply, NewState} = guild:handle_cast(Msg, State),
- NewState
- after 1000 -> error(no_push_hold_reported)
- end.
-
-apply_session_presence(PresenceSessions, State) ->
- report_push_holds(PresenceSessions, apply_presence(PresenceSessions, State)).
-
-guild_message() ->
- #{
- <<"id">> => integer_to_binary(?MSG),
- <<"channel_id">> => integer_to_binary(?CHANNEL_ID),
- <<"author">> => #{<<"id">> => integer_to_binary(?AUTHOR)},
- <<"content">> => <<"hi">>
- }.
-
-dm_message() ->
- #{
- <<"id">> => integer_to_binary(?MSG),
- <<"channel_id">> => <<"5">>,
- <<"channel_type">> => 1,
- <<"author">> => #{<<"id">> => integer_to_binary(?AUTHOR)},
- <<"content">> => <<"hi">>
- }.
-
-desktop_away() ->
- #{status => online, afk => true, mobile => false}.
-
-desktop_offline() ->
- #{status => offline, afk => false, mobile => false}.
-
-fake_guild(State) ->
- spawn(fun() -> fake_guild_loop(State) end).
-
-fake_guild_loop(State) ->
- receive
- {'$gen_call', From, Request} ->
- {reply, Reply, State} = guild:handle_call(Request, From, State),
- gen_server:reply(From, Reply),
- fake_guild_loop(State);
- {set_state, NewState} ->
- fake_guild_loop(NewState);
- stop ->
- ok
- end.
-
-send_held_message(State) ->
- Guild = fake_guild(State),
- ok = guild_dispatch_push:collect_and_send_push_notifications(
- guild_message(), ?GUILD_ID, State#{guild_pid => Guild}
- ),
- Guild.
-
-idle_session() ->
- spawn(fun() ->
- receive
- stop -> ok
- end
- end).
-
-with_push_spy(Fun) ->
- Self = self(),
- Previous = application:get_env(fluxer_gateway, guild_push_offline_grace_recheck_ms),
- ok = application:set_env(fluxer_gateway, guild_push_offline_grace_recheck_ms, ?GRACE_MS),
- ok = meck:new(push, [passthrough, no_link]),
- try
- ok = meck:expect(push, handle_message_create, fun(Params) ->
- Self ! {pushed, maps:get(user_ids, Params)},
- ok
- end),
- Fun()
- after
- meck:unload(push),
- case Previous of
- {ok, Value} ->
- application:set_env(fluxer_gateway, guild_push_offline_grace_recheck_ms, Value);
- undefined ->
- application:unset_env(fluxer_gateway, guild_push_offline_grace_recheck_ms)
- end
- end.
-
-immediate_pushes() ->
- receive
- {pushed, UserIds} -> [UserIds | immediate_pushes()]
- after 0 -> []
- end.
-
-push_within(Ms) ->
- receive
- {pushed, UserIds} -> UserIds
- after Ms -> none
- end.
-
-desktop_plus_backgrounded_phone_still_publishes_online_mobile_not_afk_test() ->
- PresenceSessions = #{
- <<"desktop">> => desktop_active(), <<"phone">> => phone_backgrounded()
- },
- Payload = published_presence(PresenceSessions),
- ?assertEqual(<<"online">>, maps:get(<<"status">>, Payload)),
- ?assertEqual(true, maps:get(<<"mobile">>, Payload)),
- ?assertEqual(false, maps:get(<<"afk">>, Payload)),
- ?assertEqual(
- {ok, Payload},
- presence_broadcast:current_visible_presence(#{
- sessions => PresenceSessions, user_data => user_data(), custom_status => null
- })
- ).
-
-guild_message_is_held_through_grace_for_a_user_active_on_desktop_with_a_backgrounded_phone_test() ->
- Desktop = idle_session(),
- Phone = idle_session(),
- State0 = guild_state(#{<<"desktop">> => Desktop, <<"phone">> => Phone}),
- try
- with_push_spy(fun() ->
- State = apply_session_presence(
- #{<<"desktop">> => desktop_active(), <<"phone">> => phone_backgrounded()},
- State0
- ),
- Guild = send_held_message(State),
- ?assertEqual([], immediate_pushes()),
- ?assertEqual(none, push_within(?GRACE_MS * 3)),
- Guild ! stop
- end)
- after
- Desktop ! stop,
- Phone ! stop,
- ets:delete(maps:get(member_presence, State0))
- end.
-
-guild_message_is_held_through_grace_for_a_user_active_on_desktop_only_test() ->
- Desktop = idle_session(),
- State0 = guild_state(#{<<"desktop">> => Desktop}),
- try
- with_push_spy(fun() ->
- State = apply_presence(#{<<"desktop">> => desktop_active()}, State0),
- ok = guild_dispatch_push:collect_and_send_push_notifications(
- guild_message(), ?GUILD_ID, State
- ),
- ?assertEqual([], immediate_pushes()),
- Desktop ! stop,
- ?assertEqual([?USER], push_within(?GRACE_MS * 10))
- end)
- after
- Desktop ! stop,
- ets:delete(maps:get(member_presence, State0))
- end.
-
-invisible_desktop_is_published_as_offline_test() ->
- Payload = published_presence(#{<<"desktop">> => desktop_invisible()}),
- ?assertEqual(<<"offline">>, maps:get(<<"status">>, Payload)),
- ?assertEqual(
- not_found,
- presence_broadcast:current_visible_presence(#{
- sessions => #{<<"desktop">> => desktop_invisible()},
- user_data => user_data(),
- custom_status => null
- })
- ).
-
-guild_message_to_a_user_on_desktop_with_a_backgrounded_phone_is_released_when_the_desktop_ends_test() ->
- Desktop = idle_session(),
- Phone = idle_session(),
- State0 = guild_state(#{<<"desktop">> => Desktop, <<"phone">> => Phone}),
- try
- with_push_spy(fun() ->
- State = apply_session_presence(
- #{<<"desktop">> => desktop_active(), <<"phone">> => phone_backgrounded()},
- State0
- ),
- ok = guild_dispatch_push:collect_and_send_push_notifications(
- guild_message(), ?GUILD_ID, State
- ),
- ?assertEqual([], immediate_pushes()),
- Desktop ! stop,
- ?assertEqual([?USER], push_within(?GRACE_MS * 10))
- end)
- after
- Desktop ! stop,
- Phone ! stop,
- ets:delete(maps:get(member_presence, State0))
- end.
-
-guild_message_is_pushed_immediately_to_a_user_on_a_backgrounded_phone_only_test() ->
- Phone = idle_session(),
- State0 = guild_state(#{<<"phone">> => Phone}),
- try
- with_push_spy(fun() ->
- State = apply_session_presence(#{<<"phone">> => phone_backgrounded()}, State0),
- ok = guild_dispatch_push:collect_and_send_push_notifications(
- guild_message(), ?GUILD_ID, State
- ),
- ?assertEqual([[?USER]], immediate_pushes())
- end)
- after
- Phone ! stop,
- ets:delete(maps:get(member_presence, State0))
- end.
-
-guild_message_is_held_through_grace_for_a_user_active_on_an_invisible_desktop_test() ->
- Desktop = idle_session(),
- State0 = guild_state(#{<<"desktop">> => Desktop}),
- try
- with_push_spy(fun() ->
- Online = apply_session_presence(#{<<"desktop">> => desktop_active()}, State0),
- State = apply_session_presence(#{<<"desktop">> => desktop_invisible()}, Online),
- ?assertMatch(
- #{<<"status">> := <<"offline">>},
- guild_state_member:lookup_presence(maps:get(member_presence, State), ?USER)
- ),
- Guild = send_held_message(State),
- ?assertEqual([], immediate_pushes()),
- ?assertEqual(none, push_within(?GRACE_MS * 3)),
- Guild ! stop
- end)
- after
- Desktop ! stop,
- ets:delete(maps:get(member_presence, State0))
- end.
-
-dm_path_buffers_the_push_for_an_active_invisible_desktop_test() ->
- with_push_spy(fun() ->
- State = presence_update:handle_message_create_event(dm_message(), #{
- user_id => ?USER,
- sessions => #{<<"desktop">> => desktop_invisible()},
- push_buffer => []
- }),
- ?assertEqual(1, length(maps:get(push_buffer, State))),
- ?assertEqual([], immediate_pushes())
- end).
-
-dm_path_buffers_the_push_for_an_active_desktop_with_a_backgrounded_phone_test() ->
- with_push_spy(fun() ->
- State = presence_update:handle_message_create_event(dm_message(), #{
- user_id => ?USER,
- sessions => #{
- <<"desktop">> => desktop_active(), <<"phone">> => phone_backgrounded()
- },
- push_buffer => []
- }),
- ?assertEqual(1, length(maps:get(push_buffer, State))),
- ?assertEqual([], immediate_pushes())
- end).
-
-session_reports_a_push_hold_change_to_its_guilds_test() ->
- Base = #{
- id => <<"desktop">>,
- status => online,
- afk => false,
- mobile => false,
- presence_pid => undefined,
- guilds => #{?GUILD_ID => {self(), make_ref()}}
- },
- {noreply, Afk} = session_lifecycle:handle_presence_update_cast(#{afk => true}, Base),
- ?assertEqual(
- [{set_session_push_hold, <<"desktop">>, false}], received_casts()
- ),
- {noreply, _Idle} = session_lifecycle:handle_presence_update_cast(#{status => idle}, Afk),
- ?assertEqual([], received_casts()),
- {noreply, _Back} = session_lifecycle:handle_presence_update_cast(
- #{afk => false, status => invisible}, Afk
- ),
- ?assertEqual(
- [{set_session_push_hold, <<"desktop">>, true}], received_casts()
- ).
-
-a_foreground_phone_never_holds_guild_pushes_test() ->
- ?assertEqual(
- [{set_session_push_hold, <<"phone">>, false}],
- reported_push_hold(#{id => <<"phone">>, status => online, afk => false, mobile => true})
- ).
-
-a_dnd_desktop_holds_guild_pushes_test() ->
- ?assertEqual(
- [{set_session_push_hold, <<"desktop">>, true}],
- reported_push_hold(#{id => <<"desktop">>, status => dnd, afk => false, mobile => false})
- ).
-
-a_bot_session_never_reports_a_push_hold_test() ->
- ?assertEqual(
- [],
- reported_push_hold(#{
- id => <<"bot">>, status => online, afk => false, mobile => false, bot => true
- })
- ).
-
-a_desktop_back_from_afk_on_dnd_holds_guild_pushes_again_test() ->
- Base = #{
- id => <<"desktop">>,
- status => online,
- afk => true,
- mobile => false,
- presence_pid => undefined,
- guilds => #{?GUILD_ID => {self(), make_ref()}}
- },
- {noreply, _Dnd} = session_lifecycle:handle_presence_update_cast(
- #{afk => false, status => dnd}, Base
- ),
- ?assertEqual([{set_session_push_hold, <<"desktop">>, true}], received_casts()).
-
-only_sessions_that_reported_no_hold_are_released_at_grace_test() ->
- State = #{
- sessions => #{
- <<"released">> => #{push_hold => false},
- <<"holding">> => #{push_hold => true},
- <<"never_reported">> => #{}
- }
- },
- ?assertEqual(
- [<<"released">>],
- guild_sessions:released_push_holds(
- [<<"released">>, <<"holding">>, <<"never_reported">>, <<"gone">>], State
- )
- ).
-
-reported_push_hold(Session) ->
- ok = session_lifecycle:send_guild_push_hold({self(), make_ref()}, Session),
- received_casts().
-
-received_casts() ->
- receive
- {'$gen_cast', Msg} -> [Msg | received_casts()]
- after 0 -> []
- end.
-
-guild_message_to_a_user_on_desktop_with_a_backgrounded_phone_is_released_when_the_desktop_stops_holding_test() ->
- Desktop = idle_session(),
- Phone = idle_session(),
- State0 = guild_state(#{<<"desktop">> => Desktop, <<"phone">> => Phone}),
- try
- with_push_spy(fun() ->
- State = apply_session_presence(
- #{<<"desktop">> => desktop_active(), <<"phone">> => phone_backgrounded()},
- State0
- ),
- Guild = send_held_message(State),
- ?assertEqual([], immediate_pushes()),
- Guild ! {set_state, report_push_hold(<<"desktop">>, desktop_offline(), State)},
- ?assertEqual([?USER], push_within(?GRACE_MS * 10)),
- ?assert(is_process_alive(Desktop)),
- Guild ! stop
- end)
- after
- Desktop ! stop,
- Phone ! stop,
- ets:delete(maps:get(member_presence, State0))
- end.
-
-guild_message_to_a_user_on_an_invisible_desktop_is_released_when_the_desktop_goes_afk_test() ->
- Desktop = idle_session(),
- State0 = guild_state(#{<<"desktop">> => Desktop}),
- try
- with_push_spy(fun() ->
- State = apply_session_presence(#{<<"desktop">> => desktop_invisible()}, State0),
- Guild = send_held_message(State),
- ?assertEqual([], immediate_pushes()),
- Guild ! {set_state, report_push_hold(<<"desktop">>, desktop_away(), State)},
- ?assertEqual([?USER], push_within(?GRACE_MS * 10)),
- Guild ! stop
- end)
- after
- Desktop ! stop,
- ets:delete(maps:get(member_presence, State0))
- end.
-
-manually_idle_desktop_does_not_hold_guild_pushes_test() ->
- Base = #{
- id => <<"desktop">>,
- status => online,
- afk => false,
- mobile => false,
- presence_pid => undefined,
- guilds => #{?GUILD_ID => {self(), make_ref()}}
- },
- {noreply, _Idle} = session_lifecycle:handle_presence_update_cast(#{status => idle}, Base),
- ?assertEqual([{set_session_push_hold, <<"desktop">>, false}], received_casts()).
diff --git a/fluxer_gateway/test/guild_push_silent_tests.erl b/fluxer_gateway/test/guild_push_silent_tests.erl
deleted file mode 100644
index a629f709a..000000000
--- a/fluxer_gateway/test/guild_push_silent_tests.erl
+++ /dev/null
@@ -1,85 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_push_silent_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(GUILD_ID, 7300).
--define(CHANNEL_ID, 7400).
--define(USER, 30).
--define(AUTHOR, 40).
--define(SUPPRESS_NOTIFICATIONS, 4096).
-
-member() ->
- #{<<"user">> => #{<<"id">> => integer_to_binary(?USER)}, <<"roles">> => []}.
-
-guild_state(MembersTab) ->
- #{
- id => ?GUILD_ID,
- data => #{
- <<"guild">> => #{
- <<"id">> => ?GUILD_ID,
- <<"name">> => <<"Guild">>,
- <<"owner_id">> => ?USER,
- <<"default_message_notifications">> => 0
- },
- <<"channels">> => [#{<<"id">> => ?CHANNEL_ID, <<"name">> => <<"general">>}],
- <<"channel_index">> => #{
- ?CHANNEL_ID => #{<<"id">> => ?CHANNEL_ID, <<"name">> => <<"general">>}
- },
- <<"roles">> => [],
- <<"role_index">> => #{},
- members_ets => MembersTab
- },
- sessions => #{}
- }.
-
-guild_message(Id, Flags) ->
- #{
- <<"id">> => integer_to_binary(Id),
- <<"channel_id">> => integer_to_binary(?CHANNEL_ID),
- <<"author">> => #{<<"id">> => integer_to_binary(?AUTHOR)},
- <<"content">> => <<"<@30> hi @everyone">>,
- <<"mentions">> => [#{<<"id">> => integer_to_binary(?USER)}],
- <<"mention_everyone">> => true,
- <<"flags">> => Flags
- }.
-
-pushed_message_ids(Messages) ->
- Self = self(),
- MembersTab = ets:new(guild_push_silent_members, [set, public]),
- true = ets:insert(MembersTab, {?USER, member()}),
- ok = meck:new(push, [passthrough, no_link]),
- try
- ok = meck:expect(push, handle_message_create, fun(Params) ->
- Self ! {pushed, maps:get(<<"id">>, maps:get(message_data, Params))},
- ok
- end),
- lists:foreach(
- fun(Message) ->
- ok = guild_dispatch_push:maybe_send_push_notifications(
- message_create, Message, ?GUILD_ID, guild_state(MembersTab)
- )
- end,
- Messages
- ),
- lists:sort(collect_pushed(1000))
- after
- meck:unload(push),
- ets:delete(MembersTab)
- end.
-
-collect_pushed(Timeout) ->
- receive
- {pushed, Id} -> [binary_to_integer(Id) | collect_pushed(300)]
- after Timeout -> []
- end.
-
-a_silent_guild_message_mentioning_the_member_is_not_pushed_test() ->
- Messages = [
- guild_message(1, ?SUPPRESS_NOTIFICATIONS),
- guild_message(2, ?SUPPRESS_NOTIFICATIONS bor 4),
- guild_message(3, 0),
- guild_message(4, 4)
- ],
- ?assertEqual([3, 4], pushed_message_ids(Messages)).
diff --git a/fluxer_gateway/test/guild_request_members_filter_tests.erl b/fluxer_gateway/test/guild_request_members_filter_tests.erl
deleted file mode 100644
index 3c1ad58f8..000000000
--- a/fluxer_gateway/test/guild_request_members_filter_tests.erl
+++ /dev/null
@@ -1,396 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_request_members_filter_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(REQUEST_MEMBERS_RATE_LIMIT_TABLE, guild_request_members_rate_limit).
--define(REQUEST_MEMBERS_RATE_LIMIT_MAX_EVENTS, 12).
--define(REQUEST_MEMBERS_GUILD_RATE_LIMIT_TABLE, guild_request_members_guild_rate_limit).
--define(REQUEST_MEMBERS_GUILD_RATE_LIMIT_MAX_EVENTS, 40).
--define(FULL_LIST_BOT_RATE_LIMIT_TABLE, guild_request_members_bot_full_list_rate_limit).
--define(FULL_LIST_BOT_RATE_LIMIT_WINDOW_MS, 30000).
-
-is_full_member_list_true_test() ->
- ?assertEqual(true, guild_request_members_filter:is_full_member_list(<<>>, 0, [])).
-
-is_full_member_list_query_set_test() ->
- ?assertEqual(false, guild_request_members_filter:is_full_member_list(<<"abc">>, 0, [])).
-
-is_full_member_list_limit_set_test() ->
- ?assertEqual(false, guild_request_members_filter:is_full_member_list(<<>>, 10, [])).
-
-is_full_member_list_user_ids_set_test() ->
- ?assertEqual(false, guild_request_members_filter:is_full_member_list(<<>>, 0, [1])).
-
-check_permission_non_full_list_allows_user_test() ->
- ?assertEqual(
- ok,
- guild_request_members_filter:check_permission(1, false, 123, false, #{guilds => #{}})
- ).
-
-check_permission_bot_full_list_allowed_test() ->
- ?assertEqual(
- ok, guild_request_members_filter:check_permission(1, true, 123, true, #{guilds => #{}})
- ).
-
-check_permission_user_full_list_missing_guild_test() ->
- ?assertEqual(
- {error, guild_not_found},
- guild_request_members_filter:check_permission(1, false, 123, true, #{guilds => #{}})
- ).
-
-check_full_list_bot_rate_limit_non_full_list_test() ->
- ?assertEqual(
- ok, guild_request_members_filter:check_full_list_bot_rate_limit(false, true, 1, 2)
- ).
-
-check_full_list_bot_rate_limit_non_bot_test() ->
- ?assertEqual(
- ok, guild_request_members_filter:check_full_list_bot_rate_limit(true, false, 1, 2)
- ).
-
-check_full_list_bot_rate_limit_allows_first_test() ->
- UserId = 111111001,
- GuildId = 111111002,
- clear_full_list_bot_rate_limit(UserId, GuildId),
- ?assertEqual(
- ok,
- guild_request_members_filter:check_full_list_bot_rate_limit(true, true, UserId, GuildId)
- ),
- clear_full_list_bot_rate_limit(UserId, GuildId).
-
-check_full_list_bot_rate_limit_blocks_second_within_window_test() ->
- with_rate_limits_enabled(fun() ->
- UserId = 111111003,
- GuildId = 111111004,
- clear_full_list_bot_rate_limit(UserId, GuildId),
- ?assertEqual(
- ok,
- guild_request_members_filter:check_full_list_bot_rate_limit(
- true, true, UserId, GuildId
- )
- ),
- case
- guild_request_members_filter:check_full_list_bot_rate_limit(
- true, true, UserId, GuildId
- )
- of
- {rate_limited, RetryAfter} ->
- ?assert(RetryAfter > 0),
- ?assert(RetryAfter =< ?FULL_LIST_BOT_RATE_LIMIT_WINDOW_MS);
- Other ->
- ?assertEqual({rate_limited, expected}, Other)
- end,
- clear_full_list_bot_rate_limit(UserId, GuildId)
- end).
-
-check_full_list_bot_rate_limit_disabled_by_env_test() ->
- OldValue = os:getenv("FLUXER_DISABLE_RATE_LIMITS"),
- os:putenv("FLUXER_DISABLE_RATE_LIMITS", "true"),
- try
- UserId = 111111011,
- GuildId = 111111012,
- clear_full_list_bot_rate_limit(UserId, GuildId),
- ?assertEqual(
- ok,
- guild_request_members_filter:check_full_list_bot_rate_limit(
- true, true, UserId, GuildId
- )
- ),
- ?assertEqual(
- ok,
- guild_request_members_filter:check_full_list_bot_rate_limit(
- true, true, UserId, GuildId
- )
- ),
- clear_full_list_bot_rate_limit(UserId, GuildId)
- after
- restore_env("FLUXER_DISABLE_RATE_LIMITS", OldValue)
- end.
-
-check_full_list_bot_rate_limit_per_guild_isolation_test() ->
- UserId = 111111005,
- GuildA = 111111006,
- GuildB = 111111007,
- clear_full_list_bot_rate_limit(UserId, GuildA),
- clear_full_list_bot_rate_limit(UserId, GuildB),
- ?assertEqual(
- ok,
- guild_request_members_filter:check_full_list_bot_rate_limit(true, true, UserId, GuildA)
- ),
- ?assertEqual(
- ok,
- guild_request_members_filter:check_full_list_bot_rate_limit(true, true, UserId, GuildB)
- ),
- clear_full_list_bot_rate_limit(UserId, GuildA),
- clear_full_list_bot_rate_limit(UserId, GuildB).
-
-check_full_list_bot_rate_limit_per_bot_isolation_test() ->
- UserA = 111111008,
- UserB = 111111009,
- GuildId = 111111010,
- clear_full_list_bot_rate_limit(UserA, GuildId),
- clear_full_list_bot_rate_limit(UserB, GuildId),
- ?assertEqual(
- ok,
- guild_request_members_filter:check_full_list_bot_rate_limit(true, true, UserA, GuildId)
- ),
- ?assertEqual(
- ok,
- guild_request_members_filter:check_full_list_bot_rate_limit(true, true, UserB, GuildId)
- ),
- clear_full_list_bot_rate_limit(UserA, GuildId),
- clear_full_list_bot_rate_limit(UserB, GuildId).
-
-enforce_single_guild_for_bots_user_multi_test() ->
- ?assertEqual(
- ok, guild_request_members_filter:enforce_single_guild_for_bots(false, [1, 2, 3])
- ).
-
-enforce_single_guild_for_bots_bot_single_test() ->
- ?assertEqual(ok, guild_request_members_filter:enforce_single_guild_for_bots(true, [1])).
-
-enforce_single_guild_for_bots_bot_multi_rejected_test() ->
- ?assertEqual(
- {error, too_many_guild_ids},
- guild_request_members_filter:enforce_single_guild_for_bots(true, [1, 2])
- ).
-
-enforce_single_guild_for_bots_bot_empty_test() ->
- ?assertEqual(ok, guild_request_members_filter:enforce_single_guild_for_bots(true, [])).
-
-check_request_rate_limit_allows_initial_request_test() ->
- UserId = 987654321,
- clear_request_rate_limit(UserId),
- ?assertEqual(ok, guild_request_members_filter:check_request_rate_limit(UserId)),
- clear_request_rate_limit(UserId).
-
-check_request_rate_limit_blocks_burst_test() ->
- UserId = 987654322,
- clear_request_rate_limit(UserId),
- ensure_ets_table(?REQUEST_MEMBERS_RATE_LIMIT_TABLE),
- Now = erlang:system_time(millisecond),
- Timestamps = lists:duplicate(?REQUEST_MEMBERS_RATE_LIMIT_MAX_EVENTS, Now - 1000),
- ets:insert(?REQUEST_MEMBERS_RATE_LIMIT_TABLE, {UserId, Timestamps}),
- ?assertEqual(
- {error, rate_limited}, guild_request_members_filter:check_request_rate_limit(UserId)
- ),
- clear_request_rate_limit(UserId).
-
-check_request_rate_limit_invalid_user_test() ->
- ?assertEqual(
- {error, invalid_session},
- guild_request_members_filter:check_request_rate_limit(undefined)
- ).
-
-check_guild_request_rate_limit_allows_initial_request_test() ->
- GuildId = 87654321,
- clear_guild_request_rate_limit(GuildId),
- ?assertEqual(ok, guild_request_members_filter:check_guild_request_rate_limit(GuildId)),
- clear_guild_request_rate_limit(GuildId).
-
-check_guild_request_rate_limit_blocks_burst_test() ->
- GuildId = 87654322,
- clear_guild_request_rate_limit(GuildId),
- ensure_ets_table(?REQUEST_MEMBERS_GUILD_RATE_LIMIT_TABLE),
- Now = erlang:system_time(millisecond),
- Timestamps = lists:duplicate(?REQUEST_MEMBERS_GUILD_RATE_LIMIT_MAX_EVENTS, Now - 1000),
- ets:insert(?REQUEST_MEMBERS_GUILD_RATE_LIMIT_TABLE, {GuildId, Timestamps}),
- ?assertEqual(
- {error, rate_limited},
- guild_request_members_filter:check_guild_request_rate_limit(GuildId)
- ),
- clear_guild_request_rate_limit(GuildId).
-
-check_guild_request_rate_limit_invalid_guild_test() ->
- ?assertEqual(
- {error, invalid_guild_id},
- guild_request_members_filter:check_guild_request_rate_limit(invalid_guild_id())
- ).
-
-handle_request_consumes_user_budget_test() ->
- with_rate_limits_enabled(fun() ->
- UserId = 555000001,
- clear_request_rate_limit(UserId),
- SessionState = #{user_id => integer_to_binary(UserId), guilds => #{}, bot => false},
- Data = #{<<"guild_id">> => <<"777000001">>, <<"query">> => <<"a">>, <<"limit">> => 10},
- Results = [
- guild_request_members:handle_request(Data, self(), SessionState)
- || _ <- lists:seq(1, ?REQUEST_MEMBERS_RATE_LIMIT_MAX_EVENTS)
- ],
- ?assertEqual(
- lists:duplicate(?REQUEST_MEMBERS_RATE_LIMIT_MAX_EVENTS, {error, guild_not_found}),
- Results
- ),
- ?assertEqual(
- {error, rate_limited},
- guild_request_members:handle_request(Data, self(), SessionState)
- ),
- clear_request_rate_limit(UserId)
- end).
-
-handle_request_refuses_guild_over_budget_test() ->
- with_rate_limits_enabled(fun() ->
- UserId = 555000002,
- GuildIds = [777000002, 777000003],
- SessionState = spent_guild_session(UserId, GuildIds),
- [GuildIdBin | _] = GuildIdBins = [integer_to_binary(Id) || Id <- GuildIds],
- ?assertEqual(
- {error, rate_limited},
- guild_request_members:handle_request(
- #{<<"guild_id">> => GuildIdBin, <<"query">> => <<"a">>}, self(), SessionState
- )
- ),
- ?assertEqual(
- {error, guild_not_found},
- guild_request_members:handle_request(
- #{<<"guild_ids">> => GuildIdBins, <<"query">> => <<"a">>}, self(), SessionState
- )
- ),
- clear_request_rate_limit(UserId),
- lists:foreach(fun clear_guild_request_rate_limit/1, GuildIds)
- end).
-
-spent_guild_session(UserId, GuildIds) ->
- clear_request_rate_limit(UserId),
- ensure_ets_table(?REQUEST_MEMBERS_GUILD_RATE_LIMIT_TABLE),
- Now = erlang:system_time(millisecond),
- Spent = lists:duplicate(?REQUEST_MEMBERS_GUILD_RATE_LIMIT_MAX_EVENTS, Now - 1000),
- ets:insert(?REQUEST_MEMBERS_GUILD_RATE_LIMIT_TABLE, [{Id, Spent} || Id <- GuildIds]),
- #{
- user_id => integer_to_binary(UserId),
- guilds => maps:from_list([{Id, {self(), make_ref()}} || Id <- GuildIds]),
- bot => false
- }.
-
-handle_request_budgets_disabled_by_env_test() ->
- OldValue = os:getenv("FLUXER_DISABLE_RATE_LIMITS"),
- os:putenv("FLUXER_DISABLE_RATE_LIMITS", "true"),
- try
- UserId = 555000004,
- clear_request_rate_limit(UserId),
- SessionState = #{user_id => integer_to_binary(UserId), guilds => #{}, bot => false},
- Data = #{<<"guild_id">> => <<"777000004">>, <<"query">> => <<"a">>},
- Results = [
- guild_request_members:handle_request(Data, self(), SessionState)
- || _ <- lists:seq(1, ?REQUEST_MEMBERS_RATE_LIMIT_MAX_EVENTS + 1)
- ],
- ?assertEqual(
- lists:duplicate(
- ?REQUEST_MEMBERS_RATE_LIMIT_MAX_EVENTS + 1, {error, guild_not_found}
- ),
- Results
- )
- after
- restore_env("FLUXER_DISABLE_RATE_LIMITS", OldValue)
- end.
-
-rate_limit_tables_outlive_the_request_worker_test() ->
- with_rate_limits_enabled(fun() ->
- UserId = 555000005,
- drop_table(?REQUEST_MEMBERS_RATE_LIMIT_TABLE),
- {ok, OwnerPid} = start_ets_owner(),
- try
- ok = check_rate_limit_in_worker(UserId),
- ?assertMatch(
- [{UserId, [_]}], ets:lookup(?REQUEST_MEMBERS_RATE_LIMIT_TABLE, UserId)
- ),
- ?assertEqual(OwnerPid, ets:info(?REQUEST_MEMBERS_RATE_LIMIT_TABLE, owner))
- after
- gen_server:stop(OwnerPid),
- drop_table(?REQUEST_MEMBERS_RATE_LIMIT_TABLE)
- end
- end).
-
-check_rate_limit_in_worker(UserId) ->
- Self = self(),
- {Worker, Ref} = spawn_monitor(fun() ->
- Self ! {checked, guild_request_members_filter:check_request_rate_limit(UserId)}
- end),
- receive
- {checked, ok} -> ok
- after 1000 -> error(worker_timeout)
- end,
- receive
- {'DOWN', Ref, process, Worker, _} -> ok
- after 1000 -> error(worker_alive)
- end.
-
-drop_table(Name) ->
- case ets:whereis(Name) of
- undefined -> ok;
- _ -> ets:delete(Name)
- end.
-
-prune_expired_entries_drops_idle_keys_test() ->
- Table = ets:new(request_members_prune_test, [public, set]),
- Now = erlang:system_time(millisecond),
- ets:insert(Table, [
- {idle_window, [Now - 20000, Now - 25000]},
- {active_window, [Now - 100, Now - 20000]},
- {idle_bot, Now - 40000},
- {active_bot, Now - 100}
- ]),
- ?assertEqual(ok, guild_request_members_filter:prune_expired_entries(Table, 10000)),
- ?assertEqual(
- [active_bot, active_window],
- lists:sort([Key || {Key, _} <- ets:tab2list(Table)])
- ),
- ets:delete(Table),
- ?assertEqual(gone, guild_request_members_filter:prune_expired_entries(Table, 10000)).
-
-start_ets_owner() ->
- case whereis(guild_ets_owner) of
- undefined -> guild_ets_owner:start_link();
- Existing -> {ok, Existing}
- end.
-
-restore_env(Key, false) ->
- os:unsetenv(Key);
-restore_env(Key, Value) ->
- os:putenv(Key, Value).
-
-with_rate_limits_enabled(Fun) ->
- OldValue = os:getenv("FLUXER_DISABLE_RATE_LIMITS"),
- os:unsetenv("FLUXER_DISABLE_RATE_LIMITS"),
- try
- Fun()
- after
- restore_env("FLUXER_DISABLE_RATE_LIMITS", OldValue)
- end.
-
-clear_full_list_bot_rate_limit(UserId, GuildId) ->
- ensure_ets_table(?FULL_LIST_BOT_RATE_LIMIT_TABLE),
- ets:delete(?FULL_LIST_BOT_RATE_LIMIT_TABLE, {UserId, GuildId}).
-
-invalid_guild_id() ->
- eqwalizer:dynamic_cast(undefined).
-
-clear_request_rate_limit(UserId) ->
- ensure_ets_table(?REQUEST_MEMBERS_RATE_LIMIT_TABLE),
- ets:delete(?REQUEST_MEMBERS_RATE_LIMIT_TABLE, UserId).
-
-clear_guild_request_rate_limit(GuildId) ->
- ensure_ets_table(?REQUEST_MEMBERS_GUILD_RATE_LIMIT_TABLE),
- ets:delete(?REQUEST_MEMBERS_GUILD_RATE_LIMIT_TABLE, GuildId).
-
-ensure_ets_table(Name) ->
- case ets:whereis(Name) of
- undefined ->
- try
- ets:new(Name, [
- named_table,
- public,
- set,
- {read_concurrency, true},
- {write_concurrency, true}
- ]),
- ok
- catch
- error:badarg -> ok
- end;
- _ ->
- ok
- end.
diff --git a/fluxer_gateway/test/guild_session_tracking_tests.erl b/fluxer_gateway/test/guild_session_tracking_tests.erl
deleted file mode 100644
index 06d517613..000000000
--- a/fluxer_gateway/test/guild_session_tracking_tests.erl
+++ /dev/null
@@ -1,400 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_session_tracking_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(GUILD_ID, 910100).
--define(CHANNEL_ID, 910500).
--define(USER_A, 810001).
--define(USER_B, 810002).
--define(USER_C, 810003).
-
-handoff_reconnect_counts_each_session_once_test_() ->
- {timeout, 60, fun handoff_reconnect_counts_each_session_once/0}.
-
-handoff_reconnect_overflow_keeps_tracking_test_() ->
- {timeout, 60, fun handoff_reconnect_overflow_keeps_tracking/0}.
-
-reconnect_of_connected_session_counts_once_test_() ->
- {timeout, 60, fun reconnect_of_connected_session_counts_once/0}.
-
-not_member_reconnect_releases_tracking_test_() ->
- {timeout, 60, fun not_member_reconnect_releases_tracking/0}.
-
-reconnecting_session_down_releases_tracking_test_() ->
- {timeout, 60, fun reconnecting_session_down_releases_tracking/0}.
-
-fresh_pending_down_keeps_reconnecting_owner_tracked_test_() ->
- {timeout, 60, fun fresh_pending_down_keeps_reconnecting_owner_tracked/0}.
-
-unavailable_removal_of_fresh_pending_keeps_owner_tracked_test_() ->
- {timeout, 60, fun unavailable_removal_of_fresh_pending_keeps_owner_tracked/0}.
-
-fresh_pending_sibling_keeps_mutual_members_test_() ->
- {timeout, 60, fun fresh_pending_sibling_keeps_mutual_members/0}.
-
-handoff_reconnect_counts_each_session_once() ->
- with_sessions(
- [{<<"a1">>, ?USER_A}, {<<"a2">>, ?USER_A}, {<<"b1">>, ?USER_B}],
- fun(Sessions) ->
- with_guild(base_state(Sessions), fun(Source) ->
- await_tracking(#{?USER_A => 2, ?USER_B => 1}, Source),
- {ok, Exported} = gen_server:call(Source, export_handoff_state, 10000),
- with_guild(transferred_state(Exported), fun(Target) ->
- await_tracking(#{?USER_A => 2, ?USER_B => 1}, Target),
- reconnect_all(Target, Sessions, 0),
- await_tracking(#{?USER_A => 2, ?USER_B => 1}, Target),
- kill_session(<<"b1">>, Sessions),
- await_tracking(#{?USER_A => 2}, Target),
- kill_session(<<"a1">>, Sessions),
- await_tracking(#{?USER_A => 1}, Target),
- kill_session(<<"a2">>, Sessions),
- await_tracking(#{}, Target)
- end)
- end)
- end
- ).
-
-handoff_reconnect_overflow_keeps_tracking() ->
- with_sessions(
- [{<<"a1">>, ?USER_A}, {<<"b1">>, ?USER_B}, {<<"c1">>, ?USER_C}],
- fun(Sessions) ->
- with_guild(base_state(Sessions), fun(Source) ->
- {ok, Exported} = gen_server:call(Source, export_handoff_state, 10000),
- with_guild(transferred_state(Exported), fun(Target) ->
- Expected = #{?USER_A => 1, ?USER_B => 1, ?USER_C => 1},
- await_tracking(Expected, Target),
- hold_connect_workers(Target, 1),
- [
- send_connect(Target, Sid, Sessions, 0)
- || Sid <- [<<"a1">>, <<"b1">>, <<"c1">>]
- ],
- ?assertEqual({error, overloaded}, await_result(<<"a1">>, 0)),
- ?assertEqual({error, overloaded}, await_result(<<"b1">>, 0)),
- State = get_state(Target),
- Dropped = maps:get(<<"a1">>, maps:get(sessions, State)),
- ?assertEqual(true, maps:get(pending_connect, Dropped)),
- ?assertNot(maps:is_key(<<"a1">>, maps:get(session_connect_pending, State))),
- assert_tracking(Expected, State),
- release_connect_workers(Target),
- ?assertMatch({ok, _, _}, await_result(<<"c1">>, 0)),
- send_connect(Target, <<"a1">>, Sessions, 1),
- send_connect(Target, <<"b1">>, Sessions, 1),
- ?assertMatch({ok, _, _}, await_result(<<"a1">>, 1)),
- ?assertMatch({ok, _, _}, await_result(<<"b1">>, 1)),
- await_tracking(Expected, Target),
- kill_session(<<"a1">>, Sessions),
- await_tracking(#{?USER_B => 1, ?USER_C => 1}, Target)
- end)
- end)
- end
- ).
-
-reconnect_of_connected_session_counts_once() ->
- with_sessions(
- [{<<"a1">>, ?USER_A}, {<<"b1">>, ?USER_B}],
- fun(Sessions) ->
- with_guild(base_state(Sessions), fun(Guild) ->
- reconnect_all(Guild, Sessions, 1),
- reconnect_all(Guild, Sessions, 2),
- State = get_state(Guild),
- assert_tracking(#{?USER_A => 1, ?USER_B => 1}, State),
- [
- ?assertEqual(false, maps:get(pending_connect, Entry))
- || Entry <- maps:values(maps:get(sessions, State))
- ],
- kill_session(<<"b1">>, Sessions),
- await_tracking(#{?USER_A => 1}, Guild)
- end)
- end
- ).
-
-not_member_reconnect_releases_tracking() ->
- with_sessions(
- [{<<"a1">>, ?USER_A}, {<<"b1">>, ?USER_B}],
- fun(Sessions) ->
- with_guild(base_state(Sessions), fun(Guild) ->
- sys:replace_state(Guild, fun(S) ->
- S#{
- data => guild_data_index_members:remove_member(
- ?USER_B, maps:get(data, S)
- )
- }
- end),
- send_connect(Guild, <<"b1">>, Sessions, 1),
- ?assertEqual({error, not_member}, await_result(<<"b1">>, 1)),
- State = get_state(Guild),
- ?assertNot(maps:is_key(<<"b1">>, maps:get(sessions, State))),
- assert_tracking(#{?USER_A => 1}, State)
- end)
- end
- ).
-
-reconnecting_session_down_releases_tracking() ->
- with_sessions(
- [{<<"a1">>, ?USER_A}, {<<"b1">>, ?USER_B}],
- fun(Sessions) ->
- with_guild(base_state(Sessions), fun(Guild) ->
- hold_connect_workers(Guild, 16),
- send_connect(Guild, <<"b1">>, Sessions, 1),
- Pending = maps:get(<<"b1">>, maps:get(sessions, get_state(Guild))),
- ?assertEqual(true, maps:get(pending_connect, Pending)),
- await_tracking(#{?USER_A => 1, ?USER_B => 1}, Guild),
- kill_session(<<"b1">>, Sessions),
- await_tracking(#{?USER_A => 1}, Guild)
- end)
- end
- ).
-
-fresh_pending_down_keeps_reconnecting_owner_tracked() ->
- with_sessions(
- [{<<"a1">>, ?USER_A}, {<<"a2">>, ?USER_A}, {<<"c1">>, ?USER_C}],
- fun(Sessions) ->
- with_guild(base_state(without(<<"a1">>, Sessions)), fun(Guild) ->
- hold_connect_workers(Guild, 16),
- send_connect(Guild, <<"a2">>, Sessions, 1),
- send_connect(Guild, <<"a1">>, Sessions, 1),
- kill_session(<<"a1">>, Sessions),
- await_tracking(#{?USER_A => 1, ?USER_C => 1}, Guild),
- release_connect_workers(Guild),
- ?assertMatch({ok, _, _}, await_result(<<"a2">>, 1)),
- await_tracking(#{?USER_A => 1, ?USER_C => 1}, Guild),
- kill_session(<<"a2">>, Sessions),
- await_tracking(#{?USER_C => 1}, Guild)
- end)
- end
- ).
-
-unavailable_removal_of_fresh_pending_keeps_owner_tracked() ->
- with_sessions(
- [{<<"a1">>, ?USER_A}, {<<"a2">>, ?USER_A}],
- fun(Sessions) ->
- with_guild(base_state(without(<<"a1">>, Sessions)), fun(Guild) ->
- hold_connect_workers(Guild, 16),
- send_connect(Guild, <<"a1">>, Sessions, 1),
- sys:replace_state(Guild, fun(S) ->
- guild_sessions_connect:remove_session(<<"a1">>, S)
- end),
- State = get_state(Guild),
- ?assertNot(maps:is_key(<<"a1">>, maps:get(sessions, State))),
- assert_tracking(#{?USER_A => 1}, State)
- end)
- end
- ).
-
-fresh_pending_sibling_keeps_mutual_members() ->
- with_sessions(
- [{<<"a1">>, ?USER_A}, {<<"a2">>, ?USER_A}, {<<"c1">>, ?USER_C}],
- fun(Sessions) ->
- with_guild(base_state(without(<<"a1">>, Sessions)), fun(Guild) ->
- send_connect(Guild, <<"a2">>, Sessions, 1),
- ?assertMatch({ok, _, _}, await_result(<<"a2">>, 1)),
- hold_connect_workers(Guild, 16),
- send_connect(Guild, <<"a1">>, Sessions, 1),
- State = get_state(Guild),
- SessionMap = maps:get(<<"a2">>, maps:get(sessions, State)),
- ?assertEqual(
- #{?CHANNEL_ID => true}, maps:get(viewable_channels, SessionMap)
- ),
- ?assertEqual(
- true,
- maps:get(pending_connect, maps:get(<<"a1">>, maps:get(sessions, State)))
- ),
- ?assertEqual(
- #{?CHANNEL_ID => true},
- guild_visibility_channels:get_cached_viewable_channel_map(?USER_A, State)
- ),
- ?assertEqual(
- [?USER_C],
- guild_subscription_mutual_channels:filter_member_ids(
- #{}, ?USER_A, [?USER_C], State
- )
- )
- end)
- end
- ).
-
-await_tracking(Expected, Guild) ->
- await_tracking(Expected, Guild, 100).
-
-await_tracking(Expected, Guild, 0) ->
- assert_tracking(Expected, get_state(Guild));
-await_tracking(Expected, Guild, Tries) ->
- case tracking(get_state(Guild)) =:= expected_tracking(Expected) of
- true ->
- ok;
- false ->
- timer:sleep(20),
- await_tracking(Expected, Guild, Tries - 1)
- end.
-
-assert_tracking(Expected, State) ->
- ?assertEqual(expected_tracking(Expected), tracking(State)).
-
-expected_tracking(Expected) ->
- {Expected, lists:sort(maps:keys(Expected)), Expected}.
-
-tracking(State) ->
- {
- maps:get(user_session_counts, State),
- lists:sort(sets:to_list(maps:get(connected_user_ids, State))),
- maps:get(presence_subscriptions, State)
- }.
-
-with_sessions(Specs, Fun) ->
- Parent = self(),
- Sessions = [
- {Sid, UserId, spawn(fun() -> session_loop(Parent, Sid) end)}
- || {Sid, UserId} <- Specs
- ],
- try
- Fun(Sessions)
- after
- [exit(Pid, kill) || {_, _, Pid} <- Sessions],
- flush()
- end.
-
-session_loop(Parent, Sid) ->
- receive
- {guild_connect_result, _GuildId, Attempt, Reply} ->
- Parent ! {connect_result, Sid, Attempt, Reply},
- session_loop(Parent, Sid);
- _ ->
- session_loop(Parent, Sid)
- end.
-
-without(Sid, Sessions) ->
- lists:keydelete(Sid, 1, Sessions).
-
-with_guild(State, Fun) ->
- {ok, Pid} = gen_server:start(guild, State, []),
- try
- Fun(Pid)
- after
- catch gen_server:call(Pid, {terminate}, 5000)
- end.
-
-get_state(Guild) ->
- gen_server:call(Guild, {get_sessions}, 10000).
-
-hold_connect_workers(Guild, MaxQueue) ->
- sys:replace_state(Guild, fun(S) ->
- S#{session_connect_inflight => 8, session_connect_max_queue => MaxQueue}
- end),
- ok.
-
-release_connect_workers(Guild) ->
- sys:replace_state(Guild, fun(S) ->
- guild_connect_async:maybe_start_session_connect_workers(
- S#{session_connect_inflight => 0, session_connect_max_queue => 16}
- )
- end),
- ok.
-
-reconnect_all(Guild, Sessions, Attempt) ->
- [send_connect(Guild, Sid, Sessions, Attempt) || {Sid, _, _} <- Sessions],
- [?assertMatch({ok, _, _}, await_result(Sid, Attempt)) || {Sid, _, _} <- Sessions],
- ok.
-
-send_connect(Guild, Sid, Sessions, Attempt) ->
- {Sid, UserId, Pid} = lists:keyfind(Sid, 1, Sessions),
- Request = #{
- session_id => Sid,
- user_id => UserId,
- session_pid => Pid,
- bot => false,
- is_staff => false,
- initial_guild_id => ?GUILD_ID,
- active_guilds => sets:from_list([?GUILD_ID])
- },
- gen_server:cast(
- Guild,
- {session_connect_async, #{
- guild_id => ?GUILD_ID, attempt => Attempt, request => Request
- }}
- ).
-
-await_result(Sid, Attempt) ->
- receive
- {connect_result, Sid, Attempt, Reply} -> Reply
- after 10000 ->
- error({no_connect_result, Sid, Attempt})
- end.
-
-kill_session(Sid, Sessions) ->
- {Sid, _UserId, Pid} = lists:keyfind(Sid, 1, Sessions),
- Ref = monitor(process, Pid),
- exit(Pid, kill),
- receive
- {'DOWN', Ref, process, Pid, _} -> ok
- end.
-
-flush() ->
- receive
- {connect_result, _, _, _} -> flush()
- after 0 ->
- ok
- end.
-
-transferred_state(Exported) ->
- guild_manager_shard_lifecycle:normalize_transferred_guild_state(?GUILD_ID, Exported).
-
-base_state(Sessions) ->
- Members = [member(UserId) || UserId <- [?USER_A, ?USER_B, ?USER_C]],
- #{
- id => ?GUILD_ID,
- member_count => length(Members),
- sessions => maps:from_list([
- {Sid, #{
- session_id => Sid,
- user_id => UserId,
- pid => Pid,
- active_guilds => sets:from_list([?GUILD_ID])
- }}
- || {Sid, UserId, Pid} <- Sessions
- ]),
- data => #{
- <<"guild">> => #{
- <<"id">> => ?GUILD_ID,
- <<"owner_id">> => ?USER_A,
- <<"features">> => [],
- <<"member_count">> => length(Members)
- },
- <<"roles">> => [
- #{
- <<"id">> => ?GUILD_ID,
- <<"name">> => <<"everyone">>,
- <<"permissions">> =>
- constants:view_channel_permission() bor
- constants:view_channel_members_permission(),
- <<"hoist">> => false,
- <<"position">> => 0
- }
- ],
- <<"channels">> => [
- #{
- <<"id">> => ?CHANNEL_ID,
- <<"name">> => <<"general">>,
- <<"type">> => 0,
- <<"permission_overwrites">> => []
- }
- ],
- <<"members">> => Members
- }
- }.
-
-member(UserId) ->
- Name = integer_to_binary(UserId),
- #{
- <<"user">> => #{
- <<"id">> => UserId,
- <<"username">> => <<"u", Name/binary>>,
- <<"global_name">> => <<"U", Name/binary>>,
- <<"bot">> => false
- },
- <<"nick">> => null,
- <<"roles">> => [],
- <<"joined_at">> => <<"2026-01-01T00:00:00.000000+00:00">>
- }.
diff --git a/fluxer_gateway/test/guild_sessions_connect_tests.erl b/fluxer_gateway/test/guild_sessions_connect_tests.erl
deleted file mode 100644
index 71b3a88d9..000000000
--- a/fluxer_gateway/test/guild_sessions_connect_tests.erl
+++ /dev/null
@@ -1,208 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_sessions_connect_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-build_initial_last_message_ids_empty_channels_test() ->
- ?assertEqual(
- #{}, guild_sessions_connect:build_initial_last_message_ids(#{<<"channels">> => []})
- ).
-
-build_initial_last_message_ids_with_channels_test() ->
- GuildState = #{
- <<"channels">> => [
- #{<<"id">> => <<"100">>, <<"last_message_id">> => <<"500">>},
- #{<<"id">> => <<"101">>, <<"last_message_id">> => <<"600">>}
- ]
- },
- ?assertEqual(
- #{<<"100">> => <<"500">>, <<"101">> => <<"600">>},
- guild_sessions_connect:build_initial_last_message_ids(GuildState)
- ).
-
-build_initial_last_message_ids_normalizes_integer_ids_test() ->
- GuildState = #{
- <<"channels">> => [
- #{<<"id">> => 100, <<"last_message_id">> => 500},
- #{<<"id">> => 101, <<"last_message_id">> => <<"600">>}
- ]
- },
- ?assertEqual(
- #{<<"100">> => <<"500">>, <<"101">> => <<"600">>},
- guild_sessions_connect:build_initial_last_message_ids(GuildState)
- ).
-
-build_initial_last_message_ids_filters_null_test() ->
- GuildState = #{
- <<"channels">> => [
- #{<<"id">> => <<"100">>, <<"last_message_id">> => <<"500">>},
- #{<<"id">> => <<"101">>, <<"last_message_id">> => null},
- #{<<"id">> => <<"102">>}
- ]
- },
- ?assertEqual(
- #{<<"100">> => <<"500">>},
- guild_sessions_connect:build_initial_last_message_ids(GuildState)
- ).
-
-build_initial_channel_versions_test() ->
- GuildState = #{
- <<"channels">> => [
- #{<<"id">> => <<"100">>, <<"version">> => 5},
- #{<<"id">> => <<"101">>}
- ]
- },
- ?assertEqual(
- #{<<"100">> => 5, <<"101">> => 0},
- guild_sessions_connect:build_initial_channel_versions(GuildState)
- ).
-
-build_initial_channel_versions_normalizes_integer_ids_test() ->
- GuildState = #{
- <<"channels">> => [
- #{<<"id">> => 100, <<"version">> => 5},
- #{<<"id">> => 101}
- ]
- },
- ?assertEqual(
- #{<<"100">> => 5, <<"101">> => 0},
- guild_sessions_connect:build_initial_channel_versions(GuildState)
- ).
-
-remove_session_cleans_connect_pending_test() ->
- SessionId = <<"s1">>,
- State = remove_session_state(SessionId),
- NewState = guild_sessions_connect:remove_session(SessionId, State),
- #{} = Pending = maps:get(session_connect_pending, NewState, #{}),
- ?assertEqual(false, maps:is_key(SessionId, Pending)),
- ?assertEqual(true, maps:is_key(<<"s2">>, Pending)).
-
-remove_session_clears_ref_index_test() ->
- SessionId = <<"s1">>,
- State0 = remove_session_state(SessionId),
- Session = maps:get(SessionId, maps:get(sessions, State0)),
- Ref = maps:get(mref, Session),
- State = State0#{guild_session_refs => #{Ref => SessionId}},
- NewState = guild_sessions_connect:remove_session(SessionId, State),
- Refs = map_utils:ensure_map(maps:get(guild_session_refs, NewState, #{})),
- ?assertEqual(false, maps:is_key(Ref, Refs)).
-
-cleanup_connect_admission_queue_format_test() ->
- S1 = <<"s1">>,
- S2 = <<"s2">>,
- S3 = <<"s3">>,
- Queue = queue:from_list([
- #{request => #{session_id => S1}, attempt => 0},
- #{request => #{session_id => S2}, attempt => 1},
- #{request => #{session_id => S1}, attempt => 2},
- #{request => #{session_id => S3}, attempt => 3}
- ]),
- State1 = guild_sessions_connect_cleanup:cleanup_connect_admission_for_session(
- S1, #{
- sessions => #{},
- session_connect_pending => #{S1 => 2},
- session_connect_queue => Queue
- }
- ),
- ResultQueue = queue:to_list(maps:get(session_connect_queue, State1)),
- SessionIds = [
- maps:get(session_id, maps:get(request, Item, #{}), undefined)
- || Item <- ResultQueue
- ],
- ?assertEqual(2, length(ResultQueue)),
- ?assertEqual(false, lists:member(S1, SessionIds)),
- ?assertEqual(true, lists:member(S2, SessionIds)),
- ?assertEqual(true, lists:member(S3, SessionIds)).
-
-session_down_clears_passive_sync_entry_test() ->
- ok = passive_sync_registry:init(),
- SessionId = <<"passive-down">>,
- ok = passive_sync_registry:store(SessionId, 42, stored_passive_state()),
- {Ref, Session, State} = down_state(SessionId),
- {noreply, _} = guild_sessions_connect:handle_session_down(Ref, {SessionId, Session}, State),
- ?assertEqual([], ets:lookup(passive_sync_registry, {SessionId, 42})).
-
-remove_session_clears_passive_sync_entry_test() ->
- ok = passive_sync_registry:init(),
- SessionId = <<"passive-remove">>,
- ok = passive_sync_registry:store(SessionId, 42, stored_passive_state()),
- _ = guild_sessions_connect:remove_session(SessionId, remove_session_state(SessionId)),
- ?assertEqual([], ets:lookup(passive_sync_registry, {SessionId, 42})).
-
-passive_sync_registry_stays_bounded_across_session_cycles_test() ->
- ok = passive_sync_registry:init(),
- GuildRows = fun() -> length(ets:match(passive_sync_registry, {{'_', 42}, '_'})) end,
- Before = GuildRows(),
- lists:foreach(
- fun(N) ->
- SessionId = <<"cycle-", (integer_to_binary(N))/binary>>,
- ok = passive_sync_registry:store(SessionId, 42, stored_passive_state()),
- {Ref, Session, State} = down_state(SessionId),
- {noreply, _} = guild_sessions_connect:handle_session_down(
- Ref, {SessionId, Session}, State
- )
- end,
- lists:seq(1, 500)
- ),
- ?assertEqual(Before, GuildRows()).
-
-guild_terminate_clears_passive_sync_entries_test() ->
- ok = passive_sync_registry:init(),
- GuildId = 4242,
- OtherGuildId = 4343,
- lists:foreach(
- fun({SessionId, GId}) ->
- ok = passive_sync_registry:store(SessionId, GId, stored_passive_state())
- end,
- [{<<"t1">>, GuildId}, {<<"t2">>, GuildId}, {<<"t1">>, OtherGuildId}]
- ),
- ok = guild:terminate(shutdown, #{
- id => GuildId,
- sessions => #{<<"t1">> => #{}, <<"t2">> => #{}}
- }),
- ?assertEqual([], ets:lookup(passive_sync_registry, {<<"t1">>, GuildId})),
- ?assertEqual([], ets:lookup(passive_sync_registry, {<<"t2">>, GuildId})),
- ?assertEqual(
- stored_passive_state(), passive_sync_registry:lookup(<<"t1">>, OtherGuildId)
- ),
- ok = passive_sync_registry:delete(<<"t1">>, OtherGuildId).
-
-stored_passive_state() ->
- #{
- previous_passive_updates => #{<<"1">> => <<"2">>},
- previous_passive_channel_versions => #{},
- previous_passive_voice_states => #{}
- }.
-
-down_state(SessionId) ->
- State0 = remove_session_state(SessionId),
- Session = maps:get(SessionId, maps:get(sessions, State0)),
- Ref = maps:get(mref, Session),
- {Ref, Session, State0#{guild_session_refs => #{Ref => SessionId}}}.
-
-remove_session_state(SessionId) ->
- SessionData = #{
- session_id => SessionId,
- user_id => 1,
- pid => self(),
- mref => make_ref(),
- active_guilds => sets:new(),
- user_roles => [],
- bot => false
- },
- #{
- id => 42,
- sessions => #{SessionId => SessionData},
- presence_subscriptions => #{1 => 1},
- member_list_subscriptions => guild_member_list_subs:new(),
- member_subscriptions => guild_subscriptions:init_state(),
- connected_user_ids => sets:new(),
- user_session_counts => #{},
- session_connect_pending => #{SessionId => 3, <<"s2">> => 1},
- session_connect_queue => [
- #{request => #{session_id => SessionId}, attempt => 3},
- #{request => #{session_id => <<"s2">>}, attempt => 1}
- ]
- }.
diff --git a/fluxer_gateway/test/guild_sessions_tests.erl b/fluxer_gateway/test/guild_sessions_tests.erl
deleted file mode 100644
index 0bd2d1770..000000000
--- a/fluxer_gateway/test/guild_sessions_tests.erl
+++ /dev/null
@@ -1,203 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_sessions_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-filter_sessions_for_channel_uses_cached_viewable_channels_test() ->
- SessionId = <<"s1">>,
- SessionData = #{
- session_id => SessionId,
- user_id => 10,
- pid => self(),
- viewable_channels => #{200 => true}
- },
- Sessions = #{SessionId => SessionData},
- State = #{sessions => Sessions, data => #{<<"members">> => #{}}},
- Result = guild_sessions:filter_sessions_for_channel(Sessions, 200, undefined, State),
- ?assertEqual([{SessionId, SessionData}], Result).
-
-filter_sessions_exclude_session_specific_test() ->
- Sessions = #{<<"s1">> => #{}, <<"s2">> => #{}},
- Result = guild_sessions:filter_sessions_exclude_session(Sessions, <<"s1">>),
- ?assertEqual(1, length(Result)),
- ?assertEqual([{<<"s2">>, #{}}], Result).
-
-pending_connect_filtered_from_channel_sessions_test() ->
- NormalSession = #{
- session_id => <<"s1">>,
- user_id => 10,
- pid => self(),
- viewable_channels => #{200 => true}
- },
- PendingSession = #{
- session_id => <<"s2">>,
- user_id => 11,
- pid => self(),
- pending_connect => true,
- viewable_channels => #{200 => true}
- },
- Sessions = #{<<"s1">> => NormalSession, <<"s2">> => PendingSession},
- State = #{sessions => Sessions, data => #{<<"members">> => #{}}},
- Result = guild_sessions:filter_sessions_for_channel(Sessions, 200, undefined, State),
- ?assertEqual(1, length(Result)),
- [{ResultSid, _}] = Result,
- ?assertEqual(<<"s1">>, ResultSid).
-
-refresh_user_session_cache_updates_roles_and_viewable_channels_test() ->
- UserId = 10,
- GuildId = 42,
- RoleId = 99,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- },
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"channels">> => [
- #{<<"id">> => <<"100">>, <<"permission_overwrites">> => []}
- ],
- <<"members">> => #{
- UserId => #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [integer_to_binary(RoleId)]
- }
- }
- },
- sessions => #{
- <<"s1">> => #{user_id => UserId, user_roles => [], viewable_channels => #{}},
- <<"s2">> => #{user_id => 20, user_roles => [1], viewable_channels => #{200 => true}}
- }
- },
- Result = guild_sessions:refresh_user_session_cache(UserId, State),
- S1 = maps:get(<<"s1">>, maps:get(sessions, Result)),
- S2 = maps:get(<<"s2">>, maps:get(sessions, Result)),
- ?assertEqual([RoleId], maps:get(user_roles, S1)),
- ?assert(maps:is_key(100, maps:get(viewable_channels, S1))),
- ?assertEqual([1], maps:get(user_roles, S2)),
- ?assertEqual(#{200 => true}, maps:get(viewable_channels, S2)).
-
-filter_sessions_exclude_session_filters_pending_test() ->
- Sessions = #{
- <<"s1">> => #{pending_connect => true},
- <<"s2">> => #{},
- <<"s3">> => #{pending_connect => false}
- },
- Result = guild_sessions:filter_sessions_exclude_session(Sessions, undefined),
- ResultIds = lists:sort([Sid || {Sid, _} <- Result]),
- ?assertEqual([<<"s2">>, <<"s3">>], ResultIds).
-
-filter_sessions_for_channel_excludes_specified_session_test() ->
- S1 = #{
- session_id => <<"s1">>,
- user_id => 10,
- pid => self(),
- viewable_channels => #{200 => true}
- },
- S2 = #{
- session_id => <<"s2">>,
- user_id => 11,
- pid => self(),
- viewable_channels => #{200 => true}
- },
- Sessions = #{<<"s1">> => S1, <<"s2">> => S2},
- State = #{sessions => Sessions, data => #{<<"members">> => #{}}},
- Result = guild_sessions:filter_sessions_for_channel(Sessions, 200, <<"s1">>, State),
- ?assertEqual(1, length(Result)),
- [{ResultSid, _}] = Result,
- ?assertEqual(<<"s2">>, ResultSid).
-
-filter_sessions_for_channel_falls_back_to_permission_check_test() ->
- GuildId = 42,
- UserId = 10,
- ChannelId = 200,
- ViewPerm = constants:view_channel_permission(),
- SessionData = #{session_id => <<"s1">>, user_id => UserId, pid => self()},
- Sessions = #{<<"s1">> => SessionData},
- State = #{
- id => GuildId,
- sessions => Sessions,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"members">> => #{
- UserId => #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => []
- }
- },
- <<"channels">> => [
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"permission_overwrites">> => []
- }
- ]
- }
- },
- Result = guild_sessions:filter_sessions_for_channel(Sessions, ChannelId, undefined, State),
- ?assertEqual(1, length(Result)).
-
-filter_sessions_for_channel_no_member_returns_empty_test() ->
- SessionData = #{session_id => <<"s1">>, user_id => 999, pid => self()},
- Sessions = #{<<"s1">> => SessionData},
- State = #{
- sessions => Sessions,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"888">>},
- <<"members">> => [],
- <<"roles">> => [],
- <<"channels">> => []
- }
- },
- Result = guild_sessions:filter_sessions_for_channel(Sessions, 200, undefined, State),
- ?assertEqual([], Result).
-
-refresh_all_viewable_channels_populates_cache_test() ->
- SessionId = <<"s1">>,
- UserId = 10,
- GuildId = 42,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- sessions => #{
- SessionId => #{session_id => SessionId, user_id => UserId, pid => self()}
- },
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"members">> => #{
- UserId => #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => []
- }
- },
- <<"channels">> => [
- #{<<"id">> => <<"200">>, <<"permission_overwrites">> => []}
- ]
- }
- },
- UpdatedState = guild_sessions:refresh_all_viewable_channels(State),
- UpdatedSessions = maps:get(sessions, UpdatedState, #{}),
- UpdatedSession = maps:get(SessionId, UpdatedSessions),
- ViewableChannels = maps:get(viewable_channels, UpdatedSession, #{}),
- ?assertEqual(true, maps:is_key(200, ViewableChannels)).
diff --git a/fluxer_gateway/test/guild_state_channel_resync_tests.erl b/fluxer_gateway/test/guild_state_channel_resync_tests.erl
deleted file mode 100644
index 287555371..000000000
--- a/fluxer_gateway/test/guild_state_channel_resync_tests.erl
+++ /dev/null
@@ -1,164 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_state_channel_resync_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(GUILD_ID, 9100).
--define(CHANNEL_ID, 9500).
--define(ROLE_ID, 9200).
--define(USER_A, 9010).
--define(USER_B, 9020).
--define(USER_C, 9030).
-
-channel_update_syncs_every_subscriber_after_permission_change_test() ->
- with_relay_mock(fun run_channel_update_syncs_every_subscriber/0).
-
-channel_update_bulk_syncs_every_subscriber_after_permission_change_test() ->
- with_relay_mock(fun run_channel_update_bulk_syncs_every_subscriber/0).
-
-run_channel_update_syncs_every_subscriber() ->
- run_resync_case(channel_update, denied_channel()).
-
-run_channel_update_bulk_syncs_every_subscriber() ->
- run_resync_case(channel_update_bulk, #{<<"channels">> => [denied_channel()]}).
-
-run_resync_case(Event, EventData) ->
- PidA = spawn(fun idle/0),
- PidB = spawn(fun idle/0),
- SubsTab = guild_member_list_subs:new(),
- State0 = base_state(SubsTab, PidA, PidB),
- {State1, _SyncA, _RangesA} = guild_member_list_subscribe:subscribe_ranges(
- <<"s_a">>, list_id(), [{0, 99}], State0
- ),
- {State2, _SyncB, _RangesB} = guild_member_list_subscribe:subscribe_ranges(
- <<"s_b">>, list_id(), [{0, 99}], State1
- ),
- try
- ?assertEqual({3, 0}, guild_member_list_read:get_counts(list_id(), State2)),
- {noreply, UpdatedState} = guild_dispatch:handle_dispatch(Event, EventData, State2),
- ?assertEqual({2, 0}, guild_member_list_read:get_counts(list_id(), UpdatedState)),
- {Pids, Raw, Payload} = receive_member_list_dispatch(),
- ?assertEqual(lists:sort([PidA, PidB]), lists:sort(Pids)),
- ?assertEqual(list_id(), maps:get(<<"channel_id">>, Payload)),
- ?assertEqual(list_id(), maps:get(<<"id">>, Payload)),
- ?assertEqual(2, maps:get(<<"member_count">>, Payload)),
- ?assertEqual(nomatch, binary:match(Raw, integer_to_binary(?USER_C))),
- assert_no_further_dispatch(),
- guild_member_list_channel_engine:destroy_all(UpdatedState)
- after
- PidA ! stop,
- PidB ! stop,
- ets:delete(SubsTab)
- end.
-
-base_state(SubsTab, PidA, PidB) ->
- #{
- id => ?GUILD_ID,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(?GUILD_ID),
- <<"permissions">> => integer_to_binary(viewer_permissions())
- },
- #{<<"id">> => integer_to_binary(?ROLE_ID), <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- member(?USER_A, []),
- member(?USER_B, []),
- member(?USER_C, [integer_to_binary(?ROLE_ID)])
- ],
- <<"channels">> => [visible_channel()]
- },
- sessions => #{
- <<"s_a">> => session(<<"s_a">>, ?USER_A, PidA),
- <<"s_b">> => session(<<"s_b">>, ?USER_B, PidB)
- },
- member_presence => #{},
- member_list_subscriptions => SubsTab
- }.
-
-session(SessionId, UserId, Pid) ->
- #{
- session_id => SessionId,
- user_id => UserId,
- pid => Pid,
- viewable_channels => #{?CHANNEL_ID => true}
- }.
-
-member(UserId, Roles) ->
- #{
- <<"user">> => #{
- <<"id">> => integer_to_binary(UserId),
- <<"username">> => <<"u", (integer_to_binary(UserId))/binary>>
- },
- <<"roles">> => Roles
- }.
-
-visible_channel() ->
- #{<<"id">> => list_id(), <<"type">> => 0, <<"permission_overwrites">> => []}.
-
-denied_channel() ->
- #{
- <<"id">> => list_id(),
- <<"type">> => 0,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(?ROLE_ID),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(constants:view_channel_permission())
- }
- ]
- }.
-
-viewer_permissions() ->
- constants:view_channel_permission() bor constants:view_channel_members_permission().
-
-list_id() ->
- integer_to_binary(?CHANNEL_ID).
-
-with_relay_mock(Fun) ->
- meck:new(gateway_dispatch_relay, [passthrough, no_link]),
- Parent = self(),
- meck:expect(
- gateway_dispatch_relay,
- dispatch_many,
- fun
- (Pids, guild_member_list_update, {pre_encoded, Bin}, GuildId) when is_binary(Bin) ->
- Parent ! {member_list_dispatch, Pids, guild_member_list_update, GuildId, Bin},
- ok;
- (_Pids, _Event, _Payload, _GuildId) ->
- ok
- end
- ),
- try
- Fun()
- after
- meck:unload(gateway_dispatch_relay)
- end.
-
-receive_member_list_dispatch() ->
- receive
- {member_list_dispatch, Pids, guild_member_list_update, ?GUILD_ID, Bin} ->
- {Pids, Bin, json:decode(Bin)}
- after 1000 ->
- ?assert(false, no_member_list_sync_dispatched),
- {[], <<>>, #{}}
- end.
-
-assert_no_further_dispatch() ->
- receive
- {member_list_dispatch, _Pids, _Event, _GuildId, _Bin} = Msg ->
- ?assert(false, {unexpected_member_list_dispatch, Msg})
- after 0 ->
- ok
- end.
-
-idle() ->
- receive
- stop -> ok
- after 30000 -> ok
- end.
diff --git a/fluxer_gateway/test/guild_state_roles_tests.erl b/fluxer_gateway/test/guild_state_roles_tests.erl
deleted file mode 100644
index f8dde30fd..000000000
--- a/fluxer_gateway/test/guild_state_roles_tests.erl
+++ /dev/null
@@ -1,178 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_state_roles_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-handle_role_delete_strips_from_members_test() ->
- RoleIdToDelete = <<"200">>,
- Data = guild_data_index:normalize_map(#{
- <<"roles">> => [
- #{<<"id">> => <<"100">>, <<"name">> => <<"Admin">>},
- #{<<"id">> => <<"200">>, <<"name">> => <<"Moderator">>}
- ],
- <<"members">> => #{
- 1 => #{<<"user">> => #{<<"id">> => <<"1">>}, <<"roles">> => [<<"100">>, <<"200">>]},
- 2 => #{<<"user">> => #{<<"id">> => <<"2">>}, <<"roles">> => [<<"200">>]},
- 3 => #{<<"user">> => #{<<"id">> => <<"3">>}, <<"roles">> => [<<"100">>]}
- },
- <<"channels">> => []
- }),
- EventData = #{<<"role_id">> => RoleIdToDelete},
- Result = guild_state_roles:handle_role_delete(EventData, Data),
- Members = maps:get(<<"members">>, Result),
- M1 = maps:get(1, Members),
- M2 = maps:get(2, Members),
- M3 = maps:get(3, Members),
- ?assertEqual([100], maps:get(<<"roles">>, M1)),
- ?assertEqual([], maps:get(<<"roles">>, M2)),
- ?assertEqual([100], maps:get(<<"roles">>, M3)).
-
-handle_role_delete_strips_from_channel_overwrites_test() ->
- RoleIdToDelete = <<"200">>,
- Data = #{
- <<"roles">> => [
- #{<<"id">> => <<"100">>, <<"name">> => <<"Everyone">>},
- #{<<"id">> => <<"200">>, <<"name">> => <<"Moderator">>}
- ],
- <<"members">> => [],
- <<"channels">> => [
- #{
- <<"id">> => <<"500">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => <<"100">>,
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => <<"1024">>
- },
- #{
- <<"id">> => <<"200">>,
- <<"type">> => 0,
- <<"allow">> => <<"1024">>,
- <<"deny">> => <<"0">>
- },
- #{
- <<"id">> => <<"1">>,
- <<"type">> => 1,
- <<"allow">> => <<"2048">>,
- <<"deny">> => <<"0">>
- }
- ]
- }
- ]
- },
- EventData = #{<<"role_id">> => RoleIdToDelete},
- Result = guild_state_roles:handle_role_delete(EventData, Data),
- Channels = maps:get(<<"channels">>, Result),
- [Ch1] = Channels,
- Ch1Overwrites = maps:get(<<"permission_overwrites">>, Ch1),
- ?assertEqual(2, length(Ch1Overwrites)).
-
-handle_role_create_test() ->
- Data = #{
- <<"roles">> => [#{<<"id">> => <<"1">>, <<"name">> => <<"Everyone">>}],
- <<"members">> => [],
- <<"channels">> => []
- },
- EventData = #{<<"role">> => #{<<"id">> => <<"2">>, <<"name">> => <<"New">>}},
- Result = guild_state_roles:handle_role_create(EventData, Data),
- Roles = guild_data_index_roles:role_list(Result),
- ?assertEqual(2, length(Roles)),
- RoleIndex = guild_data_index_roles:role_index(Result),
- ?assertMatch(#{2 := _}, RoleIndex).
-
-handle_role_update_replaces_role_test() ->
- Data = #{
- <<"roles">> => [
- #{<<"id">> => <<"1">>, <<"name">> => <<"Old">>},
- #{<<"id">> => <<"2">>, <<"name">> => <<"Keep">>}
- ],
- <<"members">> => [],
- <<"channels">> => []
- },
- EventData = #{<<"role">> => #{<<"id">> => <<"1">>, <<"name">> => <<"Updated">>}},
- Result = guild_state_roles:handle_role_update(EventData, Data),
- Roles = guild_data_index_roles:role_list(Result),
- [R1, R2] = Roles,
- ?assertEqual(<<"Updated">>, maps:get(<<"name">>, R1)),
- ?assertEqual(<<"Keep">>, maps:get(<<"name">>, R2)).
-
-handle_role_update_bulk_test() ->
- Data = #{
- <<"roles">> => [
- #{<<"id">> => <<"1">>, <<"name">> => <<"A">>},
- #{<<"id">> => <<"2">>, <<"name">> => <<"B">>},
- #{<<"id">> => <<"3">>, <<"name">> => <<"C">>}
- ],
- <<"members">> => [],
- <<"channels">> => []
- },
- EventData = #{
- <<"roles">> => [
- #{<<"id">> => <<"1">>, <<"name">> => <<"A2">>},
- #{<<"id">> => <<"3">>, <<"name">> => <<"C2">>}
- ]
- },
- Result = guild_state_roles:handle_role_update_bulk(EventData, Data),
- Roles = guild_data_index_roles:role_list(Result),
- [R1, R2, R3] = Roles,
- ?assertEqual(<<"A2">>, maps:get(<<"name">>, R1)),
- ?assertEqual(<<"B">>, maps:get(<<"name">>, R2)),
- ?assertEqual(<<"C2">>, maps:get(<<"name">>, R3)).
-
-handle_role_delete_removes_role_from_list_test() ->
- Data = #{
- <<"roles">> => [
- #{<<"id">> => <<"1">>, <<"name">> => <<"Keep">>},
- #{<<"id">> => <<"2">>, <<"name">> => <<"Delete">>}
- ],
- <<"members">> => [],
- <<"channels">> => []
- },
- EventData = #{<<"role_id">> => <<"2">>},
- Result = guild_state_roles:handle_role_delete(EventData, Data),
- Roles = guild_data_index_roles:role_list(Result),
- ?assertEqual(1, length(Roles)),
- ?assertEqual(<<"Keep">>, maps:get(<<"name">>, hd(Roles))).
-
-strip_role_from_members_no_affected_users_test() ->
- Data = guild_data_index:normalize_map(#{
- <<"roles">> => [],
- <<"members">> => #{
- 1 => #{<<"user">> => #{<<"id">> => <<"1">>}, <<"roles">> => [<<"100">>]}
- },
- <<"channels">> => []
- }),
- Result = guild_state_roles_delete:strip_role_from_members(999, Data),
- #{<<"roles">> := Roles} = guild_data_index_members:get_member(1, Result),
- ?assertEqual([100], Roles).
-
-strip_role_from_channel_overwrites_preserves_user_overwrites_test() ->
- Data = #{
- <<"channels">> => [
- #{
- <<"id">> => <<"500">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => <<"100">>,
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => <<"0">>
- },
- #{
- <<"id">> => <<"1">>,
- <<"type">> => 1,
- <<"allow">> => <<"1024">>,
- <<"deny">> => <<"0">>
- }
- ]
- }
- ]
- },
- Result = guild_state_roles_delete:strip_role_from_channel_overwrites(100, Data),
- [Ch] = guild_data_index_channels:channel_list(Result),
- Overwrites = maps:get(<<"permission_overwrites">>, Ch),
- ?assertEqual(1, length(Overwrites)),
- ?assertEqual(1, maps:get(<<"type">>, hd(Overwrites))).
diff --git a/fluxer_gateway/test/guild_thread_push_tests.erl b/fluxer_gateway/test/guild_thread_push_tests.erl
deleted file mode 100644
index 9ebf3271f..000000000
--- a/fluxer_gateway/test/guild_thread_push_tests.erl
+++ /dev/null
@@ -1,201 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_thread_push_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(G, 1).
--define(A, 10).
--define(B, 11).
--define(C, 12).
--define(OUT, 13).
--define(AUTHOR, 14).
--define(TEXT, 100).
--define(THREAD, 500).
--define(VIEW, 1024).
--define(SEND, 2048).
--define(CONFIG_KEY, channel_threads_config).
-
-with_config(Fun) ->
- Previous = persistent_term:get(?CONFIG_KEY, undefined),
- Config = (channel_threads_config:default_config())#{
- enabled => true,
- included_users =>
- #{integer_to_binary(Id) => true || Id <- [?A, ?B, ?C, ?AUTHOR]}
- },
- persistent_term:put(?CONFIG_KEY, Config),
- try
- Fun()
- after
- case Previous of
- undefined -> persistent_term:erase(?CONFIG_KEY);
- _ -> persistent_term:put(?CONFIG_KEY, Previous)
- end
- end.
-
-raw_data() ->
- Gid = integer_to_binary(?G),
- Member = fun(Id) ->
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(Id)},
- <<"roles">> => [],
- <<"joined_at">> => <<"2026-01-01T00:00:00Z">>
- }
- end,
- #{
- <<"guild">> => #{<<"id">> => Gid, <<"owner_id">> => <<"999">>, <<"features">> => []},
- <<"roles">> => [
- #{
- <<"id">> => Gid,
- <<"permissions">> => integer_to_binary(?VIEW bor ?SEND),
- <<"position">> => 0
- }
- ],
- <<"channels">> => [
- #{<<"id">> => <<"100">>, <<"type">> => 0, <<"permission_overwrites">> => []}
- ],
- <<"members">> => [Member(Id) || Id <- [?A, ?B, ?C, ?OUT, ?AUTHOR]],
- <<"emojis">> => [],
- <<"stickers">> => []
- }.
-
-thread_member(UserId) ->
- #{
- <<"id">> => integer_to_binary(?THREAD),
- <<"user_id">> => integer_to_binary(UserId),
- <<"join_timestamp">> => <<"2026-01-01T00:00:00.000Z">>,
- <<"flags">> => 1
- }.
-
-state(Active) ->
- Payload = guild_thread_load:load_payload(#{
- <<"threads">> => [
- #{
- <<"id">> => integer_to_binary(?THREAD),
- <<"guild_id">> => integer_to_binary(?G),
- <<"parent_id">> => integer_to_binary(?TEXT),
- <<"type">> => 11,
- <<"name">> => <<"ideas">>,
- <<"thread_metadata">> => #{<<"archived">> => false, <<"locked">> => false}
- }
- ],
- <<"thread_members">> => [thread_member(?A), thread_member(?OUT)]
- }),
- Base = #{
- id => ?G,
- member_count => 5,
- data => guild_data_index:normalize_map(raw_data()),
- sessions => #{
- <<"b">> => #{session_id => <<"b">>, user_id => ?B, pid => self()},
- <<"a">> => #{session_id => <<"a">>, user_id => ?A, pid => self()}
- }
- },
- Gate =
- case Active of
- true ->
- #{
- thread_gate => #{active => true, version => 1},
- thread_tainted => true,
- thread_load => {ok, Payload}
- };
- false ->
- #{}
- end,
- guild_thread_load:install(Gate, Base).
-
-with_state(Active, Fun) ->
- with_config(fun() ->
- State = state(Active),
- try
- Fun(State)
- after
- guild_thread_store:destroy(guild_thread_gate:store(State))
- end
- end).
-
-mention_request(ChannelId, Overrides) ->
- maps:merge(
- #{
- channel_id => ChannelId,
- author_id => ?AUTHOR,
- mention_everyone => false,
- mention_here => false,
- role_ids => [],
- user_ids => []
- },
- Overrides
- ).
-
-everyone(Request, State) ->
- {reply, #{mentions := Entries}, _} =
- guild_members_mutation:resolve_mention_sources_page(
- Request#{limit => 100, cursor => undefined}, State
- ),
- lists:sort([entry_user_id(E) || E <- Entries, maps:get(everyone, E, false)]).
-
-everyone_in_a_thread_reaches_recipient_active_members_only_test() ->
- with_state(true, fun(State) ->
- Request = mention_request(?THREAD, #{mention_everyone => true}),
- ?assertEqual([?A], everyone(Request, State)),
- ?assertEqual(
- [?A, ?B, ?C, ?OUT],
- everyone(mention_request(?TEXT, #{mention_everyone => true}), State)
- )
- end).
-
-here_in_a_thread_needs_membership_and_a_connection_test() ->
- with_state(true, fun(State) ->
- Request = mention_request(?THREAD, #{mention_here => true}),
- ?assertEqual([?A], everyone(Request, State)),
- ?assertEqual([?A, ?B], everyone(mention_request(?TEXT, #{mention_here => true}), State))
- end).
-
-direct_mentions_in_a_thread_skip_inactive_recipients_test() ->
- with_state(true, fun(State) ->
- {reply, #{mentions := Entries}, _} =
- guild_members_mutation:resolve_mention_sources_page(
- (mention_request(?THREAD, #{user_ids => [?B, ?OUT]}))#{
- limit => 100, cursor => undefined
- },
- State
- ),
- ?assertEqual(
- [?B], lists:sort([entry_user_id(E) || E <- Entries, maps:get(direct, E, false)])
- )
- end).
-
-paged_everyone_in_a_thread_lists_members_only_test() ->
- with_state(true, fun(State) ->
- Request = (mention_request(?THREAD, #{mention_everyone => true}))#{
- limit => 100, cursor => undefined
- },
- {reply, #{mentions := Entries}, _} =
- guild_members_mutation:resolve_mention_sources_page(Request, State),
- ?assertEqual([?A], lists:sort([entry_user_id(E) || E <- Entries]))
- end).
-
-inactive_guild_mentions_are_unchanged_test() ->
- with_state(false, fun(State) ->
- ?assertEqual(undefined, guild_thread_push:mention_universe(?THREAD, State)),
- ?assertEqual(
- [?A, ?B, ?C, ?OUT],
- everyone(mention_request(?TEXT, #{mention_everyone => true}), State)
- )
- end).
-
-passive_threads_follow_membership_test() ->
- with_state(true, fun(State) ->
- ?assertMatch(
- [#{<<"name">> := <<"ideas">>}],
- guild_thread_push:passive_threads(#{thread_viewer => true}, ?A, State)
- ),
- ?assertEqual(
- [], guild_thread_push:passive_threads(#{thread_viewer => true}, ?B, State)
- ),
- ?assertEqual([], guild_thread_push:passive_threads(#{}, ?A, State))
- end).
-
-entry_user_id(#{user_id := UserId}) -> UserId;
-entry_user_id(#{<<"user_id">> := UserId}) -> snowflake_id:parse_optional(UserId);
-entry_user_id(UserId) when is_integer(UserId) -> UserId;
-entry_user_id(Other) -> Other.
diff --git a/fluxer_gateway/test/guild_threads_tests.erl b/fluxer_gateway/test/guild_threads_tests.erl
deleted file mode 100644
index a5bd5795a..000000000
--- a/fluxer_gateway/test/guild_threads_tests.erl
+++ /dev/null
@@ -1,2056 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_threads_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
--define(G, 1).
--define(A, 10).
--define(C, 11).
--define(X, 12).
--define(P, 13).
--define(V, 14).
--define(M, 15).
--define(OWNER, 999).
--define(TEXT, 100).
--define(FORUM, 200).
--define(CATEGORY, 300).
--define(HIDDEN, 400).
--define(T1, 500).
--define(T2, 600).
--define(MOD_ROLE, 50).
--define(VIEW, 1024).
--define(SEND, 2048).
--define(HISTORY, 65536).
--define(IN_THREADS, (1 bsl 38)).
--define(MANAGE_THREADS, (1 bsl 34)).
--define(CONFIG_KEY, channel_threads_config).
-
-with_config(Fun) ->
- Previous = persistent_term:get(?CONFIG_KEY, undefined),
- Config = (channel_threads_config:default_config())#{
- enabled => true,
- included_users =>
- #{
- integer_to_binary(Id) => true
- || Id <- [?A, ?P, ?V, ?M, ?OWNER]
- }
- },
- persistent_term:put(?CONFIG_KEY, Config),
- try
- Fun()
- after
- case Previous of
- undefined -> persistent_term:erase(?CONFIG_KEY);
- _ -> persistent_term:put(?CONFIG_KEY, Previous)
- end
- end.
-
-raw_data() ->
- Gid = integer_to_binary(?G),
- Everyone = integer_to_binary(?VIEW bor ?SEND bor ?HISTORY bor ?IN_THREADS),
- Member = fun(Id, Roles, Bot) ->
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(Id), <<"bot">> => Bot},
- <<"roles">> => Roles,
- <<"joined_at">> => <<"2026-01-01T00:00:00Z">>
- }
- end,
- #{
- <<"guild">> => #{
- <<"id">> => Gid, <<"owner_id">> => integer_to_binary(?OWNER), <<"features">> => []
- },
- <<"roles">> => [
- #{<<"id">> => Gid, <<"permissions">> => Everyone, <<"position">> => 0},
- #{
- <<"id">> => integer_to_binary(?MOD_ROLE),
- <<"permissions">> => integer_to_binary(?MANAGE_THREADS),
- <<"position">> => 1
- }
- ],
- <<"channels">> => [
- #{<<"id">> => <<"100">>, <<"type">> => 0, <<"permission_overwrites">> => []},
- #{
- <<"id">> => <<"300">>,
- <<"type">> => 4,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => Gid,
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => <<"1024">>
- }
- ]
- },
- #{
- <<"id">> => <<"200">>,
- <<"type">> => 15,
- <<"parent_id">> => <<"300">>,
- <<"default_thread_rate_limit_per_user">> => 5,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => Gid,
- <<"type">> => 0,
- <<"allow">> => <<"1024">>,
- <<"deny">> => <<"0">>
- }
- ]
- },
- #{
- <<"id">> => <<"400">>,
- <<"type">> => 0,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(?P),
- <<"type">> => 1,
- <<"allow">> => <<"0">>,
- <<"deny">> => <<"1024">>
- }
- ]
- }
- ],
- <<"members">> => [
- Member(?A, [], false),
- Member(?C, [], false),
- Member(?X, [integer_to_binary(?MOD_ROLE)], true),
- Member(?P, [], false),
- Member(?V, [], false),
- Member(?M, [integer_to_binary(?MOD_ROLE)], false),
- Member(?OWNER, [], false)
- ],
- <<"emojis">> => [],
- <<"stickers">> => []
- }.
-
-thread(Id, Parent, Type) ->
- #{
- <<"id">> => integer_to_binary(Id),
- <<"guild_id">> => integer_to_binary(?G),
- <<"parent_id">> => integer_to_binary(Parent),
- <<"owner_id">> => integer_to_binary(?A),
- <<"type">> => Type,
- <<"name">> => <<"thread">>,
- <<"last_message_id">> => null,
- <<"rate_limit_per_user">> => 0,
- <<"flags">> => 0,
- <<"message_count">> => 0,
- <<"total_message_sent">> => 0,
- <<"member_count">> => 1,
- <<"thread_metadata">> => #{
- <<"archived">> => false,
- <<"locked">> => false,
- <<"auto_archive_duration">> => 4320,
- <<"archive_timestamp">> => <<"2026-01-01T00:00:00.000Z">>,
- <<"create_timestamp">> => <<"2026-01-01T00:00:00.000Z">>
- }
- }.
-
-thread_member(ThreadId, UserId) ->
- #{
- <<"id">> => integer_to_binary(ThreadId),
- <<"user_id">> => integer_to_binary(UserId),
- <<"join_timestamp">> => <<"2026-01-01T00:00:00.000Z">>,
- <<"flags">> => 1,
- <<"muted">> => false,
- <<"mute_config">> => null
- }.
-
-active_state(Pids) ->
- Payload = guild_thread_load:load_payload(#{
- <<"threads">> => [thread(?T1, ?TEXT, 11), thread(?T2, ?TEXT, 12)],
- <<"thread_members">> => [thread_member(?T1, ?A), thread_member(?T2, ?A)]
- }),
- Base = #{
- id => ?G,
- member_count => 10,
- data => guild_data_index:normalize_map(raw_data()),
- sessions => sessions(Pids),
- member_list_subscriptions => guild_member_list_subs:new()
- },
- guild_thread_load:install(
- #{
- thread_gate => #{active => true, version => 1},
- thread_tainted => true,
- thread_load => {ok, Payload}
- },
- Base
- ).
-
-inactive_state(Pids) ->
- guild_thread_load:install(#{}, #{
- id => ?G,
- member_count => 10,
- data => guild_data_index:normalize_map(raw_data()),
- sessions => sessions(Pids),
- member_list_subscriptions => guild_member_list_subs:new()
- }).
-
-sessions(Pids) ->
- maps:from_list([
- {atom_to_binary(Tag), session(Tag, UserId, Bot, Capable, Pid)}
- || {Tag, UserId, Bot, Capable, Pid} <- [
- {a, ?A, false, true, maps:get(a, Pids)},
- {c, ?C, false, true, maps:get(c, Pids)},
- {x, ?X, true, false, maps:get(x, Pids)},
- {p, ?P, false, true, maps:get(p, Pids)},
- {v, ?V, false, true, maps:get(v, Pids)},
- {i, ?A, false, false, maps:get(i, Pids)}
- ]
- ]).
-
-session(Tag, UserId, Bot, Capable, Pid) ->
- #{
- session_id => atom_to_binary(Tag),
- user_id => UserId,
- pid => Pid,
- bot => Bot,
- is_staff => false,
- pending_connect => false,
- active_guilds => sets:from_list([?G]),
- thread_capable => Capable
- }.
-
-start_captures() ->
- Parent = self(),
- maps:from_list([
- {Tag, spawn(fun() -> capture_loop(Tag, Parent) end)}
- || Tag <- [a, c, x, p, v, i]
- ]).
-
-stop_captures(Pids) ->
- maps:foreach(fun(_Tag, Pid) -> Pid ! stop end, Pids).
-
-capture_loop(Tag, Parent) ->
- receive
- stop ->
- ok;
- {'$gen_cast', {dispatch, Event, Payload}} ->
- Parent ! {captured, Tag, Event, decode(Payload)},
- capture_loop(Tag, Parent);
- _Other ->
- capture_loop(Tag, Parent)
- end.
-
-decode({pre_encoded, Bin}) ->
- json:decode(Bin);
-decode(Map) when is_map(Map) ->
- json:decode(iolist_to_binary(json:encode(guild_data_wire:payload(Map)))).
-
-drain() ->
- drain([]).
-
-drain(Acc) ->
- receive
- {captured, Tag, Event, Payload} -> drain([{Tag, Event, Payload} | Acc])
- after 150 ->
- lists:reverse(Acc)
- end.
-
-received(Tag, Event, Events) ->
- [Payload || {T, E, Payload} <- Events, T =:= Tag, E =:= Event].
-
-with_guild(Fun) ->
- with_config(fun() ->
- Pids = start_captures(),
- State = active_state(Pids),
- try
- Fun(State)
- after
- guild_thread_store:destroy(guild_thread_gate:store(State)),
- stop_captures(Pids),
- settle_mailbox_age()
- end
- end).
-
-settle_mailbox_age() ->
- receive
- {guild_mailbox_age, Seq} ->
- ok = guild_mailbox_age:handle_mark(Seq),
- settle_mailbox_age()
- after 0 ->
- ok
- end.
-
-dispatch(Event, Data, State) ->
- {noreply, NewState} = guild_dispatch:handle_dispatch(Event, Data, State),
- NewState.
-
-viewer_flags_follow_capability_bot_and_enrolment_test() ->
- with_guild(fun(State) ->
- Sessions = maps:get(sessions, State),
- Viewer = fun(Sid) -> guild_thread_gate:session_viewer(maps:get(Sid, Sessions)) end,
- ?assert(Viewer(<<"a">>)),
- ?assertNot(Viewer(<<"c">>)),
- ?assert(Viewer(<<"x">>)),
- ?assertNot(Viewer(<<"i">>))
- end).
-
-untainted_inactive_guild_create_is_unchanged_test() ->
- with_config(fun() ->
- Pids = start_captures(),
- try
- State = inactive_state(Pids),
- meck:new(guild_thread_view, [passthrough]),
- try
- Plain = guild_data:get_guild_state(?A, State),
- Opts = guild_data:get_guild_state(?A, State, #{thread_viewer => false}),
- ?assertEqual(Plain, Opts),
- ?assertNot(maps:is_key(<<"threads">>, Plain)),
- ?assertEqual(0, meck:num_calls(guild_thread_view, '_', '_'))
- after
- meck:unload(guild_thread_view)
- end,
- ?assertEqual(
- #{},
- maps:with([thread_gate, thread_store, thread_tainted], maps:get(data, State))
- )
- after
- stop_captures(Pids)
- end
- end).
-
-tainted_inactive_reload_masks_role_bits_test() ->
- Pids = start_captures(),
- try
- {_Channels, Extras} = guild_thread_load:channels_collection(#{
- <<"channels">> => [], <<"thread_tainted">> => true
- }),
- State = guild_thread_load:install(Extras, #{
- id => ?G,
- member_count => 10,
- data => guild_data_index:normalize_map(raw_data()),
- sessions => sessions(Pids),
- member_list_subscriptions => guild_member_list_subs:new()
- }),
- ?assertNot(guild_thread_gate:active(State)),
- ?assert(guild_thread_gate:needs_variant(State)),
- GuildState = guild_data:get_guild_state(?C, State, #{thread_viewer => false}),
- [
- ?assertEqual(0, maps:get(<<"permissions">>, R) band ?IN_THREADS)
- || R <- maps:get(<<"roles">>, GuildState)
- ],
- Untainted = guild_data:get_guild_state(
- ?C, inactive_state(Pids), #{thread_viewer => false}
- ),
- ?assert(
- lists:any(
- fun(R) -> maps:get(<<"permissions">>, R) band ?IN_THREADS =/= 0 end,
- maps:get(<<"roles">>, Untainted)
- )
- )
- after
- stop_captures(Pids)
- end.
-
-viewer_guild_create_carries_joined_threads_test() ->
- with_guild(fun(State) ->
- GuildState = guild_data:get_guild_state(?A, State, #{
- thread_viewer => true, bot => false
- }),
- Threads = maps:get(<<"threads">>, GuildState),
- ?assertEqual([?T1, ?T2], lists:sort([maps:get(<<"id">>, T) || T <- Threads])),
- [T1] = [T || T <- Threads, maps:get(<<"id">>, T) =:= ?T1],
- Member = maps:get(<<"member">>, T1),
- ?assertNot(maps:is_key(<<"id">>, Member)),
- ?assertNot(maps:is_key(<<"user_id">>, Member)),
- ?assertNot(maps:is_key(<<"member_ids_preview">>, T1)),
- VState = guild_data:get_guild_state(?V, State, #{thread_viewer => true, bot => false}),
- ?assertEqual([], maps:get(<<"threads">>, VState)),
- XState = guild_data:get_guild_state(?X, State, #{thread_viewer => true, bot => true}),
- ?assertEqual(
- [?T1, ?T2],
- lists:sort([maps:get(<<"id">>, T) || T <- maps:get(<<"threads">>, XState)])
- )
- end).
-
-control_session_guild_create_hides_forums_and_bits_test() ->
- with_guild(fun(State) ->
- lists:foreach(
- fun(UserId) ->
- GuildState = guild_data:get_guild_state(UserId, State, #{thread_viewer => false}),
- ?assertNot(maps:is_key(<<"threads">>, GuildState)),
- Ids = [maps:get(<<"id">>, C) || C <- maps:get(<<"channels">>, GuildState)],
- ?assertNot(lists:member(?FORUM, Ids)),
- ?assertEqual(UserId =:= ?OWNER, lists:member(?CATEGORY, Ids)),
- [
- ?assertEqual(0, maps:get(<<"permissions">>, R) band ?IN_THREADS)
- || R <- maps:get(<<"roles">>, GuildState)
- ]
- end,
- [?C, ?OWNER]
- ),
- Viewer = guild_data:get_guild_state(?A, State, #{thread_viewer => true}),
- ViewerIds = [maps:get(<<"id">>, C) || C <- maps:get(<<"channels">>, Viewer)],
- ?assert(lists:member(?FORUM, ViewerIds)),
- ?assert(lists:member(?CATEGORY, ViewerIds))
- end).
-
-permissions_fail_closed_for_unknown_ids_test() ->
- with_guild(fun(State) ->
- ?assertEqual(0, guild_permissions:get_member_permissions(?A, 424242, State)),
- Inactive = State#{data => maps:remove(thread_gate, maps:get(data, State))},
- ?assertNotEqual(0, guild_permissions:get_member_permissions(?A, 424242, Inactive))
- end).
-
-thread_permissions_derive_from_parent_test() ->
- with_guild(fun(State) ->
- Perms = guild_permissions:get_member_permissions(?V, ?T1, State),
- ?assert(bitset:has(Perms, ?VIEW)),
- ?assert(bitset:has(Perms, ?SEND)),
- ?assertNot(
- bitset:has(guild_permissions:get_member_permissions(?V, ?T2, State), ?VIEW)
- ),
- ?assert(
- bitset:has(guild_permissions:get_member_permissions(?A, ?T2, State), ?VIEW)
- ),
- ?assert(
- bitset:has(guild_permissions:get_member_permissions(?M, ?T2, State), ?VIEW)
- ),
- {reply, #{auth_context := Context}, _} = guild_data:get_auth_context(
- #{user_id => ?V, channel_id => ?T1}, State
- ),
- ?assertEqual(?TEXT, maps:get(<<"id">>, maps:get(<<"parent_channel">>, Context)))
- end).
-
-thread_create_recipients_and_shaping_test() ->
- with_guild(fun(State) ->
- Data = (thread(700, ?TEXT, 11))#{
- <<"newly_created">> => true,
- <<"_fluxer_member_ids_preview">> => [integer_to_binary(?A)],
- <<"_fluxer_members">> => [thread_member(700, ?A)]
- },
- _ = dispatch(thread_create, Data, State),
- Events = drain(),
- [ForA] = received(a, thread_create, Events),
- ?assertEqual(true, maps:get(<<"newly_created">>, ForA)),
- ?assertEqual(
- integer_to_binary(?A), maps:get(<<"user_id">>, maps:get(<<"member">>, ForA))
- ),
- ?assertNot(maps:is_key(<<"_fluxer_members">>, ForA)),
- ?assertNot(maps:is_key(<<"member_ids_preview">>, ForA)),
- [ForX] = received(x, thread_create, Events),
- ?assertNot(maps:is_key(<<"member">>, ForX)),
- ?assertEqual([], received(v, thread_create, Events)),
- ?assertEqual([], received(c, thread_create, Events)),
- ?assertEqual([], received(i, thread_create, Events))
- end).
-
-private_thread_create_never_reaches_subscribed_non_members_test() ->
- with_guild(fun(State0) ->
- State = guild_thread_subscriptions:update(<<"v">>, #{threads => true}, State0),
- _ = dispatch(thread_create, thread(701, ?TEXT, 12), State),
- Events = drain(),
- ?assertEqual([], received(v, thread_create, Events)),
- ?assertMatch([_], received(x, thread_create, Events)),
- _ = dispatch(thread_create, thread(702, ?TEXT, 11), State),
- ?assertMatch([_], received(v, thread_create, drain()))
- end).
-
-members_update_synthesizes_create_and_suppresses_creator_duplicate_test() ->
- with_guild(fun(State0) ->
- Created = (thread(703, ?TEXT, 12))#{<<"_fluxer_members">> => [thread_member(703, ?A)]},
- State1 = dispatch(thread_create, Created, State0),
- _ = drain(),
- CreatorAdded = #{
- <<"id">> => <<"703">>,
- <<"member_count">> => 1,
- <<"added_members">> => [thread_member(703, ?A)],
- <<"_fluxer_thread">> => thread(703, ?TEXT, 12)
- },
- State2 = dispatch(thread_members_update, CreatorAdded, State1),
- Events1 = drain(),
- ?assertEqual([], received(a, thread_create, Events1)),
- ?assertMatch([_], received(a, thread_members_update, Events1)),
- VAdded = CreatorAdded#{
- <<"member_count">> => 2, <<"added_members">> => [thread_member(703, ?V)]
- },
- _ = dispatch(thread_members_update, VAdded, State2),
- Events2 = drain(),
- [Create] = received(v, thread_create, Events2),
- ?assertNot(maps:is_key(<<"newly_created">>, Create)),
- ?assertEqual(
- integer_to_binary(?V), maps:get(<<"user_id">>, maps:get(<<"member">>, Create))
- ),
- [Update] = received(v, thread_members_update, Events2),
- [Added] = maps:get(<<"added_members">>, Update),
- ?assertEqual(
- integer_to_binary(?V),
- maps:get(<<"id">>, maps:get(<<"user">>, maps:get(<<"member">>, Added)))
- ),
- ?assert(maps:is_key(<<"presence">>, Added)),
- ?assertNot(maps:is_key(<<"muted">>, Added)),
- ?assertNot(maps:is_key(<<"mute_config">>, Added)),
- ?assertNot(maps:is_key(<<"_fluxer_thread">>, Update)),
- ?assertMatch([_], received(a, thread_members_update, Events2)),
- ?assertEqual([], received(i, thread_members_update, Events2)),
- ?assertMatch([_], received(x, thread_members_update, Events2)),
- ?assertEqual([], received(p, thread_members_update, Events2)),
- ?assertEqual(
- thread_create,
- element(2, hd([E || {v, _, _} = E <- Events2]))
- )
- end).
-
-removed_user_without_view_still_gets_members_update_test() ->
- with_guild(fun(State) ->
- Removal = #{
- <<"id">> => integer_to_binary(?T2),
- <<"member_count">> => 1,
- <<"removed_member_ids">> => [integer_to_binary(?P)]
- },
- _ = dispatch(thread_members_update, Removal, State),
- [Update] = received(p, thread_members_update, drain()),
- ?assertEqual([integer_to_binary(?P)], maps:get(<<"removed_member_ids">>, Update))
- end).
-
-thread_delete_payload_is_exact_test() ->
- with_guild(fun(State) ->
- Data = #{
- <<"id">> => integer_to_binary(?T1),
- <<"parent_id">> => integer_to_binary(?TEXT),
- <<"type">> => 11
- },
- State1 = dispatch(thread_delete, Data, State),
- Events = drain(),
- [ForA] = received(a, thread_delete, Events),
- ?assertEqual(
- lists:sort([<<"guild_id">>, <<"id">>, <<"parent_id">>, <<"type">>]),
- lists:sort(maps:keys(ForA))
- ),
- ?assertMatch([_], received(x, thread_delete, Events)),
- ?assertEqual([], received(c, thread_delete, Events)),
- ?assertEqual(undefined, guild_thread_gate:thread(?T1, State1))
- end).
-
-archived_private_thread_delete_reaches_listed_members_test() ->
- with_guild(fun(State0) ->
- Archived = (thread(?T2, ?TEXT, 12))#{
- <<"thread_metadata">> => #{<<"archived">> => true, <<"locked">> => false}
- },
- State1 = dispatch(thread_update, Archived, State0),
- drain(),
- ?assertEqual(undefined, guild_thread_gate:thread(?T2, State1)),
- Data = #{
- <<"id">> => integer_to_binary(?T2),
- <<"parent_id">> => integer_to_binary(?TEXT),
- <<"type">> => 12
- },
- _ = dispatch(thread_delete, Data, State1),
- ?assertEqual([], received(a, thread_delete, drain())),
- _ = dispatch(
- thread_delete, Data#{<<"_fluxer_member_ids">> => [integer_to_binary(?A)]}, State1
- ),
- Events = drain(),
- [ForA] = received(a, thread_delete, Events),
- ?assertNot(maps:is_key(<<"_fluxer_member_ids">>, ForA)),
- ?assertEqual([], received(v, thread_delete, Events))
- end).
-
-unknown_thread_uses_internal_context_test() ->
- with_guild(fun(State) ->
- Data = #{
- <<"id">> => <<"800">>,
- <<"member_count">> => 1,
- <<"added_members">> => [thread_member(800, ?V)],
- <<"_fluxer_thread">> => thread(800, ?TEXT, 11)
- },
- State1 = dispatch(thread_members_update, Data, State),
- ?assertNotEqual(undefined, guild_thread_gate:thread(800, State1)),
- Events = drain(),
- ?assertMatch([_], received(v, thread_create, Events)),
- ?assertMatch([_], received(v, thread_members_update, Events))
- end).
-
-archive_removes_thread_and_unarchive_orders_update_before_member_update_test() ->
- with_guild(fun(State0) ->
- Archived = (thread(?T1, ?TEXT, 11))#{
- <<"thread_metadata">> => #{<<"archived">> => true, <<"locked">> => false}
- },
- State1 = dispatch(thread_update, Archived, State0),
- ?assertMatch([_], received(a, thread_update, drain())),
- ?assertEqual(undefined, guild_thread_gate:thread(?T1, State1)),
- Unarchived = (thread(?T1, ?TEXT, 11))#{
- <<"_fluxer_members">> => [thread_member(?T1, ?A)]
- },
- {noreply, State2} = guild:handle_cast(
- {dispatch_many, [#{event => thread_update, data => Unarchived}]}, State1
- ),
- Drained = drain(),
- ?assertEqual([thread_update, thread_member_update], [E || {a, E, _} <- Drained]),
- [Member] = received(a, thread_member_update, Drained),
- ?assertEqual(integer_to_binary(?G), maps:get(<<"guild_id">>, Member)),
- ?assertEqual(integer_to_binary(?A), maps:get(<<"user_id">>, Member)),
- ?assertEqual([], received(v, thread_member_update, Drained)),
- ?assertNotEqual(undefined, guild_thread_gate:thread(?T1, State2))
- end).
-
-message_create_in_thread_reaches_members_and_bots_only_test() ->
- with_guild(fun(State) ->
- Message = #{
- <<"id">> => <<"900">>,
- <<"channel_id">> => integer_to_binary(?T1),
- <<"type">> => 0,
- <<"content">> => <<"hi">>,
- <<"author">> => #{<<"id">> => integer_to_binary(?X)},
- <<"mentions">> => [],
- <<"mention_roles">> => []
- },
- State1 = dispatch(message_create, Message, State),
- Events = drain(),
- ?assertMatch([_], received(a, message_create, Events)),
- ?assertMatch([_], received(x, message_create, Events)),
- ?assertEqual([], received(v, message_create, Events)),
- ?assertEqual([], received(c, message_create, Events)),
- ?assertEqual([], received(i, message_create, Events)),
- Thread = guild_thread_gate:thread(?T1, State1),
- ?assertEqual(1, maps:get(<<"message_count">>, Thread))
- end).
-
-type_18_and_thread_only_updates_are_hidden_from_control_test() ->
- with_guild(fun(State) ->
- Created = #{
- <<"id">> => <<"901">>,
- <<"channel_id">> => integer_to_binary(?TEXT),
- <<"type">> => 18,
- <<"author">> => #{<<"id">> => integer_to_binary(?A)},
- <<"mentions">> => [],
- <<"mention_roles">> => []
- },
- _ = dispatch(message_create, Created, State),
- Events1 = drain(),
- ?assertMatch([_], received(a, message_create, Events1)),
- ?assertEqual([], received(c, message_create, Events1)),
- Update = #{
- <<"id">> => <<"902">>,
- <<"channel_id">> => integer_to_binary(?TEXT),
- <<"flags">> => 16#20,
- <<"thread">> => #{<<"id">> => <<"903">>},
- <<"__thread_only_update">> => true
- },
- _ = dispatch(message_update, Update, State),
- Events2 = drain(),
- [ForA] = received(a, message_update, Events2),
- ?assertNot(maps:is_key(<<"__thread_only_update">>, ForA)),
- ?assertEqual([], received(c, message_update, Events2)),
- Reply = #{
- <<"id">> => <<"904">>,
- <<"channel_id">> => integer_to_binary(?TEXT),
- <<"flags">> => 16#20 bor 4,
- <<"thread">> => #{<<"id">> => <<"905">>},
- <<"referenced_message">> => #{<<"type">> => 18, <<"id">> => <<"906">>}
- },
- _ = dispatch(message_update, Reply, State),
- Events3 = drain(),
- [Masked] = received(c, message_update, Events3),
- ?assertEqual(4, maps:get(<<"flags">>, Masked)),
- ?assertNot(maps:is_key(<<"thread">>, Masked)),
- ?assertEqual(null, maps:get(<<"referenced_message">>, Masked)),
- [Full] = received(a, message_update, Events3),
- ?assertEqual(16#24, maps:get(<<"flags">>, Full))
- end).
-
-forum_channel_events_reach_viewers_only_test() ->
- with_guild(fun(State) ->
- Forum = #{
- <<"id">> => <<"210">>,
- <<"type">> => 15,
- <<"permission_overwrites">> => []
- },
- _ = dispatch(channel_create, Forum, State),
- Events = drain(),
- ?assertMatch([_], received(a, channel_create, Events)),
- ?assertEqual([], received(c, channel_create, Events)),
- ?assertEqual([], received(i, channel_create, Events))
- end).
-
-inactive_guild_drops_gated_events_test() ->
- with_config(fun() ->
- Pids = start_captures(),
- try
- State = inactive_state(Pids),
- _ = dispatch(thread_create, thread(700, ?TEXT, 11), State),
- _ = dispatch(channel_create, #{<<"id">> => <<"210">>, <<"type">> => 15}, State),
- ?assertEqual([], drain())
- after
- stop_captures(Pids)
- end
- end).
-
-live_audit_entries_on_thread_targets_are_viewer_only_test() ->
- with_guild(fun(State0) ->
- Sessions = maps:get(sessions, State0),
- Passive = maps:map(fun(_Sid, S) -> S#{active_guilds => sets:new()} end, Sessions),
- Owner = maps:get(<<"a">>, Passive),
- State = State0#{
- member_count => 300,
- sessions => Passive#{
- <<"c">> => (maps:get(<<"c">>, Passive))#{user_id => ?OWNER},
- <<"a">> => Owner#{user_id => ?OWNER, thread_viewer => true}
- }
- },
- Entry = #{
- <<"id">> => <<"1000">>,
- <<"action_type">> => 110,
- <<"target_id">> => integer_to_binary(?T1),
- <<"__thread_scoped">> => integer_to_binary(?G)
- },
- _ = dispatch(guild_audit_log_entry_create, Entry, State),
- Events = drain(),
- [ForA] = received(a, guild_audit_log_entry_create, Events),
- ?assertNot(maps:is_key(<<"__thread_scoped">>, ForA)),
- ?assertEqual([], received(c, guild_audit_log_entry_create, Events))
- end).
-
-passive_sessions_get_self_directed_thread_events_test() ->
- with_guild(fun(State0) ->
- Sessions = maps:get(sessions, State0),
- Passive = maps:map(fun(_Sid, S) -> S#{active_guilds => sets:new()} end, Sessions),
- State1 = guild_thread_subscriptions:update(
- <<"v">>, #{threads => true}, State0#{member_count => 300, sessions => Passive}
- ),
- _ = dispatch(thread_member_update, (thread_member(?T1, ?A))#{<<"flags">> => 3}, State1),
- ?assertMatch([_], received(a, thread_member_update, drain())),
- Created = (thread(704, ?TEXT, 11))#{<<"_fluxer_members">> => [thread_member(704, ?A)]},
- State2 = dispatch(thread_create, Created, State1),
- Events = drain(),
- ?assertMatch([_], received(a, thread_create, Events)),
- ?assertEqual([], received(v, thread_create, Events)),
- _ = dispatch(
- thread_members_update,
- #{
- <<"id">> => <<"704">>,
- <<"member_count">> => 2,
- <<"added_members">> => [thread_member(704, ?V)],
- <<"_fluxer_thread">> => thread(704, ?TEXT, 11)
- },
- State2
- ),
- Events2 = drain(),
- ?assertMatch([_], received(v, thread_members_update, Events2)),
- ?assertEqual([], received(a, thread_members_update, Events2)),
- Unarchive = (thread(?T1, ?TEXT, 11))#{<<"name">> => <<"renamed">>},
- _ = dispatch(thread_update, Unarchive, State2),
- Events3 = drain(),
- ?assertMatch([_], received(a, thread_update, Events3)),
- ?assertEqual([], received(v, thread_update, Events3))
- end).
-
-permission_loss_keeps_membership_and_sends_no_delete_test() ->
- with_guild(fun(State) ->
- Gid = integer_to_binary(?G),
- Update = #{
- <<"id">> => integer_to_binary(?TEXT),
- <<"type">> => 0,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(?A),
- <<"type">> => 1,
- <<"allow">> => <<"0">>,
- <<"deny">> => <<"1024">>
- },
- #{
- <<"id">> => Gid,
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => <<"0">>
- }
- ]
- },
- State1 = dispatch(channel_update, Update, State),
- Events = drain(),
- ?assertEqual([], received(a, thread_delete, Events)),
- Tab = guild_thread_gate:store(State1),
- ?assert(guild_thread_store:is_member(Tab, ?T1, ?A)),
- Message = #{
- <<"id">> => <<"910">>,
- <<"channel_id">> => integer_to_binary(?T1),
- <<"type">> => 0,
- <<"mentions">> => [],
- <<"mention_roles">> => []
- },
- _ = dispatch(message_create, Message, State1),
- ?assertEqual([], received(a, message_create, drain()))
- end).
-
-op14_threads_subscription_is_viewer_only_and_syncs_test() ->
- with_guild(fun(State0) ->
- State1 = guild_thread_subscriptions:update(<<"c">>, #{threads => true}, State0),
- ?assertNot(
- maps:is_key(thread_subscribed, maps:get(<<"c">>, maps:get(sessions, State1)))
- ),
- State2 = guild_thread_subscriptions:update(<<"v">>, #{threads => true}, State1),
- _ = guild_thread_subscriptions:handle_tick(<<"v">>, State2),
- [Sync] = received(v, thread_list_sync, drain()),
- ?assertNot(maps:is_key(<<"channel_ids">>, Sync)),
- ?assertEqual([integer_to_binary(?T1)], [
- maps:get(<<"id">>, T)
- || T <- maps:get(<<"threads">>, Sync)
- ]),
- ?assertEqual([], maps:get(<<"members">>, Sync)),
- State3 = guild_thread_subscriptions:update(
- <<"a">>, #{member_lists => [?T1, ?T2, 424242]}, State2
- ),
- Lists = received(a, thread_member_list_update, drain()),
- ?assertEqual(2, length(Lists)),
- [First | _] = Lists,
- [Entry] = maps:get(<<"members">>, First),
- ?assertEqual(integer_to_binary(?A), maps:get(<<"user_id">>, Entry)),
- ?assert(maps:is_key(<<"presence">>, Entry)),
- Passive = guild_sessions_passive:set_session_passive_guild(<<"v">>, ?G, State3),
- ?assertNot(
- maps:is_key(thread_subscribed, maps:get(<<"v">>, maps:get(sessions, Passive)))
- )
- end).
-
-access_gain_sends_list_sync_with_channel_ids_test() ->
- with_guild(fun(State0) ->
- State1 = dispatch(thread_create, thread(705, ?HIDDEN, 11), State0),
- Events0 = drain(),
- ?assertEqual([], received(p, thread_create, Events0)),
- Lifted = #{
- <<"id">> => integer_to_binary(?HIDDEN),
- <<"type">> => 0,
- <<"permission_overwrites">> => []
- },
- _ = dispatch(channel_update, Lifted, State1),
- [Sync] = received(p, thread_list_sync, drain()),
- ?assertEqual([integer_to_binary(?HIDDEN)], maps:get(<<"channel_ids">>, Sync)),
- ?assertEqual([<<"705">>], [maps:get(<<"id">>, T) || T <- maps:get(<<"threads">>, Sync)])
- end).
-
-op16_from_control_session_ignores_forums_and_threads_test() ->
- with_guild(fun(State) ->
- Request = #{session_id => <<"c">>, user_id => ?C, channel_ids => [?FORUM, ?T1]},
- {reply, #{counts := Counts}, _} = guild_query_handler:handle_call(
- {get_channel_member_counts, Request}, {self(), make_ref()}, State
- ),
- ?assertEqual([], Counts)
- end).
-
-public_online_count_ignores_forums_test() ->
- with_guild(fun(State) ->
- Data = maps:get(data, State),
- WithoutForums = guild_data_index:put_channels(
- [
- C
- || C <- guild_data_index_channels:channel_list(Data),
- maps:get(<<"type">>, C) =/= 15
- ],
- Data
- ),
- ?assertEqual(
- guild_public_online:compute_count(State#{data => WithoutForums}),
- guild_public_online:compute_count(State)
- )
- end).
-
-flip_deactivation_resends_only_changed_sessions_test_() ->
- {timeout, 30, fun flip_deactivation_resends_only_changed_sessions/0}.
-
-flip_deactivation_resends_only_changed_sessions() ->
- with_guild(fun(State) ->
- Flip = #{
- <<"thread_gate">> => #{<<"active">> => false, <<"config_version">> => 2},
- <<"thread_tainted">> => true,
- <<"channels">> => [
- C
- || C <- maps:get(<<"channels">>, raw_data()), maps:get(<<"type">>, C) =/= 15
- ],
- <<"roles">> => maps:get(<<"roles">>, raw_data())
- },
- Off = guild_thread_flip:apply_flip(Flip, State),
- ?assertNot(guild_thread_gate:active(Off)),
- ?assertEqual(undefined, guild_thread_gate:store(Off)),
- Sessions = maps:get(sessions, Off),
- ?assertNot(lists:any(fun guild_thread_gate:session_viewer/1, maps:values(Sessions))),
- Resends = collect_resends([]),
- ?assertEqual([<<"a">>, <<"p">>, <<"v">>, <<"x">>], lists:sort(Resends)),
- _ = guild_thread_flip:resend(<<"a">>, Off),
- Events = drain(),
- [GuildCreate] = received(a, guild_create, Events),
- ?assertNot(maps:is_key(<<"threads">>, GuildCreate)),
- ?assertEqual([], received(a, guild_update, Events))
- end).
-
-collect_resends(Acc) ->
- receive
- {thread_flip_resend, SessionId} -> collect_resends([SessionId | Acc])
- after 11000 ->
- Acc
- end.
-
-flip_activation_marks_viewers_and_loads_threads_test() ->
- with_config(fun() ->
- Pids = start_captures(),
- try
- State = inactive_state(Pids),
- Flip = #{
- <<"thread_gate">> => #{<<"active">> => true, <<"config_version">> => 3},
- <<"thread_tainted">> => true,
- <<"channels">> => maps:get(<<"channels">>, raw_data()),
- <<"roles">> => maps:get(<<"roles">>, raw_data()),
- <<"threads">> => [thread(?T1, ?TEXT, 11)],
- <<"thread_members">> => [thread_member(?T1, ?A)]
- },
- On = guild_thread_flip:apply_flip(Flip, State),
- ?assert(guild_thread_gate:active(On)),
- ?assertNotEqual(undefined, guild_thread_gate:thread(?T1, On)),
- ?assert(
- guild_thread_gate:session_viewer(maps:get(<<"a">>, maps:get(sessions, On)))
- ),
- ?assertNot(
- guild_thread_gate:session_viewer(maps:get(<<"c">>, maps:get(sessions, On)))
- ),
- guild_thread_store:destroy(guild_thread_gate:store(On))
- after
- stop_captures(Pids)
- end
- end).
-
-flip_result_keeps_live_channels_and_replays_held_events_test() ->
- with_config(fun() ->
- Pids = start_captures(),
- try
- On = run_flip_with_held_events(3, Pids),
- ?assert(guild_thread_gate:active(On)),
- ?assertNot(maps:is_key(thread_flip_held, On)),
- ?assertNot(maps:is_key(thread_flip_retry, On)),
- Index = guild_data_index_channels:channel_index(maps:get(data, On)),
- ?assertMatch(#{<<"type">> := 15}, maps:get(?FORUM, Index)),
- ?assertEqual([], maps:get(<<"permission_overwrites">>, maps:get(?HIDDEN, Index))),
- ?assertEqual(2, length(guild_data_index_roles:role_list(maps:get(data, On)))),
- ?assertNotEqual(undefined, guild_thread_gate:thread(?T1, On)),
- guild_thread_store:destroy(guild_thread_gate:store(On))
- after
- stop_captures(Pids)
- end
- end).
-
-flip_result_from_a_stale_api_rearms_the_flip_test() ->
- with_config(fun() ->
- Pids = start_captures(),
- try
- On = run_flip_with_held_events(2, Pids),
- ?assert(guild_thread_gate:active(On)),
- #{thread_flip_retry := {Timer, 1}} = On,
- ?assert(erlang:read_timer(Timer) > 0),
- _ = erlang:cancel_timer(Timer),
- guild_thread_store:destroy(guild_thread_gate:store(On))
- after
- stop_captures(Pids)
- end
- end).
-
-held_event_without_an_id_is_skipped_on_replay_test() ->
- with_config(fun() ->
- Pids = start_captures(),
- try
- Raw = raw_data(),
- Snapshot = [
- C
- || C <- maps:get(<<"channels">>, Raw), maps:get(<<"type">>, C) =/= 15
- ],
- Ref = make_ref(),
- Held = [
- {thread_create, thread(?T1, ?FORUM, 11)},
- {thread_update, #{<<"guild_id">> => integer_to_binary(?G)}}
- ],
- State = (inactive_state(Pids))#{
- sessions => #{},
- data => guild_data_index:normalize_map(Raw),
- thread_flip => {Ref, 3},
- thread_flip_held => {2, Held}
- },
- Flip = #{
- <<"config_version">> => 3,
- <<"thread_gate">> => #{<<"active">> => true, <<"config_version">> => 3},
- <<"thread_tainted">> => true,
- <<"channels">> => Snapshot,
- <<"roles">> => [],
- <<"threads">> => [],
- <<"thread_members">> => []
- },
- On = guild_thread_flip:handle_result(Ref, {ok, Flip}, State),
- ?assert(guild_thread_gate:active(On)),
- ?assertNotEqual(undefined, guild_thread_gate:thread(?T1, On)),
- guild_thread_store:destroy(guild_thread_gate:store(On))
- after
- stop_captures(Pids)
- end
- end).
-
-run_flip_with_held_events(ApiVersion, Pids) ->
- Raw = raw_data(),
- [Forum] = [C || C <- maps:get(<<"channels">>, Raw), maps:get(<<"type">>, C) =:= 15],
- Snapshot = [C || C <- maps:get(<<"channels">>, Raw), maps:get(<<"type">>, C) =/= 15],
- Inactive = inactive_state(Pids),
- Ref = make_ref(),
- State0 = Inactive#{
- sessions => #{},
- data => guild_data_index:normalize_map(Raw#{<<"channels">> => Snapshot}),
- thread_flip => {Ref, 3},
- thread_flip_held => {0, []}
- },
- Lifted = #{
- <<"id">> => integer_to_binary(?HIDDEN),
- <<"type">> => 0,
- <<"permission_overwrites">> => []
- },
- State1 = dispatch(channel_create, Forum, State0),
- State2 = dispatch(thread_create, thread(?T1, ?FORUM, 11), State1),
- State3 = dispatch(channel_update, Lifted, State2),
- ?assertMatch(#{thread_flip_held := {2, _}}, State3),
- Flip = #{
- <<"config_version">> => ApiVersion,
- <<"thread_gate">> => #{<<"active">> => true, <<"config_version">> => ApiVersion},
- <<"thread_tainted">> => true,
- <<"channels">> => Snapshot,
- <<"roles">> => [],
- <<"threads">> => [],
- <<"thread_members">> => []
- },
- guild_thread_flip:handle_result(Ref, {ok, Flip}, State3).
-
-thread_store_retire_destroys_only_non_current_stores_test() ->
- Current = guild_thread_store:new(),
- Retired = guild_thread_store:new(),
- State = #{data => #{thread_store => Current}},
- ?assertEqual({noreply, State}, guild:handle_info({thread_store_retire, Current}, State)),
- ?assertEqual({noreply, State}, guild:handle_info({thread_store_retire, Retired}, State)),
- ?assertNotEqual(undefined, ets:info(Current)),
- ?assertEqual(undefined, ets:info(Retired)),
- guild_thread_store:destroy(Current).
-
-flip_activation_without_sessions_rebuilds_the_permission_cache_test() ->
- with_config(fun() ->
- Pids = start_captures(),
- try
- Raw = raw_data(),
- NoForum = Raw#{
- <<"channels">> => [
- C
- || C <- maps:get(<<"channels">>, Raw), maps:get(<<"type">>, C) =/= 15
- ]
- },
- Inactive = inactive_state(Pids),
- State = Inactive#{sessions => #{}, data => guild_data_index:normalize_map(NoForum)},
- ok = guild_permission_cache:put_state(State),
- Flip = #{
- <<"thread_gate">> => #{<<"active">> => true, <<"config_version">> => 3},
- <<"thread_tainted">> => true,
- <<"channels">> => maps:get(<<"channels">>, raw_data()),
- <<"roles">> => maps:get(<<"roles">>, raw_data()),
- <<"threads">> => [],
- <<"thread_members">> => []
- },
- On = guild_thread_flip:apply_flip(Flip, State),
- {ok, #{data := Cached}} = guild_permission_cache:get_snapshot(?G),
- ?assertMatch(#{active := true}, maps:get(thread_gate, Cached, undefined)),
- ?assert(
- lists:any(
- fun(C) -> maps:get(<<"type">>, C) =:= 15 end,
- guild_data_index_channels:channel_list(Cached)
- )
- ),
- guild_permission_cache:delete(?G),
- guild_thread_store:destroy(guild_thread_gate:store(On))
- after
- stop_captures(Pids)
- end
- end).
-
-non_viewer_visibility_of_indexed_channels_uses_type_only_test() ->
- with_guild(fun(State) ->
- [C] = [S || S <- maps:values(maps:get(sessions, State)), maps:get(user_id, S) =:= ?C],
- ?assertNot(guild_thread_gate:session_viewer(C)),
- Tab = guild_thread_gate:store(State),
- Fake = guild_data_normalize:thread(thread(?TEXT, ?TEXT, 11)),
- guild_thread_store:put_thread(Tab, Fake),
- ?assertNotEqual(undefined, guild_thread_gate:thread(?TEXT, State)),
- ?assert(guild_thread_gate:channel_visible(C, ?TEXT, State)),
- ?assertNot(guild_thread_gate:channel_visible(C, ?FORUM, State)),
- ?assertNot(guild_thread_gate:channel_visible(C, ?T1, State)),
- Data = maps:get(data, State),
- Index = guild_data_index_channels:channel_index(Data),
- Indexed = State#{
- data => Data#{
- <<"channel_index">> => Index#{?T2 => #{<<"id">> => ?T2, <<"type">> => 12}}
- }
- },
- ?assertNot(guild_thread_gate:channel_visible(C, ?T2, Indexed))
- end).
-
-forum_only_category_update_skips_non_viewers_test() ->
- with_guild(fun(State) ->
- [Category] = [
- C
- || C <- guild_data_index_channels:channel_list(maps:get(data, State)),
- maps:get(<<"type">>, C) =:= 4
- ],
- Update = guild_data_wire:payload(Category#{<<"name">> => <<"renamed">>}),
- _ = dispatch(channel_update, Update, State),
- Events = drain(),
- ?assertMatch([_], received(a, channel_update, Events)),
- ?assertMatch([_], received(x, channel_update, Events)),
- ?assertEqual([], received(c, channel_update, Events)),
- ?assertEqual([], received(i, channel_update, Events))
- end).
-
-visibility_gain_channel_create_is_masked_for_non_viewers_test() ->
- with_guild(fun(State) ->
- Gid = integer_to_binary(?G),
- Everyone = #{
- <<"id">> => Gid,
- <<"type">> => 0,
- <<"allow">> => integer_to_binary(?IN_THREADS),
- <<"deny">> => <<"0">>
- },
- DenyC = #{
- <<"id">> => integer_to_binary(?C),
- <<"type">> => 1,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(?VIEW)
- },
- WithText = fun(Overwrites) ->
- Data = maps:get(data, State),
- Channels = [
- case maps:get(<<"id">>, C) of
- ?TEXT ->
- C#{
- <<"permission_overwrites">> => Overwrites,
- <<"default_thread_rate_limit_per_user">> => 7
- };
- _ ->
- C
- end
- || C <- guild_data_index_channels:channel_list(Data)
- ],
- State#{data => guild_data_index:put_channels(Channels, Data)}
- end,
- Old = WithText([Everyone, DenyC]),
- New = WithText([Everyone]),
- _ = guild_visibility_overwrites:compute_and_dispatch_visibility_changes_for_users(
- [?C], Old, New
- ),
- [Create] = received(c, channel_create, drain()),
- ?assertEqual(integer_to_binary(?TEXT), maps:get(<<"id">>, Create)),
- ?assertNot(maps:is_key(<<"default_thread_rate_limit_per_user">>, Create)),
- [Overwrite] = maps:get(<<"permission_overwrites">>, Create),
- ?assertEqual(<<"0">>, maps:get(<<"allow">>, Overwrite))
- end).
-
-handoff_export_carries_rows_within_budget_test() ->
- with_guild(fun(State) ->
- Exported = guild_handoff:export_handoff_state(State),
- Data = maps:get(data, Exported),
- ?assertNot(maps:is_key(thread_store, Data)),
- ?assert(is_list(maps:get(thread_rows, Data))),
- Restored = guild_init:init_base_state(Exported),
- ?assertNotEqual(undefined, guild_thread_gate:thread(?T1, Restored)),
- ?assert(
- guild_thread_gate:session_viewer(maps:get(<<"a">>, maps:get(sessions, Restored)))
- ),
- guild_thread_store:destroy(guild_thread_gate:store(Restored))
- end).
-
-handoff_strips_rows_over_budget_test() ->
- Tab = guild_thread_store:new(),
- try
- true = ets:insert(Tab, [{{p, 1, N}, true} || N <- lists:seq(1, 50001)]),
- Exported = guild_thread_load:export_handoff(#{thread_store => Tab}),
- ?assertEqual(#{}, Exported)
- after
- guild_thread_store:destroy(Tab)
- end.
-
-memory_fixture_of_a_thousand_threads_test() ->
- Tab = guild_thread_store:new(),
- try
- Threads = [thread(10000 + N, ?TEXT, 11) || N <- lists:seq(1, 1000)],
- Members = [
- thread_member(10000 + N, 20000 + U)
- || N <- lists:seq(1, 1000), U <- lists:seq(1, 50)
- ],
- ok = guild_thread_store:load(
- Tab,
- [guild_data_normalize:thread(T) || T <- Threads],
- [guild_data_normalize:thread_member(M) || M <- Members]
- ),
- ?assertEqual(1000, guild_thread_store:thread_count(Tab)),
- ?assertEqual(1000 * 2 + 1000 * 50 * 2, guild_thread_store:row_count(Tab)),
- Words = ets:info(Tab, memory),
- ?assert(Words * erlang:system_info(wordsize) < 64 * 1024 * 1024)
- after
- guild_thread_store:destroy(Tab)
- end.
-
-can_view_channel_call_sites_are_enumerated_test() ->
- Known = lists:sort([
- guild,
- guild_data_channels,
- guild_dispatch,
- guild_dispatch_push,
- guild_dispatch_send,
- guild_member_list_channel_engine,
- guild_member_list_connected,
- guild_members_common,
- guild_members_query,
- guild_passive_sync,
- guild_permissions,
- guild_permissions_check,
- guild_query_handler,
- guild_request_forum_unreads,
- guild_member_list_subscribe,
- guild_sessions,
- guild_subscription_handler,
- guild_thread_gate,
- guild_visibility_channels,
- guild_visibility_memo,
- guild_visibility_overwrites,
- guild_visibility_roles,
- guild_members_search,
- guild_members_mutation
- ]),
- Dir = filename:join([code:lib_dir(fluxer_gateway), "..", "..", "..", "..", "src", "guild"]),
- Files = filelib:wildcard(filename:join(source_dir(Dir), "*.erl")),
- ?assert(length(Files) > 50),
- Modules = lists:usort([
- list_to_atom(filename:basename(F, ".erl"))
- || F <- Files,
- calls_view_primitive(F)
- ]),
- ?assertEqual([], Modules -- Known).
-
-source_dir(Fallback) ->
- Candidates = [
- "src/guild",
- filename:join([code:lib_dir(fluxer_gateway), "src", "guild"]),
- Fallback
- ],
- hd([D || D <- Candidates, filelib:is_dir(D)] ++ [Fallback]).
-
-calls_view_primitive(File) ->
- {ok, Bin} = file:read_file(File),
- binary:match(Bin, [
- <<"can_view_channel(">>,
- <<"session_can_view_channel(">>,
- <<"session_can_view_channel_members(">>
- ]) =/= nomatch.
-
-load_race_replays_events_queued_while_loading_test_() ->
- {spawn, {timeout, 20, fun load_race_replays_events_queued_while_loading/0}}.
-
-load_race_replays_events_queued_while_loading() ->
- with_config(fun() ->
- Pids = start_captures(),
- Base = #{
- id => ?G,
- member_count => 10,
- data => guild_data_index:normalize_map(raw_data()),
- sessions => sessions(Pids)
- },
- Loading = guild_thread_load:install(
- #{thread_gate => #{active => true, version => 1}}, Base
- ),
- try
- ?assert(guild_thread_load:loading(Loading)),
- #{thread_load := #{timer := Timer}} = Loading,
- erlang:cancel_timer(Timer),
- flush_load_retries(),
- Ref = make_ref(),
- Fetching = Loading#{thread_load => (maps:get(thread_load, Loading))#{ref => Ref}},
- Created = (thread(706, ?TEXT, 11))#{
- <<"_fluxer_members">> => [thread_member(706, ?A)]
- },
- Retrying = dispatch(thread_create, Created, Fetching),
- ?assertMatch([_], received(a, thread_create, drain())),
- Payload = guild_thread_load:load_payload(#{
- <<"threads">> => [thread(?T1, ?TEXT, 11)],
- <<"thread_members">> => [thread_member(?T1, ?A)]
- }),
- Loaded = guild_thread_load:handle_load_result(Ref, {ok, Payload}, Retrying),
- ?assertNot(guild_thread_load:loading(Loaded)),
- ?assertNotEqual(undefined, guild_thread_gate:thread(?T1, Loaded)),
- ?assertNotEqual(undefined, guild_thread_gate:thread(706, Loaded)),
- Ticks = lists:sort(sync_ticks(6000)),
- ?assertEqual([<<"a">>, <<"x">>], Ticks),
- Synced = lists:foldl(
- fun(Sid, Acc) -> guild_thread_subscriptions:handle_tick(Sid, Acc) end,
- Loaded,
- Ticks
- ),
- Events = drain(),
- [Sync] = received(a, thread_list_sync, Events),
- ?assertNot(maps:is_key(<<"channel_ids">>, Sync)),
- ?assertEqual(
- lists:sort([integer_to_binary(?T1), <<"706">>]),
- lists:sort([maps:get(<<"id">>, T) || T <- maps:get(<<"threads">>, Sync)])
- ),
- ?assertMatch([_], received(x, thread_list_sync, Events)),
- ?assertEqual([], received(c, thread_list_sync, Events)),
- guild_thread_store:destroy(guild_thread_gate:store(Synced))
- after
- stop_captures(Pids)
- end
- end).
-
-sync_ticks(Timeout) ->
- Deadline = erlang:monotonic_time(millisecond) + Timeout,
- sync_ticks(Deadline, []).
-
-sync_ticks(Deadline, Acc) ->
- Wait = max(0, Deadline - erlang:monotonic_time(millisecond)),
- receive
- {thread_list_sync_tick, Sid} -> sync_ticks(Deadline, [Sid | Acc])
- after Wait -> Acc
- end.
-
-flush_load_retries() ->
- receive
- thread_load_retry -> flush_load_retries()
- after 0 -> ok
- end.
-
-first_fetch_after_a_stripped_handoff_is_immediate_test() ->
- flush_load_retries(),
- Installed = guild_thread_load:install(
- #{thread_gate => #{active => true, version => 1}},
- #{id => ?G, data => #{}, sessions => #{}}
- ),
- try
- ?assert(guild_thread_load:loading(Installed)),
- receive
- thread_load_retry -> ok
- after 100 -> ?assert(false)
- end,
- Ref = make_ref(),
- Loading = Installed#{thread_load => (maps:get(thread_load, Installed))#{ref => Ref}},
- Failed = guild_thread_load:handle_load_result(Ref, {error, down}, Loading),
- #{thread_load := #{timer := Timer, attempt := 1}} = Failed,
- Remaining = erlang:cancel_timer(Timer),
- ?assert(is_integer(Remaining) andalso Remaining > 29000)
- after
- guild_thread_load:deactivate(Installed)
- end.
-
-active_channels_collection_loads_threads_asynchronously_test() ->
- flush_load_retries(),
- {Channels, Extras} = guild_thread_load:channels_collection(#{
- <<"channels">> => [#{<<"id">> => <<"1">>}],
- <<"thread_gate">> => #{<<"active">> => true, <<"config_version">> => 1},
- <<"threads">> => [thread(?T1, ?TEXT, 11)]
- }),
- ?assertEqual([#{<<"id">> => <<"1">>}], Channels),
- ?assertNot(maps:is_key(thread_load, Extras)),
- Installed = guild_thread_load:install(Extras, #{id => ?G, data => #{}, sessions => #{}}),
- ?assert(guild_thread_load:loading(Installed)),
- ?assertEqual(undefined, guild_thread_gate:thread(?T1, Installed)),
- receive
- thread_load_retry -> ok
- after 100 -> ?assert(false)
- end,
- guild_thread_load:deactivate(Installed).
-
-flip_resend_skips_sessions_of_an_unavailable_guild_test() ->
- with_guild(fun(State) ->
- Data = maps:get(data, State),
- Guild = maps:get(<<"guild">>, Data),
- Unavailable = State#{
- data => Data#{
- <<"guild">> => Guild#{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}
- }
- },
- _ = guild_thread_flip:resend(<<"a">>, Unavailable),
- ?assertEqual([], received(a, guild_create, drain())),
- _ = guild_thread_flip:resend(<<"a">>, State),
- ?assertMatch([_], received(a, guild_create, drain()))
- end).
-
-flip_resend_keeps_a_degraded_guild_degraded_test() ->
- with_guild(fun(State) ->
- ok = guild_ets_owner:ensure_table(guild_health_status, [named_table, public, set]),
- _ = guild_thread_flip:resend(<<"a">>, State),
- [Healthy] = received(a, guild_create, drain()),
- ?assertNot(maps:is_key(<<"degraded">>, Healthy)),
- true = ets:insert(guild_health_status, {self(), ?G, true, undefined, undefined}),
- try
- _ = guild_thread_flip:resend(<<"a">>, State),
- ?assertMatch([#{<<"degraded">> := true}], received(a, guild_create, drain()))
- after
- ets:delete(guild_health_status, self())
- end
- end).
-
-gate_only_reload_keeps_the_ready_store_while_it_refetches_test() ->
- with_guild(fun(State) ->
- Store = guild_thread_gate:store(State),
- Reloaded = guild_thread_flip:reinstall(
- #{thread_gate => #{active => true, version => 1}}, State, State
- ),
- flush_load_retries(),
- ?assertEqual(Store, guild_thread_gate:store(Reloaded)),
- ?assertMatch(#{<<"id">> := _}, guild_thread_gate:thread(?T1, Reloaded)),
- ?assert(guild_thread_load:loading(Reloaded)),
- Ref = make_ref(),
- Fresh = guild_thread_load:handle_load_result(
- Ref,
- {ok, guild_thread_load:load_payload(#{<<"threads">> => [thread(?T2, ?TEXT, 12)]})},
- thread_load_ref(Ref, Reloaded)
- ),
- ?assertNot(guild_thread_load:loading(Fresh)),
- ?assertEqual(undefined, guild_thread_gate:thread(?T1, Fresh)),
- ?assertMatch(#{<<"id">> := _}, guild_thread_gate:thread(?T2, Fresh)),
- guild_thread_store:destroy(guild_thread_gate:store(Fresh))
- end).
-
-changed_gate_reload_starts_an_empty_store_test() ->
- with_guild(fun(State) ->
- Reloaded = guild_thread_flip:reinstall(
- #{thread_gate => #{active => true, version => 2}}, State, State
- ),
- flush_load_retries(),
- try
- ?assertNotEqual(guild_thread_gate:store(State), guild_thread_gate:store(Reloaded)),
- ?assertEqual(undefined, guild_thread_gate:thread(?T1, Reloaded))
- after
- guild_thread_store:destroy(guild_thread_gate:store(Reloaded))
- end
- end).
-
-thread_load_ref(Ref, #{thread_load := Load} = State) ->
- State#{thread_load => Load#{ref => Ref}}.
-
-reactivation_clears_thread_subscriptions_so_op14_resyncs_test_() ->
- {spawn, {timeout, 20, fun reactivation_clears_thread_subscriptions_so_op14_resyncs/0}}.
-
-reactivation_clears_thread_subscriptions_so_op14_resyncs() ->
- with_guild(fun(State) ->
- Sessions = maps:get(sessions, State),
- A = maps:get(<<"a">>, Sessions),
- Subscribed = State#{
- sessions => Sessions#{
- <<"a">> => A#{thread_subscribed => true, thread_member_lists => [?T1]}
- }
- },
- Off = guild_thread_flip:reinstall(
- #{thread_gate => #{active => false, version => 2}}, Subscribed, Subscribed
- ),
- OffA = maps:get(<<"a">>, maps:get(sessions, Off)),
- ?assertNot(maps:is_key(thread_subscribed, OffA)),
- ?assertNot(maps:is_key(thread_member_lists, OffA)),
- On = guild_thread_flip:reinstall(
- #{
- thread_gate => #{active => true, version => 3},
- thread_load => {ok, #{threads => [], members => [], parent_settings => []}}
- },
- Off,
- Off
- ),
- try
- OnA = maps:get(<<"a">>, maps:get(sessions, On)),
- ?assert(guild_thread_gate:session_viewer(OnA)),
- Updated = guild_thread_subscriptions:update(<<"a">>, #{threads => true}, On),
- ?assertEqual(
- true,
- maps:get(thread_subscribed, maps:get(<<"a">>, maps:get(sessions, Updated)))
- ),
- receive
- {thread_list_sync_tick, <<"a">>} -> ok
- after 6000 -> ?assert(false)
- end
- after
- guild_thread_store:destroy(guild_thread_gate:store(On)),
- flush_flip_resends()
- end
- end).
-
-flush_flip_resends() ->
- receive
- {thread_flip_resend, _} -> flush_flip_resends();
- {thread_list_sync_tick, _} -> flush_flip_resends()
- after 0 -> ok
- end.
-
-thread_member_list_follows_presence_changes_test() ->
- with_guild(fun(State) ->
- Subscribed = guild_thread_subscriptions:update(
- <<"a">>, #{member_lists => [?T1]}, State
- ),
- ?assertMatch(#{thread_presence_users := #{?A := [?T1]}}, Subscribed),
- [_] = received(a, thread_member_list_update, drain()),
- Changed = lists:foldl(
- fun guild_thread_subscriptions:presence_changed/2, Subscribed, [?A, ?A, ?A]
- ),
- ?assertEqual([], received(a, thread_member_list_update, drain())),
- _ = guild_thread_subscriptions:handle_list_flush(Changed),
- ?assertMatch([_], received(a, thread_member_list_update, drain())),
- ?assertEqual(Subscribed, guild_thread_subscriptions:presence_changed(?C, Subscribed)),
- ?assertEqual(State, guild_thread_subscriptions:presence_changed(?A, State))
- end).
-
-thread_member_list_follows_member_updates_test() ->
- with_guild(fun(State) ->
- Subscribed = guild_thread_subscriptions:update(
- <<"a">>, #{member_lists => [?T1]}, State
- ),
- [_] = received(a, thread_member_list_update, drain()),
- Update = fun(UserId, Nick) ->
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [],
- <<"nick">> => Nick
- }
- end,
- Changed = dispatch(guild_member_update, Update(?A, <<"renamed">>), Subscribed),
- ?assertEqual([], received(a, thread_member_list_update, drain())),
- _ = guild_thread_subscriptions:handle_list_flush(Changed),
- [#{<<"members">> := Members}] = received(a, thread_member_list_update, drain()),
- ?assertEqual(
- [<<"renamed">>],
- [
- maps:get(<<"nick">>, Member)
- || #{<<"user_id">> := Id, <<"member">> := Member} <- Members,
- Id =:= integer_to_binary(?A)
- ]
- ),
- Unlisted = dispatch(guild_member_update, Update(?C, <<"other">>), Subscribed),
- ?assertNot(maps:is_key(thread_list_dirty, Unlisted))
- end).
-
-thread_member_list_resubscribe_resends_snapshot_test() ->
- with_guild(fun(State) ->
- Subscribed = guild_thread_subscriptions:update(
- <<"a">>, #{member_lists => [?T1]}, State
- ),
- [_] = received(a, thread_member_list_update, drain()),
- Again = guild_thread_subscriptions:update(
- <<"a">>, #{member_lists => [?T1]}, Subscribed
- ),
- [_] = received(a, thread_member_list_update, drain()),
- _ = guild_thread_subscriptions:update(<<"a">>, #{threads => true}, Again),
- ?assertEqual([], received(a, thread_member_list_update, drain()))
- end).
-
-thread_member_list_drops_removed_guild_members_test() ->
- with_guild(fun(State0) ->
- Added = #{
- <<"id">> => integer_to_binary(?T1),
- <<"member_count">> => 2,
- <<"added_members">> => [thread_member(?T1, ?V)]
- },
- State1 = dispatch(thread_members_update, Added, State0),
- Subscribed = guild_thread_subscriptions:update(
- <<"a">>, #{member_lists => [?T1]}, State1
- ),
- _ = drain(),
- Removed = dispatch(
- guild_member_remove,
- #{<<"user">> => #{<<"id">> => integer_to_binary(?V)}},
- Subscribed
- ),
- ?assertEqual(#{?T1 => true}, maps:get(thread_list_dirty, Removed)),
- _ = guild_thread_subscriptions:handle_list_flush(Removed),
- [#{<<"members">> := Members}] = received(a, thread_member_list_update, drain()),
- ?assertEqual(
- [integer_to_binary(?A)], [maps:get(<<"user_id">>, M) || M <- Members]
- )
- end).
-
-handoff_through_an_old_node_round_trips_test() ->
- with_guild(fun(State) ->
- Exported = guild_handoff:export_handoff_state(State),
- OldShape = Exported#{
- data => maps:without(
- [thread_gate, thread_tainted, thread_rows, thread_rows_at],
- maps:get(data, Exported)
- )
- },
- FromOld = guild_init:init_base_state(OldShape),
- ?assertEqual(undefined, guild_thread_gate:store(FromOld)),
- ?assertNot(guild_thread_load:loading(FromOld)),
- ?assertNot(
- lists:any(
- fun guild_thread_gate:session_viewer/1,
- maps:values(maps:get(sessions, FromOld))
- )
- ),
- ReExported = guild_handoff:export_handoff_state(FromOld),
- ?assertNot(maps:is_key(thread_rows, maps:get(data, ReExported))),
- Stale = Exported#{
- data => (maps:get(data, Exported))#{thread_rows_at => 0}
- },
- flush_load_retries(),
- FromStale = guild_init:init_base_state(Stale),
- try
- ?assert(guild_thread_load:loading(FromStale)),
- ?assertEqual(undefined, guild_thread_gate:thread(?T1, FromStale)),
- receive
- thread_load_retry -> ok
- after 100 -> ?assert(false)
- end
- after
- guild_thread_load:deactivate(FromStale)
- end
- end).
-
-excluded_bot_is_a_control_session_test() ->
- with_config(fun() ->
- Config = persistent_term:get(?CONFIG_KEY),
- persistent_term:put(?CONFIG_KEY, Config#{
- excluded_users => #{integer_to_binary(?X) => true}
- }),
- Pids = start_captures(),
- State = active_state(Pids),
- try
- ?assertNot(
- guild_thread_gate:session_viewer(maps:get(<<"x">>, maps:get(sessions, State)))
- ),
- _ = dispatch(thread_create, thread(707, ?TEXT, 11), State),
- ?assertEqual([], received(x, thread_create, drain()))
- after
- guild_thread_store:destroy(guild_thread_gate:store(State)),
- stop_captures(Pids)
- end
- end).
-
-thread_message_permission_work_ignores_non_member_sessions_test() ->
- with_guild(fun(State) ->
- Message = #{
- <<"id">> => <<"920">>,
- <<"channel_id">> => integer_to_binary(?T1),
- <<"type">> => 0,
- <<"content">> => <<"hi">>,
- <<"author">> => #{<<"id">> => integer_to_binary(?X)},
- <<"mentions">> => [],
- <<"mention_roles">> => []
- },
- Crowd = maps:from_list([
- {
- <<"crowd", (integer_to_binary(N))/binary>>,
- (session(crowd, UserId, false, true, self()))#{
- session_id => <<"crowd", (integer_to_binary(N))/binary>>
- }
- }
- || N <- lists:seq(1, 1000), UserId <- [lists:nth(1 + N rem 2, [?C, ?V])]
- ]),
- Crowded = guild_thread_gate:recompute_session_viewers(State#{
- sessions => maps:merge(maps:get(sessions, State), Crowd)
- }),
- meck:new(guild_thread_permissions, [passthrough, no_link]),
- try
- _ = dispatch(message_create, Message, State),
- Base = meck:num_calls(guild_thread_permissions, resolve, '_'),
- ?assertMatch([_], received(a, message_create, drain())),
- meck:reset(guild_thread_permissions),
- _ = dispatch(message_create, Message#{<<"id">> => <<"921">>}, Crowded),
- ?assertEqual(Base, meck:num_calls(guild_thread_permissions, resolve, '_')),
- ?assertMatch([_], received(a, message_create, drain()))
- after
- meck:unload(guild_thread_permissions)
- end,
- flush_crowd()
- end).
-
-flush_crowd() ->
- receive
- {'$gen_cast', _} -> flush_crowd()
- after 0 -> ok
- end.
-
-tainted_inactive_guild_drops_thread_message_deletes_test() ->
- with_config(fun() ->
- Pids = start_captures(),
- try
- {_Channels, Extras} = guild_thread_load:channels_collection(#{
- <<"channels">> => [], <<"thread_tainted">> => true
- }),
- State = guild_thread_load:install(Extras, #{
- id => ?G,
- member_count => 10,
- data => guild_data_index:normalize_map(raw_data()),
- sessions => sessions(Pids),
- member_list_subscriptions => guild_member_list_subs:new()
- }),
- Bulk = #{<<"channel_id">> => integer_to_binary(?T1), <<"ids">> => [<<"930">>]},
- _ = dispatch(message_delete_bulk, Bulk, State),
- _ = dispatch(
- message_delete_bulk,
- Bulk#{<<"_fluxer_thread">> => thread(?T1, ?TEXT, 11)},
- State
- ),
- ?assertEqual([], drain()),
- Text = #{<<"channel_id">> => integer_to_binary(?TEXT), <<"ids">> => [<<"931">>]},
- _ = dispatch(message_delete_bulk, Text, State),
- ?assertMatch([_], received(c, message_delete_bulk, drain()))
- after
- stop_captures(Pids)
- end
- end).
-
-archived_thread_message_delete_uses_the_internal_context_test() ->
- with_guild(fun(State0) ->
- Archived = (thread(?T1, ?TEXT, 11))#{
- <<"thread_metadata">> => #{<<"archived">> => true, <<"locked">> => false}
- },
- State1 = guild_thread_subscriptions:update(
- <<"v">>, #{threads => true}, dispatch(thread_update, Archived, State0)
- ),
- drain(),
- ?assertEqual(undefined, guild_thread_gate:thread(?T1, State1)),
- Delete = #{<<"channel_id">> => integer_to_binary(?T1), <<"id">> => <<"940">>},
- _ = dispatch(message_delete, Delete, State1),
- ?assertEqual([], drain()),
- Context = #{
- <<"id">> => integer_to_binary(?T1),
- <<"parent_id">> => integer_to_binary(?TEXT),
- <<"type">> => 11
- },
- _ = dispatch(message_delete, Delete#{<<"_fluxer_thread">> => Context}, State1),
- Events = drain(),
- [ForV] = received(v, message_delete, Events),
- ?assertNot(maps:is_key(<<"_fluxer_thread">>, ForV)),
- ?assertMatch([_], received(x, message_delete, Events)),
- ?assertEqual([], received(c, message_delete, Events)),
- ?assertEqual([], received(i, message_delete, Events))
- end).
-
-archived_thread_member_update_checks_parent_access_test() ->
- with_guild(fun(State0) ->
- State1 = dispatch(thread_create, thread(708, ?HIDDEN, 11), State0),
- Archived = (thread(708, ?HIDDEN, 11))#{
- <<"thread_metadata">> => #{<<"archived">> => true, <<"locked">> => false}
- },
- State2 = dispatch(thread_update, Archived, State1),
- drain(),
- ?assertEqual(undefined, guild_thread_gate:thread(708, State2)),
- Update = fun(UserId) ->
- (thread_member(708, UserId))#{<<"_fluxer_parent_id">> => integer_to_binary(?HIDDEN)}
- end,
- _ = dispatch(thread_member_update, Update(?V), State2),
- [ForV] = received(v, thread_member_update, drain()),
- ?assertNot(maps:is_key(<<"_fluxer_parent_id">>, ForV)),
- _ = dispatch(thread_member_update, Update(?P), State2),
- ?assertEqual([], received(p, thread_member_update, drain())),
- _ = dispatch(thread_member_update, thread_member(708, ?V), State2),
- ?assertEqual([], received(v, thread_member_update, drain()))
- end).
-
-handoff_restores_thread_member_list_presence_tracking_test() ->
- with_guild(fun(State) ->
- Subscribed = guild_thread_subscriptions:update(
- <<"a">>, #{member_lists => [?T1]}, State
- ),
- drain(),
- Exported = guild_manager_shard_lifecycle:normalize_transferred_guild_state(
- maps:get(id, Subscribed), guild_handoff:export_handoff_state(Subscribed)
- ),
- Restored = guild_init:init_base_state(Exported),
- try
- ?assertMatch(#{thread_presence_users := #{?A := [?T1]}}, Restored),
- _ = guild_thread_subscriptions:handle_list_flush(
- guild_thread_subscriptions:presence_changed(?A, Restored)
- ),
- ?assertMatch([_], received(a, thread_member_list_update, drain()))
- after
- guild_thread_store:destroy(guild_thread_gate:store(Restored))
- end
- end).
-
-capable_and_incapable_sessions_of_one_user_split_test() ->
- with_guild(fun(State) ->
- Sessions = maps:get(sessions, State),
- ?assert(guild_thread_gate:session_viewer(maps:get(<<"a">>, Sessions))),
- ?assertNot(guild_thread_gate:session_viewer(maps:get(<<"i">>, Sessions))),
- ?assert(
- maps:is_key(
- <<"threads">>,
- guild_data:get_guild_state(
- ?A, State, guild_thread_gate:state_opts(maps:get(<<"a">>, Sessions))
- )
- )
- ),
- ?assertNot(
- maps:is_key(
- <<"threads">>,
- guild_data:get_guild_state(
- ?A, State, guild_thread_gate:state_opts(maps:get(<<"i">>, Sessions))
- )
- )
- ),
- _ = dispatch(
- thread_create,
- (thread(709, ?TEXT, 11))#{<<"_fluxer_members">> => [thread_member(709, ?A)]},
- State
- ),
- Created = drain(),
- ?assertMatch([_], received(a, thread_create, Created)),
- ?assertEqual([], received(i, thread_create, Created)),
- Update = #{
- <<"id">> => <<"950">>,
- <<"channel_id">> => integer_to_binary(?TEXT),
- <<"flags">> => 16#20 bor 4,
- <<"thread">> => #{<<"id">> => <<"709">>}
- },
- _ = dispatch(message_update, Update, State),
- Updated = drain(),
- [Full] = received(a, message_update, Updated),
- ?assertEqual(16#24, maps:get(<<"flags">>, Full)),
- ?assert(maps:is_key(<<"thread">>, Full)),
- [Masked] = received(i, message_update, Updated),
- ?assertEqual(4, maps:get(<<"flags">>, Masked)),
- ?assertNot(maps:is_key(<<"thread">>, Masked))
- end).
-
-forum_only_shared_channel_grants_no_presence_to_control_sessions_test() ->
- with_guild(fun(State0) ->
- Data0 = maps:get(data, State0),
- Forum = [
- maps:remove(<<"parent_id">>, C)
- || C <- guild_data_index_channels:channel_list(Data0), maps:get(<<"type">>, C) =:= 15
- ],
- State = State0#{data => guild_data_index:put_channels(Forum, Data0)},
- Sessions = maps:get(sessions, State),
- ?assertEqual(
- [?V],
- guild_subscription_mutual_channels:filter_member_ids(
- maps:get(<<"a">>, Sessions), ?A, [?V], State
- )
- ),
- ?assertEqual(
- [],
- guild_subscription_mutual_channels:filter_member_ids(
- maps:get(<<"c">>, Sessions), ?C, [?V], State
- )
- ),
- ?assertEqual(
- #{<<"a">> => [?V], <<"c">> => []},
- guild_subscription_mutual_channels:filter_session_member_ids(
- [{<<"a">>, ?A, [?V]}, {<<"c">>, ?C, [?V]}], State
- )
- )
- end).
-
--define(NEWS, 110).
--define(NEWS_THREAD, 800).
-
-news_raw_data() ->
- Raw = raw_data(),
- News = #{<<"id">> => <<"110">>, <<"type">> => 5, <<"permission_overwrites">> => []},
- Raw#{<<"channels">> => maps:get(<<"channels">>, Raw) ++ [News]}.
-
-news_state(Pids) ->
- Payload = guild_thread_load:load_payload(#{
- <<"threads">> => [thread(?T1, ?TEXT, 11), thread(?NEWS_THREAD, ?NEWS, 10)],
- <<"thread_members">> => [thread_member(?T1, ?A), thread_member(?NEWS_THREAD, ?A)]
- }),
- guild_thread_load:install(
- #{
- thread_gate => #{active => true, version => 1},
- thread_tainted => true,
- thread_load => {ok, Payload}
- },
- #{
- id => ?G,
- member_count => 10,
- data => guild_data_index:normalize_map(news_raw_data()),
- sessions => sessions(Pids),
- member_list_subscriptions => guild_member_list_subs:new()
- }
- ).
-
-with_news_guild(Fun) ->
- with_config(fun() ->
- Pids = start_captures(),
- State = news_state(Pids),
- try
- Fun(State)
- after
- guild_thread_store:destroy(guild_thread_gate:store(State)),
- stop_captures(Pids),
- settle_mailbox_age()
- end
- end).
-
-news_thread_create_reaches_viewers_only_test() ->
- with_news_guild(fun(State0) ->
- Data = (thread(801, ?NEWS, 10))#{
- <<"newly_created">> => true,
- <<"_fluxer_members">> => [thread_member(801, ?A)]
- },
- State1 = dispatch(thread_create, Data, State0),
- Events1 = drain(),
- [ForA] = received(a, thread_create, Events1),
- ?assertEqual(10, maps:get(<<"type">>, ForA)),
- ?assertEqual(integer_to_binary(?NEWS), maps:get(<<"parent_id">>, ForA)),
- ?assertMatch([_], received(x, thread_create, Events1)),
- ?assertEqual([], received(v, thread_create, Events1)),
- ?assertEqual([], received(c, thread_create, Events1)),
- ?assertEqual([], received(i, thread_create, Events1)),
- State2 = guild_thread_subscriptions:update(<<"v">>, #{threads => true}, State1),
- _ = dispatch(thread_create, thread(802, ?NEWS, 10), State2),
- Events2 = drain(),
- ?assertMatch([_], received(v, thread_create, Events2)),
- ?assertEqual([], received(c, thread_create, Events2)),
- ?assertEqual([], received(i, thread_create, Events2))
- end).
-
-news_thread_permissions_derive_from_announcement_parent_test() ->
- with_news_guild(fun(State) ->
- Perms = guild_permissions:get_member_permissions(?V, ?NEWS_THREAD, State),
- ?assert(bitset:has(Perms, ?VIEW)),
- ?assert(bitset:has(Perms, ?SEND)),
- {reply, #{auth_context := Context}, _} = guild_data:get_auth_context(
- #{user_id => ?V, channel_id => ?NEWS_THREAD}, State
- ),
- ?assertEqual(?NEWS, maps:get(<<"id">>, maps:get(<<"parent_channel">>, Context))),
- [C] = [S || S <- maps:values(maps:get(sessions, State)), maps:get(user_id, S) =:= ?C],
- ?assert(guild_thread_gate:channel_visible(C, ?NEWS, State)),
- ?assertNot(guild_thread_gate:channel_visible(C, ?NEWS_THREAD, State))
- end).
-
-news_thread_permission_loss_on_parent_hides_thread_test() ->
- with_news_guild(fun(State0) ->
- Gid = integer_to_binary(?G),
- Hidden = #{
- <<"id">> => integer_to_binary(?NEWS),
- <<"type">> => 5,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => Gid,
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => <<"1024">>
- }
- ]
- },
- State1 = dispatch(channel_update, Hidden, State0),
- _ = drain(),
- ?assertNot(
- bitset:has(
- guild_permissions:get_member_permissions(?A, ?NEWS_THREAD, State1), ?VIEW
- )
- ),
- ?assertNotEqual(undefined, guild_thread_gate:thread(?NEWS_THREAD, State1)),
- _ = dispatch(thread_update, thread(?NEWS_THREAD, ?NEWS, 10), State1),
- ?assertEqual([], received(a, thread_update, drain()))
- end).
-
-news_guild_create_carries_type_10_for_viewers_only_test() ->
- with_news_guild(fun(State) ->
- Viewer = guild_data:get_guild_state(?A, State, #{thread_viewer => true, bot => false}),
- [News] = [
- T
- || T <- maps:get(<<"threads">>, Viewer), maps:get(<<"id">>, T) =:= ?NEWS_THREAD
- ],
- ?assertEqual(10, maps:get(<<"type">>, News)),
- ?assert(maps:is_key(<<"member">>, News)),
- Bot = guild_data:get_guild_state(?X, State, #{thread_viewer => true, bot => true}),
- ?assert(
- lists:member(?NEWS_THREAD, [
- maps:get(<<"id">>, T)
- || T <- maps:get(<<"threads">>, Bot)
- ])
- ),
- Control = guild_data:get_guild_state(?C, State, #{thread_viewer => false}),
- ?assertNot(maps:is_key(<<"threads">>, Control)),
- Ids = [maps:get(<<"id">>, C) || C <- maps:get(<<"channels">>, Control)],
- ?assert(lists:member(?NEWS, Ids)),
- ?assertNot(lists:member(?NEWS_THREAD, Ids))
- end).
-
-news_thread_messages_and_crosspost_updates_hide_threads_from_control_test() ->
- with_news_guild(fun(State) ->
- Message = #{
- <<"id">> => <<"910">>,
- <<"channel_id">> => integer_to_binary(?NEWS_THREAD),
- <<"type">> => 0,
- <<"content">> => <<"hi">>,
- <<"author">> => #{<<"id">> => integer_to_binary(?X)},
- <<"mentions">> => [],
- <<"mention_roles">> => []
- },
- _ = dispatch(message_create, Message, State),
- Events1 = drain(),
- ?assertMatch([_], received(a, message_create, Events1)),
- ?assertEqual([], received(c, message_create, Events1)),
- ?assertEqual([], received(i, message_create, Events1)),
- Created = #{
- <<"id">> => <<"911">>,
- <<"channel_id">> => integer_to_binary(?NEWS),
- <<"type">> => 18,
- <<"author">> => #{<<"id">> => integer_to_binary(?A)},
- <<"mentions">> => [],
- <<"mention_roles">> => []
- },
- _ = dispatch(message_create, Created, State),
- Events2 = drain(),
- ?assertMatch([_], received(a, message_create, Events2)),
- ?assertEqual([], received(c, message_create, Events2)),
- Crossposted = #{
- <<"id">> => <<"912">>,
- <<"channel_id">> => integer_to_binary(?NEWS),
- <<"flags">> => 16#20 bor 1,
- <<"thread">> => thread(912, ?NEWS, 10)
- },
- _ = dispatch(message_update, Crossposted, State),
- Events3 = drain(),
- [Full] = received(a, message_update, Events3),
- ?assertEqual(16#21, maps:get(<<"flags">>, Full)),
- ?assertEqual(10, maps:get(<<"type">>, maps:get(<<"thread">>, Full))),
- lists:foreach(
- fun(Tag) ->
- [Masked] = received(Tag, message_update, Events3),
- ?assertEqual(1, maps:get(<<"flags">>, Masked)),
- ?assertNot(maps:is_key(<<"thread">>, Masked))
- end,
- [c, i]
- )
- end).
-
-news_thread_list_sync_includes_type_10_test() ->
- with_news_guild(fun(State0) ->
- State1 = guild_thread_subscriptions:update(<<"v">>, #{threads => true}, State0),
- _ = guild_thread_subscriptions:handle_tick(<<"v">>, State1),
- [Sync] = received(v, thread_list_sync, drain()),
- ?assertEqual(
- [integer_to_binary(?T1), integer_to_binary(?NEWS_THREAD)],
- lists:sort([maps:get(<<"id">>, T) || T <- maps:get(<<"threads">>, Sync)])
- )
- end).
-
-inactive_guild_drops_news_threads_and_keeps_announcement_channels_test() ->
- with_config(fun() ->
- Pids = start_captures(),
- try
- State = inactive_state(Pids),
- _ = dispatch(thread_create, thread(803, ?TEXT, 10), State),
- _ = dispatch(channel_create, #{<<"id">> => <<"804">>, <<"type">> => 10}, State),
- ?assertEqual([], drain()),
- News = #{<<"id">> => <<"805">>, <<"type">> => 5, <<"permission_overwrites">> => []},
- _ = dispatch(channel_create, News, State),
- Events = drain(),
- [ForI] = received(i, channel_create, Events),
- ?assertEqual(5, maps:get(<<"type">>, ForI)),
- ?assertMatch([_], received(c, channel_create, Events))
- after
- stop_captures(Pids)
- end
- end).
-
-news_thread_handoff_round_trips_test() ->
- with_news_guild(fun(State) ->
- Exported = guild_handoff:export_handoff_state(State),
- Restored = guild_init:init_base_state(Exported),
- try
- ?assertMatch(
- #{<<"type">> := 10}, guild_thread_gate:thread(?NEWS_THREAD, Restored)
- ),
- ?assert(
- bitset:has(
- guild_permissions:get_member_permissions(?V, ?NEWS_THREAD, Restored), ?VIEW
- )
- )
- after
- guild_thread_store:destroy(guild_thread_gate:store(Restored))
- end
- end).
diff --git a/fluxer_gateway/test/guild_virtual_channel_access_tests.erl b/fluxer_gateway/test/guild_virtual_channel_access_tests.erl
deleted file mode 100644
index 17fa6c764..000000000
--- a/fluxer_gateway/test/guild_virtual_channel_access_tests.erl
+++ /dev/null
@@ -1,31 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_virtual_channel_access_tests).
--typing([eqwalizer]).
--include_lib("eunit/include/eunit.hrl").
-
-add_virtual_access_updates_session_cache_test() ->
- State = #{
- sessions => #{
- <<"s1">> => #{user_id => 100, viewable_channels => #{}}
- }
- },
- State1 = guild_virtual_channel_access:add_virtual_access(100, 500, State),
- Session = maps:get(<<"s1">>, maps:get(sessions, State1)),
- ViewableChannels = maps:get(viewable_channels, Session, #{}),
- ?assertEqual(true, maps:is_key(500, ViewableChannels)).
-
-remove_virtual_access_updates_session_cache_test() ->
- State = #{
- sessions => #{
- <<"s1">> => #{user_id => 100, viewable_channels => #{500 => true}}
- },
- virtual_channel_access => #{100 => sets:from_list([500])},
- virtual_channel_access_pending => #{100 => sets:from_list([500])},
- virtual_channel_access_preserve => #{100 => sets:new()},
- virtual_channel_access_move_pending => #{100 => sets:new()}
- },
- State1 = guild_virtual_channel_access:remove_virtual_access(100, 500, State),
- Session = maps:get(<<"s1">>, maps:get(sessions, State1)),
- ViewableChannels = maps:get(viewable_channels, Session, #{}),
- ?assertEqual(false, maps:is_key(500, ViewableChannels)).
diff --git a/fluxer_gateway/test/guild_visibility_channels_tests.erl b/fluxer_gateway/test/guild_visibility_channels_tests.erl
deleted file mode 100644
index 5d09c02f7..000000000
--- a/fluxer_gateway/test/guild_visibility_channels_tests.erl
+++ /dev/null
@@ -1,249 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_visibility_channels_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-filter_connected_session_entries_excludes_pending_test() ->
- Normal = #{session_id => <<"s1">>, user_id => 1, pending_connect => false},
- Pending = #{session_id => <<"s2">>, user_id => 2, pending_connect => true},
- NoPending = #{session_id => <<"s3">>, user_id => 3},
- Sessions = #{<<"s1">> => Normal, <<"s2">> => Pending, <<"s3">> => NoPending},
- Result = guild_visibility_channels:filter_connected_session_entries(Sessions),
- ResultIds = lists:sort([Sid || {Sid, _} <- Result]),
- ?assertEqual([<<"s1">>, <<"s3">>], ResultIds).
-
-update_viewable_map_for_channel_add_test() ->
- Map = #{100 => true},
- Result = guild_visibility_channels:update_viewable_map_for_channel(Map, 200, true),
- ?assertEqual(true, maps:is_key(200, Result)),
- ?assertEqual(true, maps:is_key(100, Result)).
-
-update_viewable_map_for_channel_remove_test() ->
- Map = #{100 => true, 200 => true},
- Result = guild_visibility_channels:update_viewable_map_for_channel(Map, 100, false),
- ?assertEqual(false, maps:is_key(100, Result)),
- ?assertEqual(true, maps:is_key(200, Result)).
-
-viewable_channel_map_test() ->
- Set = sets:from_list([10, 20, 30]),
- Map = guild_visibility_channels:viewable_channel_map(Set),
- ?assertEqual(3, map_size(Map)),
- ?assertEqual(true, maps:get(10, Map)),
- ?assertEqual(true, maps:get(20, Map)),
- ?assertEqual(true, maps:get(30, Map)).
-
-viewable_channel_map_empty_test() ->
- Map = guild_visibility_channels:viewable_channel_map(sets:new()),
- ?assertEqual(#{}, Map).
-
-viewable_channel_set_uses_cached_session_data_test() ->
- UserId = 10,
- State = #{
- sessions => #{
- <<"s1">> => #{
- user_id => UserId,
- viewable_channels => #{100 => true, 200 => true}
- }
- },
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"members">> => [],
- <<"channels">> => [],
- <<"roles">> => []
- }
- },
- ChannelSet = guild_visibility_channels:viewable_channel_set(UserId, State),
- ?assertEqual(true, sets:is_element(100, ChannelSet)),
- ?assertEqual(true, sets:is_element(200, ChannelSet)),
- ?assertEqual(false, sets:is_element(999, ChannelSet)).
-
-administrator_sees_all_channels_test() ->
- GuildId = 50,
- UserId = 10,
- ChannelId = 100,
- Admin = constants:administrator_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(Admin)
- }
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(constants:view_channel_permission())
- }
- ]
- }
- ]
- }
- },
- Channels = guild_visibility_channels:get_user_viewable_channels(UserId, State),
- ?assertEqual([ChannelId], Channels).
-
-owner_sees_all_channels_test() ->
- GuildId = 60,
- OwnerId = 10,
- ChannelId = 200,
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => integer_to_binary(OwnerId)},
- <<"roles">> => [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(OwnerId)}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{<<"id">> => integer_to_binary(ChannelId), <<"permission_overwrites">> => []}
- ]
- }
- },
- Channels = guild_visibility_channels:get_user_viewable_channels(OwnerId, State),
- ?assertEqual([ChannelId], Channels).
-
-everyone_role_grants_view_test() ->
- GuildId = 70,
- UserId = 10,
- ChannelId = 300,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{<<"id">> => integer_to_binary(ChannelId), <<"permission_overwrites">> => []}
- ]
- }
- },
- Channels = guild_visibility_channels:get_user_viewable_channels(UserId, State),
- ?assertEqual([ChannelId], Channels).
-
-multiple_channels_partial_visibility_test() ->
- GuildId = 110,
- UserId = 10,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- },
- #{<<"id">> => <<"300">>, <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{<<"id">> => <<"100">>, <<"permission_overwrites">> => []},
- #{
- <<"id">> => <<"101">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(ViewPerm)
- }
- ]
- },
- #{<<"id">> => <<"102">>, <<"permission_overwrites">> => []}
- ]
- }
- },
- Channels = lists:sort(guild_visibility_channels:get_user_viewable_channels(UserId, State)),
- ?assertEqual([100, 102], Channels).
-
-invalid_channel_ids_are_skipped_test() ->
- GuildId = 120,
- UserId = 10,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{<<"id">> => <<"001">>, <<"permission_overwrites">> => []},
- #{<<"id">> => <<"400">>, <<"permission_overwrites">> => []}
- ]
- }
- },
- Channels = guild_visibility_channels:get_user_viewable_channels(UserId, State),
- ?assertEqual([400], Channels).
-
-invalid_parent_id_does_not_include_category_test() ->
- GuildId = 130,
- UserId = 10,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{
- <<"id">> => <<"2">>,
- <<"type">> => 4,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(ViewPerm)
- }
- ]
- },
- #{
- <<"id">> => <<"401">>,
- <<"parent_id">> => <<"002">>,
- <<"permission_overwrites">> => []
- }
- ]
- }
- },
- Channels = guild_visibility_channels:get_user_viewable_channels(UserId, State),
- ?assertEqual([401], Channels).
diff --git a/fluxer_gateway/test/guild_visibility_permission_tests.erl b/fluxer_gateway/test/guild_visibility_permission_tests.erl
deleted file mode 100644
index 3536d18aa..000000000
--- a/fluxer_gateway/test/guild_visibility_permission_tests.erl
+++ /dev/null
@@ -1,206 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_visibility_permission_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-channel_overwrite_denies_view_test() ->
- GuildId = 80,
- UserId = 10,
- RoleId = 200,
- ChannelId = 400,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- },
- #{<<"id">> => integer_to_binary(RoleId), <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [integer_to_binary(RoleId)]
- }
- ],
- <<"channels">> => [
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- ]
- }
- },
- Channels = guild_visibility_channels:get_user_viewable_channels(UserId, State),
- ?assertEqual([], Channels).
-
-role_overwrite_allows_view_test() ->
- GuildId = 90,
- UserId = 10,
- RoleId = 300,
- ChannelId = 500,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- },
- #{<<"id">> => integer_to_binary(RoleId), <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [integer_to_binary(RoleId)]
- }
- ],
- <<"channels">> => [
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(ViewPerm)
- },
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"type">> => 0,
- <<"allow">> => integer_to_binary(ViewPerm),
- <<"deny">> => <<"0">>
- }
- ]
- }
- ]
- }
- },
- Channels = guild_visibility_channels:get_user_viewable_channels(UserId, State),
- ?assertEqual([ChannelId], Channels).
-
-user_overwrite_denies_view_test() ->
- GuildId = 91,
- UserId = 10,
- RoleId = 301,
- ChannelId = 501,
- ViewPerm = constants:view_channel_permission(),
- State = #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- },
- #{<<"id">> => integer_to_binary(RoleId), <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [integer_to_binary(RoleId)]
- }
- ],
- <<"channels">> => [
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"type">> => 0,
- <<"allow">> => integer_to_binary(ViewPerm),
- <<"deny">> => <<"0">>
- },
- #{
- <<"id">> => integer_to_binary(UserId),
- <<"type">> => 1,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(ViewPerm)
- }
- ]
- }
- ]
- }
- },
- Channels = guild_visibility_channels:get_user_viewable_channels(UserId, State),
- ?assertEqual([], Channels).
-
-parent_category_included_when_child_channel_is_visible_test() ->
- GuildId = 40,
- UserId = 11,
- RoleId = 99,
- CategoryId = 200,
- ChannelId = 201,
- ViewPerm = constants:view_channel_permission(),
- State = parent_category_visible_state(
- GuildId, UserId, RoleId, CategoryId, ChannelId, ViewPerm
- ),
- Channels = lists:sort(guild_visibility_channels:get_user_viewable_channels(UserId, State)),
- ?assertEqual([CategoryId, ChannelId], Channels).
-
-parent_category_visible_state(GuildId, UserId, RoleId, CategoryId, ChannelId, ViewPerm) ->
- #{
- id => GuildId,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => <<"0">>},
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ],
- <<"members">> => [
- #{
- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},
- <<"roles">> => [integer_to_binary(RoleId)]
- }
- ],
- <<"channels">> => [
- parent_category_channel(CategoryId, RoleId, ViewPerm),
- child_visible_channel(ChannelId, CategoryId, RoleId, ViewPerm)
- ]
- }
- }.
-
-parent_category_channel(CategoryId, RoleId, ViewPerm) ->
- #{
- <<"id">> => integer_to_binary(CategoryId),
- <<"type">> => 4,
- <<"permission_overwrites">> => [
- role_overwrite(RoleId, <<"0">>, integer_to_binary(ViewPerm))
- ]
- }.
-
-child_visible_channel(ChannelId, CategoryId, RoleId, ViewPerm) ->
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"type">> => 0,
- <<"parent_id">> => integer_to_binary(CategoryId),
- <<"permission_overwrites">> => [
- role_overwrite(RoleId, integer_to_binary(ViewPerm), <<"0">>)
- ]
- }.
-
-role_overwrite(RoleId, Allow, Deny) ->
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"type">> => 0,
- <<"allow">> => Allow,
- <<"deny">> => Deny
- }.
diff --git a/fluxer_gateway/test/guild_visibility_tests.erl b/fluxer_gateway/test/guild_visibility_tests.erl
deleted file mode 100644
index 28896161d..000000000
--- a/fluxer_gateway/test/guild_visibility_tests.erl
+++ /dev/null
@@ -1,218 +0,0 @@
-%% SPDX-License-Identifier: AGPL-3.0-or-later
-
--module(guild_visibility_tests).
--typing([eqwalizer]).
-
--include_lib("eunit/include/eunit.hrl").
-
-preserves_connected_channel_visibility_on_permission_loss_test() ->
- UserId = 10,
- GuildId = 1,
- ChannelId = 5,
- ViewPerm = constants:view_channel_permission(),
- OldState = visibility_state(GuildId, UserId, ChannelId, ViewPerm, true),
- NewState = visibility_state(GuildId, UserId, ChannelId, 0, true),
- UpdatedState = guild_visibility_overwrites:compute_and_dispatch_visibility_changes(
- OldState, NewState
- ),
- ?assert(guild_virtual_channel_access:has_virtual_access(UserId, ChannelId, UpdatedState)),
- ?assertEqual(
- false,
- guild_virtual_channel_access:is_pending_join(UserId, ChannelId, UpdatedState)
- ),
- ?assert(
- guild_permissions_check:can_view_channel(UserId, ChannelId, undefined, UpdatedState)
- ).
-
-does_not_add_virtual_access_when_not_connected_test() ->
- UserId = 20,
- GuildId = 2,
- ChannelId = 6,
- ViewPerm = constants:view_channel_permission(),
- OldState = visibility_state(GuildId, UserId, ChannelId, ViewPerm, false),
- NewState = visibility_state(GuildId, UserId, ChannelId, 0, false),
- UpdatedState = guild_visibility_overwrites:compute_and_dispatch_visibility_changes(
- OldState, NewState
- ),
- ?assertNot(
- guild_virtual_channel_access:has_virtual_access(UserId, ChannelId, UpdatedState)
- ).
-
-does_not_add_virtual_access_when_permission_remains_test() ->
- UserId = 30,
- GuildId = 3,
- ChannelId = 7,
- ViewPerm = constants:view_channel_permission(),
- OldState = visibility_state(GuildId, UserId, ChannelId, ViewPerm, true),
- NewState = visibility_state(GuildId, UserId, ChannelId, ViewPerm, true),
- UpdatedState = guild_visibility_overwrites:compute_and_dispatch_visibility_changes(
- OldState, NewState
- ),
- ?assertNot(
- guild_virtual_channel_access:has_virtual_access(UserId, ChannelId, UpdatedState)
- ).
-
-compute_and_dispatch_visibility_changes_for_users_targets_selected_users_test() ->
- GuildId = 33,
- ChannelId = 77,
- RoleId = 101,
- ViewPerm = constants:view_channel_permission(),
- OldState = users_visibility_state(GuildId, ChannelId, RoleId, ViewPerm, role, role),
- NewState = users_visibility_state(GuildId, ChannelId, RoleId, ViewPerm, none, role),
- UpdatedState = guild_visibility_overwrites:compute_and_dispatch_visibility_changes_for_users(
- [10], OldState, NewState
- ),
- UpdatedSessions = maps:get(sessions, UpdatedState),
- UpdatedSession10 = maps:get(<<"s10">>, UpdatedSessions),
- UpdatedSession20 = maps:get(<<"s20">>, UpdatedSessions),
- ?assertEqual(
- false,
- maps:is_key(ChannelId, maps:get(viewable_channels, UpdatedSession10, #{}))
- ),
- ?assertEqual(
- true,
- maps:is_key(ChannelId, maps:get(viewable_channels, UpdatedSession20, #{}))
- ).
-
-compute_and_dispatch_visibility_changes_for_channels_limits_test() ->
- GuildId = 44,
- UserId = 10,
- ChannelA = 100,
- ChannelB = 101,
- ViewPerm = constants:view_channel_permission(),
- BaseRole = #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- },
- OldChannels = [visible_channel(ChannelA), visible_channel(ChannelB)],
- NewChannels = [denied_channel(ChannelA, GuildId, ViewPerm), visible_channel(ChannelB)],
- OldState = channels_visibility_state(
- GuildId, UserId, BaseRole, ChannelA, ChannelB, OldChannels
- ),
- NewState = channels_visibility_state(
- GuildId, UserId, BaseRole, ChannelA, ChannelB, NewChannels
- ),
- UpdatedState = guild_visibility_overwrites:compute_and_dispatch_visibility_changes_for_channels(
- [ChannelA], OldState, NewState
- ),
- UpdatedSession = maps:get(<<"s10">>, maps:get(sessions, UpdatedState)),
- UpdatedViewable = maps:get(viewable_channels, UpdatedSession, #{}),
- ?assertEqual(false, maps:is_key(ChannelA, UpdatedViewable)),
- ?assertEqual(true, maps:is_key(ChannelB, UpdatedViewable)).
-
-connected_voice_channel_sets_groups_channels_by_user_test() ->
- State = #{
- voice_states => #{
- <<"a">> => #{<<"user_id">> => <<"10">>, <<"channel_id">> => <<"100">>},
- <<"b">> => #{<<"user_id">> => <<"10">>, <<"channel_id">> => <<"101">>},
- <<"c">> => #{<<"user_id">> => <<"20">>, <<"channel_id">> => <<"200">>},
- <<"bad">> => #{<<"user_id">> => <<"20">>, <<"channel_id">> => null}
- }
- },
- Result = guild_visibility_channels:connected_voice_channel_sets(State),
- ?assertEqual([100, 101], lists:sort(sets:to_list(maps:get(10, Result)))),
- ?assertEqual([200], sets:to_list(maps:get(20, Result))).
-
-users_visibility_state(GuildId, ChannelId, RoleId, ViewPerm, User10Role, User20Role) ->
- Session10 = visibility_session(<<"s10">>, 10, #{ChannelId => true}),
- Session20 = visibility_session(<<"s20">>, 20, #{ChannelId => true}),
- #{
- id => GuildId,
- sessions => #{<<"s10">> => Session10, <<"s20">> => Session20},
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => visibility_roles(GuildId, RoleId, ViewPerm),
- <<"members">> => #{
- 10 => visibility_member(10, role_ids(User10Role, RoleId)),
- 20 => visibility_member(20, role_ids(User20Role, RoleId))
- },
- <<"channels">> => [visible_channel(ChannelId)]
- }
- }.
-
-channels_visibility_state(GuildId, UserId, BaseRole, ChannelA, ChannelB, Channels) ->
- Session = visibility_session(<<"s10">>, UserId, #{ChannelA => true, ChannelB => true}),
- #{
- id => GuildId,
- sessions => #{<<"s10">> => Session},
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [BaseRole],
- <<"members">> => #{UserId => visibility_member(UserId, [])},
- <<"channels">> => Channels
- }
- }.
-
-visibility_session(SessionId, UserId, ViewableChannels) ->
- #{
- session_id => SessionId,
- user_id => UserId,
- pid => self(),
- viewable_channels => ViewableChannels
- }.
-
-visibility_roles(GuildId, RoleId, ViewPerm) ->
- [
- #{<<"id">> => integer_to_binary(GuildId), <<"permissions">> => <<"0">>},
- #{
- <<"id">> => integer_to_binary(RoleId),
- <<"permissions">> => integer_to_binary(ViewPerm)
- }
- ].
-
-visibility_member(UserId, Roles) ->
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => Roles}.
-
-role_ids(role, RoleId) ->
- [integer_to_binary(RoleId)];
-role_ids(none, _RoleId) ->
- [].
-
-visible_channel(ChannelId) ->
- #{<<"id">> => integer_to_binary(ChannelId), <<"permission_overwrites">> => []}.
-
-denied_channel(ChannelId, GuildId, ViewPerm) ->
- #{
- <<"id">> => integer_to_binary(ChannelId),
- <<"permission_overwrites">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => integer_to_binary(ViewPerm)
- }
- ]
- }.
-
-visibility_state(GuildId, UserId, ChannelId, Perms, Connected) ->
- VoiceStates =
- case Connected of
- true ->
- #{
- <<"conn">> => #{
- <<"user_id">> => integer_to_binary(UserId),
- <<"guild_id">> => integer_to_binary(GuildId),
- <<"channel_id">> => integer_to_binary(ChannelId),
- <<"connection_id">> => <<"conn">>
- }
- };
- false ->
- #{}
- end,
- Sessions = #{<<"s1">> => #{user_id => UserId, pid => self()}},
- Data = #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [
- #{
- <<"id">> => integer_to_binary(GuildId),
- <<"permissions">> => integer_to_binary(Perms)
- }
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{<<"id">> => integer_to_binary(ChannelId), <<"permission_overwrites">> => []}
- ]
- },
- #{id => GuildId, data => Data, sessions => Sessions, voice_states => VoiceStates}.