active-fedora 9.0.6 → 9.0.8

data/spec/integration/belongs_to_association_spec.rb

@@ -10,6 +10,9 @@ describe ActiveFedora::Base do
       belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasConstituent
     end
     class SpecialInheritedBook < Book
+      def assert_content_model
+        self.has_model = [self.class.to_s, self.class.superclass.to_s]
+      end
     end
 
   end
@@ -73,8 +76,8 @@ describe ActiveFedora::Base do
     end
 
     it "should cast to the most specific class for the association" do
-      @library2.books[0].class == Book
-      @library2.books[1].class == SpecialInheritedBook
+      expect(@library2.books[0]).to be_instance_of Book
+      expect(@library2.books[1]).to be_instance_of SpecialInheritedBook
     end
 
     after do
@@ -90,104 +93,172 @@ describe ActiveFedora::Base do
         belongs_to :complex_collection, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ComplexCollection'
       end
 
-      class ComplexObject < SimpleObject
+      #NOTE: As RDF assertions seem to be returned in alphabetical order, the "Z" is to insure this is stored
+      # after the SimpleObject relationship for this particular case. This is to ensure people don't just change ActiveFedora
+      # to pick the first content model and it works by alphabetical chance.
+      class ZComplexObject < SimpleObject
         belongs_to :simple_collection, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleCollection'
         belongs_to :complex_collection, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ComplexCollection'
+
+        def assert_content_model
+          self.has_model = [self.class.to_s, self.class.superclass.to_s]
+        end
       end
 
       class SimpleCollection < ActiveFedora::Base
         has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleObject', autosave: true
-        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ComplexObject', autosave: true
+        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject', autosave: true
       end
 
       class ComplexCollection < SimpleCollection
         has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleObject', autosave: true
-        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ComplexObject', autosave: true
+        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject', autosave: true
+
+        def assert_content_model
+          self.has_model = [self.class.to_s, self.class.superclass.to_s]
+        end
       end
 
     end
     after :all do
       Object.send(:remove_const, :SimpleObject)
-      Object.send(:remove_const, :ComplexObject)
+      Object.send(:remove_const, :ZComplexObject)
       Object.send(:remove_const, :SimpleCollection)
       Object.send(:remove_const, :ComplexCollection)
     end
 
     describe "saving between the before and after hooks" do
+      let(:complex_object) { ZComplexObject.find(ZComplexObject.create.id) }
+      let(:complex_collection) { ComplexCollection.find(ComplexCollection.create.id) }
+
+      context "Verify that an inherited object will save and retrieve with the correct models" do
+        it "should have added the inverse relationship for the correct class" do
+          expect(complex_object.has_model).to match_array(["SimpleObject", "ZComplexObject"])
+          expect(complex_collection.has_model).to match_array(["SimpleCollection", "ComplexCollection"])
+        end
+      end
+
       context "Add a complex_object into a simple_collection" do
+        let(:simple_collection) { SimpleCollection.create }
+
         before do
-          @simple_collection = SimpleCollection.create
-          @complex_collection = ComplexCollection.create
-          @complex_object = ComplexObject.create
-          @simple_collection.objects = [@complex_object]
-          @simple_collection.save!
-          @complex_collection.save!
+          simple_collection.objects = [complex_object]
+          simple_collection.save!
+          complex_collection.save!
         end
         it "should have added the inverse relationship for the correct class" do
-          expect(@complex_object.simple_collection).to be_instance_of SimpleCollection
-          expect(@complex_object.complex_collection).to be_nil
+          expect(complex_object.simple_collection).to be_instance_of SimpleCollection
+          expect(complex_object.complex_collection).to be_nil
         end
       end
 
       context "Add a complex_object into a complex_collection" do
         before do
-          @complex_collection = ComplexCollection.create
-          @complex_object = ComplexObject.create
-          @complex_collection.objects = [@complex_object] # this sticks it into the :objects association, but since it is a ComplexObject it should also be fetched by :complex_collection association
-          @complex_collection.save
+          complex_collection.objects = [complex_object] # this sticks it into the :objects association, but since it is a ZComplexObject it should also be fetched by :complex_collection association
+          complex_collection.save
         end
 
         it "should have added the inverse relationship for the correct class" do
