Merge pull request #384 from basho/basho/separate-test-directory

Bugfix and separate test files directory.

src/lager_crash_log.erl

@@ -1,4 +1,6 @@
-%% Copyright (c) 2011-2012 Basho Technologies, Inc.  All Rights Reserved.
+%% -------------------------------------------------------------------
+%%
+%% Copyright (c) 2011-2017 Basho Technologies, Inc.
 %%
 %% This file is provided to you under the Apache License,
 %% Version 2.0 (the "License"); you may not use this file
@@ -13,6 +15,8 @@
 %% KIND, either express or implied.  See the License for the
 %% specific language governing permissions and limitations
 %% under the License.
+%%
+%% -------------------------------------------------------------------
 
 %% @doc Lager crash log writer. This module implements a gen_server which writes
 %% error_logger error messages out to a file in their original format. The
@@ -236,105 +240,118 @@ do_log({log, Event}, #state{name=Name, fd=FD, inode=Inode, flap=Flap,
 filesystem_test_() ->
     {foreach,
         fun() ->
-                file:write_file("crash_test.log", ""),
-                error_logger:tty(false),
-                application:load(lager),
-                application:set_env(lager, handlers, [{lager_test_backend, info}]),
-                application:set_env(lager, error_logger_redirect, true),
-                application:unset_env(lager, crash_log),
-                lager:start(),
-                timer:sleep(100),
-                lager_test_backend:flush()
-        end,
-        fun(_) ->
-                case whereis(lager_crash_log) of
-                    P when is_pid(P) ->
-                        exit(P, kill);
-                    _ -> ok
-                end,
-                file:delete("crash_test.log"),
-                application:stop(lager),
-                application:stop(goldrush),
-                error_logger:tty(true)
+            CrashLog = filename:join(lager_util:create_test_dir(), "crash_test.log"),
+            file:write_file(CrashLog, []),
+
+            error_logger:tty(false),
+            application:load(lager),
+            application:set_env(lager, handlers, [{lager_test_backend, info}]),
+            application:set_env(lager, error_logger_redirect, true),
+            application:unset_env(lager, crash_log),
+            lager:start(),
+            timer:sleep(100),
+            lager_test_backend:flush(),
+            CrashLog
         end,
-        [
+        fun(CrashLog) ->
+            case whereis(lager_crash_log) of
+                P when is_pid(P) ->
+                    exit(P, kill);
+                _ ->
+                    ok
+            end,
+            application:stop(lager),
+            application:stop(goldrush),
+            lager_util:delete_test_dir(filename:dirname(CrashLog)),
+            error_logger:tty(true)
+        end, [
+        fun(CrashLog) ->
             {"under normal circumstances, file should be opened",
-                fun() ->
-                        {ok, _} = ?MODULE:start_link("crash_test.log", 65535, 0, undefined, 0),
-                        _ = gen_event:which_handlers(error_logger),
-                        sync_error_logger:error_msg("Test message\n"),
-                        {ok, Bin} = file:read_file("crash_test.log"),
-                        ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}]))
-                end
-            },
+            fun() ->
+                {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0),
+                _ = gen_event:which_handlers(error_logger),
+                sync_error_logger:error_msg("Test message\n"),
+                {ok, Bin} = file:read_file(CrashLog),
+                ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}]))
+            end}
+        end,
+        fun(CrashLog) ->
             {"file can't be opened on startup triggers an error message",
-                fun() ->
-                        {ok, FInfo} = file:read_file_info("crash_test.log"),
-                        file:write_file_info("crash_test.log", FInfo#file_info{mode = 0}),
-                        {ok, _} = ?MODULE:start_link("crash_test.log", 65535, 0, undefined, 0),
-                        ?assertEqual(1, lager_test_backend:count()),
-                        {_Level, _Time, Message,_Metadata} = lager_test_backend:pop(),
-                        ?assertEqual("Failed to open crash log file crash_test.log with error: permission denied", lists:flatten(Message))
-                end
-            },
+            fun() ->
+                {ok, FInfo} = file:read_file_info(CrashLog),
+                file:write_file_info(CrashLog, FInfo#file_info{mode = 0}),
+                {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0),
+                ?assertEqual(1, lager_test_backend:count()),
+                {_Level, _Time, Message,_Metadata} = lager_test_backend:pop(),
+                ?assertEqual(
+                    "Failed to open crash log file " ++ CrashLog ++ " with error: permission denied",
+                    lists:flatten(Message))
+            end}
+        end,
+        fun(CrashLog) ->
             {"file that becomes unavailable at runtime should trigger an error message",
-                fun() ->
-                        {ok, _} = ?MODULE:start_link("crash_test.log", 65535, 0, undefined, 0),
-                        ?assertEqual(0, lager_test_backend:count()),
-                        sync_error_logger:error_msg("Test message\n"),
-                        _ = gen_event:which_handlers(error_logger),
-                        ?assertEqual(1, lager_test_backend:count()),
-                        file:delete("crash_test.log"),
-                        file:write_file("crash_test.log", ""),
-                        {ok, FInfo} = file:read_file_info("crash_test.log"),
-                        file:write_file_info("crash_test.log", FInfo#file_info{mode = 0}),
-                        sync_error_logger:error_msg("Test message\n"),
-                        _ = gen_event:which_handlers(error_logger),
-                        ?assertEqual(3, lager_test_backend:count()),
-                        lager_test_backend:pop(),
-                        {_Level, _Time, Message,_Metadata} = lager_test_backend:pop(),
-                        ?assertEqual("Failed to reopen crash log crash_test.log with error: permission denied", lists:flatten(Message))
-                end
-            },
+            fun() ->
+                {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0),
+                ?assertEqual(0, lager_test_backend:count()),
+                sync_error_logger:error_msg("Test message\n"),
+                _ = gen_event:which_handlers(error_logger),
+                ?assertEqual(1, lager_test_backend:count()),
+                file:delete(CrashLog),
+                file:write_file(CrashLog, ""),
+                {ok, FInfo} = file:read_file_info(CrashLog),
+                file:write_file_info(CrashLog, FInfo#file_info{mode = 0}),
+                sync_error_logger:error_msg("Test message\n"),
+                _ = gen_event:which_handlers(error_logger),
+                ?assertEqual(3, lager_test_backend:count()),
+                lager_test_backend:pop(),
+                {_Level, _Time, Message,_Metadata} = lager_test_backend:pop(),
+                ?assertEqual(
+                    "Failed to reopen crash log " ++ CrashLog ++ " with error: permission denied",
+                    lists:flatten(Message))
+            end}
+        end,
+        fun(CrashLog) ->
             {"unavailable files that are fixed at runtime should start having log messages written",
-                fun() ->
-                        {ok, FInfo} = file:read_file_info("crash_test.log"),
-                        OldPerms = FInfo#file_info.mode,
-                        file:write_file_info("crash_test.log", FInfo#file_info{mode = 0}),
-                        {ok, _} = ?MODULE:start_link("crash_test.log", 65535, 0, undefined, 0),
-                        ?assertEqual(1, lager_test_backend:count()),
-                        {_Level, _Time, Message,_Metadata} = lager_test_backend:pop(),
-                        ?assertEqual("Failed to open crash log file crash_test.log with error: permission denied", lists:flatten(Message)),
-                        file:write_file_info("crash_test.log", FInfo#file_info{mode = OldPerms}),
-                        sync_error_logger:error_msg("Test message~n"),
-                        _ = gen_event:which_handlers(error_logger),
-                        {ok, Bin} = file:read_file("crash_test.log"),
-                        ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}]))
-                end
-            },
+            fun() ->
+                {ok, FInfo} = file:read_file_info(CrashLog),
+                OldPerms = FInfo#file_info.mode,
+                file:write_file_info(CrashLog, FInfo#file_info{mode = 0}),
+                {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0),
+                ?assertEqual(1, lager_test_backend:count()),
+                {_Level, _Time, Message,_Metadata} = lager_test_backend:pop(),
+                ?assertEqual(
+                    "Failed to open crash log file " ++ CrashLog ++ " with error: permission denied",
+                    lists:flatten(Message)),
+                file:write_file_info(CrashLog, FInfo#file_info{mode = OldPerms}),
+                sync_error_logger:error_msg("Test message~n"),
+                _ = gen_event:which_handlers(error_logger),
+                {ok, Bin} = file:read_file(CrashLog),
+                ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}]))
+            end}
+        end,
+        fun(CrashLog) ->
             {"external logfile rotation/deletion should be handled",
-                fun() ->
-                        {ok, _} = ?MODULE:start_link("crash_test.log", 65535, 0, undefined, 0),
-                        ?assertEqual(0, lager_test_backend:count()),
-                        sync_error_logger:error_msg("Test message~n"),
-                        _ = gen_event:which_handlers(error_logger),
-                        {ok, Bin} = file:read_file("crash_test.log"),
-                        ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}])),
-                        file:delete("crash_test.log"),
-                        file:write_file("crash_test.log", ""),
-                        sync_error_logger:error_msg("Test message1~n"),
-                        _ = gen_event:which_handlers(error_logger),
-                        {ok, Bin1} = file:read_file("crash_test.log"),
-                        ?assertMatch([_, "Test message1\n"], re:split(Bin1, "\n", [{return, list}, {parts, 2}])),
-                        file:rename("crash_test.log", "crash_test.log.0"),
-                        sync_error_logger:error_msg("Test message2~n"),
-                        _ = gen_event:which_handlers(error_logger),
-                        {ok, Bin2} = file:read_file("crash_test.log"),
-                        ?assertMatch([_, "Test message2\n"], re:split(Bin2, "\n", [{return, list}, {parts, 2}]))
-                end
-            }
-        ]
-    }.
+            fun() ->
+                {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0),
+                ?assertEqual(0, lager_test_backend:count()),
+                sync_error_logger:error_msg("Test message~n"),
+                _ = gen_event:which_handlers(error_logger),
+                {ok, Bin} = file:read_file(CrashLog),
+                ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}])),
+                file:delete(CrashLog),
+                file:write_file(CrashLog, ""),
+                sync_error_logger:error_msg("Test message1~n"),
+                _ = gen_event:which_handlers(error_logger),
+                {ok, Bin1} = file:read_file(CrashLog),
+                ?assertMatch([_, "Test message1\n"], re:split(Bin1, "\n", [{return, list}, {parts, 2}])),
+                file:rename(CrashLog, CrashLog ++ ".0"),
+                sync_error_logger:error_msg("Test message2~n"),
+                _ = gen_event:which_handlers(error_logger),
+                {ok, Bin2} = file:read_file(CrashLog),
+                ?assertMatch([_, "Test message2\n"], re:split(Bin2, "\n", [{return, list}, {parts, 2}]))
+            end}
+        end
+    ]}.
 
 -endif.
 

