propono 1.7.0 → 2.0.0.rc1

data/test/integration/integration_test.rb

@@ -2,23 +2,20 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Propono
   class IntegrationTest < Minitest::Test
-    def setup
-      super
-      Fog.unmock!
 
+    def propono_client
       config_file = YAML.load_file( File.expand_path('../../config.yml', __FILE__))
-      Propono.config do |config|
+      @propono_client ||= Propono::Client.new do |config|
         config.access_key = config_file['access_key']
         config.secret_key = config_file['secret_key']
         config.queue_region = config_file['queue_region']
         config.application_name = config_file['application_name']
-        config.udp_host = "localhost"
       end
     end
 
     # Wait a max of 20secs before failing the test
-    def wait_for_thread(thread)
-      200.times do |x|
+    def wait_for_thread(thread, secs = 20)
+      (secs * 10).times do |x|
         return true unless thread.alive?
         sleep(0.1)
       end

data/test/integration/slow_queue_test.rb

@@ -11,16 +11,18 @@ module Propono
       message_received = false
       slow_message_received = false
 
-      Propono.drain_queue(slow_topic)
-      Propono.drain_queue(topic)
-      Propono.subscribe_by_queue(topic)
+      propono_client.drain_queue(topic)
+      propono_client.drain_queue(slow_topic)
+
+      propono_client.subscribe(topic)
 
       thread = Thread.new do
         begin
-          Propono.listen_to_queue(topic) do |message, context|
+          propono_client.listen(topic) do |message, context|
             flunks << "Wrong message" unless (message == text || message == slow_text)
             message_received = true if message == text
             slow_message_received = true if message == slow_text
+            thread.terminate if message_received && slow_message_received
           end
         rescue => e
           flunks << e.message
@@ -38,12 +40,13 @@ module Propono
 
       sleep(1) # Make sure the listener has started
 
-      Propono.publish(slow_topic, slow_text, async: false)
-      Propono.publish(topic, text, async: false)
-      flunks << "Test Timeout" unless wait_for_thread(thread)
+      propono_client.publish(slow_topic, slow_text)
+      propono_client.publish(topic, text)
+
+      flunks << "Test Timeout" unless wait_for_thread(thread, 60)
       flunk(flunks.join("\n")) unless flunks.empty?
     ensure
-      # thread.terminate
+      thread.terminate if thread
     end
   end
 end

data/test/integration/sns_to_sqs_test.rb

@@ -8,15 +8,16 @@ module Propono
       flunks = []
       message_received = false
 
-      Propono.drain_queue(topic)
-      Propono.subscribe_by_queue(topic)
+      propono_client.drain_queue(topic)
+      propono_client.subscribe(topic)
 
       thread = Thread.new do
         begin
-          Propono.listen_to_queue(topic) do |message, context|
+          propono_client.listen(topic) do |message, context|
             flunks << "Wrong message" unless message == text
             flunks << "Wrong id" unless context[:id] =~ Regexp.new("[a-z0-9]{6}")
             message_received = true
+            thread.terminate
           end
         rescue => e
           flunks << e.message
@@ -33,27 +34,26 @@ module Propono
 
       sleep(1) # Make sure the listener has started
 
-      Propono.publish(topic, text)
+      propono_client.publish(topic, text)
       flunks << "Test Timeout" unless wait_for_thread(thread)
       flunk(flunks.join("\n")) unless flunks.empty?
     ensure
-      thread.terminate
+      thread.terminate if thread
     end
 
 =begin
-
-
     def test_failed_messge_is_transferred_to_failed_channel
-      topic = "test-topic"
+      topic = "propono-tests-sns-to-sqs-topic-failed"
       text = "This is my message #{DateTime.now} #{rand()}"
       flunks = []
       message_received = false
 
-      Propono.subscribe_by_queue(topic)
+      propono_client.drain_queue(topic)
+      propono_client.subscribe(topic)
 
       thread = Thread.new do
         begin
-          Propono.listen_to_queue(topic) do |message, context|
+          propono_client.listen(topic) do |message, context|
             raise StandardError.new 'BOOM'
           end
         rescue => e
@@ -63,12 +63,13 @@ module Propono
         end
       end
 
