ul-wukong 4.1.0

data/spec/wukong/local/runner_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Wukong::Local::LocalRunner do
+  before { EM.stub(:run) }
+
+  describe "choosing a processor name" do
+
+    it "raises an error without any arguments" do
+      expect { local_runner() }.to raise_error(Wukong::Error, /must provide.*processor.*run.*argument/i)
+    end
+    
+    it "raises an error when passed the name of a processor that isn't registered" do
+      expect { local_runner('some_proc_that_dont_exit') }.to raise_error(Wukong::Error, /no such processor.*some_proc.*/i)
+    end
+    
+    it "accepts an explicit --run argument" do
+      local_runner('--run=identity').processor.should == 'identity'
+    end
+    
+    it "accepts a registered processor name from the first argument" do
+      local_runner('identity').processor.should == 'identity'
+    end
+    
+    it "accepts a registerd processor name from the the basename of the first file argument" do
+      local_runner(examples_dir('string_reverser.rb')).processor.should == 'string_reverser'
+    end
+  end
+  
+end

data/spec/wukong/local/stdio_driver_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Wukong::Local::StdioDriver do
+  before { EM.stub(:stop) }
+  
+  let(:driver) { Wukong::Local::StdioDriver.new(:bogus_event_machine_inserted_arg, :identity, {}) }
+
+  it "attaches itself as an EventMachine handler for $stdin, providing the given label and settings" do
+    EM.should_receive(:attach).with($stdin, Wukong::Local::StdioDriver, :foo, {})
+    Wukong::Local::StdioDriver.start(:foo, {})
+  end
+
+  describe "setting up a dataflow" do
+    context "#post_init hook from EventMachine" do
+      after { driver.post_init }
+      
+      it "sets signal traps for INT and TERM" do
+        Signal.should_receive(:trap).with('INT').at_least(:once)
+        Signal.should_receive(:trap).with('TERM').at_least(:once)
+      end
+      
+      it "calls the #setup_dataflow method" do
+        driver.should_receive(:setup_dataflow).at_least(:once)
+      end
+      
+      it "syncs $stdout" do
+        $stdout.should_receive(:sync).at_least(:once)
+      end
+      
+    end
+  end
+
+  describe "driving a dataflow" do
+    context "#receive_line hook from EventMachine" do
+      let(:line) { "hello" }
+      
+      after  { driver.receive_line(line) }
+      it "passes the line to the #send_through_dataflow method" do
+        driver.should_receive(:send_through_dataflow).with(line)
+      end
+      
+      context "upon an error within the dataflow" do
+        let(:message) { "whoops" }
+        
+        before do
+          driver.should_receive(:send_through_dataflow).with(line) do
+            raise Wukong::Error.new(message)
+          end
+          driver.log.stub(:error)
+        end
+        
+        it "logs an error message" do
+          driver.log.should_receive(:error).with(kind_of(String))
+        end
+      end
+    end
+  end
+
+  describe "shutting down a dataflow" do
+    context "#unbind hook from EventMachine" do
+      after { driver.unbind }
+      
+      it "calls the #finalize_and_stop_dataflow method" do
+        driver.should_receive(:finalize_and_stop_dataflow)
+      end
+      
+      it "stops the EventMachine reactor" do
+        EM.should_receive(:stop)
+      end
+      
+    end
+  end
+end

data/spec/wukong/local_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Wukong::Local do
+  it_behaves_like 'a plugin'
+end
+

