propono 1.7.0 → 2.0.0.rc1

data/test/services/queue_listener_test.rb

@@ -5,30 +5,45 @@ module Propono
 
     def setup
       super
-      @topic_id = "some-topic"
+      @topic_name = "some-topic"
 
       @receipt_handle1 = "test-receipt-handle1"
       @receipt_handle2 = "test-receipt-handle2"
       @message1 = {cat: "Foobar 123"}
       @message2 = "Barfoo 543"
       @message1_id = "abc123"
-      @message1_id = "987whf"
+      @message2_id = "987whf"
       @body1 = {id: @message1_id, message: @message1}
       @body2 = {id: @message2_id, message: @message2}
-      @sqs_message1 = { "ReceiptHandle" => @receipt_handle1, "Body" => {"Message" => @body1.to_json}.to_json}
-      @sqs_message2 = { "ReceiptHandle" => @receipt_handle2, "Body" => {"Message" => @body2.to_json}.to_json}
-      @messages = { "Message" => [ @sqs_message1, @sqs_message2 ] }
-      @sqs_response = mock().tap{|m|m.stubs(body: @messages)}
-      @sqs = mock()
-      @sqs.stubs(receive_message: @sqs_response)
-      @sqs.stubs(:delete_message)
 
-      @listener = QueueListener.new(@topic_id) {}
-      @listener.stubs(sqs: @sqs)
+      @sqs_message1 = mock
+      @sqs_message1.stubs(receipt_handle: @receipt_handle1, body: {"Message" => @body1.to_json}.to_json)
+      @sqs_message2 = mock
+      @sqs_message2.stubs(receipt_handle: @receipt_handle2, body: {"Message" => @body2.to_json}.to_json)
 
-      Propono.config.num_messages_per_poll = 14
+      @queue = mock.tap {|q| q.stubs(url: "foobar", arn: "qarn") }
+      @topic = mock.tap {|t| t.stubs(arn: "tarn") }
+      aws_client.stubs(
+        create_queue: @queue,
+        create_topic: @topic
+      )
+      aws_client.stubs(:subscribe_sqs_to_sns)
+      aws_client.stubs(:set_sqs_policy)
 
-      Propono.config.max_retries = 0
+      @messages = [@sqs_message1, @sqs_message2]
+      aws_client.stubs(read_from_sqs: @messages)
+      aws_client.stubs(:delete_from_sqs)
+
+      @listener = QueueListener.new(aws_client, propono_config, @topic_name) {}
+
+      @slow_queue = mock
+      @slow_queue.stubs(url: "some_queue_url")
+      @failed_queue = mock
+      @corrupt_queue = mock
+      @listener.stubs(slow_queue: @slow_queue, corrupt_queue: @corrupt_queue, failed_queue: @failed_queue)
+
+      propono_config.num_messages_per_poll = 14
+      propono_config.max_retries = 0
     end
 
     def test_listen_should_loop
@@ -37,88 +52,70 @@ module Propono
     end
 
     def test_listen_raises_with_nil_topic
-      listener = QueueListener.new(nil) {}
+      listener = QueueListener.new(aws_client, propono_config, nil) {}
       assert_raises ProponoError do
         listener.listen
       end
     end
 
     def test_drain_should_continue_if_queue_empty
-      @listener.expects(:read_messages).returns(nil)
+      @listener.expects(:read_messages_from_queue).with(@slow_queue, 10, long_poll: false).returns(false)
+      @listener.expects(:read_messages_from_queue).with(@queue, 10, long_poll: false).returns(false)
       @listener.drain
       assert true
     end
 
     def test_drain_raises_with_nil_topic
-      listener = QueueListener.new(nil) {}
+      listener = QueueListener.new(aws_client, propono_config, nil) {}
       assert_raises ProponoError do
         listener.drain
       end
     end
 
     def test_read_messages_should_subscribe
