active-fedora 6.8.0 → 7.0.0.pre1

data/spec/integration/persistence_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe 'persisting objects' do
+describe "persisting objects" do
   before :all do
     class MockAFBaseRelationship < ActiveFedora::Base
-      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'foo' do |m|
-        m.field 'name', :string
+      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"foo" do |m|
+        m.field "name", :string
       end
-      delegate :name, to: 'foo', multiple: false
+      has_attributes :name, datastream: 'foo', multiple: false
       validates :name, presence: true
     end
   end
@@ -14,9 +14,9 @@ describe 'persisting objects' do
     Object.send(:remove_const, :MockAFBaseRelationship)
   end
 
-  describe '#create!' do
-    it 'should validate' do
-      expect { MockAFBaseRelationship.create!}.to raise_error ActiveFedora::RecordInvalid, "Validation failed: Name can't be blank"
+  describe "#create!" do
+    it "should validate" do
+      lambda { MockAFBaseRelationship.create!}.should raise_error ActiveFedora::RecordInvalid, "Validation failed: Name can't be blank"
     end
   end
 end

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe 'Nesting attribute behavior of RDFDatastream' do
-  describe '.attributes=' do
-    describe 'complex properties' do
-      before do
-        class DummyMADS < RDF::Vocabulary('http://www.loc.gov/mads/rdf/v1#')
+describe "Nesting attribute behavior of RDFDatastream" do
+  describe ".attributes=" do
+    describe "complex properties" do
+      before do 
+        class DummyMADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
           # componentList and Types of components
           property :componentList
           property :Topic
@@ -12,8 +12,8 @@ describe 'Nesting attribute behavior of RDFDatastream' do
           property :PersonalName
           property :CorporateName
           property :ComplexSubject
-
-
+          
+          
           # elementList and elementList values
           property :elementList
           property :elementValue
@@ -26,8 +26,8 @@ describe 'Nesting attribute behavior of RDFDatastream' do
 
         class ComplexRDFDatastream < ActiveFedora::NtriplesRDFDatastream
           map_predicates do |map|
-            map.topic(in: DummyMADS, to: 'Topic', class_name: 'Topic')
-            map.personalName(in: DummyMADS, to: 'PersonalName', class_name: 'PersonalName')
+            map.topic(in: DummyMADS, to: "Topic", class_name:"Topic")
+            map.personalName(in: DummyMADS, to: "PersonalName", class_name:"PersonalName")
             map.title(in: RDF::DC)
           end
 
@@ -36,15 +36,15 @@ describe 'Nesting attribute behavior of RDFDatastream' do
           class Topic
             include ActiveFedora::RdfObject
             map_predicates do |map|
-              map.elementList(in: DummyMADS, class_name: 'ComplexRDFDatastream::ElementList')
+              map.elementList(in: DummyMADS, class_name:"ComplexRDFDatastream::ElementList")
             end
             accepts_nested_attributes_for :elementList
           end
           class PersonalName
             include ActiveFedora::RdfObject
             map_predicates do |map|
-              map.elementList(in: DummyMADS, to: 'elementList', class_name: 'ComplexRDFDatastream::ElementList')
-              map.extraProperty(in: DummyMADS, to: 'elementValue', class_name: 'ComplexRDFDatastream::Topic')
+              map.elementList(in: DummyMADS, to: "elementList", class_name:"ComplexRDFDatastream::ElementList")
+              map.extraProperty(in: DummyMADS, to: "elementValue", class_name:"ComplexRDFDatastream::Topic")
             end
             accepts_nested_attributes_for :elementList, :extraProperty
           end
@@ -52,11 +52,11 @@ describe 'Nesting attribute behavior of RDFDatastream' do
             include ActiveFedora::RdfList
             rdf_type DummyMADS.elementList
             map_predicates do |map|
