active-fedora 1.1.6 → 1.1.7

data/spec/fixtures/mods_articles/hydrangea_article1.xml

@@ -0,0 +1,90 @@
+<mods version="3.0" xsi:schemaLocation="http://www.loc.gov/mods/v3
+ http://www.loc.gov/standards/mods/v3/mods-3-0.xsd" xmlns="http://www.loc.gov/mods/v3" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+    <titleInfo>
+        <nonSort>THE</nonSort>
+        <title>ARTICLE TITLE HYDRANGEA ARTICLE 1</title>
+        <subTitle>SUBTITLE</subTitle>
+    </titleInfo>
+    <titleInfo lang="finnish">
+        <title>Artikkelin otsikko Hydrangea artiklan 1</title>
+    </titleInfo>
+
+    <name type="personal">
+        <namePart type="family">FAMILY NAME</namePart>
+        <namePart type="given">GIVEN NAMES</namePart>
+        <namePart type="termsOfAddress">DR.</namePart>
+        <displayForm>NAME AS IT APPEARS</displayForm>
+        <affiliation>FACULTY, UNIVERSITY</affiliation>    
+        <role> 
+            <roleTerm authority="marcrelator" type="text">creator</roleTerm>
+        </role>
+        <role>
+            <roleTerm type="text">submitter</roleTerm>
+        </role>
+    </name>
+    
+    <name type="personal">
+        <namePart type="family">Gautama</namePart>
+        <namePart type="given">Siddartha</namePart>
+        <namePart type="termsOfAddress">Prince</namePart>
+        <affiliation>Nirvana</affiliation>    
+        <role> 
+            <roleTerm authority="marcrelator" type="text">teacher</roleTerm>
+        </role>
+    </name>
+
+    <typeOfResource>text</typeOfResource>
+    <genre authority="local">journal article</genre>
+
+    <abstract>ABSTRACT</abstract>
+    <subject>
+        <topic>TOPIC 1</topic>
+        <topic>TOPIC 2</topic>
+    </subject>
+    <subject authority="AUTHORITY SOURCE (RFCD, LCSH)">
+        <topic>CONTROLLED TERM</topic>
+    </subject>
+
+    <language>
+        <languageTerm authority="iso639-2b" type="code">en-aus </languageTerm>
+    </language>
+
+    <physicalDescription>
+        <internetMediaType>application/pdf</internetMediaType>
+        <extent>36 p.</extent>
+    </physicalDescription>
+
+    <relatedItem type="host">
+        <titleInfo>
+            <title>TITLE OF HOST JOURNAL</title>
+        </titleInfo>
+        <originInfo>
+            <publisher>PUBLISHER</publisher>
+            <dateIssued>DATE</dateIssued>
+        </originInfo>
+        <identifier type="issn">0013-8908</identifier>    
+        <part>
+            <detail type="volume">
+                <number>2</number>
+            </detail>
+            <detail type="level">
+                <number>2</number>
+            </detail>
+            <extent unit="pages">
+                <start>195</start>
+                <end>230</end>
+            </extent>
+            <date>FEB. 2007</date>
+        </part>            
+    </relatedItem>
+
+    <identifier type="uri">http://URL.edu.au/</identifier>
+    <identifier type="doi">doi:10.1006/jmbi.1995.0238</identifier>
+    <location>
+        <url>http://URL.edu.au/</url>
+    </location>        
+    <accessCondition type="restrictionOnAccess">EMBARGO NOTE</accessCondition>
+    <accessCondition type="use and reproduction">OPEN ACCESS</accessCondition>
+
+</mods>

data/spec/integration/full_featured_model_spec.rb

@@ -1,6 +1,7 @@
 require File.join( File.dirname(__FILE__), "../spec_helper" )
 
 require 'rexml/document'
+require "hydra"
 
 include ActiveFedora
 
@@ -30,6 +31,12 @@ describe ActiveFedora::Base do
           m.field "location", :string
         end
         
