wukong 3.0.0.pre2 → 3.0.0.pre3

data/spec/wu/geo/geolocated_spec.rb

@@ -0,0 +1,247 @@
+require          'gorillib/data_munging'
+require          'wu/geo/geolocated'
+
+describe Wukong::Geolocated do
+  let(:aus_lng){   -97.759003 } # Austin, TX -- infochimps HQ
+  let(:aus_lat){    30.273884 }
+  let(:sat_lng){   -98.486123 } # San Antonio, TX
+  let(:sat_lat){    29.42575  }
+  let(:dpi){ 72 }
+  #
+  let(:aus_tile_x_3){  1.82758 } # zoom level 3
+  let(:aus_tile_y_3){  3.29356 }
+  let(:aus_pixel_x_3){ 468     }
+  let(:aus_pixel_y_3){ 843     }
+  #
+  let(:aus_tile_x_8){   58.48248675555555 } # zoom level 8
+  let(:aus_tile_y_8){  105.39405073699557 }
+  let(:aus_tile_x_11){ 467 } # zoom level 11
+  let(:aus_tile_y_11){ 843 }
+  #
+  let(:aus_quadkey  ){ "0231301203311211" }
+  let(:aus_quadkey_3){ "023"             }
+  let(:radius){      1_000_000 } # 1,000 km
+
+  context Wukong::Geolocated::ByCoordinates do
+    let(:point_klass) do
+      module Wukong
+        class TestPoint
+          include Gorillib::Model
+          include Wukong::Geolocated::ByCoordinates
+          field :name,       String, position: 0,   doc: "Name of this location"
+          field :longitude,  Float,  position: 1,   doc: "Longitude (X) of a point, in decimal degrees"
+          field :latitude,   Float,  position: 2,   doc: "Latitude (Y) of a point, in decimal degrees"
+        end
+      end
+      Wukong::TestPoint
+    end
+    subject{ point_klass.new("Infochimps HQ", aus_lng, aus_lat) }
+
+    context '#tile_xf' do
+      it "tile X coordinate, as a float" do
+        subject.tile_xf(3).should  be_within(0.0001).of( 1.82758)
+        subject.tile_xf(8).should  be_within(0.0001).of(58.48248)
+        subject.tile_xf(11).should be_within(0.0001).of(467.8598)
+      end
+    end
+    context '#tile_x' do
+      it "tile X coordinate, as an integer" do
+        subject.tile_x(3).should  ==   1
+        subject.tile_x(8).should  ==  58
+        subject.tile_x(11).should == 467
+      end
+    end
+    context '#tile_yf' do
+      it "tile Y coordinate, as a float" do
+        subject.tile_yf(3).should  be_within(0.0001).of(  3.29356)
+        subject.tile_yf(8).should  be_within(0.0001).of(105.394051)
+        subject.tile_yf(11).should be_within(0.0001).of(843.152406)
+      end
+    end
+    context '#tile_x' do
+      it "tile Y coordinate, as an integer" do
+        subject.tile_y(3).should  ==   3
+        subject.tile_y(8).should  == 105
+        subject.tile_y(11).should == 843
+      end
+    end
+    context '#quadkey' do
+      it "a string of 2-bit tile selectors" do
+        subject.quadkey(3).should  == "023"
+        subject.quadkey(16).should == "0231301203311211"
+      end
+    end
+  end
+
+  context Wukong::Geolocated do
+
+    it "gives private methods on including class as well as the methods on itself" do
+      klass = Class.new{ include Wukong::Geolocated }
+      klass.should be_private_method_defined(:lng_lat_zl_to_tile_xy)
+      klass.should be_private_method_defined(:haversine_distance)
+    end
+
+    #
+    # Tile coordinates
+    #
+
+    it "returns a map tile size given a zoom level" do
+      Wukong::Geolocated.map_tile_size(3).should == 8
+    end
+
+    it "returns a tile_x, tile_y pair given a longitude, latitude and zoom level" do
+      Wukong::Geolocated.lng_lat_zl_to_tile_xy(aus_lng, aus_lat,  8).should == [ 58, 105]
+      Wukong::Geolocated.lng_lat_zl_to_tile_xy(aus_lng, aus_lat, 11).should == [467, 843]
+    end
+
+    it "returns a longitude, latitude pair given tile_x, tile_y and zoom level" do
+      lng, lat = Wukong::Geolocated.tile_xy_zl_to_lng_lat(aus_tile_x_8, aus_tile_y_8, 8)
+      lng.should be_within(0.0001).of(aus_lng)
+      lat.should be_within(0.0001).of(aus_lat)
+    end
+
+    #
+    # Pixel coordinates
+    #
+
+    it "returns a map pizel size given a zoom level" do
+      Wukong::Geolocated.map_pixel_size(3).should == 2048
+    end
+
+    it "returns a pixel_x, pixel_y pair given a longitude, latitude and zoom level" do
+      Wukong::Geolocated.lng_lat_zl_to_pixel_xy(aus_lng, aus_lat, 3).should == [468, 843]
+    end
+
+    it "returns a longitude, latitude pair given pixel_x, pixel_y and zoom level" do
+      lng, lat = Wukong::Geolocated.pixel_xy_zl_to_lng_lat(aus_pixel_x_3, aus_pixel_y_3, 3)
+      lat.round(4).should ==  30.2970
+      lng.round(4).should == -97.7344
+    end
+
+    it "returns a tile x-y pair given a pixel x-y pair" do
+      Wukong::Geolocated.pixel_xy_to_tile_xy(aus_pixel_x_3, aus_pixel_y_3).should == [1,3]
+    end
+
+    it "returns a pixel x-y pair given a float tile x-y pair" do
+      Wukong::Geolocated.tile_xy_to_pixel_xy(aus_tile_x_3,      aus_tile_y_3     ).should == [467.86048, 843.15136]
+    end
+
+    it "returns a pixel x-y pair given an integer tile x-y pair" do
+      Wukong::Geolocated.tile_xy_to_pixel_xy(aus_tile_x_3.to_i, aus_tile_y_3.to_i).should == [256, 768]
+    end
+
+    #
+    # Quadkey coordinates
+    #
+
+    it "returns a quadkey given a tile x-y pair and a zoom level" do
+      Wukong::Geolocated.tile_xy_zl_to_quadkey(aus_tile_x_3,  aus_tile_y_3,  3).should == "023"
+      Wukong::Geolocated.tile_xy_zl_to_quadkey(aus_tile_x_8,  aus_tile_y_8,  8).should == "02313012"
+      Wukong::Geolocated.tile_xy_zl_to_quadkey(aus_tile_x_11, aus_tile_y_11,11).should == "02313012033"
+    end
+
+    it "returns a quadkey given a longitude, latitude and a zoom level" do
+      Wukong::Geolocated.lng_lat_zl_to_quadkey(aus_lng, aus_lat,  3).should == "023"
+      Wukong::Geolocated.lng_lat_zl_to_quadkey(aus_lng, aus_lat,  8).should == "02313012"
+      Wukong::Geolocated.lng_lat_zl_to_quadkey(aus_lng, aus_lat, 11).should == "02313012033"
+      Wukong::Geolocated.lng_lat_zl_to_quadkey(aus_lng, aus_lat, 16).should == "0231301203311211"
+    end
+
+    it "returns a packed quadkey (an integer) given a tile xy and zoom level" do
+      Wukong::Geolocated.tile_xy_zl_to_packed_qk(aus_tile_x_3.floor,  aus_tile_y_3.floor,  3).should == "023".to_i(4)
+      Wukong::Geolocated.tile_xy_zl_to_packed_qk(aus_tile_x_8.floor,  aus_tile_y_8.floor,  8).should == "02313012".to_i(4)
+      Wukong::Geolocated.tile_xy_zl_to_packed_qk(aus_tile_x_11.floor, aus_tile_y_11.floor,11).should == "02313012033".to_i(4)
+    end
+
+    context '.packed_qk_zl_to_tile_xy' do
+      let(:packed_qk){ "0231301203311211".to_i(4) }
+      it "returns a tile xy given a packed quadkey (integer)" do
+        Wukong::Geolocated.packed_qk_zl_to_tile_xy(packed_qk >> 26,  3).should == [  1,   3,  3]
+        Wukong::Geolocated.packed_qk_zl_to_tile_xy(packed_qk >> 16,  8).should == [ 58, 105,  8]
+        Wukong::Geolocated.packed_qk_zl_to_tile_xy(packed_qk >> 10, 11).should == [467, 843, 11]
+      end
+
+      it "defaults to zl=16 for packed quadkeys" do
+        Wukong::Geolocated.packed_qk_zl_to_tile_xy(packed_qk    ).should == [14971, 26980, 16]
+        Wukong::Geolocated.packed_qk_zl_to_tile_xy(packed_qk, 16).should == [14971, 26980, 16]
+      end
+    end
+
+    it "returns tile x-y pair and a zoom level given a quadkey" do
+      Wukong::Geolocated.quadkey_to_tile_xy_zl(aus_quadkey[0..2] ).should == [1, 3, 3]
+      Wukong::Geolocated.quadkey_to_tile_xy_zl(aus_quadkey[0..7] ).should == [aus_tile_x_8.floor,  aus_tile_y_8.floor,  8]
+      Wukong::Geolocated.quadkey_to_tile_xy_zl(aus_quadkey[0..10]).should == [aus_tile_x_11.floor, aus_tile_y_11.floor, 11]
+    end
+
+    it "allows '' to be a quadkey (whole map)" do
+      Wukong::Geolocated.quadkey_to_tile_xy_zl("").should == [0, 0, 0]
+    end
+
+    it "maps tile xyz [0,0,0] to quadkey ''" do
+      Wukong::Geolocated.tile_xy_zl_to_quadkey(0,0,0).should == ""
+    end
+
+    it "throws an error if a bad quadkey is given" do
+      expect{ Wukong::Geolocated.quadkey_to_tile_xy_zl("bad_key") }.to raise_error(ArgumentError, /Quadkey.*characters/)
+    end
+
+    it "returns a bounding box given a quadkey" do
+      left, btm, right, top = Wukong::Geolocated.quadkey_to_bbox(aus_quadkey_3)
+      left.should  be_within(0.0001).of(-135.0)
+      right.should be_within(0.0001).of(- 90.0)
+      btm.should   be_within(0.0001).of(   0.0)
+      top.should   be_within(0.0001).of(  40.9799)
+    end
+
+    it "returns the smallest quadkey containing two points" do
+      Wukong::Geolocated.quadkey_containing_bbox(aus_lng, aus_lat, sat_lng, sat_lat).should == "023130"
+    end
+
+    it "returns a bounding box given a point and radius" do
+      left, btm, right, top = Wukong::Geolocated.lng_lat_rad_to_bbox(aus_lng, aus_lat, radius)
+
+      left.should  be_within(0.0001).of(-108.1723)
+      right.should be_within(0.0001).of(- 87.3457)
+      btm.should   be_within(0.0001).of(  21.2807)
+      top.should   be_within(0.0001).of(  39.2671)
+    end
+
+    it "returns a centroid given a bounding box" do
+      mid_lng, mid_lat = Wukong::Geolocated.bbox_centroid([aus_lng, sat_lat], [sat_lng, aus_lat])
+      mid_lng.should be_within(0.0001).of(-98.1241)
+      mid_lat.should be_within(0.0001).of( 29.8503)
+    end
+
+    it "returns a pixel resolution given a latitude and zoom level" do
+      Wukong::Geolocated.pixel_resolution(aus_lat, 3).should be_within(0.0001).of(16880.4081)
+    end
+
+    it "returns a map scale given a latitude, zoom level and dpi" do
+      Wukong::Geolocated.map_scale_for_dpi(aus_lat, 3, dpi).should be_within(0.0001).of(47849975.8302)
+    end
+
+    it "calculates the haversine distance between two points" do
+      Wukong::Geolocated.haversine_distance(aus_lng, aus_lat, sat_lng, sat_lat).should be_within(0.0001).of(117522.1219)
+    end
+
+    it "calculates the haversine midpoint between two points" do
+      lng, lat = Wukong::Geolocated.haversine_midpoint(aus_lng, sat_lat, sat_lng, aus_lat)
+      lng.should be_within(0.0001).of(-98.1241)
+      lat.should be_within(0.0001).of( 29.8503)
+    end
+
+    it "calculates the point a given distance directly north from a lat/lng" do
+      lng, lat = Wukong::Geolocated.point_north(aus_lng, aus_lat, 1000000)
+      lng.should be_within(0.0001).of(-97.7590)
+      lat.should be_within(0.0001).of( 39.2671)
+    end
+
+    it "calculates the point a given distance directly east from a lat/lng" do
+      lng, lat = Wukong::Geolocated.point_east(aus_lng, aus_lat, 1000000)
+      lng.should be_within(0.0001).of(-87.3457)
+      lat.should be_within(0.0001).of( 30.2739)
+    end
+
+
+  end # module methods
+end