-      QueueSubscription.expects(create: mock(queue: mock(url: {})))
+      queue = mock
+      queue.stubs(:url)
+      QueueSubscription.expects(:create).with(aws_client, propono_config, @topic_name).returns(mock(queue: queue))
       @listener.send(:read_messages)
     end
 
     def test_read_message_from_sqs
       max_number_of_messages = 5
-      queue_url = @listener.send(:main_queue_url)
-      options = { 'MaxNumberOfMessages' => max_number_of_messages }
-      @sqs.expects(:receive_message).with(queue_url, options).returns(@sqs_response)
-      @listener.send(:read_messages_from_queue, queue_url, max_number_of_messages)
+      aws_client.expects(:read_from_sqs).with(@queue, max_number_of_messages, long_poll: true)
+      @listener.send(:read_messages_from_queue, @queue, max_number_of_messages)
     end
 
     def test_log_message_from_sqs
-      queue_url = @listener.send(:main_queue_url)
-      Propono.config.logger.expects(:info).with() {|x| x == "Propono [#{@message1_id}]: Received from sqs."}
-      @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
+      propono_config.logger.expects(:info).with() {|x| x == "Propono [#{@message1_id}]: Received from sqs."}
+      @listener.send(:read_messages_from_queue, @queue, propono_config.num_messages_per_poll)
     end
 
     def test_read_messages_calls_process_message_for_each_msg
-
-      queue_url = @listener.send(:main_queue_url)
-      @listener.expects(:process_raw_message).with(@sqs_message1, queue_url)
-      @listener.expects(:process_raw_message).with(@sqs_message2, queue_url)
-      @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
+      @listener.expects(:process_raw_message).with(@sqs_message1, @queue)
+      @listener.expects(:process_raw_message).with(@sqs_message2, @queue)
+      @listener.send(:read_messages_from_queue, @queue, propono_config.num_messages_per_poll)
     end
 
     def test_read_messages_does_not_call_process_messages_if_there_are_none
-      queue_url = @listener.send(:main_queue_url)
-      @sqs_response.stubs(body: {"Message" => []})
+      aws_client.stubs(read_from_sqs: [])
       @listener.expects(:process_message).never
-      @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
+      @listener.send(:read_messages_from_queue, @queue, propono_config.num_messages_per_poll)
     end
 
     def test_exception_from_sqs_is_logged
-      queue_url = "http://example.com"
-      @listener.stubs(main_queue_url: queue_url)
-      @sqs.stubs(:receive_message).raises(StandardError)
-      Propono.config.logger.expects(:error).with("Unexpected error reading from queue http://example.com")
-      Propono.config.logger.expects(:error).with() {|x| x.is_a?(StandardError)}
-      @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
-    end
-
-    def test_forbidden_error_is_logged_and_re_raised
-      queue_url = "http://example.com"
-      @listener.stubs(queue_url: queue_url)
-      @sqs.stubs(:receive_message).raises(Excon::Errors::Forbidden.new(nil, nil, nil))
-      Propono.config.logger.expects(:error).with("Forbidden error caught and re-raised. http://example.com")
-      Propono.config.logger.expects(:error).with() {|x| x.is_a?(Excon::Errors::Forbidden)}
-      assert_raises Excon::Errors::Forbidden do
-        @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
-      end
+      aws_client.stubs(:read_from_sqs).raises(StandardError)
+      propono_config.logger.expects(:error).with("Unexpected error reading from queue #{@queue.url}")
+      @listener.send(:read_messages_from_queue, @queue, propono_config.num_messages_per_poll)
     end
 
     def test_exception_from_sqs_returns_false
-      @sqs.stubs(:receive_message).raises(StandardError)
+      aws_client.stubs(:read_from_sqs).raises(StandardError)
       refute @listener.send(:read_messages)
     end
 
     def test_each_message_processor_is_yielded
       messages_yielded = []
-      @listener = QueueListener.new(@topic_id) { |m, _| messages_yielded.push(m) }
-      @listener.stubs(sqs: @sqs)
+      @listener = QueueListener.new(aws_client, propono_config, @topic_name) { |m, _| messages_yielded.push(m) }
       @listener.send(:read_messages)
 
       assert_equal messages_yielded.size, 2
