resque_manager 3.3.0 → 3.3.1

data/test/functional/resque_manager/resque_controller_test.rb

@@ -1,9 +1,306 @@
-require 'test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'resque_manager/resque_controller.rb'
 
 module ResqueManager
   class ResqueControllerTest < ActionController::TestCase
-    # test "the truth" do
-    #   assert true
-    # end
+    context 'ResqueManager::ResqueController' do
+      setup { Resque.redis.flushdb } # flush redis
+      context '#working' do
+        should 'respond with success and render the _working partial' do
+          get :working, use_route: :resque_manager
+          assert_response :success
+          assert_template partial: '_working'
+        end
+      end
+
+      context '#queues' do
+        should 'respond with success and render the _queues partial' do
+          get :queues, use_route: :resque_manager
+          assert_response :success
+          assert_template partial: '_queues'
+        end
+      end
+
+      context '#poll' do
+        should 'respond with success and start the live polling' do
+          get :poll, { page: 'overview', use_route: :resque_manager }
+          assert_response :success
+          assert_select 'p.poll', text: /Last Updated: [0-9]{2}:[0-9]{2}:[0-9]{2}/, count: 1
+        end
+      end
+
+      context '#status_poll' do
+        should 'respond with success and start the live polling' do
+          get :status_poll, use_route: :resque_manager
+          assert_response :success
+          assert_select 'p.poll', text: /Last Updated: [0-9]{2}:[0-9]{2}:[0-9]{2}/, count: 1
+        end
+      end
+
+      context '#remove_job' do
+        should 'always redirect' do
+          @request.env['HTTP_REFERER'] = '/resque/queues/single_record_loader'
+          post :remove_job, { class: SingleRecordLoader, use_route: :resque_manager }
+          assert_redirected_to '/resque/queues/single_record_loader'
+        end
+
+        should 'dequeue' do
+          ResqueManager.applications.expects(:blank?).returns(true)
+          Resque.expects(:dequeue)
+          @request.env['HTTP_REFERER'] = '/resque/queues/single_record_loader'
+          post :remove_job, { class: SingleRecordLoader, use_route: :resque_manager }
+          assert_redirected_to '/resque/queues/single_record_loader'
+        end
+      end
+
+      context '#stop_worker' do
+        should 'always redirect to workers path' do
+          post :stop_worker, use_route: :resque_manager
+          assert_redirected_to '/resque/workers'
+        end
+
+        should 'stop a worker and redirect' do
+          worker = Resque::Worker.new(:data_contribution_file)
+          worker.expects(:quit)
+          ResqueManager::ResqueController.any_instance.expects(:find_worker).returns(worker)
+          post :stop_worker, { worker: worker, use_route: :resque_manager }
+          assert_redirected_to '/resque/workers'
+        end
+      end
+
+      context '#pause_worker' do
+        should 'always redirect to workers path' do
+          post :pause_worker, use_route: :resque_manager
+          assert_redirected_to '/resque/workers'
+        end
+
+        should 'pause a worker and redirect' do
+          worker = Resque::Worker.new(:data_contribution_file)
+          worker.expects(:pause)
+          ResqueManager::ResqueController.any_instance.expects(:find_worker).returns(worker)
+          post :pause_worker, { worker: worker, use_route: :resque_manager }
+          assert_redirected_to '/resque/workers'
+        end
+      end
+
+      context '#continue_worker' do
+        should 'always redirect to workers path' do
+          post :continue_worker, use_route: :resque_manager
+          assert_redirected_to '/resque/workers'
+        end
+
+        should 'continue a worker and redirect' do
+          worker = Resque::Worker.new(:data_contribution_file)
+          worker.expects(:continue)
+          ResqueManager::ResqueController.any_instance.expects(:find_worker).returns(worker)
+          post :continue_worker, { worker: worker, use_route: :resque_manager }
+          assert_redirected_to '/resque/workers'
+        end
+      end
+
+      context '#restart_worker' do
+        should 'always redirect to workers path' do
+          post :restart_worker, use_route: :resque_manager
+          assert_redirected_to '/resque/workers'
+        end
+
+        should 'continue a worker and redirect' do
+          worker = Resque::Worker.new(:data_contribution_file)
+          worker.expects(:restart)
+          ResqueManager::ResqueController.any_instance.expects(:find_worker).returns(worker)
+          post :restart_worker, { worker: worker, use_route: :resque_manager }
+          assert_redirected_to '/resque/workers'
+        end
+      end
+
+      context '#start_worker' do
+        should 'always redirect to workers path' do
+          post :start_worker, use_route: :resque_manager
+          assert_redirected_to '/resque/workers'
+        end
+
+        should 'continue a worker and redirect' do
+          worker = Resque::Worker.new(:data_contribution_file)
+          Resque::Worker.expects(:start)
+          post :start_worker, { worker: worker, use_route: :resque_manager }
+          assert_redirected_to '/resque/workers'
+        end
+      end
+
+      context '#stats' do
+        should 'redirect to /stats/resque for a missing id' do
+          post :stats, use_route: :resque_manager
+          assert_redirected_to '/resque/stats?id=resque'
+        end
+
+        should 'render resque info text when id is txt' do
+          post :stats, id: 'txt', use_route: :resque_manager
+          assert_equal 'resque.pending=0</br>resque.processed+=0</br>resque.failed+=0</br>resque.workers=0</br>resque.working=0', @response.body, @response.body
+        end
+      end
+
+      context '#schedule' do
+        should 'have a response of success' do
+          get :schedule, use_route: :resque_manager
+          assert_response :success
+        end
+      end
+
+      context '#schedule_requeue' do
+        should 'always redirect to overview' do
+          Resque::Scheduler.stubs(:enqueue_from_config)
+          post :schedule_requeue, use_route: :resque_manager
+          assert_redirected_to '/resque/overview'
+        end
+      end
+
+      context '#add_scheduled_job' do
+        should 'have an error for a name already existing and missing ip and missing cron' do
+          # Resque.schedule.keys.expects(:include?).returns(true)
+          # Stub on array instead of Resque.schedule.keys otherwise the stub never works.
+          Array.any_instance.expects(:include?).returns(true).at_least_once
+          post :add_scheduled_job, { name: 'key', use_route: :resque_manager }
+          assert_redirected_to '/resque/schedule'
+          errors = flash[:error].split('<br>')
+          assert_includes errors, 'You must enter an ip address for the server you want this job to run on.', errors.inspect
+          assert_includes errors, 'You must enter the cron schedule.', errors.inspect
+          assert_includes errors, 'Name already exists.'
+        end
+
+        should 'add a job to the scheduler' do
+          ip = '0.0.0.0'
+          Resque.redis.expects(:rpush)
+          ResqueScheduler.expects(:restart).with(ip)
+          post :add_scheduled_job, { 'name'=> 'TestName', 'class' => 'SingleRecordLoader', 'ip' => ip, 'args' => nil, 'description' => 'Test job', 'cron' => 'TestCron', use_route: :resque_manager }
+          assert_nil flash[:error]
+        end
+      end
+
+      context '#remove_from_schedule' do
+        should 'always redirect to schedule' do
+          post :remove_from_schedule, use_route: :resque_manager
+          assert_redirected_to '/resque/schedule'
+        end
+
+        should 'restart schedule from ip' do
+          Resque.stubs(:list_range).returns([{'SingleRecordLoader' => 'test data'}])
+          Resque.redis.expects(:lrem).with(:scheduled, 0, {'SingleRecordLoader' => 'test data'}.to_json)
+          ResqueScheduler.expects(:restart).with('0.0.0.0')
+          post :remove_from_schedule, { ip: '0.0.0.0', job_name: 'SingleRecordLoader', use_route: :resque_manager }
+          assert_redirected_to '/resque/schedule'
+        end
+      end
+
+      context '#start_scheduler' do
+        should 'always redirect to schedule and call ResqueScheduler.start' do
+          ResqueScheduler.expects(:start).with('0.0.0.0')
+          post :start_scheduler, { ip: '0.0.0.0', use_route: :resque_manager }
+          assert_redirected_to '/resque/schedule'
+        end
+      end
+
+      context '#stop_scheduler' do
+        should 'always redirect to schedule and call ResqueScheduler.start' do
+          ResqueScheduler.expects(:quit).with('0.0.0.0')
+          post :stop_scheduler, { ip: '0.0.0.0', use_route: :resque_manager }
+          assert_redirected_to '/resque/schedule'
+        end
+      end
+
+      context '#statuses' do
+        should 'respond with a status in json format' do
+          hash = Resque::Plugins::Status::Hash.set('UUID', 'message')
+          Resque::Plugins::Status::Hash.stubs(:status_ids).returns(%w(UUID))
+          post :statuses,  { format: :js, use_route: :resque_manager }
+          assert_equal hash, JSON.parse(@response.body).first, JSON.parse(@response.body).inspect
+        end
+      end
+
+      context '#clear_statuses' do
+        should 'always redirect to statuses page and call Resque::Plugins::Status::Hash.clear' do
+          Resque::Plugins::Status::Hash.expects(:clear)
+          post :clear_statuses, use_route: :resque_manager
+          assert_redirected_to '/resque/statuses'
+        end
+      end
+
+      context '#status' do
+        should 'render a status in json' do
+          hash = Resque::Plugins::Status::Hash.set('UUID', 'message')
+          post :status, { id: 'UUID', format: :js, use_route: :resque_manager }
+          assert_equal hash, JSON.parse(@response.body), JSON.parse(@response.body).inspect
+        end
+      end
+
+      context '#kill' do
+        should 'redirect to statuses and kill a status' do
+          Resque::Plugins::Status::Hash.set('UUID', 'message')
+          post :kill, { id: 'UUID', use_route: :resque_manager }
+          assert_redirected_to '/resque/statuses'
+          hash = Resque::Plugins::Status::Hash.get('UUID')
+          assert_equal 'killed', hash['status']
+        end
+      end
+
+      context '#cleaner_stale' do
+        should 'always redirect to cleaner' do
+          Resque::Plugins::ResqueCleaner.any_instance.expects(:clear_stale)
+          post :cleaner_stale, use_route: :resque_manager
+          assert_redirected_to '/resque/cleaner'
+        end
+      end
+
+      context 'private' do
+        setup { @controller = ResqueController.new }
+        context '#check_connection' do
+          should 'return true' do
+            assert @controller.send(:check_connection)
+          end
+
+          should 'rescue a Errno::ECONNRFUSED exception and render template resque/error' do
+            # Check connection is a before_filter stub an exception and make a get request to working
+            # We need an actual request to render the template
+            Resque.expects(:keys).raises(Errno::ECONNREFUSED.new)
+            get :working, use_route: :resque_manager
+            assert_match /#{Resque.redis_id}/, @response.body, @response.body.inspect
+            assert_template 'resque/error'
+          end
+        end
+
+        context '#find_worker' do
+          should 'return nil for a missing worker' do
+            assert_nil @controller.send(:find_worker, '')
+          end
+
+          should 'find the correct worker' do
+            worker = Resque::Worker.new(:data_contribution_file)
+            Resque::Worker.expects(:exists?).returns(true)
+            response = @controller.send(:find_worker, worker.to_s)
+            first, *rest=worker.to_s.split(':')
+            first.gsub!(/_/, '.')
+            worker_id = "#{first}:#{rest.join(':')}"
+            worker.to_s = worker_id
+            assert_equal worker, response
+          end
+        end
+
+        context '#get_cleaner' do
+          should 'return a cleaner' do
+            cleaner = @controller.send(:get_cleaner)
+            assert_kind_of Resque::Plugins::ResqueCleaner, cleaner
+            refute cleaner.print_message
+          end
+        end
+
+        context '#hours_ago' do
+          should 'return the correctly formatted hours ago time' do
+            now = Time.now
+            Time.expects(:now).returns(now).at_least_once
+            hours = @controller.send(:hours_ago, 2)
+            assert_equal now - 2*60*60, hours
+          end
+        end
+      end
+    end
   end
 end