-              map.topicElement(in: DummyMADS, to: 'TopicElement', :class_name => 'MadsTopicElement')
-              map.temporalElement(in: DummyMADS, to: 'TemporalElement')
-              map.fullNameElement(in: DummyMADS, to: 'FullNameElement')
-              map.dateNameElement(in: DummyMADS, to: 'DateNameElement')
-              map.nameElement(in: DummyMADS, to: 'NameElement')
+              map.topicElement(in: DummyMADS, to: "TopicElement", :class_name => "MadsTopicElement")
+              map.temporalElement(in: DummyMADS, to: "TemporalElement")
+              map.fullNameElement(in: DummyMADS, to: "FullNameElement")
+              map.dateNameElement(in: DummyMADS, to: "DateNameElement")
+              map.nameElement(in: DummyMADS, to: "NameElement")
               map.elementValue(in: DummyMADS)
             end
             accepts_nested_attributes_for :topicElement
@@ -74,58 +74,58 @@ describe 'Nesting attribute behavior of RDFDatastream' do
         Object.send(:remove_const, :ComplexRDFDatastream)
         Object.send(:remove_const, :DummyMADS)
       end
-      subject { ComplexRDFDatastream.new(double('inner object', :pid => 'foo', :new_record? => true), 'descMetadata') }
-      let(:params) do
-        { myResource:
+      subject { ComplexRDFDatastream.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata') }
+      let(:params) do 
+        { myResource: 
           {
             topic_attributes: {
               '0' =>
               {
                 elementList_attributes: [{
-                  topicElement_attributes: [{elementValue: 'Cosmology'}]
+                  topicElement_attributes: [{elementValue:"Cosmology"}]
                   }]
               },
               '1' =>
               {
                 elementList_attributes: [{
-                  topicElement_attributes: {'0' => {elementValue: 'Quantum Behavior'}}
+                  topicElement_attributes: {'0' => {elementValue:"Quantum Behavior"}}
                 }]
               }
             },
             personalName_attributes: [
-              {
+              { 
                 elementList_attributes: [{
-                  fullNameElement: 'Jefferson, Thomas',
-                  dateNameElement: '1743-1826'
+                  fullNameElement: "Jefferson, Thomas",
+                  dateNameElement: "1743-1826"                  
                 }]
-              }
+              } 
               #, "Hemings, Sally"
-            ]
+            ],
           }
         }
       end
 
-      describe 'on lists' do
-        subject { ComplexRDFDatastream::PersonalName.new(RDF::Graph.new) }
-        it 'should accept a hash' do
-          subject.elementList_attributes =  [{ topicElement_attributes: {'0' => { elementValue: 'Quantum Behavior' }, '1' => { elementValue: 'Wave Function' }}}]
-          expect(subject.elementList.first[0].elementValue).to eq(['Quantum Behavior'])
-          expect(subject.elementList.first[1].elementValue).to eq(['Wave Function'])
+      describe "on lists" do
+        subject { ComplexRDFDatastream::PersonalName.new(RDF::Graph.new) } 
+        it "should accept a hash" do
+          subject.elementList_attributes =  [{ topicElement_attributes: {'0' => { elementValue:"Quantum Behavior" }, '1' => { elementValue:"Wave Function" }}}]
+          subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
+          subject.elementList.first[1].elementValue.should == ["Wave Function"]
 
         end
-        it 'should accept an array' do
-          subject.elementList_attributes =  [{ topicElement_attributes: [{ elementValue: 'Quantum Behavior' }, { elementValue: 'Wave Function' }]}]
-          expect(subject.elementList.first[0].elementValue).to eq(['Quantum Behavior'])
-          expect(subject.elementList.first[1].elementValue).to eq(['Wave Function'])
+        it "should accept an array" do
+          subject.elementList_attributes =  [{ topicElement_attributes: [{ elementValue:"Quantum Behavior" }, { elementValue:"Wave Function" }]}]
+          subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
+          subject.elementList.first[1].elementValue.should == ["Wave Function"]
         end
       end
 
-      it 'should create nested objects' do
+      it "should create nested objects" do
           # Replace the graph's contents with the Hash
           subject.attributes = params[:myResource]
 
           # Here's how this would happen if we didn't have attributes=
-          # personal_name = subject.personalName.build
+          # personal_name = subject.personalName.build 
           # elem_list = personal_name.elementList.build
           # elem_list.fullNameElement = "Jefferson, Thomas"
           # elem_list.dateNameElement = "1743-1826"
@@ -133,35 +133,35 @@ describe 'Nesting attribute behavior of RDFDatastream' do
           # elem_list = topic.elementList.build
           # elem_list.fullNameElement = 'Cosmology'
 
-          expect(subject.topic[0].elementList.first[0].elementValue).to eq(['Cosmology'])
-          expect(subject.topic[1].elementList.first[0].elementValue).to eq(['Quantum Behavior'])
-          expect(subject.personalName.first.elementList.first.fullNameElement).to eq(['Jefferson, Thomas'])
-          expect(subject.personalName.first.elementList.first.dateNameElement).to eq(['1743-1826'])
+          subject.topic[0].elementList.first[0].elementValue.should == ["Cosmology"]
+          subject.topic[1].elementList.first[0].elementValue.should == ["Quantum Behavior"]
+          subject.personalName.first.elementList.first.fullNameElement.should == ["Jefferson, Thomas"]
+          subject.personalName.first.elementList.first.dateNameElement.should == ["1743-1826"]
       end
     end
 
-    describe 'with an existing object' do
-      before(:each) do
+    describe "with an existing object" do
+      before(:each) do 
         class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
           map_predicates do |map|
-            map.parts(:in => RDF::DC, :to => 'hasPart', :class_name => 'Component')
+            map.parts(:in=> RDF::DC, :to=>'hasPart', :class_name=>'Component')
           end
           accepts_nested_attributes_for :parts, allow_destroy: true
 
           class Component
             include ActiveFedora::RdfObject
             map_predicates do |map|
-              map.label(:in => RDF::DC, :to => 'title')
+              map.label(:in=> RDF::DC, :to=>'title')
             end
           end
         end
 
       end
-
+      
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
       end
-      subject { SpecDatastream.new(double('inner object', :pid => 'foo', :new_record? => true), 'descMetadata') }
+      subject { SpecDatastream.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata') }
       before do
         subject.attributes = { parts_attributes: [
                                   {label: 'Alternator'},
@@ -172,16 +172,16 @@ describe 'Nesting attribute behavior of RDFDatastream' do
       let (:replace_object_id) { subject.parts[1].rdf_subject.to_s }
       let (:remove_object_id) { subject.parts[3].rdf_subject.to_s }
 
-      it 'should update nested objects' do
-        subject.parts_attributes = [{id: replace_object_id, label: 'Universal Joint'}, {label: 'Oil Pump'}, {id: remove_object_id, _destroy: '1', label: 'bar1 uno'}]
+      it "should update nested objects" do
+        subject.parts_attributes= [{id: replace_object_id, label: "Universal Joint"}, {label:"Oil Pump"}, {id: remove_object_id, _destroy: '1', label: "bar1 uno"}]
 
-        expect(subject.parts.map{|p| p.label.first}).to eq(['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump'])
+        subject.parts.map{|p| p.label.first}.should == ['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump']
 
       end
-      it 'create a new object when the id is provided' do
-       subject.parts_attributes = [{id: 'http://example.com/part#1', label: 'Universal Joint'}]
-       expect(subject.parts.last.rdf_subject).to eq('http://example.com/part#1')
+      it "create a new object when the id is provided" do
+       subject.parts_attributes= [{id: 'http://example.com/part#1', label: "Universal Joint"}]
+       subject.parts.last.rdf_subject.should == 'http://example.com/part#1'
       end
-    end
+    end    
   end
 end

data/spec/integration/relation_delegation_spec.rb

@@ -1,65 +1,66 @@
 require 'spec_helper'
 
 describe ActiveFedora::Model do
-
-  before(:all) do
+  
+  before(:all) do 
     module ModelIntegrationSpec
       class Basic < ActiveFedora::Base
-        has_metadata :name => 'properties', :type => ActiveFedora::SimpleDatastream do |m|
-          m.field 'foo', :string
-          m.field 'bar', :string
-          m.field 'baz', :string
+        has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream do |m|
+          m.field "foo", :string
+          m.field "bar", :string
+          m.field "baz", :string
         end
 
-        delegate_to :properties, [:foo, :bar, :baz], multiple: true
+        has_attributes :foo, :bar, :baz, datastream: 'properties', multiple: true
 
         def to_solr(doc = {})
           doc = super
           doc[ActiveFedora::SolrService.solr_name('foo', :sortable)] = doc[ActiveFedora::SolrService.solr_name('foo', type: :string)]
           doc
         end
-
       end
     end
 
   end
-
+  
   after(:all) do
     Object.send(:remove_const, :ModelIntegrationSpec)
   end
 
 
-  describe 'with multiple objects' do
-    let!(:instance1){ ModelIntegrationSpec::Basic.create!(:foo => 'Beta', :bar => 'Chips')}
-    let!(:instance2){ ModelIntegrationSpec::Basic.create!(:foo => 'Alpha', :bar => 'Peanuts')}
-    let!(:instance3){ ModelIntegrationSpec::Basic.create!(:foo => 'Sigma', :bar => 'Peanuts')}
+  describe "with multiple objects" do
+    let!(:instance1){ ModelIntegrationSpec::Basic.create!(:foo=>'Beta', :bar=>'Chips')}
+    let!(:instance2){ ModelIntegrationSpec::Basic.create!(:foo=>'Alpha', :bar=>'Peanuts')}
+    let!(:instance3){ ModelIntegrationSpec::Basic.create!(:foo=>'Sigma', :bar=>'Peanuts')}
 
     after { ModelIntegrationSpec::Basic.delete_all }
 
     subject { ModelIntegrationSpec::Basic.where(bar: 'Peanuts') }
 
-    it 'should map' do
-      expect(subject.map(&:id)).to eq([instance2.id, instance3.id])
+    it "should map" do
+      subject.map(&:id).should == [instance2.id, instance3.id]
     end
 
-    it 'should collect' do
-      expect(subject.collect(&:id)).to eq([instance2.id, instance3.id])
+    it "should collect" do
+      subject.collect(&:id).should == [instance2.id, instance3.id]
     end
 
-    it 'should have each' do
+    it "should have each" do
       t = double
-      expect(t).to receive(:foo).twice
+      t.should_receive(:foo).twice
       subject.each { t.foo }
     end
 
-    it 'should have all?' do
-      expect(subject.all? { |t| t.foo == ['Alpha']}).to be_falsey
-      expect(subject.all? { |t| t.bar == ['Peanuts']}).to be_truthy
+    it "should have all?" do
+      expect(subject.all? { |t| t.foo == ['Alpha']}).to be_false
+      expect(subject.all? { |t| t.bar == ['Peanuts']}).to be_true
     end
 
-    it 'should have include?' do
-      expect(subject.include?(instance1)).to be_falsey
-      expect(subject.include?(instance2)).to be_truthy
+    it "should have include?" do
+      expect(subject.include?(instance1)).to be_false
+      expect(subject.include?(instance2)).to be_true
     end
   end
 end
+
+

data/spec/integration/relation_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe ActiveFedora::Base do
+  before :all do
+    class Library < ActiveFedora::Base 
+      has_many :books, property: :has_member
+    end
+    class Book < ActiveFedora::Base; end
+  end
+  after :all do
+    Library.delete_all
+    Object.send(:remove_const, :Library)
+    Object.send(:remove_const, :Book)
+  end
+
+  subject {Library.all} 
+  its(:class) {should eq ActiveFedora::Relation }
+
+  describe "#find" do
+    before do
+      Library.create
+      @library = Library.create
+    end
+    it "should find one of them" do
+      expect(subject.find(@library.id)).to eq @library
+    end
+    it "should find with a block" do
+      expect(subject.find { |l| l.id == @library.id}).to eq @library
+    end
+  end
+
+  describe "#select" do
+    before do
+      Library.create
+      @library = Library.create
+    end
+    it "should find with a block" do
+      expect(subject.select { |l| l.id == @library.id}).to eq [@library]
+    end
+  end
+end
+

data/spec/integration/rels_ext_datastream_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 require 'active_fedora'
-require 'rexml/document'
+require "rexml/document"
 
 
 describe ActiveFedora::RelsExtDatastream do
-
+  
   before(:all) do
-    @sample_relationships_hash = Hash.new(:is_member_of => ['info:fedora/demo:5', 'info:fedora/demo:10'])
+    @sample_relationships_hash = Hash.new(:is_member_of => ["info:fedora/demo:5", "info:fedora/demo:10"])
     @sample_xml_string = <<-EOS
     <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
       <rdf:Description rdf:about="info:fedora/changeme:475">
@@ -16,17 +16,17 @@ describe ActiveFedora::RelsExtDatastream do
       </rdf:Description>
     </rdf:RDF>
     EOS
-
+  
     @sample_xml = REXML::Document.new(@sample_xml_string)
   end
-
+  
   before(:each) do
     @test_object = ActiveFedora::Base.new
     @test_datastream = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
     @test_datastream.model = @test_object
     @test_object.save
   end
-
+  
   after(:each) do
     begin
     @test_object.delete
@@ -49,34 +49,34 @@ describe ActiveFedora::RelsExtDatastream do
     rescue
     end
   end
-
-
+  
+  
   describe '#serialize!' do
-
-    it 'should generate new rdf/xml as the datastream content' do
+    
+    it "should generate new rdf/xml as the datastream content" do
       @test_object.add_datastream(@test_datastream)
-      @test_object.add_relationship(:is_member_of, 'info:fedora/demo:5')
-      @test_object.add_relationship(:is_member_of, 'info:fedora/demo:10')
+      @test_object.add_relationship(:is_member_of, "info:fedora/demo:5")
+      @test_object.add_relationship(:is_member_of, "info:fedora/demo:10")
       rexml1 = REXML::Document.new(@test_datastream.to_rels_ext())
       @test_datastream.serialize!
-      rexml2 = REXML::Document.new(@test_object.datastreams['RELS-EXT'].content)
-      expect(rexml1.root.elements['rdf:Description'].inspect).to eql(rexml2.root.elements['rdf:Description'].inspect)
+      rexml2 = REXML::Document.new(@test_object.datastreams["RELS-EXT"].content)
+      rexml1.root.elements["rdf:Description"].inspect.should eql(rexml2.root.elements["rdf:Description"].inspect)
     end
-
+  
   end
-
-  it 'should load relationships from fedora into parent object' do
+  
+  it "should load relationships from fedora into parent object" do
     class SpecNode; include ActiveFedora::SemanticNode; end
-    ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace].each_key do |p|
+    ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace].each_key do |p| 
       @test_object.add_relationship(p, "info:fedora/demo:#{rand(100)}")
     end
     @test_object.save
     # make sure that _something_ was actually added to the object's relationships hash
-    expect(@test_object.ids_for_outbound(:is_member_of).size).to eq(1)
+    @test_object.ids_for_outbound(:is_member_of).size.should == 1
     new_rels = ActiveFedora::Base.find(@test_object.pid).relationships
     # This stopped working, need to push an issue into the rdf library. (when dumping ntriples, the order of assertions changed)
     #new_rels.should == @test_object.relationships
-    expect(new_rels.dump(:rdfxml)).to eq(@test_object.relationships.dump(:rdfxml))
+    new_rels.dump(:rdfxml).should == @test_object.relationships.dump(:rdfxml)
   end
 
 end