Revert back to avoid meck

Author: ansd

deps/rabbit/test/amqp_client_SUITE.erl

@@ -6216,35 +6216,20 @@ tcp_back_pressure_rabbitmq_internal_flow(QType, Config) ->
     end,
     flush(receiver_attached),
 
-    {_GenStatemStateSession, StateSession} = formatted_state(Session),
-    Socket = case web_amqp(Config) of
-                 true ->
-                     #{socket := {ws, GunPid, _GunStreamRef}} = StateSession,
-                     {_GenStatemStateGun, StateGun} = formatted_state(GunPid),
-                     %% https://github.com/ninenines/gun/blob/2.1.0/src/gun.erl#L315
-                     element(12, StateGun);
-                 false ->
-                     #{socket := {tcp, Sock}} = StateSession,
-                     Sock
-             end,
-    ?assert(is_port(Socket)),
+    {_GenStatemState,
+     #{reader := ReaderPid,
+       socket := {tcp, Socket}}} = formatted_state(Session),
 
-    %% Provoke TCP back-pressure from client to server by:
-    %% 1. using very small buffers
+    %% Provoke TCP back-pressure from client to server by using very small buffers.
     ok = inet:setopts(Socket, [{recbuf, 256},
                                {buffer, 256}]),
-    %% 2. stopping reading from the socket
-    Mod = inet,
-    ok = meck:new(Mod, [unstick, no_link, passthrough]),
-    ok = meck:expect(Mod, setopts, fun(_Sock, [{active, once}]) ->
-                                           ok;
-                                      (Sock, Opts) ->
-                                           meck:passthrough([Sock, Opts])
-                                   end),
+    %% Suspend the receiving client such that it stops reading from its socket
+    %% causing TCP back-pressure to the server being applied.
+    true = erlang:suspend_process(ReaderPid),
 
     ok = amqp10_client:flow_link_credit(Receiver, Num, never),
     %% We give the queue time to send messages to the session proc and writer proc.
-    timer:sleep(2000),
+    timer:sleep(1000),
 
     %% Here, we do a bit of white box testing: We assert that RabbitMQ has some form of internal
     %% flow control by checking that the queue sent some but, more importantly, not all its
@@ -6258,14 +6243,14 @@ tcp_back_pressure_rabbitmq_internal_flow(QType, Config) ->
     ok = inet:setopts(Socket, [{recbuf, 65536},
                                {buffer, 65536}]),
     %% When we resume the receiving client, we expect to receive all messages.
-    ?assert(meck:validate(Mod)),
-    ok = meck:unload(Mod),
-    ok = Mod:setopts(Socket, [{active, once}]),
+    true = erlang:resume_process(ReaderPid),
     receive_messages(Receiver, Num),
 
     ok = detach_link_sync(Receiver),
     {ok, #{message_count := 0}} = rabbitmq_amqp_client:delete_queue(LinkPair, QName),
-    ok = close({Connection, Session, LinkPair}).
+    ok = rabbitmq_amqp_client:detach_management_link_pair_sync(LinkPair),
+    ok = end_session_sync(Session),
+    ok = close_connection_sync(Connection).
 
 session_flow_control_default_max_frame_size(Config) ->
     QName = atom_to_binary(?FUNCTION_NAME),