active-fedora 4.1.0 → 4.2.0

data/spec/support/mock_fedora.rb

@@ -9,14 +9,18 @@ end
   
 def stub_get(pid, datastreams=nil, record_exists=false)
   pid.gsub!(/:/, '%3A')
-  mock_client.stubs(:[]).with("objects/#{pid}?format=xml").returns(stub('get getter', :get=>'foobar')) if record_exists
- # @mock_client.expects(:[]).with("objects/#{pid}?format=xml").raises(RestClient::ResourceNotFound) unless record_exists
+  if record_exists
+    mock_client.stubs(:[]).with("objects/#{pid}?format=xml").returns(stub('get getter', :get=>'foobar'))
+  else
+    mock_client.stubs(:[]).with("objects/#{pid}?format=xml").raises(RestClient::ResourceNotFound)
+  end
   mock_client.stubs(:[]).with("objects/#{pid}/datastreams?format=xml").returns(@getter)
   datastreams ||= ['someData', 'withText', 'withText2', 'RELS-EXT']
   datastreams.each do |dsid|
     mock_client.stubs(:[]).with("objects/#{pid}/datastreams/#{dsid}?format=xml").returns(@getter)
   end
 end
+
 def stub_ingest(pid=nil)
   n = pid ? pid.gsub(/:/, '%3A') : nil
   mock_client.expects(:[]).with("objects/#{n || 'new'}").returns(stub("ingester", :post=>pid))

data/spec/unit/base_spec.rb

@@ -7,60 +7,75 @@ describe ActiveFedora::Base do
       ActiveFedora::Base.shard_index(@this_pid).should == 0
     end
 
-    describe "should have a connection_for_pid" do
-      before do
+    context "When the repository is NOT sharded" do
+      subject {ActiveFedora::Base.connection_for_pid('foo:bar')}
+      before(:each) do
+        ActiveFedora.config.stubs(:sharded?).returns(false)
         ActiveFedora::Base.fedora_connection = {}
+        ActiveFedora.config.stubs(:credentials).returns(:url=>'myfedora')
+      end
+      it { should be_kind_of Rubydora::Repository}
+      it "should be the standard connection" do
+        subject.client.url.should == 'myfedora'
       end
-      context "When the server is not sharded" do
-        subject {ActiveFedora::Base.connection_for_pid('foo:bar')}
-        before(:each) do
-          ActiveFedora.config.expects(:sharded?).returns(false)
-          ActiveFedora.config.expects(:credentials).returns(:url=>'myfedora')
+      describe "assign_pid" do
+        after do
+          ActiveFedora::RubydoraConnection.unstub(:new)
         end
-        it { should be_kind_of Rubydora::Repository}
-        it "should be the standard connection" do
-          subject.client.url.should == 'myfedora'
+        it "should use fedora to generate pids" do
+          # TODO: This juggling of Fedora credentials & establishing connections should be handled by an establish_fedora_connection method, 
+          # possibly wrap it all into a fedora_connection method - MZ 06-05-2012
+          stubfedora = mock("Fedora")
+          stubfedora.expects(:connection).returns(mock("Connection", :next_pid =>"<pid>sample:newpid</pid>"))
+          # Should use ActiveFedora.config.credentials as a single hash rather than an array of shards
+          ActiveFedora::RubydoraConnection.expects(:new).with(ActiveFedora.config.credentials).returns(stubfedora)
+          ActiveFedora::Base.assign_pid(ActiveFedora::Base.new.inner_object)
         end
       end
-      context "When the repository is sharded" do
-        before :all do
-          class FooHistory < ActiveFedora::Base
-            def self.shard_index(pid)
-              pid == 'foo:bar' ? 0 : 1
-            end
-          end
+      describe "shard_index" do
+        it "should always return zero (the first and only connection)" do
+          ActiveFedora::Base.shard_index('foo:bar').should == 0
         end
