Don't run delegate tests if there's no second node, remove use of closures since the coverage analyser breaks them.

1 files changed, 107 insertions, 73 deletions

diff --git a/src/rabbit_tests.erl b/src/rabbit_tests.erl
index b5efd2d4..ed7b2e60 100644
--- a/src/rabbit_tests.erl
+++ b/src/rabbit_tests.erl
@@ -61,9 +61,37 @@ all_tests() ->
     passed = test_cluster_management(),
     passed = test_user_management(),
     passed = test_server_status(),
-    passed = test_hooks(),
-    passed = test_delegates_async(),
-    passed = test_delegates_sync(),
+    passed = maybe_run_cluster_dependent_tests(),
+    passed.
+
+
+maybe_run_cluster_dependent_tests() ->
+    SecondaryNode = rabbit_misc:makenode("hare"),
+
+    case net_adm:ping(SecondaryNode) of
+        pong -> passed = run_cluster_dependent_tests(SecondaryNode);
+        pang -> io:format("Skipping cluster dependent tests with node ~p~n",
+                          [SecondaryNode])
+    end,
+    passed.
+
+run_cluster_dependent_tests(SecondaryNode) ->
+    SecondaryNodeS = atom_to_list(SecondaryNode),
+
+    ok = control_action(stop_app, []),
+    ok = control_action(reset, []),
+    ok = control_action(cluster, [SecondaryNodeS]),
+    ok = control_action(start_app, []),
+
+    io:format("Running cluster dependent tests with node ~p~n", [SecondaryNode]),
+    passed = test_delegates_async(SecondaryNode),
+    passed = test_delegates_sync(SecondaryNode),
+
+    ok = control_action(stop_app, []),
+    ok = control_action(reset, []),
+    ok = control_action(cluster, []),
+    ok = control_action(start_app, []),
+
     passed.
 
 test_priority_queue() ->
@@ -813,91 +841,48 @@ test_hooks() ->
     end,
     passed.
 
-test_delegates_async() ->
-    SecondaryNode = rabbit_misc:makenode("hare"),
-
+test_delegates_async(SecondaryNode) ->
     Self = self(),
     Sender = fun(Pid) -> Pid ! {invoked, Self} end,
 
-    Receiver = fun() ->
-        receive
-            {invoked, Pid} ->
-                Pid ! response,
-                ok
-        after 100 ->
-            io:format("Async message not sent~n"),
-            throw(timeout)
-        end
-    end,
-
-    ok = delegate:cast(spawn(Receiver), Sender),
-    ok = delegate:cast(spawn(SecondaryNode, Receiver), Sender),
-    await_response(2),
+    ok = delegate:cast(spawn(fun async_responder/0), Sender),
+    ok = delegate:cast(spawn(SecondaryNode, fun async_responder/0), Sender),
+    async_await_response(2),
 
-    LocalPids = [spawn(Receiver) || _ <- lists:seq(1,10)],
-    RemotePids = [spawn(SecondaryNode, Receiver) || _ <- lists:seq(1,10)],
+    LocalPids = [spawn(fun async_responder/0) || _ <- lists:seq(1,10)],
+    RemotePids =
+        [spawn(SecondaryNode, fun async_responder/0) || _ <- lists:seq(1,10)],
     ok = delegate:cast(LocalPids ++ RemotePids, Sender),
-    await_response(20),
+    async_await_response(20),
 
     passed.
 
-await_response(0) ->
-    ok;
-
-await_response(Count) ->
-    receive
-        response -> ok,
-        await_response(Count - 1)
-    after 100 ->
-        io:format("Async reply not received~n"),
-        throw(timeout)
-    end.
-
-test_delegates_sync() ->
-    SecondaryNode = rabbit_misc:makenode("hare"),
-    {ok, "foo"} = delegate:call(node(), fun() -> "foo" end),
-    {ok, "bar"} = delegate:call(SecondaryNode, fun() -> "bar" end),
-
-    Sender = fun(Pid) ->
-        gen_server2:call(Pid, invoked)
-    end,
-
-    Responder = fun() ->
-        receive
-            {'$gen_call', From, invoked} ->
-                gen_server2:reply(From, response)
-        after 100 ->
-            io:format("Sync hook not invoked~n"),
-            throw(timeout)
-        end
-    end,
+test_delegates_sync(SecondaryNode) ->
+    {ok, "foo"} = delegate:call(node(), fun sync_simple_result/0),
+    {ok, "foo"} = delegate:call(SecondaryNode, fun sync_simple_result/0),
 
