gorillib 0.1.11 → 0.4.0pre

data/spec/gorillib/utils/capture_output_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'gorillib/utils/capture_output'
+
+describe Gorillib::TestHelpers, :simple_spec => true do
+
+  context '.capture_output' do
+    let(:mock_stdout){ StringIO.new('', 'w') }
+    let(:mock_stderr){ StringIO.new('', 'w') }
+
+    before do
+      mock_stderr ; mock_stdout
+      StringIO.should_receive(:new).and_return(mock_stdout)
+      StringIO.should_receive(:new).and_return(mock_stderr)
+    end
+
+    it 'gives me a new $stdout and $stderr' do
+      Gorillib::TestHelpers.capture_output do
+        $stdout.should equal(mock_stdout)
+        $stderr.should equal(mock_stderr)
+      end
+    end
+
+    it 'yields a wrapped block' do
+      i_wuz_here = nil
+      Gorillib::TestHelpers.capture_output do
+        i_wuz_here = true
+      end
+      i_wuz_here.should == true
+    end
+
+    it 'restores the original values' do
+      old_stdout = $stdout ; old_stderr = $stderr
+      Gorillib::TestHelpers.capture_output do
+        $stdout.should equal(mock_stdout)
+        $stderr.should equal(mock_stderr)
+      end
+      $stdout.should equal(old_stdout)
+      $stderr.should equal(old_stderr)
+    end
+
+    it 'restores the original values even if there is an error' do
+      old_stdout = $stdout ; old_stderr = $stderr
+      Gorillib::TestHelpers.capture_output do
+        raise 'hell'
+      end rescue nil
+      $stdout.should equal(old_stdout)
+      $stderr.should equal(old_stderr)
+    end
+
+    it 'returns the captured streams' do
+      returned_stdout, returned_stderr = Gorillib::TestHelpers.capture_output do
+        $stdout.puts 'I was here'
+        $stderr.puts 'so was I'
+      end
+      returned_stdout.should equal(mock_stdout)
+      returned_stderr.should equal(mock_stderr)
+      mock_stdout.string.should == "I was here\n"
+      mock_stderr.string.should == "so was I\n"
+    end
+
+    it 'raises an error if no block is given' do
+      lambda{ Gorillib::TestHelpers.capture_output }.should raise_error(LocalJumpError, "no block given (yield)")
+    end
+
+  end
+
+  context '.quiet_output' do
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 require 'rubygems' unless defined?(Gem)
-require 'spork'
 require 'rspec'
 
 GORILLIB_ROOT_DIR = File.expand_path(File.join(File.dirname(__FILE__),'..'))
@@ -7,16 +6,14 @@ def GORILLIB_ROOT_DIR *paths
   File.join(::GORILLIB_ROOT_DIR, *paths)
 end
 
-Spork.prefork do # Must restart for changes to config / code from libraries loaded here
-  $LOAD_PATH.unshift(GORILLIB_ROOT_DIR('lib'))
-  $LOAD_PATH.unshift(GORILLIB_ROOT_DIR('spec/support'))
-  Dir[GORILLIB_ROOT_DIR('spec/support/matchers/*.rb')].each {|f| require f}
+ENV['QUIET_RSPEC'] = 'please'
 
-  RSpec.configure do |config|
-  end
-end
+$LOAD_PATH.unshift(GORILLIB_ROOT_DIR('lib'))
+$LOAD_PATH.unshift(GORILLIB_ROOT_DIR('spec/support'))
+require 'gorillib_test_helpers'
+Dir[GORILLIB_ROOT_DIR('spec/support/matchers/*.rb')].each {|f| require f}
+Dir[GORILLIB_ROOT_DIR('spec/support/shared_examples/*.rb')].each {|f| require f}
 
-Spork.each_run do # This code will be run each time you run your specs.
-  RSpec.configure do |config|
-  end
+RSpec.configure do |config|
+  include Gorillib::TestHelpers
 end

data/spec/support/gorillib_test_helpers.rb

