active-fedora 1.0.5 → 1.1.0

data/spec/unit/connection_spec.rb

@@ -0,0 +1,25 @@
+require File.join( File.dirname(__FILE__),  "../spec_helper" )
+
+require 'active_resource'
+require 'fedora/repository'
+
+describe Fedora::Connection do
+  it "should be creatable w/ a surrogate id" do
+    c = Fedora::Connection.new('http://127.0.0.1/fedora', 'fubar', 'bob')
+    c.site.to_s.should == "http://127.0.0.1/fedora"
+    c.format.should == 'fubar'
+    c.surrogate.should == 'bob'
+  end
+  it "should set a from header if surrogate defined." do
+    c = Fedora::Connection.new('http://127.0.0.1/fedora', ActiveResource::Formats[:xml], 'bob')
+    h = Hash.new
+    r= c.send(:build_request_headers,h)
+    r['From'].should == 'bob'
+  end
+  it "should not set a from header if surrogate undefined." do
+    c = Fedora::Connection.new('http://127.0.0.1/fedora' )
+    h = Hash.new
+    r= c.send(:build_request_headers,h)
+    r['From'].should be_nil
+  end
+end

data/spec/unit/content_model_spec.rb

@@ -0,0 +1,51 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require 'mocha'
+
+
+describe ActiveFedora::ContentModel do
+  
+  before(:each) do
+    Fedora::Repository.instance.stubs(:nextid).returns("_nextid_")
+    @test_cmodel = ActiveFedora::ContentModel.new
+  end
+  
+  it "should provide #new" do
+    ActiveFedora::ContentModel.should respond_to(:new)
+  end
+  
+  describe "#new" do
+    it "should create a kind of ActiveFedora::Base object" do
+      @test_cmodel.should be_kind_of(ActiveFedora::Base)
+    end
+    it "should set pid_suffix to empty string unless overriden in options hash" do
+      @test_cmodel.pid_suffix.should == ""
+      boo_model = ActiveFedora::ContentModel.new(:pid_suffix => "boo")
+      boo_model.pid_suffix.should == "boo"
+    end
+    it "should set namespace to cmodel unless overriden in options hash" do
+      @test_cmodel.namespace.should == "afmodel"
+      boo_model = ActiveFedora::ContentModel.new(:namespace => "boo")
+      boo_model.namespace.should == "boo"
+    end
+  end
+  
+  it "should provide @pid_suffix" do
+    @test_cmodel.should respond_to(:pid_suffix)
+    @test_cmodel.should respond_to(:pid_suffix=)
+  end
+  
+  it 'should provide #pid_from_ruby_class' do
+    ActiveFedora::ContentModel.should respond_to(:pid_from_ruby_class)
+  end
+  
+  describe "#pid_from_ruby_class" do
+    it "should construct pids" do
+     ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class).should == "afmodel:ActiveFedora_ContentModel"
+     ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class, :namespace => "foo", :pid_suffix => "BarBar").should == "foo:ActiveFedora_ContentModelBarBar"
+    end
+  end
+  
+
+end

data/spec/unit/datastream_concurrency_spec.rb

