mirror of
https://github.com/fluxerapp/fluxer
synced 2026-10-07 19:22:14 +09:00
test(backend): remove duplicate and useless tests (#2820)
This commit is contained in:
Hampus
@@ -1,141 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(gateway_errors_tests).
|
||||
-typing([eqwalizer]).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
error_test() ->
|
||||
?assertEqual(
|
||||
{error, not_found, voice_connection_not_found},
|
||||
gateway_errors:error(voice_connection_not_found)
|
||||
),
|
||||
?assertEqual(
|
||||
{error, validation_error, voice_channel_not_voice},
|
||||
gateway_errors:error(voice_channel_not_voice)
|
||||
),
|
||||
?assertEqual(
|
||||
{error, permission_denied, voice_permission_denied},
|
||||
gateway_errors:error(voice_permission_denied)
|
||||
).
|
||||
|
||||
error_code_test() ->
|
||||
?assertEqual(
|
||||
<<"VOICE_CONNECTION_NOT_FOUND">>,
|
||||
gateway_errors:error_code(voice_connection_not_found)
|
||||
),
|
||||
?assertEqual(
|
||||
<<"VOICE_CHANNEL_NOT_FOUND">>, gateway_errors:error_code(voice_channel_not_found)
|
||||
),
|
||||
?assertEqual(
|
||||
<<"VOICE_PERMISSION_DENIED">>,
|
||||
gateway_errors:error_code(voice_permission_denied)
|
||||
),
|
||||
?assertEqual(
|
||||
<<"VOICE_PERMISSION_DENIED">>,
|
||||
gateway_errors:error_code(voice_moderator_missing_connect)
|
||||
),
|
||||
?assertEqual(<<"UNKNOWN_ERROR">>, gateway_errors:error_code(some_random_error)),
|
||||
?assertEqual(<<"TIMEOUT">>, gateway_errors:error_code(timeout)),
|
||||
?assertEqual(<<"INTERNAL_ERROR">>, gateway_errors:error_code(internal_error)).
|
||||
|
||||
error_message_test() ->
|
||||
?assertEqual(
|
||||
<<"Voice connection not found">>,
|
||||
gateway_errors:error_message(voice_connection_not_found)
|
||||
),
|
||||
?assertEqual(
|
||||
<<"Voice channel not found">>,
|
||||
gateway_errors:error_message(voice_channel_not_found)
|
||||
),
|
||||
?assertEqual(
|
||||
<<"Missing voice permissions">>,
|
||||
gateway_errors:error_message(voice_permission_denied)
|
||||
),
|
||||
?assertEqual(
|
||||
<<"Voice channel is full">>,
|
||||
gateway_errors:error_message(voice_channel_full)
|
||||
),
|
||||
?assertEqual(
|
||||
<<"An unknown error occurred">>,
|
||||
gateway_errors:error_message(some_random_error)
|
||||
),
|
||||
?assertEqual(<<"Request timed out">>, gateway_errors:error_message(timeout)).
|
||||
|
||||
error_category_test() ->
|
||||
?assertEqual(not_found, gateway_errors:error_category(voice_connection_not_found)),
|
||||
?assertEqual(not_found, gateway_errors:error_category(voice_channel_not_found)),
|
||||
?assertEqual(not_found, gateway_errors:error_category(dm_channel_not_found)),
|
||||
?assertEqual(validation_error, gateway_errors:error_category(voice_channel_not_voice)),
|
||||
?assertEqual(validation_error, gateway_errors:error_category(validation_invalid_snowflake)),
|
||||
?assertEqual(permission_denied, gateway_errors:error_category(voice_permission_denied)),
|
||||
?assertEqual(permission_denied, gateway_errors:error_category(voice_channel_full)),
|
||||
?assertEqual(voice_error, gateway_errors:error_category(voice_token_failed)),
|
||||
?assertEqual(rate_limited, gateway_errors:error_category(voice_update_rate_limited)),
|
||||
?assertEqual(timeout, gateway_errors:error_category(timeout)),
|
||||
?assertEqual(unknown, gateway_errors:error_category(unknown_error)),
|
||||
?assertEqual(unknown, gateway_errors:error_category(some_random_error)).
|
||||
|
||||
is_recoverable_test() ->
|
||||
?assert(gateway_errors:is_recoverable(not_found)),
|
||||
?assert(gateway_errors:is_recoverable(permission_denied)),
|
||||
?assert(gateway_errors:is_recoverable(voice_error)),
|
||||
?assert(gateway_errors:is_recoverable(validation_error)),
|
||||
?assert(gateway_errors:is_recoverable(timeout)),
|
||||
?assert(gateway_errors:is_recoverable(unknown)),
|
||||
?assertNot(gateway_errors:is_recoverable(rate_limited)),
|
||||
?assertNot(gateway_errors:is_recoverable(auth_failed)).
|
||||
|
||||
all_voice_errors_have_codes_test() ->
|
||||
VoiceErrors = [
|
||||
voice_connection_not_found,
|
||||
voice_channel_not_found,
|
||||
voice_channel_not_voice,
|
||||
voice_member_not_found,
|
||||
voice_user_not_in_voice,
|
||||
voice_guild_not_found,
|
||||
voice_permission_denied,
|
||||
voice_member_timed_out,
|
||||
voice_channel_full,
|
||||
voice_connection_limit_reached,
|
||||
voice_missing_connection_id,
|
||||
voice_invalid_user_id,
|
||||
voice_invalid_channel_id,
|
||||
voice_invalid_state,
|
||||
voice_user_mismatch,
|
||||
voice_token_failed,
|
||||
voice_guild_id_missing,
|
||||
voice_invalid_guild_id,
|
||||
voice_moderator_missing_connect,
|
||||
voice_unclaimed_account,
|
||||
voice_update_rate_limited,
|
||||
voice_nonce_mismatch,
|
||||
voice_pending_expired,
|
||||
voice_camera_user_limit,
|
||||
voice_e2ee_required
|
||||
],
|
||||
assert_known_error_codes(VoiceErrors).
|
||||
|
||||
all_dm_errors_have_codes_test() ->
|
||||
DmErrors = [dm_channel_not_found, dm_not_recipient, dm_invalid_channel_type],
|
||||
assert_known_error_codes(DmErrors).
|
||||
|
||||
all_validation_errors_have_codes_test() ->
|
||||
ValidationErrors = [
|
||||
validation_invalid_snowflake,
|
||||
validation_null_snowflake,
|
||||
validation_invalid_snowflake_list,
|
||||
validation_expected_list,
|
||||
validation_expected_map,
|
||||
validation_missing_field,
|
||||
validation_invalid_params
|
||||
],
|
||||
assert_known_error_codes(ValidationErrors).
|
||||
|
||||
assert_known_error_codes(Errors) ->
|
||||
lists:foreach(fun assert_known_error_code/1, Errors).
|
||||
|
||||
assert_known_error_code(Error) ->
|
||||
Code = gateway_errors:error_code(Error),
|
||||
?assert(is_binary(Code)),
|
||||
?assertNotEqual(<<"UNKNOWN_ERROR">>, Code).
|
||||
@@ -1,18 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(guild_manager_shard_reload_tests).
|
||||
-typing([eqwalizer]).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
select_guilds_to_reload_empty_ids_test() ->
|
||||
Guilds = #{1 => {self(), make_ref()}, 2 => {self(), make_ref()}},
|
||||
Result = guild_manager_shard_reload:select_guilds_to_reload([], Guilds),
|
||||
?assertEqual(2, length(Result)).
|
||||
|
||||
select_guilds_to_reload_specific_ids_test() ->
|
||||
Pid = self(),
|
||||
Ref = make_ref(),
|
||||
Guilds = #{1 => {Pid, Ref}, 2 => {Pid, Ref}, 3 => loading},
|
||||
Result = guild_manager_shard_reload:select_guilds_to_reload([1, 3], Guilds),
|
||||
?assertEqual(1, length(Result)).
|
||||
@@ -1,218 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(guild_member_list_common_tests).
|
||||
-typing([eqwalizer]).
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
get_member_user_id_extracts_id_test() ->
|
||||
Member = #{<<"user">> => #{<<"id">> => <<"42">>}},
|
||||
?assertEqual(42, guild_member_list_common:get_member_user_id(Member)).
|
||||
|
||||
get_member_user_id_keeps_integer_id_test() ->
|
||||
Member = #{<<"user">> => #{<<"id">> => 42}},
|
||||
?assertEqual(42, guild_member_list_common:get_member_user_id(Member)).
|
||||
|
||||
get_member_user_id_returns_undefined_for_missing_user_test() ->
|
||||
?assertEqual(undefined, guild_member_list_common:get_member_user_id(#{})).
|
||||
|
||||
get_member_user_id_no_id_in_user_test() ->
|
||||
Member = #{<<"user">> => #{<<"username">> => <<"noone">>}},
|
||||
?assertEqual(undefined, guild_member_list_common:get_member_user_id(Member)).
|
||||
|
||||
get_member_user_id_zero_is_invalid_test() ->
|
||||
Member = #{<<"user">> => #{<<"id">> => <<"0">>}},
|
||||
?assertEqual(undefined, guild_member_list_common:get_member_user_id(Member)).
|
||||
|
||||
get_member_display_name_prefers_nick_test() ->
|
||||
Member = #{
|
||||
<<"nick">> => <<"Cool Nick">>,
|
||||
<<"user">> => #{<<"global_name">> => <<"Global">>, <<"username">> => <<"user">>}
|
||||
},
|
||||
?assertEqual(<<"Cool Nick">>, guild_member_list_common:get_member_display_name(Member)).
|
||||
|
||||
get_member_display_name_falls_back_to_global_name_test() ->
|
||||
Member = #{
|
||||
<<"user">> => #{<<"global_name">> => <<"Global">>, <<"username">> => <<"user">>}
|
||||
},
|
||||
?assertEqual(<<"Global">>, guild_member_list_common:get_member_display_name(Member)).
|
||||
|
||||
get_member_display_name_falls_back_to_username_test() ->
|
||||
Member = #{<<"user">> => #{<<"username">> => <<"user">>}},
|
||||
?assertEqual(<<"user">>, guild_member_list_common:get_member_display_name(Member)).
|
||||
|
||||
get_member_display_name_null_nick_test() ->
|
||||
Member = #{<<"nick">> => null, <<"user">> => #{<<"username">> => <<"bob">>}},
|
||||
?assertEqual(<<"bob">>, guild_member_list_common:get_member_display_name(Member)).
|
||||
|
||||
get_member_display_name_undefined_nick_test() ->
|
||||
Member = #{<<"nick">> => undefined, <<"user">> => #{<<"username">> => <<"charlie">>}},
|
||||
?assertEqual(<<"charlie">>, guild_member_list_common:get_member_display_name(Member)).
|
||||
|
||||
get_member_display_name_empty_nick_test() ->
|
||||
Member = #{<<"nick">> => <<>>, <<"user">> => #{<<"username">> => <<"dave">>}},
|
||||
?assertEqual(<<"dave">>, guild_member_list_common:get_member_display_name(Member)).
|
||||
|
||||
get_member_display_name_no_user_field_test() ->
|
||||
?assertEqual(<<>>, guild_member_list_common:get_member_display_name(#{})).
|
||||
|
||||
sort_key_same_display_name_deterministic_by_user_id_test() ->
|
||||
MemberA = #{<<"nick">> => <<"Alice">>, <<"user">> => #{<<"id">> => <<"100">>}},
|
||||
MemberB = #{<<"nick">> => <<"Alice">>, <<"user">> => #{<<"id">> => <<"200">>}},
|
||||
?assert(
|
||||
guild_member_list_common:get_member_sort_key(MemberA) <
|
||||
guild_member_list_common:get_member_sort_key(MemberB)
|
||||
).
|
||||
|
||||
sort_key_same_name_lower_id_first_test() ->
|
||||
MemberA = #{<<"nick">> => <<"zebra">>, <<"user">> => #{<<"id">> => <<"1">>}},
|
||||
MemberB = #{<<"nick">> => <<"zebra">>, <<"user">> => #{<<"id">> => <<"999">>}},
|
||||
?assert(
|
||||
guild_member_list_common:get_member_sort_key(MemberA) <
|
||||
guild_member_list_common:get_member_sort_key(MemberB)
|
||||
).
|
||||
|
||||
sort_key_mixed_case_names_test() ->
|
||||
MemberLower = #{<<"nick">> => <<"alice">>, <<"user">> => #{<<"id">> => <<"1">>}},
|
||||
MemberUpper = #{<<"nick">> => <<"Alice">>, <<"user">> => #{<<"id">> => <<"2">>}},
|
||||
{FoldedLower, _} = guild_member_list_common:get_member_sort_key(MemberLower),
|
||||
{FoldedUpper, _} = guild_member_list_common:get_member_sort_key(MemberUpper),
|
||||
?assertEqual(FoldedLower, FoldedUpper).
|
||||
|
||||
sort_key_unicode_names_test() ->
|
||||
MemberUnicode = #{<<"nick">> => <<"Ωmega"/utf8>>, <<"user">> => #{<<"id">> => <<"1">>}},
|
||||
MemberAscii = #{<<"nick">> => <<"alpha">>, <<"user">> => #{<<"id">> => <<"2">>}},
|
||||
?assert(is_tuple(guild_member_list_common:get_member_sort_key(MemberUnicode))),
|
||||
?assert(is_tuple(guild_member_list_common:get_member_sort_key(MemberAscii))).
|
||||
|
||||
sort_key_empty_display_name_test() ->
|
||||
MemberEmpty = #{<<"user">> => #{<<"id">> => <<"1">>}},
|
||||
{Folded, Id} = guild_member_list_common:get_member_sort_key(MemberEmpty),
|
||||
?assertEqual(<<>>, Folded),
|
||||
?assertEqual(1, Id).
|
||||
|
||||
sort_key_empty_name_sorts_before_nonempty_test() ->
|
||||
MemberEmpty = #{<<"user">> => #{<<"id">> => <<"1">>}},
|
||||
MemberNamed = #{<<"nick">> => <<"alice">>, <<"user">> => #{<<"id">> => <<"2">>}},
|
||||
?assert(
|
||||
guild_member_list_common:get_member_sort_key(MemberEmpty) <
|
||||
guild_member_list_common:get_member_sort_key(MemberNamed)
|
||||
).
|
||||
|
||||
casefold_binary_mixed_case_test() ->
|
||||
?assertEqual(<<"hello">>, guild_member_list_common:casefold_binary(<<"HeLLo">>)).
|
||||
|
||||
casefold_binary_already_lower_test() ->
|
||||
?assertEqual(<<"world">>, guild_member_list_common:casefold_binary(<<"world">>)).
|
||||
|
||||
casefold_binary_empty_test() ->
|
||||
?assertEqual(<<>>, guild_member_list_common:casefold_binary(<<>>)).
|
||||
|
||||
casefold_binary_integer_test() ->
|
||||
?assertEqual(<<"42">>, guild_member_list_common:casefold_binary(42)).
|
||||
|
||||
casefold_binary_undefined_test() ->
|
||||
?assertEqual(<<>>, guild_member_list_common:casefold_binary(undefined)).
|
||||
|
||||
normalize_name_binary_test() ->
|
||||
?assertEqual(<<"hello">>, guild_member_list_common:normalize_name(<<"hello">>)).
|
||||
|
||||
normalize_name_integer_test() ->
|
||||
?assertEqual(<<"42">>, guild_member_list_common:normalize_name(42)).
|
||||
|
||||
normalize_name_null_test() ->
|
||||
?assertEqual(<<>>, guild_member_list_common:normalize_name(null)).
|
||||
|
||||
normalize_name_undefined_test() ->
|
||||
?assertEqual(<<>>, guild_member_list_common:normalize_name(undefined)).
|
||||
|
||||
normalize_name_list_test() ->
|
||||
?assertEqual(<<"hello">>, guild_member_list_common:normalize_name("hello")).
|
||||
|
||||
normalize_name_other_test() ->
|
||||
?assertEqual(<<>>, guild_member_list_common:normalize_name(#{})).
|
||||
|
||||
deep_merge_member_merges_user_test() ->
|
||||
Current = #{
|
||||
<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"alice">>},
|
||||
<<"nick">> => <<"a">>
|
||||
},
|
||||
Update = #{
|
||||
<<"user">> => #{<<"id">> => <<"1">>, <<"avatar">> => <<"new">>},
|
||||
<<"nick">> => <<"b">>
|
||||
},
|
||||
Result = guild_member_list_common:deep_merge_member(Current, Update),
|
||||
User = maps:get(<<"user">>, Result),
|
||||
?assertEqual(1, maps:get(<<"id">>, User)),
|
||||
?assertEqual(<<"alice">>, maps:get(<<"username">>, User)),
|
||||
?assertEqual(<<"new">>, maps:get(<<"avatar">>, User)),
|
||||
?assertEqual(<<"b">>, maps:get(<<"nick">>, Result)).
|
||||
|
||||
deep_merge_member_update_without_user_field_test() ->
|
||||
Current = #{
|
||||
<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"alice">>},
|
||||
<<"nick">> => <<"a">>
|
||||
},
|
||||
Update = #{<<"nick">> => <<"b">>},
|
||||
Result = guild_member_list_common:deep_merge_member(Current, Update),
|
||||
User = maps:get(<<"user">>, Result),
|
||||
?assertEqual(<<"alice">>, maps:get(<<"username">>, User)),
|
||||
?assertEqual(<<"b">>, maps:get(<<"nick">>, Result)).
|
||||
|
||||
deep_merge_member_null_user_in_update_test() ->
|
||||
Current = #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"alice">>}},
|
||||
Update = #{<<"user">> => null, <<"nick">> => <<"new">>},
|
||||
Result = guild_member_list_common:deep_merge_member(Current, Update),
|
||||
?assertEqual(null, maps:get(<<"user">>, Result)),
|
||||
?assertEqual(<<"new">>, maps:get(<<"nick">>, Result)).
|
||||
|
||||
deep_merge_member_new_roles_test() ->
|
||||
Current = #{<<"user">> => #{<<"id">> => <<"1">>}, <<"roles">> => [<<"100">>]},
|
||||
Update = #{<<"roles">> => [<<"200">>, <<"300">>]},
|
||||
Result = guild_member_list_common:deep_merge_member(Current, Update),
|
||||
assert_roles([200, 300], Result).
|
||||
|
||||
deep_merge_member_removing_all_roles_test() ->
|
||||
Current = #{<<"user">> => #{<<"id">> => <<"1">>}, <<"roles">> => [<<"100">>, <<"200">>]},
|
||||
Update = #{<<"roles">> => []},
|
||||
Result = guild_member_list_common:deep_merge_member(Current, Update),
|
||||
?assertEqual([], maps:get(<<"roles">>, Result)).
|
||||
|
||||
deep_merge_member_non_map_user_in_update_test() ->
|
||||
Current = #{<<"user">> => #{<<"id">> => <<"1">>}},
|
||||
Update = #{<<"user">> => <<"invalid">>},
|
||||
Result = guild_member_list_common:deep_merge_member(Current, Update),
|
||||
?assertEqual(<<"invalid">>, maps:get(<<"user">>, Result)).
|
||||
|
||||
upsert_new_member_into_empty_state_test() ->
|
||||
Data = guild_data_index:normalize_data(#{
|
||||
<<"members">> => [],
|
||||
<<"roles">> => [],
|
||||
<<"channels">> => []
|
||||
}),
|
||||
State = #{data => Data},
|
||||
MemberUpdate = #{<<"user">> => #{<<"id">> => <<"42">>}, <<"nick">> => <<"new">>},
|
||||
{CurrentMember, UpdatedMember, NewState} =
|
||||
guild_member_list_common:upsert_member_in_state(42, MemberUpdate, State),
|
||||
?assertEqual(undefined, CurrentMember),
|
||||
?assertEqual(<<"new">>, maps:get(<<"nick">>, UpdatedMember)),
|
||||
NewData = maps:get(data, NewState),
|
||||
NewMembers = guild_data_index:member_map(NewData),
|
||||
?assertEqual(true, maps:is_key(42, NewMembers)).
|
||||
|
||||
upsert_existing_member_with_changed_roles_test() ->
|
||||
ExistingMember = #{<<"user">> => #{<<"id">> => <<"42">>}, <<"roles">> => [<<"100">>]},
|
||||
Data = guild_data_index:normalize_data(#{
|
||||
<<"members">> => [ExistingMember],
|
||||
<<"roles">> => [],
|
||||
<<"channels">> => []
|
||||
}),
|
||||
State = #{data => Data},
|
||||
MemberUpdate = #{<<"roles">> => [<<"200">>, <<"300">>]},
|
||||
{CurrentMember, UpdatedMember, _NewState} =
|
||||
guild_member_list_common:upsert_member_in_state(42, MemberUpdate, State),
|
||||
#{<<"roles">> := CurrentRoles} = CurrentMember,
|
||||
?assertEqual([100], CurrentRoles),
|
||||
assert_roles([200, 300], UpdatedMember).
|
||||
|
||||
assert_roles(ExpectedRoles, Member) ->
|
||||
?assertEqual(ExpectedRoles, maps:get(<<"roles">>, Member)).
|
||||
@@ -1,38 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(guild_request_members_chunk_tests).
|
||||
-typing([eqwalizer]).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
build_chunk_data_basic_test() ->
|
||||
Members = [#{<<"user">> => #{<<"id">> => <<"1">>}}],
|
||||
Result = guild_request_members_chunk:build_chunk_data(Members, [], 0, 1, null),
|
||||
?assertEqual(Members, maps:get(<<"members">>, Result)),
|
||||
?assertEqual(0, maps:get(<<"chunk_index">>, Result)),
|
||||
?assertEqual(1, maps:get(<<"chunk_count">>, Result)),
|
||||
?assertNot(maps:is_key(<<"presences">>, Result)),
|
||||
?assertNot(maps:is_key(<<"nonce">>, Result)).
|
||||
|
||||
build_chunk_data_with_presences_test() ->
|
||||
Members = [#{<<"user">> => #{<<"id">> => <<"1">>}}],
|
||||
Presences = [#{<<"user">> => #{<<"id">> => <<"1">>}, <<"status">> => <<"online">>}],
|
||||
Result = guild_request_members_chunk:build_chunk_data(Members, Presences, 0, 1, null),
|
||||
?assertEqual(Presences, maps:get(<<"presences">>, Result)),
|
||||
?assertNot(maps:is_key(<<"nonce">>, Result)).
|
||||
|
||||
build_chunk_data_with_nonce_test() ->
|
||||
Members = [],
|
||||
Result = guild_request_members_chunk:build_chunk_data(Members, [], 0, 1, <<"my_nonce">>),
|
||||
?assertEqual(<<"my_nonce">>, maps:get(<<"nonce">>, Result)).
|
||||
|
||||
build_chunk_data_with_presences_and_nonce_test() ->
|
||||
Members = [#{<<"user">> => #{<<"id">> => <<"1">>}}],
|
||||
Presences = [#{<<"user">> => #{<<"id">> => <<"1">>}, <<"status">> => <<"online">>}],
|
||||
Result = guild_request_members_chunk:build_chunk_data(
|
||||
Members, Presences, 2, 5, <<"nonce1">>
|
||||
),
|
||||
?assertEqual(Presences, maps:get(<<"presences">>, Result)),
|
||||
?assertEqual(<<"nonce1">>, maps:get(<<"nonce">>, Result)),
|
||||
?assertEqual(2, maps:get(<<"chunk_index">>, Result)),
|
||||
?assertEqual(5, maps:get(<<"chunk_count">>, Result)).
|
||||
@@ -1,51 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(guild_request_members_presence_tests).
|
||||
-typing([eqwalizer]).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
presence_visible_online_test() ->
|
||||
?assertEqual(
|
||||
true, guild_request_members_presence:presence_visible(#{<<"status">> => <<"online">>})
|
||||
).
|
||||
|
||||
presence_visible_idle_test() ->
|
||||
?assertEqual(
|
||||
true, guild_request_members_presence:presence_visible(#{<<"status">> => <<"idle">>})
|
||||
).
|
||||
|
||||
presence_visible_dnd_test() ->
|
||||
?assertEqual(
|
||||
true, guild_request_members_presence:presence_visible(#{<<"status">> => <<"dnd">>})
|
||||
).
|
||||
|
||||
presence_visible_offline_test() ->
|
||||
?assertEqual(
|
||||
false, guild_request_members_presence:presence_visible(#{<<"status">> => <<"offline">>})
|
||||
).
|
||||
|
||||
presence_visible_invisible_test() ->
|
||||
?assertEqual(
|
||||
false,
|
||||
guild_request_members_presence:presence_visible(#{<<"status">> => <<"invisible">>})
|
||||
).
|
||||
|
||||
presence_visible_missing_status_test() ->
|
||||
?assertEqual(false, guild_request_members_presence:presence_visible(#{})).
|
||||
|
||||
presence_user_id_valid_test() ->
|
||||
?assertEqual(
|
||||
42,
|
||||
guild_request_members_presence:presence_user_id(
|
||||
#{<<"user">> => #{<<"id">> => <<"42">>}}
|
||||
)
|
||||
).
|
||||
|
||||
presence_user_id_rejects_malformed_snowflake_test() ->
|
||||
?assertEqual(
|
||||
undefined,
|
||||
guild_request_members_presence:presence_user_id(
|
||||
#{<<"user">> => #{<<"id">> => <<"042">>}}
|
||||
)
|
||||
).
|
||||
@@ -1,194 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(guild_request_members_tests).
|
||||
-typing([eqwalizer]).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
parse_request_valid_test() ->
|
||||
Data = #{
|
||||
<<"guild_id">> => <<"123456789">>,
|
||||
<<"query">> => <<"test">>,
|
||||
<<"limit">> => 10,
|
||||
<<"presences">> => true,
|
||||
<<"nonce">> => <<"abc123">>
|
||||
},
|
||||
{ok, Request} = guild_request_members:parse_request(Data),
|
||||
?assertEqual([123456789], maps:get(guild_ids, Request)),
|
||||
?assertEqual(<<"test">>, maps:get(query, Request)),
|
||||
?assertEqual(10, maps:get(limit, Request)),
|
||||
?assertEqual(true, maps:get(presences, Request)),
|
||||
?assertEqual(<<"abc123">>, maps:get(nonce, Request)).
|
||||
|
||||
parse_request_with_user_ids_test() ->
|
||||
Data = #{
|
||||
<<"guild_id">> => <<"123">>,
|
||||
<<"user_ids">> => [<<"1">>, <<"2">>, <<"3">>]
|
||||
},
|
||||
{ok, Request} = guild_request_members:parse_request(Data),
|
||||
?assertEqual([123], maps:get(guild_ids, Request)),
|
||||
?assertEqual([1, 2, 3], maps:get(user_ids, Request)).
|
||||
|
||||
parse_request_invalid_guild_id_test() ->
|
||||
Data = #{<<"guild_id">> => <<"invalid">>},
|
||||
{error, invalid_guild_id} = guild_request_members:parse_request(Data).
|
||||
|
||||
parse_request_with_guild_ids_array_test() ->
|
||||
Data = #{
|
||||
<<"guild_ids">> => [<<"3">>, <<"1">>, <<"3">>, <<"2">>],
|
||||
<<"query">> => <<"test">>
|
||||
},
|
||||
{ok, Request} = guild_request_members:parse_request(Data),
|
||||
?assertEqual([3, 1, 2], maps:get(guild_ids, Request)),
|
||||
?assertEqual(<<"test">>, maps:get(query, Request)).
|
||||
|
||||
parse_request_with_guild_ids_invalid_entry_test() ->
|
||||
Data = #{
|
||||
<<"guild_ids">> => [<<"123">>, <<"not_a_guild_id">>]
|
||||
},
|
||||
?assertEqual({error, invalid_guild_id}, guild_request_members:parse_request(Data)).
|
||||
|
||||
parse_request_with_multiple_guild_ids_drops_nonce_test() ->
|
||||
Data = #{
|
||||
<<"guild_ids">> => [<<"123">>, <<"456">>],
|
||||
<<"nonce">> => <<"abc123">>
|
||||
},
|
||||
{ok, Request} = guild_request_members:parse_request(Data),
|
||||
?assertEqual([123, 456], maps:get(guild_ids, Request)),
|
||||
?assertEqual(null, maps:get(nonce, Request)).
|
||||
|
||||
normalize_nonce_test() ->
|
||||
?assertEqual(<<"abc">>, guild_request_members:normalize_nonce(<<"abc">>)),
|
||||
?assertEqual(
|
||||
null,
|
||||
guild_request_members:normalize_nonce(<<"this_nonce_is_way_too_long_to_be_valid">>)
|
||||
),
|
||||
?assertEqual(null, guild_request_members:normalize_nonce(undefined)).
|
||||
|
||||
validate_user_ids_too_many_test() ->
|
||||
UserIds = lists:seq(1, 101),
|
||||
?assertEqual({error, too_many_user_ids}, guild_request_members:validate_user_ids(UserIds)).
|
||||
|
||||
validate_user_ids_exactly_max_test() ->
|
||||
UserIds = lists:seq(1, 100),
|
||||
{ok, Parsed} = guild_request_members:validate_user_ids(UserIds),
|
||||
?assertEqual(100, length(Parsed)).
|
||||
|
||||
validate_user_ids_non_list_test() ->
|
||||
{ok, []} = guild_request_members:validate_user_ids(not_a_list).
|
||||
|
||||
validate_user_ids_filters_invalid_test() ->
|
||||
{ok, Parsed} = guild_request_members:validate_user_ids([<<"1">>, <<"invalid">>, 3, -5, 0]),
|
||||
?assertEqual([1, 3], Parsed).
|
||||
|
||||
validate_user_ids_empty_test() ->
|
||||
{ok, []} = guild_request_members:validate_user_ids([]).
|
||||
|
||||
parse_user_id_integer_test() ->
|
||||
?assertEqual({ok, 42}, guild_request_members:parse_user_id(42)).
|
||||
|
||||
parse_user_id_binary_test() ->
|
||||
?assertEqual({ok, 123}, guild_request_members:parse_user_id(<<"123">>)).
|
||||
|
||||
parse_user_id_zero_test() ->
|
||||
?assertEqual(error, guild_request_members:parse_user_id(0)).
|
||||
|
||||
parse_user_id_negative_test() ->
|
||||
?assertEqual(error, guild_request_members:parse_user_id(-1)).
|
||||
|
||||
parse_user_id_invalid_binary_test() ->
|
||||
?assertEqual(error, guild_request_members:parse_user_id(<<"abc">>)).
|
||||
|
||||
parse_user_id_other_type_test() ->
|
||||
?assertEqual(error, guild_request_members:parse_user_id(1.5)).
|
||||
|
||||
ensure_binary_binary_test() ->
|
||||
?assertEqual(<<"hello">>, guild_request_members:ensure_binary(<<"hello">>)).
|
||||
|
||||
ensure_binary_integer_test() ->
|
||||
?assertEqual(<<>>, guild_request_members:ensure_binary(42)).
|
||||
|
||||
ensure_binary_undefined_test() ->
|
||||
?assertEqual(<<>>, guild_request_members:ensure_binary(undefined)).
|
||||
|
||||
ensure_limit_valid_test() ->
|
||||
?assertEqual(10, guild_request_members:ensure_limit(10)).
|
||||
|
||||
ensure_limit_zero_test() ->
|
||||
?assertEqual(0, guild_request_members:ensure_limit(0)).
|
||||
|
||||
ensure_limit_negative_test() ->
|
||||
?assertEqual(0, guild_request_members:ensure_limit(-1)).
|
||||
|
||||
ensure_limit_non_integer_test() ->
|
||||
?assertEqual(0, guild_request_members:ensure_limit(<<"10">>)).
|
||||
|
||||
ensure_limit_clamped_test() ->
|
||||
?assertEqual(100, guild_request_members:ensure_limit(101)).
|
||||
|
||||
validate_guild_id_integer_test() ->
|
||||
?assertEqual({ok, 123}, guild_request_members:validate_guild_id(123)).
|
||||
|
||||
validate_guild_id_zero_test() ->
|
||||
?assertEqual({error, invalid_guild_id}, guild_request_members:validate_guild_id(0)).
|
||||
|
||||
validate_guild_id_negative_test() ->
|
||||
?assertEqual({error, invalid_guild_id}, guild_request_members:validate_guild_id(-1)).
|
||||
|
||||
validate_guild_id_atom_test() ->
|
||||
?assertEqual({error, invalid_guild_id}, guild_request_members:validate_guild_id(undefined)).
|
||||
|
||||
normalize_nonce_exactly_max_length_test() ->
|
||||
Nonce = list_to_binary(lists:duplicate(32, $a)),
|
||||
?assertEqual(Nonce, guild_request_members:normalize_nonce(Nonce)).
|
||||
|
||||
normalize_nonce_one_over_max_test() ->
|
||||
Nonce = list_to_binary(lists:duplicate(33, $a)),
|
||||
?assertEqual(null, guild_request_members:normalize_nonce(Nonce)).
|
||||
|
||||
normalize_nonce_empty_binary_test() ->
|
||||
?assertEqual(<<>>, guild_request_members:normalize_nonce(<<>>)).
|
||||
|
||||
normalize_nonce_integer_test() ->
|
||||
?assertEqual(null, guild_request_members:normalize_nonce(42)).
|
||||
|
||||
normalize_nonce_null_atom_test() ->
|
||||
?assertEqual(null, guild_request_members:normalize_nonce(null)).
|
||||
|
||||
parse_request_defaults_test() ->
|
||||
Data = #{<<"guild_id">> => 12345},
|
||||
{ok, Request} = guild_request_members:parse_request(Data),
|
||||
?assertEqual([12345], maps:get(guild_ids, Request)),
|
||||
?assertEqual(<<>>, maps:get(query, Request)),
|
||||
?assertEqual(0, maps:get(limit, Request)),
|
||||
?assertEqual([], maps:get(user_ids, Request)),
|
||||
?assertEqual(false, maps:get(presences, Request)),
|
||||
?assertEqual(null, maps:get(nonce, Request)).
|
||||
|
||||
parse_request_non_binary_query_test() ->
|
||||
Data = #{<<"guild_id">> => 123, <<"query">> => 42},
|
||||
{ok, Request} = guild_request_members:parse_request(Data),
|
||||
?assertEqual(<<>>, maps:get(query, Request)).
|
||||
|
||||
parse_request_negative_limit_test() ->
|
||||
Data = #{<<"guild_id">> => 123, <<"limit">> => -5},
|
||||
{ok, Request} = guild_request_members:parse_request(Data),
|
||||
?assertEqual(0, maps:get(limit, Request)).
|
||||
|
||||
parse_request_presences_not_true_test() ->
|
||||
Data = #{<<"guild_id">> => 123, <<"presences">> => <<"yes">>},
|
||||
{ok, Request} = guild_request_members:parse_request(Data),
|
||||
?assertEqual(false, maps:get(presences, Request)).
|
||||
|
||||
parse_request_missing_guild_id_test() ->
|
||||
Data = #{<<"query">> => <<"test">>},
|
||||
?assertEqual({error, invalid_guild_id}, guild_request_members:parse_request(Data)).
|
||||
|
||||
handle_request_invalid_data_test() ->
|
||||
?assertEqual(
|
||||
{error, invalid_request},
|
||||
guild_request_members:handle_request(invalid_request(), self(), #{})
|
||||
).
|
||||
|
||||
invalid_request() ->
|
||||
eqwalizer:dynamic_cast(not_a_map).
|
||||
@@ -1,89 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(map_utils_filter_tests).
|
||||
-typing([eqwalizer]).
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
filter_by_field_basic_test() ->
|
||||
List = [
|
||||
#{id => 1, type => a, name => <<"first">>},
|
||||
#{id => 2, type => b, name => <<"second">>},
|
||||
#{id => 3, type => a, name => <<"third">>},
|
||||
#{id => 4, type => c},
|
||||
#{id => 5, type => a}
|
||||
],
|
||||
|
||||
Filtered = map_utils:filter_by_field(List, type, a),
|
||||
?assertEqual(3, length(Filtered)),
|
||||
assert_all_type(a, Filtered),
|
||||
|
||||
?assertEqual(
|
||||
[#{id => 2, type => b, name => <<"second">>}],
|
||||
map_utils:filter_by_field(List, id, 2)
|
||||
),
|
||||
|
||||
?assertEqual([], map_utils:filter_by_field(List, type, nonexistent)),
|
||||
|
||||
?assertEqual([], map_utils:filter_by_field(List, missing_field, value)).
|
||||
|
||||
filter_by_field_mixed_lists_test() ->
|
||||
MixedList = [
|
||||
#{id => 1, type => a},
|
||||
not_a_map,
|
||||
#{id => 2, type => b},
|
||||
123,
|
||||
#{id => 3, type => a},
|
||||
<<"binary">>,
|
||||
undefined,
|
||||
#{id => 4, type => a},
|
||||
[],
|
||||
{tuple, value},
|
||||
#{id => 5, type => c}
|
||||
],
|
||||
|
||||
Result = map_utils:filter_by_field(MixedList, type, a),
|
||||
?assertEqual(3, length(Result)),
|
||||
?assert(lists:all(fun is_map/1, Result)),
|
||||
assert_all_type(a, Result),
|
||||
|
||||
Ids = [maps:get(id, M) || M <- Result],
|
||||
?assertEqual([1, 3, 4], Ids),
|
||||
|
||||
ResultB = map_utils:filter_by_field(MixedList, type, b),
|
||||
?assertEqual(1, length(ResultB)),
|
||||
?assertEqual([#{id => 2, type => b}], ResultB).
|
||||
|
||||
filter_by_field_edge_cases_test() ->
|
||||
?assertEqual([], map_utils:filter_by_field([], field, value)),
|
||||
|
||||
NonMaps = [123, atom, <<"binary">>, {tuple}, []],
|
||||
?assertEqual([], map_utils:filter_by_field(NonMaps, field, value)),
|
||||
|
||||
NoFieldList = [#{a => 1}, #{b => 2}, #{c => 3}],
|
||||
?assertEqual([], map_utils:filter_by_field(NoFieldList, missing, value)),
|
||||
|
||||
?assertEqual([], map_utils:filter_by_field(not_a_list, field, value)),
|
||||
?assertEqual([], map_utils:filter_by_field(#{}, field, value)),
|
||||
?assertEqual([], map_utils:filter_by_field(123, field, value)),
|
||||
|
||||
BinaryList = [
|
||||
#{<<"key">> => <<"value1">>},
|
||||
#{<<"key">> => <<"value2">>},
|
||||
#{<<"other">> => <<"value1">>}
|
||||
],
|
||||
?assertEqual(
|
||||
[#{<<"key">> => <<"value1">>}],
|
||||
map_utils:filter_by_field(BinaryList, <<"key">>, <<"value1">>)
|
||||
),
|
||||
|
||||
ComplexList = [
|
||||
#{data => #{nested => value}},
|
||||
#{data => [1, 2, 3]},
|
||||
#{data => #{nested => value}},
|
||||
#{other => data}
|
||||
],
|
||||
ComplexFiltered = map_utils:filter_by_field(ComplexList, data, #{nested => value}),
|
||||
?assertEqual(2, length(ComplexFiltered)).
|
||||
|
||||
assert_all_type(ExpectedType, Result) ->
|
||||
?assert(lists:all(fun(M) -> maps:get(type, M) =:= ExpectedType end, Result)).
|
||||
@@ -1,116 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(map_utils_find_tests).
|
||||
-typing([eqwalizer]).
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
find_by_field_basic_test() ->
|
||||
List = [
|
||||
#{id => 1, type => a},
|
||||
#{id => 2, type => b},
|
||||
#{id => 3, type => a},
|
||||
#{id => 4, type => c}
|
||||
],
|
||||
|
||||
?assertEqual({ok, #{id => 2, type => b}}, map_utils:find_by_field(List, id, 2)),
|
||||
?assertEqual({ok, #{id => 4, type => c}}, map_utils:find_by_field(List, id, 4)),
|
||||
|
||||
?assertEqual(error, map_utils:find_by_field(List, id, 999)),
|
||||
?assertEqual(error, map_utils:find_by_field(List, type, nonexistent)),
|
||||
|
||||
?assertEqual(error, map_utils:find_by_field([], id, 1)).
|
||||
|
||||
find_by_field_multiple_matches_test() ->
|
||||
List = [
|
||||
#{id => 1, type => a, order => first},
|
||||
#{id => 2, type => b, order => second},
|
||||
#{id => 3, type => a, order => third},
|
||||
#{id => 4, type => c, order => fourth},
|
||||
#{id => 5, type => a, order => fifth}
|
||||
],
|
||||
|
||||
{ok, First} = map_utils:find_by_field(List, type, a),
|
||||
?assertEqual(1, maps:get(id, First)),
|
||||
?assertEqual(first, maps:get(order, First)),
|
||||
|
||||
?assertNotEqual(third, maps:get(order, First)),
|
||||
?assertNotEqual(fifth, maps:get(order, First)),
|
||||
|
||||
List2 = [
|
||||
#{name => <<"Alice">>, age => 25},
|
||||
#{name => <<"Bob">>, age => 30},
|
||||
#{name => <<"Charlie">>, age => 25},
|
||||
#{name => <<"Diana">>, age => 25}
|
||||
],
|
||||
|
||||
{ok, FirstAge25} = map_utils:find_by_field(List2, age, 25),
|
||||
?assertEqual(<<"Alice">>, maps:get(name, FirstAge25)).
|
||||
|
||||
find_by_field_no_matches_test() ->
|
||||
List = [
|
||||
#{id => 1, type => a},
|
||||
#{id => 2, type => b},
|
||||
#{id => 3, type => c}
|
||||
],
|
||||
|
||||
?assertEqual(error, map_utils:find_by_field(List, id, 999)),
|
||||
?assertEqual(error, map_utils:find_by_field(List, type, z)),
|
||||
?assertEqual(error, map_utils:find_by_field(List, missing_field, value)),
|
||||
?assertEqual(error, map_utils:find_by_field(List, id, <<"wrong_type">>)),
|
||||
|
||||
?assertEqual(error, map_utils:find_by_field([], any_field, any_value)).
|
||||
|
||||
find_by_field_with_non_maps_test() ->
|
||||
MixedList = [
|
||||
not_a_map,
|
||||
123,
|
||||
#{id => 1, type => a},
|
||||
<<"binary">>,
|
||||
undefined,
|
||||
#{id => 2, type => b},
|
||||
[],
|
||||
#{id => 3, type => a}
|
||||
],
|
||||
|
||||
{ok, Found1} = map_utils:find_by_field(MixedList, type, a),
|
||||
?assertEqual(1, maps:get(id, Found1)),
|
||||
|
||||
{ok, Found2} = map_utils:find_by_field(MixedList, id, 2),
|
||||
?assertEqual(b, maps:get(type, Found2)),
|
||||
|
||||
MixedList2 = [atom, 456, {tuple}, #{id => 5, type => z}],
|
||||
?assertEqual({ok, #{id => 5, type => z}}, map_utils:find_by_field(MixedList2, id, 5)),
|
||||
|
||||
OnlyNonMaps = [atom, 123, <<"binary">>, {tuple}, []],
|
||||
?assertEqual(error, map_utils:find_by_field(OnlyNonMaps, field, value)).
|
||||
|
||||
find_by_field_invalid_input_test() ->
|
||||
?assertEqual(error, map_utils:find_by_field(not_a_list, field, value)),
|
||||
?assertEqual(error, map_utils:find_by_field(#{}, field, value)),
|
||||
?assertEqual(error, map_utils:find_by_field(123, field, value)),
|
||||
?assertEqual(error, map_utils:find_by_field(<<"binary">>, field, value)),
|
||||
?assertEqual(error, map_utils:find_by_field(undefined, field, value)),
|
||||
?assertEqual(error, map_utils:find_by_field(atom, field, value)),
|
||||
?assertEqual(error, map_utils:find_by_field({tuple}, field, value)).
|
||||
|
||||
find_by_field_complex_values_test() ->
|
||||
List = [
|
||||
#{<<"id">> => <<"first">>, <<"data">> => <<"value1">>},
|
||||
#{<<"id">> => <<"second">>, <<"data">> => <<"value2">>},
|
||||
#{<<"id">> => <<"third">>, <<"data">> => <<"value1">>}
|
||||
],
|
||||
|
||||
{ok, Found} = map_utils:find_by_field(List, <<"data">>, <<"value1">>),
|
||||
?assertEqual(<<"first">>, maps:get(<<"id">>, Found)),
|
||||
|
||||
ComplexList = [
|
||||
#{key => #{nested => value1}, id => 1},
|
||||
#{key => [1, 2, 3], id => 2},
|
||||
#{key => #{nested => value1}, id => 3}
|
||||
],
|
||||
|
||||
{ok, ComplexFound} = map_utils:find_by_field(ComplexList, key, #{nested => value1}),
|
||||
?assertEqual(1, maps:get(id, ComplexFound)),
|
||||
|
||||
{ok, ListFound} = map_utils:find_by_field(ComplexList, key, [1, 2, 3]),
|
||||
?assertEqual(2, maps:get(id, ListFound)).
|
||||
@@ -1,247 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(map_utils_tests).
|
||||
-typing([eqwalizer]).
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
get_safe_basic_test() ->
|
||||
Map = #{key => value, number => 42},
|
||||
|
||||
?assertEqual(value, map_utils:get_safe(Map, key, default)),
|
||||
?assertEqual(42, map_utils:get_safe(Map, number, 0)),
|
||||
|
||||
?assertEqual(default, map_utils:get_safe(Map, missing, default)),
|
||||
?assertEqual(0, map_utils:get_safe(Map, missing, 0)).
|
||||
|
||||
get_safe_various_input_types_test() ->
|
||||
?assertEqual(default, map_utils:get_safe(not_a_map, key, default)),
|
||||
?assertEqual(default, map_utils:get_safe([], key, default)),
|
||||
?assertEqual(default, map_utils:get_safe(123, key, default)),
|
||||
?assertEqual(default, map_utils:get_safe(<<"binary">>, key, default)),
|
||||
?assertEqual(default, map_utils:get_safe(undefined, key, default)),
|
||||
?assertEqual(default, map_utils:get_safe(atom, key, default)),
|
||||
?assertEqual(default, map_utils:get_safe({tuple, value}, key, default)),
|
||||
?assertEqual(default, map_utils:get_safe(self(), key, default)).
|
||||
|
||||
get_safe_various_key_types_test() ->
|
||||
Map = #{
|
||||
atom_key => atom_value,
|
||||
<<"binary_key">> => binary_value,
|
||||
123 => number_key_value,
|
||||
{tuple, key} => tuple_key_value
|
||||
},
|
||||
|
||||
?assertEqual(atom_value, map_utils:get_safe(Map, atom_key, default)),
|
||||
?assertEqual(binary_value, map_utils:get_safe(Map, <<"binary_key">>, default)),
|
||||
?assertEqual(number_key_value, map_utils:get_safe(Map, 123, default)),
|
||||
?assertEqual(tuple_key_value, map_utils:get_safe(Map, {tuple, key}, default)),
|
||||
|
||||
?assertEqual(default, map_utils:get_safe(Map, missing_atom, default)),
|
||||
?assertEqual(default, map_utils:get_safe(Map, <<"missing_binary">>, default)),
|
||||
?assertEqual(default, map_utils:get_safe(Map, 999, default)).
|
||||
|
||||
get_safe_default_types_test() ->
|
||||
Map = #{key => value},
|
||||
|
||||
?assertEqual(nil, map_utils:get_safe(Map, missing, nil)),
|
||||
?assertEqual(0, map_utils:get_safe(Map, missing, 0)),
|
||||
?assertEqual(<<"default">>, map_utils:get_safe(Map, missing, <<"default">>)),
|
||||
?assertEqual([], map_utils:get_safe(Map, missing, [])),
|
||||
?assertEqual(#{}, map_utils:get_safe(Map, missing, #{})),
|
||||
?assertEqual({tuple, default}, map_utils:get_safe(Map, missing, {tuple, default})).
|
||||
|
||||
get_nested_basic_test() ->
|
||||
Map = #{
|
||||
level1 => #{
|
||||
level2 => #{
|
||||
level3 => deep_value
|
||||
},
|
||||
other => other_value
|
||||
},
|
||||
simple => simple_value
|
||||
},
|
||||
|
||||
?assertEqual(#{level3 => deep_value}, map_utils:get_nested(Map, [level1, level2], default)),
|
||||
?assertEqual(
|
||||
#{other => other_value, level2 => #{level3 => deep_value}},
|
||||
map_utils:get_nested(Map, [level1], default)
|
||||
),
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(Map, [level1, level2, level3], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [level1, other], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [simple], default)),
|
||||
|
||||
?assertEqual(Map, map_utils:get_nested(Map, [], default)),
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(Map, [level1, missing], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [missing, level2], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [level1, level2, missing], default)).
|
||||
|
||||
get_nested_deep_nesting_test() ->
|
||||
DeepMap = #{
|
||||
l1 => #{
|
||||
l2 => #{
|
||||
l3 => #{
|
||||
l4 => #{
|
||||
l5 => final_value,
|
||||
other5 => value5
|
||||
},
|
||||
other4 => value4
|
||||
},
|
||||
other3 => value3
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
Level4Map = map_utils:get_nested(DeepMap, [l1, l2, l3, l4], default),
|
||||
?assert(is_map(Level4Map)),
|
||||
assert_map_field(Level4Map, l5, final_value),
|
||||
assert_map_field(Level4Map, other5, value5),
|
||||
|
||||
Level3Map = map_utils:get_nested(DeepMap, [l1, l2, l3], default),
|
||||
?assert(is_map(Level3Map)),
|
||||
assert_map_field(Level3Map, other4, value4),
|
||||
|
||||
Level2Map = map_utils:get_nested(DeepMap, [l1, l2], default),
|
||||
?assert(is_map(Level2Map)),
|
||||
assert_map_field(Level2Map, other3, value3),
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(DeepMap, [l1, l2, l3, l4, l5], default)),
|
||||
?assertEqual(default, map_utils:get_nested(DeepMap, [l1, l2, l3, l4, other5], default)),
|
||||
?assertEqual(default, map_utils:get_nested(DeepMap, [l1, l2, l3, other4], default)),
|
||||
?assertEqual(default, map_utils:get_nested(DeepMap, [l1, l2, other3], default)),
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(DeepMap, [l1, l2, l3, l4, l5, extra], default)),
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(DeepMap, [l1, l2, missing, l4, l5], default)),
|
||||
?assertEqual(default, map_utils:get_nested(DeepMap, [missing, l2, l3, l4, l5], default)).
|
||||
|
||||
get_nested_partial_paths_test() ->
|
||||
Map = #{
|
||||
user => #{
|
||||
name => <<"Alice">>,
|
||||
age => 30,
|
||||
address => #{
|
||||
city => <<"New York">>,
|
||||
zip => 10001
|
||||
}
|
||||
},
|
||||
count => 42,
|
||||
tags => [tag1, tag2, tag3]
|
||||
},
|
||||
|
||||
UserMap = map_utils:get_nested(Map, [user], default),
|
||||
?assert(is_map(UserMap)),
|
||||
assert_map_field(UserMap, name, <<"Alice">>),
|
||||
|
||||
AddressMap = map_utils:get_nested(Map, [user, address], default),
|
||||
?assert(is_map(AddressMap)),
|
||||
assert_map_field(AddressMap, city, <<"New York">>),
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(Map, [count], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [user, name], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [user, age], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [tags], default)),
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(Map, [count, extra], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [count, deep, path], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [user, name, extra], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [tags, extra], default)),
|
||||
?assertEqual(default, map_utils:get_nested(Map, [user, age, extra, path], default)).
|
||||
|
||||
assert_map_field(Map, Key, Expected) when is_map(Map) ->
|
||||
?assertEqual(Expected, maps:get(Key, Map)).
|
||||
|
||||
get_nested_edge_cases_test() ->
|
||||
Map = #{key => #{nested => value}},
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(not_a_map, [], default)),
|
||||
?assertEqual(default, map_utils:get_nested([], [], default)),
|
||||
?assertEqual(default, map_utils:get_nested(123, [], default)),
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(not_a_map, [key], default)),
|
||||
?assertEqual(default, map_utils:get_nested([], [key], default)),
|
||||
?assertEqual(default, map_utils:get_nested(123, [key, nested], default)),
|
||||
?assertEqual(default, map_utils:get_safe(undefined, key, default)),
|
||||
|
||||
?assertEqual(#{nested => value}, map_utils:get_nested(Map, [key], default)),
|
||||
|
||||
?assertEqual(default, map_utils:get_nested(Map, [key, nested], default)),
|
||||
|
||||
BinaryMap = #{<<"key">> => #{<<"nested">> => <<"value">>}},
|
||||
?assertEqual(
|
||||
#{<<"nested">> => <<"value">>},
|
||||
map_utils:get_nested(BinaryMap, [<<"key">>], default)
|
||||
),
|
||||
?assertEqual(default, map_utils:get_nested(BinaryMap, [<<"key">>, <<"nested">>], default)).
|
||||
|
||||
get_integer_basic_test() ->
|
||||
Map = #{user_id => <<"42">>, <<"count">> => 10},
|
||||
?assertEqual(42, map_utils:get_integer(Map, user_id, undefined)),
|
||||
?assertEqual(10, map_utils:get_integer(Map, <<"count">>, 0)),
|
||||
?assertEqual(99, map_utils:get_integer(Map, missing, 99)).
|
||||
|
||||
get_integer_invalid_input_test() ->
|
||||
?assertEqual(7, map_utils:get_integer(undefined, count, 7)),
|
||||
?assertEqual(undefined, map_utils:get_integer(#{}, user_id, undefined)),
|
||||
?assertEqual(undefined, map_utils:get_integer(#{user_id => <<"abc">>}, user_id, undefined)).
|
||||
|
||||
get_binary_basic_test() ->
|
||||
Map = #{<<"name">> => <<"fluxer">>, tag => atom},
|
||||
?assertEqual(<<"fluxer">>, map_utils:get_binary(Map, <<"name">>, <<"default">>)),
|
||||
?assertEqual(<<"atom">>, map_utils:get_binary(Map, tag, <<"default">>)).
|
||||
|
||||
get_binary_invalid_input_test() ->
|
||||
?assertEqual(<<"default">>, map_utils:get_binary(not_a_map, <<"id">>, <<"default">>)),
|
||||
?assertEqual(undefined, map_utils:get_binary(#{}, <<"missing">>, undefined)),
|
||||
?assertEqual(<<"default">>, map_utils:get_binary(#{num => 123}, <<"num">>, <<"default">>)).
|
||||
|
||||
ensure_map_test() ->
|
||||
Map = #{key => value, nested => #{inner => data}},
|
||||
?assertEqual(Map, map_utils:ensure_map(Map)),
|
||||
|
||||
?assertEqual(#{}, map_utils:ensure_map(#{})).
|
||||
|
||||
ensure_map_all_input_types_test() ->
|
||||
?assertEqual(#{}, map_utils:ensure_map(not_a_map)),
|
||||
?assertEqual(#{}, map_utils:ensure_map([])),
|
||||
?assertEqual(#{}, map_utils:ensure_map([1, 2, 3])),
|
||||
?assertEqual(#{}, map_utils:ensure_map(123)),
|
||||
?assertEqual(#{}, map_utils:ensure_map(123.456)),
|
||||
?assertEqual(#{}, map_utils:ensure_map(<<"binary">>)),
|
||||
?assertEqual(#{}, map_utils:ensure_map("string")),
|
||||
?assertEqual(#{}, map_utils:ensure_map(undefined)),
|
||||
?assertEqual(#{}, map_utils:ensure_map(atom)),
|
||||
?assertEqual(#{}, map_utils:ensure_map(true)),
|
||||
?assertEqual(#{}, map_utils:ensure_map(false)),
|
||||
?assertEqual(#{}, map_utils:ensure_map({tuple, value})),
|
||||
?assertEqual(#{}, map_utils:ensure_map(self())),
|
||||
?assertEqual(#{}, map_utils:ensure_map(make_ref())),
|
||||
?assertEqual(#{}, map_utils:ensure_map(fun() -> ok end)).
|
||||
|
||||
ensure_list_test() ->
|
||||
List = [1, 2, 3],
|
||||
?assertEqual(List, map_utils:ensure_list(List)),
|
||||
|
||||
ComplexList = [#{a => 1}, {tuple}, <<"binary">>, atom],
|
||||
?assertEqual(ComplexList, map_utils:ensure_list(ComplexList)),
|
||||
|
||||
?assertEqual([], map_utils:ensure_list([])).
|
||||
|
||||
ensure_list_all_input_types_test() ->
|
||||
?assertEqual([], map_utils:ensure_list(not_a_list)),
|
||||
?assertEqual([], map_utils:ensure_list(#{})),
|
||||
?assertEqual([], map_utils:ensure_list(#{key => value})),
|
||||
?assertEqual([], map_utils:ensure_list(123)),
|
||||
?assertEqual([], map_utils:ensure_list(123.456)),
|
||||
?assertEqual([], map_utils:ensure_list(<<"binary">>)),
|
||||
?assertEqual("string", map_utils:ensure_list("string")),
|
||||
?assert(is_list(map_utils:ensure_list("string"))),
|
||||
?assertEqual([], map_utils:ensure_list(undefined)),
|
||||
?assertEqual([], map_utils:ensure_list(atom)),
|
||||
?assertEqual([], map_utils:ensure_list(true)),
|
||||
?assertEqual([], map_utils:ensure_list(false)),
|
||||
?assertEqual([], map_utils:ensure_list({tuple, value})),
|
||||
?assertEqual([], map_utils:ensure_list(self())),
|
||||
?assertEqual([], map_utils:ensure_list(make_ref())),
|
||||
?assertEqual([], map_utils:ensure_list(fun() -> ok end)).
|
||||
@@ -1,51 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(presence_manager_shards_tests).
|
||||
-typing([eqwalizer]).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
determine_count_configured_test() ->
|
||||
with_runtime_config(presence_shards, 5, fun() ->
|
||||
?assertMatch({5, configured}, presence_manager_shards:determine_count())
|
||||
end).
|
||||
|
||||
determine_count_auto_test() ->
|
||||
with_runtime_config(presence_shards, undefined, fun() ->
|
||||
{Count, auto} = presence_manager_shards:determine_count(),
|
||||
?assert(Count > 0)
|
||||
end).
|
||||
|
||||
select_test() ->
|
||||
?assert(presence_manager_shards:select(100, 4) >= 0),
|
||||
?assert(presence_manager_shards:select(100, 4) < 4).
|
||||
|
||||
find_by_ref_test() ->
|
||||
Ref1 = make_ref(),
|
||||
Ref2 = make_ref(),
|
||||
Shards = #{0 => #{pid => self(), ref => Ref1}, 1 => #{pid => self(), ref => Ref2}},
|
||||
?assertEqual({ok, 0}, presence_manager_shards:find_by_ref(Ref1, Shards)),
|
||||
?assertEqual({ok, 1}, presence_manager_shards:find_by_ref(Ref2, Shards)),
|
||||
?assertEqual(not_found, presence_manager_shards:find_by_ref(make_ref(), Shards)).
|
||||
|
||||
default_count_test() ->
|
||||
?assert(presence_manager_shards:default_count() >= 1).
|
||||
|
||||
with_runtime_config(Key, Value, Fun) ->
|
||||
ensure_runtime_config(),
|
||||
Original = fluxer_gateway_env:get(Key),
|
||||
fluxer_gateway_env:patch(#{Key => Value}),
|
||||
Result = Fun(),
|
||||
restore_runtime_config(Key, Original),
|
||||
Result.
|
||||
|
||||
ensure_runtime_config() ->
|
||||
case persistent_term:get({fluxer_gateway, runtime_config}, undefined) of
|
||||
undefined -> persistent_term:put({fluxer_gateway, runtime_config}, #{});
|
||||
_ -> ok
|
||||
end.
|
||||
|
||||
restore_runtime_config(Key, undefined) ->
|
||||
fluxer_gateway_env:update(fun(Map) -> maps:remove(Key, Map) end);
|
||||
restore_runtime_config(Key, Value) ->
|
||||
fluxer_gateway_env:update(fun(Map) -> Map#{Key => Value} end).
|
||||
@@ -1,89 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(type_conv_id_tests).
|
||||
-typing([eqwalizer]).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
to_snowflake_with_valid_values_test() ->
|
||||
?assertEqual(123, snowflake_id:parse(123)),
|
||||
?assertEqual(456, snowflake_id:parse(<<"456">>)),
|
||||
?assertEqual(789, snowflake_id:parse("789")).
|
||||
|
||||
to_snowflake_rejects_malformed_values_test() ->
|
||||
?assertError({invalid_snowflake, 0}, snowflake_id:parse(0)),
|
||||
?assertError({invalid_snowflake, <<"0">>}, snowflake_id:parse(<<"0">>)),
|
||||
?assertError({invalid_snowflake, -1}, snowflake_id:parse(-1)),
|
||||
?assertError({invalid_snowflake, <<"-1">>}, snowflake_id:parse(<<"-1">>)),
|
||||
?assertError({invalid_snowflake, <<"+1">>}, snowflake_id:parse(<<"+1">>)),
|
||||
?assertError({invalid_snowflake, <<"001">>}, snowflake_id:parse(<<"001">>)),
|
||||
?assertError({invalid_snowflake, "001"}, snowflake_id:parse("001")),
|
||||
?assertError({invalid_snowflake, <<"">>}, snowflake_id:parse(<<"">>)),
|
||||
?assertError({invalid_snowflake, <<"abc">>}, snowflake_id:parse(<<"abc">>)),
|
||||
?assertError({invalid_snowflake, 12.34}, snowflake_id:parse(12.34)).
|
||||
|
||||
to_snowflake_rejects_values_above_int64_test() ->
|
||||
?assertEqual(9223372036854775807, snowflake_id:parse(9223372036854775807)),
|
||||
?assertEqual(9223372036854775807, snowflake_id:parse(<<"9223372036854775807">>)),
|
||||
?assertError(
|
||||
{invalid_snowflake, 9223372036854775808}, snowflake_id:parse(9223372036854775808)
|
||||
),
|
||||
?assertError(
|
||||
{invalid_snowflake, <<"9223372036854775808">>},
|
||||
snowflake_id:parse(<<"9223372036854775808">>)
|
||||
),
|
||||
?assertError(
|
||||
{invalid_snowflake, "9223372036854775808"}, snowflake_id:parse("9223372036854775808")
|
||||
).
|
||||
|
||||
extract_id_with_atom_key_valid_test() ->
|
||||
?assertEqual(123, type_conv:extract_id(#{user_id => 123}, user_id)),
|
||||
?assertEqual(456, type_conv:extract_id(#{user_id => <<"456">>}, user_id)),
|
||||
?assertEqual(789, type_conv:extract_id(#{user_id => "789"}, user_id)).
|
||||
|
||||
extract_id_with_atom_key_rejects_malformed_ids_test() ->
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => 0}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => -1}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => <<"-1">>}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => <<"001">>}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => <<"+1">>}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => "001"}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => "invalid"}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => [1, 2, 3]}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => 9223372036854775808}, user_id)),
|
||||
?assertEqual(
|
||||
undefined, type_conv:extract_id(#{user_id => <<"9223372036854775808">>}, user_id)
|
||||
).
|
||||
|
||||
extract_id_with_atom_key_missing_or_invalid_test() ->
|
||||
?assertEqual(undefined, type_conv:extract_id(#{other_field => 999}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => undefined}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => #{}}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(not_a_map, user_id)).
|
||||
|
||||
extract_id_with_binary_key_valid_test() ->
|
||||
?assertEqual(123, type_conv:extract_id(#{<<"user_id">> => 123}, <<"user_id">>)),
|
||||
?assertEqual(456, type_conv:extract_id(#{<<"user_id">> => <<"456">>}, <<"user_id">>)),
|
||||
?assertEqual(789, type_conv:extract_id(#{<<"user_id">> => "789"}, <<"user_id">>)).
|
||||
|
||||
extract_id_with_binary_key_rejects_malformed_ids_test() ->
|
||||
?assertEqual(undefined, type_conv:extract_id(#{<<"user_id">> => <<"0">>}, <<"user_id">>)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{<<"user_id">> => -1}, <<"user_id">>)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{<<"user_id">> => <<"-1">>}, <<"user_id">>)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{<<"user_id">> => <<"001">>}, <<"user_id">>)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{<<"user_id">> => 12.34}, <<"user_id">>)).
|
||||
|
||||
extract_id_with_invalid_key_type_test() ->
|
||||
Map = #{user_id => 123},
|
||||
?assertEqual(undefined, type_conv:extract_id(Map, 123)),
|
||||
?assertEqual(undefined, type_conv:extract_id(Map, "user_id")),
|
||||
?assertEqual(undefined, type_conv:extract_id(Map, {user_id})),
|
||||
?assertEqual(undefined, type_conv:extract_id(Map, [user_id])).
|
||||
|
||||
extract_id_required_returns_snowflake_or_undefined_test() ->
|
||||
?assertEqual(123, type_conv:extract_id_required(#{user_id => 123}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id_required(#{user_id => <<"0">>}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id_required(#{user_id => -1}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id_required(#{user_id => <<"001">>}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id_required(#{other => value}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id_required(not_a_map, user_id)).
|
||||
@@ -1,305 +0,0 @@
|
||||
%% SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
-module(type_conv_tests).
|
||||
-typing([eqwalizer]).
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
to_integer_with_integer_test() ->
|
||||
?assertEqual(42, type_conv:to_integer(42)),
|
||||
?assertEqual(0, type_conv:to_integer(0)),
|
||||
?assertEqual(-100, type_conv:to_integer(-100)).
|
||||
|
||||
to_integer_with_integer_edge_cases_test() ->
|
||||
?assertEqual(1234567890123456789, type_conv:to_integer(1234567890123456789)),
|
||||
?assertEqual(9223372036854775807, type_conv:to_integer(9223372036854775807)),
|
||||
?assertEqual(-9223372036854775807, type_conv:to_integer(-9223372036854775807)).
|
||||
|
||||
to_integer_with_binary_valid_test() ->
|
||||
?assertEqual(123, type_conv:to_integer(<<"123">>)),
|
||||
?assertEqual(0, type_conv:to_integer(<<"0">>)),
|
||||
?assertEqual(-456, type_conv:to_integer(<<"-456">>)).
|
||||
|
||||
to_integer_with_binary_edge_cases_test() ->
|
||||
?assertEqual(1234567890123456789, type_conv:to_integer(<<"1234567890123456789">>)),
|
||||
?assertEqual(9223372036854775807, type_conv:to_integer(<<"9223372036854775807">>)),
|
||||
?assertEqual(-9223372036854775807, type_conv:to_integer(<<"-9223372036854775807">>)),
|
||||
?assertEqual(1, type_conv:to_integer(<<"1">>)),
|
||||
?assertEqual(123, type_conv:to_integer(<<"00123">>)),
|
||||
?assertEqual(0, type_conv:to_integer(<<"0">>)).
|
||||
|
||||
to_integer_with_binary_invalid_test() ->
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"not_a_number">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"12.34">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<" ">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"abc123">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"123abc">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"12 34">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"--123">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"+-123">>)).
|
||||
|
||||
to_integer_with_binary_special_chars_test() ->
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"!@#$%">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"∞">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"①②③">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"一二三">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"null">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"NaN">>)),
|
||||
?assertEqual(undefined, type_conv:to_integer(<<"Infinity">>)).
|
||||
|
||||
to_integer_with_list_valid_test() ->
|
||||
?assertEqual(789, type_conv:to_integer("789")),
|
||||
?assertEqual(-123, type_conv:to_integer("-123")),
|
||||
?assertEqual(0, type_conv:to_integer("0")).
|
||||
|
||||
to_integer_with_list_edge_cases_test() ->
|
||||
?assertEqual(1234567890123456789, type_conv:to_integer("1234567890123456789")),
|
||||
?assertEqual(5, type_conv:to_integer("5")),
|
||||
?assertEqual(42, type_conv:to_integer("00042")),
|
||||
?assertEqual(-42, type_conv:to_integer("-00042")).
|
||||
|
||||
to_integer_with_list_invalid_test() ->
|
||||
?assertEqual(undefined, type_conv:to_integer("invalid")),
|
||||
?assertEqual(undefined, type_conv:to_integer("12.34")),
|
||||
?assertEqual(undefined, type_conv:to_integer("")),
|
||||
?assertEqual(undefined, type_conv:to_integer(" ")),
|
||||
?assertEqual(undefined, type_conv:to_integer("abc")),
|
||||
?assertEqual(undefined, type_conv:to_integer("123abc")),
|
||||
?assertEqual(undefined, type_conv:to_integer("12 34")),
|
||||
?assertEqual(undefined, type_conv:to_integer([1, 2, 3])).
|
||||
|
||||
to_integer_with_list_special_chars_test() ->
|
||||
?assertEqual(undefined, type_conv:to_integer("!@#$%")),
|
||||
?assertEqual(undefined, type_conv:to_integer("hello world")),
|
||||
?assertEqual(undefined, type_conv:to_integer("--456")),
|
||||
?assertEqual(undefined, type_conv:to_integer("null")).
|
||||
|
||||
to_integer_with_atom_valid_test() ->
|
||||
?assertEqual(123, type_conv:to_integer('123')),
|
||||
?assertEqual(-456, type_conv:to_integer('-456')),
|
||||
?assertEqual(0, type_conv:to_integer('0')).
|
||||
|
||||
to_integer_with_atom_invalid_test() ->
|
||||
?assertEqual(undefined, type_conv:to_integer(test)),
|
||||
?assertEqual(undefined, type_conv:to_integer('not_a_number')),
|
||||
?assertEqual(undefined, type_conv:to_integer(hello)),
|
||||
?assertEqual(undefined, type_conv:to_integer(true)),
|
||||
?assertEqual(undefined, type_conv:to_integer(false)),
|
||||
?assertEqual(undefined, type_conv:to_integer(nil)),
|
||||
?assertEqual(undefined, type_conv:to_integer('')).
|
||||
|
||||
to_integer_with_undefined_test() ->
|
||||
?assertEqual(undefined, type_conv:to_integer(undefined)).
|
||||
|
||||
to_integer_with_invalid_types_test() ->
|
||||
?assertEqual(undefined, type_conv:to_integer(12.34)),
|
||||
?assertEqual(undefined, type_conv:to_integer(-45.67)),
|
||||
?assertEqual(undefined, type_conv:to_integer(0.0)),
|
||||
?assertEqual(undefined, type_conv:to_integer(#{key => value})),
|
||||
?assertEqual(undefined, type_conv:to_integer(#{})),
|
||||
?assertEqual(undefined, type_conv:to_integer({1, 2, 3})),
|
||||
?assertEqual(undefined, type_conv:to_integer({})),
|
||||
Ref = make_ref(),
|
||||
?assertEqual(undefined, type_conv:to_integer(Ref)),
|
||||
?assertEqual(undefined, type_conv:to_integer(self())),
|
||||
?assertEqual(undefined, type_conv:to_integer(erlang:list_to_port("#Port<0.0>"))).
|
||||
|
||||
to_binary_with_binary_test() ->
|
||||
?assertEqual(<<"test">>, type_conv:to_binary(<<"test">>)),
|
||||
?assertEqual(<<>>, type_conv:to_binary(<<>>)).
|
||||
|
||||
to_binary_with_binary_edge_cases_test() ->
|
||||
?assertEqual(<<"hello world">>, type_conv:to_binary(<<"hello world">>)),
|
||||
?assertEqual(<<"!@#$%^&*()">>, type_conv:to_binary(<<"!@#$%^&*()">>)),
|
||||
?assertEqual(<<"line1\nline2">>, type_conv:to_binary(<<"line1\nline2">>)),
|
||||
?assertEqual(<<"tab\there">>, type_conv:to_binary(<<"tab\there">>)),
|
||||
LongBinary = binary:copy(<<"x">>, 10000),
|
||||
?assertEqual(LongBinary, type_conv:to_binary(LongBinary)).
|
||||
|
||||
to_binary_with_binary_unicode_test() ->
|
||||
?assertEqual(<<"Hello 世界"/utf8>>, type_conv:to_binary(<<"Hello 世界"/utf8>>)),
|
||||
?assertEqual(<<"Здравствуй мир"/utf8>>, type_conv:to_binary(<<"Здравствуй мир"/utf8>>)),
|
||||
?assertEqual(<<"مرحبا بالعالم"/utf8>>, type_conv:to_binary(<<"مرحبا بالعالم"/utf8>>)),
|
||||
?assertEqual(<<"🚀🌟💻"/utf8>>, type_conv:to_binary(<<"🚀🌟💻"/utf8>>)),
|
||||
?assertEqual(<<"Ñoño"/utf8>>, type_conv:to_binary(<<"Ñoño"/utf8>>)),
|
||||
?assertEqual(<<"Café"/utf8>>, type_conv:to_binary(<<"Café"/utf8>>)).
|
||||
|
||||
to_binary_with_integer_test() ->
|
||||
?assertEqual(<<"42">>, type_conv:to_binary(42)),
|
||||
?assertEqual(<<"0">>, type_conv:to_binary(0)),
|
||||
?assertEqual(<<"-100">>, type_conv:to_binary(-100)).
|
||||
|
||||
to_binary_with_integer_edge_cases_test() ->
|
||||
?assertEqual(<<"1234567890123456789">>, type_conv:to_binary(1234567890123456789)),
|
||||
?assertEqual(<<"9223372036854775807">>, type_conv:to_binary(9223372036854775807)),
|
||||
?assertEqual(<<"-9223372036854775807">>, type_conv:to_binary(-9223372036854775807)),
|
||||
?assertEqual(<<"1">>, type_conv:to_binary(1)),
|
||||
?assertEqual(<<"-1">>, type_conv:to_binary(-1)).
|
||||
|
||||
to_binary_with_list_valid_test() ->
|
||||
?assertEqual(<<"hello">>, type_conv:to_binary("hello")),
|
||||
?assertEqual(<<>>, type_conv:to_binary("")).
|
||||
|
||||
to_binary_with_list_edge_cases_test() ->
|
||||
?assertEqual(<<"hello world">>, type_conv:to_binary("hello world")),
|
||||
?assertEqual(<<"!@#$%">>, type_conv:to_binary("!@#$%")),
|
||||
?assertEqual(<<"line1\nline2">>, type_conv:to_binary("line1\nline2")),
|
||||
LongString = lists:duplicate(10000, $x),
|
||||
LongBinary = binary:copy(<<"x">>, 10000),
|
||||
?assertEqual(LongBinary, type_conv:to_binary(LongString)).
|
||||
|
||||
to_binary_with_list_unicode_test() ->
|
||||
?assertEqual(undefined, type_conv:to_binary(unicode_world_chars())),
|
||||
?assertEqual(undefined, type_conv:to_binary(emoji_chars())),
|
||||
|
||||
?assertEqual(<<67, 97, 102, 233>>, type_conv:to_binary(cafe_latin1_chars())),
|
||||
|
||||
?assertEqual(<<"Hello">>, type_conv:to_binary([72, 101, 108, 108, 111])),
|
||||
|
||||
?assertEqual(<<0, 1, 127, 255>>, type_conv:to_binary([0, 1, 127, 255])).
|
||||
|
||||
to_binary_with_list_invalid_test() ->
|
||||
?assertEqual(<<1, 2, 3>>, type_conv:to_binary([1, 2, 3])),
|
||||
?assertEqual(undefined, type_conv:to_binary([256])),
|
||||
?assertEqual(undefined, type_conv:to_binary([1000])),
|
||||
?assertEqual(undefined, type_conv:to_binary([-1])),
|
||||
?assertEqual(undefined, type_conv:to_binary([hello, world])),
|
||||
?assertEqual(undefined, type_conv:to_binary([1, 2, atom])).
|
||||
|
||||
to_binary_with_atom_test() ->
|
||||
?assertEqual(<<"test">>, type_conv:to_binary(test)),
|
||||
?assertEqual(<<"hello_world">>, type_conv:to_binary(hello_world)),
|
||||
?assertEqual(<<"true">>, type_conv:to_binary(true)),
|
||||
?assertEqual(<<"false">>, type_conv:to_binary(false)),
|
||||
?assertEqual(<<"">>, type_conv:to_binary('')).
|
||||
|
||||
to_binary_with_atom_edge_cases_test() ->
|
||||
?assertEqual(<<"Hello World">>, type_conv:to_binary('Hello World')),
|
||||
?assertEqual(<<"123">>, type_conv:to_binary('123')),
|
||||
?assertEqual(<<"hello-world">>, type_conv:to_binary('hello-world')),
|
||||
?assertEqual(<<"test@example">>, type_conv:to_binary('test@example')),
|
||||
?assertEqual(undefined, type_conv:to_binary(undefined)).
|
||||
|
||||
to_binary_with_invalid_types_test() ->
|
||||
?assertEqual(undefined, type_conv:to_binary(12.34)),
|
||||
?assertEqual(undefined, type_conv:to_binary(-45.67)),
|
||||
?assertEqual(undefined, type_conv:to_binary(0.0)),
|
||||
?assertEqual(undefined, type_conv:to_binary(#{key => value})),
|
||||
?assertEqual(undefined, type_conv:to_binary(#{})),
|
||||
?assertEqual(undefined, type_conv:to_binary({1, 2, 3})),
|
||||
?assertEqual(undefined, type_conv:to_binary({})),
|
||||
Ref = make_ref(),
|
||||
?assertEqual(undefined, type_conv:to_binary(Ref)),
|
||||
?assertEqual(undefined, type_conv:to_binary(self())),
|
||||
?assertEqual(undefined, type_conv:to_binary(erlang:list_to_port("#Port<0.0>"))).
|
||||
|
||||
to_list_with_list_test() ->
|
||||
?assertEqual("test", type_conv:to_list("test")),
|
||||
?assertEqual([], type_conv:to_list([])),
|
||||
?assertEqual([1, 2, 3], type_conv:to_list([1, 2, 3])).
|
||||
|
||||
to_list_with_list_edge_cases_test() ->
|
||||
?assertEqual("hello world", type_conv:to_list("hello world")),
|
||||
?assertEqual("!@#$%^&*()", type_conv:to_list("!@#$%^&*()")),
|
||||
?assertEqual([true, false, nil], type_conv:to_list([true, false, nil])),
|
||||
?assertEqual(nested_number_lists(), type_conv:to_list(nested_number_lists())),
|
||||
LongList = lists:duplicate(10000, $x),
|
||||
?assertEqual(LongList, type_conv:to_list(LongList)).
|
||||
|
||||
to_list_with_list_unicode_test() ->
|
||||
?assertEqual(unicode_world_chars(), type_conv:to_list(unicode_world_chars())),
|
||||
?assertEqual(cafe_latin1_chars(), type_conv:to_list(cafe_latin1_chars())),
|
||||
?assertEqual(emoji_chars(), type_conv:to_list(emoji_chars())).
|
||||
|
||||
to_list_with_binary_test() ->
|
||||
?assertEqual("hello", type_conv:to_list(<<"hello">>)),
|
||||
?assertEqual("", type_conv:to_list(<<>>)).
|
||||
|
||||
to_list_with_binary_edge_cases_test() ->
|
||||
?assertEqual("hello world", type_conv:to_list(<<"hello world">>)),
|
||||
?assertEqual("!@#$%", type_conv:to_list(<<"!@#$%">>)),
|
||||
?assertEqual("line1\nline2", type_conv:to_list(<<"line1\nline2">>)),
|
||||
?assertEqual("tab\there", type_conv:to_list(<<"tab\there">>)),
|
||||
LongBinary = binary:copy(<<"x">>, 10000),
|
||||
LongList = lists:duplicate(10000, $x),
|
||||
?assertEqual(LongList, type_conv:to_list(LongBinary)).
|
||||
|
||||
to_list_with_binary_unicode_test() ->
|
||||
?assertEqual(
|
||||
[72, 101, 108, 108, 111, 32, 228, 184, 150, 231, 149, 140],
|
||||
type_conv:to_list(<<"Hello 世界"/utf8>>)
|
||||
),
|
||||
?assertEqual([67, 97, 102, 195, 169], type_conv:to_list(<<"Café"/utf8>>)),
|
||||
?assertEqual(
|
||||
<<"Hello 世界"/utf8>>, list_to_binary(assert_list(type_conv:to_list(<<"Hello 世界"/utf8>>)))
|
||||
).
|
||||
|
||||
to_list_with_atom_test() ->
|
||||
?assertEqual("test", type_conv:to_list(test)),
|
||||
?assertEqual("hello_world", type_conv:to_list(hello_world)),
|
||||
?assertEqual("true", type_conv:to_list(true)),
|
||||
?assertEqual("false", type_conv:to_list(false)),
|
||||
?assertEqual("", type_conv:to_list('')).
|
||||
|
||||
to_list_with_atom_edge_cases_test() ->
|
||||
?assertEqual(
|
||||
[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100], type_conv:to_list('Hello World')
|
||||
),
|
||||
?assertEqual([49, 50, 51], type_conv:to_list('123')),
|
||||
?assertEqual(
|
||||
[104, 101, 108, 108, 111, 45, 119, 111, 114, 108, 100], type_conv:to_list('hello-world')
|
||||
),
|
||||
?assertEqual(undefined, type_conv:to_list(undefined)).
|
||||
|
||||
to_list_rejects_non_list_like_values_test() ->
|
||||
lists:foreach(
|
||||
fun(Value) -> ?assertEqual(undefined, type_conv:to_list(Value)) end,
|
||||
[42, 12.34, #{}, {1, 2, 3}, make_ref(), self()]
|
||||
).
|
||||
|
||||
unicode_world_chars() ->
|
||||
[72, 101, 108, 108, 111, 32, 19990, 30028].
|
||||
|
||||
cafe_latin1_chars() ->
|
||||
[67, 97, 102, 233].
|
||||
|
||||
emoji_chars() ->
|
||||
[128640, 127775, 128187].
|
||||
|
||||
nested_number_lists() ->
|
||||
[[1, 2], [3, 4]].
|
||||
|
||||
extract_id_uses_snowflake_semantics_test() ->
|
||||
?assertEqual(123, type_conv:extract_id(#{user_id => 123}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => <<"0">>}, user_id)),
|
||||
?assertEqual(456, type_conv:extract_id(#{<<"user_id">> => <<"456">>}, <<"user_id">>)),
|
||||
?assertEqual(789, type_conv:extract_id(#{<<"user_id">> => "789"}, <<"user_id">>)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => -1}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => <<"-1">>}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id(#{user_id => <<"001">>}, user_id)).
|
||||
|
||||
extract_id_required_returns_snowflake_or_undefined_test() ->
|
||||
?assertEqual(123, type_conv:extract_id_required(#{user_id => <<"123">>}, user_id)),
|
||||
?assertEqual(
|
||||
undefined, type_conv:extract_id_required(#{<<"user_id">> => 0}, <<"user_id">>)
|
||||
),
|
||||
?assertEqual(undefined, type_conv:extract_id_required(#{user_id => "-1"}, user_id)),
|
||||
?assertEqual(undefined, type_conv:extract_id_required(#{user_id => "001"}, user_id)).
|
||||
to_list_with_invalid_types_test() ->
|
||||
?assertEqual(undefined, type_conv:to_list(42)),
|
||||
?assertEqual(undefined, type_conv:to_list(-123)),
|
||||
?assertEqual(undefined, type_conv:to_list(0)),
|
||||
?assertEqual(undefined, type_conv:to_list(12.34)),
|
||||
?assertEqual(undefined, type_conv:to_list(-45.67)),
|
||||
?assertEqual(undefined, type_conv:to_list(0.0)),
|
||||
?assertEqual(undefined, type_conv:to_list(#{key => value})),
|
||||
?assertEqual(undefined, type_conv:to_list(#{})),
|
||||
?assertEqual(undefined, type_conv:to_list({1, 2, 3})),
|
||||
?assertEqual(undefined, type_conv:to_list({})),
|
||||
Ref = make_ref(),
|
||||
?assertEqual(undefined, type_conv:to_list(Ref)),
|
||||
?assertEqual(undefined, type_conv:to_list(self())),
|
||||
?assertEqual(undefined, type_conv:to_list(erlang:list_to_port("#Port<0.0>"))).
|
||||
|
||||
assert_list(Value) when is_list(Value) ->
|
||||
Value.
|
||||
Reference in New Issue
Block a user