data/spec/wukong/logger_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Wukong::Logging do
+
+  let(:loggable) { Class.new.class_eval { include Wukong::Logging } }
+  let(:model)    { Class.new.class_eval { include Gorillib::Model } }
+  
+  describe "a class including Wukong::Logging" do
+    subject { loggable }
+
+    it { should respond_to(:log) }
+
+    describe "has instances that" do
+      let(:loggable_instance) { loggable.new      }
+      subject                 { loggable_instance }
+      
+      it   { should respond_to(:log)   }
+      describe "have an instance method #log that" do
+        let(:log) { loggable_instance.log }
+        subject   { log                   }
+
+        it { should respond_to(:debug) }
+        it { should respond_to(:info)  }
+        it { should respond_to(:warn)  }
+      end
+    end
+
+    describe "has subclasses" do
+      let(:child)  { Class.new(loggable)    }
+      
+      describe "with instances that" do
+        subject { child.new }
+        
+        it      { should respond_to(:log)   }
+      end
+    end
+  end
+
+  describe "a class including Gorillib::Model and then Wukong::Logging" do
+    let(:loggable_model) { model.class_eval { include Wukong::Logging } }
+    subject              { loggable_model                               }
+    
+    describe "has fields that" do
+      subject { loggable_model.fields }
+      it      { should include(:log) }
+    end
+  end
+end
+

data/spec/wukong/model/faker_spec.rb

@@ -0,0 +1,132 @@
+# require 'spec_helper'
+
+# describe 'Wukong::Faker', :helpers => true do
+
+#   context 'specifies fakers' do
+#     subject{ Class.new{ include Gorillib::Model; include Wukong::Faker } }
+
+#     it 'using type if no faker given' do
+#       subject.field :last_name, String
+#       # subject.fields[:last_name].type.should_receive(:fake_value)
+#       Gorillib::Factory(String).should_receive(:fake_value)
+#       subject.fake_value
+#     end
+
+#     it 'with proc' do
+#       my_proc = ->{ %w[John Paul George Ringo] }
+#       subject.field :first_name, String, :faker => my_proc
+#       my_proc.should_receive(:call)
+#       subject.fake_value
+#     end
+
+#     it 'with helper name' do
+#       subject.field :longitude, String, :faker => :fake_longitude
+#       Wukong::Faker::Helpers.should_receive(:fake_longitude)
+#       subject.fake_value
+#     end
+
+#     it 'with explicit faker factory' do
+#       subject.field :longitude, String, :faker => Gorillib::Factory(Integer)
+#       Gorillib::Factory(Integer).should_receive(:fake_value)
+#       subject.fake_value
+#     end
+
+#     it 'with explicit method' do
+#       subject.define_singleton_method(:fake_orgasm){ 'OHHH YEAHHH' }
+#       subject.field :orgasm, String
+#       subject.should_receive(:fake_orgasm)
+#       subject.fake_value
+#     end
+#   end
+
+#   be_ish_matcher :guid, /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+
+#   be_ish_matcher :fileext,    %r{^[\w\.\-]+$}
+#   be_ish_matcher :basename,   %r{^\w+\.\w+$}
+#   be_ish_matcher :dirname,    %r{^/(\w+/){1,}\w+$}
+#   be_ish_matcher :filename,   %r{^/(\w+/){1,}\w+\.\w+$}
+
+#   be_ish_matcher :identifier,  /\A[a-z]\w*\z/
+
+#   be_ish_matcher :hostname,    /^(\w+\.)+\w+$/
+#   be_ish_matcher :ip_address,  /^(\d+\.){3}\d+$/
+
+#   context 'extensions to Gorillib::Factory' do
+#     context Gorillib::Factory(String) do
+#       its(:fake_value){ should =~ /^\w+$/ }
+#     end
+#     context(Gorillib::Factory(Guid)) do
+#       its(:fake_value){ should be_guid_ish }
+#     end
+#     context(Gorillib::Factory(IpAddress)) do
+#       its(:fake_value){ should be_ip_address_ish }
+#     end
+#     context(Gorillib::Factory(Hostname)) do
+#       its(:fake_value){ should be_hostname_ish }
+#     end
+
+#     context(Gorillib::Factory(Symbol)) do
+#       its(:fake_value){ should be_a Symbol }
+#       its(:fake_value){ should be_identifier_ish }
+#     end
+
+#     context(Gorillib::Factory(Integer)) do
+#       its(:fake_value){ should be_a Integer }
+#       its(:fake_value){ should be < 100 }
+#     end
+
+#     context(Gorillib::Factory(Time)) do
+#       its(:fake_value){ should be_a Time }
+#       its(:fake_value){ should be_within(5).of(Time.now) }
+#     end
+
+#     context(Gorillib::Factory(NilClass)    ){ its(:fake_value){ should equal(nil) } }
+#     context(Gorillib::Factory(TrueClass)   ){ its(:fake_value){ should equal(true) } }
+#     context(Gorillib::Factory(FalseClass)  ){ its(:fake_value){ should equal(false) } }
+#     context(Gorillib::Factory(:boolean)    ){ its(:fake_value){ should be_in([true, false]) } }
+
+#   end
+
+#   context Wukong::Faker::Helpers do
+#     subject{ Wukong::Faker::Helpers }
+
+#     its(:fake_integer){ should be_a(Integer) }
+#     its(:fake_integer){ should be < 100 }
+#     it{ subject.fake_integer(:min => 90, :max => 90).should == 90 }
+#     it{ subject.fake_integer(:min => 91, :max => 99).should be_in(91..99) }
+
+#     its(:fake_float){ should be_a(Float) }
+#     its(:fake_float){ should be < 1.0 }
+#     it{ subject.fake_float(:min => 90, :max => 90).should == 90 }
+#     it{ subject.fake_float(:min => 91, :max => 99).should be_in(91..99) }
+
+#     its(:fake_latitude){       should be_a(Float) }
+#     its(:fake_latitude){       should be_in(32 .. 45) }
+#     its(:fake_longitude){      should be_a(Float) }
+#     its(:fake_longitude){      should be_in(-117 .. -68) }
+
+#     its(:fake_country_id){     should be_a(String) }
+
+#     its(:fake_area_code){      should be_a(Integer) }
+#     its(:fake_area_code){      should be_in( 201 .. 987) }
+
+#     its(:fake_identifier){     should be_identifier_ish }
+#     its(:fake_sentence){       should =~ /(\S+\s+){1,5}\S+\./ }
+#     its(:fake_sentence){       should =~ /(\S+\.)/ }
+
+#     its(:fake_fileext ){       should be_a(String) }
+#     its(:fake_basename){       should be_a(String) }
+#     its(:fake_dirname ){       should be_a(String) }
+#     its(:fake_filename){       should be_a(String) }
+#     its(:fake_fileext ){       should be_fileext_ish }
+#     its(:fake_basename){       should be_basename_ish }
+#     its(:fake_dirname ){       should be_dirname_ish }
+#     its(:fake_filename){       should be_filename_ish }
+
+#     its(:fake_hostname){       should be_hostname_ish }
+#     its(:fake_ip_addresss){    should be_ip_address_ish }
+#     its(:fake_version_number){ should be_a(String) }
+#     its(:fake_version_number){ should =~ /^\d+\.\d+$/ }
+#   end
+
+# end