@@ -0,0 +1,59 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require "rexml/document"
+require 'ftools'
+
+describe ActiveFedora::Datastream do
+  
+  before(:each) do
+    Fedora::Repository.instance.expects(:nextid).returns("foo")
+    @test_object = ActiveFedora::Base.new
+    @test_datastream = ActiveFedora::Datastream.new(:pid=>@test_object.pid, :dsid=>'abcd', :blob=>StringIO.new("hi there"))
+  end
+  
+  it "should provide #last_modified_in_repository" do
+    @test_datastream.should respond_to(:last_modified_in_repository)
+  end
+  
+  it 'should update @last_modified when #save or #content is called' do 
+    pending
+    Fedora::Repository.any_instance.stubs(:save)
+    Fedora::Repository.any_instance.stubs(:fetch_custom)
+    @test_datastream.expects(:last_modified=).times(2)
+    @test_datastream.expects(:last_modified_in_repository).times(3)
+    @test_datastream.save
+    @test_datastream.content
+  end
+  
+  describe '#save' do
+    it 'should not save to fedora if @last_modified does not match the datetime from fedora'
+    it 'should save to fedora if @last_modified matches the datetime from fedora'
+  end
+  
+  describe '#last_modified_in_repository' do
+      it "should retrieve a datetime from fedora"
+  end
+  
+  it 'should provide #check_concurrency' do
+    @test_datastream.should respond_to(:check_concurrency)
+  end
+  
+  describe '#check_concurrency' do
+    it 'should return true if @last_modified matches the datetime from fedora' do
+      pending
+      @test_datastream.expects(:last_modified_in_repository).returns("2008-10-17T00:17:18.194Z")
+      @test_datastream.last_modified = "2008-10-17T00:17:18.194Z"
+      @test_datastream.check_concurrency.should == true
+    end
+    
+    it 'should raise an error if @last_modified does not match the datetime from fedora' do
+      pending
+      @test_datastream.expects(:last_modified_in_repository).returns("blah blah blah")
+      @test_datastream.last_modified = "2008-10-17T00:17:18.194Z"
+      @test_datastream.check_concurrency.should raise_error()
+    end
+    
+  end
+  
+end

data/spec/unit/datastream_spec.rb

@@ -0,0 +1,85 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require "rexml/document"
+require 'ftools'
+
+describe ActiveFedora::Datastream do
+  
+  before(:each) do
+    Fedora::Repository.instance.expects(:nextid).returns("foo")
+    @test_object = ActiveFedora::Base.new
+    @test_datastream = ActiveFedora::Datastream.new(:pid=>@test_object.pid, :dsid=>'abcd', :blob=>StringIO.new("hi there"))
+  end
+
+  it "should implement delete" do
+    Fedora::Repository.instance.expects(:delete).with('foo/datastreams/abcd').returns(true).times(2)
+    @test_datastream.delete.should == true
+    ActiveFedora::Datastream.delete('foo', 'abcd').should == true
+  end
+  
+  it "should set control_group" do
+    xml=<<-EOF
+    <?xml version="1.0" encoding="UTF-8"?>
+    <foxml:datastream xmlns:foxml="foo" ID="Addelson_Frances19971114_FINAL.doc" STATE="A" CONTROL_GROUP="M" VERSIONABLE="true">
+        <foxml:datastreamVersion ID="Addelson_Frances19971114_FINAL.doc.0" LABEL="Addelson_Frances19971114_FINAL.doc" CREATED="2008-11-19T18:18:46.631Z" MIMETYPE="application/msword">
+          <foxml:contentLocation TYPE="INTERNAL_ID" REF="changeme:551+Addelson_Frances19971114_FINAL.doc+Addelson_Frances19971114_FINAL.doc.0"/>
+        </foxml:datastreamVersion>
+      </foxml:datastream>
+    EOF
+    n = ActiveFedora::Datastream.from_xml(ActiveFedora::Datastream.new, REXML::Document.new(xml).elements.first)
+    n.control_group.should == 'M'
+
+  end
+
+  it "should escape dots in  to_param" do
+    @test_datastream.stubs(:dsid).returns('foo.bar')
+    @test_datastream.to_param.should == 'foo%2ebar'
+  end
+  
+  it 'should provide #save, #before_save and #after_save' do
+    @test_datastream.should respond_to(:save)
+    @test_datastream.should respond_to(:before_save)
+    @test_datastream.should respond_to(:after_save)
+  end
+  
+  describe '#save' do
+    it 'should call #before_save and #after_save' do
+      Fedora::Repository.instance.stubs(:save)
+      @test_datastream.stubs(:last_modified_in_repository)
+      @test_datastream.expects(:before_save)
+      @test_datastream.expects(:after_save)
+      @test_datastream.save
+    end
+    
+    it "should set @dirty to false" do
+      Fedora::Repository.instance.stubs(:save)
+      #@test_datastream.stubs(:last_modified_in_repository)
+      @test_datastream.expects(:dirty=).with(false)
+      @test_datastream.save
+    end
+  end
+  
+  describe ".dirty?" do
+    it "should return the value of the @dirty attribute" do
+      @test_datastream.dirty.should equal(@test_datastream.dirty?)
+      @test_datastream.dirty = "boo"
+      @test_datastream.dirty?.should == "boo"    
+    end
+  end 
+  
+  describe ".dsid=" do
+    it "should set the datastream's dsid" do
+      @test_datastream.dsid = "foodsid"
+      @test_datastream.dsid.should == "foodsid"
+    end
+  end 
+  
+  it "should have mime_type accessors and should allow you to pass :mime_type OR :mimeType as an argument to initialize block" do
+    ds1 = ActiveFedora::Datastream.new(:mime_type=>"text/foo")    
+    ds1.mime_type.should == "text/foo"
+    ds2 = ActiveFedora::Datastream.new(:mime_type=>"text/bar")
+    ds2.mime_type.should == "text/bar"
+  end
+  
+end

