Current section
Files
Jump to
Current section
Files
src/telega@testing@mock.erl
-module(telega@testing@mock).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/telega/testing/mock.gleam").
-export([ok_response/1, bool_response/0, message_response/0, client/0, message_client/0, client_with/1, route/2, route_with_body/2, route_with_response/2, routed_client/1, stateful_client/1, get_calls/1, assert_call_count/2, assert_no_calls/1, assert_called_with_path/2, assert_called_with_body/3]).
-export_type([api_call/0, mock_route/0]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(
" Mock client and assertion utilities for testing bot API interactions.\n"
"\n"
" ```gleam\n"
" import telega/testing/mock\n"
"\n"
" let #(client, calls) = mock.client()\n"
" // ... use client in your bot setup ...\n"
" mock.assert_call_count(from: calls, expected: 1)\n"
" ```\n"
).
-type api_call() :: {api_call, gleam@http@request:request(binary())}.
-type mock_route() :: {mock_route,
binary(),
fun((gleam@http@request:request(binary())) -> {ok,
gleam@http@response:response(binary())} |
{error, telega@error:telega_error()})}.
-file("src/telega/testing/mock.gleam", 32).
?DOC(" Wraps a `Json` value into `{\"ok\":true,\"result\":...}` Telegram API response format.\n").
-spec ok_response(gleam@json:json()) -> binary().
ok_response(Result) ->
gleam@json:to_string(
gleam@json:object(
[{<<"ok"/utf8>>, gleam@json:bool(true)},
{<<"result"/utf8>>, Result}]
)
).
-file("src/telega/testing/mock.gleam", 38).
?DOC(
" Returns a `{\"ok\":true,\"result\":true}` response string.\n"
" Use for endpoints that return a boolean (e.g. `answerCallbackQuery`, `deleteMessage`).\n"
).
-spec bool_response() -> binary().
bool_response() ->
ok_response(gleam@json:bool(true)).
-file("src/telega/testing/mock.gleam", 44).
?DOC(
" Returns a JSON string representing a valid `{\"ok\":true,\"result\":{...message...}}` response.\n"
" Useful for building custom mock clients that need to return valid Message responses.\n"
).
-spec message_response() -> binary().
message_response() ->
ok_response(
telega@model@encoder:encode_message(
telega@testing@factory:message(<<""/utf8>>)
)
).
-file("src/telega/testing/mock.gleam", 52).
?DOC(
" Creates a mock Telegram client that records all API calls\n"
" and returns 200 OK with an empty successful response.\n"
" Note: This response will NOT decode as a valid Message.\n"
" Use `message_client()` if your handlers call reply functions.\n"
).
-spec client() -> {telega@client:telegram_client(),
gleam@erlang@process:subject(api_call())}.
client() ->
Calls = gleam@erlang@process:new_subject(),
Fetch_client = fun(Req) ->
gleam@erlang@process:send(Calls, {api_call, Req}),
{ok,
begin
_pipe = gleam@http@response:new(200),
gleam@http@response:set_body(
_pipe,
<<"{\"ok\":true,\"result\":{}}"/utf8>>
)
end}
end,
Telegram_client = telega@client:new(<<"test_token"/utf8>>, Fetch_client),
{Telegram_client, Calls}.
-file("src/telega/testing/mock.gleam", 65).
?DOC(
" Creates a mock Telegram client that records all API calls\n"
" and returns 200 OK with a valid Message response.\n"
" Use this when your handlers call `reply.with_text` or other reply functions.\n"
).
-spec message_client() -> {telega@client:telegram_client(),
gleam@erlang@process:subject(api_call())}.
message_client() ->
Response_body = message_response(),
Calls = gleam@erlang@process:new_subject(),
Fetch_client = fun(Req) ->
gleam@erlang@process:send(Calls, {api_call, Req}),
{ok,
begin
_pipe = gleam@http@response:new(200),
gleam@http@response:set_body(_pipe, Response_body)
end}
end,
Telegram_client = telega@client:new(<<"test_token"/utf8>>, Fetch_client),
{Telegram_client, Calls}.
-file("src/telega/testing/mock.gleam", 77).
?DOC(" Creates a mock client with a custom response handler.\n").
-spec client_with(
fun((gleam@http@request:request(binary())) -> {ok,
gleam@http@response:response(binary())} |
{error, telega@error:telega_error()})
) -> {telega@client:telegram_client(), gleam@erlang@process:subject(api_call())}.
client_with(Handler) ->
Calls = gleam@erlang@process:new_subject(),
Fetch_client = fun(Req) ->
gleam@erlang@process:send(Calls, {api_call, Req}),
Handler(Req)
end,
Telegram_client = telega@client:new(<<"test_token"/utf8>>, Fetch_client),
{Telegram_client, Calls}.
-file("src/telega/testing/mock.gleam", 104).
?DOC(
" Creates a route that matches requests whose path contains `path_contains`\n"
" and delegates to the given handler function.\n"
).
-spec route(
binary(),
fun((gleam@http@request:request(binary())) -> {ok,
gleam@http@response:response(binary())} |
{error, telega@error:telega_error()})
) -> mock_route().
route(Path_contains, Handler) ->
{mock_route, Path_contains, Handler}.
-file("src/telega/testing/mock.gleam", 114).
?DOC(
" Creates a route that matches requests whose path contains `path_contains`\n"
" and returns a 200 OK with the given body string.\n"
).
-spec route_with_body(binary(), binary()) -> mock_route().
route_with_body(Path_contains, Body) ->
{mock_route,
Path_contains,
fun(_) ->
{ok,
begin
_pipe = gleam@http@response:new(200),
gleam@http@response:set_body(_pipe, Body)
end}
end}.
-file("src/telega/testing/mock.gleam", 126).
?DOC(
" Creates a route that matches requests whose path contains `path_contains`\n"
" and returns a 200 OK with the given response string (from `ok_response`, `bool_response`, etc.).\n"
" Prefer this over `route_with_body` for type-safe response building.\n"
).
-spec route_with_response(binary(), binary()) -> mock_route().
route_with_response(Path_contains, Response_body) ->
{mock_route,
Path_contains,
fun(_) ->
{ok,
begin
_pipe = gleam@http@response:new(200),
gleam@http@response:set_body(_pipe, Response_body)
end}
end}.
-file("src/telega/testing/mock.gleam", 154).
-spec find_matching_route(
list(mock_route()),
gleam@http@request:request(binary())
) -> {ok, mock_route()} | {error, nil}.
find_matching_route(Routes, Req) ->
gleam@list:find(
Routes,
fun(R) ->
gleam_stdlib:contains_string(
erlang:element(8, Req),
erlang:element(2, R)
)
end
).
-file("src/telega/testing/mock.gleam", 138).
?DOC(
" Creates a mock client that routes requests through a list of `MockRoute`s.\n"
" Routes are checked in order; first match wins. Unmatched requests fall back\n"
" to a default `message_response()`.\n"
).
-spec routed_client(list(mock_route())) -> {telega@client:telegram_client(),
gleam@erlang@process:subject(api_call())}.
routed_client(Routes) ->
Default_body = message_response(),
Calls = gleam@erlang@process:new_subject(),
Fetch_client = fun(Req) ->
gleam@erlang@process:send(Calls, {api_call, Req}),
case find_matching_route(Routes, Req) of
{ok, Matched_route} ->
(erlang:element(3, Matched_route))(Req);
{error, _} ->
{ok,
begin
_pipe = gleam@http@response:new(200),
gleam@http@response:set_body(_pipe, Default_body)
end}
end
end,
Telegram_client = telega@client:new(<<"test_token"/utf8>>, Fetch_client),
{Telegram_client, Calls}.
-file("src/telega/testing/mock.gleam", 167).
?DOC(
" Creates a mock client that passes a 0-based call counter to the handler.\n"
" Useful for returning different responses based on call order.\n"
).
-spec stateful_client(
fun((gleam@http@request:request(binary()), integer()) -> {ok,
gleam@http@response:response(binary())} |
{error, telega@error:telega_error()})
) -> {telega@client:telegram_client(), gleam@erlang@process:subject(api_call())}.
stateful_client(Handler) ->
Calls = gleam@erlang@process:new_subject(),
Counter = gleam@erlang@process:new_subject(),
gleam@erlang@process:send(Counter, 0),
Fetch_client = fun(Req) ->
N@1 = case gleam@erlang@process:'receive'(Counter, 1000) of
{ok, N} -> N;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"telega/testing/mock"/utf8>>,
function => <<"stateful_client"/utf8>>,
line => 175,
value => _assert_fail,
start => 6324,
'end' => 6373,
pattern_start => 6335,
pattern_end => 6340})
end,
gleam@erlang@process:send(Counter, N@1 + 1),
gleam@erlang@process:send(Calls, {api_call, Req}),
Handler(Req, N@1)
end,
Telegram_client = telega@client:new(<<"test_token"/utf8>>, Fetch_client),
{Telegram_client, Calls}.
-file("src/telega/testing/mock.gleam", 189).
-spec drain_calls(gleam@erlang@process:subject(api_call()), list(api_call())) -> list(api_call()).
drain_calls(Subject, Acc) ->
case gleam@erlang@process:'receive'(Subject, 0) of
{ok, Call} ->
drain_calls(Subject, [Call | Acc]);
{error, _} ->
lists:reverse(Acc)
end.
-file("src/telega/testing/mock.gleam", 185).
?DOC(" Drains all recorded API calls from the subject.\n").
-spec get_calls(gleam@erlang@process:subject(api_call())) -> list(api_call()).
get_calls(Subject) ->
drain_calls(Subject, []).
-file("src/telega/testing/mock.gleam", 197).
?DOC(" Asserts the number of recorded API calls equals the expected count.\n").
-spec assert_call_count(gleam@erlang@process:subject(api_call()), integer()) -> list(api_call()).
assert_call_count(Subject, Expected) ->
Calls = get_calls(Subject),
Count = erlang:length(Calls),
case Count =:= Expected of
true ->
Calls;
false ->
erlang:error(#{gleam_error => panic,
message => (<<<<<<"Expected "/utf8,
(gleam@string:inspect(Expected))/binary>>/binary,
" API calls, got "/utf8>>/binary,
(gleam@string:inspect(Count))/binary>>),
file => <<?FILEPATH/utf8>>,
module => <<"telega/testing/mock"/utf8>>,
function => <<"assert_call_count"/utf8>>,
line => 206})
end.
-file("src/telega/testing/mock.gleam", 216).
?DOC(" Asserts no API calls were recorded.\n").
-spec assert_no_calls(gleam@erlang@process:subject(api_call())) -> nil.
assert_no_calls(Subject) ->
Calls = get_calls(Subject),
case gleam@list:is_empty(Calls) of
true ->
nil;
false ->
erlang:error(#{gleam_error => panic,
message => (<<"Expected no API calls, got "/utf8,
(gleam@string:inspect(erlang:length(Calls)))/binary>>),
file => <<?FILEPATH/utf8>>,
module => <<"telega/testing/mock"/utf8>>,
function => <<"assert_no_calls"/utf8>>,
line => 221})
end.
-file("src/telega/testing/mock.gleam", 228).
?DOC(" Asserts at least one API call was made to a path containing the given string.\n").
-spec assert_called_with_path(
gleam@erlang@process:subject(api_call()),
binary()
) -> api_call().
assert_called_with_path(Subject, Path_contains) ->
Calls = get_calls(Subject),
case gleam@list:find(
Calls,
fun(Call) ->
gleam_stdlib:contains_string(
erlang:element(8, erlang:element(2, Call)),
Path_contains
)
end
) of
{ok, Call@1} ->
Call@1;
{error, _} ->
erlang:error(#{gleam_error => panic,
message => (<<<<<<"No API call found with path containing '"/utf8,
Path_contains/binary>>/binary,
"'. Calls: "/utf8>>/binary,
(gleam@string:inspect(Calls))/binary>>),
file => <<?FILEPATH/utf8>>,
module => <<"telega/testing/mock"/utf8>>,
function => <<"assert_called_with_path"/utf8>>,
line => 240})
end.
-file("src/telega/testing/mock.gleam", 251).
?DOC(
" Asserts at least one API call was made to a path containing `path_contains`\n"
" and whose request body contains `body_contains`.\n"
).
-spec assert_called_with_body(
gleam@erlang@process:subject(api_call()),
binary(),
binary()
) -> api_call().
assert_called_with_body(Subject, Path_contains, Body_contains) ->
Calls = get_calls(Subject),
case gleam@list:find(
Calls,
fun(Call) ->
gleam_stdlib:contains_string(
erlang:element(8, erlang:element(2, Call)),
Path_contains
)
andalso gleam_stdlib:contains_string(
erlang:element(4, erlang:element(2, Call)),
Body_contains
)
end
) of
{ok, Call@1} ->
Call@1;
{error, _} ->
erlang:error(#{gleam_error => panic,
message => (<<<<<<<<<<"No API call found with path containing '"/utf8,
Path_contains/binary>>/binary,
"' and body containing '"/utf8>>/binary,
Body_contains/binary>>/binary,
"'. Calls: "/utf8>>/binary,
(gleam@string:inspect(Calls))/binary>>),
file => <<?FILEPATH/utf8>>,
module => <<"telega/testing/mock"/utf8>>,
function => <<"assert_called_with_body"/utf8>>,
line => 265})
end.