active-fedora 6.8.0 → 7.0.0.pre1

data/spec/integration/has_many_associations_spec.rb

@@ -1,23 +1,82 @@
 require 'spec_helper'
 
-describe 'When two or more relationships share the same property' do
+describe "Looking up collection members" do
+  before :all do
+    class Library < ActiveFedora::Base 
+      has_many :books
+    end
+
+    class Book < ActiveFedora::Base 
+      belongs_to :library, :property=>:has_constituent
+    end
+  end
+  after :all do
+    Object.send(:remove_const, :Book)
+    Object.send(:remove_const, :Library)
+  end
+  describe "of has_many" do
+    let(:book) { Book.create }
+    let(:library) { Library.create() }
+    before do
+      library.books = [book]
+      library.save!
+    end
+    it "should read book_ids from solr" do
+      library.reload.book_ids.should ==[book.pid]
+    end
+    it "should read books from solr" do
+      library.reload.books.should ==[book]
+    end
+  end
+end
+
+describe "After save callbacks" do
+  before :all do
+    class Library < ActiveFedora::Base 
+      has_many :books
+    end
+
+    class Book < ActiveFedora::Base 
+      belongs_to :library, :property=>:has_constituent
+      after_save :find_self
+      attr_accessor :library_books
+
+      def find_self
+        # It's important we have the to_a so that it fetches the relationship immediately instead of lazy loading
+        self.library_books = library.books.to_a
+      end
+    end
+  end
+  after :all do
+    Object.send(:remove_const, :Book)
+    Object.send(:remove_const, :Library)
+  end
+  let(:library) { Library.create() }
+  let(:book) { Book.new(library: library) }
+  it "should have the relationship available in after_save" do
+    book.save!
+    book.library_books.should include book
+  end
+end
+
+describe "When two or more relationships share the same property" do 
   before do
-    class Book < ActiveFedora::Base
-      has_many :collections, :class_name => 'Collection'
+    class Book < ActiveFedora::Base 
+      has_many :collections, :class_name=>'Collection'
       has_many :people
     end
 
     class Person < ActiveFedora::Base
-      belongs_to :book, :property => :is_part_of
+      belongs_to :book, :property=>:is_part_of
     end
 
     class Collection < ActiveFedora::Base
-      belongs_to :book, :property => :is_part_of
+      belongs_to :book, :property=>:is_part_of
     end
 
     @book = Book.create!
-    @person1 = Person.create!(:book => @book)
-    @person2 = Person.create!(:book => @book)
+    @person1 = Person.create!(:book=>@book)
+    @person2 = Person.create!(:book=>@book)
   end
   after do
       Object.send(:remove_const, :Collection)
@@ -25,25 +84,25 @@ describe 'When two or more relationships share the same property' do
       Object.send(:remove_const, :Book)
   end
 
-  it 'Should only return relationships of the correct class' do
+  it "Should only return relationships of the correct class" do
     @book.reload
-    expect(@book.people).to eq([@person1, @person2])
-    expect(@book.collections).to eq([])
+    @book.people.should == [@person1, @person2]
+    @book.collections.should == []
   end
 end
 
-describe 'When relationship is restricted to AF::Base' do
+describe "When relationship is restricted to AF::Base" do
   before do
-    class Email < ActiveFedora::Base
-      has_many :attachments, :property => :is_part_of, :class_name => 'ActiveFedora::Base'
+    class Email < ActiveFedora::Base 
+      has_many :attachments, :property=>:is_part_of, :class_name=>'ActiveFedora::Base'
     end
 
     class Image < ActiveFedora::Base
-      belongs_to :email, :property => :is_part_of
+      belongs_to :email, :property=>:is_part_of
     end
 
     class PDF < ActiveFedora::Base
-      belongs_to :email, :property => :is_part_of
+      belongs_to :email, :property=>:is_part_of
     end
   end
 
@@ -54,19 +113,19 @@ describe 'When relationship is restricted to AF::Base' do
   end
 
 
-  describe 'creating new objects with object relationships' do
+  describe "creating new objects with object relationships" do
     before do
       @book = Email.create!
-      @image = Image.create!(:email => @book)
-      @pdf = PDF.create!(:email => @book)
+      @image = Image.create!(:email=>@book)
+      @pdf = PDF.create!(:email=>@book)
     end