@@ -126,120 +123,116 @@ module Propono
       assert messages_yielded.include?(@message2)
     end
 
+    def test_ok_if_message_processor_is_nil
+      messages_yielded = []
+      @listener = QueueListener.new(aws_client, propono_config, @topic_name)
+
+      @listener.send(:process_message, "")
+      assert_equal messages_yielded.size, 0
+    end
+
     def test_each_message_processor_context
-      contexts = []
-      @listener = QueueListener.new(@topic_id) { |_, context| contexts << context }
-      @listener.stubs(sqs: @sqs)
+      ids = []
+      @listener = QueueListener.new(aws_client, propono_config, @topic_name) { |_, context| ids << context[:id] }
       @listener.send(:read_messages)
 
-      assert_equal contexts.size, 2
-      assert contexts.include?({id: @message1_id})
-      assert contexts.include?({id: @message2_id})
+      assert_equal ids.size, 2
+      assert ids.include?(@message1_id)
+      assert ids.include?(@message2_id)
     end
 
     def test_each_message_is_deleted
-      queue_url = "test-queue-url"
+      queue = "test-queue-url"
 
-      @sqs.expects(:delete_message).with(queue_url, @receipt_handle1)
-      @sqs.expects(:delete_message).with(queue_url, @receipt_handle2)
+      aws_client.expects(:delete_from_sqs).with(queue, @receipt_handle1)
+      aws_client.expects(:delete_from_sqs).with(queue, @receipt_handle2)
 
-      @listener.stubs(queue_url: queue_url)
-      @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
+      @listener.stubs(queue: queue)
+      @listener.send(:read_messages_from_queue, queue, propono_config.num_messages_per_poll)
     end
 
     def test_messages_are_deleted_if_there_is_an_exception_processing
-      queue_url = "test-queue-url"
-
-      @sqs.expects(:delete_message).with(queue_url, @receipt_handle1)
-      @sqs.expects(:delete_message).with(queue_url, @receipt_handle2)
+      aws_client.expects(:delete_from_sqs).with(@queue, @receipt_handle1)
+      aws_client.expects(:delete_from_sqs).with(@queue, @receipt_handle2)
 
       exception = StandardError.new("Test Error")
-      @listener = QueueListener.new(@topic_id) { raise exception }
-      @listener.stubs(queue_url: queue_url)
-      @listener.stubs(sqs: @sqs)
+      @listener = QueueListener.new(aws_client, propono_config, @topic_name) { raise exception }
       @listener.stubs(:requeue_message_on_failure).with(SqsMessage.new(@sqs_message1), exception)
       @listener.stubs(:requeue_message_on_failure).with(SqsMessage.new(@sqs_message2), exception)
-      @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
+      @listener.send(:read_messages_from_queue, @queue, propono_config.num_messages_per_poll)
     end
 
     def test_messages_are_retried_or_abandoned_on_failure
-      queue_url = "test-queue-url"
-
       exception = StandardError.new("Test Error")
-      @listener = QueueListener.new(@topic_id) { raise exception }
+      @listener = QueueListener.new(aws_client, propono_config, @topic_name) { raise exception }
       @listener.expects(:requeue_message_on_failure).with(SqsMessage.new(@sqs_message1), exception)
       @listener.expects(:requeue_message_on_failure).with(SqsMessage.new(@sqs_message2), exception)
-      @listener.stubs(sqs: @sqs)
-      @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
+      @listener.send(:read_messages_from_queue, @queue, propono_config.num_messages_per_poll)
     end
 
     def test_failed_on_moving_to_failed_queue_does_not_delete
-      queue_url = "test-queue-url"
-
       exception = StandardError.new("Test Error")