data/spec/unit/fedora_object_spec.rb

@@ -0,0 +1,66 @@
+require File.join( File.dirname(__FILE__),  "../spec_helper" )
+
+describe Fedora::FedoraObject do
+  
+  before(:each) do
+    Fedora::Repository.register(ActiveFedora.fedora_config[:url])
+    @test_object = Fedora::FedoraObject.new
+  end
+  
+  it 'should respond to #object_xml' do
+    Fedora::FedoraObject.should respond_to(:object_xml)
+  end
+  it 'hash should not have to_query) on it' do
+    Fedora::BaseObject.new
+    {:foo=>:bar}.to_fedora_query.should == 'foo=bar'
+  end
+  
+  it 'should respond to .object_xml' do
+    @test_object.should respond_to(:object_xml)
+  end
+  
+  it "should provide .url" do
+    @test_object.should respond_to(:url)
+  end
+  
+  describe ".url" do
+    it "should return the Repository fedora_url with /objects/pid appended" do
+      Fedora::Repository.instance.expects(:fedora_url).returns(mock("fedora url", :scheme => "_scheme_", :host => "_host_", :port => "_port_", :path => "_path_"))
+      @test_object.expects(:pid).returns("_PID_")
+      @test_object.url.should == "_scheme_://_host_:_port__path_/objects/_PID_"
+    end
+  end
+  
+  describe ".label" do
+    before(:all) do
+      @properties = [:label, :state, :modified_date, :create_date, :owner_id]
+      @sample_attributes = {:label => "label", :state => "state", :modified_date => "modified_date", :create_date => "create_date", :owner_id => "owner_id"}
+    end
+    it "should give preference to pulling from attributes hash" do
+      @test_object.expects(:attributes).times(@properties.length*2).returns(@sample_attributes)
+      @properties.each do |p|
+        @test_object.send(p)
+      end
+    end
+    
+    it "should rely solely on attributes hash if new_object" do
+      @test_object.new_object = true
+      @test_object.expects(:properties_from_fedora).never
+      @test_object.expects(:attributes).times(@properties.length*2).returns(@sample_attributes)
+      @properties.each do |p|
+        @test_object.send(p)
+      end
+    end
+    
+    it "should call properties_from_fedora if not a new_object" do
+      @test_object.new_object = false
+      @test_object.expects(:properties_from_fedora).times(@properties.length).returns(@sample_attributes)
+      @test_object.expects(:attributes).times(@properties.length).returns({})
+      @properties.each do |p|
+        @test_object.send(p)
+      end
+    end
+    
+  end
+
+end

data/spec/unit/inheritance_spec.rb