data/spec/wu/model/reconcilable_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require 'gorillib/model'
+require 'wu/model/reconcilable'
+require 'support/model_test_helpers'
+
+describe Gorillib::Model::Reconcilable, :model_spec do
+
+  before do
+    smurfhouse_class.class_eval do
+      include Gorillib::Model::Reconcilable
+    end
+    smurf_class.class_eval do
+      include Gorillib::Model::Reconcilable
+      field :cromulence, Integer
+      field :smurfhouse, Gorillib::Test::Smurfhouse
+    end
+  end
+  let(:empty_smurf){ smurf_class.new(name: nil) }
+  let(:angry_smurf){ smurf_class.new(name: 'Angry Smurf', smurfiness: 20, weapon: :smurfchucks) }
+  let(:handy_smurf){ smurf_class.new(name: 'Handy Smurf', smurfiness: 20, weapon: :monkeysmurf) }
+  subject{           smurf_class.new(name: 'Handy Smurf', smurfiness: 20, weapon: :monkeysmurf) }
+
+  context '#reconcilable_attributes' do
+    it 'returns only unset, non-nil values' do
+      subject.weapon = nil
+      subject.reconcilable_attributes.should == { name: 'Handy Smurf', smurfiness: 20 }
+      subject.compact_attributes.should      == { name: 'Handy Smurf', smurfiness: 20, weapon: nil }
+      empty_smurf.reconcilable_attributes.should == {}
+    end
+  end
+
+  context '#conflicting_attribute!' do
+    it 'warns by default' do
+      stdout, stderr = capture_output{ subject.conflicting_attribute!(:weapon, :monkeysmurf, :smurfwrench) }
+      stderr.string.should =~ /conflicting.* weapon: had :monkeysmurf got :smurfwrench\b/
+    end
+    it 'returns false always by default' do
+      subject.stub(:warn)
+      subject.conflicting_attribute!(:weapon, :monkeysmurf, :smurfwrench).should == false
+    end
+  end
+
+  context '#adopt' do
+    it 'returns true on compatible, false on incompatible' do
+      subject.stub(:warn)
+      subject.adopt(empty_smurf).should be_true
+      subject.adopt(angry_smurf).should be_false
+    end
+
+    it 'calls adopt_foo instead of adopt_attribute(:foo, ...) if present' do
+      subject.should_receive(:adopt_weapon).with(:smurfchucks,  angry_smurf).and_return true
+      subject.should_receive(:adopt_name  ).with('Angry Smurf', angry_smurf).and_return true
+      subject.adopt(angry_smurf).should be_true
+    end
+
+    context 'on compatible objects' do
+      before{ subject.should_not_receive(:conflicting_attribute!) }
+      it 'makes no changes from unset or nil values' do
+        subject.adopt(empty_smurf).should be_true
+        subject.should == handy_smurf
+      end
+      it 'makes no changes from equal values' do
+        subject.adopt(handy_smurf).should be_true
+        subject.should == handy_smurf
+      end
+      it 'sets unset attributes to the other value' do
+        handy_smurf.cromulence = 99
+        subject.attribute_set?(:cromulence).should be_false
+        subject.adopt(handy_smurf).should be_true
+        subject.should == handy_smurf
+        subject.cromulence.should == 99
+      end
+      it 'sets nil attributes to the other value' do
+        handy_smurf.cromulence = 99
+        subject.cromulence = nil
+        subject.attribute_set?(:cromulence).should be_true
+        subject.adopt(handy_smurf).should be_true
+        subject.should == handy_smurf
+        subject.cromulence.should == 99
+      end
+      it 'asks adoptable attribute to adopt other value' do
+        handy_smurf.smurfhouse  = smurfhouse_class.new(color: :brown)
+        sh = subject.smurfhouse = smurfhouse_class.new(shape: :mushroom)
+        subject.adopt(handy_smurf).should be_true
+        subject.smurfhouse.attributes.should == { shape: :mushroom, color: :brown }
+        subject.smurfhouse.should equal(sh)
+      end
+      it 'does not call block' do
+        subject.adopt(empty_smurf){ raise 'should not call block' }
+      end
+    end
+
+    context 'on incompatible objects' do
+      it 'returns the value of conflicting_attribute!' do
+        subject.weapon = :smurfwrench
+        subject.should_receive(:conflicting_attribute!).with(:weapon, :smurfwrench, :monkeysmurf).and_return(false)
+        subject.adopt(handy_smurf).should be_false
+      end
+      it 'returns the value of conflicting_attribute!' do
+        subject.weapon = :smurfwrench
+        subject.should_receive(:conflicting_attribute!).with(:weapon, :smurfwrench, :monkeysmurf).and_return(true)
+        subject.adopt(handy_smurf).should be_true
+      end
+      it 'keeps its own value' do
+        subject.stub(:conflicting_attribute!)
+        subject.weapon = :smurfwrench
+        subject.adopt(handy_smurf)
+        subject.weapon.should == :smurfwrench
+      end
+      it 'adoptible attributes reconcile' do
+        handy_smurf.smurfhouse  = smurfhouse_class.new(color: :brown)
+        sh = subject.smurfhouse = smurfhouse_class.new(shape: :mushroom, color: :red)
+        sh.should_receive(:conflicting_attribute!).with(:color, :red, :brown)
+        #
+        subject.adopt(handy_smurf).should be_false
+        subject.smurfhouse.attributes.should == { shape: :mushroom, color: :red }
+        subject.smurfhouse.should equal(sh)
+      end
+      it 'adoptible attributes reconcile and warn' do
+        subject.should_not_receive(:conflicting_attribute!)
+        handy_smurf.smurfhouse  = smurfhouse_class.new(color: :brown)
+        sh = subject.smurfhouse = smurfhouse_class.new(shape: :mushroom, color: :red)
+        sh.should_receive(:conflicting_attribute!).with(:color, :red, :brown)
+        #
+        subject.adopt(handy_smurf)
+      end
+      it 'does not take a block' do
+        subject.stub(:warn)
+        subject.adopt(angry_smurf){ raise 'should not call block' }
+      end
+    end
+  end
+
+  context '#adopt_attribute' do
+    context 'takse a block (useful in overrides):' do
+      it 'on compatible values, block is not called' do
+        subject.should_not_receive(:conflicting_attribute!)
+        subject.send(:adopt_attribute, :weapon, :monkeysmurf) do
+          raise 'should not call block'
+        end
+      end
+      it 'on incompatible values, block is called instead of conflicting_attribute!' do
+        subject.should_not_receive(:conflicting_attribute!)
+        subject.send(:adopt_attribute, :weapon, :smurfwrench) do
+          mock_val
+        end.should == mock_val
+      end
+    end
+  end
+
+
+end

