Merge pull request #11547 from rabbitmq/speed-up-rabbit-tests

Speed up rabbit tests suites

Author: michaelklishin

deps/rabbit/.DS_Store

@@ -660,7 +660,7 @@ rabbitmq_integration_suite(
     additional_beam = [
         ":test_queue_utils_beam",
     ],
-    shard_count = 5,
+    shard_count = 3,
 )
 
 rabbitmq_integration_suite(
@@ -814,7 +814,7 @@ rabbitmq_integration_suite(
     additional_beam = [
         ":test_queue_utils_beam",
     ],
-    shard_count = 22,
+    shard_count = 19,
     deps = [
         "@proper//:erlang_app",
     ],

deps/rabbit/BUILD.bazel

@@ -10,10 +10,11 @@
 -include_lib("amqp_client/include/amqp_client.hrl").
 -include_lib("eunit/include/eunit.hrl").
 
+-compile(nowarn_export_all).
 -compile(export_all).
 
--define(CONSUMER_TIMEOUT, 3000).
--define(RECEIVE_TIMEOUT, 5000).
+-define(CONSUMER_TIMEOUT, 2000).
+-define(RECEIVE_TIMEOUT, ?CONSUMER_TIMEOUT * 2).
 
 -define(GROUP_CONFIG,
         #{global_consumer_timeout => [{rabbit, [{consumer_timeout, ?CONSUMER_TIMEOUT}]},
@@ -84,8 +85,9 @@ init_per_group(Group, Config0) ->
             GroupConfig = maps:get(Group, ?GROUP_CONFIG),
             ClusterSize = 3,
             Config = rabbit_ct_helpers:merge_app_env(
-                       Config0, {rabbit, [{channel_tick_interval, 1000},
-                                          {quorum_tick_interval, 1000}] ++ ?config(rabbit, GroupConfig)}),
+                       Config0, {rabbit, [{channel_tick_interval, 256},
+                                          {quorum_tick_interval, 256}] ++
+                                 ?config(rabbit, GroupConfig)}),
             Config1 = rabbit_ct_helpers:set_config(
                         Config, [ {rmq_nodename_suffix, Group},
                                   {rmq_nodes_count, ClusterSize}

deps/rabbit/test/consumer_timeout_SUITE.erl

@@ -78,7 +78,8 @@ groups() ->
                                dead_letter_routing_key_cycle_max_length,
                                dead_letter_headers_reason_maxlen,
                                %% tested separately in rabbit_fifo_dlx_integration_SUITE
-                               dead_letter_missing_exchange
+                               dead_letter_missing_exchange,
+                               dead_letter_routing_key_cycle_ttl
                               ]}
                             ]
        },
@@ -95,9 +96,14 @@ suite() ->
 %% -------------------------------------------------------------------
 
 init_per_suite(Config0) ->
+    Tick = 256,
     rabbit_ct_helpers:log_environment(),
     Config = rabbit_ct_helpers:merge_app_env(
-               Config0, {rabbit, [{dead_letter_worker_publisher_confirm_timeout, 2000}]}),
+               Config0, {rabbit, [{dead_letter_worker_publisher_confirm_timeout, 2000},
+                                  {collect_statistics_interval, Tick},
+                                  {channel_tick_interval, Tick},
+                                  {quorum_tick_interval, Tick},
+                                  {stream_tick_interval, Tick}]}),
     rabbit_ct_helpers:run_setup_steps(Config).
 
 end_per_suite(Config) ->

deps/rabbit/test/dead_lettering_SUITE.erl