@@ -0,0 +1,46 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require 'active_fedora/base'
+require 'active_fedora/metadata_datastream'
+require 'active_fedora/qualified_dublin_core_datastream'
+
+describe ActiveFedora::Base do
+  before(:each) do
+    Fedora::Repository.instance.stubs(:nextid).returns("_nextid_")
+    class Foo < ActiveFedora::Base
+      has_metadata :type=>ActiveFedora::MetadataDatastream, :name=>"foostream" do|m|
+        m.field "foostream", :string
+      end
+      has_metadata :type=>ActiveFedora::QualifiedDublinCoreDatastream, :name=>"dcstream" do|m|
+        m.field "fz", :string
+      end
+    end
+    class Bar  < ActiveFedora::Base
+      has_metadata :type=>ActiveFedora::MetadataDatastream, :name=>"barstream" do |m|
+        m.field "barfield", :string
+      end
+    end
+  end
+
+  it "doesn't overwrite stream specs" do
+    f = Foo.new
+    f.datastreams.size.should == 2 #doesn't get dc until saved
+    streams = f.datastreams.values.map(&:class).sort
+#    streams.pop.name.should == "ActiveFedora::Datastream" #dc isn't here till saved
+    streams.pop.name.should == "ActiveFedora::MetadataDatastream"
+    streams.pop.name.should == "ActiveFedora::QualifiedDublinCoreDatastream"
+  end
+
+  it "should work for multiple types" do
+    b = Foo.new
+    f = Bar.new
+    b.class.ds_specs.should_not == f.class.ds_specs
+  end
+  after do
+    Object.send(:remove_const, :Bar)
+    Object.send(:remove_const, :Foo)
+  end
+
+end
+  

data/spec/unit/metadata_datastream_spec.rb

