wukong 3.0.1 → 4.0.0

data/spec/support/model_test_helpers.rb

@@ -9,7 +9,7 @@ shared_context 'model', :model_spec do
 
   after(:each){ Gorillib::Test.nuke_constants ; Meta::Gorillib::Test.nuke_constants }
 
-  let(:mock_val){ mock('mock value') }
+  let(:mock_val){ double('mock value') }
 
   let(:smurf_class) do
     class Gorillib::Test::Smurf

data/spec/support/shared_context_for_graphs.rb

@@ -0,0 +1,57 @@
+shared_context "graphs" do
+
+  let(:empty_graph) do
+    Hanuman::Graph.receive({})
+  end
+
+  let(:single_stage_graph) do
+    Hanuman::Graph.receive({stages: {first: Hanuman::Stage.receive(label: :first)}})
+  end
+  
+  let(:graph) do
+    Hanuman::Graph.receive(stages: {
+                             first_a: Hanuman::Stage.receive(label: :first_a), # ancestor
+                             first_b: Hanuman::Stage.receive(label: :first_b), # ancestor, 
+                             second:  Hanuman::Stage.receive(label: :second),  # ancestor, descendent
+                             third_a: Hanuman::Stage.receive(label: :third_a), # ancestor, descendent
+                             third_b: Hanuman::Stage.receive(label: :third_b), #           descendent
+                             fourth:  Hanuman::Stage.receive(label: :fourth),  #           descendent
+                           },
+                           links: [
+                                   Hanuman::LinkFactory.connect(:simple, :first_a, :second),
+                                   Hanuman::LinkFactory.connect(:simple, :first_b, :second),
+                                   Hanuman::LinkFactory.connect(:simple, :second, :third_a),
+                                   Hanuman::LinkFactory.connect(:simple, :second, :third_b),
+                                   Hanuman::LinkFactory.connect(:simple, :third_a, :fourth),
+                                  ]
+                           )
+  end
+
+  let(:empty_tree) do
+    Hanuman::Tree.receive({})
+  end
+
+  let(:single_stage_tree) do
+    Hanuman::Tree.receive({stages: { first: Hanuman::Stage.receive(label: :first)}})
+  end
+  
+  let(:tree) do
+    Hanuman::Tree.receive(stages: {
+                            # important to mix up the order here so we
+                            # can ensure that tree-sorting is working.
+                            first:   Hanuman::Stage.receive(label: :first),   # ancestor,
+                            third_b: Hanuman::Stage.receive(label: :third_b), #           descendent
+                            second:  Hanuman::Stage.receive(label: :second),  # ancestor, descendent
+                            fourth:  Hanuman::Stage.receive(label: :fourth),  #           descendent
+                            third_a: Hanuman::Stage.receive(label: :third_a), # ancestor, descendent
+                          },
+                          links: [
+                                  Hanuman::LinkFactory.connect(:simple, :first,  :second),
+                                  Hanuman::LinkFactory.connect(:simple, :second, :third_a),
+                                  Hanuman::LinkFactory.connect(:simple, :second, :third_b),
+                                  Hanuman::LinkFactory.connect(:simple, :third_a, :fourth),
+                                 ]
+                          )
+  end
+
+end

data/spec/support/shared_examples_for_builders.rb

@@ -1,5 +1,12 @@
 shared_examples_for 'a Stage::Builder' do
-  before(:each){ Hanuman::GlobalRegistry.clear! }
+  before(:each) do
+    @registry = Hanuman::GlobalRegistry.show
+    Hanuman::GlobalRegistry.clear!
+  end
+  
+  after(:each) do
+    Hanuman::GlobalRegistry.merge! @registry
+  end
   
   context '.receive' do
     it 'extra arguments are stored in the :args attribute' do
@@ -84,18 +91,4 @@ shared_examples_for 'a Stage::Builder' do
       subject.serialize.should_not include(:args, :for_class)
     end
   end
-
-  context '#into' do
-    subject          { described_class.receive(label: :pyro)   }
-    let(:other_stage){ described_class.receive(label: :iceman) }
-    
-    it 'returns the linked into stage for chaining' do
-      subject.into(other_stage).should be(other_stage)      
-    end
-    
-    it 'links two stages together with a simple link' do
-      subject.into(other_stage)
-      subject.links.should be_any{ |link| link.from == :pyro and link.into == :iceman }
-    end
-  end
 end

data/spec/wukong/driver_spec.rb

@@ -1,2 +1,154 @@
 require 'spec_helper'
 