-          expect(@complex_object.complex_collection).to be_instance_of ComplexCollection
-          expect(@complex_object.reload.simple_collection).to be_instance_of ComplexCollection
+          expect(complex_object.complex_collection).to be_instance_of ComplexCollection
+          expect(complex_object.reload.simple_collection).to be_instance_of ComplexCollection
         end
       end
 
       context "Adding mixed types on a base class with a filtered has_many relationship" do
+        let(:simple_collection) { SimpleCollection.create }
+        let(:simple_object) { SimpleObject.create }
+       
         before do
-          @simple_collection = SimpleCollection.create
-          @complex_object = ComplexObject.create
-          @simple_object = SimpleObject.create
-          @simple_collection.objects = [@complex_object, @simple_object]
-          @simple_collection.save!
+          simple_collection.objects = [complex_object, simple_object]
+          simple_collection.save!
         end
         it "ignores objects who's classes aren't specified" do
-          expect(@simple_collection.complex_objects.size).to eq 1
-          expect(@simple_collection.complex_objects[0]).to be_instance_of ComplexObject
-          expect(@simple_collection.complex_objects[1]).to be_nil
+          expect(simple_collection.complex_objects.size).to eq 1
+          expect(simple_collection.complex_objects[0]).to be_instance_of ZComplexObject
+          expect(simple_collection.complex_objects[1]).to be_nil
 
-          expect(@simple_collection.objects.size).to eq 2
-          expect(@simple_collection.objects[0]).to be_instance_of ComplexObject
-          expect(@simple_collection.objects[1]).to be_instance_of SimpleObject
+          expect(simple_collection.objects.size).to eq 2
+          expect(simple_collection.objects[0]).to be_instance_of ZComplexObject
+          expect(simple_collection.objects[1]).to be_instance_of SimpleObject
 
-          expect(@simple_object.simple_collection).to be_instance_of SimpleCollection
-          expect(@simple_object.complex_collection).to be_nil
+          expect(simple_object.simple_collection).to be_instance_of SimpleCollection
+          expect(simple_object.complex_collection).to be_nil
         end
       end
 
       context "Adding mixed types on a subclass with a filtered has_many relationship" do
-        before do
-          @complex_collection = ComplexCollection.create
-          @complex_object = ComplexObject.create
-          @simple_object = SimpleObject.create
-          @complex_collection.objects = [@complex_object, @simple_object]
-          @complex_collection.save!
+       let(:simple_object) { SimpleObject.create }
+       
+       before do
+          complex_collection.objects = [complex_object, simple_object]
+          complex_collection.save!
         end
         it "ignores objects who's classes aren't specified" do
-          expect(@complex_collection.complex_objects.size).to eq 1
-          expect(@complex_collection.complex_objects[0]).to be_instance_of ComplexObject
-          expect(@complex_collection.complex_objects[1]).to be_nil
+          expect(complex_collection.complex_objects.size).to eq 1
+          expect(complex_collection.complex_objects[0]).to be_instance_of ZComplexObject
+          expect(complex_collection.complex_objects[1]).to be_nil
 
-          expect(@complex_collection.objects.size).to eq 2
-          expect(@complex_collection.objects[0]).to be_instance_of ComplexObject
-          expect(@complex_collection.objects[1]).to be_instance_of SimpleObject
+          expect(complex_collection.objects.size).to eq 2
+          expect(complex_collection.objects[0]).to be_instance_of ZComplexObject
+          expect(complex_collection.objects[1]).to be_instance_of SimpleObject
 
-          expect(@simple_object.complex_collection).to be_instance_of ComplexCollection
-          expect(@simple_object.reload.simple_collection).to be_instance_of ComplexCollection
+          expect(simple_object.complex_collection).to be_instance_of ComplexCollection
+          expect(simple_object.reload.simple_collection).to be_instance_of ComplexCollection
         end
       end
     end
   end