-    it 'Should not restrict relationships ' do
+    it "Should not restrict relationships " do
       @book.reload
-      expect(@book.attachments).to eq([@image, @pdf])
+      @book.attachments.should == [@image, @pdf]
     end
   end
 
-  describe 'creating new objects with id setter' do
+  describe "creating new objects with id setter" do
     let!(:image) { Image.create }
     let!(:email) { Email.create }
     let!(:pdf) { PDF.create }
@@ -77,11 +136,100 @@ describe 'When relationship is restricted to AF::Base' do
       image.destroy
     end
 
-    it 'Should not restrict relationships ' do
-      expect(Deprecation).not_to receive(:warn) # a deprecation in 6.6.0 that's going away in 7.0.0
+    it "Should not restrict relationships " do
       email.attachment_ids = [image.id, pdf.id]
       email.reload
-      expect(email.attachments).to eq([image, pdf])
+      email.attachments.should == [image, pdf]
     end
   end
 end
+
+describe "Deleting a dependent relationship" do
+  before do
+    class Item < ActiveFedora::Base
+      has_many :components, :property => :is_part_of
+    end
+    class Component < ActiveFedora::Base
+      belongs_to :item, :property => :is_part_of
+    end
+  end
+
+  after do
+      Object.send(:remove_const, :Item)
+      Object.send(:remove_const, :Component)
+  end
+
+  let(:item) { Item.create }
+  let(:component) { Component.create }
+
+  it "should remove relationships" do
+    component.item = item
+    component.save!
+    item.components.should == [component]
+    item.components.delete(component)
+    item.reload
+    component.reload
+    component.relationships(:is_part_of).should == []
+    item.components.should == []
+  end
+
+  it "should remove the relationships that point at that object" do
+    component.item = item
+    component.save!
+    item.delete
+    component.reload
+    component.relationships(:is_part_of).should == []
+  end
+
+  it "should only try to delete objects that exist in the datastore (not cached objects)" do
+    item.components << component
+    item.save!
+    component.delete
+    item.delete
+  end
+
+end
+
+describe "Autosave" do
+  before do
+    class Item < ActiveFedora::Base
+      has_many :components
+      has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
+        m.field "title", :string
+      end
+      has_attributes :title, datastream: 'foo'
+    end
+    class Component < ActiveFedora::Base
+      belongs_to :item, :property => :is_part_of
+      has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
+        m.field "description", :string
+      end
+      has_attributes :description, datastream: 'foo'
+    end
+  end
+
+  after do
+      Object.send(:remove_const, :Item)
+      Object.send(:remove_const, :Component)
+  end
+
+  describe "From the belongs_to side" do
+    let(:component) { Component.create(item: Item.new(title: 'my title')) }
+
+    it "should save dependent records" do
+      component.reload
+      component.item.title.should == 'my title'
+    end
+  end
+  describe "From the has_many side" do
+    let(:item) { Item.create(components: [Component.new(description: 'my description')]) }
+
+    it "should save dependent records" do
+      item.reload
+      item.components.first.description.should == 'my description'
+    end
+  end
+
+end
+
+

data/spec/integration/json_serialization_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Objects should be serialized to JSON" do
+  it "should have json results" do
+    ActiveFedora::Base.new.to_json.should == "{\"id\":null}"
+  end
+
+  describe "with a more interesting model" do
+    before do
+      class Foo < ActiveFedora::Base
+        has_metadata 'descMetadata', type: ActiveFedora::SimpleDatastream do |m|
+          m.field "foo", :text
+          m.field "bar", :text
+        end
+        has_attributes :foo, datastream: 'descMetadata', multiple: true
+        has_attributes :bar, datastream: 'descMetadata', multiple: false
+      end
+    end
+    after do
+      Object.send(:remove_const, :Foo)
+    end
+    subject { Foo.new(foo: "baz", bar: 'quix') }
+    before { subject.stub(pid: 'test:123') }
+    it "should have to_json" do
+      json = JSON.parse(subject.to_json)
+      expect(json['id']).to eq "test:123"
+      expect(json['foo']).to eq ["baz"]
+      expect(json['bar']).to eq "quix"
+    end
+  end
+end

