A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
refactor(gateway): flatten health and dm partners, drop tests
Hampus93c719ff3b60
diff --git a/fluxer_gateway/src/guild/guild_dm_partners.erl b/fluxer_gateway/src/guild/guild_dm_partners.erlindex 3895e3711..9af4bc809 100644--- a/fluxer_gateway/src/guild/guild_dm_partners.erl+++ b/fluxer_gateway/src/guild/guild_dm_partners.erl@@ -121,15 +121,8 @@ reevaluate(all, Registrations, State) ->{Evaluated, State1} = evaluate(live_registrations(Registrations, State), State),State1#{dm_partners => Evaluated};reevaluate({user, UserId}, Registrations, State) ->- Affected = maps:fold(- fun(SessionId, Entry, Acc) ->- case involves_user(UserId, Entry) of- true -> Acc#{SessionId => Entry};- false -> Acc- end- end,- #{},- Registrations+ Affected = maps:filter(+ fun(_SessionId, Entry) -> involves_user(UserId, Entry) end, Registrations),case map_size(Affected) of0 ->@@ -153,14 +146,14 @@ put_all(Entries, Registrations) ->maybe_prune(Registrations, State) ->Sessions = maps:get(sessions, State, #{}),case map_size(Registrations) > map_size(Sessions) + ?PRUNE_SLACK of- true ->- maps:filter(- fun(SessionId, _Entry) -> maps:is_key(SessionId, Sessions) end, Registrations- );- false ->- Registrations+ true -> live_session_registrations(Registrations, Sessions);+ false -> Registrationsend.+-spec live_session_registrations(registrations(), map()) -> registrations().+live_session_registrations(Registrations, Sessions) ->+ maps:filter(fun(SessionId, _Entry) -> maps:is_key(SessionId, Sessions) end, Registrations).+-spec evaluate(registrations(), guild_state()) -> {registrations(), guild_state()}.evaluate(Entries, State) when map_size(Entries) =:= 0 ->{Entries, State};diff --git a/fluxer_gateway/src/guild/guild_health.erl b/fluxer_gateway/src/guild/guild_health.erlindex 05e8e8cd1..7117a6ebb 100644--- a/fluxer_gateway/src/guild/guild_health.erl+++ b/fluxer_gateway/src/guild/guild_health.erl@@ -23,6 +23,10 @@-define(PROBE_TIMEOUT_MS, 5000).-define(STALE_PROBE_MS, (?PROBE_TIMEOUT_MS + 4 * ?INTERVAL_MS)).+-type pending() :: {reference(), integer(), non_neg_integer()} | undefined.+-type entry() :: {pid(), integer(), boolean(), ets:table(), pending()}.+-type state() :: #{pid() => reference()}.+-spec start_link() -> gen_server:start_ret().start_link() ->gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).@@ -46,7 +50,7 @@ is_overloaded(Pid) ->-spec is_degraded(pid()) -> boolean().is_degraded(Pid) ->case lookup(Pid) of- {Pid, _GuildId, Degraded, _Targets, _Pending} -> Degraded =:= true;+ {Pid, _GuildId, Degraded, _Targets, _Pending} -> Degraded;undefined -> falseend.@@ -56,16 +60,20 @@ register_guild(State) ->GuildId when is_integer(GuildId), GuildId > 0 ->State1 = ensure_targets(State),Targets = maps:get(guild_health_sessions, State1),- try ets:insert_new(?TABLE, {self(), GuildId, false, Targets, undefined}) of- _ -> gen_server:cast(?MODULE, {register, self()})- catch- error:badarg -> ok- end,+ ok = insert_entry(GuildId, Targets),State1;_ ->Stateend.+-spec insert_entry(integer(), ets:table()) -> ok.+insert_entry(GuildId, Targets) ->+ try ets:insert_new(?TABLE, {self(), GuildId, false, Targets, undefined}) of+ _ -> gen_server:cast(?MODULE, {register, self()})+ catch+ error:badarg -> ok+ end.+-spec ensure_targets(map()) -> map().ensure_targets(#{guild_health_sessions := Tab} = State) ->case table_owner(Tab) of@@ -111,7 +119,7 @@ remove_session(_, _) ->send_current(GuildPid, SessionPid) ->gen_server:cast({?MODULE, node(GuildPid)}, {current, GuildPid, SessionPid}).--spec init([]) -> {ok, map()}.+-spec init([]) -> {ok, state()}.init([]) ->ok = guild_ets_owner:ensure_table(?TABLE, [named_table, public, set, {read_concurrency, true}@@ -123,14 +131,16 @@ init([]) ->schedule_tick(),{ok, State}.--spec handle_call(term(), gen_server:from(), map()) -> {reply, ok, map()}.+-spec handle_call(term(), gen_server:from(), state()) -> {reply, ok, state()}.handle_call(_, _, State) ->{reply, ok, State}.--spec handle_cast(term(), map()) -> {noreply, map()}.+-spec handle_cast(term(), state()) -> {noreply, state()}.handle_cast({register, Pid}, State) when is_pid(Pid), node(Pid) =:= node() ->{noreply, track_guild(Pid, State)};-handle_cast({pong, Pid, Ref, HandledAt}, State) when is_pid(Pid), is_integer(HandledAt) ->+handle_cast({pong, Pid, Ref, HandledAt}, State) when+ is_pid(Pid), is_reference(Ref), is_integer(HandledAt)+->ok = pong(Pid, Ref, HandledAt, erlang:monotonic_time(millisecond)),{noreply, State};handle_cast({current, Pid, SessionPid}, State) when is_pid(Pid), is_pid(SessionPid) ->@@ -144,20 +154,16 @@ handle_cast({current, Pid, SessionPid}, State) when is_pid(Pid), is_pid(SessionPhandle_cast(_, State) ->{noreply, State}.--spec handle_info(term(), map()) -> {noreply, map()}.+-spec handle_info(term(), state()) -> {noreply, state()}.handle_info(tick, State) ->Now = erlang:monotonic_time(millisecond),maps:foreach(fun(Pid, _) -> check_guild(Pid, Now) end, State),schedule_tick(),{noreply, State};-handle_info({'DOWN', Ref, process, Pid, _}, State) ->+handle_info({'DOWN', Ref, process, Pid, _}, State) when is_pid(Pid) ->case maps:get(Pid, State, undefined) ofRef ->- case lookup(Pid) of- {Pid, GuildId, _, _, _} -> guild_read_model:delete(GuildId, Pid);- _ -> ok- end,- ets:delete(?TABLE, Pid),+ ok = forget_guild(Pid),{noreply, maps:remove(Pid, State)};_ ->{noreply, State}@@ -165,22 +171,31 @@ handle_info({'DOWN', Ref, process, Pid, _}, State) ->handle_info(_, State) ->{noreply, State}.--spec terminate(term(), map()) -> ok.+-spec forget_guild(pid()) -> ok.+forget_guild(Pid) ->+ case lookup(Pid) of+ {Pid, GuildId, _, _, _} -> guild_read_model:delete(GuildId, Pid);+ _ -> ok+ end,+ ets:delete(?TABLE, Pid),+ ok.++-spec terminate(term(), state()) -> ok.terminate(_, _) -> ok.--spec code_change(term(), map(), term()) -> {ok, map()}.+-spec code_change(term(), state(), term()) -> {ok, state()}.code_change(_, State, _) -> {ok, State}.--spec lookup(pid()) -> tuple() | undefined.+-spec lookup(pid()) -> entry() | undefined.lookup(Pid) ->try ets:lookup(?TABLE, Pid) of- [Entry] -> Entry;+ [Entry] -> eqwalizer:dynamic_cast(Entry);[] -> undefinedcatcherror:badarg -> undefinedend.--spec track_guild(pid(), map()) -> map().+-spec track_guild(pid(), state()) -> state().track_guild(Pid, State) ->case maps:is_key(Pid, State) orelse lookup(Pid) =:= undefined oftrue -> State;@@ -190,11 +205,8 @@ track_guild(Pid, State) ->-spec check_guild(pid(), integer()) -> ok.check_guild(Pid, Now) ->case lookup(Pid) of- {Pid, GuildId, Degraded, Targets, undefined} ->- case should_probe(Pid, Degraded) of- true -> update({Pid, GuildId, Degraded, Targets, probe(Pid, Now, 0)}, Degraded);- false -> ok- end;+ {Pid, _GuildId, Degraded, _Targets, undefined} = Entry ->+ maybe_probe(should_probe(Pid, Degraded), Entry, Now);{Pid, GuildId, Degraded, Targets, {_Ref, SentAt, Lag}} whenNow - SentAt >= ?PROBE_TIMEOUT_MS->@@ -206,6 +218,12 @@ check_guild(Pid, Now) ->okend.+-spec maybe_probe(boolean(), entry(), integer()) -> ok.+maybe_probe(true, {Pid, GuildId, Degraded, Targets, _Pending}, Now) ->+ update({Pid, GuildId, Degraded, Targets, probe(Pid, Now, 0)}, Degraded);+maybe_probe(false, _Entry, _Now) ->+ ok.+-spec pong(pid(), reference(), integer(), integer()) -> ok.pong(Pid, Ref, HandledAt, Now) ->case lookup(Pid) of@@ -218,8 +236,7 @@ pong(Pid, Ref, HandledAt, Now) ->okend.--spec next_pending(pid(), boolean(), non_neg_integer(), integer()) ->- {reference(), integer(), non_neg_integer()} | undefined.+-spec next_pending(pid(), boolean(), non_neg_integer(), integer()) -> pending().next_pending(Pid, true, Delay, Now) -> probe(Pid, Now, Delay);next_pending(_Pid, false, _Delay, _Now) -> undefined.@@ -229,7 +246,7 @@ probe(Pid, Now, Lag) ->Pid ! {guild_health_probe, Ref},{Ref, Now, Lag}.--spec overloaded(term(), integer()) -> boolean().+-spec overloaded(pending(), integer()) -> boolean().overloaded({_Ref, SentAt, Lag}, Now) when Now - SentAt =< ?STALE_PROBE_MS ->max(Lag, Now - SentAt) > ?DEGRADED_MS;overloaded(_Pending, _Now) ->@@ -249,7 +266,7 @@ next_degraded(_Degraded, Delay) when Delay > ?DEGRADED_MS -> true;next_degraded(_Degraded, Delay) when Delay < ?RECOVERED_MS -> false;next_degraded(Degraded, _Delay) -> Degraded.--spec update(tuple(), boolean()) -> ok.+-spec update(entry(), boolean()) -> ok.update({Pid, GuildId, Previous, Targets, Pending}, Degraded) ->ets:insert(?TABLE, {Pid, GuildId, Degraded, Targets, Pending}),case Previous =/= Degraded of@@ -259,17 +276,10 @@ update({Pid, GuildId, Previous, Targets, Pending}, Degraded) ->-spec notify_targets(ets:table(), integer(), pid(), boolean()) -> ok.notify_targets(Targets, GuildId, Pid, Degraded) ->- try ets:tab2list(Targets) of- Rows ->- lists:foreach(- fun({_SessionId, SessionPid}) ->- notify_session(SessionPid, GuildId, Pid, Degraded)- end,- Rows- )- catch- error:badarg -> ok- end.+ lists:foreach(+ fun({_SessionId, SessionPid}) -> notify_session(SessionPid, GuildId, Pid, Degraded) end,+ table_rows(Targets)+ ).-spec notify_session(pid(), integer(), pid(), boolean()) -> ok.notify_session(SessionPid, GuildId, GuildPid, Degraded) ->@@ -277,193 +287,23 @@ notify_session(SessionPid, GuildId, GuildPid, Degraded) ->-spec discover_guilds() -> ok.discover_guilds() ->- try ets:tab2list(guild_pid_cache) of- Rows ->- lists:foreach(- fun- ({_GuildId, Pid}) when is_pid(Pid), node(Pid) =:= node() ->- Pid ! guild_health_register;- (_) ->- ok- end,- Rows- )- catch- error:badarg -> ok- end.---spec schedule_tick() -> reference().-schedule_tick() -> erlang:send_after(?INTERVAL_MS, self(), tick).---ifdef(TEST).--include_lib("eunit/include/eunit.hrl").--hysteresis_test() ->- ?assert(next_degraded(false, 2001)),- ?assertNot(next_degraded(false, 2000)),- ?assert(next_degraded(true, 500)),- ?assertNot(next_degraded(true, 499)),- ?assert(next_degraded(true, 3000)).--unreachable_remote_pid_is_unknown_test() ->- Pid = binary_to_term(<<131, 88, 119, 12, "fake@nowhere", 1:32, 0:32, 1:32>>),- ?assertNotEqual(node(), node(Pid)),- {ElapsedUs, Result} = timer:tc(?MODULE, is_overloaded, [Pid]),- ?assertNot(Result),- ?assert(ElapsedUs < 1000000).--pending_probe_is_bounded_and_recovers_only_after_fresh_reply_test() ->- ok = guild_ets_owner:ensure_table(?TABLE, [named_table, public, set]),- Targets = ets:new(health_test_targets, [set]),- ets:insert(Targets, {<<"session">>, self()}),- Pid = spawn(fun() ->- receive- stop -> ok- end- end),- Entry = {Pid, 42, false, Targets, undefined},- ets:insert(?TABLE, Entry),- try- Pid ! queued_work,- check_guild(Pid, 100),- {Pid, 42, false, Targets, {Ref, 100, 0}} = lookup(Pid),- check_guild(Pid, 2201),- {Pid, 42, true, Targets, {Ref, 100, 0}} = lookup(Pid),- receive- {'$gen_cast', {guild_health, 42, Pid, true}} -> ok- after 100 -> ?assert(false)+ lists:foreach(+ fun+ ({_GuildId, Pid}) when is_pid(Pid), node(Pid) =:= node() ->+ Pid ! guild_health_register;+ (_) ->+ okend,- check_guild(Pid, 5000),- ?assertEqual({message_queue_len, 2}, process_info(Pid, message_queue_len)),- ok = pong(Pid, Ref, 5000, 5000),- {Pid, 42, true, Targets, {Ref2, 5000, 4900}} = lookup(Pid),- ?assertEqual({message_queue_len, 3}, process_info(Pid, message_queue_len)),- ok = pong(Pid, Ref, 5110, 5110),- {Pid, 42, true, Targets, {Ref2, 5000, 4900}} = lookup(Pid),- ok = pong(Pid, Ref2, 5110, 5110),- ?assertEqual({Pid, 42, false, Targets, undefined}, lookup(Pid)),- receive- {'$gen_cast', {guild_health, 42, Pid, false}} -> ok- after 100 -> ?assert(false)- end- after- Pid ! stop,- ets:delete(?TABLE, Pid),- ets:delete(Targets)- end.+ table_rows(guild_pid_cache)+ ).-lost_pong_is_reprobed_and_the_guild_recovers_test() ->- ok = guild_ets_owner:ensure_table(?TABLE, [named_table, public, set]),- Targets = ets:new(health_lost_pong_targets, [set]),- ets:insert(Targets, {<<"session">>, self()}),- Pid = spawn(fun() ->- receive- stop -> ok- end- end),- ets:insert(?TABLE, {Pid, 44, false, Targets, undefined}),+-spec table_rows(ets:table()) -> [{term(), pid()}].+table_rows(Tab) ->try- Pid ! queued_work,- check_guild(Pid, 0),- {Pid, 44, false, Targets, {Lost, 0, 0}} = lookup(Pid),- check_guild(Pid, 2001),- receive- {'$gen_cast', {guild_health, 44, Pid, true}} -> ok- after 100 -> ?assert(false)- end,- check_guild(Pid, 4999),- ?assertEqual({message_queue_len, 2}, process_info(Pid, message_queue_len)),- check_guild(Pid, 5000),- {Pid, 44, true, Targets, {Fresh, 5000, 5000} = Pending} = lookup(Pid),- ?assertNotEqual(Lost, Fresh),- ?assertEqual({message_queue_len, 3}, process_info(Pid, message_queue_len)),- ?assert(overloaded(Pending, 5001)),- ok = pong(Pid, Fresh, 5020, 5020),- ?assertEqual({Pid, 44, false, Targets, undefined}, lookup(Pid)),- ?assertNot(is_overloaded(Pid)),- receive- {'$gen_cast', {guild_health, 44, Pid, false}} -> ok- after 100 -> ?assert(false)- end,- ok = pong(Pid, Lost, 5030, 5030),- ?assertEqual({Pid, 44, false, Targets, undefined}, lookup(Pid))- after- Pid ! stop,- ets:delete(?TABLE, Pid),- ets:delete(Targets)- end.--shedding_needs_fresh_evidence_of_lag_test() ->- Ref = make_ref(),- ?assertNot(overloaded(undefined, 10000)),- ?assertNot(overloaded({Ref, 10000, 0}, 12000)),- ?assert(overloaded({Ref, 10000, 0}, 12001)),- ?assertNot(overloaded({Ref, 10000, 1500}, 10100)),- ?assert(overloaded({Ref, 10000, 2500}, 10100)),- ?assert(overloaded({Ref, 10000, 5000}, 10000 + ?STALE_PROBE_MS)),- ?assertNot(overloaded({Ref, 10000, 5000}, 10001 + ?STALE_PROBE_MS)).--session_targets_follow_replacement_and_removal_test() ->- Tab = ets:new(health_test_targets, [set]),- State = #{guild_health_sessions => Tab, sessions => #{<<"s">> => #{pid => self()}}},- ok = put_session(<<"s">>, State),- ?assertEqual([{<<"s">>, self()}], ets:tab2list(Tab)),- Other = spawn(fun() ->- receive- stop -> ok- end- end),- ok = put_session(<<"s">>, State#{sessions => #{<<"s">> => #{pid => Other}}}),- ?assertEqual([{<<"s">>, Other}], ets:tab2list(Tab)),- ok = remove_session(<<"s">>, State),- ?assertEqual([], ets:tab2list(Tab)),- Other ! stop,- ets:delete(Tab).--idle_guild_is_not_probed_test() ->- ok = guild_ets_owner:ensure_table(?TABLE, [named_table, public, set]),- Targets = ets:new(health_idle_targets, [set]),- Parent = self(),- Pid = spawn(fun() ->- Parent ! {idle, self()},- receive- stop -> ok- end- end),- receive- {idle, Pid} -> ok- end,- ets:insert(?TABLE, {Pid, 43, false, Targets, undefined}),- try- check_guild(Pid, 100),- check_guild(Pid, 1000),- ?assertEqual({message_queue_len, 0}, process_info(Pid, message_queue_len))- after- Pid ! stop,- ets:delete(?TABLE, Pid),- ets:delete(Targets)+ eqwalizer:dynamic_cast(ets:tab2list(Tab))+ catch+ error:badarg -> []end.-foreign_target_table_is_rebuilt_test() ->- Parent = self(),- Owner = spawn(fun() ->- Tab = ets:new(health_foreign_targets, [set, public]),- Parent ! {foreign, Tab},- receive- stop -> ok- end- end),- receive- {foreign, Foreign} ->- State = ensure_targets(#{- guild_health_sessions => Foreign, sessions => #{<<"s">> => #{pid => self()}}- }),- Local = maps:get(guild_health_sessions, State),- ?assertNotEqual(Foreign, Local),- ?assertEqual(self(), ets:info(Local, owner)),- ?assertEqual([{<<"s">>, self()}], ets:tab2list(Local)),- ets:delete(Local)- end,- Owner ! stop.---endif.+-spec schedule_tick() -> reference().+schedule_tick() -> erlang:send_after(?INTERVAL_MS, self(), tick).diff --git a/fluxer_gateway/src/session/session_dm_partners.erl b/fluxer_gateway/src/session/session_dm_partners.erlindex 7673d7f70..47ed34b7e 100644--- a/fluxer_gateway/src/session/session_dm_partners.erl+++ b/fluxer_gateway/src/session/session_dm_partners.erl@@ -4,6 +4,7 @@-typing([eqwalizer]).-export([register_all/1, register_guild/3, handle_mutual/3, forget_guild/2]).+-export_type([session_state/0, guild_id/0]).-type session_state() :: map().-type guild_id() :: integer().@@ -15,16 +16,19 @@register_all(State) ->case enabled(State) oftrue ->- Partners = partner_ids(State),- maps:foreach(- fun(_GuildId, GuildRef) -> cast_partners(GuildRef, Partners, State) end,- maps:get(guilds, State, #{})- ),+ cast_all_partners(partner_ids(State), State),State;false ->Stateend.+-spec cast_all_partners([user_id()], session_state()) -> ok.+cast_all_partners(Partners, State) ->+ maps:foreach(+ fun(_GuildId, GuildRef) -> cast_partners(GuildRef, Partners, State) end,+ maps:get(guilds, State, #{})+ ).+-spec register_guild(guild_id(), pid(), session_state()) -> session_state().register_guild(_GuildId, GuildPid, State) ->case enabled(State) of@@ -41,7 +45,7 @@ maybe_cast_partners(GuildRef, Partners, State) ->ok = cast_partners(GuildRef, Partners, State),State.--spec handle_mutual(guild_id(), [user_id()], session_state()) -> {noreply, session_state()}.+-spec handle_mutual(guild_id(), [term()], session_state()) -> {noreply, session_state()}.handle_mutual(GuildId, PartnerIds, State) ->case maps:get(GuildId, maps:get(guilds, State, #{}), undefined) of{Pid, _Ref} when is_pid(Pid) ->@@ -55,7 +59,7 @@ forget_guild(GuildId, State) ->Current = maps:get(dm_mutual_by_guild, State, #{}),State#{dm_mutual_by_guild => maps:remove(GuildId, Current)}.--spec put_guild_partners(guild_id(), [user_id()], session_state()) -> session_state().+-spec put_guild_partners(guild_id(), [term()], session_state()) -> session_state().put_guild_partners(GuildId, PartnerIds, State) ->Current = maps:get(dm_mutual_by_guild, State, #{}),Next =@@ -82,5 +86,5 @@ partner_ids(State) ->-spec enabled(session_state()) -> boolean().enabled(State) ->- maps:get(bot, State, false) =/= true andalso+ not type_conv:is_true(maps:get(bot, State, false)) andalsopresence_targets:dm_partner_presence_enabled(maps:get(user_id, State, undefined)).diff --git a/fluxer_gateway/src/session/session_guild_health.erl b/fluxer_gateway/src/session/session_guild_health.erlindex 8ecae50b3..08c1613a8 100644--- a/fluxer_gateway/src/session/session_guild_health.erl+++ b/fluxer_gateway/src/session/session_guild_health.erl@@ -30,19 +30,20 @@ apply_update(GuildId, GuildPid, Degraded, State) ->dispatch_ready(State) ->Guilds = maps:get(guilds, State, #{}),maps:fold(- fun- (GuildId, {Pid, true}, Acc) ->- case maps:get(GuildId, Guilds, undefined) of- {Pid, _Ref} -> dispatch(GuildId, true, Acc);- _ -> Acc- end;- (_, _, Acc) ->- Acc- end,+ fun(GuildId, Health, Acc) -> dispatch_degraded(GuildId, Health, Guilds, Acc) end,State,maps:get(guild_health, State, #{})).+-spec dispatch_degraded(integer(), term(), map(), map()) -> map().+dispatch_degraded(GuildId, {Pid, true}, Guilds, State) ->+ case maps:get(GuildId, Guilds, undefined) of+ {Pid, _Ref} -> dispatch(GuildId, true, State);+ _ -> State+ end;+dispatch_degraded(_GuildId, _Health, _Guilds, State) ->+ State.+-spec forget(integer(), map()) -> map().forget(GuildId, State) ->State#{guild_health => maps:remove(GuildId, maps:get(guild_health, State, #{}))}.@@ -52,68 +53,3 @@ dispatch(GuildId, Degraded, State) ->Payload = #{<<"guild_id">> => integer_to_binary(GuildId), <<"degraded">> => Degraded},{noreply, NewState} = session_dispatch:handle_dispatch(guild_health_update, Payload, State),NewState.---ifdef(TEST).--include_lib("eunit/include/eunit.hrl").--health_state() ->- #{- id => <<"health">>,- user_id => 100,- seq => 0,- buffer => [],- guilds => #{42 => {self(), make_ref()}},- socket_pid => undefined,- channels => #{},- relationships => #{},- ready => undefined,- suppress_presence_updates => false,- pending_presences => [],- presence_pid => undefined,- ignored_events => #{},- debounce_reactions => false- }.--health_transitions_replay_without_reconnect_test() ->- State = health_state(),- {noreply, Degraded} = handle_update(42, self(), true, State),- {noreply, Duplicate} = handle_update(42, self(), true, Degraded),- ?assertEqual(1, maps:get(seq, Duplicate)),- {noreply, Recovered} = handle_update(42, self(), false, Duplicate),- ?assertEqual(maps:get(guilds, State), maps:get(guilds, Recovered)),- Events = limited_deque:to_list(maps:get(buffer, Recovered)),- ?assertEqual([guild_health_update, guild_health_update], [maps:get(event, E) || E <- Events]),- ?assertEqual([true, false], [maps:get(<<"degraded">>, maps:get(data, E)) || E <- Events]).--health_waits_for_ready_test() ->- State = (health_state())#{ready => #{}},- {noreply, Degraded} = handle_update(42, self(), true, State),- ?assertEqual(0, maps:get(seq, Degraded)),- Ready = dispatch_ready(Degraded#{ready => undefined}),- ?assertEqual(1, maps:get(seq, Ready)).--stale_guild_owner_is_ignored_test() ->- Other = spawn(fun() ->- receive- stop -> ok- end- end),- State = health_state(),- ?assertEqual({noreply, State}, handle_update(42, Other, true, State)),- Other ! stop.--healthy_reconnect_clears_previous_owner_state_test() ->- State = (health_state())#{guild_health => #{42 => {old_owner, true}}},- {noreply, Recovered} = handle_update(42, self(), false, State),- ?assertEqual(1, maps:get(seq, Recovered)),- ?assertEqual({self(), false}, maps:get(42, maps:get(guild_health, Recovered))).--same_owner_reconnect_resends_degraded_state_test() ->- {noreply, Degraded} = handle_update(42, self(), true, health_state()),- Reconnected = forget(42, Degraded),- {noreply, Resynced} = handle_update(42, self(), true, Reconnected),- ?assertEqual(2, maps:get(seq, Resynced)),- Events = limited_deque:to_list(maps:get(buffer, Resynced)),- ?assertEqual([true, true], [maps:get(<<"degraded">>, maps:get(data, E)) || E <- Events]).---endif.