bumbleworks 0.0.4

data/spec/lib/bumbleworks/configuration_spec.rb

@@ -0,0 +1,162 @@
+describe Bumbleworks::Configuration do
+  let(:configuration) {described_class.new}
+  before :each do
+    configuration.clear!
+  end
+
+  describe "#root" do
+    it 'raises an error if client did not define' do
+      expect{configuration.root}.to raise_error Bumbleworks::UndefinedSetting
+    end
+
+    it 'returns folder set by user' do
+      configuration.root = '/what/about/that'
+      configuration.root.should == '/what/about/that'
+    end
+
+    it 'uses Rails.root if Rails is defined' do
+      class Rails
+        def self.root
+          '/Rails/Root'
+        end
+      end
+
+      configuration.root.should == '/Rails/Root'
+      Object.send(:remove_const, :Rails)
+    end
+
+    it 'uses Sinatra::Application.root if defined' do
+      class Sinatra
+        class Application
+          def self.root
+            '/Sinatra/Root'
+          end
+        end
+      end
+
+      configuration.root.should == '/Sinatra/Root'
+      Object.send(:remove_const, :Sinatra)
+    end
+
+    it 'uses Rory.root if defined' do
+      class Rory
+        def self.root
+          '/Rory/Root'
+        end
+      end
+
+      configuration.root.should == '/Rory/Root'
+      Object.send(:remove_const, :Rory)
+    end
+  end
+
+  describe "#definitions_directory" do
+    it 'returns the folder which was set by the client app' do
+      File.stub(:directory?).with('/dog/ate/my/homework').and_return(true)
+      configuration.definitions_directory = '/dog/ate/my/homework'
+      configuration.definitions_directory.should == '/dog/ate/my/homework'
+    end
+
+    it 'returns the default folder if not set by client app' do
+      File.stub(:directory? => true)
+      configuration.root = '/Root'
+      configuration.definitions_directory.should == '/Root/lib/process_definitions'
+    end
+
+    it 'raises an error if default folder not found' do
+      configuration.root = '/Root'
+      expect{configuration.definitions_directory}.to raise_error Bumbleworks::InvalidSetting
+    end
+
+    it 'raises an error if specific folder not found' do
+      configuration.definitions_directory = '/mumbo/jumbo'
+      expect{configuration.definitions_directory}.to raise_error Bumbleworks::InvalidSetting
+    end
+  end
+
+  describe "#participants_directory" do
+    it 'returns the folder which was set by the client app' do
+      File.stub(:directory?).with('/dog/ate/my/homework').and_return(true)
+      configuration.participants_directory = '/dog/ate/my/homework'
+      configuration.participants_directory.should == '/dog/ate/my/homework'
+    end
+
+    it 'returns the default folder if not set by client app' do
+      File.stub(:directory? => false)
+      File.stub(:directory?).with('/Root/app/participants').and_return(true)
+      configuration.root = '/Root'
+      configuration.participants_directory.should == '/Root/app/participants'
+    end
+
+    it 'raises an error if default folder not found' do
+      configuration.root = '/Root'
+      expect{configuration.participants_directory}.to raise_error Bumbleworks::InvalidSetting
+    end
+
+    it 'raises an error if specific folder not found' do
+      configuration.participants_directory = '/mumbo/jumbo'
+      expect{configuration.participants_directory}.to raise_error Bumbleworks::InvalidSetting
+    end
+  end
+
+  describe "#storage" do
+    it 'can set storage directly' do
+      storage = double("Storage")
+      configuration.storage = storage
+      configuration.storage.should == storage
+    end
+  end
+
+  describe '#add_storage_adapter' do
+    it 'adds storage adapter to registered list' do
+      GoodForNothingStorage = OpenStruct.new(
+        :driver => nil, :display_name => 'Dummy', :use? => true
+      )
+      configuration.storage_adapters.should be_empty
+      configuration.add_storage_adapter(GoodForNothingStorage)
+      configuration.add_storage_adapter(Bumbleworks::HashStorage)
+      configuration.storage_adapters.should =~ [
+        GoodForNothingStorage, Bumbleworks::HashStorage
+      ]
+    end
+
+    it 'raises ArgumentError if object is not a storage adapter' do
+      expect {
+        configuration.add_storage_adapter(:nice_try_buddy)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#autostart_worker' do
+    it 'returns false by default' do
+      configuration.autostart_worker.should be_false
+    end
+
+    it 'only returns true if set explicitly to true' do
+      configuration.autostart_worker = 'yes'
+      configuration.autostart_worker.should be_false
+      configuration.autostart_worker = 1
+      configuration.autostart_worker.should be_false
+      configuration.autostart_worker = true
+      configuration.autostart_worker.should be_true
+    end
+  end
+
+  describe '#clear!' do
+    it 'resets #root' do
+      configuration.root = '/Root'
+      configuration.clear!
+      expect{configuration.root}.to raise_error Bumbleworks::UndefinedSetting
+    end
+
+    it 'resets #definitions_directory' do
+      File.stub(:directory? => true)
+      configuration.definitions_directory = '/One/Two'
+      configuration.definitions_directory.should == '/One/Two'
+      configuration.clear!
+
+      configuration.root = '/Root'
+      configuration.definitions_directory.should == '/Root/lib/process_definitions'
+    end
+  end
+end

data/spec/lib/bumbleworks/participant_registration_spec.rb

@@ -0,0 +1,13 @@
+describe Bumbleworks::ParticipantRegistration do
+  describe '.autoload_all' do
+    it 'autoloads all participants in directory' do
+      Bumbleworks.reset!
+      Bumbleworks.root = File.join(fixtures_path, 'apps', 'with_default_directories')
+      Object.should_receive(:autoload).with(:HoneyParticipant,
+        File.join(Bumbleworks.root, 'app', 'participants', 'honey_participant.rb'))
+      Object.should_receive(:autoload).with(:MolassesParticipant,
+        File.join(Bumbleworks.root, 'app', 'participants', 'molasses_participant.rb'))
+      Bumbleworks::ParticipantRegistration.autoload_all
+    end
+  end
+end

data/spec/lib/bumbleworks/process_definition_spec.rb

@@ -0,0 +1,178 @@
+describe Bumbleworks::ProcessDefinition do
+  before :each do
+    Bumbleworks.reset!
+    Bumbleworks.storage = {}
+  end
+
+  let(:valid_definition) { %q(
+    Bumbleworks.define_process 'monkeys' do
+      chocolate_covered_skis :are => 'awesome'
+    end
+  )}
+
+  it "can be constructed with name and definition" do
+    pdef = described_class.new(:name => 'zach', :definition => 'orbo')
+    pdef.name.should == 'zach'
+    pdef.definition.should == 'orbo'
+  end
+
+  it "can be constructed with name and tree" do
+    pdef = described_class.new(:name => 'zach', :tree => ["define", {"your" => "face"}])
+    pdef.name.should == 'zach'
+    pdef.tree.should == ["define", {"your" => "face"}]
+  end
+
+  describe '#build_tree!' do
+    it "converts Bumbleworks definition to Ruote tree" do
+      pdef = described_class.new(:name => 'monkeys', :definition => valid_definition)
+      pdef.build_tree!.should == [
+        "define", {"name" => "monkeys"},
+        [
+          ["chocolate_covered_skis", {"are" => "awesome"}, []]
+        ]
+      ]
+    end
+
+    it "raises error if name in definition does not match" do
+      wrong_named_def = valid_definition.gsub(/monkeys/, 'slot_cats')
+      pdef = described_class.new(:name => 'monkeys', :definition => wrong_named_def)
+      expect {
+        pdef.build_tree!
+      }.to raise_error(described_class::Invalid, /Name does not match name in definition/)
+    end
+
+    it "adds name to tree when not specified in definition" do
+      unnamed_def = valid_definition.gsub(/ 'monkeys'/, '')
+      pdef = described_class.new(:name => 'spit_salad', :definition => unnamed_def)
+      pdef.build_tree!.should == [
+        "define", {"name" => "spit_salad"},
+        [
+          ["chocolate_covered_skis", {"are" => "awesome"}, []]
+        ]
+      ]
+    end
+  end
+
+  describe "#validate!" do
+    it "raises error if name not specified" do
+      expect {
+        described_class.new.validate!
+      }.to raise_error(described_class::Invalid, /Name must be specified/)
+    end
+
+    it "raises error if definition and tree not specified" do
+      expect {
+        described_class.new.validate!
+      }.to raise_error(described_class::Invalid, /Definition or tree must be specified/)
+    end
+
+    it "raises error if definition invalid" do
+      pdef = described_class.new(:name => 'yay', :definition => 'do good stuff')
+      expect {
+        pdef.validate!
+      }.to raise_error(described_class::Invalid, /Definition is not a valid process definition/)
+    end
+
+    it "raises error if name already taken" do
+      Bumbleworks.dashboard.variables['tasty_beans'] = 'A miraculous ingredient'
+      expect {
+        described_class.new(:name => 'tasty_beans').validate!
+      }.to raise_error(described_class::Invalid, /Name is not unique/)
+    end
+  end
+
+  describe "#save!" do
+    it "validates" do
+      pdef = described_class.new
+      pdef.should_receive(:validate!)
+      pdef.save!
+    end
+
+    it "raises validation error if invalid" do
+      expect {
+        described_class.new.save!
+      }.to raise_error(described_class::Invalid)
+    end
+
+    it "registers the process definition with the dashboard" do
+      pdef = described_class.new(:name => 'monkeys', :definition => valid_definition)
+      pdef.save!
+      Bumbleworks.dashboard.variables['monkeys'].should ==
+        pdef.build_tree!
+    end
+  end
+
+  describe ".find_by_name" do
+    it "returns an instance with a previously registered definition" do
+      Bumbleworks.dashboard.variables['foo'] = 'go to the bar'
+      pdef = described_class.find_by_name('foo')
+      pdef.tree.should == 'go to the bar'
+    end
+
+    it "raises an error if registered definition can't be found by given name" do
+      lambda { described_class.find_by_name('nerf') }.should raise_error(described_class::NotFound)
+    end
+  end
+
+  describe "#load_definition_from_file" do
+    it "raises an error if given file can't be found" do
+      pdef = described_class.new(:name => 'whatever')
+      lambda { pdef.load_definition_from_file('nerf') }.should raise_error(described_class::FileNotFound)
+    end
+
+    it "sets #definition to the parsed result of the file, if found" do
+      pdef = described_class.new(:name => 'test_process')
+      pdef.load_definition_from_file definition_path('test_process')
+      pdef.definition.should == File.read(definition_path('test_process'))
+    end
+  end
+
+  describe '.create_all_from_directory!' do
+    let(:definitions_path) { File.join(fixtures_path, 'definitions') }
+
+    it 'raises error if any invalid files are encountered' do
+      expect {
+        described_class.create_all_from_directory!(definitions_path)
+      }.to raise_error(described_class::Invalid)
+    end
+
+    it 'rolls back any processes defined within current transaction if error' do
+      Bumbleworks.dashboard.variables['keep_me'] = 'top_secret_cat_pics'
+      Bumbleworks::Support.stub(:all_files).
+        and_yield(definition_path('test_process'), 'test_process').
+        and_yield(definition_path('a_list_of_jams'), 'a_list_of_jams')
+      expect {
+        described_class.create_all_from_directory!(definitions_path)
+      }.to raise_error
+      Bumbleworks.dashboard.variables['test_process'].should be_nil
+      Bumbleworks.dashboard.variables['keep_me'].should == 'top_secret_cat_pics'
+    end
+
+    it 'skips invalid files and loads all valid definitions when option specified' do
+      described_class.create_all_from_directory!(definitions_path, :skip_invalid => true)
+      Bumbleworks.dashboard.variables['test_process'].should ==
+        ["define", { "name" => "test_process" }, [["nothing", {}, []]]]
+      Bumbleworks.dashboard.variables['test_nested_process'].should ==
+        ["define", { "name" => "test_nested_process" }, [["nothing_nested", {}, []]]]
+      Bumbleworks.dashboard.variables['a_list_of_jams'].should be_nil
+    end
+  end
+
+  describe '.create!' do
+    it 'builds and saves a new instance' do
+      pdef = described_class.create!(:name => 'monkeys', :definition => valid_definition)
+      Bumbleworks.dashboard.variables['monkeys'].should ==
+        pdef.build_tree!
+    end
+  end
+
+  describe '.define' do
+    it 'creates a process definition from a given block' do
+      definition = described_class.define 'nammikins' do
+        treefles
+      end
+      Bumbleworks.dashboard.variables['nammikins'].should ==
+        ["define", {"name" => "nammikins"}, [["treefles", {}, []]]]
+    end
+  end
+end

data/spec/lib/bumbleworks/ruote_spec.rb

@@ -0,0 +1,107 @@
+describe Bumbleworks::Ruote do
+  before :each do
+    Bumbleworks.reset!
+  end
+
+  describe '.dashboard' do
+    it 'raises an error if no storage is defined' do
+      Bumbleworks.storage = nil
+      expect { described_class.dashboard }.to raise_error Bumbleworks::UndefinedSetting
+    end
+
+    it 'creates a new dashboard' do
+      Bumbleworks.storage = {}
+      described_class.dashboard.should be_an_instance_of(Ruote::Dashboard)
+    end
+
+    it 'does not start a worker if autostart is false' do
+      Bumbleworks.storage = {}
+      described_class.dashboard.worker.should be_nil
+    end
+
+    it 'starts a worker if autostart is true' do
+      Bumbleworks.storage = {}
+      Bumbleworks.autostart_worker = true
+      described_class.dashboard.worker.should_not be_nil
+    end
+
+    it 'starts a worker if :start_worker option is true' do
+      Bumbleworks.storage = {}
+      described_class.dashboard(:start_worker => true).worker.should_not be_nil
+    end
+  end
+
+  describe '.start_worker!' do
+    it 'adds new worker to dashboard and returns worker' do
+      Bumbleworks.storage = {}
+      described_class.dashboard.worker.should be_nil
+      new_worker = described_class.start_worker!
+      new_worker.should be_an_instance_of(Ruote::Worker)
+      described_class.dashboard.worker.should == new_worker
+    end
+
+    it 'joins current thread if :join option is true' do
+      Bumbleworks.storage = {}
+      ::Ruote::Dashboard.stub(:new).and_return(dash_double = double('dash', :worker => nil))
+      dash_double.should_receive(:join)
+      described_class.start_worker!(:join => true)
+    end
+
+    it 'returns if :join option not true' do
+      Bumbleworks.storage = {}
+      ::Ruote::Dashboard.stub(:new).and_return(dash_double = double('dash', :worker => nil))
+      dash_double.should_receive(:join).never
+      described_class.start_worker!
+    end
+  end
+
+  describe '.register_participants' do
+    it 'loads participants from given block, adding storage participant catchall' do
+      registration_block = Proc.new {
+        bees_honey 'BeesHoney'
+        maple_syrup 'MapleSyrup'
+        catchall 'NewCatchall'
+      }
+
+      Bumbleworks.storage = {}
+      described_class.dashboard.participant_list.should be_empty
+      described_class.register_participants &registration_block
+      described_class.dashboard.participant_list.should have(4).items
+      described_class.dashboard.participant_list.map(&:classname).should =~ ['BeesHoney', 'MapleSyrup', 'NewCatchall', 'Ruote::StorageParticipant']
+    end
+
+    it 'does not add storage participant catchall if already exists' do
+      registration_block = Proc.new {
+        bees_honey 'BeesHoney'
+        catchall
+      }
+
+      Bumbleworks.storage = {}
+      described_class.dashboard.participant_list.should be_empty
+      described_class.register_participants &registration_block
+      described_class.dashboard.participant_list.should have(2).items
+      described_class.dashboard.participant_list.map(&:classname).should =~ ['BeesHoney', 'Ruote::StorageParticipant']
+    end
+
+    it 'adds catchall participant if block is nil' do
+      Bumbleworks.storage = {}
+      described_class.dashboard.participant_list.should be_empty
+      described_class.register_participants &nil
+      described_class.dashboard.participant_list.should have(1).item
+      described_class.dashboard.participant_list.first.classname.should == 'Ruote::StorageParticipant'
+    end
+  end
+
+  describe '.storage' do
+    it 'raise error when storage is not defined' do
+      expect { described_class.send(:storage) }.to raise_error Bumbleworks::UndefinedSetting
+    end
+
+    it 'handles Hash storage' do
+      storage = {}
+      Bumbleworks.storage = storage
+      Ruote::HashStorage.should_receive(:new).with(storage)
+      described_class.send(:storage)
+    end
+  end
+end