data/spec/wukong/widget/processors_spec.rb

@@ -27,7 +27,6 @@ describe Wukong::Processor do
     end
   end
   
-  
   context :extract do
     subject { processor(:extract) }
     

data/spec/wukong/widget/serializers_spec.rb

@@ -1,92 +1,118 @@
 require 'spec_helper'
 
-describe "Serializing" do
-
-  context :to_json do
-    
-    let(:emittable)     { {"hi" => "there"} }
-    let(:not_emittable) { {"n" => Float::INFINITY} }
+shared_context 'serializers', serializer: true do
+  let(:bad_record){ nil }
+  let(:serializer){ create_processor(self.class.top_level_description, on_error: :skip) }
+end
 
-    it_behaves_like 'a processor', :named => :to_json
-    
-    it "should handle valid records" do
-      processor.given(emittable).should emit_json(emittable)
-    end
+shared_examples_for 'a serializer' do
+  it_behaves_like 'a processor'
+end
 
-    it "should skip bad records" do
-      processor.given(not_emittable).should emit(0).records
-    end
-    
+shared_examples_for 'a serializer that complains on bad recors', :handles_errors => true do
+  it 'handles errors on bad records' do
+    serializer.should_receive(:handle_error).with(bad_record, a_kind_of(Exception)).and_return(nil)
+    serializer.given(bad_record).should emit(0).records
   end
