active_worker 0.50.0

data/test/test_failure_event.rb

@@ -0,0 +1,69 @@
+require_relative "test_helper"
+
+module ActiveWorker
+  class FailureEventTest < ActiveSupport::TestCase
+
+    test "can create a failure event from error and basic params" do
+      exception = create_exception
+
+      config = ActiveWorker::Configuration.create
+
+      original_events = FailureEvent.from_error(config, exception)
+      assert_equal 1, original_events.size
+      original_event = original_events.first
+
+      event = FailureEvent.where(configuration_id: config.id).first
+
+      assert_equal original_event, event
+      assert_equal exception.backtrace.join("\n"), event.stack_trace
+      assert_equal "Mocha::Mock", event.error_type
+    end
+
+    test "event name and error message are used in event display" do
+      exception = create_exception
+      config = ActiveWorker::Configuration.create
+
+      original_event = FailureEvent.from_error(config, exception).first
+
+      assert_match /#{config.event_name}/, original_event.message
+      assert_match /#{exception.message}/, original_event.message
+    end
+
+    test "can use failure events as finished events" do
+      exception = create_exception
+      config = ActiveWorker::Configuration.create
+      original_event = FailureEvent.from_error(config,exception).first
+      event = FinishedEvent.where(configuration_id: config.id).first
+
+      assert_equal original_event, event
+    end
+
+    test "expands for threads unless completed" do
+      exception = create_exception
+
+      config = ExpandableConfig.create number_of_threads: 2
+
+      config.expand_for_threads
+
+      events = FailureEvent.from_error(config, exception)
+
+      assert_equal 2, events.size
+    end
+
+    test "expands for threads" do
+      exception = create_exception
+
+      config = ExpandableConfig.create number_of_threads: 2
+
+      config.expand_for_threads
+      config.finished
+
+      events = FailureEvent.from_error(config, exception)
+
+      assert_equal 1, events.size
+    end
+
+
+
+  end
+end

data/test/test_finished_event.rb

@@ -0,0 +1,35 @@
+require_relative "test_helper"
+
+module ActiveWorker
+  class FinishedEventTest < ActiveSupport::TestCase
+
+    test "exists_for_configurations scopes to finished events" do
+      config1 = Configuration.create
+      config2 = Configuration.create
+      config3 = Configuration.create
+
+      FinishedEvent.create configuration: config1
+      FinishedEvent.create configuration: config2
+
+      configs = [config1, config2, config3]
+
+      assert_equal false, FinishedEvent.exists_for_configurations?(configs)
+
+      Event.create configuration: config3
+
+      assert_equal false, FinishedEvent.exists_for_configurations?(configs)
+
+      FinishedEvent.create configuration: config3
+
+      assert FinishedEvent.exists_for_configurations?(configs)
+    end
+
+    test "finished message" do
+      configuration = Configuration.create
+      event = FinishedEvent.create(configuration: configuration)
+
+      assert_match /finished/, event.message
+    end
+
+  end
+end

data/test/test_has_modes.rb

@@ -0,0 +1,56 @@
+require_relative "test_helper"
+
+module ActiveWorker
+  class Modeable < Configuration
+    include ActiveWorker::Behavior::HasModes
+
+    field :custom_field
+
+    add_mode :first, custom_field: "mode1", other_field: "default"
+    add_mode :second, custom_field: "mode2"
+  end
+
+  class ModeableWithNoModes < Configuration
+    include ActiveWorker::Behavior::HasModes
+    field :custom_field
+  end
+
+  class HasModesTest < ActiveSupport::TestCase
+    test "can specify modes" do
+      mode_config = Modeable.create mode: :first
+
+      assert_equal [:first, :second], Modeable.modes
+      assert_equal :first, mode_config.mode
+    end
+
+    test "sets custom fields with mode map" do
+      mode_config = Modeable.create mode: :first
+      assert_equal "mode1", mode_config.custom_field
+      assert_equal "default", mode_config.other_field
+    end
+
+    test "mode does not override already set field" do
+      mode_config = Modeable.create mode: :first, custom_field: "set"
+      assert_equal "set", mode_config.custom_field
+    end
+
+    test "does not blow up with unsupported mode" do
+      assert_raise ActiveWorker::Behavior::HasModes::ModeNotSupportedException do
+        Modeable.create mode: "foo"
+      end
+    end
+
+    test "allows no mode to be set" do
+      mode_config = Modeable.create custom_field: "set"
+      assert_equal "set", mode_config.custom_field
+    end
+
+    test "allows no modes to be added" do
+      assert_equal [], ModeableWithNoModes.modes
+
+    end
+
+  end
+
+
+end

data/test/test_helper.rb

