active_worker 0.50.0

data/lib/active_worker/modes_map.rb

@@ -0,0 +1,37 @@
+module ActiveWorker
+  class ModesMap
+
+    attr_reader :modes_hash
+
+    def initialize
+      @modes_hash = Hash.new do |hash, key|
+        inner_hash = {}
+        hash[key] = inner_hash
+        inner_hash
+      end
+    end
+
+    def add_mode(mode_name, field_maps)
+      modes_hash[normalize_mode_name(mode_name)].merge! field_maps
+    end
+
+    def normalize_mode_name(mode_name)
+      mode_name.to_sym
+    end
+
+    def modes
+      modes_hash.keys
+    end
+
+    def supports?(mode_name)
+      modes.include? normalize_mode_name(mode_name)
+    end
+
+    def mode(mode_name)
+      if supports? mode_name
+        modes_hash[normalize_mode_name(mode_name)]
+      end
+    end
+
+  end
+end

data/lib/active_worker/notification_event.rb

@@ -0,0 +1,9 @@
+module ActiveWorker
+  class NotificationEvent < ActiveWorker::Event
+
+    def generate_message
+      "#{configuration.event_name} has been notified"
+    end
+
+  end
+end

data/lib/active_worker/parent_event.rb

@@ -0,0 +1,5 @@
+module ActiveWorker
+  class ParentEvent < ActiveWorker::Event
+    extend Behavior::CreateFromError
+  end
+end

data/lib/active_worker/started_event.rb

@@ -0,0 +1,10 @@
+module ActiveWorker
+  class StartedEvent < ActiveWorker::Event
+    def generate_message
+      "#{configuration.event_name} started"
+    end
+
+    after_create :notify_root_of_child_started
+
+  end
+end

data/lib/active_worker/templatable.rb

@@ -0,0 +1,46 @@
+module ActiveWorker
+  module Templatable
+
+    module ClassMethods
+      def templates_with_names
+        Template.with_names(self)
+      end
+    end
+
+    def self.included(base)
+      base.field :renderable, :type => Boolean, :default => true
+      base.field :template_name
+
+      base.extend(ClassMethods)
+    end
+
+    def find_template
+      child_template_ids = configurations.map(&:find_template).map(&:id)
+
+      attributes_for_template = {}
+      attributes_for_template[:configuration_type] = self.class.name
+
+      if child_template_ids.any?
+        attributes_for_template[:child_template_ids] = child_template_ids
+      end
+
+      self.class.template_fields.each do |field|
+        attributes_for_template[field] = read_attribute(field)
+      end
+
+      template = Template.find_or_create_by(attributes_for_template)
+      template.name = template_name if template_name && (! template_name.empty?)
+      template.save!
+      template
+    end
+
+    def template_name_or(input_string)
+      if template_name && (! template_name.empty?)
+        template_name
+      else
+        input_string
+      end
+    end
+
+  end
+end

data/lib/active_worker/template.rb

@@ -0,0 +1,41 @@
+module ActiveWorker
+  class Template
+    include Mongoid::Document
+
+    has_and_belongs_to_many :child_templates,  :class_name => "ActiveWorker::Template", :inverse_of => :parent_templates
+
+    field :name
+    field :configuration_type
+
+    scope :with_names, ->(configuration_class) { where(:name.exists => true, :configuration_type => configuration_class.name)}
+
+    def name_for_display
+      if(name && !(name.empty?))
+        name
+      else
+        configuration_type.split("::")[0..-2].join(" ")
+      end
+    end
+
+    def build_configuration
+      configuration = configuration_class.new
+
+      configuration_class.template_fields.each do |field|
+        configuration.write_attribute(field,read_attribute(field))
+      end
+
+      configuration.template_name = name
+
+      child_template_ids.each do |child_id|
+        child = Template.find(child_id)
+        configuration.configurations << child.build_configuration
+      end
+
+      configuration
+    end
+
+    def configuration_class
+      configuration_type.constantize
+    end
+  end
+end

data/lib/active_worker/termination_event.rb