src/lager_util.erl

@@ -1,4 +1,6 @@
-%% Copyright (c) 2011-2012 Basho Technologies, Inc.  All Rights Reserved.
+%% -------------------------------------------------------------------
+%%
+%% Copyright (c) 2011-2017 Basho Technologies, Inc.
 %%
 %% This file is provided to you under the Apache License,
 %% Version 2.0 (the "License"); you may not use this file
@@ -13,6 +15,8 @@
 %% KIND, either express or implied.  See the License for the
 %% specific language governing permissions and limitations
 %% under the License.
+%%
+%% -------------------------------------------------------------------
 
 -module(lager_util).
 
@@ -26,6 +30,7 @@
         trace_filter/1, trace_filter/2, expand_path/1, check_hwm/1, make_internal_sink_name/1]).
 
 -ifdef(TEST).
+-export([create_test_dir/0, delete_test_dir/1]).
 -include_lib("eunit/include/eunit.hrl").
 -endif.
 
@@ -368,7 +373,7 @@ calculate_next_rotation([{date, Date}|T], {{Year, Month, Day}, _} = Now) ->
 trace_filter(Query) ->
     trace_filter(?DEFAULT_TRACER, Query).
 
-%% TODO: Support multiple trace modules 
+%% TODO: Support multiple trace modules
 %-spec trace_filter(Module :: atom(), Query :: 'none' | [tuple()]) -> {ok, any()}.
 trace_filter(Module, Query) when Query == none; Query == [] ->
     {ok, _} = glc:compile(Module, glc:null(false));
