active-fedora 1.0.5 → 1.1.0

data/spec/unit/model_spec.rb

@@ -0,0 +1,186 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require 'active_fedora/model'
+require "rexml/document"
+require 'ftools'
+require 'mocha'
+
+
+describe ActiveFedora::Model do
+  
+  before(:all) do
+    module SpecModel
+      class Basic
+        include ActiveFedora::Model
+      end
+    end
+    @test_property = ActiveFedora::Property.new("foo_model","test_property", :text)
+  end
+  
+  before(:each) do 
+    Fedora::Repository.instance.stubs(:nextid).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
+  
+  describe "#attribute_set" do
+    it "should look up the property's ivar name from properties hash" do
+      pending
+      SpecModel::Basic.expects(:properties).with(@test_property.name)
+      SpecModel::Basic.expects(:set_instance_variable).with(@test_property.instance_variable_name, "new value")
+      SpecModel::Basic.attribute_set(@test_property.name, "new value")
+    end
+  end
+  
+  describe "#attribute_get" do
+    it "should look up the property's ivar name from properties hash" do
+      pending
+      SpecModel::Basic.expects(:properties).with(@test_property.name)
+      SpecModel::Basic.expects(:get_instance_variable).with(@test_property.instance_variable_name)
+      SpecModel::Basic.attribute_get(@test_property.name, "new value")
+    end
+  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
+  
+  it 'should provide #find' do
+    SpecModel::Basic.should respond_to(:find)
+  end
+  
+  describe '#find' do
+    
+    it "(:all) should query solr for all objects with :active_fedora_model_s of self.class" do
+      mock_solr = mock("SolrConnection")
+      mock_result = mock("MockResult")
+      mock_result.expects(:hits).returns([{"id" => "changeme:30"}, {"id" => "changeme:22"}])
+      mock_solr.expects(:query).with('active_fedora_model_s:SpecModel\:\:Basic').returns(mock_result)
+      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
+      Fedora::Repository.instance.expects(:find_model).with("changeme:30", SpecModel::Basic).returns("Fake Object")
+      Fedora::Repository.instance.expects(:find_model).with("changeme:22", SpecModel::Basic).returns("Fake Object")
+      SpecModel::Basic.find(:all)
+    end
+    
+    it "(String) should query solr for an object with the given id and return that object" do
+      mock_solr = mock("SolrConnection")
+      mock_result = mock("MockResult")
+      mock_result.expects(:hits).returns([{"id" => "changeme:30"}])
+      mock_solr.expects(:query).with('id:changeme\:30').returns(mock_result)
+      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
+      Fedora::Repository.instance.expects(:find_model).with("changeme:30", SpecModel::Basic).returns("Fake Object")
+    
+      SpecModel::Basic.find("changeme:30").should == "Fake Object"
+    end
+    
+    it 'should not call #new' do
+      mock_solr = mock("SolrConnection")
+      mock_result = mock("MockResult")
+      mock_result.expects(:hits).returns([{"id" => "changeme:30"}])
+      mock_solr.expects(:query).with('id:changeme\:30').returns(mock_result)
+      Fedora::Repository.instance.expects(:find_model).with("changeme:30", SpecModel::Basic).returns("fake object")
+
+      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
+    
+      res = SpecModel::Basic.find("changeme:30")
+    end
+    
+    describe"(:pid => xxx)" do 
+      it "should pull the inner object from fedora if it already exists in fedora" do
+        pending
+        Fedora::Repository.instance.expects(:save).never
+        mock_obj = mock("Fedora Object")
+        Fedora::Repository.instance.expects(:find_objects).returns([mock_obj])
+        ActiveFedora::Base.new(:pid=>"test:1").inner_object.should equal(mock_obj)
+      end
+      it "should save the inner_object to fedora if it does not already exist" do
+        pending
+        Fedora::Repository.instance.expects(:save)
+        Fedora::Repository.instance.expects(:find_objects).returns([])
+        ActiveFedora::Base.new(:pid=>"test:1")
+      end
+    end
+    
+  end
+  
+  
+  it 'should provide #find_by_solr' do
+    SpecModel::Basic.should respond_to(:find)
+  end
+  
+  describe '#find_by_solr' do
+    it "(:all) should query solr for all objects with :active_fedora_model_s of self.class and return a Solr result" do
+      mock_solr = mock("SolrConnection")
+      mock_response = mock("SolrResponse")
+      mock_solr.expects(:query).with('active_fedora_model_s:SpecModel\:\:Basic', {}).returns(mock_response)
+      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
+    
+      SpecModel::Basic.find_by_solr(:all).should equal(mock_response)
+    end
+    it "(String) should query solr for an object with the given id and return the Solr Result" do
+      mock_solr = mock("SolrConnection")
+      mock_response = mock("SolrResponse")
+      mock_solr.expects(:query).with('id:changeme\:30', {}).returns(mock_response)
+      ActiveFedora::SolrService.expects(:instance).returns(mock("SolrService", :conn => mock_solr))
+    
+      SpecModel::Basic.find_by_solr("changeme:30").should equal(mock_response)
+    end
+  end
+  
+  describe "load_instance" do
+    it "should use Repository.find_model to instantiate an object" do
+      mock_repo = mock("repo")
+      mock_repo.expects(:find_model).with("_PID_", SpecModel::Basic)
+      Fedora::Repository.expects(:instance).returns(mock_repo) 
+      SpecModel::Basic.load_instance("_PID_")
+    end
+  end
+end