+        # has_metadata :name=>"arbitrary_xml", :type=> ActiveFedora::NokogiriDatastream do |m|
+        #   m.root_property :myxml, "my_xml", "http://www.example.gov/schema/v3"
+        # end
+        
+        has_metadata :name=>"mods_article", :type=> Hydra::ModsArticle 
+        
         has_metadata :name => "dublin_core", :type => ActiveFedora::QualifiedDublinCoreDatastream do |m|
           # Default :multiple => true
           #

data/spec/integration/repository_spec.rb

@@ -47,6 +47,10 @@ require File.join( File.dirname(__FILE__),  "../spec_helper" )
 #    curl -i http://localhost:8080/fedora/objects/nextPID.xml -u fedoraAdmin:fedoraAdmin
  
 describe Fedora::Repository, "constructor" do
+  after(:all) do
+    Fedora::Repository.register(ActiveFedora.fedora_config[:url])
+  end
+  
   it "should accept URL as string" do
     fedora_url = "http://fedoraAdmin:fedoraAdmin@127.0.0.1:8080/fedora"
     repository = Fedora::Repository.register(fedora_url)

data/spec/unit/nokogiri_datastream_spec.rb

@@ -1,6 +1,5 @@
 require File.join( File.dirname(__FILE__), "../spec_helper" )
 
-
 describe ActiveFedora::NokogiriDatastream do
   
   before(:all) do
@@ -15,7 +14,7 @@ describe ActiveFedora::NokogiriDatastream do
   end
   
   before(:each) do
-    @test_ds = ActiveFedora::NokogiriDatastream.new
+    @test_ds = ActiveFedora::NokogiriDatastream.new(:blob=>"<test_xml/>")
   end
   
   after(:each) do
@@ -26,6 +25,24 @@ describe ActiveFedora::NokogiriDatastream do
       ActiveFedora::NokogiriDatastream.should respond_to(:new)
       @test_ds.ng_xml.should be_instance_of(Nokogiri::XML::Document)
     end
+    it 'should load xml from blob if provided' do
+      test_ds1 = ActiveFedora::NokogiriDatastream.new(:blob=>"<xml><foo/></xml>")
+      test_ds1.ng_xml.to_xml.should == "<?xml version=\"1.0\"?>\n<xml>\n  <foo/>\n</xml>\n"
+    end
+  end
+  
+  describe '#from_xml' do
+    it "should work when a template datastream is passed in" do
+      mods_xml = Nokogiri::XML::Document.parse( fixture(File.join("mods_articles", "hydrangea_article1.xml")) )
+      tmpl = Hydra::ModsArticle.new
+      Hydra::ModsArticle.from_xml(mods_xml,tmpl).ng_xml.root.to_xml.should == mods_xml.root.to_xml
+    end
+    it "should work when foxml datastream xml is passed in" do
+      pending "at least for now, just updated Base.deserialize to feed in the xml content rather than the foxml datstream xml.  Possibly we can update MetadataDatstream to assume the same and leave it at that? -MZ 23-06-2010"
+      hydrangea_article_foxml = Nokogiri::XML::Document.parse( fixture("hydrangea_fixture_mods_article1.foxml.xml") )
+      ds_xml = hydrangea_article_foxml.at_xpath("//foxml:datastream[@ID='descMetadata']")
+      Hydra::ModsArticle.from_xml(ds_xml).ng_xml.to_xml.should == hydrangea_article_foxml.at_xpath("//foxml:datastream[@ID='descMetadata']/foxml:datastreamVersion[last()]/foxml:xmlContent").first_element_child.to_xml
+    end
   end
   
 
@@ -49,33 +66,35 @@ describe ActiveFedora::NokogiriDatastream 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)
-      returned_xml = XmlSimple.xml_in(@test_ds.to_xml)
-      returned_xml.should == @sample_xml
+    
+    it "should ng_xml.to_xml" do
+      @test_ds.ng_xml.expects(:to_xml).returns("xml")
+      @test_ds.to_xml.should == "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)
+    it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do
+      doc = Nokogiri::XML::Document.parse("<test_document/>")
+      doc.root.expects(:add_child).with(@test_ds.ng_xml.root)
+      @test_ds.to_xml(doc)
     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