@@ -401,7 +406,7 @@ validate_trace(_) ->
 validate_trace_filter(Filter) when is_tuple(Filter), is_atom(element(1, Filter)) =:= false ->
     false;
 validate_trace_filter(Filter) ->
-        case lists:all(fun({Key, '*'}) when is_atom(Key) -> true; 
+        case lists:all(fun({Key, '*'}) when is_atom(Key) -> true;
                           ({Key, '!'}) when is_atom(Key) -> true;
                           ({Key, _Value})      when is_atom(Key) -> true;
                           ({Key, '=', _Value}) when is_atom(Key) -> true;
@@ -414,16 +419,16 @@ validate_trace_filter(Filter) ->
                 false
         end.
 
-trace_all(Query) -> 
+trace_all(Query) ->
 	glc:all(trace_acc(Query)).
 
-trace_any(Query) -> 
+trace_any(Query) ->
 	glc:any(Query).
 
 trace_acc(Query) ->
     trace_acc(Query, []).
 
-trace_acc([], Acc) -> 
+trace_acc([], Acc) ->
 	lists:reverse(Acc);
 trace_acc([{Key, '*'}|T], Acc) ->
 	trace_acc(T, [glc:wc(Key)|Acc]);
@@ -437,7 +442,7 @@ trace_acc([{Key, '>', Val}|T], Acc) ->
 	trace_acc(T, [glc:gt(Key, Val)|Acc]);
 trace_acc([{Key, '<', Val}|T], Acc) ->
 	trace_acc(T, [glc:lt(Key, Val)|Acc]).
-	
+
 
 check_traces(_, _,  [], Acc) ->
     lists:flatten(Acc);
@@ -614,49 +619,52 @@ rotation_calculation_test() ->
 
     ?assertMatch({{2000, 1, 7}, {16, 0, 0}},
         calculate_next_rotation([{day, 5}, {hour, 16}], {{2000, 1, 3}, {17, 34, 43}})),
-    
+
     ?assertMatch({{2000, 1, 3}, {16, 0, 0}},
         calculate_next_rotation([{day, 1}, {hour, 16}], {{1999, 12, 28}, {17, 34, 43}})),
     ok.
 
 rotate_file_test() ->
-    file:delete("rotation.log"),
-    [file:delete(["rotation.log.", integer_to_list(N)]) || N <- lists:seq(0, 9)],
-    [begin
-                file:write_file("rotation.log", integer_to_list(N)),
-                Count = case N > 10 of
-                    true -> 10;
-                    _ -> N
-                end,
-                [begin
-                            FileName = ["rotation.log.", integer_to_list(M)],
-                            ?assert(filelib:is_regular(FileName)),
-                            %% check the expected value is in the file
-                            Number = list_to_binary(integer_to_list(N - M - 1)),
-                            ?assertEqual({ok, Number}, file:read_file(FileName))
-                end
-                || M <- lists:seq(0, Count-1)],
-                rotate_logfile("rotation.log", 10)
-    end || N <- lists:seq(0, 20)].
+    RotCount = 10,
+    TestDir = create_test_dir(),
+    TestLog = filename:join(TestDir, "rotation.log"),
+    Outer = fun(N) ->
+        ?assertEqual(ok, file:write_file(TestLog, erlang:integer_to_list(N))),
+        Inner = fun(M) ->
+            File = lists:flatten([TestLog, $., erlang:integer_to_list(M)]),
+            ?assert(filelib:is_regular(File)),
+            %% check the expected value is in the file
+            Number = erlang:list_to_binary(integer_to_list(N - M - 1)),
+            ?assertEqual({ok, Number}, file:read_file(File))
+        end,
+        Count = erlang:min(N, RotCount),
+        % The first time through, Count == 0, so the sequence is empty,
+        % effectively skipping the inner loop so a rotation can occur that
+        % creates the file that Inner looks for.
+        % Don't shoot the messenger, it was worse before this refactoring.
+        lists:foreach(Inner, lists:seq(0, Count-1)),
+        rotate_logfile(TestLog, RotCount)
+    end,
+    lists:foreach(Outer, lists:seq(0, (RotCount * 2))),
+    delete_test_dir(TestDir).
 
 rotate_file_fail_test() ->
-    %% make sure the directory exists
-    ?assertEqual(ok, filelib:ensure_dir("rotation/rotation.log")),
-    %% fix the permissions on it
-    os:cmd("chown -R u+rwx rotation"),
-    %% delete any old files
-    [ok = file:delete(F) || F <- filelib:wildcard("rotation/*")],
+    TestDir = create_test_dir(),
+    TestLog = filename:join(TestDir, "rotation.log"),
+    %% set known permissions on it
+    os:cmd("chmod -R u+rwx " ++ TestDir),
     %% write a file
-    file:write_file("rotation/rotation.log", "hello"),
+    file:write_file(TestLog, "hello"),
     %% hose up the permissions
-    os:cmd("chown u-w rotation"),
-    ?assertMatch({error, _}, rotate_logfile("rotation.log", 10)),
-    ?assert(filelib:is_regular("rotation/rotation.log")),
-    os:cmd("chown u+w rotation"),
-    ?assertMatch(ok, rotate_logfile("rotation/rotation.log", 10)),
-    ?assert(filelib:is_regular("rotation/rotation.log.0")),
-    ?assertEqual(false, filelib:is_regular("rotation/rotation.log")),
-    ok.
+    os:cmd("chmod u-w " ++ TestDir),
+    ?assertMatch({error, _}, rotate_logfile(TestLog, 10)),
+    ?assert(filelib:is_regular(TestLog)),
+    %% fix the permissions
+    os:cmd("chmod u+w " ++ TestDir),
+    ?assertMatch(ok, rotate_logfile(TestLog, 10)),
+    ?assert(filelib:is_regular(TestLog ++ ".0")),
+    ?assertEqual(false, filelib:is_regular(TestLog)),
+    delete_test_dir(TestDir).
 
 check_trace_test() ->
     lager:start(),
@@ -803,4 +811,32 @@ sink_name_test_() ->
         ?_assertEqual(audit_lager_event, make_internal_sink_name(audit))
     ].
 
+create_test_dir() ->
+    Dir = filename:join(["/tmp", "lager_test",
+        erlang:integer_to_list(erlang:phash2(os:timestamp()))]),
+    ?assertEqual(ok, filelib:ensure_dir(Dir)),
+    case file:make_dir(Dir) of
+        ok ->
+            Dir;
+        Err ->
+            ?assertEqual({error, eexist}, Err),
+            create_test_dir()
+    end.
+
+delete_test_dir(Dir) ->
+    ListRet = file:list_dir_all(Dir),
+    ?assertMatch({ok, _}, ListRet),
+    {_, Entries} = ListRet,
+    lists:foreach(
+        fun(Entry) ->
+            FsElem = filename:join(Dir, Entry),
+            case filelib:is_dir(FsElem) of
+                true ->
+                    delete_test_dir(FsElem);
+                _ ->
+                    ?assertEqual(ok, file:delete(FsElem))
+            end
+        end, Entries),
+    ?assertEqual(ok, file:del_dir(Dir)).
+
 -endif.

test/lager_rotate.erl

@@ -1,3 +1,23 @@
+%% -------------------------------------------------------------------
+%%
+%% Copyright (c) 2016-2017 Basho Technologies, Inc.
+%%
+%% This file is provided to you under the Apache License,
+%% Version 2.0 (the "License"); you may not use this file
+%% except in compliance with the License.  You may obtain
+%% a copy of the License at
+%%
+%%   http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing,
+%% software distributed under the License is distributed on an
+%% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+%% KIND, either express or implied.  See the License for the
+%% specific language governing permissions and limitations
+%% under the License.
+%%
+%% -------------------------------------------------------------------
+
 -module(lager_rotate).
 
 -compile(export_all).
@@ -6,54 +26,71 @@
 -include_lib("eunit/include/eunit.hrl").
 -endif.
 
+-record(state, {
+    dir     :: string(),
+    log1    :: string(),
+    log1r   :: string(),
+    log2    :: string(),
+    log2r   :: string(),
+    sink    :: string(),
+    sinkr   :: string()
+}).
 
 rotate_test_() ->
     {foreach,
         fun() ->
-                file:write_file("test1.log", ""),
-                file:write_file("test2.log", ""),
-                file:write_file("test3.log", ""),
-                file:delete("test1.log.0"),
-                file:delete("test2.log.0"),
-                file:delete("test3.log.0"),
-                error_logger:tty(false),
-                application:load(lager),
-                application:set_env(lager, handlers, 
-                    [{lager_file_backend, [{file, "test1.log"}, {level, info}]},
-                     {lager_file_backend, [{file, "test2.log"}, {level, info}]}]),
-                application:set_env(lager, extra_sinks,
-                    [{sink_event, 
-                        [{handlers, 
-                            [{lager_file_backend, [{file, "test3.log"}, {level, info}]}]}
-                        ]}]),
-                application:set_env(lager, error_logger_redirect, false),
-                application:set_env(lager, async_threshold, undefined),
-                lager:start()
-        end,
-        fun(_) ->
-                file:delete("test1.log"),
-                file:delete("test2.log"),
-                file:delete("test3.log"),
-                file:delete("test1.log.0"),
-                file:delete("test2.log.0"),
-                file:delete("test3.log.0"),
-                application:stop(lager),
-                application:stop(goldrush),
-                error_logger:tty(true)
+            Dir = lager_util:create_test_dir(),
+            Log1 = filename:join(Dir, "test1.log"),
+            Log2 = filename:join(Dir, "test2.log"),
+            Sink = filename:join(Dir, "sink.log"),
+            State = #state{
+                dir     = Dir,
+                log1    = Log1,
+                log1r   = Log1 ++ ".0",
+                log2    = Log2,
+                log2r   = Log2 ++ ".0",
+                sink    = Sink,
+                sinkr   = Sink ++ ".0"
+            },
+            file:write_file(Log1, []),
+            file:write_file(Log2, []),
+            file:write_file(Sink, []),
+
+            error_logger:tty(false),
+            application:load(lager),
+            application:set_env(lager, handlers, [
+                {lager_file_backend, [{file, Log1}, {level, info}]},
+                {lager_file_backend, [{file, Log2}, {level, info}]} ]),
+            application:set_env(lager, extra_sinks, [
+                {sink_event,
+                    [{handlers,
+                        [{lager_file_backend, [{file, Sink}, {level, info}]}]}
+                    ]}]),
+            application:set_env(lager, error_logger_redirect, false),
+            application:set_env(lager, async_threshold, undefined),
+            lager:start(),
+            State
         end,
-        [{"Rotate single file",
+        fun(#state{dir = Dir}) ->
+            application:stop(lager),
+            application:stop(goldrush),
+            lager_util:delete_test_dir(Dir),
+            error_logger:tty(true)
+        end, [
+        fun(State) ->
+            {"Rotate single file",
             fun() ->
                 lager:log(error, self(), "Test message 1"),
                 lager:log(sink_event, error, self(), "Sink test message 1", []),
-                lager:rotate_handler({lager_file_backend, "test1.log"}),
-                ok = wait_until(fun() -> filelib:is_regular("test1.log.0") end, 10),
+                lager:rotate_handler({lager_file_backend, State#state.log1}),
+                ok = wait_until(fun() -> filelib:is_regular(State#state.log1r) end, 10),
                 lager:log(error, self(), "Test message 2"),
                 lager:log(sink_event, error, self(), "Sink test message 2", []),
-                
-                {ok, File1} = file:read_file("test1.log"),
-                {ok, File2} = file:read_file("test2.log"),
-                {ok, SinkFile} = file:read_file("test3.log"),
-                {ok, File1Old} = file:read_file("test1.log.0"),
+
+                {ok, File1} = file:read_file(State#state.log1),
+                {ok, File2} = file:read_file(State#state.log2),
+                {ok, SinkFile} = file:read_file(State#state.sink),
+                {ok, File1Old} = file:read_file(State#state.log1r),
 
                 have_no_log(File1, <<"Test message 1">>),
                 have_log(File1, <<"Test message 2">>),
@@ -66,19 +103,21 @@ rotate_test_() ->
 
                 have_log(SinkFile, <<"Sink test message 1">>),
                 have_log(SinkFile, <<"Sink test message 2">>)
-            end},
-         {"Rotate sink",
+            end}
+        end,
+        fun(State) ->
+            {"Rotate sink",
             fun() ->
                 lager:log(error, self(), "Test message 1"),
                 lager:log(sink_event, error, self(), "Sink test message 1", []),
                 lager:rotate_sink(sink_event),
-                ok = wait_until(fun() -> filelib:is_regular("test3.log.0") end, 10),
+                ok = wait_until(fun() -> filelib:is_regular(State#state.sinkr) end, 10),
                 lager:log(error, self(), "Test message 2"),
                 lager:log(sink_event, error, self(), "Sink test message 2", []),
-                {ok, File1} = file:read_file("test1.log"),
-                {ok, File2} = file:read_file("test2.log"),
-                {ok, SinkFile} = file:read_file("test3.log"),
-                {ok, SinkFileOld} = file:read_file("test3.log.0"),
+                {ok, File1} = file:read_file(State#state.log1),
+                {ok, File2} = file:read_file(State#state.log2),
+                {ok, SinkFile} = file:read_file(State#state.sink),
+                {ok, SinkFileOld} = file:read_file(State#state.sinkr),
 
                 have_log(File1, <<"Test message 1">>),
                 have_log(File1, <<"Test message 2">>),
@@ -91,21 +130,23 @@ rotate_test_() ->
 
                 have_no_log(SinkFile, <<"Sink test message 1">>),
                 have_log(SinkFile, <<"Sink test message 2">>)
-            end},
-         {"Rotate all",
+            end}
+        end,
+        fun(State) ->
+            {"Rotate all",
             fun() ->
                 lager:log(error, self(), "Test message 1"),
                 lager:log(sink_event, error, self(), "Sink test message 1", []),
                 lager:rotate_all(),
-                ok = wait_until(fun() -> filelib:is_regular("test3.log.0") end, 10),
+                ok = wait_until(fun() -> filelib:is_regular(State#state.sinkr) end, 10),
                 lager:log(error, self(), "Test message 2"),
                 lager:log(sink_event, error, self(), "Sink test message 2", []),
-                {ok, File1} = file:read_file("test1.log"),
-                {ok, File2} = file:read_file("test2.log"),
-                {ok, SinkFile} = file:read_file("test3.log"),
-                {ok, File1Old} = file:read_file("test1.log.0"),
-                {ok, File2Old} = file:read_file("test2.log.0"),
-                {ok, SinkFileOld} = file:read_file("test3.log.0"),
+                {ok, File1} = file:read_file(State#state.log1),
+                {ok, File2} = file:read_file(State#state.log2),
+                {ok, SinkFile} = file:read_file(State#state.sink),
+                {ok, File1Old} = file:read_file(State#state.log1r),
+                {ok, File2Old} = file:read_file(State#state.log2r),
+                {ok, SinkFileOld} = file:read_file(State#state.sinkr),
 
                 have_no_log(File1, <<"Test message 1">>),
                 have_log(File1, <<"Test message 2">>),
@@ -125,7 +166,9 @@ rotate_test_() ->
                 have_log(File2Old, <<"Test message 1">>),
                 have_no_log(File2Old, <<"Test message 2">>)
 
-            end}]}.
+            end}
+        end
+    ]}.
 
 have_log(Data, Log) ->
     {_,_} = binary:match(Data, Log).