active-fedora 9.0.2 → 9.0.8

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

data/spec/integration/query_result_builder_spec.rb

@@ -30,7 +30,7 @@ describe ActiveFedora::QueryResultBuilder do
       Object.send(:remove_const, :FooObject)
     end
     it "should return an array of objects that are of the class stored in active_fedora_model_s" do
-      query = "id\:#{RSolr.escape(@test_object.id)} OR id\:#{RSolr.escape(@foo_object.id)}"
+      query = ActiveFedora::SolrQueryBuilder.construct_query_for_ids([@test_object.id, @foo_object.id])
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::QueryResultBuilder.reify_solr_results(solr_result)
       expect(result.length).to eq 2
@@ -40,7 +40,7 @@ describe ActiveFedora::QueryResultBuilder do
     end
 
     it 'should #reify a lightweight object as a new instance' do
-      query = "id\:#{RSolr.escape(@foo_object.id)}"
+      query = ActiveFedora::SolrQueryBuilder.construct_query_for_ids([@foo_object.id])
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::QueryResultBuilder.reify_solr_results(solr_result,{:load_from_solr=>true})
       expect(result.first).to be_instance_of FooObject

data/spec/integration/versionable_spec.rb

@@ -18,6 +18,43 @@ describe "a versionable class" do
 
   it { is_expected.to be_versionable }
 
+  describe 'sorting versions' do
+    before do
+      allow(subject).to receive(:fedora_versions) { versions }
+    end
+
+    let(:version1) { double('version1', uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e711aa993d-e1d2-4a65-93ee-3a12fc9541ab', label: 'version1', created: '2015-04-02T19:54:45.962Z') }
+    let(:version2) { double('version2', uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e790373a67-c9ee-447d-b740-4faa882b1a1f', label: 'version2', created: '2015-04-02T19:54:45.96Z') }
+    let(:versions) { [version1, version2] }
+
+    subject { ActiveFedora::VersionsGraph.new }
+
+    it 'sorts by DateTime' do
+      expect(subject.first).to eq version2
+    end
+
+    context 'with an unparseable created date' do
+      let(:version2) { double('version2', uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e790373a67-c9ee-447d-b740-4faa882b1a1f', label: 'version2', created: '') }
+
+      it 'raises an exception' do
+        expect { subject.first }.to raise_error(ActiveFedora::VersionLacksCreateDate)
+      end
+    end
+
+    context 'with a missing created date' do
+      before do
+        # Because mocks raise RSpec::Mocks::MockExpectationError instead
+        allow(version2).to receive(:created) { raise NoMethodError }
+      end
+
+      let(:version2) { double('version2', uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e790373a67-c9ee-447d-b740-4faa882b1a1f', label: 'version2') }
+
+      it 'raises an exception' do
+        expect { subject.first }.to raise_error(ActiveFedora::VersionLacksCreateDate)
+      end
+    end
+  end
+
   context "after saving" do
     before do
       subject.title = ["Greetings Earthlings"]
@@ -175,7 +212,7 @@ describe "a versionable rdf datastream" do
           end
 
           it "should have two unique versions" do
-            expect(subject.versions.all.size).to eq 2      
+            expect(subject.versions.all.size).to eq 2
           end
 
           it "should load the restored datastream's content" do