+    
+    it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (functional test)' do
+      expected_result = XmlSimple.xml_in("<test_document><foo/><test_xml/></test_document>")
+      doc = Nokogiri::XML::Document.parse("<test_document><foo/></test_document>")
+      result = @test_ds.to_xml(doc)
+      XmlSimple.xml_in(doc.to_s).should == expected_result
+      XmlSimple.xml_in(result).should == expected_result
     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)
+    it 'should add to root of Nokogiri::XML::Documents, but add directly to the elements if a Nokogiri::XML::Node is passed in' do
+      mock_new_node = mock("new node")
+      mock_new_node.stubs(:to_xml).returns("foo")
+      
+      doc = Nokogiri::XML::Document.parse("<test_document/>")
+      el = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
+      doc.root.expects(:add_child).with(@test_ds.ng_xml.root).returns(mock_new_node)
+      el.expects(:add_child).with(@test_ds.ng_xml.root).returns(mock_new_node)
+      @test_ds.to_xml(doc).should 
       @test_ds.to_xml(el)
     end
     
@@ -92,118 +111,6 @@ describe ActiveFedora::NokogiriDatastream do
     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
-    
-    
-    describe ".values" do
-      it "should call ng_xml.values_for(field_name) OR call corresponding lookup method and build an array of values by calling .value on each node in the set"
-    end
-
-    describe ".values<<" do
-      it "should call corresponding builder method"
-    end
-  
-    describe ".values=" do
-      it "should wipe out any existing nodes, use the corresponding builder, and insert new node(s) as the replacement"
-    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
     
@@ -212,7 +119,15 @@ describe ActiveFedora::NokogiriDatastream do
       ActiveFedora::SolrService.load_mappings
     end
     
-    it "should iterate through the class fields, calling .values on each and appending the values to the solr doc"
+    it "should iterate through the class accessors, calling .solrize_accessor on each and passing in the solr doc" do
+      mock_accessors = {:accessor1=>:accessor1_info, :accessor2=>:accessor2_info}
+      ActiveFedora::NokogiriDatastream.stubs(:accessors).returns(mock_accessors)
+      doc = Solr::Document.new
+      mock_accessors.each_pair do |k,v|
+        @test_ds.expects(:solrize_accessor).with(k, v, :solr_doc=>doc)
+      end
+      @test_ds.to_solr(doc)
+    end
     
     it "should provide .to_solr and return a SolrDocument" do
       @test_ds.should respond_to(:to_solr)
@@ -224,76 +139,101 @@ describe ActiveFedora::NokogiriDatastream do
       @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
+  
+  describe ".solrize_accessor" do
+    before(:all) do
+      class AccessorizedDs < ActiveFedora::NokogiriDatastream
+        
+        root_property :mods, "mods", "http://www.loc.gov/mods/v3", :attributes=>["id", "version"], :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"          
+        
+        accessor :title_info, :relative_xpath=>'oxns:titleInfo', :children=>[
+          {:main_title=>{:relative_xpath=>'oxns:title'}},         
+          {:language =>{:relative_xpath=>{:attribute=>"lang"} }}
+          ] 
+        accessor :abstract
+        accessor :topic_tag, :relative_xpath=>'oxns:subject/oxns:topic'
+        accessor :person, :relative_xpath=>'oxns:name[@type="personal"]',  :children=>[
+          {:last_name=>{:relative_xpath=>'oxns:namePart[@type="family"]'}}, 
+          {:first_name=>{:relative_xpath=>'oxns:namePart[@type="given"]'}}, 
+          {:institution=>{:relative_xpath=>'oxns:affiliation'}}, 
+          {:role=>{:children=>[
+            {:text=>{:relative_xpath=>'oxns:roleTerm[@type="text"]'}},
+            {:code=>{:relative_xpath=>'oxns:roleTerm[@type="code"]'}}
+          ]}}
+        ]
+      end
     end
     
-    it "should allow multiple values for a single field"
+    before(:each) do
+      file = fixture(File.join("mods_articles", "hydrangea_article1.xml"))
+      @accessorized_ds = AccessorizedDs.new(:blob=>file)
+    end
     
