rabbit_logger_std_h: Mock calls to io:put_chars/2 during testing

[Why]
Before `rabbitmq_prelaunch` was moved from `deps/rabbit/apps` to `deps`,
it would inherit compile flags from `deps/rabbit`. Therefore, when
`rabbit` was tested, `rabbit_logger_std_h` simply replaced the calls to
`io:put_chars/2` with an internal macro to also call `ct:log/2`.

This is not possible anymore after the move and the move broke the
console-based testcases.

[How]
`rabbit_logger_std_h` now uses an indirect internal call to a wrapper of
`io:put_chars/2`. This allows the `logging_SUITE` to mock that call and
add the addition call to `ct:log/2`.

We need to do an explicit `?MODULE:io_put_chars/2` even though a local
call would work, otherwise meck can't intercept the calls.

Author: dumbbell

deps/rabbit/test/logging_SUITE.erl

@@ -107,9 +107,12 @@ groups() ->
 
 init_per_suite(Config) ->
     rabbit_ct_helpers:log_environment(),
-    rabbit_ct_helpers:run_setup_steps(Config).
+    Config1 = rabbit_ct_helpers:run_setup_steps(Config),
+    meck_rabbit_logger_std_h(),
+    Config1.
 
 end_per_suite(Config) ->
+    unmeck_rabbit_logger_std_h(),
     Config.
 
 init_per_group(syslog_output, Config) ->
@@ -186,6 +189,23 @@ end_per_testcase(Testcase, Config) ->
               end,
     rabbit_ct_helpers:testcase_finished(Config1, Testcase).
 
+meck_rabbit_logger_std_h() ->
+    ok = meck:new(rabbit_logger_std_h, [no_link, passthrough]),
+    ok = meck:expect(
+           rabbit_logger_std_h, io_put_chars,
+           fun(DEVICE, DATA) ->
+                   %% We log to Common Test log as well.
+                   %% This is the file we use to check
+                   %% the message made it to
+                   %% stdout/stderr.
+                   ct:log("~ts", [DATA]),
+                   io:put_chars(DEVICE, DATA)
+           end).
+
+unmeck_rabbit_logger_std_h() ->
+    ?assert(meck:validate(rabbit_logger_std_h)),
+    ok = meck:unload(rabbit_logger_std_h).
+
 remove_all_handlers() ->
     _ = [logger:remove_handler(Id)
          || #{id := Id} <- logger:get_handler_config()].

deps/rabbitmq_prelaunch/src/rabbit_logger_std_h.erl

@@ -20,19 +20,9 @@
 -module(rabbit_logger_std_h).
 
 -ifdef(TEST).
--define(io_put_chars(DEVICE, DATA), begin
-                                        %% We log to Common Test log as well.
-                                        %% This is the file we use to check
-                                        %% the message made it to
-                                        %% stdout/stderr.
-                                        ct:log("~ts", [DATA]),
-                                        io:put_chars(DEVICE, DATA)
-                                    end).
-
 -export([parse_date_spec/1, parse_day_of_week/2, parse_day_of_month/2, parse_hour/2, parse_minute/2]).
--else.
--define(io_put_chars(DEVICE, DATA), io:put_chars(DEVICE, DATA)).
 -endif.
+
 -define(file_write(DEVICE, DATA), file:write(DEVICE, DATA)).
 -define(file_datasync(DEVICE), file:datasync(DEVICE)).
 
@@ -50,6 +40,9 @@
 -export([log/2, adding_handler/1, removing_handler/1, changing_config/3,
          filter_config/1]).
 
+%% Internal export to allow the use of meck.
+-export([io_put_chars/2]).
+
 -define(DEFAULT_CALL_TIMEOUT, 5000).
 
 %%%===================================================================
@@ -549,15 +542,15 @@ ensure_open(Filename, Modes) ->
 
 write_to_dev(Bin,#{dev:=standard_io}=State) ->
     try
-        io:put_chars(user, Bin)
+        ?MODULE:io_put_chars(user, Bin)
     catch _E:_R ->
-            io:put_chars(
+            ?MODULE:io_put_chars(
               standard_error, "Failed to write log message to stdout, trying stderr\n"),
-            io:put_chars(standard_error, Bin)
+            ?MODULE:io_put_chars(standard_error, Bin)
     end,
     State;
 write_to_dev(Bin,#{dev:=DevName}=State) ->
-    ?io_put_chars(DevName, Bin),
+    ?MODULE:io_put_chars(DevName, Bin),
     State;
 write_to_dev(Bin, State) ->
     State1 = #{fd:=Fd} = maybe_ensure_file(State),
@@ -566,6 +559,9 @@ write_to_dev(Bin, State) ->
     maybe_notify_error(write,Result,State2),
     State2#{synced=>false,write_res=>Result}.
 
+io_put_chars(DevName, Bin) ->
+    io:put_chars(DevName, Bin).
+
 sync_dev(#{synced:=false}=State) ->
     State1 = #{fd:=Fd} = maybe_ensure_file(State),
     Result = ?file_datasync(Fd),