active-fedora 8.7.0 → 9.0.0.beta1

data/spec/integration/has_and_belongs_to_many_associations_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe ActiveFedora::Base do
   describe "with inverse" do
     before do
-      class Book < ActiveFedora::Base 
-        has_and_belongs_to_many :topics, :property=>:has_topic, :inverse_of=>:is_topic_of
-        has_and_belongs_to_many :collections, :property=>:is_member_of_collection
+      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::RelsExt.isMemberOfCollection
       end
 
       class SpecialInheritedBook < Book
@@ -15,8 +15,8 @@ describe ActiveFedora::Base do
       class Collection < ActiveFedora::Base
       end
 
-      class Topic < ActiveFedora::Base 
-        has_and_belongs_to_many :books, :property=>:is_topic_of
+      class Topic < ActiveFedora::Base
+        has_and_belongs_to_many :books, predicate: ::RDF::FOAF.isPrimaryTopicOf
       end
     end
 
@@ -28,91 +28,96 @@ describe ActiveFedora::Base do
     end
 
     describe "an unsaved instance" do
+      let(:topic1) { Topic.create }
       before do
-        @topic1 = Topic.create
-        @topic2 = Topic.create
         @book = Book.create
-        @special_book = SpecialInheritedBook.create #TODO this isnt' needed in every test.
       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])
+        @book.topics << topic1
+        expect(@book.topics).to eq [topic1]
+        expect(topic1.books).to eq [@book]
+        expect(topic1.reload.books).to eq [@book]
 
-        @book.topics.delete(@topic1)
-        #@topic1.books.delete(@book)
-        expect(@book.topics).to eq([])
-        expect(@topic1.books).to eq([])
+        @book.topics.delete(topic1)
+        expect(@book.topics).to be_empty
+        expect(topic1.books).to be_empty
       end
-      it "Should allow for more than 10 items" do
 
-        (0..11).each do
+      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.pid)
-        expect(book2.topics.count).to eq(12)
-      end
-
-      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])
+        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]
+        end
       end
 
       it "Should cast found books to the correct cmodel" do
-        @topic1.books[0].class == Book
-        @topic1.books[1].class == SpecialInheritedBook
+        topic1.books[0].class == Book
+        topic1.books[1].class == SpecialInheritedBook
       end
 
-      after do
-        @topic1.delete
-        @topic2.delete
-        @book.delete
-        @special_book.delete
-      end
     end
+
     describe "a saved instance" do
-      before do
-        @book = Book.create
-        @topic1 = Topic.create
-        @topic2 = Topic.create
-      end
+      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.relationships(:has_topic)).to eq([@topic1.internal_uri])
-        expect(@topic1.relationships(:has_topic)).to eq([])
-        expect(@topic1.relationships(:is_topic_of)).to eq([@book.internal_uri])
-        expect(Topic.find(@topic1.pid).books).to eq([@book]) #Can't have saved it because @book isn't saved yet.
+        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
+
       it "should save new child objects" do
-        @book.topics << Topic.new
-        expect(@book.topics.first.pid).not_to be_nil
+        book.topics << Topic.new
+        expect(book.topics.first.id).to_not be_nil
       end
+
       it "should clear out the old associtions" do
-        @book.topics = [@topic1]
-        @book.topics = [@topic2]
-        expect(@book.topic_ids).to eq([@topic2.pid])
+        book.topics = [topic1]
+        book.topics = [topic2]
+        expect(book.topic_ids).to eq [topic2.id]
       end
-      after do
-        @book.delete
-        @topic1.delete
-        @topic2.delete
+
+      context "with members" do
+        before do
+          book.topics = [topic1, topic2]
+          book.save
+        end
+
+        context "destroy" do
+          it "should remove the associations" do
+            book.destroy
+          end
+        end
       end
     end
   end
 
   describe "when inverse is not specified" do
     before do
-      class Book < ActiveFedora::Base 
-        has_and_belongs_to_many :collections, :property=>:is_member_of_collection
+      class Book < ActiveFedora::Base
+        has_and_belongs_to_many :collections, predicate: ActiveFedora::RDF::RelsExt.isMemberOfCollection
       end
 
       class Collection < ActiveFedora::Base
+        has_and_belongs_to_many :books, predicate: ActiveFedora::RDF::RelsExt.isMemberOfCollection
       end
     end
 
@@ -129,33 +134,29 @@ describe ActiveFedora::Base do
         book.collections << collection
         book.save!
       end
-      after do
-        collection.delete
-        book.delete
-      end
 
       it "should have a collection" do