@@ -0,0 +1,21 @@
+module ActiveWorker
+  class TerminationEvent < ActiveWorker::FinishedEvent
+
+    def self.from_termination(root_configuration)
+      events = []
+      root_configuration.configurations_for_events.each do |configuration|
+        events << create_termination_from_configuration(configuration) unless configuration.completed?
+      end
+      events
+    end
+
+    def self.create_termination_from_configuration(configuration)
+      constructor_options = {
+          :message => "#{configuration.event_name} was terminated",
+          :configuration => configuration,
+      }
+      create! constructor_options
+    end
+
+  end
+end

data/test/mongoid.yml

@@ -0,0 +1,28 @@
+test:
+  sessions:
+    default:
+      database: active_worker_test
+      hosts:
+        - localhost:27017
+      options:
+        consistency: :strong
+        safe: true
+        identity_map_enabled: true
+  options:
+    preload_models: true
+
+
+
+#settings: &settings
+#  autocreate_indexes: true
+#  identity_map_enabled: true
+#
+#defaults: &defaults
+#  <<: *settings
+#  host: localhost
+#  port: 27017
+#
+#test:
+#  <<: *defaults
+#  database: active_worker_test
+#  logger: false

data/test/test_acts_as_root_object.rb

@@ -0,0 +1,123 @@
+require_relative "test_helper"
+
+module ActiveWorker
+  class ActsAsRootObjectTest < ActiveSupport::TestCase
+
+
+    test "renderable configuration hashes returns array of configuration hashes" do
+      root = Rootable.create
+      topconfig1 = root.configurations.create({}, TemplatableTopConfig)
+      topconfig2 = root.configurations.create({}, TemplatableTopConfig)
+      child_config1 = topconfig2.configurations.create({}, TemplatableChildConfig)
+
+      assert_equal 2, root.renderable_configuration_hashes.size
+      assert_equal 1, root.renderable_configuration_hashes[1]["configurations"].size
+
+    end
+
+    test "renderable configurations hashes only returns with renderable configurations" do
+
+      root = Rootable.create
+
+      topconfig1 = root.configurations.create({}, TemplatableTopConfig)
+      topconfig2 = root.configurations.create({}, TopConfig)
+      templatable_child_config1 = topconfig1.configurations.create({}, TemplatableChildConfig)
+      child_config1 = topconfig1.configurations.create({}, ChildConfig)
+
+      templatable_child_config2 = topconfig2.configurations.create({}, TemplatableChildConfig)
+      child_config2 = topconfig2.configurations.create({}, ChildConfig)
+
+      renderable_hashes = root.renderable_configuration_hashes
+
+      assert_equal 1, renderable_hashes.size
+      assert_equal 1, renderable_hashes[0]["configurations"].size
+
+    end
+
+    test "sets flags on immediate child configurations" do
+      root = Rootable.create flags: {"flag" => true}
+
+      topconfig1 = root.configurations.create({}, TemplatableTopConfig)
+      topconfig2 = root.configurations.create({}, TopConfig)
+      root.set_flags
+      topconfig1.reload
+      topconfig2.reload
+
+      templatable_child_config1 = topconfig1.configurations.create({}, TemplatableChildConfig)
+      child_config1 = topconfig1.configurations.create({}, ChildConfig)
+
+      templatable_child_config2 = topconfig2.configurations.create({}, TemplatableChildConfig)
+      child_config2 = topconfig2.configurations.create({}, ChildConfig)
+
+      assert topconfig1.flags["flag"]
+      assert topconfig2.flags["flag"]
+      assert templatable_child_config1.flags["flag"]
+      assert child_config1.flags["flag"]
+      assert templatable_child_config2.flags["flag"]
+      assert child_config2.flags["flag"]
+    end
+
+    test "is completed when configurations complete" do
+      root = Rootable.create
+      topconfig1 = root.configurations.create({}, TemplatableTopConfig)
+      topconfig2 = root.configurations.create({}, TemplatableTopConfig)
+
+      root.reload
+      assert_equal false, root.completed?
+
+      topconfig1.finished
+
+      root.reload
+      assert_equal false, root.completed?
+
+      topconfig2.finished
+
+      root.reload
+      assert_equal true, root.completed?
+
+    end
+
+    test "duration calculates when completed" do
+      root = Rootable.create
+      topconfig1 = root.configurations.create({}, TemplatableTopConfig)
+
+      initial_duration = root.duration
+
+      assert initial_duration > 0
+
+      topconfig1.finished
+
+      final_duration = root.duration
+
+      assert initial_duration < final_duration
+    end
+
+    test "duration returns 0 if completed but missing finished_at" do
+      root = Rootable.create
+
+      root.root_object_finished = true
+
+      duration = root.duration
+
+      assert_equal 0, duration
+    end
+
+
+    test "sets finished_at correctly" do
+      root = Rootable.create
+      topconfig1 = TemplatableTopConfig.create
+      root.configurations << topconfig1
+
+      root.reload
+      assert_nil root.finished_at
+
+      topconfig1.finished
+      root.reload
+
+      assert root.completed?
+      assert root.finished_at.to_i > 0
+    end
+
+  end
+
+end