@@ -27,13 +27,7 @@ groups() ->
       {clustered, [], [
           {cluster_size_3, [], [
               vhost_deletion,
-              quorum_unaffected_after_vhost_failure
-            ]},
-          {cluster_size_5, [], [
-              %% Khepri does not work on a cluster in minority. Thus, to test these
-              %% specific cases with quorum queues in minority we need a bigger cluster.
-              %% 5-nodes RMQ and 3-nodes quorum queues allows to test the same test
-              %% cases than a 3-nodes mnesia cluster.
+              quorum_unaffected_after_vhost_failure,
               recover_follower_after_standalone_restart,
               force_delete_if_no_consensus,
               takeover_on_failure,
@@ -129,8 +123,11 @@ force_delete_if_no_consensus(Config) ->
     ACh = rabbit_ct_client_helpers:open_channel(Config, A),
     rabbit_ct_client_helpers:publish(ACh, QName, 10),
 
-    ok = rabbit_ct_broker_helpers:restart_node(Config, B),
-    ok = rabbit_ct_broker_helpers:stop_node(Config, A),
+    %% Delete a member on one node
+    ?assertEqual(ok,
+                 rpc:call(Server, rabbit_quorum_queue, delete_member,
+                          [<<"/">>, QName, B])),
+    %% stop another node
     ok = rabbit_ct_broker_helpers:stop_node(Config, C),
 
     BCh = rabbit_ct_client_helpers:open_channel(Config, B),
@@ -144,6 +141,7 @@ force_delete_if_no_consensus(Config) ->
     BCh2 = rabbit_ct_client_helpers:open_channel(Config, B),
     ?assertMatch(#'queue.delete_ok'{},
                  amqp_channel:call(BCh2, #'queue.delete'{queue = QName})),
+    ok = rabbit_ct_broker_helpers:restart_node(Config, C),
     ok.
 
 takeover_on_failure(Config) ->
@@ -222,56 +220,38 @@ quorum_unaffected_after_vhost_failure(Config) ->
        60000).
 
 recover_follower_after_standalone_restart(Config) ->
-    case rabbit_ct_helpers:is_mixed_versions() of
-      false ->
-            %% Tests that followers can be brought up standalone after forgetting the
-            %% rest of the cluster. Consensus won't be reached as there is only one node in the
-            %% new cluster.
-            [Server | _] = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
-            Ch = rabbit_ct_client_helpers:open_channel(Config, Server),
-
-            QName = ?config(queue_name, Config),
-            Args = ?config(queue_args, Config),
-            amqp_channel:call(Ch, #'queue.declare'{queue = QName,
-                                                   arguments = Args,
-                                                   durable = true
-                                                  }),
-
-            RaName = queue_utils:ra_name(QName),
-            {ok, [{_, A}, {_, B}, {_, C}], _} = ra:members({RaName, Server}),
-            Servers = [A, B, C],
-
-            rabbit_ct_client_helpers:publish(Ch, QName, 15),
-            rabbit_ct_client_helpers:close_channel(Ch),
-
-            Name = ra_name(QName),
-            wait_for_messages_ready(Servers, Name, 15),
-
-            rabbit_ct_broker_helpers:stop_node(Config, C),
-            rabbit_ct_broker_helpers:stop_node(Config, B),
-            rabbit_ct_broker_helpers:stop_node(Config, A),
-
-            %% Restart one follower
-            forget_cluster_node(Config, B, C),
-            forget_cluster_node(Config, B, A),
-
-            ok = rabbit_ct_broker_helpers:start_node(Config, B),
-            wait_for_messages_ready([B], Name, 15),
-            ok = rabbit_ct_broker_helpers:stop_node(Config, B),
-
-            %% Restart the other
-            forget_cluster_node(Config, C, B),
-            forget_cluster_node(Config, C, A),
-
-            ok = rabbit_ct_broker_helpers:start_node(Config, C),
-            wait_for_messages_ready([C], Name, 15),
-            ok = rabbit_ct_broker_helpers:stop_node(Config, C),
-            ok;
-        _ ->
-            {skip, "cannot be run in mixed mode"}
-    end.
+    %% Tests that quorum queues shrink when forget_cluster_node
+    %% operations are issues.
+    [Server | _] = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
+    Ch = rabbit_ct_client_helpers:open_channel(Config, Server),
+
+    QName = ?config(queue_name, Config),
+    Args = ?config(queue_args, Config),
+    amqp_channel:call(Ch, #'queue.declare'{queue = QName,
+                                           arguments = Args,
+                                           durable = true
+                                          }),
+
+    RaName = queue_utils:ra_name(QName),
+    {ok, [{_, A}, {_, B}, {_, C}], _} = ra:members({RaName, Server}),
+    Servers = [A, B, C],
+
+    Name = ra_name(QName),
+
+    rabbit_ct_client_helpers:publish(Ch, QName, 15),
+    wait_for_messages_ready(Servers, Name, 15),
+    rabbit_ct_client_helpers:close_channel(Ch),
+
+    %% Restart one follower
+    forget_cluster_node(Config, B, C),
+    wait_for_messages_ready([B], Name, 15),
+    forget_cluster_node(Config, B, A),
+    wait_for_messages_ready([B], Name, 15),
+
+    ok.
 
 %%----------------------------------------------------------------------------
 forget_cluster_node(Config, Node, NodeToRemove) ->
+    ok = rabbit_control_helper:command(stop_app, NodeToRemove),
     rabbit_ct_broker_helpers:rabbitmqctl(
-      Config, Node, ["forget_cluster_node", "--offline", NodeToRemove]).
+      Config, Node, ["forget_cluster_node", NodeToRemove]).

deps/rabbit/test/dynamic_qq_SUITE.erl

@@ -5,9 +5,9 @@
 %% Copyright (c) 2007-2024 Broadcom. All Rights Reserved. The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. All rights reserved.
 %%
 -module(metrics_SUITE).
+-compile(nowarn_export_all).
 -compile(export_all).
 
--include_lib("common_test/include/ct.hrl").
 -include_lib("proper/include/proper.hrl").
 -include_lib("eunit/include/eunit.hrl").
 -include_lib("amqp_client/include/amqp_client.hrl").
@@ -142,7 +142,12 @@ connection_metric_idemp(Config, {N, R}) ->
                                5000),
     Table2 = [ Pid || {Pid, _} <- read_table_rpc(Config, connection_coarse_metrics)],
     % refresh stats 'R' times
-    [[Pid ! emit_stats || Pid <- Table] || _ <- lists:seq(1, R)],
+    [[begin
+          Pid ! emit_stats
+      end|| Pid <- Table] || _ <- lists:seq(1, R)],
+    [begin
+         _ = gen_server:call(Pid, {info, [pid]})
+     end|| Pid <- Table],
     force_metric_gc(Config),
     TableAfter = [ Pid || {Pid, _} <- read_table_rpc(Config, connection_metrics)],
     TableAfter2 = [ Pid || {Pid, _} <- read_table_rpc(Config, connection_coarse_metrics)],
@@ -159,6 +164,9 @@ channel_metric_idemp(Config, {N, R}) ->
     Table2 = [ Pid || {Pid, _} <- read_table_rpc(Config, channel_process_metrics)],
     % refresh stats 'R' times
     [[Pid ! emit_stats || Pid <- Table] || _ <- lists:seq(1, R)],
+    [begin
+         _ = gen_server:call(Pid, {info, [pid]})
+     end|| Pid <- Table],
     force_metric_gc(Config),
     TableAfter = [ Pid || {Pid, _} <- read_table_rpc(Config, channel_metrics)],
     TableAfter2 = [ Pid || {Pid, _} <- read_table_rpc(Config, channel_process_metrics)],
@@ -182,7 +190,10 @@ queue_metric_idemp(Config, {N, R}) ->
     Table2 = [ Pid || {Pid, _, _} <- read_table_rpc(Config, queue_coarse_metrics)],
     % refresh stats 'R' times
     ChanTable = read_table_rpc(Config, channel_created),
-    [[Pid ! emit_stats || {Pid, _, _} <- ChanTable ] || _ <- lists:seq(1, R)],
+    [[begin
+          Pid ! emit_stats,
+         gen_server2:call(Pid, flush)
+      end|| {Pid, _, _} <- ChanTable ] || _ <- lists:seq(1, R)],
     force_metric_gc(Config),
     TableAfter = [ Pid || {Pid, _, _} <- read_table_rpc(Config,  queue_metrics)],
     TableAfter2 = [ Pid || {Pid, _, _} <- read_table_rpc(Config, queue_coarse_metrics)],
@@ -383,8 +394,13 @@ ensure_channel_queue_metrics_populated(Chan, Queue) ->
     {#'basic.get_ok'{}, #amqp_msg{}} = amqp_channel:call(Chan, Get).
 
 force_channel_stats(Config) ->
-    [ Pid ! emit_stats || {Pid, _} <- read_table_rpc(Config, channel_created) ],
-    timer:sleep(100).
+    [begin
+         Pid ! emit_stats,
+         gen_server2:call(Pid, flush)
+     end
+         || {Pid, _} <- read_table_rpc(Config, channel_created)
+         ],
+    ok.
 
 read_table_rpc(Config, Table) ->
     rabbit_ct_broker_helpers:rpc(Config, 0, ?MODULE, read_table, [Table]).
@@ -397,7 +413,6 @@ read_table(Table) ->
     ets:tab2list(Table).
 
 force_metric_gc(Config) ->
-    timer:sleep(300),
     rabbit_ct_broker_helpers:rpc(Config, 0, erlang, send,
                                  [rabbit_core_metrics_gc, start_gc]),
     rabbit_ct_broker_helpers:rpc(Config, 0, gen_server, call,

deps/rabbit/test/metrics_SUITE.erl

@@ -15,6 +15,7 @@
     cluster_members_online/2
 ]).
 
+-compile(nowarn_export_all).
 -compile(export_all).
 
 all() ->

deps/rabbit/test/peer_discovery_classic_config_SUITE.erl

@@ -55,53 +55,43 @@ init_per_suite(Config) ->
     end.
 
 end_per_suite(Config) ->
-    rabbit_ct_helpers:run_teardown_steps(Config).
-
-init_per_group(_, Config) ->
-    Config.
-
-end_per_group(_, Config) ->
     Config.
 
-init_per_testcase(Testcase, Config) ->
-    rabbit_ct_helpers:testcase_started(Config, Testcase),
+init_per_group(Group, Config0) ->
     ClusterSize = 1,
-    TestNumber = rabbit_ct_helpers:testcase_number(Config, ?MODULE, Testcase),
+    PrivDir = ?config(priv_dir, Config0),
+    MotdFile = filename:join(PrivDir, "motd.txt"),
+    ok = file:write_file(MotdFile, <<"My MOTD\n">>),
     Config1 = rabbit_ct_helpers:set_config(
-                Config,
+                Config0,
                 [
-                 {rmq_nodename_suffix, Testcase},
-                 {tcp_ports_base, {skip_n_nodes, TestNumber * ClusterSize}}
+                 {rmq_nodename_suffix, Group},
+                 {tcp_ports_base, {skip_n_nodes, ClusterSize}},
+                 {motd_file, MotdFile}
                 ]),
-    Config2 = case Testcase of
-                  override_product_name_in_conf ->
-                      rabbit_ct_helpers:merge_app_env(
-                        Config1,
-                        {rabbit, [{product_name, "MyProduct"}]});
-                  override_product_version_in_conf ->
-                      rabbit_ct_helpers:merge_app_env(
-                        Config1,
-                        {rabbit, [{product_version, "MyVersion"}]});
-                  set_motd_in_conf ->
-                      PrivDir = ?config(priv_dir, Config),
-                      MotdFile = filename:join(PrivDir, "motd.txt"),
-                      ok = file:write_file(MotdFile, <<"My MOTD\n">>),
-                      C2 = rabbit_ct_helpers:set_config(
-                             Config1,
-                             {motd_file, MotdFile}),
-                      rabbit_ct_helpers:merge_app_env(
-                        C2,
-                        {rabbit, [{motd_file, MotdFile}]})
-              end,
-    rabbit_ct_helpers:run_steps(Config2,
+
+    Config = rabbit_ct_helpers:merge_app_env(
+               Config1,
+               {rabbit, [
+                         {product_name, "MyProduct"},
+                         {product_version, "MyVersion"},
+                         {motd_file, MotdFile}]}),
+    rabbit_ct_helpers:run_steps(Config,
       rabbit_ct_broker_helpers:setup_steps() ++
       rabbit_ct_client_helpers:setup_steps()).
 
+end_per_group(_, Config) ->
+    rabbit_ct_helpers:run_steps(Config,
+                                rabbit_ct_client_helpers:teardown_steps() ++
+                                rabbit_ct_broker_helpers:teardown_steps()).
+
+init_per_testcase(Testcase, Config) ->
+    rabbit_ct_helpers:testcase_started(Config, Testcase),
+    Config.
+
 end_per_testcase(Testcase, Config) ->
-    Config1 = rabbit_ct_helpers:run_steps(Config,
-      rabbit_ct_client_helpers:teardown_steps() ++
-      rabbit_ct_broker_helpers:teardown_steps()),
-    rabbit_ct_helpers:testcase_finished(Config1, Testcase).
+    rabbit_ct_helpers:testcase_finished(Config, Testcase),
+    Config.
 
 %% -------------------------------------------------------------------
 %% Testcases.

deps/rabbit/test/product_info_SUITE.erl

@@ -68,8 +68,6 @@ groups() ->
        {classic_queue, GroupOptions, AllTests ++ [delete_immediately_by_pid_succeeds,
                                                   trigger_message_store_compaction]},
        {quorum_queue, GroupOptions, AllTests ++ ExtraBccTests ++ [delete_immediately_by_pid_fails]},
-       {quorum_queue_in_memory_limit, GroupOptions, AllTests ++ [delete_immediately_by_pid_fails]},
-       {quorum_queue_in_memory_bytes, GroupOptions, AllTests ++ [delete_immediately_by_pid_fails]},
        {stream_queue, GroupOptions, ExtraBccTests ++ [publish, subscribe]}
       ]}
     ].