-      @listener = QueueListener.new(@topic_id) { raise exception }
+      @listener = QueueListener.new(aws_client, propono_config, @topic_name) { raise exception }
       @listener.stubs(:requeue_message_on_failure).with(SqsMessage.new(@sqs_message1), exception).raises(StandardError.new("failed to move"))
       @listener.stubs(:requeue_message_on_failure).with(SqsMessage.new(@sqs_message2), exception).raises(StandardError.new("failed to move"))
       @listener.expects(:delete_message).with(@sqs_message1).never
       @listener.expects(:delete_message).with(@sqs_message2).never
-      @listener.stubs(sqs: @sqs)
-      @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
+      @listener.send(:read_messages_from_queue, @queue, propono_config.num_messages_per_poll)
     end
 
     def test_messages_are_moved_to_corrupt_queue_if_there_is_an_parsing_exception
-      queue_url = "test-queue-url"
-      sqs_message1 = "foobar"
-      sqs_message2 = "barfoo"
-      @messages["Message"][0] = sqs_message1
-      @messages["Message"][1] = sqs_message2
+      sqs_message1 = mock(body: "foobar", receipt_handle: "123")
+      sqs_message2 = mock(body: "barfoo", receipt_handle: "321")
+      @messages[0] = sqs_message1
+      @messages[1] = sqs_message2
 
       @listener.expects(:move_to_corrupt_queue).with(sqs_message1)
       @listener.expects(:move_to_corrupt_queue).with(sqs_message2)
-      @listener.send(:read_messages_from_queue, queue_url, Propono.config.num_messages_per_poll)
+      @listener.send(:read_messages_from_queue, @queue, propono_config.num_messages_per_poll)
     end
 
     def test_message_moved_to_failed_queue_if_there_is_an_exception_and_retry_count_is_zero
-      @sqs.expects(:send_message).with(regexp_matches(/https:\/\/queue.amazonaws.com\/[0-9]+\/MyApp-some-topic-failed/), anything)
+      aws_client.expects(:send_to_sqs).with(@failed_queue, anything)
       @listener.send(:requeue_message_on_failure, SqsMessage.new(@sqs_message1), StandardError.new)
     end
 
     def test_message_requeued_if_there_is_an_exception_but_failure_count_less_than_retry_count
-      Propono.config.max_retries = Propono.config.num_messages_per_poll
+      propono_config.max_retries = propono_config.num_messages_per_poll
       message = SqsMessage.new(@sqs_message1)
       message.stubs(failure_count: 4)
-      @sqs.expects(:send_message).with(regexp_matches(/https:\/\/queue.amazonaws.com\/[0-9]+\/MyApp-some-topic$/), anything)
+      aws_client.expects(:send_to_sqs).with(@queue, anything)
       @listener.send(:requeue_message_on_failure, message, StandardError.new)
     end
 
     def test_message_requeued_if_there_is_an_exception_but_failure_count_exceeds_than_retry_count
-      Propono.config.max_retries = Propono.config.num_messages_per_poll
+      propono_config.max_retries = propono_config.num_messages_per_poll
       message = SqsMessage.new(@sqs_message1)
-      message.stubs(failure_count: Propono.config.num_messages_per_poll)
-      @sqs.expects(:send_message).with(regexp_matches(/https:\/\/queue.amazonaws.com\/[0-9]+\/MyApp-some-topic-failed/), anything)
+      message.stubs(failure_count: propono_config.num_messages_per_poll)
+      aws_client.expects(:send_to_sqs).with(@failed_queue, anything)
       @listener.send(:requeue_message_on_failure, message, StandardError.new)
     end
 
     def test_move_to_corrupt_queue
-      @sqs.expects(:send_message).with(regexp_matches(/https:\/\/queue.amazonaws.com\/[0-9]+\/MyApp-some-topic-corrupt/), anything)
+      aws_client.expects(:send_to_sqs).with(@corrupt_queue, @sqs_message1.body)
       @listener.send(:move_to_corrupt_queue, @sqs_message1)
     end
 
     def test_if_no_messages_read_from_normal_queue_read_from_slow_queue
