propono 1.7.0 → 2.0.0.rc1

data/test/propono_test.rb

@@ -1,83 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-module Propono
-  class ProponoTest < Minitest::Test
-
-    def test_publish_calls_publisher_publish
-      topic, message = "Foo", "Bar"
-      Publisher.expects(:publish).with(topic, message, {})
-      Propono.publish(topic, message)
-    end
-
-    def test_publish_sets_suffix_publish
-      Propono.config.queue_suffix = "-bar"
-      topic = "foo"
-      Publisher.expects(:publish).with("foo-bar", '', {})
-      Propono.publish(topic, "")
-    ensure
-      Propono.config.queue_suffix = ""
-    end
-
-    def test_subscribe_by_queue_calls_subscribe
-      topic = 'foobar'
-      Subscriber.expects(:subscribe_by_queue).with(topic)
-      Propono.subscribe_by_queue(topic)
-    end
-
-    def test_subscribe_by_post_calls_subscribe
-      topic, endpoint = 'foo', 'bar'
-      Subscriber.expects(:subscribe_by_post).with(topic, endpoint)
-      Propono.subscribe_by_post(topic, endpoint)
-    end
-
-    def test_listen_to_queue_calls_queue_listener
-      topic = 'foobar'
-      QueueListener.expects(:listen).with(topic)
-      Propono.listen_to_queue(topic)
-    end
-
-    def test_drain_queue_calls_queue_listener
-      topic = 'foobar'
-      QueueListener.expects(:drain).with(topic)
-      Propono.drain_queue(topic)
-    end
-
-    def test_listen_to_udp_calls_udp_listener
-      UdpListener.expects(:listen).with()
-      Propono.listen_to_udp()
-    end
-
-    def test_listen_to_tcp_calls_tcp_listener
-      TcpListener.expects(:listen).with()
-      Propono.listen_to_tcp()
-    end
-
-    def test_proxy_udp_calls_listen
-      UdpListener.expects(:listen).with()
-      Propono.proxy_udp()
-    end
-
-    def test_proxy_udp_calls_publish_in_the_block
-      topic = "foobar"
-      message = "message"
-      options = {id: "catdog"}
-      Propono.stubs(:listen_to_udp).yields(topic, message, options)
-      Publisher.expects(:publish).with(topic, message, options)
-      Propono.proxy_udp
-    end
-
-    def test_proxy_tcp_calls_listen
-      TcpListener.expects(:listen).with()
-      Propono.proxy_tcp()
-    end
-
-    def test_proxy_tcp_calls_publish_in_the_block
-      topic = "foobar"
-      message = "message"
-      options = {id: "catdog"}
-      Propono.stubs(:listen_to_tcp).yields(topic, message, options)
-      Publisher.expects(:publish).with(topic, message, options)
-      Propono.proxy_tcp
-    end
-  end
-end

data/test/services/queue_creator_test.rb

@@ -1,61 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Propono
-  class QueueCreatorTest < Minitest::Test
-
-    def test_finds_existing_url
-      name = "foobar"
-      url = "http://#{name}"
-      sqs = Fog::AWS::SQS::Mock.new
-      sqs.stubs(:list_queues)
-      sqs.expects(:list_queues).
-        with("QueueNamePrefix" => "#{name}").
-        returns(
-          mock(body: { "QueueUrls" => [url]})
-        )
-
-      creator = QueueCreator.new(name)
-      creator.stubs(sqs: sqs)
-
-      queue = creator.find_or_create
-      assert_equal url, queue.url
-    end
-
-    def test_create_queue_called_on_sqs
-      sqs = Fog::AWS::SQS::Mock.new
-      sqs.expects(:create_queue).with("foobar").returns(mock(body: { "QueueUrl" => "Foobar"}))
-
-      creator = QueueCreator.new("foobar")
-      creator.stubs(sqs: sqs)
-
-      creator.find_or_create
-    end
-
-    def test_returns_url
-      url = "malcs_happy_queue"
-      result = mock(body: { "QueueUrl" => url})
-      sqs = Fog::AWS::SQS::Mock.new
-      sqs.expects(create_queue: result)
-
-      creator = QueueCreator.new("foobar")
-      creator.stubs(sqs: sqs)
-
-      queue = creator.find_or_create
-      assert_equal url, queue.url
-    end
-
-    def test_should_raise_exception_if_no_queue_returned
-      result = mock(body: {})
-      sqs = Fog::AWS::SQS::Mock.new
-      sqs.expects(create_queue: result)
-
-      creator = QueueCreator.new("foobar")
-      creator.stubs(sqs: sqs)
-
-      assert_raises QueueCreatorError do
-        creator.find_or_create
-      end
-    end
-  end
-end
-

data/test/services/subscriber_test.rb

@@ -1,21 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Propono
-  class SubscriberTest < Minitest::Test
-
-    def test_subscribe_by_queue_calls_queue_subscriber
-      subscriber = QueueSubscription.new("topic")
-      QueueSubscription.expects(:new).with("topic", {}).returns(subscriber)
-      QueueSubscription.any_instance.expects(:create)
-      Subscriber.subscribe_by_queue("topic")
-    end
-
-    def test_subscribe_by_post_calls_post_subscribe
-      subscriber = PostSubscription.new("topic", 'endpoint')
-      PostSubscription.expects(:new).with("topic", 'endpoint').returns(subscriber)
-      PostSubscription.any_instance.expects(:create)
-      Subscriber.subscribe_by_post("topic", "endpoint")
-    end
-
-  end
-end