-        before :each do
-          ActiveFedora.config.expects(:sharded?).returns(true)
+      end
+    end
+    context "When the repository is sharded" do
+      before :each do
+        ActiveFedora.config.stubs(:sharded?).returns(true)
+        ActiveFedora::Base.fedora_connection = {}
+        ActiveFedora.config.stubs(:credentials).returns([{:url=>'shard1'}, {:url=>'shard2'} ])
+      end
+      describe "assign_pid" do
+        it "should always use the first shard to generate pids" do
+          stubshard1 = mock("Shard")
+          stubshard2 = mock("Shard")
+          stubshard1.expects(:connection).returns(mock("Connection", :next_pid =>"<pid>sample:newpid</pid>"))
+          stubshard2.expects(:connection).never
+          ActiveFedora::Base.fedora_connection = {0 => stubshard1, 1 => stubshard2}
+          ActiveFedora::Base.assign_pid(ActiveFedora::Base.new.inner_object)
         end
-        after :all do
-          Object.send(:remove_const, :FooHistory)
+      end
+      describe "shard_index" do
+        it "should use modulo of md5 of the pid to distribute objects across shards" do
+          ActiveFedora::Base.shard_index('foo:bar').should == 0
+          ActiveFedora::Base.shard_index('foo:nanana').should == 1
         end
-        describe "assign_pid" do
-          subject {FooHistory}
-          it "should raise an exception when assign_pid is not overridden" do
-            lambda {subject.assign_pid(stub(:namespace=>'changeme'))}.should raise_error(RuntimeError, "When using shards, you must override FooHistory.assign_pid()")
+      end
+      describe "the repository" do
+        describe "for foo:bar" do
+          subject {ActiveFedora::Base.connection_for_pid('foo:bar')}
+          it "should be shard1" do
+            subject.client.url.should == 'shard1'
           end
         end
-        describe "the repository" do
-          before do
-            ActiveFedora.config.expects(:credentials).returns([{:url=>'shard1'}, {:url=>'shard2'} ])
-          end
-          describe "for foo:bar" do
-            subject {FooHistory.connection_for_pid('foo:bar')}
-            it "should be shard1" do
-              subject.client.url.should == 'shard1'
-            end
-          end
-          describe "for foo:baz" do
-            subject {FooHistory.connection_for_pid('foo:baz')}
-            it "should be shard1" do
-              subject.client.url.should == 'shard2'
-            end
+        describe "for foo:baz" do
+          subject {ActiveFedora::Base.connection_for_pid('foo:nanana')}
+          it "should be shard1" do
+            subject.client.url.should == 'shard2'
           end
         end
       end
     end
+
   end
 
   describe "With a test class" do

data/spec/unit/datastreams_spec.rb

@@ -272,7 +272,8 @@ describe ActiveFedora::Datastreams do
     before do
       class FileDS < ActiveFedora::Datastream; end
       class FooHistory < ActiveFedora::Base
-        has_file_datastream :type=>FileDS
+        has_file_datastream
+        has_file_datastream :name=>"second", :label=>"Second file", :type=>FileDS, :control_group=>'X'
       end
     end
     after do
@@ -280,9 +281,12 @@ describe ActiveFedora::Datastreams do
       Object.send(:remove_const, :FileDS)
     end
     it "Should add a line in ds_spec" do
-      FooHistory.ds_specs['content'][:type].should == FileDS
+      FooHistory.ds_specs['content'][:type].should == ActiveFedora::Datastream
       FooHistory.ds_specs['content'][:label].should == "File Datastream"
       FooHistory.ds_specs['content'][:control_group].should == "M"
+      FooHistory.ds_specs['second'][:type].should == FileDS
+      FooHistory.ds_specs['second'][:label].should == "Second file"
+      FooHistory.ds_specs['second'][:control_group].should == "X"
     end
   end
 

data/spec/unit/model_spec.rb

@@ -6,75 +6,27 @@ describe ActiveFedora::Model do
     module SpecModel
       class Basic
         include ActiveFedora::Model
+        def initialize (args = {})
+        end
       end
     end
-    @test_property = ActiveFedora::Property.new("foo_model","test_property", :text)
-  end
-  
-  before(:each) do 
-    ActiveFedora::Base.stubs(:assign_pid).returns('_nextid_')
-    @test_instance = SpecModel::Basic.new
-    @property = stub("myproperty", :name => "mock_prop", :instance_variable_name => "@mock_prop")
-    SpecModel::Basic.extend(ActiveFedora::Model)
-    SpecModel::Basic.create_property_getter(@property)
-    @obj = SpecModel::Basic.new
   end
   
   after(:all) do
     Object.send(:remove_const, :SpecModel)
   end
   
