ul-wukong 4.1.0

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+require 'wukong'
+require 'wukong/spec_helpers'
+require 'wukong/source'
+require_relative './support/shared_context_for_graphs'
+require_relative './support/shared_examples_for_shortcuts'
+require_relative './support/shared_examples_for_builders'
+require_relative './support/shared_context_for_reducers'
+
+RSpec.configure do |config|
+  
+  config.mock_with :rspec
+  
+  include Wukong::SpecHelpers
+  def root
+    @root ||= Pathname.new(File.expand_path('../..', __FILE__))
+  end
+
+  def local_runner *args
+    runner(Wukong::Local::LocalRunner, 'wu-local', *args)
+  end
+
+  def generic_runner *args
+    # the wu-generic program doesn't have to exist for this Runner to
+    # work if it's called from Ruby code
+    runner(Wukong::Runner, 'wu-generic', *args) 
+  end
+
+  def wu_local *args
+    command('wu-local', *args)
+  end
+  
+  def wu_source *args
+    command('wu-source', *args)
+  end
+  
+  def wu *args
+    command('wu', *args)
+  end
+  
+  # FIXME Why is this here?
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  
+end

data/spec/support/example_test_helpers.rb

@@ -0,0 +1,95 @@
+if ENV['WUKONG_COV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/gorillib/'
+    add_filter '/away/'
+    add_group  'Hanuman', '/hanuman/'
+  end
+end
+
+require 'gorillib/pathname'
+require 'gorillib/type/extended'
+require 'wukong/model/faker'
+
+Pathname.register_path(:wukong_root, File.expand_path('..', File.dirname(__FILE__)))
+Pathname.register_path(:examples,    :wukong_root, 'examples')
+Pathname.register_path(:tmp,         :wukong_root, 'tmp')
+Pathname.register_path(:data,        :wukong_root, 'data')
+Pathname.path_to(:tmp).mkpath
+
+Dir[ Pathname.path_to('spec', 'support', '*.rb') ].each{|f| require f }
+
+result   = `dot -V 2>&1` rescue nil
+GRAPHVIZ = ($?.exitstatus == 0) && (result =~ /dot - graphviz version/)
+puts 'Some specs require graphviz to run -- brew/apt install graphviz, it is pretty awesome' unless GRAPHVIZ
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+shared_context 'wukong', :helpers => true do
+  RSpec::Matchers.define(:be_in){|expected| match{|actual| expected.include?(actual) } }
+
+  def self.be_ish_matcher(handle, regexp)
+    RSpec::Matchers.define("be_#{handle}_ish"){ match{|actual| actual.should =~ regexp } }
+  end
+
+  let(:mock_val)      { mock('mock val')       }
+  let(:mock_record)   { mock('mock record')    }
+  let(:mock_stage)    { mock('mock stage')     }
+  let(:mock_processor){ mock('mock processor') }
+
+  let(:test_source)         { Wukong::Integers.new(:name => :integers, :qty => 100) }
+  let(:test_sink)           { Wukong::Sink::ArraySink.new(:name => :test_sink)      }
+  let(:test_processor_class){ Wukong::AsIs                                          }
+  let(:test_processor)      { test_processor_class.new                              }
+  let(:test_filter)         { Wukong::Widget::RegexpFilter.new(:re => /^m/)         }
+  let(:test_dataflow)       { Wukong.dataflow(:test_dataflow)                       }
+end
+
+require 'gorillib/utils/capture_output'
+
+module WukongTestHelpers
+
+  def example_script_filename(name)
+    Pathname.path_to(:examples, name)
+  end
+
+  def example_script_contents(name)
+    File.read(example_script_filename(name))
+  end
+
+  def sample_data_filename(name)
+    Pathname.path_to(:wukong_root, 'data', name)
+  end
+
+  def sample_data(name)
+    File.open(sample_data_filename(name))
+  end
+
+end
+
+RSpec::Core::DSL.module_eval do
+  def describe_example_script(example_name, source_file, attrs={}, &block)
+    return unless attrs[:only]
+    load Pathname.path_to(:examples, source_file)
+    describe "Example: #{example_name}", attrs.merge(:examples_spec => true, :helpers => true) do
+      let(:example_name){ example_name }
+      instance_eval(&block)
+    end
+  rescue StandardError => err
+    warn "Broken example #{example_name} with script #{source_file} (#{attrs})"
+    warn err
+    warn err.backtrace.join("\n")
+  end
+
+  def it_generates_graphviz
+    it 'generates a graphviz picture', :if => GRAPHVIZ do
+      require 'hanuman/graphvizzer/gv_presenter'
+      #
+      basename = Pathname.path_to(:tmp, example_name.to_s)
+      Wukong.to_graphviz.save(basename, 'png')
+      yield "#{basename}.dot" if block_given?
+    end
+  end
+end

data/spec/support/hanuman_test_helpers.rb

@@ -0,0 +1,92 @@
+require 'gorillib/utils/capture_output'
+
+shared_context 'hanuman', :helpers => true do
+  let(:test_stage){           Hanuman::Stage.new(:name => :testy) }
+
+  let :example_graph do
+    Hanuman::Graph.new(:name => :scraper) do
+      action(:listener) << product(:scrape_requests) << product(:more_requests)
+      action(:parser).input(:listener)
+      action(:models).input(:parser)
+    end
+  end
+
+end
+
+shared_examples_for 'it can be linked into' do
+  let(:mock_slot){ mock('mock slot') }
+  before do
+    mock_dataflow.stub(:connect).with(mock_slot, :default, subject, :default).and_return([mock_slot, subject])
+    subject.write_attribute(:owner, mock_dataflow)
+  end
+
+  context '#<<' do
+    it 'delegates to from' do
+      subject.should_receive(:from).with(mock_slot)
+      subject << mock_slot
+    end
+    it 'returns the stage itself, for chaining' do
+      (subject << mock_slot).should == subject
+    end
+  end
+
+  context '#from' do
+    it 'asks its owner to register an edge from self into given stage' do
+      mock_dataflow.should_receive(:connect).with(mock_slot, :default, subject, :default)
+      subject.from mock_slot
+    end
+    it 'returns the stage itself, for chaining' do
+      subject.from(mock_slot).should == subject
+    end
+  end
+
+  context 'set_sink' do
+    it 'returns the actual receiving slot' do
+      # subject.set_sink(:default, mock_stage).should equal(subject)
+      subject.set_sink(mock_stage).should equal(subject)
+    end
+    it 'sets the output attribute' do
+      subject.should_receive(:write_attribute).with(:output, mock_stage)
+      # subject.set_sink(:default, mock_stage)
+      subject.set_sink(mock_stage)
+    end
+  end
+end
+
+shared_examples_for 'it can be linked from' do
+  let(:mock_slot){ mock('mock slot') }
+  before do
+    mock_dataflow.stub(:connect).with(subject, :default, mock_slot, :default).and_return([subject, mock_slot])
+    subject.write_attribute(:owner, mock_dataflow)
+  end
+
+  context '#>' do
+    it 'asks its owner to register an edge into self from given stage' do
+      mock_dataflow.should_receive(:connect).with(subject, :default, mock_slot, :default)
+      subject.into mock_slot
+    end
+    it 'returns the output stage' do
+      (subject > mock_slot).should == mock_slot
+    end
+  end
+
+  context '#into' do
+    it 'asks its owner to register an edge into self from given stage' do
+      mock_dataflow.should_receive(:connect).with(subject, :default, mock_slot, :default)
+      subject.into mock_slot
+    end
+    it 'returns the stage itself, for chaining' do
+      subject.into(mock_slot).should == subject
+    end
+  end
+
+  context 'set_input' do
+    it 'returns the actual receiving slot' do
+      subject.set_source(mock_stage).should equal(subject)
+    end
+    it 'sets the input attribute' do
+      subject.should_receive(:write_attribute).with(:input, mock_stage)
+      subject.set_source(mock_stage)
+    end
+  end
+end

data/spec/support/integration_helper.rb

@@ -0,0 +1,38 @@
+module Wukong
+  module Local
+    module IntegrationHelper
+
+      def root
+        @root ||= Pathname.new(File.expand_path('../../..', __FILE__))
+      end
+
+      def lib_dir *args
+        root.join('lib', *args)
+      end
+
+      def bin_dir *args
+        root.join('bin', *args)
+      end
+      
+      def examples_dir *args
+        root.join('examples', *args)
+      end
+
+      def integration_env
+        {
+          "PATH"    => [bin_dir.to_s, ENV["PATH"]].compact.join(':'),
+          "RUBYLIB" => [lib_dir.to_s, ENV["RUBYLIB"]].compact.join(':')
+        }
+      end
+
+      def integration_cwd
+        root.to_s
+      end
+
+      def example_script *args
+        examples_dir(*args)
+      end
+
+    end
+  end
+end

data/spec/support/model_test_helpers.rb

@@ -0,0 +1,115 @@
+require 'gorillib/utils/nuke_constants'
+require 'gorillib/utils/capture_output'
+
+module Gorillib ;               module Test ;       end ; end
+module Meta ; module Gorillib ; module Test ; end ; end ; end
+
+shared_context 'model', :model_spec do
+  include Gorillib::TestHelpers
+
+  after(:each){ Gorillib::Test.nuke_constants ; Meta::Gorillib::Test.nuke_constants }
+
+  let(:mock_val){ double('mock value') }
+
+  let(:smurf_class) do
+    class Gorillib::Test::Smurf
+      include Gorillib::Model
+      field :name,       String
+      field :smurfiness, Integer
+      field :weapon,     Symbol
+    end
+    Gorillib::Test::Smurf
+  end
+  let(:papa_smurf   ){ smurf_class.receive(:name => 'Papa Smurf', :smurfiness => 9,  :weapon => 'staff') }
+  let(:smurfette    ){ smurf_class.receive(:name => 'Smurfette',  :smurfiness => 11, :weapon => 'charm') }
+
+  let(:smurf_collection_class) do
+    smurf_class
+    class Gorillib::Test::SmurfCollection < Gorillib::ModelCollection
+      include Gorillib::Collection::ItemsBelongTo
+      self.item_type        = Gorillib::Test::Smurf
+      self.parentage_method = :village
+    end
+    Gorillib::Test::SmurfCollection
+  end
+
+  let(:smurf_village_class) do
+    smurf_class ; smurf_collection_class
+    module Gorillib::Test
+      class SmurfVillage
+        include Gorillib::Model
+        field      :name,   Symbol
+        collection :smurfs, SmurfCollection, item_type: Smurf, key_method: :name
+      end
+    end
+    Gorillib::Test::SmurfVillage
+  end
+
+  let(:smurfhouse_class) do
+    module Gorillib::Test
+      class Smurfhouse
+        include Gorillib::Model
+        field   :shape, Symbol
+        field   :color, Symbol
+      end
+    end
+    Gorillib::Test::Smurfhouse
+  end
+
+end
+
+shared_context 'builder', :model_spec, :builder_spec do
+  let(:engine_class) do
+    class Gorillib::Test::Engine
+      include Gorillib::Builder
+      magic    :name,         Symbol, :default => ->{ "#{owner? ? owner.name : ''} engine"}
+      magic    :carburetor,   Symbol, :default => :stock
+      magic    :volume,       Integer, :doc => 'displacement volume, in in^3'
+      magic    :cylinders,    Integer
+      member   :owner,        Whatever
+      self
+    end
+    Gorillib::Test::Engine
+  end
+
+  let(:car_class) do
+    engine_class
+    class Gorillib::Test::Car
+      include Gorillib::Builder
+      magic    :name,          Symbol
+      magic    :make_model,    String
+      magic    :year,          Integer
+      magic    :doors,         Integer
+      member   :engine,        Gorillib::Test::Engine
+      self
+    end
+    Gorillib::Test::Car
+  end
+
+  let(:garage_class) do
+    car_class
+    class Gorillib::Test::Garage
+      include Gorillib::Builder
+      collection :cars,       Gorillib::Test::Car, key_method: :name
+      self
+    end
+    Gorillib::Test::Garage
+  end
+
+  let(:wildcat) do
+    car_class.receive( :name => :wildcat,
+      :make_model => 'Buick Wildcat', :year => 1968, :doors => 2,
+      :engine => { :volume => 455, :cylinders => 8 } )
+  end
+  let(:ford_39) do
+    car_class.receive( :name => :ford_39,
+      :make_model => 'Ford Tudor Sedan', :year => 1939, :doors => 2, )
+  end
+  let(:garage) do
+    garage_class.new
+  end
+  let(:example_engine) do
+    engine_class.new( :name => 'Geo Metro 1.0L', :volume => 61, :cylinders => 3 )
+  end
+
+end

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