@@ -0,0 +1,120 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'active_support/test_case'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'active_worker'
+
+require 'mongoid'
+ENV["MONGOID_ENV"]="test"
+Mongoid.load!("#{File.dirname(__FILE__)}/mongoid.yml")
+
+
+Resque.redis.namespace = "resque:active_worker_test"
+
+
+module ActiveWorker
+
+  class Rootable
+    include Mongoid::Document
+    include ActiveWorker::Behavior::ActsAsRootObject
+  end
+
+
+  class TopConfig < Configuration
+    config_field :top_field
+
+    def child_configs
+      ChildConfig.mine(self).all
+    end
+  end
+
+  class ChildConfig < Configuration
+    config_field :child_field
+  end
+
+  class TemplatableTopConfig < Configuration
+    include Templatable
+    template_field :top_field
+    config_field :other_top_field
+  end
+
+  class TemplatableChildConfig < Configuration
+    include Templatable
+    template_field :child_field
+    config_field :other_child_field
+  end
+
+  class AfterLaunchConfig < ActiveWorker::Configuration
+    after_launch :after_launch_method
+  end
+
+  class ExpandableConfig < Configuration
+    include Expandable
+    include Templatable
+    field :foo
+    template_field :name
+    config_field :size
+  end
+
+  class MappedExpandableConfig < ExpandableConfig
+    def expansion_maps_for(number_of_configurations)
+      maps = []
+      number_of_configurations.times do |value|
+        maps << {size: value}
+      end
+      maps
+    end
+  end
+
+end
+
+
+class ActiveSupport::TestCase
+
+  ActiveWorker::JobQueue::RunRemotely.worker_mode = ActiveWorker::JobQueue::RunRemotely::THREADED
+
+  def create_exception
+    error_message = "Error message"
+    error_backtrace = ["line 1", "line 2"]
+
+    error = mock
+    error.stubs(:message).returns(error_message)
+    error.stubs(:backtrace).returns(error_backtrace)
+    error
+  end
+
+  def wait_for_all_configurations
+    ActiveWorker::Configuration.all.each(&:wait_until_completed)
+  end
+
+  def assert_no_failures
+    assert_equal 0, ActiveWorker::FailureEvent.count, "Failures: #{ActiveWorker::FailureEvent.all.map { |e| e.message + "\n" + e.stack_trace }.join}"
+  end
+
+  setup :clear_database
+  teardown :reset_default_worker_mode
+
+  def reset_default_worker_mode
+    ActiveWorker::Controller::local_worker_mode = ActiveWorker::DEFAULT_MODE
+  end
+
+  private
+
+  def clear_database
+    Mongoid.default_session.collections.select { |c| c.name != 'system.indexes' }.each(&:drop)
+  end
+
+end
+
+ActiveWorker::JobQueue::JobExecuter.stubs(:log_error)

data/test/test_integration.rb

@@ -0,0 +1,56 @@
+require_relative "test_helper"
+
+module ActiveWorker
+  class IntegrationTest < ActiveSupport::TestCase
+
+    test "can create correct templates" do
+
+      parent_config = TemplatableTopConfig.create(top_field: "top field", other_top_field: "other top field")
+      child_config0 = TemplatableChildConfig.create(child_field: "child field", other_child_field: "other child field", parent_configuration: parent_config)
+      child_config1 = TemplatableChildConfig.create(child_field: "different child field",other_child_field: "different other child field", parent_configuration: parent_config)
+
+      top_template = parent_config.find_template
+
+      assert_kind_of Template, top_template
+      assert_equal TemplatableTopConfig.name, top_template.configuration_type
+      assert_equal 2, top_template.child_templates.count
+
+      assert_equal parent_config.top_field,top_template[:top_field]
+      assert_nil top_template[:other_top_field]
+
+      child_template0 = top_template.child_templates[0]
+      child_template1 = top_template.child_templates[1]
+
+      assert_equal child_config0.child_field, child_template0[:child_field]
+      assert_equal child_config1.child_field, child_template1[:child_field]
+
+      assert_equal TemplatableChildConfig.name, child_template0.configuration_type
+      assert_equal TemplatableChildConfig.name, child_template0.configuration_type
+
+    end
+
+    test "can recreate correct configurations from templates" do
+      parent_config = TemplatableTopConfig.create(top_field: "top field", other_top_field: "other top field")
+      child_config0 = TemplatableChildConfig.create(child_field: "child field", other_child_field: "other child field", parent_configuration: parent_config)
+      child_config1 = TemplatableChildConfig.create(child_field: "different child field",other_child_field: "different other child field", parent_configuration: parent_config)
+
+      top_template = parent_config.find_template
+
+      created_config = top_template.build_configuration
+
+      assert_kind_of TemplatableTopConfig, created_config
+      assert_equal parent_config.top_field, created_config.top_field
+      assert_nil created_config.other_top_field
+
+      created_child_config0 = created_config.configurations[0]
+      created_child_config1 = created_config.configurations[1]
+
+      assert_equal child_config0.child_field, created_child_config0.child_field
+      assert_equal child_config1.child_field, created_child_config1.child_field
+
+      assert_nil created_child_config0.other_child_field
+      assert_nil created_child_config1.other_child_field
+    end
+
+  end
+end

