root
/
rabbitmq-server
mirror of https://github.com/rabbitmq/rabbitmq-server.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

List excahnges command test

This commit is contained in:
Daniil Fedotov 2016-05-09 14:51:20 +01:00
parent 670e7bbe47
commit 7c16aa3214
3 changed files with 247 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
deps/rabbitmq_cli/test/list_exchanges_command_test.exs vendored Normal file
View File

@ -0,0 +1,170 @@
defmodule ListExchangesCommandTest do
use ExUnit.Case, async: false
import ExUnit.CaptureIO
import TestHelper
@vhost "test1"
@user "guest"
@root "/"
@default_timeout :infinity
@default_exchanges [{"amq.direct", :direct},
{"amq.fanout", :fanout},
{"amq.match", :headers},
{"amq.rabbitmq.trace", :topic},
{"amq.headers", :headers},
{"amq.topic", :topic},
{"", :direct}]
defp default_exchange_names() do
{names, _types} = Enum.unzip(@default_exchanges)
names
end
setup_all do
:net_kernel.start([:rabbitmqctl, :shortnames])
:net_kernel.connect_node(get_rabbit_hostname)
on_exit([], fn ->
:erlang.disconnect_node(get_rabbit_hostname)
:net_kernel.stop()
end)
:ok
end
setup context do
add_vhost @vhost
set_permissions @user, @vhost, [".*", ".*", ".*"]
on_exit(fn ->
delete_vhost @vhost
end)
{
:ok,
opts: %{
quiet: true,
node: get_rabbit_hostname,
timeout: context[:test_timeout] || @default_timeout,
param: @vhost
}
}
end
@tag test_timeout: :infinity
test "return bad_info_key on a single bad arg", context do
capture_io(fn ->
assert ListExchangesCommand.run(["quack"], context[:opts]) ==
{:error, {:bad_info_key, [:quack]}}
end)
end
@tag test_timeout: :infinity
test "multiple bad args return a list of bad info key values", context do
capture_io(fn ->
assert ListExchangesCommand.run(["quack", "oink"], context[:opts]) ==
{:error, {:bad_info_key, [:quack, :oink]}}
end)
end
@tag test_timeout: :infinity
test "return bad_info_key on mix of good and bad args", context do
capture_io(fn ->
assert ListExchangesCommand.run(["quack", "type"], context[:opts]) ==
{:error, {:bad_info_key, [:quack]}}
assert ListExchangesCommand.run(["name", "oink"], context[:opts]) ==
{:error, {:bad_info_key, [:oink]}}
assert ListExchangesCommand.run(["name", "oink", "type"], context[:opts]) ==
{:error, {:bad_info_key, [:oink]}}
end)
end
@tag test_timeout: 0
test "zero timeout causes command to return badrpc", context do
capture_io(fn ->
assert ListExchangesCommand.run([], context[:opts]) ==
[{:badrpc, :timeout}]
end)
end
test "show default exchanges by default", context do
capture_io(fn ->
assert MapSet.new(ListExchangesCommand.run(["name"], context[:opts])) ==
MapSet.new(for {ex_name, ex_type} <- @default_exchanges, do: [name: ex_name])
end)
end
test "no info keys returns name and type", context do
exchange_name = "test_exchange"
declare_exchange(exchange_name, @vhost)
capture_io(fn ->
assert MapSet.new(ListExchangesCommand.run([], context[:opts])) ==
MapSet.new(
for({ex_name, ex_type} <- @default_exchanges, do: [name: ex_name, type: ex_type]) ++
[[name: exchange_name, type: :direct]])
end)
end
test "list multiple excahnges", context do
declare_exchange("test_exchange_1", @vhost, :direct)
declare_exchange("test_exchange_2", @vhost, :fanout)
capture_io(fn ->
non_default_exchanges = ListExchangesCommand.run(["name", "type"], context[:opts])
|> without_default_exchanges
assert non_default_exchanges ==
[[name: "test_exchange_1", type: :direct],
[name: "test_exchange_2", type: :fanout]]
end)
end
test "info keys filter single key", context do
declare_exchange("test_exchange_1", @vhost)
declare_exchange("test_exchange_2", @vhost)
capture_io(fn ->
non_default_exchanges = ListExchangesCommand.run(["name"], context[:opts])
|> without_default_exchanges
assert non_default_exchanges ==
[[name: "test_exchange_1"],
[name: "test_exchange_2"]]
end)
end
test "info keys add additional keys", context do
declare_exchange("durable_exchange", @vhost, :direct, true)
declare_exchange("auto_delete_exchange", @vhost, :fanout, false, true)
capture_io(fn ->
non_default_exchanges = ListExchangesCommand.run(["name", "type", "durable", "auto_delete"], context[:opts])
|> without_default_exchanges
assert non_default_exchanges ==
[[name: "auto_delete_exchange", type: :fanout, durable: false, auto_delete: true],
[name: "durable_exchange", type: :direct, durable: true, auto_delete: false]]
end)
end
test "specifying a vhost returns the targeted vhost exchanges", context do
other_vhost = "other_vhost"
add_vhost other_vhost
on_exit(fn ->
delete_vhost other_vhost
end)
declare_exchange("test_exchange_1", @vhost)
declare_exchange("test_exchange_2", other_vhost)
capture_io(fn ->
non_default_exchanges1 = ListExchangesCommand.run(["name"], context[:opts])
|> without_default_exchanges
non_default_exchanges2 = ListExchangesCommand.run(["name"], %{context[:opts] | :param => other_vhost})
|> without_default_exchanges
assert non_default_exchanges1 == [[name: "test_exchange_1"]]
assert non_default_exchanges2 == [[name: "test_exchange_2"]]
end)
end
defp without_default_exchanges(xs) do
Enum.filter(xs,
fn(x) ->
not Enum.member?(default_exchange_names(), x[:name])
end)
end
end