-  it 'should provide #attribute_set and #attribute_get' do
-    SpecModel::Basic.should respond_to(:attribute_set)
-    SpecModel::Basic.should respond_to(:attribute_get) 
-  end
-  
-  it 'should provide #create_property_getter' do
-    SpecModel::Basic.should respond_to(:create_property_getter)
-  end
-  
-  describe '#create_property_getter' do
-    it 'should add getter to the model' do
-      @obj.should respond_to(@property.name)
-    end
-    
-    it 'should use attribute_get in custom getter method' do
-      @obj.expects(:attribute_get).with(@property.name)
-      @obj.send @property.name
-    end
-    
-  end
-  
-  it 'should provide #create_property_setter' do
-    SpecModel::Basic.should respond_to(:create_property_setter)
-  end
-  
-  describe '#create_property_setter' do
-    
-    before(:each) do
-      @property = stub("myproperty", :name => "mock_prop", :instance_variable_name => "@mock_prop")
-      SpecModel::Basic.create_property_setter(@property)
-      @obj = SpecModel::Basic.new
-    end
-    
-    it 'should add setter to the model' do
-      @obj.should respond_to("#{@property.name}=")
-    end
-    
-    it 'should use attribute_set in custom setter method' do
-      @obj.expects(:attribute_set).with(@property.name, "sample value")
-      @obj.send "#{@property.name}=", "sample value" 
-    end
-      
-  end
   
   describe '#find' do
     describe "without :cast" do
       it "(:all) should query solr for all objects with :active_fedora_model_s of self.class" do
-        ActiveFedora::SolrService.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic', :rows=>1001).returns([{"id" => "changeme:30"}, {"id" => "changeme:22"}])
         SpecModel::Basic.expects(:find_one).with("changeme:30", nil).returns("Fake Object1")
         SpecModel::Basic.expects(:find_one).with("changeme:22", nil).returns("Fake Object2")
-        SpecModel::Basic.find(:all, :rows=>1001).should == ["Fake Object1", "Fake Object2"]
+        mock_docs = mock('docs')
+        mock_docs.expects(:each).multiple_yields([{"id" => "changeme:30"}],[{"id" => "changeme:22"}])
+        mock_docs.expects(:has_next?).returns(false)
+        ActiveFedora::SolrService.instance.conn.expects(:paginate).with(1, 1000, 'select', :params=>{:q=>'has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic', :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).returns('response'=>{'docs'=>mock_docs})
+        SpecModel::Basic.find(:all).should == ["Fake Object1", "Fake Object2"]
       end
       it "should use SpecModel::Basic.allocate.init_with to instantiate an object" do
         SpecModel::Basic.any_instance.expects(:init_with).returns(SpecModel::Basic.new)
@@ -82,6 +34,7 @@ describe ActiveFedora::Model do
         SpecModel::Basic.find("_PID_").should be_a SpecModel::Basic
       end
       it "should raise an exception if it is not found" do
+        Rubydora::Repository.any_instance.expects(:object).raises(RestClient::ResourceNotFound)
         SpecModel::Basic.expects(:connection_for_pid).with("_PID_")
         lambda {SpecModel::Basic.find("_PID_")}.should raise_error ActiveFedora::ObjectNotFoundError
       end
@@ -94,13 +47,91 @@ describe ActiveFedora::Model do
       end
     end
 
-    describe "with conditions hash" do
+    describe "with conditions" do
       it "should filter by the provided fields" do
         SpecModel::Basic.expects(:find_one).with("changeme:30", nil).returns("Fake Object1")
         SpecModel::Basic.expects(:find_one).with("changeme:22", nil).returns("Fake Object2")
 
-        ActiveFedora::SolrService.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic AND foo:"bar" AND baz:"quix" AND baz:"quack"', {:sort => ['system_create_dt asc'], :rows=>1002}).returns([{"id" => "changeme:30"}, {"id" => "changeme:22"}])
-        SpecModel::Basic.find({:foo=>'bar', :baz=>['quix','quack']}, {:rows=>1002}).should == ["Fake Object1", "Fake Object2"]
+        mock_docs = mock('docs')
+        mock_docs.expects(:each).multiple_yields([{"id" => "changeme:30"}],[{"id" => "changeme:22"}])
+        mock_docs.expects(:has_next?).returns(false)
+        ActiveFedora::SolrService.instance.conn.expects(:paginate).with() { |page, rows, method, hash|
+            page == 1 &&
+            rows == 1000 &&
+            method == 'select' &&
+            hash[:params] &&
+            hash[:params][:sort] == ['system_create_dt asc'] &&
+            hash[:params][:fl] == 'id' && 
+            hash[:params][:q].split(" AND ").include?("has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic") &&
+            hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
+            hash[:params][:q].split(" AND ").include?("baz:\"quix\"") &&
+            hash[:params][:q].split(" AND ").include?("baz:\"quack\"")
+        }.returns('response'=>{'docs'=>mock_docs})
+        SpecModel::Basic.find({:foo=>'bar', :baz=>['quix','quack']}).should == ["Fake Object1", "Fake Object2"]
+      end
+    end
+  end
+
+  describe '#find_each' do
+    it "should query solr for all objects with :active_fedora_model_s of self.class" do
+      mock_docs = mock('docs')
+      mock_docs.expects(:each).multiple_yields([{"id" => "changeme:30"}],[{"id" => "changeme:22"}])
+      mock_docs.expects(:has_next?).returns(false)
+      ActiveFedora::SolrService.instance.conn.expects(:paginate).with(1, 1000, 'select', :params=>{:q=>'has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic', :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).returns('response'=>{'docs'=>mock_docs})
+      
+      SpecModel::Basic.expects(:find_one).with("changeme:30", nil).returns(SpecModel::Basic.new(:pid=>'changeme:30'))
+      SpecModel::Basic.expects(:find_one).with("changeme:22", nil).returns(SpecModel::Basic.new(:pid=>'changeme:22'))
+      yielded = mock("yielded method")
+      yielded.expects(:run).with { |obj| obj.class == SpecModel::Basic}.twice
+      SpecModel::Basic.find_each(){|obj| yielded.run(obj) }
+    end
+    describe "with conditions" do
+      it "should filter by the provided fields" do
+        SpecModel::Basic.expects(:find_one).with("changeme:30", nil).returns(SpecModel::Basic.new(:pid=>'changeme:30'))
+        SpecModel::Basic.expects(:find_one).with("changeme:22", nil).returns(SpecModel::Basic.new(:pid=>'changeme:22'))
+
+        mock_docs = mock('docs')
+        mock_docs.expects(:each).multiple_yields([{"id" => "changeme:30"}],[{"id" => "changeme:22"}])
+        mock_docs.expects(:has_next?).returns(false)
+        ActiveFedora::SolrService.instance.conn.expects(:paginate).with() { |page, rows, method, hash|
+            page == 1 &&
+            rows == 1000 &&
+            method == 'select' &&
+            hash[:params] &&
+            hash[:params][:sort] == ['system_create_dt asc'] && 
+            hash[:params][:fl] == 'id' && 
+            hash[:params][:q].split(" AND ").include?("has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic") &&
+            hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
+            hash[:params][:q].split(" AND ").include?("baz:\"quix\"") &&
+            hash[:params][:q].split(" AND ").include?("baz:\"quack\"")
+        }.returns('response'=>{'docs'=>mock_docs})
+        yielded = mock("yielded method")
+        yielded.expects(:run).with { |obj| obj.class == SpecModel::Basic}.twice
+        SpecModel::Basic.find_each({:foo=>'bar', :baz=>['quix','quack']}){|obj| yielded.run(obj) }
+      end
+    end
+  end
+
+  describe '#find_in_batches' do
+    describe "with conditions hash" do
+      it "should filter by the provided fields" do
+        mock_docs = mock('docs')
+        mock_docs.expects(:has_next?).returns(false)
+        ActiveFedora::SolrService.instance.conn.expects(:paginate).with() { |page, rows, method, hash|
+            page == 1 &&
+            rows == 1002 &&
+            method == 'select' &&
+            hash[:params] &&
+            hash[:params][:sort] == ['system_create_dt asc'] && 
+            hash[:params][:fl] == 'id' && 
+            hash[:params][:q].split(" AND ").include?("has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic") &&
+            hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
+            hash[:params][:q].split(" AND ").include?("baz:\"quix\"") &&
+            hash[:params][:q].split(" AND ").include?("baz:\"quack\"")
+        }.returns('response'=>{'docs'=>mock_docs})
+        yielded = mock("yielded method")
+        yielded.expects(:run).with(mock_docs)
+        SpecModel::Basic.find_in_batches({:foo=>'bar', :baz=>['quix','quack']}, {:batch_size=>1002, :fl=>'id'}){|group| yielded.run group }.should
       end
     end
   end
@@ -137,13 +168,28 @@ describe ActiveFedora::Model do
   describe '#find_with_conditions' do
     it "should make a query to solr and return the results" do
       mock_result = stub('Result')
-      ActiveFedora::SolrService.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic AND foo:"bar" AND baz:"quix" AND baz:"quack"', {:sort => ['system_create_dt asc']}).returns(mock_result)
+           ActiveFedora::SolrService.expects(:query).with() { |args|
+            q = args.first if args.is_a? Array
+            q ||= args
+            q.split(" AND ").include?("has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic") &&
+            q.split(" AND ").include?("foo:\"bar\"") &&
+            q.split(" AND ").include?("baz:\"quix\"") &&
+            q.split(" AND ").include?("baz:\"quack\"")
+        }.returns(mock_result)
       SpecModel::Basic.find_with_conditions(:foo=>'bar', :baz=>['quix','quack']).should == mock_result
       
     end
     it "should escape quotes" do
       mock_result = stub('Result')
-      ActiveFedora::SolrService.expects(:query).with('has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic AND foo:"9\\" Nails" AND baz:"7\\" version" AND baz:"quack"', {:sort => ['system_create_dt asc']}).returns(mock_result)
+           ActiveFedora::SolrService.expects(:query).with() { |args|
+            q = args.first if args.is_a? Array
+            q ||= args
+            q.split(" AND ").include?("has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic") &&
+            q.split(" AND ").include?("has_model_s:info\\:fedora/afmodel\\:SpecModel_Basic") &&
+            q.split(" AND ").include?('foo:"9\\" Nails"') &&
+            q.split(" AND ").include?('baz:"7\\" version"') &&
+            q.split(" AND ").include?('baz:"quack"')
+        }.returns(mock_result)
       SpecModel::Basic.find_with_conditions(:foo=>'9" Nails', :baz=>['7" version','quack']).should == mock_result
       
     end

data/spec/unit/ntriples_datastream_spec.rb

@@ -13,12 +13,22 @@ describe ActiveFedora::NtriplesRDFDatastream do
           map.related_url(:to => "seeAlso", :in => RDF::RDFS)
         end
       end
-      @subject = MyDatastream.new(@inner_object, 'mixed_rdf')
+      class Foo < ActiveFedora::Base
+        has_metadata :name => "descMetadata", :type => MyDatastream
+        delegate :created, :to => :descMetadata
+        delegate :title, :to => :descMetadata
+        delegate :publisher, :to => :descMetadata
+        delegate :based_near, :to => :descMetadata
+        delegate :related_url, :to => :descMetadata
+      end
+      @object = Foo.new(:pid => 'test:1')
+      @subject = @object.descMetadata
       @subject.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
-      @subject.stubs(:pid => 'test:1')
-      @subject.stubs(:new? => false)
+      @object.save
+    end
+    after do
+      @object.delete
     end
-
     it "should have a subject" do
       @subject.rdf_subject.should == "info:fedora/test:1"
     end
@@ -29,7 +39,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.mimeType.should == 'text/plain'
     end
     it "should have dsid" do
-      @subject.dsid.should == 'mixed_rdf'
+      @subject.dsid.should == 'descMetadata'
     end
     it "should have fields" do
       @subject.created.should == ["2010-12-31"]
@@ -59,6 +69,21 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
   end
 
+  describe "some dummy instances" do
+    before do
+      class MyFoobarRDFDatastream < ActiveFedora::NtriplesRDFDatastream
+      end
+      class MyFoobarRdfDatastream < ActiveFedora::NtriplesRDFDatastream
+      end
+    end
+    it "should generate predictable prexies" do
+      MyFoobarRDFDatastream.prefix("baz").should == :my_foobar__baz
+    end
+    it "should generate prefixes case-insensitively" do
+      MyFoobarRDFDatastream.prefix("quux").should == MyFoobarRdfDatastream.prefix("quux")
+    end
+  end
+
   describe "an instance with a custom subject" do
     before do 
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
@@ -73,9 +98,9 @@ describe ActiveFedora::NtriplesRDFDatastream do
         end
       end
       @subject = MyDatastream.new(@inner_object, 'mixed_rdf')
-      @subject.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
       @subject.stubs(:pid => 'test:1')
       @subject.stubs(:new? => false)
+      @subject.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
     end
 
     it "should have fields" do
@@ -220,7 +245,16 @@ describe ActiveFedora::NtriplesRDFDatastream do
       ActiveFedora::SolrService.load_mappings
     end
     describe "with an actual object" do
-      before(:all) do
+      before(:each) do
+        class Foo < ActiveFedora::Base
+          has_metadata :name => "descMetadata", :type => MyDatastream
+          delegate :created, :to => :descMetadata
+          delegate :title, :to => :descMetadata
+          delegate :publisher, :to => :descMetadata
+          delegate :based_near, :to => :descMetadata
+          delegate :related_url, :to => :descMetadata
+          delegate :rights, :to => :descMetadata
+        end
         @obj = MyDatastream.new(@inner_object, 'solr_rdf')
         @obj.created = "2012-03-04"
         @obj.title = "Of Mice and Men, The Sequel"
@@ -230,6 +264,39 @@ describe ActiveFedora::NtriplesRDFDatastream do
         @obj.rights = "Totally open, y'all"
         @obj.save
       end
+      describe '#save' do
+        it "should set dirty? to false" do
+          @obj.dirty?.should be_false
+          @obj.title = "something"
+          @obj.dirty?.should be_true
+          @obj.save
+          @obj.dirty?.should be_false
+        end
+      end
+      describe '.content=' do
+        it "should update the content and graph, marking the datastream as changed" do
+          mock_repo = mock('repository')
+          mock_repo.expects(:datastream_dissemination).with(:pid => 'test:123', 
+                                                            :dsid => 'solr_rdf')
+          sample_rdf = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
+          @obj.stubs(:pid).returns('test:123')
+          @obj.stubs(:repository).returns(mock_repo)
+          @obj.should_not be_changed
+          @obj.content.should_not be_equivalent_to(sample_rdf)
+          @obj.content = sample_rdf
+          @obj.should be_changed
+          @obj.content.should be_equivalent_to(sample_rdf)
+        end
+      end
+      it "should save content properly upon save" do
+        foo = Foo.new(:pid => 'test:1')
+        foo.title = 'Hamlet'
+        foo.save
+        foo.title.should == ['Hamlet']
+        foo.descMetadata.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
+        foo.save
+        foo.title.should == ['Title of work']
+      end
       describe ".fields()" do
         it "should return the right # of fields" do
           @obj.fields.keys.count.should == 5
@@ -252,6 +319,17 @@ describe ActiveFedora::NtriplesRDFDatastream do
           @obj.fields[:my_datastream__based_near][:values].should include("Tacoma, WA")
           @obj.fields[:my_datastream__based_near][:values].should include("Renton, WA")
         end
+        it "should solrize even when the object is not new" do
+          foo = Foo.new
+          foo.expects(:update_index).once
+          foo.title = "title1"
+          foo.save
+          foo = Foo.find(foo.pid)
+          foo.expects(:update_index).once
+          foo.publisher = "Allah2"
+          foo.title = "The Work2"
+          foo.save  
+        end
       end
       describe ".to_solr()" do
         it "should return the right # of fields" do