Naming

1 files changed, 229 insertions, 229 deletions

diff --git a/test/per_user_connection_channel_limit_SUITE.erl b/test/per_user_connection_channel_limit_SUITE.erl
index c15d0dbd77..97e8c56856 100644
--- a/test/per_user_connection_channel_limit_SUITE.erl
+++ b/test/per_user_connection_channel_limit_SUITE.erl
@@ -143,60 +143,60 @@ clear_all_channel_tracking_tables(Config) ->
 
 most_basic_single_node_connection_and_channel_count(Config) ->
     Username = proplists:get_value(rmq_username, Config),
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
     [Conn] = open_connections(Config, [0]),
     [Chan] = open_channels(Conn, 1),
-    ?assertEqual(1, count_connections_in(Config, Username)),
-    ?assertEqual(1, count_channels_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
+    ?assertEqual(1, count_channels_of_user(Config, Username)),
     close_channels([Chan]),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
     close_connections([Conn]),
-    ?assertEqual(0, count_connections_in(Config, Username)).
+    ?assertEqual(0, count_connections_of_user(Config, Username)).
 
 single_node_single_user_connection_and_channel_count(Config) ->
     Username = proplists:get_value(rmq_username, Config),
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     [Conn1] = open_connections(Config, [0]),
     [Chan1] = open_channels(Conn1, 1),
-    ?assertEqual(1, count_connections_in(Config, Username)),
-    ?assertEqual(1, count_channels_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
+    ?assertEqual(1, count_channels_of_user(Config, Username)),
     close_channels([Chan1]),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
     close_connections([Conn1]),
-    ?assertEqual(0, count_connections_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
 
     [Conn2] = open_connections(Config, [0]),
     Chans2 = [_|_] = open_channels(Conn2, 5),
-    ?assertEqual(1, count_connections_in(Config, Username)),
-    ?assertEqual(5, count_channels_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
+    ?assertEqual(5, count_channels_of_user(Config, Username)),
 
     [Conn3] = open_connections(Config, [0]),
     Chans3 = [_|_] = open_channels(Conn3, 5),
-    ?assertEqual(2, count_connections_in(Config, Username)),
-    ?assertEqual(10, count_channels_in(Config, Username)),
+    ?assertEqual(2, count_connections_of_user(Config, Username)),
+    ?assertEqual(10, count_channels_of_user(Config, Username)),
 
     [Conn4] = open_connections(Config, [0]),
     _Chans4 = [_|_] = open_channels(Conn4, 5),
-    ?assertEqual(3, count_connections_in(Config, Username)),
-    ?assertEqual(15, count_channels_in(Config, Username)),
+    ?assertEqual(3, count_connections_of_user(Config, Username)),
+    ?assertEqual(15, count_channels_of_user(Config, Username)),
 
     kill_connections([Conn4]),
-    ?assertEqual(2, count_connections_in(Config, Username)),
-    ?assertEqual(10, count_channels_in(Config, Username)),
+    ?assertEqual(2, count_connections_of_user(Config, Username)),
+    ?assertEqual(10, count_channels_of_user(Config, Username)),
 
     [Conn5] = open_connections(Config, [0]),
     Chans5 = [_|_] = open_channels(Conn5, 5),
-    ?assertEqual(3, count_connections_in(Config, Username)),
-    ?assertEqual(15, count_channels_in(Config, Username)),
+    ?assertEqual(3, count_connections_of_user(Config, Username)),
+    ?assertEqual(15, count_channels_of_user(Config, Username)),
 
     close_channels(Chans2 ++ Chans3 ++ Chans5),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn2, Conn3, Conn5]),
-    ?assertEqual(0, count_connections_in(Config, Username)).
+    ?assertEqual(0, count_connections_of_user(Config, Username)).
 
 single_node_multiple_users_connection_and_channel_count(Config) ->
     Username1 = <<"guest1">>,
@@ -205,60 +205,60 @@ single_node_multiple_users_connection_and_channel_count(Config) ->
     set_up_user(Config, Username1),
     set_up_user(Config, Username2),
 
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     [Conn1] = open_connections(Config, [{0, Username1}]),
     Chans1 = [_|_] = open_channels(Conn1, 5),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
-    ?assertEqual(5, count_channels_in(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
+    ?assertEqual(5, count_channels_of_user(Config, Username1)),
     close_channels(Chans1),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
     close_connections([Conn1]),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
 
     [Conn2] = open_connections(Config, [{0, Username2}]),
     Chans2 = [_|_] = open_channels(Conn2, 5),
-    ?assertEqual(1, count_connections_in(Config, Username2)),
-    ?assertEqual(5, count_channels_in(Config, Username2)),
+    ?assertEqual(1, count_connections_of_user(Config, Username2)),
+    ?assertEqual(5, count_channels_of_user(Config, Username2)),
 
     [Conn3] = open_connections(Config, [{0, Username1}]),
     Chans3 = [_|_] = open_channels(Conn3, 5),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
-    ?assertEqual(5, count_channels_in(Config, Username1)),
-    ?assertEqual(1, count_connections_in(Config, Username2)),
-    ?assertEqual(5, count_channels_in(Config, Username2)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
+    ?assertEqual(5, count_channels_of_user(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username2)),
+    ?assertEqual(5, count_channels_of_user(Config, Username2)),
 
     [Conn4] = open_connections(Config, [{0, Username1}]),
     _Chans4 = [_|_] = open_channels(Conn4, 5),
-    ?assertEqual(2, count_connections_in(Config, Username1)),
-    ?assertEqual(10, count_channels_in(Config, Username1)),
+    ?assertEqual(2, count_connections_of_user(Config, Username1)),
+    ?assertEqual(10, count_channels_of_user(Config, Username1)),
 
     kill_connections([Conn4]),
     timer:sleep(200),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
-    ?assertEqual(5, count_channels_in(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
+    ?assertEqual(5, count_channels_of_user(Config, Username1)),
 
     [Conn5] = open_connections(Config, [{0, Username2}]),
     Chans5 = [_|_] = open_channels(Conn5, 5),
-    ?assertEqual(2, count_connections_in(Config, Username2)),
-    ?assertEqual(10, count_channels_in(Config, Username2)),
+    ?assertEqual(2, count_connections_of_user(Config, Username2)),
+    ?assertEqual(10, count_channels_of_user(Config, Username2)),
 
     [Conn6] = open_connections(Config, [{0, Username2}]),
     Chans6 = [_|_] = open_channels(Conn6, 5),
-    ?assertEqual(3, count_connections_in(Config, Username2)),
-    ?assertEqual(15, count_channels_in(Config, Username2)),
+    ?assertEqual(3, count_connections_of_user(Config, Username2)),
+    ?assertEqual(15, count_channels_of_user(Config, Username2)),
 
     close_channels(Chans2 ++ Chans3 ++ Chans5 ++ Chans6),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     close_connections([Conn2, Conn3, Conn5, Conn6]),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
 
     rabbit_ct_broker_helpers:delete_user(Config, Username1),
     rabbit_ct_broker_helpers:delete_user(Config, Username2).
@@ -321,72 +321,72 @@ single_node_list_in_user(Config) ->
 
 most_basic_cluster_connection_and_channel_count(Config) ->
     Username = proplists:get_value(rmq_username, Config),
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
     [Conn1] = open_connections(Config, [0]),
     Chans1 = [_|_] = open_channels(Conn1, 5),
-    ?assertEqual(1, count_connections_in(Config, Username)),
-    ?assertEqual(5, count_channels_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
+    ?assertEqual(5, count_channels_of_user(Config, Username)),
 
     [Conn2] = open_connections(Config, [1]),
     Chans2 = [_|_] = open_channels(Conn2, 5),
-    ?assertEqual(2, count_connections_in(Config, Username)),
-    ?assertEqual(10, count_channels_in(Config, Username)),
+    ?assertEqual(2, count_connections_of_user(Config, Username)),
+    ?assertEqual(10, count_channels_of_user(Config, Username)),
 
     [Conn3] = open_connections(Config, [1]),
     Chans3 = [_|_] = open_channels(Conn3, 5),
-    ?assertEqual(3, count_connections_in(Config, Username)),
-    ?assertEqual(15, count_channels_in(Config, Username)),
+    ?assertEqual(3, count_connections_of_user(Config, Username)),
+    ?assertEqual(15, count_channels_of_user(Config, Username)),
 
     close_channels(Chans1 ++ Chans2 ++ Chans3),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn1, Conn2, Conn3]),
-    ?assertEqual(0, count_connections_in(Config, Username)).
+    ?assertEqual(0, count_connections_of_user(Config, Username)).
 
 cluster_single_user_connection_and_channel_count(Config) ->
     Username = proplists:get_value(rmq_username, Config),
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     [Conn1] = open_connections(Config, [0]),
     _Chans1 = [_|_] = open_channels(Conn1, 5),
-    ?assertEqual(1, count_connections_in(Config, Username)),
-    ?assertEqual(5, count_channels_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
+    ?assertEqual(5, count_channels_of_user(Config, Username)),
     close_connections([Conn1]),
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     [Conn2] = open_connections(Config, [1]),
     Chans2 = [_|_] = open_channels(Conn2, 5),
-    ?assertEqual(1, count_connections_in(Config, Username)),
-    ?assertEqual(5, count_channels_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
+    ?assertEqual(5, count_channels_of_user(Config, Username)),
 
     [Conn3] = open_connections(Config, [0]),
     Chans3 = [_|_] = open_channels(Conn3, 5),
-    ?assertEqual(2, count_connections_in(Config, Username)),
-    ?assertEqual(10, count_channels_in(Config, Username)),
+    ?assertEqual(2, count_connections_of_user(Config, Username)),
+    ?assertEqual(10, count_channels_of_user(Config, Username)),
 
     [Conn4] = open_connections(Config, [1]),
     _Chans4 = [_|_] = open_channels(Conn4, 5),
-    ?assertEqual(3, count_connections_in(Config, Username)),
-    ?assertEqual(15, count_channels_in(Config, Username)),
+    ?assertEqual(3, count_connections_of_user(Config, Username)),
+    ?assertEqual(15, count_channels_of_user(Config, Username)),
 
     kill_connections([Conn4]),
     timer:sleep(200),
-    ?assertEqual(2, count_connections_in(Config, Username)),
-    ?assertEqual(10, count_channels_in(Config, Username)),
+    ?assertEqual(2, count_connections_of_user(Config, Username)),
+    ?assertEqual(10, count_channels_of_user(Config, Username)),
 
     [Conn5] = open_connections(Config, [1]),
     Chans5 = [_|_] = open_channels(Conn5, 5),
-    ?assertEqual(3, count_connections_in(Config, Username)),
-    ?assertEqual(15, count_channels_in(Config, Username)),
+    ?assertEqual(3, count_connections_of_user(Config, Username)),
+    ?assertEqual(15, count_channels_of_user(Config, Username)),
 
     close_channels(Chans2 ++ Chans3 ++ Chans5),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn2, Conn3, Conn5]),
-    ?assertEqual(0, count_connections_in(Config, Username)).
+    ?assertEqual(0, count_connections_of_user(Config, Username)).
 
 cluster_multiple_users_connection_and_channel_count(Config) ->
     Username1 = <<"guest1">>,
@@ -395,103 +395,103 @@ cluster_multiple_users_connection_and_channel_count(Config) ->
     set_up_user(Config, Username1),
     set_up_user(Config, Username2),
 
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     [Conn1] = open_connections(Config, [{0, Username1}]),
     _Chans1 = [_|_] = open_channels(Conn1, 5),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
-    ?assertEqual(5, count_channels_in(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
+    ?assertEqual(5, count_channels_of_user(Config, Username1)),
     close_connections([Conn1]),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
 
     [Conn2] = open_connections(Config, [{1, Username2}]),
     Chans2 = [_|_] = open_channels(Conn2, 5),
-    ?assertEqual(1, count_connections_in(Config, Username2)),
-    ?assertEqual(5, count_channels_in(Config, Username2)),
+    ?assertEqual(1, count_connections_of_user(Config, Username2)),
+    ?assertEqual(5, count_channels_of_user(Config, Username2)),
 
     [Conn3] = open_connections(Config, [{1, Username1}]),
     Chans3 = [_|_] = open_channels(Conn3, 5),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
-    ?assertEqual(5, count_channels_in(Config, Username1)),
-    ?assertEqual(1, count_connections_in(Config, Username2)),
-    ?assertEqual(5, count_channels_in(Config, Username2)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
+    ?assertEqual(5, count_channels_of_user(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username2)),
+    ?assertEqual(5, count_channels_of_user(Config, Username2)),
 
     [Conn4] = open_connections(Config, [{0, Username1}]),
     _Chans4 = [_|_] = open_channels(Conn4, 5),
-    ?assertEqual(2, count_connections_in(Config, Username1)),
-    ?assertEqual(10, count_channels_in(Config, Username1)),
+    ?assertEqual(2, count_connections_of_user(Config, Username1)),
+    ?assertEqual(10, count_channels_of_user(Config, Username1)),
 
     kill_connections([Conn4]),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
-    ?assertEqual(5, count_channels_in(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
+    ?assertEqual(5, count_channels_of_user(Config, Username1)),
 
     [Conn5] = open_connections(Config, [{1, Username2}]),
     Chans5 = [_|_] = open_channels(Conn5, 5),
-    ?assertEqual(2, count_connections_in(Config, Username2)),
-    ?assertEqual(10, count_channels_in(Config, Username2)),
+    ?assertEqual(2, count_connections_of_user(Config, Username2)),
+    ?assertEqual(10, count_channels_of_user(Config, Username2)),
 
     [Conn6] = open_connections(Config, [{0, Username2}]),
     Chans6 = [_|_] = open_channels(Conn6, 5),
-    ?assertEqual(3, count_connections_in(Config, Username2)),
-    ?assertEqual(15, count_channels_in(Config, Username2)),
+    ?assertEqual(3, count_connections_of_user(Config, Username2)),
+    ?assertEqual(15, count_channels_of_user(Config, Username2)),
 
     close_channels(Chans2 ++ Chans3 ++ Chans5 ++ Chans6),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     close_connections([Conn2, Conn3, Conn5, Conn6]),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
 
     rabbit_ct_broker_helpers:delete_user(Config, Username1),
     rabbit_ct_broker_helpers:delete_user(Config, Username2).
 
 cluster_node_restart_connection_and_channel_count(Config) ->
     Username = proplists:get_value(rmq_username, Config),
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     [Conn1] = open_connections(Config, [0]),
     _Chans1 = [_|_] = open_channels(Conn1, 5),
-    ?assertEqual(1, count_connections_in(Config, Username)),
-    ?assertEqual(5, count_channels_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
+    ?assertEqual(5, count_channels_of_user(Config, Username)),
     close_connections([Conn1]),
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     [Conn2] = open_connections(Config, [1]),
     Chans2 = [_|_] = open_channels(Conn2, 5),
-    ?assertEqual(1, count_connections_in(Config, Username)),
-    ?assertEqual(5, count_channels_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
+    ?assertEqual(5, count_channels_of_user(Config, Username)),
 
     [Conn3] = open_connections(Config, [0]),
     Chans3 = [_|_] = open_channels(Conn3, 5),
-    ?assertEqual(2, count_connections_in(Config, Username)),
-    ?assertEqual(10, count_channels_in(Config, Username)),
+    ?assertEqual(2, count_connections_of_user(Config, Username)),
+    ?assertEqual(10, count_channels_of_user(Config, Username)),
 
     [Conn4] = open_connections(Config, [1]),
     _Chans4 = [_|_] = open_channels(Conn4, 5),
-    ?assertEqual(3, count_connections_in(Config, Username)),
-    ?assertEqual(15, count_channels_in(Config, Username)),
+    ?assertEqual(3, count_connections_of_user(Config, Username)),
+    ?assertEqual(15, count_channels_of_user(Config, Username)),
 
     [Conn5] = open_connections(Config, [1]),
     Chans5 = [_|_] = open_channels(Conn5, 5),
-    ?assertEqual(4, count_connections_in(Config, Username)),
-    ?assertEqual(20, count_channels_in(Config, Username)),
+    ?assertEqual(4, count_connections_of_user(Config, Username)),
+    ?assertEqual(20, count_channels_of_user(Config, Username)),
 
     rabbit_ct_broker_helpers:restart_broker(Config, 1),
-    ?assertEqual(1, count_connections_in(Config, Username)),
-    ?assertEqual(5, count_channels_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
+    ?assertEqual(5, count_channels_of_user(Config, Username)),
 
     close_channels(Chans2 ++ Chans3 ++ Chans5),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn2, Conn3, Conn4, Conn5]),
-    ?assertEqual(0, count_connections_in(Config, Username)).
+    ?assertEqual(0, count_connections_of_user(Config, Username)).
 
 cluster_node_list_on_node(Config) ->
     [A, B] = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
@@ -557,8 +557,8 @@ single_node_single_user_limit_with(Config, ConnLimit, ChLimit) ->
     Username = proplists:get_value(rmq_username, Config),
     set_user_connection_and_channel_limit(Config, Username, 3, 15),
 
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     [Conn1, Conn2, Conn3] = Conns1 = open_connections(Config, [0, 0, 0]),
     [_Chans1, Chans2, Chans3] = [open_channels(Conn, 5) || Conn <- Conns1],
@@ -579,10 +579,10 @@ single_node_single_user_limit_with(Config, ConnLimit, ChLimit) ->
 
     close_channels(Chans2 ++ Chans3 ++ Chans4 ++ Chans5),
     timer:sleep(100),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn1, Conn2, Conn3, Conn4, Conn5]),
-    ?assertEqual(0, count_connections_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
 
     set_user_connection_and_channel_limit(Config, Username,  -1, -1).
 
@@ -590,8 +590,8 @@ single_node_single_user_zero_limit(Config) ->
     Username = proplists:get_value(rmq_username, Config),
     set_user_connection_and_channel_limit(Config, Username, 0, 0),
 
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     %% with limit = 0 no connections are allowed
     expect_that_client_connection_is_rejected(Config),
@@ -601,31 +601,31 @@ single_node_single_user_zero_limit(Config) ->
     %% with limit = 0 no channels are allowed
     set_user_connection_and_channel_limit(Config, Username, 1, 0),
     [ConnA] = open_connections(Config, [0]),
-    ?assertEqual(1, count_connections_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
     expect_that_client_channel_is_rejected(ConnA),
     timer:sleep(100),
     ?assertEqual(false, is_process_alive(ConnA)),
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     set_user_connection_and_channel_limit(Config, Username, -1, -1),
     [Conn1, Conn2] = Conns1 = open_connections(Config, [0, 0]),
     [Chans1, Chans2] = [open_channels(Conn, 5) || Conn <- Conns1],
-    ?assertEqual(2, count_connections_in(Config, Username)),
-    ?assertEqual(10, count_channels_in(Config, Username)),
+    ?assertEqual(2, count_connections_of_user(Config, Username)),
+    ?assertEqual(10, count_channels_of_user(Config, Username)),
 
     close_channels(Chans1 ++ Chans2),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn1, Conn2]),
-    ?assertEqual(0, count_connections_in(Config, Username)).
+    ?assertEqual(0, count_connections_of_user(Config, Username)).
 
 single_node_single_user_clear_limits(Config) ->
     Username = proplists:get_value(rmq_username, Config),
     set_user_connection_and_channel_limit(Config, Username, 3, 15),
 
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     [Conn1, Conn2, Conn3] = Conns1 = open_connections(Config, [0, 0, 0]),
     [_Chans1, Chans2, Chans3] = [open_channels(Conn, 5) || Conn <- Conns1],
@@ -644,8 +644,8 @@ single_node_single_user_clear_limits(Config) ->
     [Conn4] = open_connections(Config, [{0, Username}]),
     Chans4 = [_|_] = open_channels(Conn4, 5),
     timer:sleep(200),
-    ?assertEqual(3, count_connections_in(Config, Username)),
-    ?assertEqual(15, count_channels_in(Config, Username)),
+    ?assertEqual(3, count_connections_of_user(Config, Username)),
+    ?assertEqual(15, count_channels_of_user(Config, Username)),
 
     clear_all_user_limits(Config, Username),
 
@@ -654,10 +654,10 @@ single_node_single_user_clear_limits(Config) ->
 
     close_channels(Chans2 ++ Chans3 ++ Chans4 ++ Chans5 ++ Chans6 ++ Chans7),
     timer:sleep(100),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn2, Conn3, Conn4, Conn5, Conn6, Conn7]),
-    ?assertEqual(0, count_connections_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
 
     set_user_connection_and_channel_limit(Config, Username,  -1, -1).
 
@@ -671,10 +671,10 @@ single_node_multiple_users_clear_limits(Config) ->
     set_user_connection_and_channel_limit(Config, Username1, 0, 0),
     set_user_connection_and_channel_limit(Config, Username2, 0, 0),
 
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     %% with limit = 0 no connections are allowed
     expect_that_client_connection_is_rejected(Config, 0, Username1),
@@ -685,16 +685,16 @@ single_node_multiple_users_clear_limits(Config) ->
     set_user_connection_and_channel_limit(Config, Username1, 1, 0),
     set_user_connection_and_channel_limit(Config, Username2, 1, 0),
     [ConnA, ConnB] = open_connections(Config, [{0, Username1}, {0, Username2}]),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
     expect_that_client_channel_is_rejected(ConnA),
     expect_that_client_channel_is_rejected(ConnB),
     timer:sleep(100),
     ?assertEqual(false, is_process_alive(ConnA)),
     ?assertEqual(false, is_process_alive(ConnB)),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     clear_all_user_limits(Config, Username1),
     set_user_channel_limit_only(Config, Username2, -1),
@@ -704,12 +704,12 @@ single_node_multiple_users_clear_limits(Config) ->
     [Chans1, Chans2] = [open_channels(Conn, 5) || Conn <- Conns1],
 
     close_channels(Chans1 ++ Chans2),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     close_connections([Conn1, Conn2]),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
 
     set_user_connection_and_channel_limit(Config, Username1, -1, -1),
     set_user_connection_and_channel_limit(Config, Username2, -1, -1).
@@ -724,10 +724,10 @@ single_node_multiple_users_limit(Config) ->
     set_user_connection_and_channel_limit(Config, Username1, 2, 10),
     set_user_connection_and_channel_limit(Config, Username2, 2, 10),
 
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     [Conn1, Conn2, Conn3, Conn4] = Conns1 = open_connections(Config, [
         {0, Username1},
@@ -762,13 +762,13 @@ single_node_multiple_users_limit(Config) ->
 
     close_channels(Chans2 ++ Chans3 ++ Chans4 ++ Chans5 ++ Chans6 ++
                    Chans7 ++ Chans8 ++ Chans9 ++ Chans10),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     close_connections([Conn2, Conn3, Conn4, Conn5, Conn6,
                        Conn7, Conn8, Conn9, Conn10]),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
 
     set_user_connection_and_channel_limit(Config, Username1, -1, -1),
     set_user_connection_and_channel_limit(Config, Username2, -1, -1),
@@ -787,10 +787,10 @@ single_node_multiple_users_zero_limit(Config) ->
     set_user_connection_and_channel_limit(Config, Username1, 0, 0),
     set_user_connection_and_channel_limit(Config, Username2, 0, 0),
 
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     %% with limit = 0 no connections are allowed
     expect_that_client_connection_is_rejected(Config, 0, Username1),
@@ -801,28 +801,28 @@ single_node_multiple_users_zero_limit(Config) ->
     set_user_connection_and_channel_limit(Config, Username1, 1, 0),
     set_user_connection_and_channel_limit(Config, Username2, 1, 0),
     [ConnA, ConnB] = open_connections(Config, [{0, Username1}, {0, Username2}]),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
     expect_that_client_channel_is_rejected(ConnA),
     expect_that_client_channel_is_rejected(ConnB),
     timer:sleep(100),
     ?assertEqual(false, is_process_alive(ConnA)),
     ?assertEqual(false, is_process_alive(ConnB)),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     set_user_connection_and_channel_limit(Config, Username1, -1, -1),
     [Conn1, Conn2] = Conns1 = open_connections(Config, [{0, Username1}, {0, Username1}]),
     [Chans1, Chans2] = [open_channels(Conn, 5) || Conn <- Conns1],
 
     close_channels(Chans1 ++ Chans2),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     close_connections([Conn1, Conn2]),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
 
     set_user_connection_and_channel_limit(Config, Username1, -1, -1),
     set_user_connection_and_channel_limit(Config, Username2, -1, -1).
@@ -833,8 +833,8 @@ cluster_single_user_limit(Config) ->
     set_user_connection_limit_only(Config, Username, 2),
     set_user_channel_limit_only(Config, Username, 10),
 
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     %% here connections and channels are opened to different nodes
     [Conn1, Conn2] = Conns1 = open_connections(Config, [{0, Username}, {1, Username}]),
@@ -854,10 +854,10 @@ cluster_single_user_limit(Config) ->
     [Chans3, Chans4] = [open_channels(Conn, 5) || Conn <- Conns2],
 
     close_channels(Chans2 ++ Chans3 ++ Chans4),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn2, Conn3, Conn4]),
-    ?assertEqual(0, count_connections_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
 
     set_user_connection_and_channel_limit(Config, Username,  -1, -1).
 
@@ -865,8 +865,8 @@ cluster_single_user_limit2(Config) ->
     Username = proplists:get_value(rmq_username, Config),
     set_user_connection_and_channel_limit(Config, Username, 2, 10),
 
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     %% here a limit is reached on one node first
     [Conn1, Conn2] = Conns1 = open_connections(Config, [{0, Username}, {0, Username}]),
@@ -894,10 +894,10 @@ cluster_single_user_limit2(Config) ->
 
     close_channels(Chans2 ++ Chans3 ++ Chans4 ++ Chans5 ++ Chans6),
     timer:sleep(50),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn2, Conn3, Conn4, Conn5, Conn6]),
-    ?assertEqual(0, count_connections_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
 
     set_user_connection_and_channel_limit(Config, Username,  -1, -1).
 
@@ -906,8 +906,8 @@ cluster_single_user_zero_limit(Config) ->
     Username = proplists:get_value(rmq_username, Config),
     set_user_connection_and_channel_limit(Config, Username, 0, 0),
 
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     %% with limit = 0 no connections are allowed
     expect_that_client_connection_is_rejected(Config, 0),
@@ -917,22 +917,22 @@ cluster_single_user_zero_limit(Config) ->
     %% with limit = 0 no channels are allowed
     set_user_connection_and_channel_limit(Config, Username, 1, 0),
     [ConnA] = open_connections(Config, [0]),
-    ?assertEqual(1, count_connections_in(Config, Username)),
+    ?assertEqual(1, count_connections_of_user(Config, Username)),
     expect_that_client_channel_is_rejected(ConnA),
     timer:sleep(100),
     ?assertEqual(false, is_process_alive(ConnA)),
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     set_user_connection_and_channel_limit(Config, Username, -1, -1),
     [Conn1, Conn2, Conn3, Conn4] = Conns1 = open_connections(Config, [0, 1, 0, 1]),
     [Chans1, Chans2, Chans3, Chans4] = [open_channels(Conn, 5) || Conn <- Conns1],
 
     close_channels(Chans1 ++ Chans2 ++ Chans3 ++ Chans4),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn1, Conn2, Conn3, Conn4]),
-    ?assertEqual(0, count_connections_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
 
     set_user_connection_and_channel_limit(Config, Username, -1, -1).
 
@@ -940,8 +940,8 @@ cluster_single_user_clear_limits(Config) ->
     Username = proplists:get_value(rmq_username, Config),
     set_user_connection_and_channel_limit(Config, Username, 2, 10),
 
-    ?assertEqual(0, count_connections_in(Config, Username)),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     %% here a limit is reached on one node first
     [Conn1, Conn2] = Conns1 = open_connections(Config, [{0, Username}, {0, Username}]),
@@ -970,10 +970,10 @@ cluster_single_user_clear_limits(Config) ->
     close_channels(Chans2 ++ Chans3 ++ Chans4 ++ Chans5 ++ Chans6 ++ Chans7),
 
     timer:sleep(50),
-    ?assertEqual(0, count_channels_in(Config, Username)),
+    ?assertEqual(0, count_channels_of_user(Config, Username)),
 
     close_connections([Conn2, Conn3, Conn4, Conn5, Conn6, Conn7]),
-    ?assertEqual(0, count_connections_in(Config, Username)),
+    ?assertEqual(0, count_connections_of_user(Config, Username)),
 
     set_user_connection_and_channel_limit(Config, Username,  -1, -1).
 
@@ -987,10 +987,10 @@ cluster_multiple_users_clear_limits(Config) ->
     set_user_connection_and_channel_limit(Config, Username1, 0, 0),
     set_user_connection_and_channel_limit(Config, Username2, 0, 0),
 
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     %% with limit = 0 no connections are allowed
     expect_that_client_connection_is_rejected(Config, 0, Username1),
@@ -1002,20 +1002,20 @@ cluster_multiple_users_clear_limits(Config) ->
     set_user_connection_and_channel_limit(Config, Username1, 1, 0),
     set_user_connection_and_channel_limit(Config, Username2, 1, 0),
     [ConnA, ConnB] = open_connections(Config, [{0, Username1}, {1, Username2}]),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
-    ?assertEqual(1, count_connections_in(Config, Username2)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username2)),
     expect_that_client_channel_is_rejected(ConnA),
     timer:sleep(100),
     ?assertEqual(false, is_process_alive(ConnA)),
     ?assertEqual(true, is_process_alive(ConnB)),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(1, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
     kill_connections([ConnB]),
     ?assertEqual(false, is_process_alive(ConnB)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     clear_all_user_limits(Config, Username1),
     clear_all_user_limits(Config, Username2),
@@ -1029,12 +1029,12 @@ cluster_multiple_users_clear_limits(Config) ->
     [Chans1, Chans2, Chans3, Chans4] = [open_channels(Conn, 5) || Conn <- Conns1],
 
     close_channels(Chans1 ++ Chans2 ++ Chans3 ++ Chans4),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     close_connections([Conn1, Conn2, Conn3, Conn4]),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
 
     set_user_connection_and_channel_limit(Config, Username1, -1, -1),
     set_user_connection_and_channel_limit(Config, Username2, -1, -1).
@@ -1049,10 +1049,10 @@ cluster_multiple_users_zero_limit(Config) ->
     set_user_connection_and_channel_limit(Config, Username1, 0, 0),
     set_user_connection_and_channel_limit(Config, Username2, 0, 0),
 
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     %% with limit = 0 no connections are allowed
     expect_that_client_connection_is_rejected(Config, 0, Username1),
@@ -1064,20 +1064,20 @@ cluster_multiple_users_zero_limit(Config) ->
     set_user_connection_and_channel_limit(Config, Username1, 1, 0),
     set_user_connection_and_channel_limit(Config, Username2, 1, 0),
     [ConnA, ConnB] = open_connections(Config, [{0, Username1}, {1, Username2}]),
-    ?assertEqual(1, count_connections_in(Config, Username1)),
-    ?assertEqual(1, count_connections_in(Config, Username2)),
+    ?assertEqual(1, count_connections_of_user(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username2)),
     expect_that_client_channel_is_rejected(ConnA),
     timer:sleep(100),
     ?assertEqual(false, is_process_alive(ConnA)),
     ?assertEqual(true, is_process_alive(ConnB)),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(1, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(1, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
     kill_connections([ConnB]),
     ?assertEqual(false, is_process_alive(ConnB)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     set_user_connection_and_channel_limit(Config, Username1, -1, -1),
     set_user_connection_and_channel_limit(Config, Username2, -1, -1),
@@ -1091,12 +1091,12 @@ cluster_multiple_users_zero_limit(Config) ->
     [Chans1, Chans2, Chans3, Chans4] = [open_channels(Conn, 5) || Conn <- Conns1],
 
     close_channels(Chans1 ++ Chans2 ++ Chans3 ++ Chans4),
-    ?assertEqual(0, count_channels_in(Config, Username1)),
-    ?assertEqual(0, count_channels_in(Config, Username2)),
+    ?assertEqual(0, count_channels_of_user(Config, Username1)),
+    ?assertEqual(0, count_channels_of_user(Config, Username2)),
 
     close_connections([Conn1, Conn2, Conn3, Conn4]),
-    ?assertEqual(0, count_connections_in(Config, Username1)),
-    ?assertEqual(0, count_connections_in(Config, Username2)),
+    ?assertEqual(0, count_connections_of_user(Config, Username1)),
+    ?assertEqual(0, count_connections_of_user(Config, Username2)),
 
     set_user_connection_and_channel_limit(Config, Username1, -1, -1),
     set_user_connection_and_channel_limit(Config, Username2, -1, -1).
@@ -1148,12 +1148,12 @@ open_channel(Conn) when is_pid(Conn) ->
 close_channels(Channels = [_|_]) ->
     [rabbit_ct_client_helpers:close_channel(Ch) || Ch <- Channels].
 
-count_connections_in(Config, Username) ->
+count_connections_of_user(Config, Username) ->
     count_connections_in(Config, Username, 0).
 count_connections_in(Config, Username, NodeIndex) ->
     count_user_tracked_items(Config, NodeIndex, rabbit_connection_tracking, Username).
 
- count_channels_in(Config, Username) ->
+ count_channels_of_user(Config, Username) ->
      count_channels_in(Config, Username, 0).
  count_channels_in(Config, Username, NodeIndex) ->
     count_user_tracked_items(Config, NodeIndex, rabbit_channel_tracking, Username).