direct_exchange_routing_v2_SUITE: Remove testcases related to disabled feature flag

The test groups initialization is also simplified now that a level of
groups is unnecessary.

Author: dumbbell

deps/rabbit/test/direct_exchange_routing_v2_SUITE.erl

@@ -27,35 +27,24 @@ all() ->
     [
      {group, cluster_size_1},
      {group, cluster_size_2},
-     {group, cluster_size_3},
      {group, unclustered_cluster_size_2}
     ].
 
 groups() ->
     [
      {cluster_size_1, [],
-      [{start_feature_flag_enabled, [], [remove_binding_unbind_queue,
-                                         remove_binding_delete_queue,
-                                         remove_binding_delete_queue_multiple,
-                                         remove_binding_delete_exchange,
-                                         recover_bindings,
-                                         route_exchange_to_exchange,
-                                         reset]},
-       {start_feature_flag_disabled, [], [enable_feature_flag]}
-      ]},
+      [remove_binding_unbind_queue,
+       remove_binding_delete_queue,
+       remove_binding_delete_queue_multiple,
+       remove_binding_delete_exchange,
+       recover_bindings,
+       route_exchange_to_exchange,
+       reset]},
      {cluster_size_2, [],
-      [{start_feature_flag_enabled, [], [
-                                         remove_binding_node_down_transient_queue,
-                                         keep_binding_node_down_durable_queue
-                                        ]},
-       {start_feature_flag_disabled, [], [enable_feature_flag_during_definition_import]}
-      ]},
+      [remove_binding_node_down_transient_queue,
+       keep_binding_node_down_durable_queue]},
      {unclustered_cluster_size_2, [],
-      [{start_feature_flag_enabled, [], [join_cluster]}
-      ]},
-     {cluster_size_3, [],
-      [{start_feature_flag_disabled, [], [enable_feature_flag_during_binding_churn]}
-      ]}
+      [join_cluster]}
     ].
 
 suite() ->
@@ -71,41 +60,17 @@ init_per_suite(Config) ->
 end_per_suite(Config) ->
     rabbit_ct_helpers:run_teardown_steps(Config).
 
-init_per_group(cluster_size_1, Config) ->
-    rabbit_ct_helpers:set_config(Config, {rmq_nodes_count, 1});
-init_per_group(cluster_size_2, Config) ->
-    rabbit_ct_helpers:set_config(Config, {rmq_nodes_count, 2});
-init_per_group(cluster_size_3, Config) ->
-    rabbit_ct_helpers:set_config(Config, {rmq_nodes_count, 3});
-init_per_group(unclustered_cluster_size_2, Config0) ->
-    case rabbit_ct_helpers:is_mixed_versions() of
-        true ->
-            {skip, "This test group won't work in mixed mode with pre 3.11 releases"};
-        false ->
-            rabbit_ct_helpers:set_config(Config0, [{rmq_nodes_count, 2},
-                                                   {rmq_nodes_clustered, false}])
-    end;
-init_per_group(start_feature_flag_enabled = Group, Config0) ->
-    Config = start_broker(Group, Config0),
-    case rabbit_ct_broker_helpers:enable_feature_flag(Config, ?FEATURE_FLAG) of
-        ok ->
-            Config;
-        {skip, _} = Skip ->
-            end_per_group(Group, Config),
-            Skip
-    end;
-init_per_group(start_feature_flag_disabled = Group, Config0) ->
-    Config1 = rabbit_ct_helpers:merge_app_env(
-                Config0, {rabbit, [{forced_feature_flags_on_init, []}]}),
-    Config = start_broker(Group, Config1),
-    case rabbit_ct_broker_helpers:is_feature_flag_supported(Config, ?FEATURE_FLAG) of
-        true ->
-            assert_no_index_table(Config),
-            Config;
-        false ->
-            end_per_group(Group, Config),
-            {skip, io_lib:format("'~ts' feature flag is unsupported", [?FEATURE_FLAG])}
-    end.
+init_per_group(cluster_size_1 = Group, Config) ->
+    Config1 = rabbit_ct_helpers:set_config(Config, {rmq_nodes_count, 1}),
+    start_broker(Group, Config1);
+init_per_group(cluster_size_2 = Group, Config) ->
+    Config1 = rabbit_ct_helpers:set_config(Config, {rmq_nodes_count, 2}),
+    start_broker(Group, Config1);
+init_per_group(unclustered_cluster_size_2 = Group, Config0) ->
+    Config1 = rabbit_ct_helpers:set_config(Config0,
+                                           [{rmq_nodes_count, 2},
+                                            {rmq_nodes_clustered, false}]),
+    start_broker(Group, Config1).
 
 start_broker(Group, Config0) ->
     Size = rabbit_ct_helpers:get_config(Config0, rmq_nodes_count),