-      main_queue_url = "http://normal.com"
-      @listener.stubs(main_queue_url: main_queue_url)
-      slow_queue_url = "http://slow.com"
-      @listener.stubs(slow_queue_url: slow_queue_url)
+      main_queue = mock
+      @listener.stubs(main_queue: main_queue)
+      slow_queue = mock
+      @listener.stubs(slow_queue: slow_queue)
 
-      @listener.expects(:read_messages_from_queue).with(main_queue_url, Propono.config.num_messages_per_poll).returns(false)
-      @listener.expects(:read_messages_from_queue).with(slow_queue_url, 1)
+      @listener.expects(:read_messages_from_queue).with(main_queue, propono_config.num_messages_per_poll).returns(false)
+      @listener.expects(:read_messages_from_queue).with(slow_queue, 1)
       @listener.send(:read_messages)
     end
 
     def test_if_read_messages_from_normal_do_not_read_from_slow_queue
-      main_queue_url = "http://normal.com"
-      @listener.stubs(main_queue_url: main_queue_url)
+      main_queue = mock
+      @listener.stubs(main_queue: main_queue)
 
-      @listener.expects(:read_messages_from_queue).with(main_queue_url, Propono.config.num_messages_per_poll).returns(true)
+      @listener.expects(:read_messages_from_queue).with(main_queue, propono_config.num_messages_per_poll).returns(true)
       @listener.send(:read_messages)
     end
   end

data/test/test_helper.rb

@@ -1,6 +1,3 @@
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
-
 gem "minitest"
 require "minitest/autorun"
 require "minitest/pride"
@@ -14,55 +11,31 @@ require "propono"
 
 class Minitest::Test
   def setup
-    Fog.mock!
-    Propono.config do |config|
-      config.access_key = "test-access-key"
-      config.secret_key = "test-secret-key"
-      config.queue_region = "us-east-1"
-      config.application_name = "MyApp"
-      config.queue_suffix = ""
-
-      config.logger.stubs(:debug)
-      config.logger.stubs(:info)
-      config.logger.stubs(:error)
-    end
   end
-end
 
-require 'fog/aws'
-class Fog::AWS::SNS::Mock
-  def create_topic(*args)
-    foo = Object.new
-    class << foo
-      def body
-        {"TopicArn" => "FoobarFromTheMock"}
-      end
-    end
-    foo
-  end
+  def propono_config
+    return @propono_config if @propono_config
 
-  def subscribe(topic_arn, arn_or_url, type)
-  end
-end
+    @propono_config = Propono::Configuration.new
+    @propono_config.access_key = "test-access-key"
+    @propono_config.secret_key = "test-secret-key"
+    @propono_config.queue_region = "us-east-1"
+    @propono_config.application_name = "MyApp"
+    @propono_config.queue_suffix = ""
 
-class Fog::AWS::SQS::Mock
-  def list_queues(*args)
-    foo = Object.new
-    class << foo
-      def body
-        {"QueueUrls" => []}
-      end
-    end
-    foo
-  end
-  def create_queue(*args)
+    @propono_config.logger.stubs(:debug)
+    @propono_config.logger.stubs(:info)
+    @propono_config.logger.stubs(:error)
+
+    @propono_config
   end
-  def set_queue_attributes(*args)
+
+  def aws_client
+    return @aws_client if @aws_client
+
+    @aws_client = Propono::AwsClient.new(mock)
+    @aws_client.stubs(:sns_client)
+    @aws_client.stubs(:sqs_client)
+    @aws_client
   end
 end