-      failure_listener = Thread.new do
+      failure_thread = Thread.new do
         begin
-          Propono.listen_to_queue(topic, channel: :failed) do |message, context|
+          propono_client.listen(topic, channel: :failed) do |message, context|
             flunks << "Wrong message" unless message == text
             flunks << "Wrong id" unless context[:id] =~ Regexp.new("[a-z0-9]{6}")
             message_received = true
+            failure_thread.terminate
           end
         rescue => e
           flunks << e.message
@@ -79,21 +80,20 @@ module Propono
 
       Thread.new do
         sleep(1) while !message_received
+        p "Message received"
         sleep(5) # Make sure all the message deletion clear up in the thread has happened
         thread.terminate
-        failure_listener.terminate
+        failure_thread.terminate
       end
 
       sleep(1) # Make sure the listener has started
 
-      Propono.publish(topic, text)
+      propono_client.publish(topic, text)
       flunks << "Test Timeout" unless wait_for_thread(thread)
       flunk(flunks.join("\n")) unless flunks.empty?
     ensure
-      thread.terminate
+      thread.terminate if thread
     end
-
 =end
-
   end
 end

data/test/services/publisher_test.rb

@@ -4,94 +4,87 @@ module Propono
   class PublisherTest < Minitest::Test
 
     def test_initialization
-      publisher = Publisher.new('topic', 'message')
+      publisher = Publisher.new(aws_client, propono_config, 'topic', 'message')
       refute publisher.nil?
     end
 
     def test_self_publish_calls_new
       topic = "topic123"
       message = "message123"
-      Publisher.expects(:new).with(topic, message, {}).returns(mock(publish: nil))
-      Publisher.publish(topic, message)
+      Publisher.expects(:new).with(aws_client, topic, message).returns(mock(publish: nil))
+      Publisher.publish(aws_client, topic, message)
     end
 
     def test_initializer_generates_an_id
-      publisher = Publisher.new('x','y')
+      publisher = Publisher.new(aws_client, propono_config, 'x','y')
       assert publisher.instance_variable_get(:@id)
     end
 
     def test_initializer_concats_an_id
       id = "q1w2e3"
-      publisher = Publisher.new('x','y', id: id)
-      assert publisher.id =~ Regexp.new("^#{id}-[a-z0-9]{6}$")
+      hex = "313abd"
+      SecureRandom.expects(:hex).with(3).returns(hex)
+      publisher = Publisher.new(aws_client, propono_config, 'x','y', id: id)
+      assert_equal "#{id}-#{hex}", publisher.id
     end
 
     def test_self_publish_calls_publish
       Publisher.any_instance.expects(:publish)
-      Publisher.publish("topic", "message")
-    end
-
-    def test_protocol_should_be_sns_by_default
-      publisher = Publisher.new('topic', 'message')
-      assert_equal :sns, publisher.protocol
+      Publisher.publish(aws_client, propono_config, "topic", "message")
     end
 
     def test_publish_logs
-      publisher = Publisher.new("foo", "bar")
+      publisher = Publisher.new(aws_client, propono_config, "foo", "bar")
       publisher.instance_variable_set(:@id, 'abc')
-      publisher.stubs(:publish_via_sns)
-      Propono.config.logger.expects(:info).with {|x| x =~ /^Propono \[abc\]: Publishing bar to foo via sns.*/}
-      publisher.send(:publish)
-    end
-
-    def test_publish_proxies_to_sns
-      publisher = Publisher.new('topic', 'message')
-      publisher.expects(:publish_via_sns)
-      publisher.publish
-    end
-
-    def test_publish_proxies_to_udp
-      publisher = Publisher.new('topic', 'message', protocol: :udp)
-      publisher.expects(:publish_via_udp)
+      publisher.stubs(:publish_syncronously)
+      propono_config.logger.expects(:info).with {|x| x =~ /^Propono \[abc\]: Publishing bar to foo.*/}
       publisher.publish
     end
 
-    def test_publish_via_sns_should_call_sns_on_correct_topic_and_message
-      topic = "topic123"
+    def test_publish_should_call_sns_on_correct_topic_and_message
+      topic_name = "topic123"
       id = "f123"
       message = "message123"
+
+      topic = mock
       topic_arn = "arn123"