+describe Wukong::DriverMethods do
+  
+  describe "#construct_dataflow" do
+    
+    context "given a label registered to a processor" do
+      let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/) }
+      
+      context "constructs an anonymous dataflow" do
+        let(:dataflow) { driver.dataflow }
+        subject        { dataflow }
+        
+        it          { should_not be_nil   }
+        its(:label) { should     be_nil   }
+        its(:links) { should     be_empty }
+        
+        context "with a single stage" do
+          let(:stage) { dataflow.stages.values.first }
+          subject     { stage }
+
+          it          { should_not be_nil }
+          its(:label) { should == :regexp }
+          its(:match) { should == /hi/    }
+        end
+      end
+    end
+
+    context "given a serialization argument" do
+      context "that does not match a registered serializer" do
+        it "raises an error" do
+          expect { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, to: 'fake') }.to raise_error(Wukong::Error)
+        end
+      end
+      context "that matches a registered serializer" do
+        let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, to: 'json') }
+        let(:dataflow) { driver.dataflow }
+        it "appends the serializer to each of the leaves" do
+          dataflow.leaves.size.should == 1
+          dataflow.leaves.map(&:label).should_not include(:regexp)
+        end
+      end
+    end
+    
+    context "given a deserialization argument" do
+      let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, from: 'json') }
+      let(:dataflow) { driver.dataflow }
+
+      context "adds a deserializer" do
+        subject { dataflow.stages[:from_json] }
+        it      { should_not be_nil   }
+        it "which is the root of the dataflow" do
+          dataflow.root.should == subject
+        end
+        it "which is linked to the original root" do
+          dataflow.ancestors(dataflow.stages[:regexp]).should include(subject)
+        end
+      end
+    end
+
+    context "given a recordization argument" do
+      let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, as: Time) }
+      let(:dataflow) { driver.dataflow }
+      
+      context "adds a recordizer" do
+        subject { dataflow.stages[:recordize] }
+        it      { should_not be_nil   }
+        it "which is the root of the dataflow" do
+          dataflow.root.should == subject
+        end
+        it "which is linked to the original root" do
+          dataflow.ancestors(dataflow.stages[:regexp]).should include(subject)
+        end
+      end
+    end
+
+    context "given deserialization and recordization arguments" do
+      let(:driver)       { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, from: 'json', as: Time) }
+      let(:dataflow)     { driver.dataflow }
+      let(:recordizer)   { dataflow.stages[:recordize] }
+      let(:deserializer) { dataflow.stages[:from_json] }
+
+      context "adds a deserializer" do
+        subject { deserializer      }
+        it      { should_not be_nil }
+        it "which is the root of the dataflow" do
+          dataflow.root.should == subject
+        end
+        it "which is linked to the recordizer" do
+          dataflow.ancestors(dataflow.stages[:recordizer]).should include(subject)
+        end
+      end
+      
+      context "adds a recordizer" do
+        subject { recordizer        }
+        it      { should_not be_nil }
+        it "which is linked to the original root" do
+          dataflow.ancestors(dataflow.stages[:regexp]).should include(subject)
+        end
+      end
+      
+    end
+  end
+
+  describe "#setup_dataflow" do
+    let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/) }
+    
+    it "calls the driver's #setup method" do
+      driver.should_receive(:setup)
+      driver.setup_dataflow
+    end
+
+    it "calls setup on each stage of the dataflow" do
+      driver.dataflow.each_stage do |stage|
+        stage.should_receive(:setup)
+      end
+      driver.setup_dataflow
+    end
+  end
+
+  describe "#finalize_dataflow" do
+    let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/) }
+    it "calls the driver's #finalize method" do
+      driver.should_receive(:finalize)
+      driver.finalize_dataflow
+    end
+
+    it "calls finalize on each stage of the dataflow" do
+      driver.dataflow.each_stage do |stage|
+        stage.should_receive(:finalize)
+      end
+      driver.finalize_dataflow
+    end
+  end
+
+  describe "#finalize_and_stop_dataflow" do
+    let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/) }
+    it "calls the driver's #finalize and #stop methods" do
+      driver.should_receive(:finalize)
+      driver.should_receive(:stop)
+      driver.finalize_and_stop_dataflow
+    end
+
+    it "calls finalize and stop on each stage of the dataflow" do
+      driver.dataflow.each_stage do |stage|
+        stage.should_receive(:finalize)
+        stage.should_receive(:stop)
+      end
+      driver.finalize_and_stop_dataflow
+    end
+    
+  end
+  
+end

data/spec/wukong/local/runner_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Wukong::Local::LocalRunner do
-  before { EM.stub!(:run) }
+  before { EM.stub(:run) }
 
   describe "choosing a processor name" do
 
@@ -25,16 +25,5 @@ describe Wukong::Local::LocalRunner do
       local_runner(examples_dir('string_reverser.rb')).processor.should == 'string_reverser'
     end
   end
-
-  describe "uses a" do
-    it "StdioDriver by default" do
-      local_runner('identity').driver.should == Wukong::Local::StdioDriver
-    end
-
-    it "TCPDriver when given a --port argument" do
-      local_runner('identity','--tcp_port=6000').driver.should == Wukong::Local::TCPDriver
-    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/processor_spec.rb