data/spec/integration/load_from_solr_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "Loading from solr" do
+  before do
+    class MyDatastream < ActiveFedora::NtriplesRDFDatastream
+      map_predicates do |map|
+        map.title(in: RDF::DC) do |index|
+          index.as :stored_searchable, :facetable
+        end
+        map.date_uploaded(to: "dateSubmitted", in: RDF::DC) do |index|
+          index.type :date
+          index.as :stored_searchable, :sortable
+        end
+        map.identifier(in: RDF::DC) do |index|
+          index.type :integer
+          index.as :stored_searchable, :sortable
+        end
+        map.part(to: "hasPart", in: RDF::DC)
+        map.based_near(in: RDF::FOAF)
+        map.related_url(to: "seeAlso", in: RDF::RDFS)
+      end
+    end
+    class RdfTest < ActiveFedora::Base 
+      has_metadata :name=>'rdf', :type=>MyDatastream
+      has_attributes :based_near, :related_url, :part, :date_uploaded, datastream: 'rdf', multiple: true
+      has_attributes :title, :identifier, datastream: 'rdf', multiple: false
+    end
+  end
+
+  let!(:original) { RdfTest.create!(title: "PLAN 9 FROM OUTER SPACE",
+                                    date_uploaded: Date.parse('1959-01-01'),
+                                   identifier: 12345) }
+
+  after do
+    original.destroy
+    Object.send(:remove_const, :RdfTest)
+    Object.send(:remove_const, :MyDatastream)
+  end
+
+  it "should be able to get indexed properties without loading from fedora" do
+    expect(RdfTest.connection_for_pid('1')).to receive(:datastream_dissemination).never
+    obj = RdfTest.load_instance_from_solr original.pid
+    expect(obj.title).to eq "PLAN 9 FROM OUTER SPACE"
+    expect(obj.date_uploaded).to eq [Date.parse('1959-01-01')]
+    expect(obj.identifier).to eq 12345
+    expect(obj.part).to be_nil # since it wasn't indexed 
+  end
+end

data/spec/integration/model_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 describe ActiveFedora::Model do
-
-  before(:each) do
+  
+  before(:each) do 
     module ModelIntegrationSpec
-
+      
       class Base < ActiveFedora::Base
         include ActiveFedora::Model
         def self.pid_namespace
-          'foo'
+          "foo"
         end
-        has_metadata :name => 'properties', :type => ActiveFedora::SimpleDatastream, :autocreate => true
+        has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream, :autocreate => true 
       end
       class Basic < Base
       end
@@ -18,59 +18,54 @@ describe ActiveFedora::Model do
 
     @test_instance = ModelIntegrationSpec::Basic.new
     @test_instance.save
-
+    
   end
-
+  
   after(:each) do
     @test_instance.delete
     Object.send(:remove_const, :ModelIntegrationSpec)
   end
-
-  describe '#find' do
-    describe 'with :all' do
-      it 'should return an array of instances of the calling Class' do
-        result = ModelIntegrationSpec::Basic.find(:all)
-        expect(result).to be_instance_of(Array)
-        # this test is meaningless if the array length is zero
-        expect(result.length).to be > 0
-        result.each do |obj|
-          expect(obj.class).to eq(ModelIntegrationSpec::Basic)
-        end
+  
+  describe "#all" do
+    it "should return an array of instances of the calling Class" do
+      result = ModelIntegrationSpec::Basic.all.to_a
+      result.should be_instance_of(Array)
+      # this test is meaningless if the array length is zero
+      result.length.should > 0
+      result.each do |obj|
+        obj.class.should == ModelIntegrationSpec::Basic
       end
     end
-    describe '#find with a valid pid with cast' do
-      subject { ActiveFedora::Base.find(@test_instance.pid, :cast => true) }
-      it { is_expected.to be_instance_of ModelIntegrationSpec::Basic}
-    end
-    describe '#find with a valid pid without cast on Base' do
+  end
+
+  describe '#find' do
+    describe "#find with a valid pid without cast" do
       subject { ActiveFedora::Base.find(@test_instance.pid) }
-      before(:each) do
-        expect(Deprecation).to receive(:warn).at_least(1).times
-      end
-      it { is_expected.to be_instance_of ActiveFedora::Base}
+      it { should be_instance_of ModelIntegrationSpec::Basic}
+    end
+    describe "#find with a valid pid with cast of false" do
+      subject { ActiveFedora::Base.find(@test_instance.pid, cast: false) }
+      it { should be_instance_of ActiveFedora::Base}
     end