-      topic = Topic.new(topic_arn)
+      topic.stubs(arn: topic_arn)
 
-      TopicCreator.stubs(find_or_create: topic)
+      aws_client.expects(:create_topic).with(topic_name).returns(topic)
+      aws_client.expects(:publish_to_sns).with(
+        topic,
+        {id: id, message: message}
+      )
 
-      sns = mock()
-      sns.expects(:publish).with(topic_arn, {id: id, message: message}.to_json)
-      publisher = Publisher.new(topic, message)
-      publisher.stubs(id: id, sns: sns)
-      thread = publisher.send(:publish_via_sns)
-      thread.join
+      publisher = Publisher.new(aws_client, propono_config, topic_name, message)
+      publisher.stubs(id: id)
+      publisher.publish
     end
 
-    def test_publish_via_sns_should_accept_a_hash_for_message
-      topic = "topic123"
+    def test_publish_should_accept_a_hash_for_message
+      topic_name = "topic123"
       id = "foobar123"
       message = {something: ['some', 123, true]}
       body = {id: id, message: message}
 
+      topic = mock
       topic_arn = "arn123"
-      topic = Topic.new(topic_arn)
-      TopicCreator.stubs(find_or_create: topic)
+      topic.stubs(topic_arn: topic_arn)
 
-      sns = mock()
-      sns.expects(:publish).with(topic_arn, body.to_json)
-      publisher = Publisher.new(topic, message)
-      publisher.stubs(id: id, sns: sns)
-      thread = publisher.send(:publish_via_sns)
-      thread.join
+      topic = mock
+      topic_arn = "arn123"
+      topic.stubs(arn: topic_arn)
+
+      aws_client.expects(:create_topic).with(topic_name).returns(topic)
+      aws_client.expects(:publish_to_sns).with(topic, body)
+
+      publisher = Publisher.new(aws_client, propono_config, topic_name, message)
+      publisher.stubs(id: id)
+      publisher.publish
     end
 
-    def test_publish_via_sns_should_return_future_of_the_sns_response
+    def test_publish_async_should_return_future_of_the_sns_response
+      skip "Rebuild this maybe"
       topic = "topic123"
       id = "foobar123"
       message = "message123"
@@ -99,142 +92,52 @@ module Propono
 
       topic_arn = "arn123"
       topic = Topic.new(topic_arn)
-      TopicCreator.stubs(find_or_create: topic)
 
       sns = mock()
       sns.expects(:publish).with(topic_arn, body.to_json).returns(:response)
-      publisher = Publisher.new(topic, message)
+      publisher = Publisher.new(aws_client, propono_config, topic, message, async: true)
       publisher.stubs(id: id, sns: sns)
-      assert_same :response, publisher.send(:publish_via_sns).value
+      assert_same :response, publisher.send(:publish_syncronously).value
     end
 
-    def test_publish_via_sns_should_propogate_exception_on_topic_creation_error
-      TopicCreator.stubs(:find_or_create).raises(TopicCreatorError)
+    def test_publish_should_propogate_exception_on_topic_creation_error
+      aws_client.expects(:create_topic).raises(RuntimeError)
+      publisher = Publisher.new(aws_client, propono_config, "topic", "message")
 
-      assert_raises(TopicCreatorError) do
-        publisher = Publisher.new("topic", "message")
-        thread = publisher.send(:publish_via_sns)
-        thread.join
+      assert_raises(RuntimeError) do
+        publisher.publish
       end
     end
 