data/test/test_can_be_notified.rb

@@ -0,0 +1,44 @@
+require_relative "test_helper"
+
+module ActiveWorker
+
+  class CanBeNotifiedTest < ActiveSupport::TestCase
+
+    class Configuration < ActiveWorker::Configuration
+        include Expandable
+        config_field :wait_for_notifications, default: true
+        config_field :nodes
+
+        def expansion_maps_for_threads
+          nodes.split(",").map { |node| {nodes: node} }
+        end
+      end
+
+      class Controller < ActiveWorker::Controller
+        include Behavior::CanBeNotified
+
+        def execute
+          sleep 0.1 until configuration.notified?
+        end
+      end
+
+    test "controller forwards notifications" do
+      Controller::ClassMethods::SLEEP_DURATION = 0.1
+
+      nodes = "thread1, thread2, thread3"
+      configuration = CanBeNotifiedTest::Configuration.create nodes: nodes
+
+      configuration.launch
+      sleep 0.1 until (StartedEvent.count == nodes.split(",").size)
+      configuration.notify
+
+      wait_for_all_configurations
+      assert_no_failures
+
+      assert_equal 3, ActiveWorker::FinishedEvent.count
+    end
+
+
+  end
+
+end

data/test/test_configuration.rb

@@ -0,0 +1,281 @@
+require_relative "test_helper"
+
+
+module ActiveWorker
+  class ConfigurationTest < ActiveSupport::TestCase
+
+    test "can scope a child configuration type using mine" do
+      parent_config = TopConfig.create(top_field: "top field")
+      child_config0 = ChildConfig.create(child_field: "child field", parent_configuration: parent_config)
+      child_config1 = ChildConfig.create(child_field: "different child field")
+
+      assert_equal 1, parent_config.child_configs.count
+      assert_equal child_config0, parent_config.child_configs.first
+
+    end
+
+    test "Child Config is of the correct type" do
+      parent_config = TopConfig.create(top_field: "top field")
+      child_config0 = ChildConfig.create(child_field: "child field", parent_configuration: parent_config)
+
+      assert_equal TopConfig, parent_config.class
+
+      child_config = ChildConfig.where(parent_configuration_id: parent_config.to_param).first
+      assert_equal ChildConfig, child_config.class
+
+    end
+
+    test "completed?" do
+      config = TopConfig.create
+      assert_equal false, config.completed?
+      FinishedEvent.create configuration: config
+      assert config.completed?
+    end
+
+    test "passses down root object when saved" do
+      root = Rootable.create
+      config = TopConfig.new
+      root.configurations << config
+      config2 = ChildConfig.new parent_configuration: config
+
+      config.save!
+      config2.save!
+      assert_equal root, config2.root_object
+    end
+
+    test "passes down flags when saved" do
+      root = Rootable.create flags: {"analyze_performance" => true}
+      config = TopConfig.new flags: root.flags
+      root.configurations << config
+      config2 = ChildConfig.new parent_configuration: config
+
+      config.save!
+      config2.save!
+      assert config2.flags["analyze_performance"]
+    end
+
+    test "can get configuration hierarchy" do
+      config = TopConfig.create
+      config2 = ChildConfig.create parent_configuration: config
+      config3 = ChildConfig.create parent_configuration: config
+      config4 = ChildConfig.create parent_configuration: config3
+      config5 = ChildConfig.create parent_configuration: config3
+
+      root = Rootable.create
+      root.configurations << config
+
+      top_config = Configuration.get_as_hash_by_root_object(root).first
+
+      assert_equal config.to_param, top_config["_id"]
+      assert_equal config2.to_param, top_config["configurations"][0]["_id"]
+      assert_equal config3.to_param, top_config["configurations"][1]["_id"]
+
+      assert_equal config4.to_param, top_config["configurations"][1]["configurations"][0]["_id"]
+      assert_equal config5.to_param, top_config["configurations"][1]["configurations"][1]["_id"]
+    end
+
+    test "can get configurations as flat array" do
+      config = TopConfig.create
+      config2 = ChildConfig.create parent_configuration: config
+      config3 = ChildConfig.create parent_configuration: config
+      config4 = ChildConfig.create parent_configuration: config3
+      config5 = ChildConfig.create parent_configuration: config3
+
+      root = Rootable.create
+      root.configurations << config
+
+      configs = Configuration.get_as_flat_hash_by_root_object(root)
+
+      assert_equal 5, configs.size
+    end
+
+    test "can get renderable configuration hierarchy" do
+      root = Rootable.create
+      config = TopConfig.create renderable: true
+      root.configurations << config
+      config2 = ChildConfig.create parent_configuration: config, renderable: true
+      config3 = ChildConfig.create parent_configuration: config, renderable: false
+      config4 = ChildConfig.create parent_configuration: config3, renderable: true
+      config5 = ChildConfig.create parent_configuration: config3, renderable: false
+      config6 = ChildConfig.create parent_configuration: config2, renderable: true
+      config7 = ChildConfig.create parent_configuration: config6, renderable: false
+      config8 = ChildConfig.create parent_configuration: config6, renderable: true
+
+      top_config = Configuration.get_renderable_hash_by_root_object(root).first
+      assert_equal config.to_param, top_config["_id"]
+      assert_equal 1, top_config["configurations"].size
+      assert_equal config2.to_param, top_config["configurations"][0]["_id"]
+
+      assert_equal config6.to_param, top_config["configurations"][0]["configurations"][0]["_id"]
+      assert_equal 1, top_config["configurations"][0]["configurations"].size
+      assert_equal config8.to_param, top_config["configurations"][0]["configurations"][0]["configurations"][0]["_id"]
+    end
+
+    test "can get renderable hash for given configuration" do
+      config = TopConfig.create renderable: true
+      config2 = ChildConfig.create parent_configuration: config, renderable: true
+      config3 = ChildConfig.create parent_configuration: config, renderable: false
+
+      top_config = Configuration.renderable_hash_for_configuration(config.id)
+
+      assert_equal config.to_param, top_config["_id"]
+      assert_equal 1, top_config["configurations"].size
+      assert_equal config2.to_param, top_config["configurations"][0]["_id"]
+      assert_equal "ActiveWorker::TopConfig", top_config["_type"]
+    end
+
+    test "Base Configurations can be hashable with type" do
+      config = Configuration.create renderable: true
+      config2 = Configuration.create parent_configuration: config, renderable: true
+      config3 = Configuration.create parent_configuration: config, renderable: false
+
+      top_config = Configuration.renderable_hash_for_configuration(config.id)
+
+      assert_equal config.to_param.to_s, top_config["_id"]
+      assert_equal 1, top_config["configurations"].size
+      assert_equal config2.to_param.to_s, top_config["configurations"][0]["_id"]
+
+      assert_equal "ActiveWorkerConfiguration", top_config["_type"]
+      assert_equal "ActiveWorkerConfiguration", top_config["configurations"][0]["_type"]
+
+    end
+
+    test "can load hashes from configurations that no longer exist" do
+      module SoonToNotExist
+        class TopConfig < Configuration
+          field :top_field
+
+          def child_configs
+            ChildConfig.mine(self).all
+          end
+        end
+
+        class ChildConfig < Configuration
+          field :child_field
+        end
+      end
+      root = Rootable.create
+      config = SoonToNotExist::TopConfig.create
+      root.configurations << config
+      config2 = SoonToNotExist::ChildConfig.create parent_configuration: config
+      id1 = config.to_param
+      id2 = config2.to_param
+
+      ActiveWorker::ConfigurationTest::SoonToNotExist.send(:remove_const, :TopConfig)
+      ActiveWorker::ConfigurationTest::SoonToNotExist.send(:remove_const, :ChildConfig)
+
+      assert_raise NameError do
+        SoonToNotExist::TopConfig
+      end
+      assert_raise NameError do
+        SoonToNotExist::ChildConfig
+      end
+
+      top_config = Configuration.get_as_hash_by_root_object(root).first
+      assert_equal id1, top_config["_id"]
+      assert_equal id2, top_config["configurations"][0]["_id"]
+
+    end
+
+    test "can create started event" do
+      configuration = Configuration.create
+
+      configuration.started
+      assert_equal 1, StartedEvent.where(configuration_id: configuration.to_param).size
+      assert_match /#{configuration.event_name}/, StartedEvent.where(configuration_id: configuration.to_param).first.message
+    end
+
+    test "can create finished event" do
+      configuration = Configuration.create
+
+      configuration.finished
+      assert_equal 1, FinishedEvent.where(configuration_id: configuration.to_param).size
+      assert_match /#{configuration.event_name}/, FinishedEvent.where(configuration_id: configuration.to_param).first.message
+    end
+
+    test "can be notified" do
+      configuration = Configuration.create
+      assert_equal false, configuration.notified?
+      configuration.notify
+      assert configuration.notified?
+    end
+
+    test "can treat as hash" do
+      config = Configuration.create value: "value"
+
+      assert_equal "value", config[:value]
+
+      config[:value]= "value2"
+
+      assert_equal "value2", config[:value]
+
+      assert_nil config[:bad_method]
+
+    end
+
+    test "can retrieve hash of config fields" do
+      class TestConfig < Configuration
+        config_field :config_field
+        template_field :template_field
+        field :other_field
+      end
+
+      config = TestConfig.create config_field: "config_field",
+                                 template_field: "template_field",
+                                 other_field: "other_field"
+
+      expected_config_fields = {"config_field" => "config_field",
+                                "template_field" => "template_field"}
+      assert_equal expected_config_fields, config.defined_fields
+    end
+
+    test "launch calls after launch methods" do
+      config = AfterLaunchConfig.create
+      config.expects(:after_launch_method).with([config])
+      config.stubs(:enqueue_job)
+      config.launch
+    end
+
+    test "launch returns configurations" do
+      config = AfterLaunchConfig.create
+      AfterLaunchConfig.any_instance.stubs(:enqueue_job)
+      after_launch_configs = ["after launch 1", "after launch 2"]
+
+      config.stubs(:after_launch_method).returns(after_launch_configs)
+
+      configs = config.launch
+      assert_equal 3, configs.size
+
+      assert_equal [config] + after_launch_configs, configs
+    end
+
+    test "can create configuration with root object directly" do
+      root = Rootable.create
+      configuration = nil
+      assert_nothing_raised Mongoid::Errors::InvalidSetPolymorphicRelation do
+        configuration = TopConfig.create root_object: root
+      end
+
+      assert_equal root, configuration.root_object
+      assert_equal 1, root.configurations.size
+      assert_equal configuration, root.configurations.first
+
+    end
+
+    test "can create create config with root object directly" do
+      root = Rootable.create
+      config = TopConfig.create root_object: root
+
+      assert_equal 1, root.configurations.count
+      assert_equal config, root.configurations.first
+
+      root.reload
+      config.reload
+
+      assert_equal 1, root.configurations.count
+      assert_equal config, root.configurations.first
+
+    end
+
+  end
+end