-    it 'should append create keys in format field_name + _ + field_type' do
-      @test_ds.stubs(:fields).returns(@sample_fields)
+    it "should perform a lookup and iterate over nodes in the result set calling solrize_node then calling solrize_accessor on any of the children, adding accessor_name & node index to parents array" do
+      mock_title_info_set = ["TI1", "TI2"]
+      mock_main_title_set = ["main title"]
+      mock_language_set = ["language"]
       
-      #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
+      solr_doc = Solr::Document.new
       
-      #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
+      AccessorizedDs.expects(:accessor_xpath).with( :title_info ).returns("title_info_xpath")
+      @accessorized_ds.expects(:lookup).with( "title_info_xpath" ).returns(mock_title_info_set)
       
-    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"
+      mock_title_info_set.each do |tin| 
+        node_index = mock_title_info_set.index(tin)
+        @accessorized_ds.expects(:solrize_node).with(tin, [:title_info], solr_doc) 
+        
+        # Couldn't mock the recursive calls to solrize_accessor without preventing the initial one, so was forced to mock out the whole recursive stack.
+        # @accessorized_ds.expects(:solrize_accessor).with(:main_title, AccessorizedDs.accessors[:title_info][:children][:main_title], :parents=>[{:title_info=>node_index}])      
+        # @accessorized_ds.expects(:solrize_accessor).with(:language, AccessorizedDs.accessors[:title_info][:children][:language], :parents=>[{:title_info=>node_index}])
+          AccessorizedDs.expects(:accessor_xpath).with( {:title_info=>node_index}, :main_title ).returns("title_info_main_title_xpath")
+          AccessorizedDs.expects(:accessor_xpath).with( {:title_info=>node_index}, :language ).returns("title_info_language_xpath")
+          @accessorized_ds.expects(:lookup).with( "title_info_main_title_xpath" ).returns(mock_main_title_set)
+          @accessorized_ds.expects(:lookup).with( "title_info_language_xpath" ).returns(mock_language_set)
+          @accessorized_ds.expects(:solrize_node).with("main title", [{:title_info=>node_index}, :main_title], solr_doc) 
+          @accessorized_ds.expects(:solrize_node).with("language", [{:title_info=>node_index}, :language], solr_doc) 
+      end
       
-      solr_doc[:publisher_t].should be_nil
-      solr_doc[:coverage_t].should be_nil
-      solr_doc[:creation_date_dt].should be_nil
+      @accessorized_ds.solrize_accessor(:title_info, AccessorizedDs.accessors[:title_info], :solr_doc=>solr_doc)
       
-      # 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
+    it "should not call solrize_accessor once it reaches an accessor with no children accessors set" do
+      pending "not sure how to test for this"
+      @accessorized_ds.solrize_accessor(:text, AccessorizedDs.accessor_info( [{:person=>1}, :last_name] ), :parents=>[{:person=>1}])
+    end
+    
+    it "should use values form parents array when requesting accessor_xpath and when generating solr field names" do
+      parents_array = [{:person=>0}, {:role=>1}]
+      AccessorizedDs.accessors[:person][:children][:role][:children][:text]
       
+      # This should catch the "submitter" roleTerm from the second role node within the first person node and put it into a solr field called "person_0_role_2_text_0_t" and a solr field called "person_role_text_t"
+      @accessorized_ds.solrize_accessor(:text, AccessorizedDs.accessor_info( *parents_array + [:text] ), :parents=>parents_array)
+    end
+    
+    it "should use Solr mappings to generate field names" do
+
+      solr_doc =  @accessorized_ds.to_solr
       #should have these
+            
+      solr_doc[:abstract_t].should == "ABSTRACT"
+      solr_doc[:title_info_1_language_t].should == "finnish"
+      solr_doc[:person_1_role_0_text_t].should == "teacher"
+      # 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
+      # solr_doc.should == ""
       
-      @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
+  describe ".solrize_node" do
+    it "should create a solr field containing node.text"
+    it "should create hierarchical field entries if parents is not empty"
+    it "should only create one node if parents is empty"
   end
   
 end