sidekiq_strategies 0.0.1

data/spec/strategies/account_handler_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe SidekiqStrategies::AccountHandler do
+
+  before(:each) do
+    @subscriber = create_double_subscriber
+    @acc_handler = SidekiqStrategies::AccountHandler.new(120, 250, :query, 0, Spool::Publisher)
+    @acc_handler.add_subscriber(@subscriber)
+  end
+
+  describe '#new' do
+
+    it 'return an instance of AccountHandler object' do
+      expect( @acc_handler ).to be_an(SidekiqStrategies::AccountHandler)
+    end
+
+    it 'should have an Account reference with id 120' do
+      expect( @acc_handler.account ).to be_an(Account)
+      expect( @acc_handler.account.id ).to be(120)
+    end
+
+    it 'should have a Transaction reference with id 250' do
+      expect( @acc_handler.transaction ).to be_an(Transaction)
+      expect( @acc_handler.transaction.id ).to be(250)
+    end
+
+  end
+
+  describe 'instance methods' do
+
+    describe '#save_sidekiq_jid' do
+      it 'should save jid value' do
+        @acc_handler.save_sidekiq_jid('jid123')
+        expect( @acc_handler.transaction.sidekiq_jid ).to eql('jid123')
+      end
+
+      it 'should call Transaction.save! with no params' do
+        expect( @acc_handler.transaction ).to receive(:save!)
+        @acc_handler.save_sidekiq_jid('jid123')
+      end
+    end
+
+    describe '#save_beanstalkd_jid' do
+      it 'should save jid value' do
+        @acc_handler.save_beanstalkd_jid(562)
+        expect( @acc_handler.transaction.beanstalkd_jid ).to eql(562)
+      end
+
+      it 'should call Transaction.save! with no params' do
+        expect( @acc_handler.transaction ).to receive(:save!)
+        @acc_handler.save_beanstalkd_jid(562)
+      end
+    end
+
+    describe '#success' do
+      it 'should set account state to ready' do
+        @acc_handler.success
+        expect( @acc_handler.account.state ).to eql('ready')
+      end
+
+      it 'should notify subscribers' do
+        expect( @subscriber ).to receive(:state_changed).with(@acc_handler.account, 'reserved', 'ready')
+        @acc_handler.success
+      end
+    end
+
+    describe '#error' do
+      it 'should set account state to error' do
+        @acc_handler.error
+        expect( @acc_handler.account.state ).to eql('error')
+      end
+
+      it 'should notify subscribers' do
+        expect( @subscriber ).to receive(:state_changed).with(@acc_handler.account, 'reserved', 'error')
+        @acc_handler.error
+      end
+    end
+
+    describe '#start_action' do
+      it 'should set account state to querying' do
+        @acc_handler.start_action
+        expect( @acc_handler.account.state ).to eql('querying')
+      end
+
+      it 'should notify subscribers' do
+        expect( @subscriber ).to receive(:state_changed).with(@acc_handler.account, 'reserved', 'querying')
+        @acc_handler.start_action
+      end
+    end
+
+    describe '#queue_for_retry' do
+      it 'should set account state to awaiting_retry' do
+        @acc_handler.queue_for_retry
+        expect( @acc_handler.account.state ).to eql('awaiting_retry')
+      end
+
+      it 'should increase retry_count in 1' do
+        begin_retry_count = @acc_handler.transaction.retry_count
+        @acc_handler.queue_for_retry
+        expect( @acc_handler.transaction.retry_count ).to be(begin_retry_count + 1)
+      end
+
+      it 'should call Transaction.save! with params "validate: false"' do
+        expect( @acc_handler.transaction ).to receive(:save!).with(validate: false)
+        @acc_handler.queue_for_retry
+      end
+
+      it 'should notify subscribers' do
+        expect( @subscriber ).to receive(:state_changed).with(@acc_handler.account, 'reserved', 'awaiting_retry')
+        @acc_handler.queue_for_retry
+      end
+    end
+
+    describe '#queue_for_wait_at_worker' do
+      it 'should set account state to waiting_at_worker' do
+        @acc_handler.queue_for_wait_at_worker
+        expect( @acc_handler.account.state ).to eql('waiting_at_worker')
+      end
+
+      it 'should notify subscribers' do
+        expect( @subscriber ).to receive(:state_changed).with(@acc_handler.account, 'reserved', 'waiting_at_worker')
+        @acc_handler.queue_for_wait_at_worker
+      end
+    end
+
+    describe '#save_success_response' do
+      it 'should update Transaction.resonse' do
+        @acc_handler.save_success_response(create_worker_response)
+        expect( @acc_handler.transaction.response ).to eq(create_worker_response)
+      end
+
+      it 'should update Transaction.amount' do
+        @acc_handler.save_success_response(create_worker_response)
+        expect( @acc_handler.transaction.amount ).to eq(create_worker_response[:amount_due])
+      end
+
+      it 'should update account response' do
+        @acc_handler.save_success_response(create_worker_response)
+        expect( @acc_handler.account.response ).to_not be(nil)
+      end
+
+      it 'should call Transaction.save! with params "validate: false"' do
+        expect( @acc_handler.transaction ).to receive(:save!).with(validate: false)
+        @acc_handler.queue_for_retry
+      end
+    end
+
+    describe '#save_exception' do
+      before(:each) do
+        @exception = XBP::Error::ApiInternalError.new('test error')
+        @acc_handler.save_exception(@exception)
+      end
+
+      it 'shuold update Transaction.response' do
+        expect( @acc_handler.transaction.response ).to_not be(nil)
+      end
+
+      it 'shuold update Transaction.response_code' do
+        exception = XBP::Error::ApiInternalError.new('test error')
+      end
+
+      it 'shuold update Transaction.response_messsage' do
+        expect( @acc_handler.transaction.response_message ).to_not be(nil)
+      end
+
+      it 'shuold update Transaction.exception_type' do
+        expect( @acc_handler.transaction.exception_type ).to eql("XBP::Error::ApiInternalError")
+      end
+
+      it 'shuold update Transaction.exception_message' do
+        expect( @acc_handler.transaction.exception_message ).to eql("test error")
+      end
+
+      it 'should call Transaction.save! with params "validate: false"' do
+        expect( @acc_handler.transaction ).to receive(:save!).with(validate: false)
+        @acc_handler.save_exception(@exception)
+      end
+    end
+
+  end
+  
+end