-    def test_publish_via_sns_creates_a_topic
-      topic_id = "Malcs_topic_id"
-      topic_arn = "Malcs_topic_arn"
-      topic = Topic.new(topic_arn)
-
-      TopicCreator.expects(:find_or_create).with(topic_id).returns(topic)
-
-      sns = mock()
-      sns.stubs(:publish)
-      publisher = Publisher.new(topic_id, "Foobar")
-      publisher.stubs(sns: sns)
-
-      thread = publisher.send(:publish_via_sns)
-      thread.join
-    end
-
-    def test_udp_uses_correct_message_host_and_port
-      host = "http://meducation.net"
-      port = 1234
-      Propono.config.udp_host = host
-      Propono.config.udp_port = port
-      topic_id = "my-fav-topic"
-
-      id = "foobar123"
-      message = "cat dog mouse"
-      payload = {id: id, message: message, topic: topic_id}.to_json
-      UDPSocket.any_instance.expects(:send).with(payload, 0, host, port)
-
-      publisher = Publisher.new(topic_id, message)
-      publisher.stubs(id: id)
-      publisher.send(:publish_via_udp)
-    end
-
-    def test_exception_from_udpsocket_caught_and_logged
-      host = "http://meducation.net"
-      port = 1234
-      Propono.config.udp_host = host
-      Propono.config.udp_port = port
-
-      publisher = Publisher.new("topic_id", "message")
-      publisher.stubs(id: '123asd')
-      Propono.config.logger.expects(:error).with() {|x| x =~ /^Propono \[123asd\]: Failed to send : getaddrinfo:.*/}
-      publisher.send(:publish_via_udp)
-    end
-
     def test_publish_should_raise_exception_if_topic_is_nil
       assert_raises(PublisherError, "Topic is nil") do
-        Publisher.publish(nil, "foobar")
+        Publisher.publish(aws_client, propono_config, nil, "foobar")
       end
     end
 
-    def test_tcp_uses_correct_message
-      Propono.config.tcp_host = "http://meducation.net"
-      Propono.config.tcp_port = 1234
-      topic_id = "my-fav-topic"
-      id = "qweqw2312"
-      message = "foobar"
-      payload = {id: id, message: message, topic: topic_id}.to_json
-
-      socket = mock()
-      socket.expects(:write).with(payload)
-      socket.expects(:close)
-      TCPSocket.stubs(new: socket)
-
-      publisher = Publisher.new(topic_id, message)
-      publisher.stubs(id: id)
-      publisher.send(:publish_via_tcp)
-    end
-
-    def test_tcp_uses_correct_message_host_and_port
-      host = "http://meducation.net"
-      port = 1234
-      Propono.config.tcp_host = host
-      Propono.config.tcp_port = port
-      topic_id = "my-fav-topic"
-      message = "foobar"
-      TCPSocket.expects(:new).with(host, port)
-
-      publisher = Publisher.new(topic_id, message)
-      publisher.send(:publish_via_tcp)
-    end
-
-    def test_exception_from_tcpsocket_caught_and_logged
-      host = "http://meducation.net"
-      port = 1234
-      Propono.config.tcp_host = host
-      Propono.config.tcp_port = port
-
-      publisher = Publisher.new("topic_id", "message")
-      publisher.stubs(id: '123asd')
-      Propono.config.logger.expects(:error).with() {|x| x =~ /^Propono \[123asd\]: Failed to send : getaddrinfo:.*/}
-      publisher.send(:publish_via_tcp)
-    end
-
     def test_publish_should_raise_exception_if_topic_is_nil
       assert_raises(PublisherError, "Topic is nil") do
-        Publisher.publish(nil, "foobar")
+        Publisher.publish(aws_client, propono_config, nil, "foobar")
       end
     end
 
     def test_publish_should_raise_exception_if_message_is_nil
       assert_raises(PublisherError, "Message is nil") do
-        Publisher.publish("foobar", nil)
+        Publisher.publish(aws_client, propono_config, "foobar", nil)
       end
     end
 
     def test_publish_can_be_called_syncronously
-      publisher = Publisher.new("topic_id", "message", async: false)
-      publisher.expects(:publish_via_sns_syncronously).once
-      publisher.expects(:publish_via_sns_asyncronously).never
-      publisher.send(:publish_via_sns)
+      publisher = Publisher.new(aws_client, propono_config, "topic_name", "message", async: true)
+      publisher.expects(:publish_syncronously).never
+      publisher.expects(:publish_asyncronously).once
+      publisher.publish
     end
 
-    def test_publish_is_normally_called_asyncronously
-      publisher = Publisher.new("topic_id", "message")
-      publisher.expects(:publish_via_sns_asyncronously)
-      publisher.send(:publish_via_sns)
+    def test_publish_is_normally_called_syncronously
+      publisher = Publisher.new(aws_client, propono_config, "topic_name", "message")
+      publisher.expects(:publish_syncronously)
+      publisher.publish
     end
   end
 end