-        expect(book.relationships(:is_member_of_collection)).to eq([collection.internal_uri])
-        expect(book.collections).to eq([collection])
+        expect(book['collection_ids']).to eq [collection.id]
+        expect(book.collections).to eq [collection]
       end
       it "habtm should not set foreign relationships if :inverse_of is not specified" do
-         expect(collection.relationships(:is_member_of_collection)).to eq([])
+        expect(collection['book_ids']).to be_empty
       end
       it "should load the collections" do
-        reloaded = Book.find(book.pid)
-        expect(reloaded.collections).to eq([collection])
+        reloaded = Book.find(book.id)
+        expect(reloaded.collections).to eq [collection]
       end
 
       describe "#empty?" do
         subject { book.collections }
-        its(:empty?) { is_expected.to be_falsey }
+        it { should_not be_empty }
       end
     end
 
-    context "when a book isn't in a collection" do 
+    context "when a book isn't in a collection" do
       describe "#empty?" do
         subject { book.collections }
-        its(:empty?) { should be_truthy }
+        it { should be_empty }
       end
     end
   end
@@ -164,8 +165,8 @@ describe ActiveFedora::Base do
   describe "when destroying the association" do
     describe "without callbacks" do
       before do
-        class Book < ActiveFedora::Base 
-          has_and_belongs_to_many :collections, property: :is_member_of_collection
+        class Book < ActiveFedora::Base
+          has_and_belongs_to_many :collections, predicate: ActiveFedora::RDF::RelsExt.isMemberOfCollection
         end
 
         class Collection < ActiveFedora::Base
@@ -184,38 +185,33 @@ describe ActiveFedora::Base do
         book.collections << collection1 << collection2
         book.save!
       end
-      after do
-        collection1.delete
-        collection2.delete
-        book.delete
-      end
 
       it "delete should cause the entries to be removed from RELS-EXT, but not destroy the original record" do
-        expect(book.collections).to eq([collection1, collection2])
+        expect(book.collections).to eq [collection1, collection2]
         book.collections.delete(collection1)
-        expect(book.collections).to eq([collection2])
+        expect(book.collections).to eq [collection2]
         book.save!
         book.reload
-        expect(book.collections).to eq([collection2])
-        expect(Collection.find(collection1.pid)).to_not be_nil
+        expect(book.collections).to eq [collection2]
+        expect(Collection.find(collection1.id)).to_not be_nil
       end
 
       it "destroy should cause the entries to be removed from RELS-EXT, but not destroy the original record" do
-        expect(book.collections).to eq([collection1, collection2])
+        expect(book.collections).to eq [collection1, collection2]
         book.collections.destroy(collection1)
-        expect(book.collections).to eq([collection2])
+        expect(book.collections).to eq [collection2]
         book.save!
         book.reload
-        expect(book.collections).to eq([collection2])
-        expect(Collection.find(collection1.pid)).to_not be_nil
+        expect(book.collections).to eq [collection2]
+        expect(Collection.find(collection1.id)).to_not be_nil
       end
     end
 
     describe "with remove callbacks" do
       before do
-        class Book < ActiveFedora::Base 
-          has_and_belongs_to_many :collections, 
-                                  property: :is_member_of_collection,
+        class Book < ActiveFedora::Base
+          has_and_belongs_to_many :collections,
+                                  predicate: ActiveFedora::RDF::RelsExt.isMemberOfCollection,
                                   before_remove: :foo, after_remove: :bar
         end
 
@@ -234,10 +230,6 @@ describe ActiveFedora::Base do
         book.collections << collection
         book.save!
       end
-      after do
-        collection.delete
-        book.delete
-      end
 
       it "destroy should cause the before_remove and after_remove callback to be triggered" do
         expect(book).to receive(:foo).with(collection)
@@ -253,20 +245,20 @@ describe ActiveFedora::Base do
 
       it "should not remove if an exception is thrown in before_remove" do
         expect(book).to receive(:foo).with(collection).and_raise
-        expect(book).not_to receive(:bar)
+        expect(book).to_not receive(:bar)
         begin
           book.collections.delete(collection)
         rescue RuntimeError
         end
-        expect(book.collections).to eq([collection])
+        expect(book.collections).to eq [collection]
       end
     end
 
     describe "with add callbacks" do
       before do
-        class Book < ActiveFedora::Base 
-          has_and_belongs_to_many :collections, 
-                                  property: :is_member_of_collection,
+        class Book < ActiveFedora::Base
+          has_and_belongs_to_many :collections,
+                                  predicate: ActiveFedora::RDF::RelsExt.isMemberOfCollection,
                                   before_add: :foo, after_add: :bar
         end
 