data/test/test_job_executer.rb

@@ -0,0 +1,65 @@
+require_relative "test_helper"
+module ActiveWorker
+  module JobQueue
+    class JobExecuterTest < ActiveSupport::TestCase
+
+      class TestClass
+        def self.test_method(param1, param2)
+
+        end
+
+        def self.raise_method
+          raise SignalException.new "SIGHUP"
+        end
+
+        def self.handle_error(e, method, params)
+
+        end
+      end
+
+      setup do
+        JobExecuter.stubs(:log_error)
+      end
+
+      test "can execute command from args" do
+        param1 = 1
+        param2 = 2
+        TestClass.expects(:test_method).with(param1, param2)
+
+        class_name = TestClass.to_s
+        method     = :test_method
+        params     = [param1,param2]
+
+        args = {}
+        args["class_name"] = class_name
+        args["method"] = method
+        args["params"] = params
+
+        JobExecuter.execute_task_from_args(args)
+      end
+
+      test "handles and reraises signal exception" do
+        class_name = TestClass.to_s
+        method     = :raise_method
+
+        args = {}
+        args["class_name"] = class_name
+        args["method"] = method
+
+        assert_raise SignalException do
+          JobExecuter.execute_task_from_args(args)
+        end
+      end
+
+      test "can handle termination" do
+        params = [1,2]
+        fake_class = mock
+        fake_class.expects(:handle_termination).with(params)
+
+        JobExecuter.expects(:exit)
+        JobExecuter.handle_termination(fake_class, params)
+      end
+
+    end
+  end
+end

data/test/test_queue_manager.rb

@@ -0,0 +1,106 @@
+require_relative "test_helper"
+module ActiveWorker
+  module JobQueue
+    class QueueManagerTest < ActiveSupport::TestCase
+
+      test "can extract configuration id from worker" do
+        config_id = 5
+        worker = mock_worker(config_id)
+
+        extracted_id = QueueManager.new.configuration_id_from_worker(worker)
+        assert_equal config_id, extracted_id
+      end
+
+      test "can create job hash from worker" do
+        config_id = 5
+        worker = mock_worker(config_id)
+
+        job_hash = QueueManager.new.create_job_hash_from_worker(worker)
+
+        expected_hash = {"host" => "localhost",
+                         "queues" => ["execute", "localhost_execute"],
+                         "pid" => config_id.to_s,
+                         "args" => {"params" => [config_id]}}
+
+        assert_equal expected_hash, job_hash
+      end
+
+      test "can get list of active jobs for configurations" do
+        manager = QueueManager.new
+
+        Resque.expects(:working).returns(mock_workers)
+
+        jobs = manager.active_jobs_for_configurations(configuration_ids)
+
+        assert_equal 4, jobs.size
+        assert_equal [1, 2, 3, 4], jobs.map { |j| j["pid"].to_i }
+
+      end
+
+      test "does not report on jobless workers" do
+        config_id = 5
+        worker = mock_worker(config_id, {})
+
+        job_hash = QueueManager.new.create_job_hash_from_worker(worker)
+
+        assert_nil job_hash
+
+      end
+
+      test "active workers can lose their jobs" do
+        manager = QueueManager.new
+
+        workers = mock_workers + [mock_worker(11, {})]
+
+        Resque.expects(:working).returns(workers)
+
+        ids = configuration_ids + [11]
+
+        jobs = manager.active_jobs_for_configurations(ids)
+
+        assert_equal 4, jobs.size
+        assert_equal [1, 2, 3, 4], jobs.map { |j| j["pid"].to_i }
+      end
+
+      test "does not return workers without jobs" do
+        manager = QueueManager.new
+
+        workers = mock_workers(4) + [mock_worker(11, {})]
+
+        Resque.expects(:working).returns(workers)
+
+        jobs = manager.active_jobs
+
+        assert_equal 4, jobs.size
+        assert_equal [0, 1, 2, 3], jobs.map { |j| j["pid"].to_i }
+      end
+
+      def mock_workers(num_workers = 10)
+        workers = []
+        num_workers.times do |num|
+          workers << mock_worker(num)
+        end
+        workers
+      end
+
+      def configuration_ids
+        [1, 2, 3, 4, 20]
+      end
+
+      def mock_worker(config_id, job = mock_job(config_id))
+        worker = mock
+        worker.stubs(:job).returns(job)
+        worker.stubs(:hostname).returns("bad_hostname")
+        worker.stubs(:to_s).returns("localhost:#{config_id}:execute,localhost_execute")
+        worker
+      end
+
+      def mock_job(config_id)
+        args = [{"params" => [config_id]}]
+        job = {"payload" => {"args" => args}}
+      end
+
+
+    end
+  end
+end