data/test/services/tcp_listener_test.rb

@@ -1,76 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Propono
-  class TcpListenerTest < Minitest::Test
-
-    def test_intialize_sets_locals
-      block = Proc.new {}
-      listener = TcpListener.new(&block)
-      assert_equal block, listener.instance_variable_get("@processor")
-    end
-
-    def test_server_is_setup_correctly
-      port = 1234
-      Propono.config.tcp_port = port
-
-      TCPServer.expects(:open).with(port)
-
-      listener = TcpListener.new() {}
-      server = listener.send(:server)
-    end
-
-    def test_initialize_should_fail_without_a_block
-      assert_raises(TcpListenerError) do
-        TcpListener.new
-      end
-    end
-
-    def test_message_is_processed
-      tcp_msg = "Foobar"
-      processor = Proc.new {}
-      listener = TcpListener.new(&processor)
-      client = mock()
-      client.expects(:recvfrom => [tcp_msg])
-      client.expects(:close)
-
-      server = mock()
-      server.expects(accept: client)
-
-      listener.stubs(server: server)
-      listener.expects(:process_tcp_data).with(tcp_msg)
-      thread = listener.send(:receive_and_process)
-      thread.join
-    end
-
-    def test_processor_is_called_correctly
-      topic = "my-topic"
-      message = "my-message"
-      id = "qwe123"
-      processor = Proc.new {}
-      tcp_data = {topic: topic, message: message, id: id}.to_json
-      processor.expects(:call).with(topic, message, {id: id})
-
-      listener = TcpListener.new(&processor)
-      listener.send(:process_tcp_data, tcp_data)
-    end
-
-    def test_listen_should_loop
-      listener = TcpListener.new {}
-      listener.expects(:loop)
-      listener.listen
-    end
-  end
-
-  class TcpListenerLegacyTest < Minitest::Test
-    def test_processor_is_called_correctly
-      topic = "my-topic"
-      message = "my-message"
-      processor = Proc.new {}
-      tcp_data = {topic: topic, message: message}.to_json
-      processor.expects(:call).with(topic, message)
-
-      listener = TcpListener.new(&processor)
-      listener.send(:process_tcp_data, tcp_data)
-    end
-  end
-end

data/test/services/topic_creator_test.rb

@@ -1,40 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Propono
-  class TopicCreatorTest < Minitest::Test
-
-    def test_create_topic_called_on_sns
-      sns = mock()
-      sns.expects(:create_topic).with("foobar").returns(mock(body: { "TopicArn" => @arn}))
-
-      creator = TopicCreator.new("foobar")
-      creator.stubs(sns: sns)
-
-      creator.find_or_create
-    end
-
-    def test_returns_arn
-      arn = "malcs_happy_arn"
-      result = mock(body: { "TopicArn" => arn})
-      sns = mock(create_topic: result)
-
-      creator = TopicCreator.new("foobar")
-      creator.stubs(sns: sns)
-
-      topic = creator.find_or_create
-      assert_equal arn, topic.arn
-    end
-
-    def test_should_raise_exception_if_no_arn_returned
-      result = mock(body: {})
-      sns = mock(create_topic: result)
-
-      creator = TopicCreator.new("foobar")
-      creator.stubs(sns: sns)
-
-      assert_raises TopicCreatorError do
-        creator.find_or_create
-      end
-    end
-  end
-end

data/test/services/udp_listener_test.rb

@@ -1,73 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Propono
-  class UdpListenerTest < Minitest::Test
-
-    def test_intialize_sets_locals
-      block = Proc.new {}
-      listener = UdpListener.new(&block)
-      assert_equal block, listener.instance_variable_get("@processor")
-    end
-
-    def test_socket_is_setup_correctly
-      host = "my-host"
-      port = 1234
-
-      Propono.config.udp_host = host
-      Propono.config.udp_port = port
-
-      UDPSocket.any_instance.expects(:bind).with(host, port)
-
-      listener = UdpListener.new() {}
-      socket = listener.send(:socket)
-    end
-
-    def test_initialize_should_fail_without_a_block
-      assert_raises(UdpListenerError) do
-        UdpListener.new
-      end
-    end
-
-    def test_message_is_processed
-      udp_msg = "Foobar"
-      processor = Proc.new {}
-      server = UdpListener.new(&processor)
-      socket = mock(recvfrom: [udp_msg])
-      server.stubs(socket: socket)
-      server.expects(:process_udp_data).with(udp_msg)
-      thread = server.send(:receive_and_process)
-      thread.join
-    end
-
-    def test_processor_is_called_correctly
-      topic = "my-topic"
-      message = "my-message"
-      id = "123asd"
-      processor = Proc.new {}
-      udp_data = {topic: topic, message: message, id: id}.to_json
-      processor.expects(:call).with(topic, message, {id: id})
-
-      server = UdpListener.new(&processor)
-      server.send(:process_udp_data, udp_data)
-    end
-
-    def test_listen_should_loop
-      listener = UdpListener.new {}
-      listener.expects(:loop)
-      listener.listen
-    end
-  end
-
-  class UdpListenerLegacyTest < Minitest::Test
-    def test_processor_is_called_correctly
-      topic = "my-topic"
-      message = "my-message"
-      processor = Proc.new {}
-      udp_data = {topic: topic, message: message}.to_json
-      processor.expects(:call).with(topic, message)
-
-      server = UdpListener.new(&processor)
-      server.send(:process_udp_data, udp_data)
-    end
-  end
-end