@@ -279,12 +271,8 @@ describe ActiveFedora::Base do
         Object.send(:remove_const, :Collection)
       end
 
-      let (:book) { Book.create }
-      let (:collection) { Collection.create }
-      after do
-        collection.delete
-        book.delete
-      end
+      let(:book) { Book.create }
+      let(:collection) { Collection.create }
 
       it "shift should cause the before_add and after_add callback to be triggered" do
         expect(book).to receive(:foo).with(collection)
@@ -300,19 +288,45 @@ describe ActiveFedora::Base do
 
       it "should not add if an exception is thrown in before_add" do
         expect(book).to receive(:foo).with(collection).and_raise
-        expect(book).not_to receive(:bar)
+        expect(book).to_not receive(:bar)
         begin
           book.collections << collection
         rescue RuntimeError
         end
-        expect(book.collections).to eq([])
+        expect(book.collections).to eq []
       end
     end
+  end
+end
 
+describe "create" do
+  before do
+    class Book < ActiveFedora::Base
+      has_and_belongs_to_many :collections, predicate: ActiveFedora::RDF::RelsExt.isMemberOfCollection
+    end
+
+    class Collection < ActiveFedora::Base
+      property :title, predicate: ::RDF::DC.title
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Book)
+    Object.send(:remove_const, :Collection)
   end
 
+  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']
+  end
 end
 
+
 describe "Autosave" do
   before do
     class Item < ActiveFedora::Base
@@ -322,8 +336,9 @@ describe "Autosave" do
       end
       has_attributes :title, datastream: 'foo'
     end
+
     class Component < ActiveFedora::Base
-      has_and_belongs_to_many :items, :property => :is_part_of
+      has_and_belongs_to_many :items, predicate: ActiveFedora::RDF::RelsExt.isPartOf
       has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
         m.field "description", :string
       end
@@ -332,25 +347,37 @@ describe "Autosave" do
   end
 
   after do
-      Object.send(:remove_const, :Item)
-      Object.send(:remove_const, :Component)
+    Object.send(:remove_const, :Item)
+    Object.send(:remove_const, :Component)
   end
 
   describe "From the has_and_belongs_to_many side" do
-    let(:component) { Component.create(items: [Item.new(title: 'my title')]) }
+    describe "dependent records" do
+      let(:component) { Component.create(items: [Item.new(title: 'my title')]) }
 
-    it "should save dependent records" do
-      component.reload
-      expect(component.items.first.title).to eq('my title')
+      it "should be saved" do
+        component.reload
+        expect(component.items.first.title).to eq 'my title'
+      end
+    end
+
+    describe "shifting" do
+      let(:component) { Component.new }
+      let(:item) { Item.create }
+
+      it "should set item_ids" do
+        component.items << item
+        expect(component.item_ids).to eq [item.id]
+      end
     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
-      expect(item.components.first.description).to eq('my description')
+      expect(item.components.first.description).to eq 'my description'
     end
   end
-
 end

data/spec/integration/has_many_associations_spec.rb

@@ -2,18 +2,19 @@ require 'spec_helper'
 
 describe "Collection members" do
   before :all do
-    class Library < ActiveFedora::Base 
+    class Library < ActiveFedora::Base
       has_many :books
     end
 
-    class Book < ActiveFedora::Base 
-      belongs_to :library, property: :has_constituent
+    class Book < ActiveFedora::Base
+      belongs_to :library, predicate: ActiveFedora::RDF::RelsExt.hasConstituent
     end
   end
   after :all do
     Object.send(:remove_const, :Book)
     Object.send(:remove_const, :Library)
   end
+
   describe "size of has_many" do
     let(:library) { Library.create }
     context "when no members" do
@@ -21,10 +22,11 @@ describe "Collection members" do
         expect(library.books).not_to be_loaded
         expect(library.books.size).to eq(0)
         expect(library.books).to be_loaded
-        expect(library.books.any?).to be_falsey
+        expect(library.books.any?).to be false
       end
     end
   end
+
   describe "looking up has_many" do
     let(:book) { Book.create }
     let(:library) { Library.create() }
@@ -33,40 +35,41 @@ describe "Collection members" do
       library.save!
       library.reload
     end
+
     it "should read book_ids from solr" do
-      expect(library.book_ids).to eq [book.pid]
+      expect(library.book_ids).to eq [book.id]
     end
     it "should read books from solr" do
       expect(library.books).to eq [book]
     end
 
     it "should cache the results" do