-
-Fog::AWS::SQS::Mock::QueueUrl = 'https://meducation.net/foobar'
-Fog::AWS::SQS::Mock::QueueArn = 'FoobarArn'
-data = {'Attributes' => {"QueueArn" => Fog::AWS::SQS::Mock::QueueArn}}
-queues = Fog::AWS::SQS::Mock.data["us-east-1"]["test-access-key"][:queues]
-queues[Fog::AWS::SQS::Mock::QueueUrl] = data

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: propono
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - MalcyL
@@ -9,10 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-17 00:00:00.000000000 Z
+date: 2017-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: fog-aws
+  name: aws-sdk-sns
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-sqs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -97,8 +111,9 @@ dependencies:
         version: 5.0.8
 description: Pub / Sub Library using Amazon Web Services
 email:
+- jez.walker@gmail.com
+- c.p.care@gmail.com
 - malcolm@landonsonline.me.uk
-- jeremy@meducation.net
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -112,51 +127,34 @@ files:
 - README.md
 - Rakefile
 - lib/propono.rb
+- lib/propono/components/aws_client.rb
 - lib/propono/components/aws_config.rb
-- lib/propono/components/post_subscription.rb
+- lib/propono/components/client.rb
 - lib/propono/components/queue.rb
 - lib/propono/components/queue_subscription.rb
-- lib/propono/components/sns.rb
-- lib/propono/components/sqs.rb
 - lib/propono/components/sqs_message.rb
 - lib/propono/components/topic.rb
 - lib/propono/configuration.rb
 - lib/propono/logger.rb
 - lib/propono/propono_error.rb
 - lib/propono/services/publisher.rb
-- lib/propono/services/queue_creator.rb
 - lib/propono/services/queue_listener.rb
-- lib/propono/services/subscriber.rb
-- lib/propono/services/tcp_listener.rb
-- lib/propono/services/topic_creator.rb
-- lib/propono/services/udp_listener.rb
 - lib/propono/utils.rb
 - lib/propono/version.rb
 - propono.gemspec
 - test/components/aws_config_test.rb
-- test/components/post_subscription_test.rb
+- test/components/client_test.rb
 - test/components/queue_subscription_test.rb
 - test/components/queue_test.rb
-- test/components/sns_test.rb
-- test/components/sqs_test.rb
 - test/components/topic_test.rb
 - test/config.yml.example
 - test/configuration_test.rb
 - test/integration/integration_test.rb
 - test/integration/slow_queue_test.rb
 - test/integration/sns_to_sqs_test.rb
-- test/integration/tcp_to_sqs_test.rb
-- test/integration/udp_proxy_test.rb
-- test/integration/udp_to_sqs_test.rb
 - test/logger_test.rb
-- test/propono_test.rb
 - test/services/publisher_test.rb
-- test/services/queue_creator_test.rb
 - test/services/queue_listener_test.rb
-- test/services/subscriber_test.rb
-- test/services/tcp_listener_test.rb
-- test/services/topic_creator_test.rb
-- test/services/udp_listener_test.rb
 - test/test_helper.rb
 - test/utils/hash_test.rb
 homepage: ''
@@ -174,40 +172,29 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: General purpose pub/sub library built on top of AWS SNS and SQS
 test_files:
 - test/components/aws_config_test.rb
-- test/components/post_subscription_test.rb
+- test/components/client_test.rb
 - test/components/queue_subscription_test.rb
 - test/components/queue_test.rb
-- test/components/sns_test.rb
-- test/components/sqs_test.rb
 - test/components/topic_test.rb
 - test/config.yml.example
 - test/configuration_test.rb
 - test/integration/integration_test.rb
 - test/integration/slow_queue_test.rb
 - test/integration/sns_to_sqs_test.rb
-- test/integration/tcp_to_sqs_test.rb
-- test/integration/udp_proxy_test.rb
-- test/integration/udp_to_sqs_test.rb
 - test/logger_test.rb
-- test/propono_test.rb
 - test/services/publisher_test.rb
-- test/services/queue_creator_test.rb
 - test/services/queue_listener_test.rb
-- test/services/subscriber_test.rb
-- test/services/tcp_listener_test.rb
-- test/services/topic_creator_test.rb
-- test/services/udp_listener_test.rb
 - test/test_helper.rb
 - test/utils/hash_test.rb
 has_rdoc: