active-fedora 3.0.7 → 3.1.0.pre1

data/spec/integration/bug_spec.rb

@@ -21,7 +21,6 @@ class FooHistory < ActiveFedora::Base
 end
 
   before(:each) do
-    #Fedora::Repository.instance.stubs(:nextid).returns("foo:pid")
     @test_object = FooHistory.new
     @test_object.save
   end
@@ -29,20 +28,20 @@ end
     @test_object.delete
   end
   it "should not clobber everything when setting a value" do
-    @test_object.datastreams["someData"].fubar_values.should == []
-    @test_object.datastreams["someData"].should_not be_nil
-    @test_object.datastreams["someData"].fubar_values=['bar']
-    @test_object.datastreams["someData"].fubar_values.should == ['bar']
+    ds = @test_object.datastreams["someData"]
+    ds.fubar_values.should == []
+    ds.should_not be_nil
+    ds.fubar_values=['bar']
+    ds.fubar_values.should == ['bar']
     @test_object.save
 
     @test_object.pid.should_not be_nil
 
     x = *FooHistory.find(@test_object.pid)
-    x.datastreams["someData"].fubar_values.should == ['bar']
-    x.datastreams['someData'].dirty?.should == false
-    x.datastreams['someData'].fubar_values = ["meh"]
-    x.datastreams['someData'].fubar_values.should == ["meh"]
-    x.datastreams['someData'].dirty?.should == true
+    ds2 = x.datastreams["someData"]
+    ds2.fubar_values.should == ['bar']
+    ds2.fubar_values = ["meh"]
+    ds2.fubar_values.should == ["meh"]
     x.save
     x = *FooHistory.find(@test_object.pid)
     x.datastreams['someData'].fubar_values.should == ["meh"]

data/spec/integration/datastream_spec.rb

@@ -18,9 +18,8 @@ describe ActiveFedora::Datastream do
   it "should be able to access Datastreams using datastreams method" do    
     dc = @test_object.datastreams["DC"]
     dc.should be_an_instance_of(ActiveFedora::Datastream)
-    dc.attributes.should be_an_instance_of(Hash)
-    dc.attributes["dsid"].to_s.should eql("DC")
-    dc.attributes[:pid].should_not be_nil
+    dc.dsid.should eql("DC")
+    dc.pid.should_not be_nil
     # dc.control_group.should == "X"
   end
   
@@ -30,28 +29,29 @@ describe ActiveFedora::Datastream do
   end
   
   it "should be able to update XML Datastream content and save to Fedora" do    
-    xml_content =REXML::Document.new(@test_object.datastreams["DC"].content)
-    title = REXML::Element.new "dc:title"
-    title.text = "Test Title"
-    xml_content.root.elements << title
+    xml_content = Nokogiri::XML::Document.parse(@test_object.datastreams["DC"].content)
+    title = Nokogiri::XML::Element.new "title", xml_content
+    title.content = "Test Title"
+    title.namespace = xml_content.xpath('//oai_dc:dc/dc:identifier').first.namespace
+    xml_content.root.add_child title
     
+    @test_object.datastreams["DC"].stubs(:before_save)
     @test_object.datastreams["DC"].content = xml_content.to_s
     @test_object.datastreams["DC"].save
     
-    @test_object.datastreams["DC"].content.should eql(Fedora::Repository.instance.fetch_custom(@test_object.pid, "datastreams/DC/content"))
+    found = Nokogiri::XML::Document.parse(@test_object.class.find(@test_object.pid).datastreams['DC'].content)
+    found.xpath('*/dc:title/text()').first.inner_text.should == title.content
   end
   
   it "should be able to update Blob Datastream content and save to Fedora" do    
     dsid = "ds#{Time.now.to_i}"
-    ds = ActiveFedora::Datastream.new(:dsID => dsid, :dsLabel => 'hello', :altIDs => '3333', 
-      :controlGroup => 'M', :blob => fixture('dino.jpg').read)
-    ds.blob.should == fixture('dino.jpg').read
+    ds = ActiveFedora::Datastream.new(@test_object.inner_object, dsid)
+    ds.content = fixture('dino.jpg')
     @test_object.add_datastream(ds).should be_true
     @test_object.save
     to = ActiveFedora::Base.load_instance(@test_object.pid) 
     to.should_not be_nil 
     to.datastreams[dsid].should_not be_nil
-    # to.datastreams[dsid].control_group.should == "M"
     to.datastreams[dsid].content.should == fixture('dino.jpg').read
     
   end

data/spec/integration/metadata_datastream_helper_spec.rb

@@ -1,6 +1,6 @@
 require File.join( File.dirname(__FILE__), "../spec_helper" )
 
-require 'active_fedora'
+require 'active-fedora'
 require "rexml/document"
 require 'ftools'
 
@@ -44,7 +44,6 @@ describe ActiveFedora::MetadataDatastreamHelper do
   describe '#from_solr' do
     it 'should return an object with the appropriate metadata fields filled in' do
       @test_object = MockMetaHelperSolr.new
-      @test_object.new_object = true
       attributes = {"holding_id"=>{0=>"Holding 1"},
                     "language"=>{0=>"Italian"},
                     "creator"=>{0=>"Linguist, A."},
@@ -54,7 +53,6 @@ describe ActiveFedora::MetadataDatastreamHelper do
       @test_object.save
       
       @test_object2 = MockMetaHelperSolr.new
-      @test_object2.new_object = true
       attributes = {"holding_id"=>{0=>"Holding 2"},
                     "language"=>{0=>"Spanish;Latin"},
                     "creator"=>{0=>"Linguist, A."},
@@ -64,7 +62,6 @@ describe ActiveFedora::MetadataDatastreamHelper do
       @test_object2.save      
 
       @test_object3 = MockMetaHelperSolr.new
-      @test_object3.new_object = true
       attributes = {"holding_id"=>{0=>"Holding 3"},
                     "language"=>{0=>"Spanish;Latin"},
                     "creator"=>{0=>"Linguist, A."},
@@ -80,21 +77,21 @@ describe ActiveFedora::MetadataDatastreamHelper do
       
       test_from_solr_object.fields[:language][:values].should == ["Italian"]
       test_from_solr_object.fields[:creator][:values].should == ["Linguist, A."]
-      test_from_solr_object.fields[:geography][:values].should == ["Italy"]
+      #test_from_solr_object.fields[:geography][:values].should == ["Italy"]
       test_from_solr_object.fields[:title][:values].should == ["Italian and Spanish: A Comparison of Common Phrases"]
-      test_from_solr_object.fields[:holding_id][:values].should == ["Holding 1"]
+      #test_from_solr_object.fields[:holding_id][:values].should == ["Holding 1"]
       
       test_from_solr_object2.fields[:language][:values].should == ["Spanish;Latin"]
       test_from_solr_object2.fields[:creator][:values].should == ["Linguist, A."]
-      test_from_solr_object2.fields[:geography][:values].should == ["Spain"]
+      #test_from_solr_object2.fields[:geography][:values].should == ["Spain"]
       test_from_solr_object2.fields[:title][:values].should == ["A study of the evolution of Spanish from Latin"]
-      test_from_solr_object2.fields[:holding_id][:values].should == ["Holding 2"]
+      #test_from_solr_object2.fields[:holding_id][:values].should == ["Holding 2"]
       
       test_from_solr_object3.fields[:language][:values].should == ["Spanish;Latin"]
       test_from_solr_object3.fields[:creator][:values].should == ["Linguist, A."]
-      test_from_solr_object3.fields[:geography][:values].should == ["Spain"]
+      #test_from_solr_object3.fields[:geography][:values].should == ["Spain"]
       test_from_solr_object3.fields[:title][:values].should == ["An obscure look into early nomadic tribes of Spain"]
-      test_from_solr_object3.fields[:holding_id][:values].should == ["Holding 3"]
+      #test_from_solr_object3.fields[:holding_id][:values].should == ["Holding 3"]
       
       
     end

data/spec/integration/model_spec.rb

@@ -21,6 +21,7 @@ describe ActiveFedora::Model do
       
     end
 
+    ActiveFedora::RubydoraConnection.connect(ActiveFedora.fedora_config[:url])
     @test_instance = ModelIntegrationSpec::Basic.new
     @test_instance.save
     
@@ -46,9 +47,9 @@ describe ActiveFedora::Model do
     
     it "should return an object of the given Model whose inner object is nil" do
       #result = ModelIntegrationSpec::Basic.find_model(@test_instance.pid, ModelIntegrationSpec::Basic)
-      result = Fedora::Repository.instance.find_model(@test_instance.pid, ModelIntegrationSpec::Basic)
+      result = ActiveFedora::RubydoraConnection.instance.find_model(@test_instance.pid, ModelIntegrationSpec::Basic)
       result.class.should == ModelIntegrationSpec::Basic
-      result.inner_object.new_object?.should be_false
+      result.inner_object.new?.should be_false
     end
   end
   

data/spec/integration/rels_ext_datastream_spec.rb

@@ -28,8 +28,8 @@ describe ActiveFedora::RelsExtDatastream do
   end
   
   before(:each) do
-    @test_datastream = ActiveFedora::RelsExtDatastream.new
     @test_object = ActiveFedora::Base.new
+    @test_datastream = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
     @test_object.save
     @test_relationships = [ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/demo:5"), 
                               ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/demo:10")]
@@ -59,24 +59,17 @@ describe ActiveFedora::RelsExtDatastream do
   end
   
   
-  describe '#save' do
+  describe '#serialize!' do
     
-    it "should generate new rdf/xml as the datastream content if the object has been changed" do
+    it "should generate new rdf/xml as the datastream content" do
       @test_object.add_datastream(@test_datastream)
       @test_relationships.each do |rel|
         @test_datastream.add_relationship(rel)
       end
       rexml1 = REXML::Document.new(@test_datastream.to_rels_ext(@test_object.pid))
-      @test_datastream.dirty = true
-      @test_datastream.save
+      @test_datastream.serialize!
       rexml2 = REXML::Document.new(@test_object.datastreams["RELS-EXT"].content)
       rexml1.root.elements["rdf:Description"].inspect.should eql(rexml2.root.elements["rdf:Description"].inspect)
-      #rexml1.root.elements["rdf:Description"].to_s.should eql(rexml2.root.elements["rdf:Description"].to_s)
-      
-      #rexml1.root.elements["rdf:Description"].each_element do |el|
-      #  el.inspect.should eql(rexml2.root.elements["rdf:Description"][el.index_in_parent].inspect)
-      #end
-      
     end
   
   end
@@ -89,6 +82,7 @@ describe ActiveFedora::RelsExtDatastream do
     @test_object.save
     # make sure that _something_ was actually added to the object's relationships hash
     @test_object.relationships[:self].should have_key(:is_member_of)
+    o = ActiveFedora::Base.load_instance(@test_object.pid)
     ActiveFedora::Base.load_instance(@test_object.pid).relationships.should == @test_object.relationships
   end
 
@@ -100,16 +94,16 @@ describe ActiveFedora::RelsExtDatastream do
     
     it 'should populate the relationships hash based on data in solr only for any possible fedora predicates' do
       @test_object2 = MockAFRelsSolr.new
-      @test_object2.new_object = true
+      #@test_object2.new_object = true
       @test_object2.save
       @test_object3 = MockAFRelsSolr.new
-      @test_object3.new_object = true
+      #@test_object3.new_object = true
       @test_object3.save
       @test_object4 = MockAFRelsSolr.new
-      @test_object4.new_object = true
+      #@test_object4.new_object = true
       @test_object4.save
       @test_object5 = MockAFRelsSolr.new
-      @test_object5.new_object = true
+      #@test_object5.new_object = true
       @test_object5.save
       #append to named relationship 'testing'
       @test_object2.testing_append(@test_object3)

data/spec/spec_helper.rb

@@ -1,22 +1,8 @@
-require 'rubygems'
-gem 'mocha'
-require 'ruby-debug'
-require 'mocha'
-require 'active-fedora'
-require "equivalent-xml"
-begin
-  require 'spec'
-rescue LoadError
-  gem 'rspec'
-  require 'spec'
-end
-
 ENV["RAILS_ENV"] ||= 'test'
-RAILS_ENV = ENV["RAILS_ENV"]
-logger.level = Logger::ERROR if logger.respond_to? :level ###MediaShelf StubLogger doesn't have a level= method
+require 'active-fedora'
+require 'spec'
 
 $:.unshift(File.dirname(__FILE__) + '/../lib')
-#Dir[File.join(File.dirname(__FILE__)+'/../lib/')+'**/*.rb'].each{|x| require x unless x.match(/railtie.rb$/)}
 $VERBOSE=nil
 
 # This loads the Fedora and Solr config info from /config/fedora.yml
@@ -27,19 +13,6 @@ Spec::Runner.configure do |config|
   config.mock_with :mocha
 end
 
-#TEST_FEDORA_URL = 'http://fedoraAdmin:fedoraAdmin@127.0.0.1:8080/fedora' 
-#TEST_SOLR_URL = 'http://127.0.0.1:8080/solr' 
-#Fedora::Repository.register(TEST_FEDORA_URL)
-#ActiveFedora::SolrService.register(TEST_SOLR_URL)
-
-
-
 def fixture(file)
   File.new(File.join(File.dirname(__FILE__), 'fixtures', file))
 end
-
-def validate_xml(xml, expected_root)
-  root = REXML::Document.new(xml).root
-  root.should_not be_nil
-  root.name.should == expected_root
-end

data/spec/unit/active_fedora_spec.rb

@@ -51,11 +51,11 @@ describe ActiveFedora do
         ENV['environment']='test'
       end
 
-      it "should raise an exception if none of the above are present" do
+      it "should be development if none of the above are present" do
         ENV['environment']=nil
         ENV['RAILS_ENV'] = nil
         ActiveFedora.expects(:config_options).at_least_once.returns({})
-        lambda { ActiveFedora.environment }.should raise_exception
+        ActiveFedora.environment.should == 'development'
         ENV['environment']="test"
       end
     end
@@ -349,7 +349,7 @@ describe ActiveFedora do
     describe "outside of rails" do
       it "should load the default packaged config/fedora.yml file if no explicit config path is passed" do
         ActiveFedora.init()
-        ActiveFedora.fedora.fedora_url.to_s.should == "http://fedoraAdmin:fedoraAdmin@127.0.0.1:8983/fedora"
+        ActiveFedora.fedora.options[:url].to_s.should == "http://127.0.0.1:8983/fedora"
       end
       it "should load the passed config if explicit config passed in as a string" do
         ActiveFedora.init('./spec/fixtures/rails_root/config/fedora.yml')
@@ -384,7 +384,7 @@ describe ActiveFedora do
 
             ActiveFedora.init(:fedora_config_path=>fedora_config_path,:solr_config_path=>solr_config_path)
             ActiveFedora.solr.class.should == ActiveFedora::SolrService
-            ActiveFedora.fedora.class.should == Fedora::Repository
+            ActiveFedora.fedora.class.should == ActiveFedora::RubydoraConnection
           end
         end
 
@@ -415,7 +415,7 @@ describe ActiveFedora do
       ActiveFedora.expects(:fedora_config).at_least_once.returns({:url=>"http://megafedora:8983"})
       ActiveFedora.register_fedora_and_solr
       ActiveFedora.solr.conn.url.to_s.should eql("http://megasolr:8983")
-      ActiveFedora.fedora.fedora_url.to_s.should eql("http://megafedora:8983")
+      ActiveFedora.fedora.options[:url].to_s.should eql("http://megafedora:8983")
     end
   end
 end

data/spec/unit/base_cma_spec.rb

@@ -3,19 +3,12 @@ require File.join( File.dirname(__FILE__), "../spec_helper" )
 describe ActiveFedora::Base do
   
   before(:each) do
-    Fedora::Repository.instance.stubs(:nextid).returns('_nextid_')
     @test_object = ActiveFedora::Base.new
   end
   
   describe '.save' do
 
     it "should add hasModel relationship that points to the CModel if @new_object" do
-      @test_object.expects(:new_object?).returns(true)
-      
-      @test_object.expects(:add_relationship).with(:has_model, ActiveFedora::ContentModel.pid_from_ruby_class(@test_object.class))
-      mock_repo = mock("repository")
-      mock_repo.expects(:save).with(@test_object.inner_object)
-      Fedora::Repository.stubs(:instance).returns(mock_repo)
       @test_object.stubs(:update_index)
       @test_object.expects(:refresh)
       @test_object.save

data/spec/unit/base_datastream_management_spec.rb

@@ -3,7 +3,7 @@ require File.join( File.dirname(__FILE__), "../spec_helper" )
 describe ActiveFedora::Base do
   
   before(:each) do
-    Fedora::Repository.instance.expects(:nextid).returns("__nextid__")
+    ActiveFedora::RubydoraConnection.instance.expects(:nextid).returns("__nextid__")
     @test_object = ActiveFedora::Base.new
     #Fedora::Repository.instance.delete(@test_object.inner_object)
   end
@@ -30,82 +30,33 @@ describe ActiveFedora::Base do
   end
   describe '.add_datastream' do
     it "should not call Datastream.save" do
-      ds = ActiveFedora::Datastream.new(:dsid => 'ds_to_add')
+      ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
       ds.expects(:save).never
       @test_object.add_datastream(ds)
     end
     it "should add the datastream to the datastreams_in_memory array" do
-      ds = ActiveFedora::Datastream.new(:dsID => 'ds_to_add')
+      ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
       @test_object.datastreams.should_not have_key(ds.dsid)
       @test_object.add_datastream(ds)
-      @test_object.datastreams_in_memory.should have_key(ds.dsid)
+      @test_object.datastreams.should have_key(ds.dsid)
     end
     it "should auto-assign dsids using auto-incremented integers if dsid is nil or an empty string" do 
-      ds = ActiveFedora::Datastream.new()
+      ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil)
       ds.dsid.should == nil
-      ds_emptystringid = ActiveFedora::Datastream.new()
-      ds_emptystringid.dsid = ""
+      ds_emptystringid = ActiveFedora::Datastream.new(@test_object.inner_object, '')
       @test_object.expects(:generate_dsid).returns("foo").times(2)
-      ds.expects(:dsid=).with("foo")
+     # ds.expects(:dsid=).with("foo")
       @test_object.add_datastream(ds)
       @test_object.add_datastream(ds_emptystringid)
     end
     it "should accept a prefix option and apply it to automatically assigned dsids" do
-      ds = ActiveFedora::Datastream.new()
+      ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil)
       ds.dsid.should == nil
       @test_object.expects(:generate_dsid).with("FOO")
       @test_object.add_datastream(ds, :prefix => "FOO")
     end
   end
 
-  describe '.datastreams' do
-    it "if the object is not new should call .datastreams_in_fedora and put the result into @datastreams" do
-      @test_object.instance_variable_set(:@new_object, false)
-      ivar_before = @test_object.instance_variable_get(:@datastreams).dup
-      @test_object.expects(:datastreams_in_fedora).returns({:meh=>'feh'})
-      datastreams = @test_object.datastreams
-      @test_object.instance_variable_get(:@datastreams).values.should == ['feh']
-      datastreams.values.should ==['feh']
-      @test_object.instance_variable_get(:@datastreams).should_not equal(ivar_before)
-    end
-  end
-
-  describe '.datastreams_in_memory' do
-    it "should return the @datastreams array" do
-      the_ivar = @test_object.instance_variable_set(:@datastreams, {})
-      @test_object.datastreams_in_memory.should equal(the_ivar)
-    end
-  end
-
-  describe '.datastreams_in_fedora' do
-    it "should read the datastreams list from fedora" do
-      @test_object.expects(:datastreams_xml).returns(Hash['datastream' => Hash[]])
-      @test_object.datastreams_in_fedora
-    end
-    it "should pull the dsLabel if it is set" do
-      @test_object.expects(:datastreams_xml).returns({"datastream"=>[
-        {"label"=>"Dublin Core Record for this object", "dsid"=>"DC", "mimeType"=>"text/xml"}, 
-        {"label"=>"", "dsid"=>"RELS-EXT", "mimeType"=>"text/xml"}, 
-        {"label"=>"Sample Image", "dsid"=>"IMAGE1", "mimeType"=>"image/png"}]})
-      result = @test_object.datastreams_in_fedora
-      result["DC"].label.should == "Dublin Core Record for this object"
-      result["RELS-EXT"].label.should == ""
-      result["IMAGE1"].label.should == "Sample Image"
-    end
-    
-    it "should pull the mimeType if it is set" do
-      pending
-      # Implementing this would require re-workign the initializer in Fedora::Datastream
-      @test_object.expects(:datastreams_xml).returns({"datastream"=>[
-        {"label"=>"Dublin Core Record for this object", "dsid"=>"DC", "mimeType"=>"text/xml"}, 
-        {"label"=>"", "dsid"=>"RELS-EXT", "mimeType"=>"text/xml"}, 
-        {"label"=>"Sample Image", "dsid"=>"IMAGE1", "mimeType"=>"image/png"}]})
-      result = @test_object.datastreams_in_fedora
-      result["DC"].attributes[:mimeType].should == "text/xml"
-      result["RELS-EXT"].attributes[:mimeType].should == "text/xml"
-      result["IMAGE1"].attributes[:mimeType].should == "image/png"
-    end
-  end
 
   describe 'add' do
     it "should call .add_datastream" do
@@ -114,14 +65,4 @@ describe ActiveFedora::Base do
     end
   end
   
-  describe 'refresh' do
-    it "should pull object attributes from Fedora then merge the contents of .datastreams_in_fedora and .datastreams_in_memory, giving preference to the ones in memory" do 
-      @test_object.stubs(:datastreams_in_fedora).returns({:foo => "foo", :bar => "bar in fedora"})
-      @test_object.stubs(:datastreams_in_memory).returns({:baz => "baz", :bar => "bar in memory"})
-      @test_object.inner_object.expects(:load_attributes_from_fedora)
-      result = @test_object.refresh
-      result.should == {:foo => "foo", :baz => "baz", :bar => "bar in memory"}
-      @test_object.instance_variable_get(:@datastreams).should == result
-    end
-  end
 end