data/spec/strategies/beanstalkd_handler_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe SidekiqStrategies::BeanstalkdHandler do
+
+  before(:each) do
+    jobs          = create_double_beaneater_jobs({1=>create_double_beaneater_job, 2=>nil})
+    tube_pronet   = create_double_beaneater_tube(:name=>'pronet')
+    tubes         = {'pronet' => tube_pronet}
+    pool          = create_double_beaneater_pool({:jobs=>jobs, :tubes=>tubes})
+    @bns_handler  = SidekiqStrategies::BeanstalkdHandler.new( pool )
+  end
+
+  describe '#new' do
+
+    it 'return an BeanstalkdHandler object' do
+      expect( @bns_handler ).to be_a SidekiqStrategies::BeanstalkdHandler   
+    end
+
+  end
+
+  describe 'public instance methods' do
+
+    it '#obtain_tube should return a tube with name pronet' do
+      expect( @bns_handler.obtain_tube('pronet') ).to_not be(nil)
+      expect( @bns_handler.obtain_tube('pronet').name ).to eq('pronet')
+    end
+
+    it '#find_job with param 1 should return an specific job' do
+      expect( @bns_handler.find_job(1) ).to_not be(nil)
+    end
+
+    it '#find_job with param 2 should return null' do
+      expect( @bns_handler.find_job(2) ).to be(nil)
+    end    
+
+  end
+
+  describe 'private instance methods' do
+
+    it '#conn should return a Beaneater::Pool object' do
+      expect( @bns_handler.send(:conn) ).to be_an(create_double_beaneater_pool.class)
+    end
+
+    it '#host should be a valid host name' do
+      expect( @bns_handler.send(:host) ).to eql('localhost:11300')
+    end
+
+  end
+
+end