@@ -117,14 +82,10 @@ start_broker(Group, Config0) ->
                                 rabbit_ct_broker_helpers:setup_steps() ++
                                 rabbit_ct_client_helpers:setup_steps()).
 
-end_per_group(Group, Config)
-  when Group =:= start_feature_flag_enabled;
-       Group =:= start_feature_flag_disabled ->
+end_per_group(_Group, Config) ->
     rabbit_ct_helpers:run_steps(Config,
                                 rabbit_ct_client_helpers:teardown_steps() ++
-                                rabbit_ct_broker_helpers:teardown_steps());
-end_per_group(_Group, Config) ->
-    Config.
+                                rabbit_ct_broker_helpers:teardown_steps()).
 
 init_per_testcase(_TestCase, Config) ->
     Config.
@@ -360,170 +321,6 @@ route_exchange_to_exchange(Config) ->
                                                                        routing_key = RKey}),
     ok.
 
-enable_feature_flag(Config) ->
-    Nodes = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
-    {_Conn, Ch} = rabbit_ct_client_helpers:open_connection_and_channel(Config, 0),
-
-    DirectX = <<"amq.direct">>,
-    Q1 = <<"q1">>,
-    Q2 = <<"q2">>,
-    RKey = <<"k">>,
-
-    declare_queue(Ch, Q1, true),
-    bind_queue(Ch, Q1, DirectX, RKey),
-    bind_queue(Ch, Q1, <<"amq.fanout">>, RKey),
-
-    declare_queue(Ch, Q2, false),
-    bind_queue(Ch, Q2, DirectX, RKey),
-
-    amqp_channel:call(Ch, #'confirm.select'{}),
-    amqp_channel:register_confirm_handler(Ch, self()),
-
-    %% Publishing via "direct exchange routing v1" works.
-    publish(Ch, DirectX, RKey),
-    assert_confirm(),
-
-    ok = rabbit_ct_broker_helpers:enable_feature_flag(Config, ?FEATURE_FLAG),
-
-    %% The feature flag migration should have created an index table with a ram copy on all nodes.
-    ?assertEqual(lists:sort(Nodes), index_table_ram_copies(Config, 0)),
-    %% The feature flag migration should have populated the index table with all bindings whose source exchange
-    %% is a direct exchange.
-    ?assertEqual([{rabbit_misc:r(<<"/">>, exchange, DirectX), RKey}],
-                 rabbit_ct_broker_helpers:rpc(Config, 0, mnesia, dirty_all_keys, [?INDEX_TABLE_NAME])),
-    ?assertEqual(2, table_size(Config, ?INDEX_TABLE_NAME)),
-
-    %% Publishing via "direct exchange routing v2" works.
-    publish(Ch, DirectX, RKey),
-    assert_confirm(),
-
-    delete_queue(Ch, Q1),
-    delete_queue(Ch, Q2),
-    ok.
-
-%% Test that enabling feature flag works when bindings are imported concurrently.
-enable_feature_flag_during_definition_import(Config) ->
-    Nodes = [Server1 | _] = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
-    {_Conn, Ch} = rabbit_ct_client_helpers:open_connection_and_channel(Config, 0),
-    Path = filename:join([?config(data_dir, Config), "definition.json"]),
-
-    {Pid, Ref} = spawn_monitor(
-                   fun() ->
-                           ct:pal("importing definitions..."),
-                           rabbit_ct_broker_helpers:rabbitmqctl(
-                             Config, Server1, ["import_definitions", Path]
-                            ),
-                           ct:pal("imported definitions")
-                   end),
-
-    timer:sleep(rand:uniform(400)),
-    ct:pal("enabling feature flag..."),
-    ok = rabbit_ct_broker_helpers:enable_feature_flag(Config, ?FEATURE_FLAG),
-    ct:pal("enabled feature flag"),
-
-    receive {'DOWN', Ref, process, Pid, normal} ->
-                ok
-    after 10_000 ->
-              ct:fail(timeout)
-    end,
-
-    ?assertEqual(lists:sort(Nodes), index_table_ram_copies(Config, 0)),
-    ?assertEqual(?NUM_BINDINGS_TO_DIRECT_ECHANGE,
-                 table_size(Config, ?INDEX_TABLE_NAME)),
-
-    %% cleanup
-    delete_queue(Ch, <<"durable-q">>),
-    delete_queue(Ch, <<"transient-q">>),
-    ok.
-
-%% Test that enabling feature flag works when clients concurrently
-%% create and delete bindings and send messages.
-enable_feature_flag_during_binding_churn(Config) ->
-    Nodes = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
-    {_Conn1, Ch1} = rabbit_ct_client_helpers:open_connection_and_channel(Config, 0),
-    {_Conn2, Ch2} = rabbit_ct_client_helpers:open_connection_and_channel(Config, 1),
-
-    DirectX = <<"amq.direct">>,
-    FanoutX = <<"amq.fanout">>,
-    Q = <<"q">>,
-
-    NumMessages = 500,
-    BindingsDirectX = 1000,
-    BindingsFanoutX = 10,
-
-    %% setup
-    declare_queue(Ch1, Q, true),
-    lists:foreach(fun(N) ->
-                          bind_queue(Ch1, Q, DirectX, integer_to_binary(N))
-                  end, lists:seq(1, trunc(0.4 * BindingsDirectX))),
-    lists:foreach(fun(N) ->
-                          bind_queue(Ch1, Q, FanoutX, integer_to_binary(N))
-                  end, lists:seq(1, BindingsFanoutX)),
-    lists:foreach(fun(N) ->
-                          bind_queue(Ch1, Q, DirectX, integer_to_binary(N))
-                  end, lists:seq(trunc(0.4 * BindingsDirectX) + 1, trunc(0.8 * BindingsDirectX))),
-
-    {_, Ref1} = spawn_monitor(
-                  fun() ->
-                          ct:pal("sending ~b messages...", [NumMessages]),
-                          lists:foreach(
-                            fun(_) ->
-                                    publish(Ch1, DirectX, integer_to_binary(trunc(0.8 * BindingsDirectX))),
-                                    timer:sleep(1)
-                            end, lists:seq(1, NumMessages)),
-                          ct:pal("sent ~b messages", [NumMessages])
-                  end),
-    {_, Ref2} = spawn_monitor(
-                  fun() ->
-                          ct:pal("creating bindings..."),
-                          lists:foreach(
-                            fun(N) ->
-                                    bind_queue(Ch1, Q, DirectX, integer_to_binary(N)),
-                                    timer:sleep(1)
-                            end, lists:seq(trunc(0.8 * BindingsDirectX) + 1, BindingsDirectX)),
-                          ct:pal("created bindings")
-                  end),
-    {_, Ref3} = spawn_monitor(
-                  fun() ->
-                          ct:pal("deleting bindings..."),
-                          lists:foreach(
-                            fun(N) ->
-                                    unbind_queue(Ch2, Q, DirectX, integer_to_binary(N)),
-                                    timer:sleep(1)
-                            end, lists:seq(1, trunc(0.2 * BindingsDirectX))),
-                          ct:pal("deleted bindings")
-                  end),
-
-    timer:sleep(rand:uniform(300)),
-    ct:pal("enabling feature flag..."),
-    ok = rabbit_ct_broker_helpers:enable_feature_flag(Config, ?FEATURE_FLAG),
-    ct:pal("enabled feature flag"),
-
-    lists:foreach(
-      fun(Ref) ->
-              receive {'DOWN', Ref, process, _Pid, normal} ->
-                          ok
-              after 300_000 ->
-                        ct:fail(timeout)
-              end
-      end, [Ref1, Ref2, Ref3]),
-
-    NumMessagesBin = integer_to_binary(NumMessages),
-    quorum_queue_utils:wait_for_messages(Config, [[Q, NumMessagesBin, NumMessagesBin, <<"0">>]]),
-
-    ?assertEqual(lists:sort(Nodes), index_table_ram_copies(Config, 0)),
-
-    ExpectedKeys = lists:map(
-                     fun(N) ->
-                             {rabbit_misc:r(<<"/">>, exchange, DirectX), integer_to_binary(N)}
-                     end, lists:seq(trunc(0.2 * BindingsDirectX) + 1, BindingsDirectX)),
-    ActualKeys = rabbit_ct_broker_helpers:rpc(Config, 0, mnesia, dirty_all_keys, [?INDEX_TABLE_NAME]),
-    ?assertEqual(lists:sort(ExpectedKeys), lists:sort(ActualKeys)),
-
-    %% cleanup
-    delete_queue(Ch1, Q),
-    ok.
-
 reset(Config) ->
     Server = rabbit_ct_broker_helpers:get_node_config(Config, 0, nodename),