A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
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.erlindex 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 =/= asend_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.erlindex 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.erlindex 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.erlindex 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.erlindex 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) ->catcherror: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.erlindex 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.erlindex 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.erlindex 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) whenextract_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.erlindex 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) ->catcherror:badarg -> unknownend.---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.erlindex 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.erlindex 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.erlindex 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};_ -> falseend.---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.erlindex 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_foundend.---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.erlindex 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.erlindex 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 -> Stateend.---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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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]';- (3) -> '[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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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.erldeleted file mode 100644index 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}.