data/spec/strategies/helper_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe SidekiqStrategies::Helper do
+
+  before(:each) do
+    @acc_handler = SidekiqStrategies::AccountHandler.new(120, 250, :query, 0, Spool::Publisher)
+    @helper = SidekiqStrategies::Helper.new(@acc_handler, Rails.application.routes.url_helpers)
+  end
+
+  describe '#new' do
+
+    it 'return an instance of Helper object' do
+      expect( @helper ).to be_an(SidekiqStrategies::Helper)
+    end
+
+  end
+
+  describe 'instance methods' do
+
+    it '#reply_tube_name should return a valid tube name' do
+      expect( @helper.reply_tube_name ).to eql("gt-120")
+    end
+
+    it '#request_tube_name should return a valid tube name' do
+      expect( @helper.request_tube_name ).to eql("pronet")
+    end
+
+    it '#queue_message should return a valid message' do
+      queue_message = {
+        :account => 120,
+        :account_url => "http://api.bluekite.com/v1/services/gt/claro-postpay/accounts/120",
+        :action => :query,
+        :fields => {:reference=>"", :end_user_id=>"", :priority=>"normal", :code=>"", :end_user_ip_address=>"192.168.0.1", :monitor_as_url=>"http://10.33.33.22:3000/v1/services/gt/claro-postpay/accounts/1", :account_number=>"55748576", :total_cents=>""},
+        :number => "55748576",
+        :provider => "claro_postpay",
+        :reply_tube => "gt-120",
+        :request_tube => "pronet",
+        :retry_count => 0,
+        :service => "claro-postpay"
+      }
+      expect( @helper.queue_message ).to eql(queue_message)
+    end
+
+    describe '#try_again?' do
+      it 'should return false if transaction.retry_count is greater than 2' do
+        @helper.acc_handler.transaction.retry_count = 5
+        expect( @helper.try_again?(nil) ).to eql(false)
+      end
+
+      it 'should return true if it is an a retryable exception' do
+        expect( @helper.try_again?({:retry_action => true}) ).to eql(true)
+      end
+
+      it 'should return false if it isn\'t an a retryable exception' do
+        expect( @helper.try_again?({:retry_action => false}) ).to eql(false)
+      end
+    end
+
+  end
+
+end