+end
 
-  context :to_tsv do
-    let(:emittable)     { ["foo", 2, :a] }
-    let(:not_emittable) { nil            }
+describe :to_json, serializer: true do
+  let(:valid_record) { { hi: 'there' }        }
+  it 'serializes valid records' do
+    serializer.given(valid_record).should emit('{"hi":"there"}')
+  end
 
-    it_behaves_like 'a processor', :named => :to_tsv
+  it 'handles errors on bad records' do
+    MultiJson.should_receive(:dump).with(:unserializable_record, kind_of(Hash)).and_raise(StandardError)
+    serializer.should_receive(:handle_error).with(:unserializable_record, a_kind_of(Exception)).and_return(nil)
+    serializer.given(:unserializable_record).should emit(0).records
+  end
+  
+  context 'pretty' do
+    let(:serializer){ create_processor(:to_json, pretty: true) }
     
-    it "should handle valid records" do
-      processor.given(emittable).should emit_tsv(emittable.map(&:to_s))
-    end
+    it 'prettifies valid records' do
+      serializer.given(valid_record).output.first.should include("\n")
+    end  
+  end
+
+  context 'given a model' do
+    let(:json_record) {  '{"foo":"bar"}'                      }
+    let(:valid_model) { double('model', to_json: json_record) }
     
