From 0a9dd17f9062c8429150bcaf751bec0e34772ae5 Mon Sep 17 00:00:00 2001
From: Mark Allen <mrallen1@yahoo.com>
Date: Wed, 6 Apr 2016 23:10:01 -0500
Subject: [PATCH] Test manager killer on alternate sink

---
 test/lager_manager_killer_test.erl | 51 +++++++++++++++++++++++++++---
 1 file changed, 47 insertions(+), 4 deletions(-)

diff --git a/test/lager_manager_killer_test.erl b/test/lager_manager_killer_test.erl
index 7a0622a..96199b0 100644
--- a/test/lager_manager_killer_test.erl
+++ b/test/lager_manager_killer_test.erl
@@ -6,6 +6,9 @@
 -ifdef(TEST).
 -include_lib("eunit/include/eunit.hrl").
 
+-define(TEST_SINK_NAME, '__lager_test_sink').              %% <-- used by parse transform
+-define(TEST_SINK_EVENT, '__lager_test_sink_lager_event'). %% <-- used by lager API calls and internals for gen_event
+
 overload_test_() ->
     {timeout, 60,
      fun() ->
@@ -26,7 +29,7 @@ overload_test_() ->
              [lager:info("~p'th message", [N]) || N <- lists:seq(1,KillerHWM+2)],
              Margin = 100,
              ok = confirm_manager_exit(Manager, Delay+Margin),
-             ok = confirm_sink_reregister(Margin),
+             ok = confirm_sink_reregister(lager_event, Margin),
              erlang:trace(all, false, [procs]),
              wait_until(fun() ->
                                 case proplists:get_value(lager_manager_killer, gen_event:which_handlers(lager_event)) of
@@ -43,6 +46,46 @@ overload_test_() ->
              application:stop(lager)
      end}.
 
+overload_alternate_sink_test_() ->
+    {timeout, 60,
+     fun() ->
+             application:stop(lager),
+             application:load(lager),
+             Delay = 1000, % sleep 1 sec on every log
+             KillerHWM = 10, % kill the manager if there are more than 10 pending logs
+             KillerReinstallAfter = 1000, % reinstall killer after 1 sec
+             application:set_env(lager, handlers, []),
+             application:set_env(lager, extra_sinks, [{?TEST_SINK_EVENT, [
+                                                                          {handlers, [{lager_slow_backend, [{delay, Delay}]}]},
+                                                                          {killer_hwm, KillerHWM},
+                                                                          {killer_reinstall_after, KillerReinstallAfter},
+                                                                          {async_threshold, undefined}
+                                                                         ]}]),
+             application:set_env(lager, error_logger_redirect, true),
+             ensure_started(lager),
+             lager_config:set({?TEST_SINK_EVENT, async}, true),
+             Manager = whereis(?TEST_SINK_EVENT),
+             erlang:trace(all, true, [procs]),
+             [?TEST_SINK_NAME:info("~p'th message", [N]) || N <- lists:seq(1,KillerHWM+2)],
+             Margin = 100,
+             ok = confirm_manager_exit(Manager, Delay+Margin),
+             ok = confirm_sink_reregister(?TEST_SINK_EVENT, Margin),
+             erlang:trace(all, false, [procs]),
+             wait_until(fun() ->
+                                case proplists:get_value(lager_manager_killer, gen_event:which_handlers(?TEST_SINK_EVENT)) of
+                                    [] -> false;
+                                    _ -> true
+                                end
+                        end, Margin, 15),
+             wait_until(fun() ->
+                                case gen_event:call(?TEST_SINK_EVENT, lager_manager_killer, get_settings) of
+                                    [KillerHWM, KillerReinstallAfter] -> true;
+                                    _Other -> false
+                                end
+                        end, Margin, 15),
+             application:stop(lager)
+     end}.
+
 ensure_started(App) ->
     case application:start(App) of
         ok ->
@@ -63,10 +106,10 @@ confirm_manager_exit(Manager, Delay) ->
             ?assert(false)
     end.
 
-confirm_sink_reregister(Delay) ->
+confirm_sink_reregister(Sink, Delay) ->
     receive
-        {trace, _Pid, register, lager_event} ->
-            ?assertNot(lists:member(lager_manager_killer, gen_event:which_handlers(lager_event)))
+        {trace, _Pid, register, Sink} ->
+            ?assertNot(lists:member(lager_manager_killer, gen_event:which_handlers(Sink)))
     after Delay ->
             ?assert(false)
     end.