@@ -0,0 +1,290 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require 'active_fedora/metadata_datastream'
+
+# include ActiveFedora::Datastream
+
+describe ActiveFedora::MetadataDatastream do
+
+  before(:all) do
+    @sample_fields = {:publisher => {:values => ["publisher1"], :type => :string}, 
+                      :coverage => {:values => ["coverage1", "coverage2"], :type => :text}, 
+                      :creation_date => {:values => "fake-date", :type => :date},
+                      :mydate => {:values => "fake-date", :type => :date},
+                      :empty_field => {:values => {}}
+                      } 
+    @sample_xml = XmlSimple.xml_in("<fields><coverage>coverage1</coverage><coverage>coverage2</coverage><creation_date>fake-date</creation_date><mydate>fake-date</mydate><publisher>publisher1</publisher></fields>")
+    
+  end
+  
+  before(:each) do
+    @test_ds = ActiveFedora::MetadataDatastream.new
+  end
+  
+  after(:each) do
+  end
+  
+  describe '#new' do
+    it 'should provide #new' do
+      ActiveFedora::MetadataDatastream.should respond_to(:new)
+    end
+  end
+  
+
+  it 'should provide .fields' do
+    @test_ds.should respond_to(:fields)
+  end
+  
+  describe '.save' do
+    it "should provide .save" do
+      @test_ds.should respond_to(:save)
+    end
+    it "should persist the product of .to_xml in fedora" do
+      Fedora::Repository.instance.expects(:save)
+      @test_ds.expects(:to_xml).returns("fake xml")
+      @test_ds.expects(:blob=).with("fake xml")
+      @test_ds.save
+    end
+  end
+  
+  describe '.to_xml' do
+    it "should provide .to_xml" do
+      @test_ds.should respond_to(:to_xml)
+    end
+    it 'should output the fields hash as XML' do
+      @test_ds.expects(:fields).returns(@sample_fields)
+      #sample_rexml = REXML::Document.new(sample_xml)
+      #returned_rexml = REXML::Document.new(@test_ds.to_dc_xml)
+      #returned_rexml.to_s.should == sample_rexml.to_s
+      returned_xml = XmlSimple.xml_in(@test_ds.to_xml)
+      returned_xml.should == @sample_xml
+    end
+    
+    it 'should accept an optional REXML Document as an argument and insert its fields into that' do
+      @test_ds.expects(:fields).returns(@sample_fields)
+      rexml = REXML::Document.new("<test_rexml/>")
+      rexml.root.elements.expects(:add).times(5)
+      result = @test_ds.to_xml(rexml)
+    end
+    it 'should accept an optional REXML Document as an argument and insert its fields into that' do
+      @test_ds.expects(:fields).returns(@sample_fields)
+      rexml = REXML::Document.new("<test_rexml/>")
+      result = @test_ds.to_xml(rexml)
+      XmlSimple.xml_in(rexml.to_s).should == @sample_xml
+      XmlSimple.xml_in(result).should == @sample_xml
+    end
+    
+    it 'should add to root of REXML::Documents, but add directly to the elements if a REXML::Element is passed in' do
+      @test_ds.expects(:fields).returns(@sample_fields).times(2)
+      doc = REXML::Document.new("<test_document/>")
+      el = REXML::Element.new("<test_element/>")
+      doc.root.elements.expects(:add).times(5)
+      el.expects(:add).times(5)
+      @test_ds.to_xml(doc)
+      @test_ds.to_xml(el)
+    end
+    
+  end
+  
+  describe '.set_blob_for_save' do
+    it "should provide .set_blob_for_save" do
+      @test_ds.should respond_to(:set_blob_for_save)
+    end
+    
+    it "should set the blob to to_xml" do
+      @test_ds.expects(:blob=).with(@test_ds.to_xml)
+      @test_ds.set_blob_for_save
+    end
+  end
+  
+  describe '#field' do
+    
+    before(:each) do
+      class SpecDatastream < ActiveFedora::MetadataDatastream
+        def initialize
+        super
+        field :publisher, :string
+        field :coverage, :text
+        field :creation_date, :date
+        field :mydate, :date
+        field :mycomplicated_field, :string, :multiple=>false, :encoding=>'LCSH', :element_attrs=>{:foo=>:bar, :baz=>:bat}
+        end
+      end
+    end
+    
+    after(:each) do
+      Object.send(:remove_const, :SpecDatastream)
+    end
+    
+    it 'should add corresponding field to the @fields hash and set the field :type ' do
+      sds = SpecDatastream.new
+      sds.fields.should_not have_key(:bio)
+      sds.field :bio, :text
+      sds.fields.should have_key(:bio)
+      sds.fields[:bio].should have_key(:type)
+      sds.fields[:bio][:type].should == :text
+      sds.fields[:mycomplicated_field][:element_attrs].should == {:foo=>:bar, :baz=>:bat}
+    end
+    
+    it "should insert custom element attrs into the xml stream" do
+      sds = SpecDatastream.new
+      sds.mycomplicated_field_values='foo'
+      sds.fields[:mycomplicated_field][:element_attrs].should == {:foo=>:bar, :baz=>:bat}
+      sds.to_xml.should == '<fields><mycomplicated_field baz=\'bat\' foo=\'bar\'>foo</mycomplicated_field></fields>'
+    end
+    
+    it "should add getters and setters and appenders with field name" do
+      local_test_ds = SpecDatastream.new
+      local_test_ds.should respond_to(:publisher_values)
+      local_test_ds.should respond_to(:publisher_append)
+      local_test_ds.should respond_to(:publisher_values=)
+      local_test_ds.publisher_values.class.should == Array
+      local_test_ds.should respond_to(:coverage_values)
+      local_test_ds.should respond_to(:coverage_values=)
+      local_test_ds.should respond_to(:coverage_append)
+      local_test_ds.should respond_to(:creation_date_values)
+      local_test_ds.should respond_to(:creation_date_append)
+      local_test_ds.should respond_to(:creation_date_values=)
+      local_test_ds.should respond_to(:mydate_values)
+      local_test_ds.should respond_to(:mydate_append)
+      local_test_ds.should respond_to(:mydate_values=)
+    end
+    
+    it "should track field values at instance level, not at class level" do
+      local_test_ds1 = SpecDatastream.new
+      local_test_ds2 = SpecDatastream.new
+      local_test_ds1.publisher_values = ["publisher1", "publisher2"]
+      local_test_ds2.publisher_values = ["publisherA", "publisherB"]
+      
+      local_test_ds2.publisher_values.should == ["publisherA", "publisherB"]      
+      local_test_ds1.publisher_values.should == ["publisher1", "publisher2"]
+    end
+    
+    it "should allow you to add field values using <<" do
+      local_test_ds1 = SpecDatastream.new
+      local_test_ds1.publisher_values << "publisher1"
+      local_test_ds1.publisher_values.should == ["publisher1"] 
+    end
+    
+    it "should create setter that always turns non-arrays into arrays" do
+      local_test_ds = SpecDatastream.new
+      local_test_ds.publisher_values = "Foo"
+      local_test_ds.publisher_values.should == ["Foo"]
+    end
+    
+    it "should create setter that sets datastream.dirty? to true" do
+      local_test_ds = SpecDatastream.new
+      local_test_ds.should_not be_dirty
+      local_test_ds.publisher_values = "Foo"
+      local_test_ds.should be_dirty
+      
+      # Note: If you use << to append values, the datastream will not be marked as dirty!
+      #local_test_ds.dirty = false
+      
+      #local_test_ds.should_not be_dirty
+      #local_test_ds.publisher_values << "Foo"
+      #local_test_ds.should be_dirty      
+    end
+    
+    it "should add any extra opts to the field hash" do
+      local_test_ds = SpecDatastream.new
+      local_test_ds.field "myfield", :string, :foo => "foo", :bar => "bar"      
+      local_test_ds.fields[:myfield].should have_key(:foo)
+      local_test_ds.fields[:myfield][:foo].should == "foo"
+      local_test_ds.fields[:myfield].should have_key(:bar)
+      local_test_ds.fields[:myfield][:bar].should == "bar"      
+    end
+    
+  end
+  
+  describe ".to_solr" do
+    
+    after(:all) do
+      # Revert to default mappings after running tests
+      ActiveFedora::SolrService.load_mappings
+    end
+    
+    it "should provide .to_solr and return a SolrDocument" do
+      @test_ds.should respond_to(:to_solr)
+      @test_ds.to_solr.should be_kind_of(Solr::Document)
+    end
+    
+    it "should optionally allow you to provide the Solr::Document to add fields to and return that document when done" do
+      doc = Solr::Document.new
+      @test_ds.to_solr(doc).should equal(doc)
+    end
+    
+    it "should iterate through @fields hash" do
+      @test_ds.expects(:fields).returns(@sample_fields)
+      solr_doc =  @test_ds.to_solr
+      
+      solr_doc[:publisher_t].should == "publisher1"
+      solr_doc[:coverage_t].should == "coverage1"
+      solr_doc[:creation_date_dt].should == "fake-date"
+      solr_doc[:mydate_dt].should == "fake-date"
+      
+      solr_doc[:empty_field_t].should be_nil
+    end
+    
+    it "should allow multiple values for a single field"
+    
+    it 'should append create keys in format field_name + _ + field_type' do
+      @test_ds.stubs(:fields).returns(@sample_fields)
+      
+      #should have these
+            
+      @test_ds.to_solr[:publisher_t].should_not be_nil
+      @test_ds.to_solr[:coverage_t].should_not be_nil
+      @test_ds.to_solr[:creation_date_dt].should_not be_nil
+      
+      #should NOT have these
+      @test_ds.to_solr[:narrator].should be_nil
+      @test_ds.to_solr[:title].should be_nil
+      @test_ds.to_solr[:empty_field].should be_nil
+      
+    end
+    
+    it "should use Solr mappings to generate field names" do
+      ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
+      @test_ds.stubs(:fields).returns(@sample_fields)
+      solr_doc =  @test_ds.to_solr
+      
+      #should have these
+            
+      solr_doc[:publisher_field].should == "publisher1"
+      solr_doc[:coverage_field].should == "coverage1"
+      solr_doc[:creation_date_date].should == "fake-date"
+      solr_doc[:mydate_date].should == "fake-date"
+      
+      solr_doc[:publisher_t].should be_nil
+      solr_doc[:coverage_t].should be_nil
+      solr_doc[:creation_date_dt].should be_nil
+      
+      # Reload default mappings
+      ActiveFedora::SolrService.load_mappings
+    end
+    
+    it 'should append _dt to dates' do
+      @test_ds.expects(:fields).returns(@sample_fields).at_least_once
+      
+      #should have these
+      
+      @test_ds.to_solr[:creation_date_dt].should_not be_nil
+      @test_ds.to_solr[:mydate_dt].should_not be_nil
+      
+      #should NOT have these
+      
+      @test_ds.to_solr[:mydate].should be_nil
+      @test_ds.to_solr[:creation_date_date].should be_nil
+    end
+    
+  end
+  
+  describe '.fields' do
+    it "should return a Hash" do
+      @test_ds.fields.should be_instance_of(Hash)
+    end
+  end
+  
+end