94
deps/rabbitmq_cli/test/list_queues_command_test.exs vendored
View File

@ -67,10 +67,10 @@ defmodule ListQueuesCommandTest do
@tag test_timeout: 0
test "zero timeout causes command to return badrpc", context do
# capture_io(fn ->
capture_io(fn ->
assert ListQueuesCommand.run([], context[:opts]) ==
[{:badrpc, :timeout}]
# end)
end)
end
@tag test_timeout: 1
@ -79,10 +79,10 @@ defmodule ListQueuesCommandTest do
for i <- 1..10000 do
declare_queue("test_queue_" <> Integer.to_string(i), @vhost)
end
# capture_io(fn ->
capture_io(fn ->
assert ListQueuesCommand.run([], context[:opts]) ==
[{:badrpc, {:timeout, 0.001}}]
# end)
end)
end
test "no info keys returns names and message count", context do
@ -90,10 +90,10 @@ defmodule ListQueuesCommandTest do
message_count = 3
declare_queue(queue_name, @vhost)
publish_messages(queue_name, 3)
# capture_io(fn ->
assert ListQueuesCommand.run([], context[:opts]) ==
[[name: queue_name, messages: message_count]]
# end)
capture_io(fn ->
assert ListQueuesCommand.run([], context[:opts]) ==
[[name: queue_name, messages: message_count]]
end)
end
test "return multiple queues", context do
@ -101,11 +101,11 @@ defmodule ListQueuesCommandTest do
publish_messages("test_queue_1", 3)
declare_queue("test_queue_2", @vhost)
publish_messages("test_queue_2", 1)
# capture_io(fn ->
assert ListQueuesCommand.run([], context[:opts]) ==
[[name: "test_queue_1", messages: 3],
[name: "test_queue_2", messages: 1]]
# end)
capture_io(fn ->
assert ListQueuesCommand.run([], context[:opts]) ==
[[name: "test_queue_1", messages: 3],
[name: "test_queue_2", messages: 1]]
end)
end
test "info keys filter single key", context do
@ -113,11 +113,11 @@ defmodule ListQueuesCommandTest do
publish_messages("test_queue_1", 3)
declare_queue("test_queue_2", @vhost)
publish_messages("test_queue_2", 1)
# capture_io(fn ->
assert ListQueuesCommand.run(["name"], context[:opts]) ==
[[name: "test_queue_1"],
[name: "test_queue_2"]]
# end)
capture_io(fn ->
assert ListQueuesCommand.run(["name"], context[:opts]) ==
[[name: "test_queue_1"],
[name: "test_queue_2"]]
end)
end
@ -126,20 +126,60 @@ defmodule ListQueuesCommandTest do
publish_messages("durable_queue", 3)
declare_queue("auto_delete_queue", @vhost, false, true)
publish_messages("auto_delete_queue", 1)
# capture_io(fn ->
assert Keyword.equal?(ListQueuesCommand.run(["name", "messages", "durable", "auto_delete"], context[:opts]),
[[name: "durable_queue", messages: 3, durable: true, auto_delete: false],
[name: "auto_delete_queue", messages: 1, durable: false, auto_delete: true]])
# end)
capture_io(fn ->
assert Keyword.equal?(
ListQueuesCommand.run(["name", "messages", "durable", "auto_delete"], context[:opts]),
[[name: "durable_queue", messages: 3, durable: true, auto_delete: false],
[name: "auto_delete_queue", messages: 1, durable: false, auto_delete: true]])
end)
end
test "specifying a vhost returns the targeted vhost queues", context do
other_vhost = "other_vhost"
add_vhost other_vhost
on_exit(fn ->
delete_vhost other_vhost
end)
declare_queue("test_queue_1", @vhost)
declare_queue("test_queue_2", other_vhost)
capture_io(fn ->
assert ListQueuesCommand.run(["name"], context[:opts]) == [[name: "test_queue_1"]]
assert ListQueuesCommand.run(["name"], %{context[:opts] | :param => other_vhost}) == [[name: "test_queue_2"]]
end)
end
# TODO: list online/offline queues. Require cluster add/remove
# test "list online queues do not show offline queues", context do
# other_node = @secondary_node
# declare_queue("online_queue", @vhost, true)
# publish_messages("online_queue", 3)
# #declare on another node
# declare_queue_on_node(other_node, "offline_queue", @vhost, true)
# publish_messages("offline_queue", 3)
# stop_node(other_node)
# assert ListQueuesCommand.run(["name"], %{context[:opts] | online: true}) == [[name: "online_queue"]]
# end
# test "list offline queues do not show online queues", context do
# other_node = @secondary_node
# declare_queue("online_queue", @vhost, true)
# publish_messages("online_queue", 3)
# #declare on another node
# declare_queue_on_node(other_node, "offline_queue", @vhost, true)
# publish_messages("offline_queue", 3)
# stop_node(other_node)
# assert ListQueuesCommand.run(["name"], %{context[:opts] | offline: true}) == [[name: "offline_queue"]]
# end
def publish_messages(name, count) do
with_channel(@vhost, fn(channel) ->
for i <- 1..count do
AMQP.Basic.publish(channel, "", name,
"test_message" <> Integer.to_string(i))
end
for i <- 1..count do
AMQP.Basic.publish(channel, "", name,
"test_message" <> Integer.to_string(i))
end
end)
end

12
deps/rabbitmq_cli/test/test_helper.exs vendored
View File

@ -81,8 +81,16 @@ defmodule TestHelper do
def declare_queue(name, vhost, durable \\ false, auto_delete \\ false, args \\ [], owner \\ :none) do
queue_name = :rabbit_misc.r(vhost, :queue, name)
:rpc.call(get_rabbit_hostname, :rabbit_amqqueue, :declare,
[queue_name, durable, auto_delete, args, owner])
:rpc.call(get_rabbit_hostname,
:rabbit_amqqueue, :declare,
[queue_name, durable, auto_delete, args, owner])
end
def declare_exchange(name, vhost, type \\ :direct, durable \\ false, auto_delete \\ false, internal \\ false, args \\ []) do
exchange_name = :rabbit_misc.r(vhost, :exchange, name)
:rpc.call(get_rabbit_hostname,
:rabbit_exchange, :declare,
[exchange_name, type, durable, auto_delete, internal, args])
end
def list_permissions(vhost) do