@@ -102,20 +100,6 @@ init_per_group(quorum_queue, Config) ->
       [{queue_args, [{<<"x-queue-type">>, longstr, <<"quorum">>}]},
        {consumer_args, []},
        {queue_durable, true}]);
-init_per_group(quorum_queue_in_memory_limit, Config) ->
-    rabbit_ct_helpers:set_config(
-      Config,
-      [{queue_args, [{<<"x-queue-type">>, longstr, <<"quorum">>},
-                     {<<"x-max-in-memory-length">>, long, 1}]},
-       {consumer_args, []},
-       {queue_durable, true}]);
-init_per_group(quorum_queue_in_memory_bytes, Config) ->
-    rabbit_ct_helpers:set_config(
-      Config,
-      [{queue_args, [{<<"x-queue-type">>, longstr, <<"quorum">>},
-                     {<<"x-max-in-memory-bytes">>, long, 1}]},
-       {consumer_args, []},
-       {queue_durable, true}]);
 init_per_group(stream_queue, Config) ->
     rabbit_ct_helpers:set_config(
       Config,
@@ -126,10 +110,11 @@ init_per_group(Group, Config0) ->
     case lists:member({group, Group}, all()) of
         true ->
             ClusterSize = 3,
+            Tick = 256,
             Config = rabbit_ct_helpers:merge_app_env(
-                       Config0, {rabbit, [{channel_tick_interval, 1000},
-                                          {quorum_tick_interval, 1000},
-                                          {stream_tick_interval, 1000}]}),
+                       Config0, {rabbit, [{channel_tick_interval, Tick},
+                                          {quorum_tick_interval, Tick},
+                                          {stream_tick_interval, Tick}]}),
             Config1 = rabbit_ct_helpers:set_config(
                         Config, [ {rmq_nodename_suffix, Group},
                                   {rmq_nodes_count, ClusterSize}