data/spec/strategies/polling_strategy_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+describe SidekiqStrategies::PollingStrategy do
+
+  before(:each) do
+    @logger             = create_double_logger
+    @airbrake_notifier  = create_double_airbrake
+    
+    @acc_handler  = SidekiqStrategies::AccountHandler.new(120, 250, :query, 0, Spool::Publisher)
+    @helper       = SidekiqStrategies::Helper.new(@acc_handler, Rails.application.routes.url_helpers)
+    @strategy     = SidekiqStrategies::PollingStrategy.new(nil, nil, nil, nil, nil)
+  end
+
+  describe '#new' do
+
+    it 'return an instance of PollingStrategy object' do
+      expect( @strategy ).to be_an(SidekiqStrategies::PollingStrategy)
+    end
+
+    it 'should respond to #perform' do
+      expect( @strategy.respond_to?('perform') ).to be(true)
+    end
+
+    it 'should respond to #retries_exhausted' do
+      expect( @strategy.respond_to?('retries_exhausted') ).to be(true)
+    end
+
+    it 'should expect 4 params on constructor' do
+      expect{
+        SidekiqStrategies::PollingStrategy.new
+      }.to raise_error
+
+      expect{
+        SidekiqStrategies::PollingStrategy.new(nil, nil, nil, nil, nil)
+      }.to_not raise_error
+    end
+
+  end
+
+  describe '#perform' do
+    
+    context 'when Beanstalkd service is not reachable' do
+      before(:each) do
+        pool = create_double_beaneater_pool
+        allow(pool).to receive(:tubes).and_raise(Beaneater::NotConnected)
+
+        @bns_handler  = SidekiqStrategies::BeanstalkdHandler.new(pool)
+        @strategy     = SidekiqStrategies::PollingStrategy.new(@acc_handler, @bns_handler, @logger, @airbrake_notifier, @helper)
+      end 
+
+      it 'should raise XBP::Error::MessageQueueNotReachable error' do
+        expect{
+          @strategy.perform('abc123')
+        }.to raise_error(XBP::Error::MessageQueueNotReachable)
+      end
+
+      it 'should set account state to awaiting_retry' do
+        begin
+          @strategy.perform('abc123')
+        rescue XBP::Error::MessageQueueNotReachable=>e
+          expect( @acc_handler.account.state ).to eql('awaiting_retry')
+        end
+      end
+    end
+
+    context 'when there are no workers available' do
+      before(:each) do
+        request_tube_stats  = create_stats({:current_watching=>0})
+        request_tube        = create_double_beaneater_tube(:name=>'pronet', :stats=>request_tube_stats)
+        tubes               = {'pronet'=>request_tube}
+        pool                = create_double_beaneater_pool({:tubes=>tubes})
+
+        @bns_handler  = SidekiqStrategies::BeanstalkdHandler.new(pool)
+        @strategy     = SidekiqStrategies::PollingStrategy.new(@acc_handler, @bns_handler, @logger, @airbrake_notifier, @helper)
+      end 
+
+      it 'should raise XBP::Error::WorkersUnavailable error' do
+        expect{
+          @strategy.perform('abc123')
+        }.to raise_error(XBP::Error::WorkersUnavailable)
+      end
+
+      it 'should set account state to awaiting_retry' do
+        begin
+          @strategy.perform('abc123')
+        rescue XBP::Error::WorkersUnavailable=>e
+          expect( @acc_handler.account.state ).to eql('awaiting_retry')
+        end
+      end
+    end
+
+    context 'when account state is not included in [reserved, awaiting_retry, waiting_at_worker]' do
+      context 'when there is no previous data' do
+        before(:each) do
+          @acc_handler.account.state = 'querying'
+
+          request_tube  = create_double_beaneater_tube(:name=>'pronet')
+          tubes         = {'pronet'=>request_tube}
+          pool          = create_double_beaneater_pool({:tubes=>tubes})
+
+          @bns_handler  = SidekiqStrategies::BeanstalkdHandler.new(pool)
+          @strategy     = SidekiqStrategies::PollingStrategy.new(@acc_handler, @bns_handler, @logger, @airbrake_notifier, @helper)
+        end 
+
+        it 'should not raise error' do
+          expect{
+            @strategy.perform('abc123')
+          }.to_not raise_error
+        end
+
+        it 'should set account state to error' do
+          @strategy.perform('abc123')
+          expect( @acc_handler.account.state ).to eql('error')
+        end
+      end
+    end
+
+    context 'when response is never received' do
+      before(:each) do
+        request_tube_stats  = create_stats({:current_watching=>1})
+        reply_tube_stats    = create_stats({:state=>'ready'})
+        request_tube        = create_double_beaneater_tube(:name=>'pronet', :stats=>request_tube_stats, :put_response=>{:id=>1})
+        reply_tube          = create_double_beaneater_tube({:name=>'gt-120'})
+        tubes               = {'pronet'=>request_tube, 'gt-120'=>reply_tube}
+        request_job_stats   = create_stats({:state=>'ready'})
+        request_job         = create_double_beaneater_job({:stats=>request_job_stats})
+        jobs                = create_double_beaneater_jobs({1=>request_job})
+        pool                = create_double_beaneater_pool({:tubes=>tubes, :jobs=>jobs})
+
+        allow(reply_tube).to receive(:reserve).with(1).and_raise(Beaneater::TimedOutError.new(nil, nil))
+
+        @bns_handler  = SidekiqStrategies::BeanstalkdHandler.new(pool)
+        @strategy     = SidekiqStrategies::PollingStrategy.new(@acc_handler, @bns_handler, @logger, @airbrake_notifier, @helper)
+
+        @strategy.poll_tries_before_airbrake  = 10
+        @strategy.poll_max_tries              = 20
+      end
+
+      it 'should set account state to error' do
+        @strategy.perform('abc123')
+        expect( @acc_handler.account.state ).to eql('error')
+      end
+
+      it 'should send an airbrake when 10 seconds of polling has been reached' do
+        expect( @airbrake_notifier ).to receive(:notify).with(:error_message => "Polling is taking more than 10 seconds.")
+        @strategy.perform('abc123')
+      end
+
+      it 'should send an airbrake when 20 seconds of polling has been reached' do
+        expect( @airbrake_notifier ).to receive(:notify).with(:error_message => "Queue gt-120 time out. Waited 20 seconds.")
+        @strategy.perform('abc123')
+      end
+    end
+
+    context 'when response is received' do
+      context 'when is success' do
+        before(:each) do
+          request_tube_stats  = create_stats({:current_watching=>1})
+          request_tube        = create_double_beaneater_tube(:name=>'pronet', :stats=>request_tube_stats, :put_response=>{:id=>1})
+          reply_tube          = create_double_beaneater_tube({:name=>'gt-120'})
+          tubes               = {'pronet'=>request_tube, 'gt-120'=>reply_tube}
+          request_job_stats   = create_stats({:state=>'ready'})
+          request_job         = create_double_beaneater_job({:stats=>request_job_stats})
+          reply_job           = create_double_beaneater_job({:body=>Oj.dump(create_worker_response)})
+          jobs                = create_double_beaneater_jobs({1=>request_job})
+          pool                = create_double_beaneater_pool({:tubes=>tubes, :jobs=>jobs})
+
+          allow(reply_tube).to receive(:reserve).with(1).and_return(reply_job)          
+
+          @bns_handler  = SidekiqStrategies::BeanstalkdHandler.new(pool)
+          @strategy     = SidekiqStrategies::PollingStrategy.new(@acc_handler, @bns_handler, @logger, @airbrake_notifier, @helper)
+        end
+
+        it 'should set account state to ready' do
+          @strategy.perform('abc123')
+          expect( @acc_handler.account.state ).to eql('ready')
+        end
+      end
+
+      context 'when is error' do
+        before(:each) do
+          request_tube_stats  = create_stats({:current_watching=>1})
+          request_tube        = create_double_beaneater_tube(:name=>'pronet', :stats=>request_tube_stats, :put_response=>{:id=>1})
+          reply_tube          = create_double_beaneater_tube({:name=>'gt-120'})
+          tubes               = {'pronet'=>request_tube, 'gt-120'=>reply_tube}
+          request_job_stats   = create_stats({:state=>'ready'})
+          request_job         = create_double_beaneater_job({:stats=>request_job_stats})
+          reply_job           = create_double_beaneater_job({:body=>Oj.dump({:exception=>create_worker_exception})})
+          jobs                = create_double_beaneater_jobs({1=>request_job})
+          pool                = create_double_beaneater_pool({:tubes=>tubes, :jobs=>jobs})
+
+          allow(reply_tube).to receive(:reserve).with(1).and_return(reply_job)          
+
+          @bns_handler  = SidekiqStrategies::BeanstalkdHandler.new(pool)
+          @strategy     = SidekiqStrategies::PollingStrategy.new(@acc_handler, @bns_handler, @logger, @airbrake_notifier, @helper)
+        end
+
+        it 'should set account state to error' do
+          @strategy.perform('abc123')
+          expect( @acc_handler.account.state ).to eql('error')
+        end
+      end
+    end
+  end
+
+end