-    BadResponder = fun() ->
-        receive
-            {'$gen_call', _From, invoked} ->
-                throw(exception)
-        after 100 ->
-            io:format("Crashing sync hook not invoked~n"),
-            throw(timeout)
-        end
-    end,
+    {ok, response} = delegate:call(spawn(fun sync_responder/0),
+                                   fun sync_sender/1),
+    {ok, response} = delegate:call(spawn(SecondaryNode, fun sync_responder/0),
+                                   fun sync_sender/1),
 
-    {ok, response} = delegate:call(spawn(Responder), Sender),
-    {ok, response} = delegate:call(spawn(SecondaryNode, Responder), Sender),
+    {error, _} = delegate:call(spawn(fun sync_bad_responder/0),
+                               fun sync_sender/1),
+    {error, _} = delegate:call(spawn(SecondaryNode, fun sync_bad_responder/0),
+                               fun sync_sender/1),
 
-    {error, _} = delegate:call(spawn(BadResponder), Sender),
-    {error, _} = delegate:call(spawn(SecondaryNode, BadResponder), Sender),
+    LocalGoodPids = [spawn(fun sync_responder/0) || _ <- lists:seq(1,2)],
+    RemoteGoodPids = [spawn(fun sync_responder/0) || _ <- lists:seq(1,2)],
+    LocalBadPids =
+        [spawn(SecondaryNode, fun sync_bad_responder/0) || _ <- lists:seq(1,2)],
+    RemoteBadPids =
+        [spawn(SecondaryNode, fun sync_bad_responder/0) || _ <- lists:seq(1,2)],
 
-    LocalGoodPids = [spawn(Responder) || _ <- lists:seq(1,2)],
-    RemoteGoodPids = [spawn(Responder) || _ <- lists:seq(1,2)],
-    LocalBadPids = [spawn(SecondaryNode, BadResponder) || _ <- lists:seq(1,2)],
-    RemoteBadPids = [spawn(SecondaryNode, BadResponder) || _ <- lists:seq(1,2)],
-
-    GoodRes = delegate:call(LocalGoodPids ++ RemoteGoodPids, Sender),
+    GoodRes = delegate:call(LocalGoodPids ++ RemoteGoodPids, fun sync_sender/1),
     [{ok, response, _}, {ok, response, _},
      {ok, response, _}, {ok, response, _}] = GoodRes,
 
-    BadRes = delegate:call(LocalBadPids ++ RemoteBadPids, Sender),
+    BadRes = delegate:call(LocalBadPids ++ RemoteBadPids, fun sync_sender/1),
     [{error, _, _}, {error, _, _},
      {error, _, _}, {error, _, _}] = BadRes,
 
@@ -912,6 +897,55 @@ test_delegates_sync() ->
 
     passed.
 
+% Unfortunately we need these to be top level functions, not closures as
+% something about them being closures trips up execution under the coverage
+% analyser in clustered mode since the analyser only recompiles on one node and
+% there appears to be some binary-level incompatibility around closures.
+
+async_responder() ->
+    receive
+        {invoked, Pid} ->
+            Pid ! response,
+            ok
+    after 100 ->
+        io:format("Async message not sent~n"),
+        throw(timeout)
+    end.
+
+async_await_response(0) ->
+    ok;
+
+async_await_response(Count) ->
+    receive
+        response -> ok,
+        async_await_response(Count - 1)
+    after 100 ->
+        io:format("Async reply not received~n"),
+        throw(timeout)
+    end.
+
+sync_simple_result() -> "foo".
+
+sync_sender(Pid) ->
+    gen_server2:call(Pid, invoked).
+
+sync_responder() ->
+    receive
+        {'$gen_call', From, invoked} ->
+            gen_server2:reply(From, response)
+    after 100 ->
+        io:format("Sync hook not invoked~n"),
+        throw(timeout)
+    end.
+
+sync_bad_responder() ->
+    receive
+        {'$gen_call', _From, invoked} ->
+            throw(exception)
+    after 100 ->
+        io:format("Crashing sync hook not invoked~n"),
+        throw(timeout)
+    end.
 
 %---------------------------------------------------------------------