+
+  describe "casting inheritance super class test cases" do
+    before :all do
+      class SuperclassObject < ActiveFedora::Base
+        belongs_to :superclass_collection, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SuperclassCollection'
+
+        def assert_content_model
+          self.has_model = [self.class.to_s, self.class.superclass.to_s]
+        end
+      end
+
+      class SubclassObject < SuperclassObject
+      end
+
+      class SuperclassCollection < ActiveFedora::Base
+        has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SuperclassObject', autosave: true
+      end
+    end
+    after :all do
+      Object.send(:remove_const, :SuperclassObject)
+      Object.send(:remove_const, :SubclassObject)
+      Object.send(:remove_const, :SuperclassCollection)
+    end
+
+    describe "Adding subclass objects" do
+      let(:superclass_collection) { SuperclassCollection.create }
+      let(:superclass_object) { SubclassObject.create }
+
+      context "Add a subclass_object into a superclass_collection" do
+        before do
+          superclass_collection.objects = [subclass_object]
+          superclass_collection.save!
+        end
+        it "should have added the inverse relationship for the correct class" do
+          expect(subclass_object.superclass_collection).to be_instance_of SuperclassCollection
+        end
+      end
+
+      context "Set the superclass_collection of a subclass object"
+        let(:subclass_object) { SubclassObject.create }
+
+        before do
+          subclass_object.superclass_collection = superclass_collection
+          subclass_object.save!
+        end
+        it "should have added the inverse relationship for the correct class" do
+          expect(superclass_collection.objects.size).to eq 1
+          expect(superclass_collection.objects[0]).to be_instance_of SubclassObject
+        end
+      end
+    end
 end
 
 

data/spec/integration/collection_association_spec.rb

@@ -71,4 +71,50 @@ describe ActiveFedora::Base do
     end
   end
 
+  describe "finding the inverse" do
+    context "when no inverse exists" do
+      before do
+        class Item < ActiveFedora::Base
+        end
+        class Container < ActiveFedora::Base
+          has_many :items
+        end
+      end
+      after do
+        Object.send(:remove_const, :Item)
+        Object.send(:remove_const, :Container)
+      end
+
+      let(:instance) { Container.new }
+      subject { instance.items }
+
+      it "raises an error" do
+        expect { subject }.to raise_error "No :inverse_of or :predicate attribute was set or could be inferred for has_many :items on Container"
+      end
+    end
+
+    context "when classes are namespaced" do
+      before do
+        class Item < ActiveFedora::Base
+          has_and_belongs_to_many :container, predicate: ::RDF::DC.extent, class_name: 'Foo::Container'
+        end
+        module Foo
+          class Container < ActiveFedora::Base
+            has_many :items
+          end
+        end
+      end
+      after do
+        Object.send(:remove_const, :Item)
+        Object.send(:remove_const, :Foo)
+      end
+
+      let(:instance) { Foo::Container.new }
+      subject { instance.items }
+
+      it "finds the association" do
+        expect(subject).to eq []
+      end
+    end
+  end
 end

data/spec/integration/has_and_belongs_to_many_associations_spec.rb

@@ -2,109 +2,131 @@ require 'spec_helper'
 
 describe ActiveFedora::Base do
   describe "with inverse" do
-    before do
-      class Book < ActiveFedora::Base
-        has_and_belongs_to_many :topics, predicate: ::RDF::FOAF.primaryTopic, inverse_of: :books
-        has_and_belongs_to_many :collections, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection
+    context "that is also a HABTM" do
+      before do
+        class Book < ActiveFedora::Base
+          has_and_belongs_to_many :topics, predicate: ::RDF::FOAF.primaryTopic, inverse_of: :books
+        end
+
+        class Topic < ActiveFedora::Base
+          has_and_belongs_to_many :books, predicate: ::RDF::FOAF.isPrimaryTopicOf
+        end
       end
 
-      class SpecialInheritedBook < Book
+      after do
+        Object.send(:remove_const, :Book)
+        Object.send(:remove_const, :Topic)
       end
 
+      describe "an unsaved instance" do
+        let(:topic1) { Topic.create }
+        let(:book) { Book.create }
 
-      class Collection < ActiveFedora::Base
-      end
+        it "habtm should set and remove relationships bidirectionally" do
+          book.topics << topic1
+          expect(book.topics).to eq [topic1]
+          expect(topic1.books).to eq [book]
+          expect(topic1.reload.books).to eq [book]
 
-      class Topic < ActiveFedora::Base
-        has_and_belongs_to_many :books, predicate: ::RDF::FOAF.isPrimaryTopicOf
-      end
-    end
+          book.topics.delete(topic1)
+          expect(book.topics).to be_empty
+          expect(topic1.books).to be_empty
+        end
 
-    after do
-      Object.send(:remove_const, :SpecialInheritedBook)
-      Object.send(:remove_const, :Book)
-      Object.send(:remove_const, :Collection)
-      Object.send(:remove_const, :Topic)
-    end
+        it "Should allow for more than 10 items" do
+          (1..12).each do
+            book.topics << Topic.create
+          end
+          book.save
+          expect(book.topics.count).to eq 12
+          book2 = Book.find(book.id)
+          expect(book2.topics.count).to eq 12
+        end
 
