praxis-mapper 3.1.1

data/spec/praxis-mapper/identity_map_spec.rb

@@ -0,0 +1,905 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Praxis::Mapper::IdentityMap do
+  let(:scope) { {} }
+  let(:model) { SimpleModel }
+
+  subject(:identity_map) { Praxis::Mapper::IdentityMap.new(scope) }
+
+  let(:repository) { subject.connection(:default) }
+
+  let(:rows) {[
+                {:id => 1, :name => "george jr", :parent_id => 1, :description => "one"},
+                {:id => 2, :name => "george iii", :parent_id => 2, :description => "two"},
+                {:id => 3, :name => "george xvi", :parent_id => 2, :description => "three"}
+
+  ]}
+
+  let(:person_rows) {[
+                       {id: 1, email: "one@example.com", address_id: 1, prior_address_ids:JSON.dump([2,3])},
+                       {id: 2, email: "two@example.com", address_id: 2, prior_address_ids:JSON.dump([2,3])},
+                       {id: 3, email: "three@example.com", address_id: 2, prior_address_ids: nil},
+                       {id: 4, email: "four@example.com", address_id: 3, prior_address_ids: nil},
+                       {id: 5, email: "five@example.com", address_id: 3, prior_address_ids: nil}
+
+  ]}
+
+  let(:address_rows) {[
+                        {id: 1, owner_id: 1, state: 'OR'},
+                        {id: 2, owner_id: 3, state: 'CA'},
+                        {id: 3, owner_id: 1, state: 'OR'}
+  ]}
+
+  before do
+    repository.clear!
+    repository.insert(SimpleModel, rows)
+    repository.insert(PersonModel, person_rows)
+    repository.insert(AddressModel, address_rows)
+  end
+
+
+  context ".setup!" do
+
+    context "with an identity map" do
+      before do
+        Praxis::Mapper::IdentityMap.current = Praxis::Mapper::IdentityMap.new(scope)
+      end
+
+      context 'that has been cleared' do
+        before do
+          Praxis::Mapper::IdentityMap.current.clear!
+        end
+
+        it 'returns the identity_map' do
+          Praxis::Mapper::IdentityMap.setup!(scope).should be_kind_of(Praxis::Mapper::IdentityMap)
+        end
+
+        it 'sets new scopes correctly' do
+          Praxis::Mapper::IdentityMap.setup!({:foo => :bar}).scope.should_not be scope
+        end
+      end
+
+    end
+
+  end
+
+
+  context ".current" do
+    it 'setting' do
+      Praxis::Mapper::IdentityMap.current = subject
+      Thread.current[:_praxis_mapper_identity_map].should be(subject)
+    end
+
+    it 'getting' do
+      Thread.current[:_praxis_mapper_identity_map] = subject
+      Praxis::Mapper::IdentityMap.current.should be(subject)
+    end
+  end
+
+
+  context "#connection" do
+    let(:connection) { double("connection") }
+    it 'proxies through to the ConnectionManager' do
+      Praxis::Mapper::ConnectionManager.any_instance.should_receive(:checkout).with(:default).and_return(connection)
+
+      subject.connection(:default).should == connection
+    end
+  end
+
+
+  context "#load" do
+    let(:query_proc) { Proc.new { } }
+    let(:query_mock) { double("query mock", track: Set.new, where: nil, load: Set.new) }
+
+
+    context 'with normal queries' do
+      let(:record_query) do
+        Praxis::Mapper::Support::MemoryQuery.new(identity_map, model) do
+        end
+      end
+
+      let(:records) { rows.collect { |row| m = model.new(row); m._query = record_query; m } }
+
+      it 'builds a query, executes, freezes it, and returns the query results' do
+        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:execute).and_return(records)
+        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:freeze)
+        identity_map.load(model, &query_proc).should === records
+      end
+
+    end
+
+    context 'with a query with a subload' do
+      context 'for a many_to_one association' do
+        before do
+          identity_map.load PersonModel do
+            load :address
+          end
+        end
+        it 'loads the association records' do
+          identity_map.all(PersonModel).should have(5).items
+          identity_map.all(AddressModel).should have(3).items
+        end
+      end
+    end
+
+    context 'for a one_to_many association' do
+      before do
+        identity_map.load AddressModel do
+          load :residents
+        end
+      end
+      it 'loads the association records' do
+        identity_map.all(PersonModel).should have(5).items
+        identity_map.all(AddressModel).should have(3).items
+      end
+    end
+
+    context 'with nested loads and preexisting records loaded' do
+      before do
+        identity_map.load AddressModel do
+          where id: 2
+        end
+
+        identity_map.load PersonModel do
+          where id: 1
+          load :prior_addresses do
+            load :owner
+          end
+        end
+      end
+
+      it 'works' do
+        expect { identity_map.get(PersonModel, id: 3) }.to_not raise_error
+      end
+    end
+
+
+    context 'with nested loads with a where clause' do
+      before do
+        identity_map.load PersonModel do
+          where id: 2
+          load :prior_addresses do
+            where state: 'CA'
+            load :owner
+          end
+        end
+      end
+
+      it 'applies the where clause to the nested load' do
+        expect { identity_map.get(AddressModel, id: 3) }.to raise_error
+      end
+
+      it 'passes the resulting records a subsequent load' do
+        expect { identity_map.get(PersonModel, id: 3) }.to_not raise_error
+        expect { identity_map.get(PersonModel, id: 1) }.to raise_error
+      end
+    end
+
+
+  end
+
+
+
+  context "#get_staged" do
+    let(:stage) { {:id => [1,2], :names => ["george jr", "george XVI"]} }
+    before do
+      identity_map.get_staged(model,:id).should == Set.new
+      identity_map.stage(model, stage)
+    end
+
+    it 'supports getting ids for a single identity' do
+      identity_map.get_staged(model, :id).should == Set.new(stage[:id])
+    end
+
+  end
+
+
+  context "#stage" do
+
+    before do
+      identity_map.stage(model, stage)
+    end
+
+
+    context "with one item for one identity" do
+      let(:stage) { {:id => 1} }
+
+      it 'stages the key' do
+        identity_map.get_staged(model,:id).should == Set.new([1])
+      end
+    end
+
+    context "with multiple items for one identity" do
+      let(:stage) { {:id => [1,2]} }
+
+      it 'stages the keys' do
+        identity_map.get_staged(model,:id).should == Set.new(stage[:id])
+      end
+    end
+
+    context 'with multiple items for multiple identities' do
+      let(:stage) { {:id => [1,2], :names => ["george jr", "george XVI"]} }
+
+
+      it 'stages the keys' do
+        stage.each do |identity,values|
+          identity_map.get_staged(model,identity).should == Set.new(values)
+        end
+      end
+
+    end
+
+  end
+
+
+  context '#stage when staging something we already have loaded' do
+
+    before do
+      identity_map.load(model)
+      identity_map.get_staged(model,:id).should == Set.new
+    end
+
+    it 'is ignored' do
+      identity_map.stage(model, :id => [1] )
+      identity_map.get_staged(model,:id).should == Set.new
+    end
+  end
+
+
+
+  context "#finalize_model!" do
+
+    context 'with values staged for a single identity' do
+      let(:stage) { {:id => [1,2] } }
+
+      before do
+        identity_map.stage(model, stage)
+      end
+
+      it "does a multi-get for the unloaded ids and returns the query results" do
+        Praxis::Mapper::Support::MemoryQuery.any_instance.
+          should_receive(:multi_get).
+          with(:id, Set.new(stage[:id])).
+          and_return(rows[0..1])
+        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:freeze)
+
+        identity_map.finalize_model!(model).collect(&:id).should =~ rows[0..1].collect { |r| r[:id] }
+      end
+
+      context 'tracking associations' do
+        let(:track) { :parent }
+
+        it 'sets the track attribute on the generated query' do
+          Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(rows[0..1])
+          Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:track).with(track).at_least(:once).and_call_original
+          Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:track).at_least(:once).and_call_original
+          Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:freeze)
+
+          track_field = track
+          query = Praxis::Mapper::Support::MemoryQuery.new(identity_map,model) do
+            track track_field
+          end
+
+          identity_map.finalize_model!(model, query)
+        end
+      end
+
+    end
+
+
+    context 'with values staged for multiple identities' do
+      let(:stage) { {:id => [1,2], :name => ["george jr", "george xvi"]} }
+
+      before do
+        identity_map.stage(model, stage)
+      end
+
+      it 'does a multi_get for ids, then one for remaining names, freezes the query, and consolidated query reults' do
+        query = Praxis::Mapper::Support::MemoryQuery.new(identity_map, model)
+        Praxis::Mapper::Support::MemoryQuery.stub(:new).and_return(query)
+
+        query.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(rows[0..1])
+        query.should_receive(:multi_get).with(:name, Set.new(['george xvi'])).and_return([rows[2]])
+        query.should_receive(:freeze).once
+
+        expected = rows.collect { |r| r[:id] }
+        result = identity_map.finalize_model!(model)
+
+        result.collect(&:id).should =~ expected
+      end
+
+    end
+
+    context 'with unfound values remaining at the end of finalizing' do
+      let(:stage) { {:id => [1,2,4] } }
+
+      before do
+        identity_map.stage(model, stage)
+
+        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(rows[0..1])
+        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:freeze)
+      end
+
+      it 'adds the missing keys to the identity map with nil values' do
+        identity_map.finalize_model!(model)
+        identity_map.get(model,:id => 4).should be_nil
+      end
+
+
+    end
+
+    context 'with values staged for a non-identity key' do
+      let(:model) { AddressModel }
+      let(:stage) {{
+                     id: Set.new([1,2]),
+                     owner_id: Set.new([1,2,3])
+      }}
+
+      before do
+        identity_map.stage(model, stage)
+        owner_id_response = [{id:1}, {id:2}]
+
+        query = Praxis::Mapper::Support::MemoryQuery.new(identity_map, model)
+        Praxis::Mapper::Support::MemoryQuery.stub(:new).and_return(query)
+
+        query.should_receive(:multi_get).
+          with(:owner_id, Set.new(stage[:owner_id]), select: [:id]).ordered.and_return(owner_id_response)
+        query.should_receive(:multi_get).
+          with(:id, Set.new(stage[:id])).ordered.and_return(person_rows)
+
+        query.should_receive(:freeze)
+      end
+
+      it 'first resolves staged non-identity keys to identities' do
+        identity_map.finalize_model!(model)
+      end
+
+    end
+
+
+    context 'for a model with _queries staged for it too....' do
+
+      before do
+        identity_map.clear!
+        identity_map.load(PersonModel) do
+          where id: 2
+          track :address do
+            context :default
+          end
+        end
+      end
+
+
+      it 'finalize_model!' do
+        identity_map.finalize_model!(AddressModel)
+        identity_map.get_staged(PersonModel, :id).should eq(Set[3])
+      end
+
+      it 'finalize! retrieves records for newly-staged keys.' do
+        identity_map.finalize!
+        identity_map.get(PersonModel, id: 3).id.should eq(3)
+      end
+
+    end
+
+
+    context 'with context that includes a track with a block' do
+      before do
+        identity_map.clear!
+
+        identity_map.load(AddressModel) do
+          context :current
+          where id: 3
+        end
+
+        identity_map.finalize!
+      end
+
+      it 'loads the owner and residents' do
+        identity_map.all(PersonModel).should have(3).items
+        identity_map.all(PersonModel).collect(&:id).should =~ [1,4,5]
+      end
+
+      it 'loads the owner with the :default and :tiny contexts' do
+        owner = identity_map.get(PersonModel, id: 1)
+
+        owner._query.contexts.should eq(Set[:default,:tiny])
+        owner._query.track.should eq(Set[:address])
+      end
+
+      it 'loads the residents with the :default and :tiny contexts' do
+        address = identity_map.get(AddressModel, id: 3)
+
+        address.residents.should have(2).items
+        address.residents.each do |resident|
+          resident._query.contexts.should eq(Set[:default, :tiny])
+          resident._query.track.should eq(Set[:address])
+        end
+      end
+
+    end
+
+    context 'and a where clause' do
+
+
+      context 'for a many_to_one association' do
+        before do
+          identity_map.load PersonModel do
+            track :address do
+              where state: 'OR'
+            end
+          end
+        end
+        it 'raises an error ' do
+          expect { identity_map.finalize!(AddressModel) }.to raise_error(/type :many_to_one is not supported/)
+        end
+      end
+
+      context 'for a array_to_many association' do
+        before do
+          identity_map.load PersonModel do
+            track :prior_addresses do
+              where state: 'OR'
+            end
+          end
+        end
+        it 'raises an error ' do
+          expect { identity_map.finalize!(AddressModel) }.to raise_error(/type :array_to_many is not supported/)
+        end
+      end
+
+      context 'for a one_to_many association' do
+        before do
+          identity_map.load PersonModel do
+            track :properties do
+              where state: 'OR'
+            end
+          end
+        end
+
+        it 'honors the where clause' do
+          identity_map.finalize!
+          identity_map.all(AddressModel).should_not be_empty
+          identity_map.all(AddressModel).all? { |address| address.state == 'OR' }.should be(true)
+        end
+
+      end
+    end
+
+  end
+
+  context 'adding and retrieving records' do
+    let(:record_query) do
+      Praxis::Mapper::Support::MemoryQuery.new(identity_map, model) do
+        track :parent
+      end
+    end
+
+    let(:records) { rows.collect { |row| m = model.new(row); m._query = record_query; m } }
+
+    before do
+      identity_map.add_records(records)
+    end
+
+
+    it 'sets record.identity_map' do
+      records.each { |record| record.identity_map.should be(identity_map) }
+    end
+
+    # FIXME: see similar test for unloaded keys above
+    it 'round-trips nicely...' do
+      identity_map.rows_for(model).should =~ records
+    end
+
+    it 'updates primary key indices' do
+      identity_map.row_by_key(model,:id,1).should == records.first
+      identity_map.row_by_key(model,:name,"george jr").should == records.first
+    end
+
+    it 'does not re-add existing rows' do
+      new_record = SimpleModel.new(
+        :id => records.first.id,
+        :name => records.first.name,
+        :parent_id => records.first.parent_id,
+        :description => "new description"
+      )
+      identity_map.add_records([new_record])
+
+      identity_map.rows_for(model).should =~ records
+    end
+
+    it 'stages tracked associations' do
+      identity_map.get_staged(ParentModel,:id).should == Set.new([1,2])
+    end
+
+    context 'with a tracked array association' do
+      let(:records) { [YamlArrayModel.new(:id => 1, :parent_ids => YAML.dump([1,2]) )].each { |m| m._query = records_query } }
+      let(:records_query) do
+        Praxis::Mapper::Support::MemoryQuery.new(identity_map, YamlArrayModel) do
+          track :parents
+        end
+      end
+
+      it 'stages the deserialized relationship ids' do
+        identity_map.get_staged(ParentModel,:id).should == Set.new([1,2])
+      end
+
+      context 'with a nil value for the association' do
+        let(:records) { [YamlArrayModel.new(:id => 1, :parent_ids => nil)] }
+        let(:opts) { {:track => [:parents]} }
+
+        it 'does not stage anything' do
+          identity_map.get_staged(ParentModel,:id).should == Set.new
+        end
+
+      end
+    end
+  end
+
+
+  context "#add_records" do
+
+
+    context "with a tracked many_to_one association " do
+      before do
+        identity_map.load(SimpleModel) do
+          track :parent
+        end
+      end
+
+      it 'sets loaded records #identity_map' do
+        identity_map.all(model).each { |record| record.identity_map.should be(identity_map) }
+      end
+
+      it 'adds loaded records to the identity map' do
+        rows.all? do |row|
+          identity_map.rows_for(model).any? { |record| record.id == row[:id] }
+        end.should be(true)
+      end
+
+      it 'adds ids for tracked associations to unloaded ids' do
+        identity_map.get_staged(ParentModel,:id).should == Set.new([1,2])
+      end
+
+      it 'does not add ids for untracked associations to unloaded ids' do
+        identity_map.get_staged(OtherModel,:id).should == Set.new
+      end
+
+      context "loading missing ParentModel records" do
+        let(:parent_rows) {[
+                             {:id => 1, :name => "parent one"}
+        ]}
+
+        before do
+          identity_map.get_staged(ParentModel,:id).should == Set.new([1,2])
+
+          repository.insert(ParentModel, parent_rows)
+          identity_map.load(ParentModel)
+        end
+
+        it 'removes only those ids from unloaded_ids that correspond to loaded rows' do
+          identity_map.get_staged(ParentModel,:id).should == Set.new([2])
+        end
+
+      end
+    end
+
+    context 'with a tracked one_to_many association' do
+
+      before do
+        identity_map.load(PersonModel) do
+          track :properties
+        end
+      end
+
+      it 'adds loaded records to the identity map' do
+        identity_map.rows_for(PersonModel).collect(&:id).should =~ person_rows.collect { |r| r[:id] }
+
+      end
+
+      it 'adds ids for tracked associations to unloaded ids' do
+        identity_map.get_staged(AddressModel,:owner_id).should == Set.new([1,2,3,4,5])
+      end
+
+    end
+
+    # TODO: track whether a model is finalized
+    #it 'tracks whether a model has been finalized'
+
+    context 'composite identity support' do
+      let(:composite_id_rows) {[
+                                 {:id => 1, :type => "foo", :state => "running"},
+                                 {:id => 2, :type => "bar", :state => "terminated"}
+      ]}
+
+      context "loading records" do
+
+        context "for a model with a composite identity" do
+          before do
+            repository.insert(CompositeIdModel, composite_id_rows)
+            identity_map.load(CompositeIdModel)
+          end
+
+          it 'loads the rows normally' do
+            identity_map.rows_for(CompositeIdModel).collect(&:id).should =~ composite_id_rows.collect { |r| r[:id] }
+          end
+
+          it 'indexes the rows by the composite identity' do
+            identity_map.row_by_key(CompositeIdModel,[:id,:type],[1,"foo"]).state == composite_id_rows.first[:state]
+          end
+        end
+
+        context 'tracking composite associations' do
+          let(:child_rows) {[
+                              {:id => 10, :composite_id => 1, :composite_type => "foo", :name => "something"},
+                              {:id => 11, :composite_id => 2, :composite_type => "bar", :name => "nothing"}
+          ]}
+
+          before do
+            repository.insert(:other_model, child_rows)
+            identity_map.load(OtherModel) do
+              track :composite_model
+            end
+
+          end
+
+          it 'stages the CompositeIdModel identity' do
+            identity_map.get_staged(CompositeIdModel,[:id,:type]).should == Set.new([[1,"foo"],[2,"bar"]])
+          end
+          context 'when one or more of the values in the composite key is nil' do
+            let(:child_rows) {[
+                                {:id => 10, :composite_id => 1, :composite_type => "foo", :name => "something"},
+                                {:id => 11, :composite_id => nil, :composite_type => "bar", :name => "nothing"},
+                                {:id => 12, :composite_id => nil, :composite_type => nil, :name => "nothing"}
+            ]}
+            it 'skips staging them' do
+              identity_map.get_staged(CompositeIdModel,[:id,:type]).should == Set.new([[1,"foo"]])
+            end
+          end
+        end
+
+
+        context 'tracking composite associations through arrays' do
+          let(:child_rows) {[
+                              {id: 10,type: 'CompositeArrayModel',composite_array_keys: JSON.dump([[1,"foo"],[2,"bar"]]), name: "something"},
+                              {id: 11,type: 'CompositeArrayModel',composite_array_keys: JSON.dump([[2,"bar"],[3,"baz"]]), name: "something"}
+          ]}
+
+          before do
+            repository.insert(:composite_array_model, child_rows)
+            identity_map.load(CompositeArrayModel) do
+              track :composite_id_models
+            end
+
+          end
+
+          it 'stages the CompositeIdModel identity' do
+            identity_map.get_staged(CompositeIdModel,[:id,:type]).should == Set.new([[1,"foo"],[2,"bar"],[3,"baz"]])
+          end
+
+          context 'when one or more of the values in the composite key (for any composite values in the array) is nil' do
+            let(:child_rows) {[
+                                {:id => 10, :type => 'CompositeArrayModel', :composite_array_keys => JSON.dump([[1,"foo"],[2,"bar"]]),  :name => "something"},
+                                {:id => 11, :type => 'CompositeArrayModel', :composite_array_keys => JSON.dump([[2,"bar"],[3,nil]]),  :name => "something"},
+                                {:id => 13, :type => 'CompositeArrayModel', :composite_array_keys => JSON.dump([nil,      [4,nil]]),  :name => "something"}
+            ]}
+            it 'skips staging them' do
+              identity_map.get_staged(CompositeIdModel,[:id,:type]).should == Set.new([[1,"foo"],[2,"bar"]])
+            end
+          end
+        end
+      end
+
+    end
+
+    context "#clear!" do
+      let(:stage) { {:id => [3,4]} }
+
+      before do
+        identity_map.load(SimpleModel)
+        identity_map.stage(model, stage)
+
+        identity_map.rows_for(SimpleModel).should_not be_empty
+        identity_map.get_staged(SimpleModel,:id).should == Set.new(stage[:id])
+        identity_map.get_staged(SimpleModel,:name).should == Set.new
+
+        identity_map.queries[SimpleModel].add(double("query"))
+
+        identity_map.clear!
+      end
+
+
+      it 'resets the rows' do
+        identity_map.rows_for(SimpleModel).should be_empty
+      end
+
+
+      it 'clears the staged rows' do
+        identity_map.get_staged(SimpleModel,:id).should == Set.new
+      end
+
+      it 'clears the row keys' do
+        expect { identity_map.row_by_key(SimpleModel,:id,1) }.to raise_error(Praxis::Mapper::IdentityMap::UnloadedRecordException)
+      end
+
+      it 'clears the query history' do
+        identity_map.queries.should have(0).items
+      end
+
+    end
+
+    context "#all" do
+
+      before do
+        identity_map.load(SimpleModel)
+        identity_map.load(PersonModel)
+
+        # pretend we staged :id => 4, tried to properly load it, but it
+        # was not present in the database.
+        identity_map.instance_variable_get(:@row_keys)[model][:id][4] = nil
+      end
+
+      it 'returns all records' do
+        identity_map.all(SimpleModel).collect(&:id).should =~ rows.collect { |r| r[:id] }
+      end
+
+      it 'filters records by one id' do
+        identity_map.all(SimpleModel, :id =>[1]).collect(&:id).should =~ [rows.first].collect { |r| r[:id] }
+      end
+
+      it 'filters records by multiple ids' do
+        identity_map.all(SimpleModel, :id => [1,2]).collect(&:id).should =~ rows[0..1].collect { |r| r[:id] }
+      end
+
+      it 'returns an empty array if nothing was found matching a condition' do
+        identity_map.all(SimpleModel, :id => [4]).should =~ []
+      end
+
+    end
+
+    context '#row_by_key' do
+      let(:stage) { {:id => [1,2,3,4]} }
+      before do
+        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(rows)
+        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:freeze)
+        identity_map.stage(model,stage)
+        identity_map.finalize_model!(model)
+      end
+
+      it 'raises UnloadedRecordException for unknown records' do
+        expect { identity_map.row_by_key(model,:id, 5) }.to raise_error(Praxis::Mapper::IdentityMap::UnloadedRecordException)
+      end
+    end
+
+    context "#<<" do
+      let(:records) { 3.times.collect { SimpleModel.generate} }
+
+      before do
+        records.each { |record| identity_map << record }
+      end
+
+      it 'stores a single record at a time' do
+        identity_map.rows_for(SimpleModel).should =~ records
+      end
+
+      it 'sets loaded records #identity_map' do
+        records.each { |record| record.identity_map.should be(identity_map) }
+      end
+
+
+    end
+
+    context "#get" do
+      before do
+        identity_map.load(model)
+
+        # pretend we staged :id => 4, tried to properly load it, but it
+        # was not present in the database.
+        identity_map.instance_variable_get(:@row_keys)[model][:id][4] = nil
+      end
+
+      it 'returns a single records by id' do
+        identity_map.get(model, :id => 1).id.should == rows.first[:id]
+      end
+
+      it 'returns nil for a record that was not found' do
+        identity_map.get(model, :id => 4).should be_nil
+      end
+
+    end
+
+
+
+
+    context 'statistics tracking' do
+
+      context 'in a new identity map' do
+        its(:queries) { should have(0).items }
+        it 'initializes new keys with a Set' do
+          subject.queries[model].should == Set.new
+        end
+      end
+
+      context 'after loading queries' do
+
+        before do
+          subject.queries[PersonModel].should have(0).item
+        end
+
+        it 'tracks for #load' do
+          identity_map.load(PersonModel)
+
+          subject.queries[PersonModel].should have(1).item
+        end
+
+        it 'tracks for #finalize_model!' do
+          identity_map.stage(PersonModel, id: [1,2])
+          identity_map.finalize_model!(PersonModel)
+
+          subject.queries[PersonModel].should have(1).item
+        end
+
+      end
+
+
+    end
+
+    context 'secondary index support' do
+      let(:people) { identity_map.all PersonModel }
+      let(:secondary_indexes) { identity_map.instance_variable_get(:@secondary_indexes) }
+
+      before do
+        identity_map.load PersonModel
+      end
+
+      context '#index' do
+        it 'lazily calls #reindex! to build secondary indexes' do
+          identity_map.should_receive(:reindex!).with(PersonModel, :address_id).and_call_original
+
+          identity_map.index(PersonModel, :address_id, 1)
+        end
+
+        it 'does not call #reindex! if not necessary' do
+          identity_map.index(PersonModel, :address_id, 1)
+          identity_map.should_not_receive(:reindex!)
+          identity_map.index(PersonModel, :address_id, 2)
+        end
+
+        it 'supports composite keys' do
+          identity_map.should_receive(:reindex!).with(PersonModel, [:id, :email]).and_call_original
+          values = identity_map.index(PersonModel, [:id, :email], [1,"one@example.com"])
+
+          person, *rest = values
+          rest.should be_empty
+
+          person.id.should eq(1)
+          person.email.should eq('one@example.com')
+        end
+      end
+
+      context '#reindex!' do
+        it 'builds a secondary index for the given model and key' do
+          identity_map.reindex!(PersonModel, :address_id)
+
+          secondary_indexes.should have_key(PersonModel)
+          secondary_indexes[PersonModel].should have_key(:address_id)
+          secondary_indexes[PersonModel][:address_id].keys.should =~ person_rows.collect { |person| person[:address_id] }.uniq
+
+          people.each do |person|
+            identity_map.index(PersonModel, :address_id, person.address_id).should include(person)
+          end
+        end
+      end
+
+      context '#all' do
+        it 'uses the index internally' do
+          identity_map.should_receive(:reindex!).with(PersonModel, :address_id).and_call_original
+
+          people = identity_map.all(PersonModel, address_id: [2])
+          people.should have(2).items
+          people.each { |person| person.address_id.should eq(2) }
+        end
+      end
+    end
+  end
+end