@@ -0,0 +1,66 @@
+require 'gorillib/utils/capture_output'
+require 'gorillib/utils/nuke_constants'
+
+shared_examples_for "a model field" do |field_name|
+  it('gives the model a field'){ subject.class.should have_field(field_name) }
+
+  context '#read_attribute' do
+    it "if set, returns the value" do
+      subject.write_attribute(field_name, sample_val)
+      subject.read_attribute(field_name).should == sample_val
+    end
+    it "if unset, calls #read_unset_attribute" do
+      mock_val = mock
+      subject.should_receive(:read_unset_attribute).with(field_name).and_return(mock_val)
+      subject.read_attribute(field_name).should == mock_val
+    end
+    it "raises an error if the field does not exist" do
+      ->{ subject.read_attribute(:fnord) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
+    end
+  end
+
+  context '#write_attribute' do
+    it('sets the value') do
+      subject.write_attribute(field_name, sample_val)
+      subject.read_attribute(field_name).should == sample_val
+    end
+    it('returns the new value') do
+      subject.write_attribute(field_name, sample_val).should == sample_val
+    end
+    it "raises an error if the field does not exist" do
+      ->{ subject.write_attribute(:fnord, 8) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
+    end
+  end
+
+  context '#attribute_set?' do
+    it('is true if the attribute has been set') do
+      subject.write_attribute(field_name, sample_val)
+      subject.attribute_set?(field_name).should be_true
+    end
+    it('is true if the attribute has been set, even to nil or false') do
+      subject.write_attribute(field_name, nil)
+      subject.attribute_set?(field_name).should be_true
+    end
+    it('is false if never written') do
+      subject.attribute_set?(field_name).should be_false
+    end
+    it "raises an error if the field does not exist" do
+      ->{ subject.attribute_set?(:fnord) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
+    end
+  end
+
+  context "#receive_XX" do
+    it('returns the model itself') do
+      subject.send("receive_#{field_name}", raw_val).should == subject
+    end
+    it('type-converts the object') do
+      subject.send("receive_#{field_name}", raw_val)
+      subject.read_attribute(field_name).should     == sample_val
+      subject.read_attribute(field_name).should_not equal(sample_val)
+    end
+    it('uses a compatible object directly') do
+      subject.send("receive_#{field_name}", sample_val)
+      subject.read_attribute(field_name).should equal(sample_val)
+    end
+  end
+end

data/spec/support/hashlike_fuzzing_helper.rb

@@ -3,7 +3,7 @@ require 'stringio'
 ::Enumerator = Enumerable::Enumerator if (RUBY_VERSION < '1.9') && (not defined?(::Enumerator))
 
 module HashlikeFuzzingHelper
-  
+
   #
   # Fuzz testing for hashlike behavior. This throws a whole bunch of
   #
@@ -51,9 +51,9 @@ module HashlikeFuzzingHelper
     ['a', 'b', 'z'], ['a', 'b', 'a', :c, 'a'],
     [[1, 2, [3, 4]]], [[1, [2, 3, [4, 5, 6]]]]
   ]
-  
+
   INPUTS_WHEN_FULLY_HASHLIKE = INPUTS_FOR_ALL_HASHLIKES + INPUTS_WHEN_ARBITRARY_KEYS_ALLOWED + INPUTS_WHEN_INDIFFERENT_ACCESS
-  
+
   #
   # Hacky methods to do comparison
   #
@@ -90,38 +90,36 @@ module HashlikeFuzzingHelper
         input.last.is_a?(Proc) && (input.last.arity == 1))
       return
     end
-    
-    old_stderr = $stderr
-    $stderr = StringIO.new('', 'w')
-    obj_1.should_receive(:warn){|str| stderr_output << str }.at_most(:once)
-    begin
-      expected = send_to(obj_1, method_to_test, input)
-    rescue Exception => e
-      expected = e
-    end
-    expected_stderr = $stderr.string
-
-    $stderr = StringIO.new('', 'w')
-    obj_1.should_receive(:warn){|str| stderr_output << str }.at_most(:once)
-    case expected
-    when Exception
-      lambda{ send_to(obj_2, method_to_test, input) }.should raise_error(expected.class, err_regex(expected))
-    when Enumerator
-      actual = send_to(obj_2, method_to_test, input)
-      actual.should be_a(Enumerator)
-      actual.inspect.gsub(/[\"\:]/, '').gsub(/0x[a-f\d]+/,'').should == expected.inspect.gsub(/[\"\:]/, '').gsub(/0x[a-f\d]+/,'')
-    else # run the method
-      actual = send_to(obj_2, method_to_test, input)
-      if expected.is_a?(Hash) && (RUBY_VERSION < '1.9')
-        actual.should be_hash_eql(expected)
-      elsif expected.is_a?(Array) && (RUBY_VERSION < '1.9')
-        actual.should be_array_eql(expected)
-      else
-        actual.should == expected
+
+    quiet_output do
+      obj_1.should_receive(:warn){|str| stderr_output << str }.at_most(:once)
+      begin
+        expected = send_to(obj_1, method_to_test, input)
+      rescue Exception => e
+        expected = e
+      end
+      expected_stderr = $stderr.string
+
+      obj_1.should_receive(:warn){|str| stderr_output << str }.at_most(:once)
+      case expected
+      when Exception
+        lambda{ send_to(obj_2, method_to_test, input) }.should raise_error(expected.class, err_regex(expected))
+      when Enumerator
+        actual = send_to(obj_2, method_to_test, input)
+        actual.should be_a(Enumerator)
+        actual.inspect.gsub(/[\"\:]/, '').gsub(/0x[a-f\d]+/,'').should == expected.inspect.gsub(/[\"\:]/, '').gsub(/0x[a-f\d]+/,'')
+      else # run the method
+        actual = send_to(obj_2, method_to_test, input)
+        if expected.is_a?(Hash) && (RUBY_VERSION < '1.9')
+          actual.should be_hash_eql(expected)
+        elsif expected.is_a?(Array) && (RUBY_VERSION < '1.9')
+          actual.should be_array_eql(expected)
+        else
+          actual.should == expected
+        end
       end
+      $stderr.string.sub(/.*\.rb:\d+:(?:in `send\w*':)? /, '').should == expected_stderr.sub(/.*\.rb:\d+:(?:in `send\w*':)? /, '')
     end
-    $stderr.string.sub(/.*\.rb:\d+:(?:in `send\w*':)? /, '').should == expected_stderr.sub(/.*\.rb:\d+:(?:in `send\w*':)? /, '')
-    $stderr = old_stderr
   end
 
 end

data/spec/support/hashlike_helper.rb

@@ -55,7 +55,7 @@ module HashlikeHelper
     :nested_under_indifferent_access,
     :stringify_keys, :stringify_keys!, :symbolize_keys, :symbolize_keys!,
     :with_indifferent_access, :yaml_initialize,
-    :extractable_options?, :deep_dup, :reverse_merge, :reverse_merge!, :slice, :slice!, :extract!, :deep_merge, :deep_merge!, :deep_compact!, :compact, :compact!, :compact_blank, :compact_blank!
+    :extractable_options?, :deep_dup, :reverse_merge, :reverse_merge!, :slice, :slice!, :extract!, :except, :except!, :only, :only!, :deep_merge, :deep_merge!, :deep_compact!, :compact, :compact!, :compact_blank, :compact_blank!
   ]
   FANCY_HASHLIKE_METHODS.each{|meth| OMITTED_METHODS_FROM_HASH << meth }
 
@@ -69,8 +69,8 @@ module HashlikeHelper
   #   :cycle, :partition,
   # ]
   #
-  # p Enumerable.public_instance_methods.map(&:to_sym) - ENUMERABLE_METHODS
-  # p ENUMERABLE_METHODS - Enumerable.public_instance_methods.map(&:to_sym)
+  # Enumerable.public_instance_methods.map(&:to_sym) - ENUMERABLE_METHODS
+  # ENUMERABLE_METHODS - Enumerable.public_instance_methods.map(&:to_sym)
   # extra:   [:member?, :enum_slice, :reject, :select, :include?, :enum_cons, :enum_with_index]
   # missing: [:each_entry, :each_with_object, :collect_concat, :flat_map, :chunk, :slice_before]
 end

data/spec/support/model_test_helpers.rb

@@ -0,0 +1,81 @@
+module Gorillib ;               module Test ;       end ; end
+module Meta ; module Gorillib ; module Test ; end ; end ; end
+
+shared_context 'model', :model_spec => true do
+  after(:each){ Gorillib::Test.nuke_constants ; Meta::Gorillib::Test.nuke_constants }
+
+  let(:smurf_klass) do
+    class Gorillib::Test::Smurf
+      include Gorillib::Model
+
+      field :smurfiness, Integer
+      field :weapon,     Symbol
+    end
+    Gorillib::Test::Smurf
+  end
+
+  let(:smurfette_klass) do
+    class Gorillib::Test::Smurfette < smurf_klass
+      field :blondness, Boolean
+    end
+    Gorillib::Test::Smurfette
+  end
+
+  let(:poppa_smurf  ){ smurf_klass.receive(:name => 'Poppa Smurf',   :smurfiness => 9, :weapon => 'staff') }
+  let(:smurfette    ){ smurf_klass.receive(:name => 'Smurfette',     :smurfiness => 11, :weapon => 'charm') }
+  let(:generic_smurf){ smurf_klass.receive(:name => 'Generic Smurf', :smurfiness => 2, :weapon => 'fists') }
+
+  let(:engine_class) do
+    class Gorillib::Test::Engine
+      include Gorillib::Builder
+      field    :name,         Symbol, :default => ->{ "#{owner? ? owner.name : ''} engine"}
+      field    :carburetor,   Symbol, :default => :stock
+      field    :volume,       Integer, :doc => 'displacement volume, in in^3'
+      field    :cylinders,    Integer
+      member   :owner,        Whatever
+      self
+    end
+    Gorillib::Test::Engine
+  end
+
+  let(:car_class) do
+    engine_class
+    class Gorillib::Test::Car
+      include Gorillib::Builder
+      field    :name,          Symbol
+      field    :make_model,    String
+      field    :year,          Integer
+      field    :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
+      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_examples/included_module.rb

@@ -0,0 +1,20 @@
+shared_context 'included_module' do
+  
+  let(:included_module) { described_class }
+  let(:klass_name)      { 'FakeModel'     }
+  
+  def create_fake_model_klass name
+    klass = self.class.const_set(name.to_sym, Class.new)
+    mod   = included_module
+    klass.class_eval{ include(mod) }
+    klass
+  end
+  
+  def remove_fake_model_klass name
+    self.class.send(:remove_const, name.to_sym) if self.class.const_defined? name.to_sym
+  end
+
+  subject      { create_fake_model_klass(klass_name) }
+  after(:each) { remove_fake_model_klass(klass_name) }
+ 
+end