-    describe "an unsaved instance" do
-      let(:topic1) { Topic.create }
-      before do
-        @book = Book.create
-      end
+        context "with subclassed objects" do
+          before do
+            class SpecialInheritedBook < Book
+            end
+          end
 
-      it "habtm should set and remove relationships bidirectionally" do
-        @book.topics << topic1
-        expect(@book.topics).to eq [topic1]
-        expect(topic1.books).to eq [@book]
-        expect(topic1.reload.books).to eq [@book]
+          after do
+            Object.send(:remove_const, :SpecialInheritedBook)
+          end
 
-        @book.topics.delete(topic1)
-        expect(@book.topics).to be_empty
-        expect(topic1.books).to be_empty
+          let!(:special_book) { SpecialInheritedBook.create }
+          it "Should find inherited objects along with base objects" do
+            book.topics << topic1
+            special_book.topics << topic1
+            expect(topic1.books).to match_array [book, special_book]
+            expect(topic1.reload.books).to match_array [book, special_book]
+          end
+        end
       end
 
-      it "Should allow for more than 10 items" do
-        (1..12).each do
-          @book.topics << Topic.create
-        end
-        @book.save
-        expect(@book.topics.count).to eq 12
-        book2 = Book.find(@book.id)
-        expect(book2.topics.count).to eq 12
-      end
-
-      context "with subclassed objects" do
-        let!(:special_book) { SpecialInheritedBook.create }
-        it "Should find inherited objects along with base objects" do
-          @book.topics << topic1
-          special_book.topics << topic1
-          expect(topic1.books).to eq [@book, special_book]
-          expect(topic1.reload.books).to eq [@book, special_book]
+      describe "a saved instance" do
+        let!(:book) { Book.create }
+        let!(:topic1) { Topic.create }
+        let!(:topic2) { Topic.create }
+
+        it "should set relationships bidirectionally" do
+          book.topics << topic1
+          expect(book.topics).to eq [topic1]
+          expect(book['topic_ids']).to eq [topic1.id]
+          expect(topic1['book_ids']).to eq [book.id]
+          expect(Topic.find(topic1.id).books).to eq [book] #Can't have saved it because book isn't saved yet.
         end
-      end
 
-      it "Should cast found books to the correct cmodel" do
-        topic1.books[0].class == Book
-        topic1.books[1].class == SpecialInheritedBook
-      end
+        it "should save new child objects" do
+          book.topics << Topic.new
+          expect(book.topics.first.id).to_not be_nil
+        end
 
-    end
+        it "should clear out the old associtions" do
+          book.topics = [topic1]
+          book.topics = [topic2]
+          expect(book.topic_ids).to eq [topic2.id]
+        end
 
-    describe "a saved instance" do
-      let!(:book) { Book.create }
-      let!(:topic1) { Topic.create }
-      let!(:topic2) { Topic.create }
+        context "with members" do
+          before do
+            book.topics = [topic1, topic2]
+            book.save
+          end
 
-      it "should set relationships bidirectionally" do
-        book.topics << topic1
-        expect(book.topics).to eq [topic1]
-        expect(book['topic_ids']).to eq [topic1.id]
-        expect(topic1['book_ids']).to eq [book.id]
-        expect(Topic.find(topic1.id).books).to eq [book] #Can't have saved it because book isn't saved yet.
+          context "destroy" do
+            it "should remove the associations" do
+              book.destroy
+            end
+          end
+        end
       end
+    end
 
-      it "should save new child objects" do
-        book.topics << Topic.new
-        expect(book.topics.first.id).to_not be_nil
+    context "that is a has_many" do
+      before do
+        class Book < ActiveFedora::Base
+          has_many :collections
+        end
+
+        class Collection < ActiveFedora::Base
+          has_and_belongs_to_many :books, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection
+        end
       end
 
-      it "should clear out the old associtions" do
-        book.topics = [topic1]
-        book.topics = [topic2]
-        expect(book.topic_ids).to eq [topic2.id]
+      after do
+        Object.send(:remove_const, :Book)
+        Object.send(:remove_const, :Collection)
       end
 