-    it "should skip bad records" do
-      processor.given(not_emittable).should emit(0).records
+    it 'defers to the model to serialize' do
+      valid_model.should_receive(:to_json).and_return(json_record)
+      serializer.given(valid_model).should emit(json_record)
     end
   end
 end
 
-describe "Deserializing" do
-
-  context :from_json do
-    let(:parseable)     { '{"hi": "there"}' }
-    let(:not_parseable) { '{"832323:'       }
-
-    it_behaves_like 'a processor', :named => :from_json
+describe :to_tsv, serializer: true, handles_errors: true do
+  let(:valid_record) { ["foo", 2, :a] }
+  
+  it 'serializes valid records' do
+    serializer.given(valid_record).should emit("foo\t2\ta")
+  end
 
-    it "should handle valid records" do
-      processor.given(parseable).should emit({'hi' => 'there'})
-    end
+  context 'given a model' do
+    let(:tsv_record)  { "foo\tbar\tbaz"                     }
+    let(:valid_model) { double('model', to_tsv: tsv_record) }
     
-    it "should skip bad records" do
-      processor.given(not_parseable).should emit(0).records
+    it 'defers to the model to serialize' do
+      valid_model.should_receive(:to_tsv).and_return(tsv_record)
+      serializer.given(valid_model).should emit(tsv_record)
     end
   end
