gilmour 0.3.4 → 0.4.1

data/test/spec/test_pipelines.rb

@@ -0,0 +1,207 @@
+require 'rspec/given'
+
+require_relative '../../lib/gilmour'
+require_relative 'helpers/common'
+
+class Server
+  include Gilmour::Base
+end
+
+describe 'Pipelines' do
+  after(:all) do
+    EM.stop
+  end
+  Given(:gilmour) { 
+    Server.new.enable_backend('redis')
+  }
+  When {
+    gilmour.reply_to 'one' do
+      respond request.body.merge({'one' => 'foo'})
+    end
+  }
+  When {
+    gilmour.reply_to 'two' do
+      respond request.body.merge({'two' => 'foo'})
+    end
+  }
+  When {
+    gilmour.reply_to 'badtwo' do
+      respond request.body.merge({'badtwo' => 'foo'}), 500
+    end
+  }
+  When {
+    gilmour.reply_to 'three' do
+      respond request.body.merge({'three' => 'foo'})
+    end
+  }
+  When {
+    # Make sure all subscribers are active
+    sleep 1
+  }
+  context 'Compose' do
+    Given(:composed) {
+      gilmour.compose([{topic: 'one'}, {topic: 'two'},
+                       {topic: 'three', message: {'anotherthree' => 'anotherthree'}}])
+    }
+   Then {
+      waiter = Waiter.new
+      code = data = nil
+      composed.execute({zero: 'foo'}) do |d, c|
+        data = d
+        code = c
+        waiter.signal
+      end
+      waiter.wait
+      ['zero', 'one', 'two', 'three', 'anotherthree'].each do |k|
+        expect(data.has_key?(k)).to be_truthy
+      end
+      expect(code).to eq(200)
+    }
+  end
+
+  context 'AndAnd' do
+    context 'All successful' do
+      Given(:andand) {
+        gilmour.andand([{topic: 'one'}, {topic: 'two'},
+                        {topic: 'three', message: {'anotherthree' => 'anotherthree'}}])
+      }
+      Then {
+        waiter = Waiter.new
+        code = data = nil
+        andand.execute do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait
+        expect(data.keys.size).to eq(2)
+        ['three', 'anotherthree'].each do |k|
+          expect(data.has_key?(k)).to be_truthy
+        end
+        expect(code).to eq(200)
+      }
+    end
+
+    context 'Interrupted' do
+      Given(:interupted) {
+        gilmour.andand([{topic: 'one'}, {topic: 'badtwo'},
+                        {topic: 'three', message: {'anotherthree' => 'anotherthree'}}])
+      }
+      Given(:firsttry) {
+        waiter = Waiter.new
+        cont = code = data = nil
+        interupted.execute do |d, c, continuation|
+          data = d
+          code = c
+          cont = continuation
+          waiter.signal
+        end
+        waiter.wait
+        {code: code, data: data, continuation: cont}
+      }
+      Given(:secondtry) {
+        waiter = Waiter.new
+        code = data = nil
+        firsttry[:continuation].execute do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait
+        {code: code, data: data}
+      }
+      Then {
+        data = firsttry[:data]
+        code = firsttry[:code]
+        expect(data.keys.size).to eq(1)
+        ['badtwo'].each do |k|
+          expect(data.has_key?(k)).to be_truthy
+        end
+        expect(code).to eq(500)
+      }
+      And {
+        data = secondtry[:data]
+        code = secondtry[:code]
+        expect(data.keys.size).to eq(2)
+        ['three', 'anotherthree'].each do |k|
+          expect(data.has_key?(k)).to be_truthy
+        end
+        expect(code).to eq(200)
+     }
+    end
+  end
+
+  context 'Batch' do
+    context 'Without record' do
+      Given(:batch) {
+        gilmour.batch([{topic: 'one'}, {topic: 'badtwo'},
+                        {topic: 'three', message: {'anotherthree' => 'anotherthree'}}])
+      }
+      Then {
+        waiter = Waiter.new
+        code = data = nil
+        batch.execute do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait
+        expect(data).to be_kind_of(Hash)
+        expect(data.keys.size).to eq(2)
+        ['three', 'anotherthree'].each do |k|
+          expect(data.has_key?(k)).to be_truthy
+        end
+        expect(code).to eq(200)
+      }
+    end
+
+    context 'With record' do
+      Given(:batchrecord) {
+        gilmour.batch([{topic: 'one'}, {topic: 'badtwo'},
+                        {topic: 'three', message: {'anotherthree' => 'anotherthree'}}],
+                      true)
+      }
+      Then {
+        waiter = Waiter.new
+        code = data = nil
+        batchrecord.execute do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait
+        expect(data).to be_kind_of(Array)
+        expect(data.size).to eq(3)
+        %w{one badtwo three anotherthree}.each do |k|
+          expect(data.find {|o| o[:data].has_key?(k)}).not_to be_nil
+        end
+      }
+    end
+  end
+  context 'Combinations' do
+    context 'Andand and compose' do
+      Given(:andand) {
+        gilmour.andand([{topic: 'one'}, {topic: 'two'}])
+      }
+      Given(:compose) {
+        gilmour.compose([andand, {topic: 'three'}])
+      }
+      Then {
+        waiter = Waiter.new
+        code = data = nil
+        compose.execute do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait
+        expect(data.keys.size).to eq(2)
+        ['two', 'three'].each do |k|
+          expect(data.has_key?(k)).to be_truthy
+        end
+        expect(code).to eq(200)
+      }
+    end
+  end
+end
+