@@ -9,7 +9,6 @@ describe Wukong::Processor do
     it{ should respond_to(:process)  }
     it{ should respond_to(:finalize) }
     it{ should respond_to(:stop)     }
-    it{ should respond_to(:notify)   }
   end
 
   describe "default process method" do

data/spec/wukong/runner_spec.rb

@@ -90,7 +90,7 @@ describe Wukong::Runner do
       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'))
+        ENV.stub(:[]).with("BUNDLE_GEMFILE").and_return(File.join(deploy_pack_dir, 'Gemfile'))
       end
       subject   { generic_runner }
       its(:deploy_pack_dir)  { should == '/'                      }
@@ -103,7 +103,7 @@ describe Wukong::Runner do
       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'))
+        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                               }

data/spec/wukong/source_spec.rb

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

data/spec/wukong/widget/extract_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe :extract do
+
+  let(:hsh) { { "hi" => "there", "top" => { "lower" => { "lowest" => "value" } } } }
+  let(:ary) { ['1', 2, 'three'] }
+
+  subject { processor(:extract) }
+  
+  it_behaves_like 'a processor', :named => :extract
+
+  context "on a string" do
+    it "emits the string with no arguments" do
+      processor(:extract).given('hi there', 'buddy').should emit('hi there', 'buddy')
+    end
+  end
+  context "on a Fixnum" do
+    it "emits the number with no arguments" do
+      processor(:extract).given(3, 3.0).should emit(3, 3.0)
+    end
+  end
+  context "on a Hash" do
+    it "emits the hash with no arguments" do
+      processor(:extract).given(hsh).should emit(hsh)
+    end
+    it "can extract a key" do
+      processor(:extract, part: 'hi').given(hsh).should emit('there')
+    end
+    it "emits nil when the value of the key is nil" do
+      processor(:extract, part: 'bye').given(hsh).should emit(nil)
+    end
+    it "can extract a nested key" do
+      processor(:extract, part: 'top.lower.lowest').given(hsh).should emit('value')
+    end
+    it "emits nil when the value of this nested key is nil" do
+      processor(:extract, part: 'foo.bar.baz').given(hsh).should emit(nil)
+    end
+  end
+  context "on an Array" do
+    it "emits the array with no arguments" do
+      processor(:extract).given(ary).should emit(ary)
+    end
+    it "can extract the nth value with an integer argument" do
+      processor(:extract, part: 2).given(ary).should emit(2)
+    end
+    it "can extract the nth value with a string argument" do
+      processor(:extract, part: '2').given(ary).should emit(2)
+    end
+  end
+  context "on JSON" do
+    let(:garbage) { '{"239823:' }
+    it "emits the JSON with no arguments" do
+      processor(:extract).given_json(hsh).should emit_json(hsh)
+    end
+    it "will skip badly formed records" do
+      processor(:extract).given(garbage).should emit(garbage)
+    end
+    it "can extract a key" do
+      processor(:extract, part: 'hi').given_json(hsh).should emit('there')
+    end
+    it "can extract a nested key" do
+      processor(:extract, part: 'top.lower.lowest').given_json(hsh).should emit('value')
+    end
+    it "emits nil when the record is missing the key" do
+      processor(:extract, part: 'foo.bar.baz').given_json(hsh).should emit(nil)
+    end
+  end
+  context "on delimited data" do
+    it "emits the row with no arguments" do
+      processor(:extract).given_delimited('|', ary).should emit(ary.map(&:to_s).join('|'))
+    end
+    it "can extract the nth value with an integer argument" do
+      processor(:extract, part: 2, separator: '|').given_delimited('|', ary).should emit('2')
+    end
+    it "can extract nth value with a string argument" do
+      processor(:extract, part: '2', separator: '|').given_delimited('|', ary).should emit('2')
+    end
+  end
+  context "on TSV" do
+    it "emits the TSV with no arguments" do
+      processor(:extract).given_tsv(ary).should emit(ary.map(&:to_s).join("\t"))
+    end
+    it "can extract the nth value with an integer argument" do
+      processor(:extract, part: 2).given_tsv(ary).should emit('2')
+    end
+    it "can extract the nth value with a string argument" do
+      processor(:extract, part: '2').given_tsv(ary).should emit('2')
+    end
+  end
+  context "on CSV" do
+    it "emits the CSV with no arguments" do
+      processor(:extract).given_csv(ary).should emit(ary.map(&:to_s).join(","))
+    end
+    it "can extract the nth value with an integer argument" do
+      processor(:extract, part: 2, separator: ',').given_csv(ary).should emit('2')
+    end
+    it "can extract the nth value with a string argument" do
+      processor(:extract, part: '2', separator: ',').given_csv(ary).should emit('2')
+    end
+  end
+end