-  
-  context :from_tsv do
+end
 
-    let(:parseable)     { "foo\t2\ta"    }
-    let(:not_parseable) { nil            }
+describe :from_json, serializer: true, handles_errors: true do
+  let(:valid_record) { '{"hi": "there"}' }
+  let(:bad_record)   { '{"832323:'       }
+  
+  it 'deserializes valid records' do
+    serializer.given(valid_record).should emit({'hi' => 'there'})
+  end  
 
-    it_behaves_like 'a processor', :named => :from_tsv
+  context 'given a model' do
+    let(:wire_format) { { foo: 'bar' }                          }
+    let(:valid_model) { double('model', from_json: wire_format) }
     
-    it "should handle valid records" do
-      processor.given(parseable).should emit(parseable.split("\t"))
-    end
-    
-    it "should skip bad records" do
-      processor.given(not_parseable).should emit(0).records
+    it 'defers to the model to serialize' do
+      valid_model.should_receive(:from_json).and_return(wire_format)
+      serializer.given(valid_model).should emit(wire_format)
     end
   end
 end
 
-describe "Pretty printing" do
-
-  context "JSON" do
-    let(:parseable)     { '{"hi": "there"}' }
-    let(:not_parseable) { '{"832323:'       }
-
-    it_behaves_like 'a processor', :named => :pretty
-
-    it "should prettify parseable records" do
-      processor(:pretty).given(parseable).should emit_json({'hi' => 'there'})
-    end
+describe :from_tsv, serializer: true, handles_errors: true do
+  let(:valid_record) { "foo\t2\ta" }
+  
+  it 'deserializes valid records' do
+    serializer.given(valid_record).should emit(['foo', '2', 'a' ])
+  end
 
-    it "should pass on non parseable records" do
-      processor(:pretty).given(not_parseable).should emit(not_parseable)
+  context 'given a model' do
+    let(:wire_format) { { foo: 'bar' }                         }
+    let(:valid_model) { double('model', from_tsv: wire_format) }
+    
+    it 'defers to the model to serialize' do
+      valid_model.should_receive(:from_tsv).and_return(wire_format)
+      serializer.given(valid_model).should emit(wire_format)
     end
   end
+end
+
+describe :to_inspect do
+  it_behaves_like 'a processor'
+end
+
+describe :recordize, serializer: true, handles_errors: true do
+  let(:model_instance) { double('model')                                                   }
+  let(:model_klass)    { double('model_def', receive: model_instance)                      }
+  let(:serializer)     { create_processor(:recordize, model: model_klass, on_error: :skip) }
+  let(:valid_record)   { { foo: 'bar' }                                                    }
 
-  it "should pass on everything else" do
-    processor(:pretty).given('foobar').should emit('foobar')
+  it 'recordizes valid records' do
+    serializer.given(valid_record).should emit(model_instance)
   end
 end