data/test/spec/test_subscriber_redis.rb

@@ -264,7 +264,7 @@ describe 'TestSubscriber' do
 
     end
 
-    context 'Send and receive a message' do
+    context 'Send and receive a message', :debug do
       Given(:ping_opts) { redis_ping_options }
       When(:sub) do
         Gilmour::RedisBackend.new({})

data/test/spec/test_subscriber_redis_forked.rb

@@ -206,7 +206,7 @@ describe 'TestSubscriberFork' do
       end
     end
 
-    context 'Send and receive a message' do
+    context 'Send and receive a message', :debug do
       Given(:ping_opts) { redis_ping_options }
       When(:sub) do
         Gilmour::RedisBackend.new({})
@@ -375,7 +375,6 @@ describe 'TestSubscriberFork' do
 
         Thread.new{
           loop {
-            $stderr.puts "Checking values"
             sub.publisher.lpop(error_key) do |val|
               if val.is_a? String
                 code = 500

data/test/spec/test_subscriber_redis_reply_slot.rb

@@ -0,0 +1,303 @@
+# encoding: utf-8
+require 'rspec/given'
+require 'securerandom'
+require './testservice/test_service_base'
+
+require_relative 'helpers/common'
+require_relative 'helpers/connection'
+
+def install_test_subscriber
+  waiter = Waiter.new
+  TestReplier.callback do |topic, data|
+    @topic = topic
+    @data = data
+    $stderr.puts "Got callback #{topic}, #{data}"
+    waiter.signal
+  end
+  waiter
+end
+
+describe 'TestReplier' do
+  opts = redis_connection_options
+  opts[:health_check] = true
+
+  test_subscriber_path = './testservice/subscribers/test_reply'
+  after(:all) do
+    EM.stop
+  end
+  Given(:subscriber) { TestServiceBase }
+  Given do
+    subscriber.load_subscriber(test_subscriber_path)
+  end
+  Then do
+    handlers = subscriber.subscribers(TestReplier::Topic)
+    module_present = handlers.find { |h| h[:subscriber] == TestReplier }
+    module_present.should be_truthy
+  end
+
+  context 'Running Service' do
+    before(:all) do
+      @service = TestServiceBase.new(opts, 'redis')
+    end
+    Given(:connection_opts) { opts }
+    before(:all) do
+      @service.registered_subscribers.each do |s|
+        s.backend = 'redis'
+      end
+      @service.start
+    end
+
+    context 'Handler Register' do
+      When { install_test_subscriber }
+      context 'Check registered handlers' do
+        When(:handlers) do
+          subscriber.subscribers(TestReplier::Simulation)
+          .map { |h| h[:handler] }
+        end
+        Then { handlers.each { |h| h.should be_kind_of Proc } }
+        Then  do
+          arg1 = TestReplier::Simulation
+          handlers.each do |h|
+            arg2 = SecureRandom.hex
+            # simualate a handler call
+            h.call(arg1, arg2)
+            @topic.should be == arg1
+            @data.should be == arg2
+          end
+        end
+      end
+    end
+
+    context 'Receive messages' do
+      context 'Receive a message' do
+        Given(:ping_opts) { redis_ping_options }
+        When do
+          @data = @topic = nil
+          waiter = install_test_subscriber
+          g = Gilmour::RedisBackend.new({})
+          g.request!(ping_opts[:message], TestReplier::Topic)
+          waiter.wait(5)
+        end
+        Then do
+          @data.should be == ping_opts[:message]
+          @topic.should be == "gilmour.request.#{TestReplier::Topic}"
+        end
+        And { expect(EM.reactor_thread.alive?).to be_truthy }
+      end
+    end
+
+    context 'Non Fork can add dynamic listeners', :fork_dynamic do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:code) do
+        waiter = Waiter.new
+        dynamicaly_subscribed = 0
+
+        sub.request!(1, TestReplier::ReListenTopic) do |d, c|
+          sub.confirm_subscriber(sub.request_destination("test.world")) do |present|
+            dynamicaly_subscribed = present
+            waiter.signal
+          end
+        end
+
+        waiter.wait(5)
+        dynamicaly_subscribed
+      end
+      Then do
+        code.should be == true
+      end
+    end
+
+    context 'Publisher side timeout' do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:code) do
+        code = nil
+        waiter_code = Waiter.new
+
+        sub.request!(3, TestReplier::TimeoutTopic, {:timeout => 1}) do |d, c|
+          code = c
+          waiter_code.signal
+        end
+
+        waiter_code.wait(5)
+        code
+      end
+      Then do
+        code.should be == 499
+      end
+    end
+
+    context 'Handler sleeps longer than the Timeout' do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:code) do
+        waiter_error = Waiter.new
+        waiter_code = Waiter.new
+        code = nil
+
+        backend = @service.get_backend("redis")
+        backend.broadcast_errors = true
+        sub.slot Gilmour::ErrorChannel do
+          waiter_error.signal
+        end
+
+        sub.request!(3, TestReplier::TimeoutTopic) do |d, c|
+          code = c
+          waiter_code.signal
+        end
+
+        waiter_code.wait(5)
+        waiter_error.wait(5)
+
+        backend.broadcast_errors = false
+        code
+      end
+      Then do
+        code.should be == 504
+      end
+    end
+
+    context 'Handler sleeps just enough to survive the timeout' do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:code) do
+        waiter = Waiter.new
+        code = nil
+
+        sub.request!(1, TestReplier::TimeoutTopic) do |d, c|
+          code = c
+          waiter.signal
+        end
+
+        waiter.wait(5)
+        code
+      end
+      Then do
+        code.should be == 200
+      end
+    end
+
+
+    context 'Request! sans subscriber error' do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:response) do
+        waiter = Waiter.new
+        data = code = nil
+        sub.request!(ping_opts[:message], "hello.world") do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait(5)
+        [data, code]
+      end
+      Then do
+        data, code = response
+        data.should be == nil
+        code.should be == 404
+      end
+
+    end
+
+    context 'Send and receive a message' do
+      Given(:ping_opts) { redis_ping_options }
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:response) do
+        waiter = Waiter.new
+        data = code = nil
+        sub.request!(ping_opts[:message], TestReplier::Topic) do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait(5)
+        [data, code]
+      end
+      Then do
+        data, code = response
+        data.should be == ping_opts[:response]
+        code.should be == 200
+      end
+    end
+
+    context 'Send once, Receive twice' do
+      Given(:ping_opts) { redis_ping_options }
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When (:response) do
+        waiter = Waiter.new
+
+        actual_ret = []
+
+        group_proc = sub.slot TestReplier::GroupReturn do
+          actual_ret.push(request.body)
+          waiter.signal if actual_ret.length == 4
+        end
+
+        sub.signal!(ping_opts[:message], TestReplier::GroupTopic)
+        waiter.wait(5)
+
+        sub.remove_slot TestReplier::GroupReturn, group_proc
+        actual_ret
+      end
+      Then do
+        response.select { |e| e == ping_opts[:message] }.size.should == 2
+        response.select { |e| e == "2" }.size.should == 2
+      end
+    end
+
+    context 'Send message from subscriber' do
+      Given(:ping_opts) { redis_ping_options }
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When (:response) do
+        data = code = nil
+        waiter = Waiter.new
+        sub.request!(ping_opts[:message], TestReplier::Republish) do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait(5)
+        [data, code]
+      end
+      Then do
+        data, code = response
+        data.should be == ping_opts[:response]
+        code.should be == 200
+      end
+      And { expect(EM.reactor_thread.alive?).to be_truthy }
+    end
+  end
+end