data/spec/unit/property_spec.rb

@@ -0,0 +1,50 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require 'active_fedora/model'
+require 'mocha'
+include Mocha::Standalone
+
+describe ActiveFedora::Property do
+  
+  before(:all) do
+    @test_property = ActiveFedora::Property.new(stub("model_stub"),"file_name", :string)
+  end
+  
+  it 'should provide .new' do
+    ActiveFedora::Property.should respond_to(:new)
+  end
+
+  describe '.new' do
+    
+    it 'should use assertions to check types of incoming args'
+    
+    # This could rely on property_set and in turn serialize to a 'properties' metadata datastream...
+    it 'should add corresponding field to the properties datastream'
+      
+    it 'should add field to repository indexer (ie. solr)'
+  end
+  
+  it 'should provide .name' do
+    ActiveFedora::Property.should respond_to(:name)
+  end
+
+  describe '.name' do
+    it 'should return the value of the name attribute' do
+      
+    end
+  end
+  
+  it 'should provide .instance_variable_name' do
+    #ActiveFedora::Property.should respond_to(:instance_variable_name)
+    
+    @test_property.should respond_to(:instance_variable_name)
+  end
+
+  describe '.instance_variable_name' do
+    it 'should return the value of the name attribute with an @ appended' do
+      @test_property.instance_variable_name.should eql("@#{@test_property.name}")
+    end
+  end
+  
+end

data/spec/unit/qualified_dublin_core_datastream_spec.rb