-    describe '#find with a valid pid without cast on a model extending Base' do
+    describe "#find with a valid pid without cast on a model extending Base" do
       subject { ModelIntegrationSpec::Basic.find(@test_instance.pid) }
-      before(:each) do
-        expect(Deprecation).not_to receive(:warn)
-      end
-      it { is_expected.to be_instance_of ModelIntegrationSpec::Basic}
+      it { should be_instance_of ModelIntegrationSpec::Basic}
     end
   end
 
-  describe '#load_instance_from_solr' do
-    describe 'with a valid pid' do
+  describe "#load_instance_from_solr" do
+    describe "with a valid pid" do
       subject { ActiveFedora::Base.load_instance_from_solr(@test_instance.pid) }
-      it { is_expected.to be_instance_of ModelIntegrationSpec::Basic}
+      it { should be_instance_of ModelIntegrationSpec::Basic}
     end
-    describe 'with metadata datastream spec' do
+    describe "with metadata datastream spec" do
       subject { ActiveFedora::Base.load_instance_from_solr(@test_instance.pid) }
-      it 'should create an xml datastream' do
-        expect(subject.datastreams['properties']).to be_kind_of ActiveFedora::SimpleDatastream
+      it "should create an xml datastream" do
+        subject.datastreams['properties'].should be_kind_of ActiveFedora::SimpleDatastream
       end
 
-      it 'should know the datastreams properties' do
-        expect(subject.properties.dsSize).to eq(9)
+      it "should know the datastreams properties" do
+        subject.properties.dsSize.should == 9
       end
     end
   end

data/spec/integration/nested_attribute_spec.rb

@@ -1,36 +1,35 @@
 require 'spec_helper'
 
-describe 'NestedAttribute behavior' do
+describe "NestedAttribute behavior" do
   before do
     class Bar < ActiveFedora::Base
-      belongs_to :car, :property => :has_member
-      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'someData' do |m|
-        m.field 'uno', :string
-        m.field 'dos', :string
+      belongs_to :car, :property=>:has_member
+      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
+        m.field "uno", :string
+        m.field "dos", :string
       end
-      delegate :uno, to: 'someData', multiple: false
-      delegate :dos, to: 'someData', multiple: false
+      has_attributes :uno, :dos, datastream: 'someData', multiple: false
     end
 
     # base Car class, used in test for association updates and :allow_destroy flag
     class Car < ActiveFedora::Base
-      has_many :bars, :property => :has_member
-      accepts_nested_attributes_for :bars, :allow_destroy => true
+      has_many :bars, :property=>:has_member
+      accepts_nested_attributes_for :bars, :allow_destroy=>true
     end
 
     # class used in test for :reject_if=>:all_blank
     class CarAllBlank < Car
-      accepts_nested_attributes_for :bars, :reject_if => :all_blank
+      accepts_nested_attributes_for :bars, :reject_if=>:all_blank
     end
 
     # class used in test for :reject_if with proc object
     class CarProc < Car
-      accepts_nested_attributes_for :bars, :reject_if => proc { |attributes| attributes['uno'].blank? }
+      accepts_nested_attributes_for :bars, :reject_if=>proc { |attributes| attributes['uno'].blank? }
     end
 
     # class used in test for :reject_if with method name as symbol
     class CarSymbol < Car
-      accepts_nested_attributes_for :bars, :reject_if => :uno_blank
+      accepts_nested_attributes_for :bars, :reject_if=>:uno_blank
 
       def uno_blank(attributes)
         attributes['uno'].blank?
@@ -43,64 +42,64 @@ describe 'NestedAttribute behavior' do
     end
   end
 
-  it 'should have _destroy' do
-    expect(Bar.new._destroy).to be_falsey
+  it "should have _destroy" do
+    Bar.new._destroy.should be_false
   end
 
-  it 'should update the child objects' do
+  it "should update the child objects" do
     @car, @bar1, @bar2 = create_car_with_bars
 