-      expect(library.books.loaded?).to be_falsey
+      expect(library.books).to_not be_loaded
       expect(library.books).to eq [book]
-      expect(library.books.loaded?).to be_truthy
+      expect(library.books).to be_loaded
     end
     it "should load from solr" do
-      expect(library.books.load_from_solr.map {|r| r["id"]}).to eq([book.pid])
+      expect(library.books.load_from_solr.map {|r| r["id"]}).to eq([book.id])
     end
     it "should load from solr with options" do
       expect(library.books.load_from_solr(rows: 0).size).to eq(0)
     end
     it "should respond to #any?" do
-      expect(library.books.any?).to be_truthy
-      expect(library.books.any? {|book| book.library == nil}).to be_falsey
-      expect(library.books.any? {|book| book.library == library}).to be_truthy
+      expect(library.books.any?).to be true
+      expect(library.books.any? {|book| book.library == nil}).to be false
+      expect(library.books.any? {|book| book.library == library}).to be true
     end
   end
 end
 
 describe "After save callbacks" do
   before :all do
-    class Library < ActiveFedora::Base 
+    class Library < ActiveFedora::Base
       has_many :books
     end
 
-    class Book < ActiveFedora::Base 
-      belongs_to :library, :property=>:has_constituent
+    class Book < ActiveFedora::Base
+      belongs_to :library, predicate: ActiveFedora::RDF::RelsExt.hasConstituent
       after_save :find_self
       attr_accessor :library_books
 
@@ -80,27 +83,29 @@ describe "After save callbacks" do
     Object.send(:remove_const, :Book)
     Object.send(:remove_const, :Library)
   end
-  let(:library) { Library.create() }
+
+  let(:library) { Library.create }
   let(:book) { Book.new(library: library) }
+
   it "should have the relationship available in after_save" do
     book.save!
     expect(book.library_books).to include book
   end
 end
 
-describe "When two or more relationships share the same property" do 
+describe "When two or more relationships share the same property" do
   before do
-    class Book < ActiveFedora::Base 
+    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, predicate: ActiveFedora::RDF::RelsExt.isPartOf
     end
 
     class Collection < ActiveFedora::Base
-      belongs_to :book, :property=>:is_part_of
+      belongs_to :book, predicate: ActiveFedora::RDF::RelsExt.isPartOf
     end
 
     @book = Book.create!
@@ -115,30 +120,57 @@ describe "When two or more relationships share the same property" 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([])
+    expect(@book.people).to eq [@person1, @person2]
+    expect(@book.collections).to eq []
+  end
+end
+
+describe "with an polymorphic association" do
+  before do
+    class Permissionable1 < ActiveFedora::Base
+      has_many :permissions, predicate: ActiveFedora::RDF::RelsExt.isPartOf, inverse_of: :access_to
+    end
+    class Permissionable2 < ActiveFedora::Base
+      has_many :permissions, predicate: ActiveFedora::RDF::RelsExt.isPartOf, inverse_of: :access_to
+    end
+
+    class Permission < ActiveFedora::Base
+      belongs_to :access_to, predicate: ActiveFedora::RDF::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+    end
+  end
+
+  after do
+    Permissionable1.destroy_all
+    Object.send(:remove_const, :Permissionable1)
+    Object.send(:remove_const, :Permissionable2)
+    Object.send(:remove_const, :Permission)
+  end
+  let(:p1) { Permissionable1.create }
+
+  it "should make an association" do
+    expect(p1.permissions.create).to be_kind_of Permission
   end
 end
 
 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, predicate: ActiveFedora::RDF::RelsExt.isPartOf, :class_name=>'ActiveFedora::Base'
     end
 
     class Image < ActiveFedora::Base
-      belongs_to :email, :property=>:is_part_of
+      belongs_to :email, predicate: ActiveFedora::RDF::RelsExt.isPartOf
     end
 
     class PDF < ActiveFedora::Base
-      belongs_to :email, :property=>:is_part_of
+      belongs_to :email, predicate: ActiveFedora::RDF::RelsExt.isPartOf
     end
   end
 
   after do
-      Object.send(:remove_const, :Image)
-      Object.send(:remove_const, :PDF)
-      Object.send(:remove_const, :Email)
+    Object.send(:remove_const, :Image)
+    Object.send(:remove_const, :PDF)
+    Object.send(:remove_const, :Email)
   end
 
 
@@ -150,7 +182,7 @@ describe "When relationship is restricted to AF::Base" do
     end
     it "Should not restrict relationships " do
       @book.reload