@@ -0,0 +1,177 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require 'xmlsimple'
+
+describe ActiveFedora::QualifiedDublinCoreDatastream do
+
+  before(:all) do
+    # Load Sample OralHistory Model
+    require File.join( File.dirname(__FILE__), "..", "samples","oral_history_sample_model" )
+    @dc_elements = [:contributor, :coverage, :creator, :date, :description, :format, :identifier, :language, :publisher, :relation, :rights, :source]
+    @dc_terms = []
+  end
+  
+  before(:each) do
+    Fedora::Repository.instance.stubs(:nextid).returns("_nextid_")
+    @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.new
+  end
+  it "from_xml should parse everything correctly" do
+    #originally just tested that lcsh encoding and stuff worked, but the other stuff is worth testing
+    mockr= mock('repo')
+    mockr.expects(:nextid).returns("meh:leh")
+    Fedora::Repository.stubs(:instance).returns(mockr)
+    tmpl = OralHistorySampleModel.new.datastreams['dublin_core']
+
+    tmpl.expects(:subject_append).with('sh1')
+    tmpl.expects(:subject_append).with('sh2')
+    tmpl.expects(:subject_append).with('kw2')
+    tmpl.expects(:subject_append).with('kw1')
+    tmpl.expects(:spatial_append).with('sp1')
+    tmpl.expects(:spatial_append).with('sp2')
+    tmpl.expects(:language_append).with('English')
+    tmpl.expects(:alternative_append).with('alt')
+    tmpl.expects(:title_append).with('title')
+    tmpl.expects(:temporal_append).with('tmp')
+    tmpl.expects(:extent_append).with('extent')
+    tmpl.expects(:medium_append).with('medium')
+    tmpl.expects(:format_append).with('audio/x-wav')
+    tmpl.expects(:subject_heading_append).with('sh1')
+    tmpl.expects(:subject_heading_append).with('sh2')
+    tmpl.expects(:creator_append).with('creator')
+    tmpl.expects(:type_append).with('sound')
+    tmpl.expects(:rights_append).with('rights')
+    tmpl.expects(:publisher_append).with('jwa')
+    tmpl.expects(:description_append).with('desc')
+
+    sample = File.join(File.dirname(__FILE__), '../samples/oh_qdc.xml')
+    z = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(tmpl, REXML::Document.new(File.open(sample)).root.elements.first)
+    z.should === tmpl
+  end
+
+  it "should create the right number of fields" do
+    ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS.size.should == 65
+  end
+
+  it "should have unmodifiable constants" do
+    proc {ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS<<:foo}.should raise_error(TypeError, 'can\'t modify frozen array')
+
+  end
+
+  it "should have identity in and out" do
+    sample = File.join(File.dirname(__FILE__), '../samples/oh_qdc.xml')
+    tmpl = OralHistorySampleModel.new.datastreams['dublin_core']
+    z = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(tmpl, REXML::Document.new(File.open(sample)).root.elements.first)
+    y = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(tmpl, REXML::Document.new(z.to_dc_xml))
+    y.to_dc_xml.should == z.to_dc_xml
+  end
+
+  it "should handle arbitrary attribs" do
+    tmpl = OralHistorySampleModel.new.datastreams['dublin_core']
+    tmpl.field :mycomplicated, :string, :xml_node=>'alt', :element_attrs=>{:foo=>'bar'}
+    tmpl.mycomplicated_values='fubar'
+    tmpl.to_dc_xml.should == '<dc xmlns:xsi=\'http://www.w3.org/2001/XMLSchema-instance\' xmlns:dcterms=\'http://purl.org/dc/terms/\'><dcterms:alt foo=\'bar\'>fubar</dcterms:alt></dc>'
+
+  end
+
+
+
+  it "should parse dcterms and dcelements from xml" do
+    doc = REXML::Document.new(File.open(File.dirname(__FILE__)+'/../fixtures/changeme155.xml'), :force_array=>true)
+    stream = doc.elements['//foxml:datastream[@ID=\'dublin_core\']']
+    n = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(ActiveFedora::QualifiedDublinCoreDatastream.new, stream)
+    n.spatial_values.should == ["Boston [7013445]", "Dorchester [7013575]", "Roxbury [7015002]"] 
+    n.title_values.should ==  ["Oral history with Frances Addelson, 1997 November 14"]
+    n.dirty?.should == false
+
+  end
+
+
+  it "should default dc elements to :multiple=>true" do
+    @test_ds.fields.values.each do |s|
+      s.has_key?(:multiple).should == true
+    end
+  end
+  
+  after(:each) do
+  end
+  
+  describe '#new' do
+    it 'should provide #new' do
+      ActiveFedora::QualifiedDublinCoreDatastream.should respond_to(:new)
+    end
+    
+    it 'should initialize an object with fields for all DC elements' do
+      @dc_elements.each do |el|
+        @test_ds.fields.should_not be_nil
+        @test_ds.fields.should have_key("#{el.to_s}".to_sym)
+      end
+    end
+    
+    it 'should respond to getters and setters for all DC elements' do
+      @dc_elements.each do |el|
+        @test_ds.should respond_to("#{el.to_s}_values")
+        @test_ds.should respond_to("#{el.to_s}_values=") 
+        eval("@test_ds.#{el.to_s}_values").class.should == Array  
+        eval("@test_ds.#{el.to_s}_values = ['test_value']").should == ['test_value']
+      end
+    end
+    
+  end
+  
+  describe '.set_blob_for_save' do
+    it "should call .blob= with to_dc_xml" do
+      @test_ds.expects(:blob=).with(@test_ds.to_dc_xml)
+      @test_ds.set_blob_for_save
+    end
+  end
+  
+  describe '.to_dc_xml' do
+    
+    it 'should respond to .to_dc_xml' do
+      @test_ds.should respond_to(:to_dc_xml)
+    end
+
+
+    #
+    # I think the fields should just be tracked as a REXML::Document internally.  Too much BS otherwise.
+    #
+
+
+    it 'should output the fields hash as Qualified Dublin Core XML' do
+      sample_xml = "<dc xmlns:dcterms='http://purl.org/dc/terms/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><dcterms:title>title1</dcterms:title><dcterms:publisher>publisher1</dcterms:publisher><dcterms:creator>creator1</dcterms:creator><dcterms:creator>creator2</dcterms:creator></dc>"
+      #@test_ds.expects(:fields).returns({:publisher => ["publisher1"], :creator => ["creator1", "creator2"], :title => ["title1"]})
+      @test_ds.publisher_values = ["publisher1"]
+      @test_ds.creator_values = ["creator1", "creator2"]
+      @test_ds.title_values = ["title1"]
+
+      dc_xml = XmlSimple.xml_in(@test_ds.to_dc_xml)
+      dc_xml.should == XmlSimple.xml_in(sample_xml)
+    end
+
+    it 'should not include :type information' do
+      @test_ds.publisher_values = ["publisher1"]
+      dc_xml = XmlSimple.xml_in(@test_ds.to_dc_xml)
+      @test_ds.fields[:publisher].should have_key(:type)
+      dc_xml["publisher"].should_not include("type")
+    end
+
+    it "should use specified :xml_node if it is available in the field Hash" do
+      @test_ds.stubs(:fields).returns({:myfieldname => {:values => ["sample spatial coverage"], :xml_node => "nodename" }})
+      REXML::Document.new(@test_ds.to_dc_xml).elements['./dc/dcterms:nodename'].text.should ==  'sample spatial coverage'
+    end
+
+    it "should use specified :xml_node if it was specified when .field was called" do
+      sample_xml = "<dc xmlns:dcterms='http://purl.org/dc/terms/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><dcterms:nodename>sample spatial coverage</dcterms:nodename></dc>"
+      @test_ds.field :myfieldname, :string, :xml_node => "nodename"
+      @test_ds.myfieldname_values = "sample spatial coverage"
+      dc_xml = XmlSimple.xml_in(@test_ds.to_dc_xml)
+      dc_xml.should == XmlSimple.xml_in(sample_xml)
+    end
+
+    it "should only apply encoding info and other qualifiers to the nodes that explicitly declare it" do
+    end
+  end
+
+
+end