-    @car.attributes = {:bars_attributes => [{:id => @bar1.pid, :uno => 'bar1 uno'}, {:uno => 'newbar uno'}, {:id => @bar2.pid, :_destroy => '1', :uno => 'bar2 uno'}]}
-    expect(Bar.find(@bar1.pid).uno).to eq('bar1 uno')
-    expect(Bar.where(:id => @bar2.pid).first).to be_nil
-    expect(Bar.where(:uno => 'newbar uno').first).not_to be_nil
+    @car.attributes = {:bars_attributes=>[{:id=>@bar1.pid, :uno=>"bar1 uno"}, {:uno=>"newbar uno"}, {:id=>@bar2.pid, :_destroy=>'1', :uno=>'bar2 uno'}]}
+    Bar.find(@bar1.pid).uno.should == 'bar1 uno'
+    Bar.where(:id => @bar2.pid).first.should be_nil
+    Bar.where(:uno => "newbar uno").first.should_not be_nil
 
     bars = @car.bars(true)
-    expect(bars).to include(@bar1)
-    expect(bars).not_to include(@bar2)
+    bars.should include(@bar1)
+    bars.should_not include(@bar2)
   end
 
-  it 'should reject attributes when all blank' do
+  it "should reject attributes when all blank" do
     @car, @bar1, @bar2 = create_car_with_bars(CarAllBlank)
 
-    expect(@car.bars.count).to eq(2)
-    @car.attributes = {:bars_attributes => [{}, {:id => @bar1.pid, :uno => 'bar1 uno'}]}
-    expect(@car.bars(true).count).to eq(2)
+    @car.bars.count.should == 2
+    @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}]}
+    @car.bars(true).count.should == 2
 
     @bar1.reload
-    expect(@bar1.uno).to eq('bar1 uno')
+    @bar1.uno.should == "bar1 uno"
   end
 
-  it 'should reject attributes based on proc' do
+  it "should reject attributes based on proc" do
     @car, @bar1, @bar2 = create_car_with_bars(CarProc)
 
-    @car.attributes = {:bars_attributes => [{}, {:id => @bar1.pid, :uno => 'bar1 uno'}, {:id => @bar2.pid, :dos => 'bar2 dos'}]}
+    @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}, {:id=>@bar2.pid, :dos=>"bar2 dos"}]}
     @bar1.reload
     @bar2.reload
-    expect(@bar1.uno).to eq('bar1 uno')
-    expect(@bar2.dos).to be_nil
+    @bar1.uno.should == "bar1 uno"
+    @bar2.dos.should be_nil
   end
 
-  it 'should reject attributes base on method name' do
+  it "should reject attributes base on method name" do
     @car, @bar1, @bar2 = create_car_with_bars(CarSymbol)
 
-    @car.attributes = {:bars_attributes => [{}, {:id => @bar1.pid, :uno => 'bar1 uno'}, {:id => @bar2.pid, :dos => 'bar2 dos'}]}
+    @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}, {:id=>@bar2.pid, :dos=>"bar2 dos"}]}
     @bar1.reload
     @bar2.reload
-    expect(@bar1.uno).to eq('bar1 uno')
-    expect(@bar2.dos).to be_nil
+    @bar1.uno.should == "bar1 uno"
+    @bar2.dos.should be_nil
   end
 
-  it 'should throw TooManyRecords' do
+  it "should throw TooManyRecords" do
     @car, @bar1, @bar2 = create_car_with_bars(CarWithLimit)
 
-    expect {
-      @car.attributes = {:bars_attributes => [{}]}
-    }.not_to raise_exception
+    lambda {
+      @car.attributes = {:bars_attributes=>[{}]}
+    }.should_not raise_exception
 
-    expect {
-      @car.attributes = {:bars_attributes => [{}, {}]}
-    }.to raise_exception(ActiveFedora::NestedAttributes::TooManyRecords)
+    lambda {
+      @car.attributes = {:bars_attributes=>[{}, {}]}
+    }.should raise_exception(ActiveFedora::NestedAttributes::TooManyRecords)
   end
 
   private
@@ -114,8 +113,8 @@ describe 'NestedAttribute behavior' do
   def create_car_with_bars(car_class = Car, bar_class = Bar)
     car = car_class.new; car.save
 
-    bar1 = bar_class.new(:car => car); bar1.save
-    bar2 = bar_class.new(:car => car); bar2.save
+    bar1 = bar_class.new(:car=>car); bar1.save
+    bar2 = bar_class.new(:car=>car); bar2.save
     [car, bar1, bar2]
   end