-      context "with members" do
-        before do
-          book.topics = [topic1, topic2]
-          book.save
-        end
+      describe "add and remove members" do
+        let(:collection) { Collection.create }
+        let(:book) { Book.create }
 
-        context "destroy" do
-          it "should remove the associations" do
-            book.destroy
-          end
+        it "is successful" do
+          collection.books << book
+          expect {
+            collection.books.delete(book)
+          }.to change { collection.books.size }.from(1).to(0)
         end
       end
     end
@@ -297,87 +319,104 @@ describe ActiveFedora::Base do
       end
     end
   end
-end
 
-describe "create" do
-  before do
-    class Book < ActiveFedora::Base
-      has_and_belongs_to_many :collections, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection
-    end
+  describe "create" do
+    before do
+      class Book < ActiveFedora::Base
+        has_and_belongs_to_many :collections, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection
+      end
 
-    class Collection < ActiveFedora::Base
-      property :title, predicate: ::RDF::DC.title
+      class Collection < ActiveFedora::Base
+        property :title, predicate: ::RDF::DC.title
+      end
     end
-  end
 
-  after do
-    Object.send(:remove_const, :Book)
-    Object.send(:remove_const, :Collection)
-  end
+    after do
+      Object.send(:remove_const, :Book)
+      Object.send(:remove_const, :Collection)
+    end
 
-  let(:book) { Book.create }
+    let(:book) { Book.create }
 
-  it "should create" do
-    collection = book.collections.create(title: ["Permanent"])
-    expect(collection).to be_kind_of Collection
-    expect(book.collections).to include collection
-    book.save
-    expect(book.reload.collections.first.title).to eq ['Permanent']
+    it "should create" do
+      collection = book.collections.create(title: ["Permanent"])
+      expect(collection).to be_kind_of Collection
+      expect(book.collections).to include collection
+      book.save
+      expect(book.reload.collections.first.title).to eq ['Permanent']
+    end
   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
+  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
+        has_and_belongs_to_many :items, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
+        has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
+          m.field "description", :string
+        end
+        has_attributes :description, datastream: 'foo'
       end
-      has_attributes :title, datastream: 'foo'
-    end
 
-    class Component < ActiveFedora::Base
-      has_and_belongs_to_many :items, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
-      has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
-        m.field "description", :string
+      after do
+        Object.send(:remove_const, :Item)
+        Object.send(:remove_const, :Component)
       end
-      has_attributes :description, datastream: 'foo'
-    end
-  end
 
-  after do
-    Object.send(:remove_const, :Item)
-    Object.send(:remove_const, :Component)
-  end
+      describe "From the has_and_belongs_to_many side" do
+        describe "dependent records" do
+          let(:component) { Component.create(items: [Item.new(title: 'my title')]) }
+
+          it "should be saved" do
+            component.reload
+            expect(component.items.first.title).to eq 'my title'
+          end
+        end
 
-  describe "From the has_and_belongs_to_many side" do
-    describe "dependent records" do
-      let(:component) { Component.create(items: [Item.new(title: 'my title')]) }
+        describe "shifting" do
+          let(:component) { Component.new }
+          let(:item) { Item.create }
 
-      it "should be saved" do
-        component.reload
-        expect(component.items.first.title).to eq 'my title'
+          it "should set item_ids" do
+            component.items << item
+            expect(component.item_ids).to eq [item.id]
+          end
+        end
       end
-    end
 
-    describe "shifting" do
-      let(:component) { Component.new }
-      let(:item) { Item.create }
+      context "when the has_and_belongs_to_many provides an inverse_of" do
+        let(:reflection) { Component.reflect_on_association(:items) }
+        before do
+          reflection.options[:inverse_of] = :components
+        end
+
+        describe "shifting" do
+          let(:component) { Component.create }
+          let(:item) { Item.new }
 
-      it "should set item_ids" do
-        component.items << item
-        expect(component.item_ids).to eq [item.id]
+          it "should set item_ids" do
+            component.items << item
+            expect(component.item_ids).to eq [item.id]
+          end
+        end
       end
-    end
-  end
 
-  describe "From the has_many side" do
-    let(:item) { Item.create(components: [Component.new(description: 'my description')]) }
+      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
-      expect(item.components.first.description).to eq 'my description'
+        it "should save dependent records" do
+          item.reload
+          expect(item.components.first.description).to eq 'my description'
+        end
+      end
     end
   end
 end