data/test/test_helper.rb

@@ -1,8 +1,11 @@
 # Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
+ENV['RAILS_ENV'] = 'test'
+require 'resque_scheduler' # require here for tests since we don't require it in the Gemfile since it's optional
 
-require File.expand_path("../dummy/config/environment.rb",  __FILE__)
-require "rails/test_help"
+require File.expand_path('../dummy/config/environment.rb',  __FILE__)
+require 'rails/test_help'
+
+require 'shoulda'
 
 Rails.backtrace_cleaner.remove_silencers!
 
@@ -11,5 +14,5 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 # Load fixtures from the engine
 if ActiveSupport::TestCase.method_defined?(:fixture_path=)
-  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
+  ActiveSupport::TestCase.fixture_path = File.expand_path('../fixtures', __FILE__)
 end

data/test/unit/overrides/resque/worker_test.rb

@@ -0,0 +1,169 @@
+require 'test/unit'
+require 'socket'
+require File.expand_path(File.dirname(__FILE__) + '/../../../test_helper')
+
+class WorkerTest < Test::Unit::TestCase
+  context 'Worker' do
+    setup do
+      Resque.redis.flushdb # flush redis
+      Thread.current[:queues] = '*'
+      Thread.current[:path] = 'path'
+      @worker = Resque::Worker.new(:data_contribution_file)
+    end
+
+    context '#local_ip' do
+      should 'set the local_ip' do
+        assert_equal IPSocket.getaddress(Socket.gethostname), @worker.local_ip
+      end
+    end
+
+    context '#to_s' do
+      should 'return the correct string representation of the worker'do
+        Process.stubs(:pid).returns(27415)
+        object_id = Thread.current.object_id
+        assert_equal "#{Socket.gethostname}(#{IPSocket.getaddress(Socket.gethostname)}):27415:#{object_id}:path:*", @worker.to_s
+      end
+
+      should 'alias to_s as id' do
+        assert_not_nil @worker.id
+      end
+    end
+
+    context '#pause' do
+      should 'return a correctly formatted pause key' do
+        Process.stubs(:pid).returns(27415)
+        assert_equal "worker:#{Socket.gethostname}(#{IPSocket.getaddress(Socket.gethostname)}):27415:all_workers:paused", @worker.pause_key
+      end
+    end
+
+    context '#pid' do
+      should 'return the correct pid' do
+        Process.stubs(:pid).returns(27415)
+        assert_equal '27415', @worker.pid
+      end
+    end
+
+    context '#thread' do
+      should 'return the correct thread' do
+        assert_equal Thread.current.object_id.to_s, @worker.thread
+      end
+    end
+
+    context '#path' do
+      should 'return the correct path' do
+        assert_equal Thread.current[:path], @worker.path
+      end
+    end
+
+    context '#queue' do
+      should 'return the correct queue' do
+        assert_equal Thread.current[:queues], @worker.queue
+      end
+    end
+
+    context '#workers_in_pid' do
+      should 'return the worker in the redis' do
+        Resque.redis.sadd(:workers, @worker.to_s)
+        assert_equal @worker.to_s, @worker.workers_in_pid.first.to_s
+      end
+
+      should 'return an empty array' do
+        assert_empty @worker.workers_in_pid
+      end
+    end
+
+    context '#ip' do
+      should 'return the correct ip' do
+        assert_equal IPSocket.getaddress(Socket.gethostname), @worker.ip
+      end
+    end
+
+    context '#queues_in_pid' do
+      should 'return the correct queue' do
+        Resque.redis.sadd(:workers, @worker.to_s)
+        assert_equal '*', @worker.queues_in_pid.first
+      end
+    end
+
+    context '#queues' do
+      should 'return an array of queues when the queue is not *' do
+        Thread.current[:queues] = 'data_contribution,single_record_loader'
+        assert_equal %w(data_contribution single_record_loader), @worker.queues
+      end
+
+      should 'return an array of sorted resque queues' do
+        Resque.redis.sadd(:queues, @worker.to_s)
+        assert_equal @worker.to_s, @worker.queues.first
+      end
+    end
+
+    context '#shutdown' do
+      should 'set @shutdown to true and threads shutdown to true' do
+        @worker.expects(:log).with('Exiting...')
+        @worker.shutdown
+        Thread.list.each { |t| assert t[:shutdown] }
+        assert @worker.shutdown?
+      end
+    end
+
+    context '#paused' do
+      should 'return the correct pause_key' do
+        now = Time.now.to_s
+        Resque.redis.set(@worker.pause_key, Time.now.to_s)
+        assert_equal now, @worker.paused
+      end
+    end
+
+    context '#paused?' do
+      should 'return true when paused is present and @paused is false' do
+        now = Time.now.to_s
+        Resque.redis.set(@worker.pause_key, now)
+        @worker.instance_variable_set(:@paused, false)
+        assert @worker.paused?
+      end
+
+      should 'return true when @paused is true' do
+        @worker.instance_variable_set(:@paused, true)
+        assert @worker.paused?
+      end
+    end
+
+    context '#pause_processing' do
+      should 'set the worker pause key to Time.now and log the pausing process' do
+        @worker.expects(:log).with('USR2 received; pausing job processing')
+        now = Time.now
+        Time.expects(:now).returns(now).at_least_once
+        @worker.pause_processing
+        assert_equal now.to_s, @worker.paused
+      end
+    end
+
+    context '#unpause_processing' do
+      should 'delete the worker pause key and log the un-pausing process' do
+        Resque.redis.set(@worker.pause_key, Time.now.to_s) # Set the pause key
+        @worker.expects(:log).with('CONT received; resuming job processing')
+        @worker.unpause_processing
+        assert_nil @worker.paused
+        refute @worker.paused?
+      end
+    end
+
+    context '#prune_dead_workers' do
+      should 'unregister a worker when its pid is not included in worker_pids' do
+        Resque.redis.sadd(:workers, @worker.to_s)
+        @worker.expects(:worker_pids).returns([])
+        @worker.expects(:log!).with("Pruning dead worker: #{@worker.to_s}")
+        Resque::Worker.any_instance.expects(:unregister_worker)
+        @worker.prune_dead_workers
+      end
+    end
+
+    context '#unregister_worker_with_pause' do
+      should 'delete the pause key from redis' do
+        Resque.redis.set(@worker.pause_key, Time.now.to_s)
+        Redis.any_instance.expects(:del).at_least_once
+        @worker.unregister_worker_with_pause
+      end
+    end
+  end
+end