gorillib-model 0.0.1

data/spec/model/type/ip_address_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+require 'gorillib/model/type/extended'
+
+shared_examples_for(:ip_addresslike) do
+
+  its(:dotted){ should == '1.2.3.4' }
+  its(:quads){  should == [1, 2, 3, 4] }
+  its(:packed){ should == packed_1234 }
+
+  context '.from_packed' do
+    subject{ described_class.from_packed(packed_1234) }
+    it{ should be_a(described_class) }
+    its(:dotted){ should == '1.2.3.4' }
+  end
+
+  context '#bitness_min' do
+    it('is unchanged for /32'){ subject.bitness_min(32).should == subject.packed }
+    {  0 => 0,          # '0.0.0.0'
+       6 => 0,          # '0.0.0.0'
+       8 => 0x01000000, # '1.0.0.0',
+      30 => 0x01020304, # '1.2.3.4',
+    }.each do |bitness, result|
+      it("returns #{result} for #{bitness}"){ subject.bitness_min(bitness).should == result }
+    end
+    it 'raises an error if bitness is out of range' do
+      expect{ subject.bitness_min(33)    }.to raise_error(ArgumentError, /only 32 bits.*33/)
+      expect{ subject.bitness_min(-1)    }.to raise_error(ArgumentError, /only 32 bits.*-1/)
+      expect{ subject.bitness_min('bob') }.to raise_error(ArgumentError, /only 32 bits.*bob/)
+    end
+  end
+
+  context '#bitness_max' do
+    it 'returns an integer' do
+      subject.bitness_max(24).should equal(16909311)
+    end
+    it('is unchanged for /32'   ){ subject.bitness_max(32).should == subject.packed }
+    {  0 => 0xFFFFFFFF, # '255.255.255.255'
+       6 => 0x03FFFFFF, # '3.255.255.255'
+       8 => 0x01FFFFFF, # '1.255.255.255'
+      31 => 0x01020305, # '1.2.3.5'
+    }.each do |bitness, result|
+      it("returns #{result} for #{bitness}"){ subject.bitness_max(bitness).should == result }
+    end
+    it 'raises an error if bitness is out of range' do
+      expect{ subject.bitness_max(33)    }.to raise_error(ArgumentError, /only 32 bits.*33/)
+      expect{ subject.bitness_max(-1)    }.to raise_error(ArgumentError, /only 32 bits.*-1/)
+      expect{ subject.bitness_max('bob') }.to raise_error(ArgumentError, /only 32 bits.*bob/)
+    end
+  end
+end
+
+describe ::IpAddress do
+  let(:packed_1234){ 16909060 }
+  let(:dotted_1234){ '1.2.3.4' }
+  subject{ described_class.new('1.2.3.4') }
+
+  it_should_behave_like(:ip_addresslike)
+
+  its(:to_i){ should equal(packed_1234) }
+  it{ expect{ subject.to_int }.to raise_error(NoMethodError, /undefined method.*\`to_int\'/) }
+end
+
+describe ::IpNumeric do
+  let(:packed_1234){ 16909060 }
+  let(:dotted_1234){ '1.2.3.4' }
+  subject{ described_class.new(packed_1234) }
+
+  it_should_behave_like(:ip_addresslike)
+
+  context '.from_dotted' do
+    subject{ described_class.from_dotted(dotted_1234) }
+    it('memoizes #dotted') do
+      val = subject.instance_variable_get('@dotted')
+      val.should == '1.2.3.4'
+      val.should be_frozen
+    end
+    it('memoizes #quads') do
+      val = subject.instance_variable_get('@quads')
+      val.should == [1,2,3,4]
+      val.should be_frozen
+    end
+  end
+
+end
+
+
+describe ::IpRange do
+  let(:beg_1234){ 16909060 }
+  let(:end_1234){ 16909384 }
+  subject{ described_class.new(beg_1234 .. end_1234) }
+
+  its(:min){ should == beg_1234 }
+  its(:max){ should == end_1234 }
+  its(:min){ should be_a(IpNumeric) }
+  its(:max){ should be_a(IpNumeric) }
+
+  context 'bitness_blocks' do
+    it 'emits nothing if empty' do
+      described_class.new(50, 49).bitness_blocks(24).should == []
+    end
+    it 'emits only one block if min and max are in same bitness block' do
+      described_class.new(40, 80).bitness_blocks(24).should == [ [40, 80] ]
+    end
+    it 'emits only one block if min and max are the same' do
+      described_class.new(40, 40).bitness_blocks(24).should == [ [40, 40] ]
+    end
+    it 'emits two short blocks if min and max are in neighboring blocks' do
+      described_class.new(40, 260).bitness_blocks(24).should == [ [40, 255], [256, 260] ]
+    end
+    it 'emits intermediate blocks if min and max are far apart' do
+      described_class.new(40, 520).bitness_blocks(24).should == [ [40, 255], [256, 511], [512, 520] ]
+    end
+
+    {
+      [ '255.255.255.255', '255.255.255.255',  0 ] => [ [0xFFFFFFFF, 0xFFFFFFFF] ],
+      [ '255.255.255.255', '255.255.255.255', 24 ] => [ [0xFFFFFFFF, 0xFFFFFFFF] ],
+      [ '255.255.255.255', '255.255.255.255', 32 ] => [ [0xFFFFFFFF, 0xFFFFFFFF] ],
+      [ '255.255.254.1',   '255.255.255.255',  0 ] => [ [0xFFFFFe01, 0xFFFFFFFF] ],
+      [ '255.255.254.1',   '255.255.255.255', 24 ] => [ [0xFFFFFe01, 0xFFFFFeFF], [0xFFFFFF00, 0xFFFFFFFF] ],
+      [ '255.255.253.1',   '255.255.255.7',   24 ] => [ [0xFFFFFd01, 0xFFFFFdFF], [0xFFFFFe00, 0xFFFFFeFF], [0xFFFFFF00, 0xFFFFFF07] ],
+      [ '0.0.0.0',         '0.0.0.0',         24 ] => [ [0x0,        0x0], ],
+      [ '0.0.0.255',       '0.0.1.0',         24 ] => [ [0xFF, 0xFF], [0x100, 0x100] ],
+      [ '0.0.0.7',         '0.0.0.10',        31 ] => [ [0x7, 0x7], [0x8, 0x9], [0xa, 0xa], ],
+      [ '0.0.0.7',         '0.0.0.11',        31 ] => [ [0x7, 0x7], [0x8, 0x9], [0xa, 0xb], ],
+      [ '0.0.0.0',         '0.0.0.0',         24 ] => [ [0x0,        0x0], ],
+      [ '0.0.1.7',         '0.0.1.255',       24 ] => [ [0x107,      0x1FF], ],
+      [ '0.0.1.7',         '0.0.2.7',         24 ] => [ [0x107,      0x1FF], [0x200, 0x207] ],
+      [ '0.0.1.7',         '0.0.3.7',         24 ] => [ [0x107,      0x1FF], [0x200, 0x2FF], [0x300, 0x307] ],
+    }.each do |(beg_ip, end_ip, bitness), blocks|
+      it "/#{bitness}-bit blocks of #{beg_ip}..#{end_ip} are #{blocks}" do
+        beg_ip = IpNumeric.from_dotted(beg_ip)
+        end_ip = IpNumeric.from_dotted(end_ip)
+        subject = IpRange.new(beg_ip .. end_ip)
+        subject.bitness_blocks(bitness).should == blocks
+      end
+    end
+
+  end
+
+end

data/spec/model_spec.rb

@@ -0,0 +1,261 @@
+require 'spec_helper'
+
+describe Gorillib::Model, :model_spec => true do
+  let(:simple_model) do
+    class Gorillib::Test::SimpleModel
+      include Gorillib::Model
+      field :my_field,  :whatever
+      field :str_field, String
+      field :sym_field, Symbol
+      self
+    end
+  end
+  let(:subclassed_model) do
+    class Gorillib::Test::SubclassedModel < simple_model ; field :zyzzyva, Integer; field :acme, Integer ; end
+    Gorillib::Test::SubclassedModel
+  end
+  let(:nested_model) do
+    smurf_class = self.smurf_class
+    Gorillib::Test::NestedModel = Class.new(simple_model){ field :smurf, smurf_class }
+    Gorillib::Test::NestedModel
+  end
+
+  let(:described_class){ simple_model }
+  let(:example_inst){    described_class.receive(:my_field => 69) }
+
+  #
+  # IT BEHAVES LIKE A MODEL
+  # (maybe you wouldn't notice if it was just one little line)
+  #
+  it_behaves_like 'a model'
+
+  # --------------------------------------------------------------------------
+
+  context 'examples' do
+    it 'type-converts values' do
+      obj = simple_model.receive({
+          :my_field => 'accepted as-is', :str_field => :bob, :sym_field => 'converted_to_sym'
+        })
+      obj.attributes.should == { :my_field => 'accepted as-is', :str_field => 'bob', :sym_field=>:converted_to_sym }
+    end
+    it 'handles nested structures' do
+      deep_obj = nested_model.receive(:str_field => 'deep, man', :smurf => papa_smurf.attributes)
+      deep_obj.attributes.should == { :str_field => 'deep, man', :smurf => papa_smurf, :sym_field=>nil, :my_field => nil, }
+    end
+  end
+
+  context ".field" do
+    it "describes an attribute" do
+      example_inst.compact_attributes.should == { :my_field => 69 }
+      example_inst.write_attribute(:my_field, 3).should == 3
+      example_inst.compact_attributes.should == { :my_field => 3 }
+      example_inst.read_attribute(:my_field).should == 3
+    end
+    it 'inherits fields from its parent class, even if they are added later' do
+      simple_model.field_names.should    == [:my_field, :str_field, :sym_field]
+      subclassed_model.field_names.should  == [:my_field, :str_field, :sym_field, :zyzzyva, :acme]
+      simple_model.field :banksy, String
+      simple_model.field_names.should    == [:my_field, :str_field, :sym_field, :banksy ]
+      subclassed_model.field_names.should  == [:my_field, :str_field, :sym_field, :banksy, :zyzzyva, :acme]
+    end
+
+    it "supplies a reader method #foo to call read_attribute(:foo)" do
+      example_inst.should_receive(:read_attribute).with(:my_field).and_return(mock_val)
+      example_inst.my_field.should == mock_val
+    end
+    it "supplies a writer method #foo= to call write_attribute(:foo)" do
+      example_inst.should_receive(:write_attribute).with(:my_field, mock_val)
+      (example_inst.my_field = mock_val).should == mock_val
+    end
+    it "supplies #receive_foo, which does write_attribute(:foo) and returns the new value " do
+      example_inst.should_receive(:write_attribute).with(:my_field, mock_val).and_return('okey doke!')
+      (example_inst.receive_my_field(mock_val)).should == 'okey doke!'
+    end
+    it "sets visibility of reader with :reader => ()" do
+      described_class.field :test_field, Integer, :reader => :private, :writer => false
+      described_class.public_instance_methods.should_not  include(:test_field)
+      described_class.private_instance_methods.should     include(:test_field)
+      described_class.public_instance_methods.should_not  include(:test_field=)
+      described_class.private_instance_methods.should_not include(:test_field=)
+    end
+  end
+
+  context '.field' do
+    subject{ described_class.new }
+    let(:sample_val){  'bob' }
+    let(:raw_val){     :bob  }
+    it_behaves_like 'a model field', :str_field
+  end
+
+  context '#attributes' do
+    it "maps field names to attribute values" do
+      example_inst = simple_model.receive({:my_field=>7, :str_field=>'yo', :sym_field=>:sup})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>:sup}
+    end
+    it "includes all field names, set and unset" do
+      example_inst.attributes.should == {:my_field=>69, :str_field=>nil, :sym_field=>nil}
+      example_inst.receive!(:my_field=>7, :str_field=>'yo')
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+    end
+    it "goes throught the #read_attribute interface" do
+      example_inst.should_receive(:read_attribute).with(:my_field).and_return('int')
+      example_inst.should_receive(:read_attribute).with(:str_field).and_return('str')
+      example_inst.should_receive(:read_attribute).with(:sym_field).and_return('sym')
+      example_inst.attributes.should == {:my_field=>'int', :str_field=>'str', :sym_field=>'sym'}
+    end
+    it "is an empty hash if there are no fields" do
+      model_with_no_fields = Class.new{ include Gorillib::Model }
+      model_with_no_fields.new.attributes.should == {}
+    end
+  end
+
+  context '#unset_attribute' do
+    it "unsets the attribute" do
+      example_inst.attribute_set?(:my_field).should be_true
+      example_inst.unset_attribute(:my_field)
+      example_inst.attribute_set?(:my_field).should be_false
+    end
+    it "if set, returns the former value" do
+      example_inst.unset_attribute(:my_field ).should == 69
+      example_inst.unset_attribute(:str_field).should == nil
+    end
+  end
+
+  context '#update_attributes' do
+    it "consumes a map from field names to new values" do
+      example_inst.attributes.should == {:my_field=>69, :str_field=>nil, :sym_field=>nil}
+      example_inst.update_attributes({:my_field=>7, :str_field=>'yo'})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+      example_inst.update_attributes({:str_field=>'ok', :sym_field => :bye})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'ok', :sym_field=>:bye}
+    end
+    it "takes string or symbol keys" do
+      example_inst.update_attributes 'my_field'=>7, :str_field=>'yo'
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+    end
+    it "goes throught the #write_attribute interface" do
+      example_inst.should_receive(:write_attribute).with(:my_field,  7)
+      example_inst.should_receive(:write_attribute).with(:str_field, 'yo')
+      example_inst.update_attributes 'my_field'=>7, :str_field=>'yo'
+    end
+  end
+
+  context '#receive!' do
+    it "consumes a map from field names to new values" do
+      example_inst.attributes.should == {:my_field=>69, :str_field=>nil, :sym_field=>nil}
+      example_inst.receive!({:my_field=>7, :str_field=>'yo'})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+      example_inst.receive!({:str_field=>'ok', :sym_field => :bye})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'ok', :sym_field=>:bye}
+    end
+    it "takes string or symbol keys" do
+      example_inst.receive! 'my_field'=>7, :str_field=>'yo'
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+    end
+    it "goes throught the #write_attribute interface" do
+      example_inst.should_receive(:write_attribute).with(:my_field,  7)
+      example_inst.should_receive(:write_attribute).with(:str_field, 'yo')
+      example_inst.receive! 'my_field'=>7, :str_field=>'yo'
+    end
+    it "returns nil with no block given" do
+      example_inst.receive!('my_field'=>7, :str_field=>'yo').should be_nil
+    end
+  end
+
+  context '#== -- two models are equal if' do
+    let(:subklass){ Class.new(described_class) }
+    let(:obj_2){ described_class.receive(:my_field => 69) }
+    let(:obj_3){ subklass.receive(:my_field => 69) }
+
+    it 'they have the same class' do
+      example_inst.attributes.should == obj_2.attributes
+      example_inst.attributes.should == obj_3.attributes
+      example_inst.should     == obj_2
+      example_inst.should_not == obj_3
+    end
+    it 'and the same attributes' do
+      example_inst.attributes.should == obj_2.attributes
+      example_inst.should            == obj_2
+      obj_2.my_field = 100
+      example_inst.should_not == obj_2
+    end
+  end
+
+  context ".fields" do
+    it 'is a hash of Gorillib::Model::Field objects' do
+      described_class.fields.keys.should  == [:my_field, :str_field, :sym_field]
+      described_class.fields.values.each{|f| f.should be_a(Gorillib::Model::Field) }
+      described_class.fields.values.map(&:name).should == [:my_field, :str_field, :sym_field]
+    end
+  end
+
+  context '.has_field?' do
+    it 'is true if the field exists' do
+      simple_model.has_field?(  :my_field).should be_true
+      subclassed_model.has_field?(:my_field).should be_true
+      subclassed_model.has_field?(:zyzzyva ).should be_true
+    end
+    it 'is false if it does not exist' do
+      simple_model.has_field?(  :zyzzyva).should be_false
+      simple_model.has_field?(  :fnord  ).should be_false
+      subclassed_model.has_field?(:fnord  ).should be_false
+    end
+  end
+
+  context '.field_names' do
+    it 'lists fields in order by class, then in order added' do
+      described_class.field_names.should   == [:my_field, :str_field, :sym_field]
+      subclassed_model.field_names.should  == [:my_field, :str_field, :sym_field, :zyzzyva, :acme]
+      described_class.field :banksy, String
+      described_class.field_names.should   == [:my_field, :str_field, :sym_field, :banksy ]
+      subclassed_model.field_names.should  == [:my_field, :str_field, :sym_field, :banksy, :zyzzyva, :acme]
+    end
+  end
+
+  context '.typename' do
+    it 'has a typename that matches its underscored class name' do
+      described_class.typename.should == 'gorillib.test.simple_model'
+    end
+  end
+
+  context '.inspect' do
+    it('is pretty'){ smurf_class.inspect.should == 'Gorillib::Test::Smurf[name,smurfiness,weapon]' }
+    it('is pretty even if class is anonymous'){ Class.new(smurf_class).inspect.should == 'anon[name,smurfiness,weapon]' }
+  end
+  context '.inspect_compact' do
+    it('is just the class name'){ smurf_class.inspect_compact.should == "Gorillib::Test::Smurf" }
+    it('is detailed if class is anonymous'){ Class.new(smurf_class).inspect_compact.should == "anon[name,smurfiness,weapon]" }
+  end
+
+  describe Gorillib::Model::NamedSchema do
+    context ".meta_module" do
+      let(:basic_field_names){ [ :my_field, :my_field=, :receive_my_field, :receive_str_field, :receive_sym_field, :str_field, :str_field=, :sym_field, :sym_field= ]}
+      let(:anon_class){    Class.new{ include Gorillib::Model ; field :my_field, :whatever } }
+
+      it "is named for the class (if the class is named)" do
+        described_class.send(:meta_module).should == Meta::Gorillib::Test::SimpleModelType
+      end
+      it "is anonymous if the class is anonymous" do
+        anon_class.name.should be_nil
+        anon_class.send(:meta_module).should be_a(Module)
+        anon_class.send(:meta_module).name.should be_nil
+      end
+      it "carries the field-specfic accessor and receive methods" do
+        described_class.send(:meta_module).public_instance_methods.sort.should == basic_field_names
+        anon_class.send(:meta_module).public_instance_methods.sort.should      == [:my_field, :my_field=, :receive_my_field]
+      end
+      it "is injected right after the Gorillib::Model module" do
+        described_class.ancestors.first(4).should == [described_class, Meta::Gorillib::Test::SimpleModelType, Gorillib::Model, Object]
+        described_class.should < Meta::Gorillib::Test::SimpleModelType
+      end
+      it "retrieves an existing named module if one exists" do
+        Gorillib::Test.should_not be_const_defined(:TestClass)
+        module Meta::Gorillib::Test::SimpleModelType ; def kilroy_was_here() '23 skidoo' ; end ; end
+        described_class.send(:meta_module).public_instance_methods.sort.should == (basic_field_names + [:kilroy_was_here]).sort
+        Gorillib::Test.should be_const_defined(:SimpleModel)
+        described_class.send(:meta_module).should == Meta::Gorillib::Test::SimpleModelType
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+if ENV['GORILLIB_MODEL_COV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_group 'Specs',   'spec/'
+    add_group 'Library', 'lib/'
+  end
+end
+
+require 'gorillib/model'
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each{ |f| require f}
+
+RSpec.configure do |config|
+  include Gorillib::TestHelpers
+end

data/spec/support/capture_output.rb

@@ -0,0 +1,28 @@
+module Gorillib
+  module TestHelpers
+    module_function
+
+    def dummy_stdio(stdin_text=nil)
+      stdin = stdin_text.nil? ? $stdin : StringIO.new(stdin_text)
+      new_fhs = [stdin,  StringIO.new('', 'w'), StringIO.new('', 'w')]
+      old_fhs = [$stdin, $stdout,               $stderr]
+      begin
+        $stdin, $stdout, $stderr = new_fhs
+        yield
+      ensure
+        $stdin, $stdout, $stderr = old_fhs
+      end
+      new_fhs[1..2]
+    end
+
+    #
+    # Temporarily sets the global variables $stderr and $stdout to a capturable StringIO;
+    # restores them at the end, even if there is an error
+    #
+    def capture_output
+      dummy_stdio{ yield }
+    end
+
+    alias_method :quiet_output, :capture_output
+  end
+end

data/spec/support/nuke_constants.rb

@@ -0,0 +1,9 @@
+class Module
+  #
+  # Removes all constants in the module's namespace -- this is useful when
+  # writing specs for metaprogramming methods
+  #
+  def nuke_constants
+    constants.each{|const| remove_const(const) }
+  end
+end

data/spec/support/shared_context_for_builders.rb

@@ -0,0 +1,59 @@
+shared_context 'builder', :model_spec => true, :builder_spec => true do
+
+  module Gorillib ;               module Test ;       end ; end
+  module Meta ; module Gorillib ; module Test ; end ; end ; end
+
+  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_models.rb

@@ -0,0 +1,55 @@
+shared_context 'model', :model_spec => true do
+
+  module Gorillib ;               module Test ;       end ; end
+  module Meta ; module Gorillib ; module Test ; end ; end ; end
+
+  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

data/spec/support/shared_examples_for_factories.rb

@@ -0,0 +1,71 @@
+shared_examples_for :it_converts do |conversion_mapping|
+  non_native_ok = conversion_mapping.delete(:non_native_ok)
+  conversion_mapping.each do |obj, expected_result|
+    it "#{obj.inspect} to #{expected_result.inspect}" do
+      actual_result = subject.receive(obj)
+      actual_result.should  eql(expected_result)
+      subject.native?(  obj).should be_false
+      subject.blankish?(obj).should be_false
+      unless non_native_ok then subject.native?(actual_result).should be_true  ; end
+    end
+  end
+end
+
+shared_examples_for :it_considers_native do |*native_objs|
+  it native_objs.inspect do
+    native_objs.each do |obj|
+      subject.native?(  obj).should be_true
+      actual_result = subject.receive(obj)
+      actual_result.should equal(obj)
+    end
+  end
+end
+
+shared_examples_for :it_considers_blankish do |*blankish_objs|
+  it blankish_objs.inspect do
+    blankish_objs.each do |obj|
+      subject.blankish?(obj).should be_true
+      subject.receive(obj).should be_nil
+    end
+  end
+end
+
+shared_examples_for :it_is_a_mismatch_for do |*mismatched_objs|
+  it mismatched_objs.inspect do
+    mismatched_objs.each do |obj|
+      ->{ subject.receive(obj) }.should raise_error(Gorillib::Factory::FactoryMismatchError)
+    end
+  end
+end
+
+shared_examples_for :it_is_registered_as do |*keys|
+  it "the factory for #{keys}" do
+    keys.each do |key|
+      Gorillib::Factory(key).should be_a(described_class)
+    end
+    its_factory = Gorillib::Factory(keys.first)
+    Gorillib::Factory.send(:factories).to_hash.select{|key,val| val.equal?(its_factory) }.keys.should == keys
+  end
+end
+
+# hand it a collection with entries 1, 2, 3 please
+shared_examples_for :an_enumerable_factory do
+  it "accepts a factory for its items" do
+    mock_factory = double('factory')
+    mock_factory.should_receive(:receive).with(1)
+    mock_factory.should_receive(:receive).with(2)
+    mock_factory.should_receive(:receive).with(3)
+    factory = described_class.new(:items => mock_factory)
+    factory.receive( collection_123 )
+  end
+  it "can generate an empty collection" do
+    subject.empty_product.should == empty_collection
+  end
+  it "lets you override the empty collection" do
+    ep = double; ep.should_receive(:try_dup).and_return 'hey'
+    subject = described_class.new(:empty_product => ep)
+    subject.empty_product.should == 'hey'
+    subject = described_class.new(:empty_product => ->{ 'yo' })
+    subject.empty_product.should == 'yo'
+  end
+end