-      expect(@book.attachments).to eq([@image, @pdf])
+      expect(@book.attachments).to eq [@image, @pdf]
     end
   end
 
@@ -160,15 +192,15 @@ describe "When relationship is restricted to AF::Base" do
     let!(:pdf) { PDF.create }
 
     after do
-      email.destroy
       pdf.destroy
       image.destroy
+      email.destroy
     end
 
     it "Should not restrict relationships " do
       email.attachment_ids = [image.id, pdf.id]
       email.reload
-      expect(email.attachments).to eq([image, pdf])
+      expect(email.attachments).to eq [image, pdf]
     end
   end
 end
@@ -176,10 +208,10 @@ end
 describe "Deleting a dependent relationship" do
   before do
     class Item < ActiveFedora::Base
-      has_many :components, :property => :is_part_of
+      has_many :components
     end
     class Component < ActiveFedora::Base
-      belongs_to :item, :property => :is_part_of
+      belongs_to :item, predicate: ActiveFedora::RDF::RelsExt.isPartOf
     end
   end
 
@@ -191,15 +223,25 @@ describe "Deleting a dependent relationship" do
   let(:item) { Item.create }
   let(:component) { Component.create }
 
+  context "when the relationship is set by an id" do
+    let(:item_id) { item.id }
+    let!(:component1) { Component.create(item_id: item_id) }
+    let!(:component2) { Component.create(item_id: item_id) }
+
+    it "should set the inverse relationship" do
+      expect(component1.item.components).to match_array [component1, component2]
+    end
+  end
+
   it "should remove relationships" do
     component.item = item
     component.save!
-    expect(item.components).to eq([component])
+    expect(item.components).to eq [component]
     item.components.delete(component)
     item.reload
     component.reload
-    expect(component.relationships(:is_part_of)).to eq([])
-    expect(item.components).to eq([])
+    expect(component['item_id']).to be_nil
+    expect(item.components).to eq []
   end
 
   it "should remove the relationships that point at that object" do
@@ -207,7 +249,7 @@ describe "Deleting a dependent relationship" do
     component.save!
     item.delete
     component.reload
-    expect(component.relationships(:is_part_of)).to eq([])
+    expect(component['item_id']).to be_nil
   end
 
   it "should only try to delete objects that exist in the datastore (not cached objects)" do
@@ -227,45 +269,81 @@ describe "Deleting a dependent relationship" do
 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
+  context "a has_many - belongs_to relationship" 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
-      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
+      class Component < ActiveFedora::Base
+        belongs_to :item, predicate: ActiveFedora::RDF::RelsExt.isPartOf
+        has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
+          m.field "description", :string
+        end
+        has_attributes :description, datastream: 'foo'
       end
-      has_attributes :description, datastream: 'foo'
     end
-  end
 
-  after do
+    after do
       Object.send(:remove_const, :Item)
       Object.send(:remove_const, :Component)
-  end
+    end
 
-  describe "From the belongs_to side" do
-    let(:component) { Component.create(item: Item.new(title: 'my title')) }
+    context "From the belongs_to side" do
+      let(:component) { Component.create(item: Item.new(title: 'my title')) }
 
-    it "should save dependent records" do
-      component.reload
-      expect(component.item.title).to eq('my title')
+      it "should save dependent records" do
+        component.reload
+        expect(component.item.title).to eq 'my title'
+      end
     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
-      expect(item.components.first.description).to eq('my description')
+    context "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'
+      end
     end
   end
 
-end
+  context "a has_many - has_and_belongs_to_many relationship" do
+    context "with ActiveFedora::Base as classes" do
+      before do
+        class Novel < ActiveFedora::Base
+          has_many :books, predicate: ActiveFedora::RDF::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+          has_and_belongs_to_many :contents, predicate: ActiveFedora::RDF::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+        end
+        class Text < ActiveFedora::Base
+          has_many :books, predicate: ActiveFedora::RDF::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+        end
+      end
+      let(:text) { Text.create}
+      let(:novel) { Novel.create}
+
+      after do
+        Object.send(:remove_const, :Novel)
+        Object.send(:remove_const, :Text)
+      end
 
+      it "should work when added via the has_many" do
+        text.books << novel
+        novel.save
+        expect(novel.reload.contents).to eq [text]
+        expect(text.reload.books).to eq [novel]
+      end
+
+      it "should work when added via the has_and_belongs_to_many" do
+        novel.contents << text
+        novel.save!
+        text.reload
+        expect(text.books).to eq [novel]
+      end
 
+    end
+  end
+end