data/spec/unit/relationship_spec.rb

@@ -0,0 +1,77 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require "rexml/document"
+require 'mocha'
+
+include Mocha::Standalone
+
+describe ActiveFedora::Relationship do
+  
+  %/
+  module ModelSpec
+    class AudioRecord
+      include ActiveFedora::Model
+
+      relationship "parents", :is_part_of, [nil, :oral_history]      
+    end
+    
+    class OralHistory
+      include ActiveFedora::Model
+      
+      relationship "parts", :is_part_of, [:audio_record], :inbound => true
+  end
+  /%
+  before(:each) do
+    @test_relationship = ActiveFedora::Relationship.new
+  end
+  
+  it "should provide #new" do
+    ActiveFedora::Relationship.should respond_to(:new)
+  end
+  
+  describe "#new" do
+    test_relationship = ActiveFedora::Relationship.new(:subject => "demo:5", :predicate => "isMemberOf", :object => "demo:10")
+    
+    test_relationship.subject.should == "info:fedora/demo:5"
+    test_relationship.predicate.should == "isMemberOf"
+    test_relationship.object.should == "info:fedora/demo:10"
+  end
+  
+  describe "#subject=" do
+    it "should turn strings into fedora URIs" do
+      @test_relationship.subject = "demo:6"
+      @test_relationship.subject.should == "info:fedora/demo:6"
+      @test_relationship.subject = "info:fedora/demo:7"
+      @test_relationship.subject.should == "info:fedora/demo:7"
+    end
+    it "should use the pid of the passed object if it responds to #pid" do
+      mock_fedora_object = stub("mock_fedora_object", :pid => "demo:stub_pid")
+      @test_relationship.subject = mock_fedora_object
+      @test_relationship.subject.should == "info:fedora/#{mock_fedora_object.pid}"
+    end
+  end
+  
+  describe "#object=" do
+    it "should turn strings into Fedora URIs" do
+      @test_relationship.object = "demo:11"
+      @test_relationship.object.should == "info:fedora/demo:11"
+    end
+    it "should use the pid of the passed object if it responds to #pid" do
+      mock_fedora_object = stub("mock_fedora_object", :pid => "demo:stub_pid")
+      @test_relationship.object = mock_fedora_object
+      @test_relationship.object.should == "info:fedora/#{mock_fedora_object.pid}"
+    end  end
+  
+  describe "#predicate=" do
+    it "should default to setting the argument itself as the new subject" do
+      @test_relationship.predicate = "isComponentOf"
+      @test_relationship.predicate.should == "isComponentOf"
+    end
+  end
+  
+  describe "#to_hash" do
+    it "should return a hash of structure {subject => {predicate => [object]}}"
+  end
+  
+end