data/spec/wukong/processor_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Wukong::Processor do
+
+  subject { Wukong::Processor.new }  
+
+  describe "has an interface" do
+    it{ should respond_to(:setup)    }
+    it{ should respond_to(:process)  }
+    it{ should respond_to(:finalize) }
+    it{ should respond_to(:stop)     }
+  end
+
+  describe "default process method" do
+    it "yields the original input record by default on process" do
+      expect { |b| subject.process(1, &b) }.to yield_with_args(1)
+    end
+  end
+  
+end
+  

data/spec/wukong/runner_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Wukong::Runner do
+
+  context "can boot itself by" do
+
+    describe "loading" do
+      it "files passed on the command-line" do
+        loadable = examples_dir('loadable.rb')
+        generic_runner(loadable) do
+          should_receive(:load_ruby_file).with(loadable)
+        end
+      end
+      it "files when its in a deploy pack" do
+        generic_runner { should_receive(:load_deploy_pack) }
+      end
+    end
+
+    describe "configuring" do
+      subject do
+        Class.new(Wukong::Runner).tap do |configured|
+          configured.class_eval do
+            usage       'a nice usage message'
+            description 'a lovely description'
+          end
+        end
+      end
+      
+      it "a usage message" do
+        runner(subject, 'wu-generic').settings.usage.should =~ /^usage: .* a nice usage message$/
+      end
+
+      it "a description" do
+        runner(subject, 'wu-generic').settings.description.should == 'a lovely description'
+      end
+
+      it "plugins" do
+        generic_runner { Wukong.should_receive(:configure_plugins) }
+      end
+    end
+
+    describe "resolving" do
+      it "doesn't move on if resolve causes an error" do
+        generic_runner do
+          settings.should_receive(:resolve!).and_raise(RuntimeError)
+          should_not_receive(:setup)
+          should_not_receive(:validate)
+          should_not_receive(:run)
+        end
+      end
+    end
+
+    describe "setting up" do
+      it "asks plugins to boot" do
+        generic_runner do
+          Wukong.should_receive(:boot_plugins)
+        end
+      end
+    end
+
+    describe "validating" do
+      it "should run if validatation passes" do
+        generic_runner do
+          should_receive(:validate).and_return(true)
+          should_receive(:run)
+        end
+      end
+      it "dies if validate fails" do
+        generic_runner do
+          should_receive(:validate).and_return(false)
+          should_not_receive(:run)
+          should_receive(:die)
+        end
+      end
+    end
+  end
+
+  context "situating itself within a deploy pack" do
+    context "in an arbitrary directory" do
+      let(:dir) { examples_dir('empty') }
+      before    { FileUtils.cd(dir)     }
+      subject   { generic_runner            }
+      its(:deploy_pack_dir)  { should == '/'                      }
+      its(:environment_file) { should == '/config/environment.rb' }
+      its(:in_deploy_pack?)  { should be_false                    }
+    end
+
+    context "when BUNDLE_GEMFILE points at a regular Ruby project" do
+      let(:dir)             { examples_dir('empty')       }
+      let(:deploy_pack_dir) { examples_dir('ruby_project') }
+      before do
+        FileUtils.cd(dir)
+        ENV.stub(:[]).with("BUNDLE_GEMFILE").and_return(File.join(deploy_pack_dir, 'Gemfile'))
+      end
+      subject   { generic_runner }
+      its(:deploy_pack_dir)  { should == '/'                      }
+      its(:environment_file) { should == '/config/environment.rb' }
+      its(:in_deploy_pack?)  { should be_false                    }
+    end
+    
+    context "when BUNDLE_GEMFILE points at a deploy pack" do
+      let(:dir)             { examples_dir('empty')       }
+      let(:deploy_pack_dir) { examples_dir('deploy_pack') }
+      before do
+        FileUtils.cd(dir)
+        ENV.stub(:[]).with("BUNDLE_GEMFILE").and_return(File.join(deploy_pack_dir, 'Gemfile'))
+      end
+      subject   { generic_runner }
+      its(:deploy_pack_dir)  { should == deploy_pack_dir.to_s                               }
+      its(:environment_file) { should == File.join(deploy_pack_dir, 'config/environment.rb')}
+      its(:in_deploy_pack?)  { should be_true                                               }
+    end
+    
+    context "in an arbitrary Ruby project with a Gemfile" do
+      let(:dir) { examples_dir('ruby_project') }
+      before    { FileUtils.cd(dir)            }
+      subject   { generic_runner                   }
+      its(:deploy_pack_dir)  { should == '/'                      }
+      its(:environment_file) { should == '/config/environment.rb' }
+      its(:in_deploy_pack?)  { should be_false                    }
+    end
+
+    context "in a deploy pack with a Gemfile and a config/environment.rb" do
+      let(:dir) { examples_dir('deploy_pack')  }
+      before    { FileUtils.cd(dir)            }
+      subject   { generic_runner                       }
+      its(:deploy_pack_dir)  { should == dir                                    }
+      its(:environment_file) { should == File.join(dir, 'config/environment.rb')}
+      its(:in_deploy_pack?)  { should be_true                                   }
+    end
+  end
+end