active-fedora 13.1.2 → 13.1.3

data/spec/integration/belongs_to_association_spec.rb

@@ -1,260 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before do
-    class Library < ActiveFedora::Base
-      has_many :books
-    end
-
-    class Book < ActiveFedora::Base
-      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
-  after do
-    Object.send(:remove_const, :Library)
-    Object.send(:remove_const, :SpecialInheritedBook)
-    Object.send(:remove_const, :Book)
-  end
-
-  let(:library) { Library.create }
-  let(:book) { Book.new }
-
-  describe "setting the id property" do
-    it "stores it" do
-      book.library_id = library.id
-      expect(book.library_id).to eq library.id
-    end
-
-    it "marks it as changed" do
-      expect {
-        book.library_id = library.id
-      }.to change { book.changed? }.from(false).to(true)
-    end
-
-    describe "reassigning the parent_id" do
-      let(:library2) { Library.create }
-      before { book.library = library2 }
-
-      it "updates the object" do
-        expect(book.library).to eq library2 # cause the association to set @loaded
-        library_proxy = book.send(:association_instance_get, :library)
-        expect(library_proxy).to_not be_stale_target
-        book.library_id = library.id
-        expect(library_proxy).to be_stale_target
-        expect(book.library).to eq library
-      end
-    end
-
-    it "is settable via []=" do
-      book[:library_id] = library.id
-      expect(book.library_id).to eq library.id
-    end
-  end
-
-  describe "getting the id property" do
-    it "is accessable via []" do
-      book[:library_id] = library.id
-      expect(book[:library_id]).to eq library.id
-    end
-  end
-
-  describe "when dealing with inherited objects" do
-    before do
-      @library2 = Library.create
-      @special_book = SpecialInheritedBook.create
-
-      book.library = @library2
-      book.save
-      @special_book.library = @library2
-      @special_book.save
-    end
-
-    it "casts to the most specific class for the association" do
-      expect(@library2.books[0]).to be_instance_of Book
-      expect(@library2.books[1]).to be_instance_of SpecialInheritedBook
-    end
-
-    after do
-      @library2.delete
-      @special_book.delete
-    end
-  end
-
-  describe "casting inheritance detailed test cases" do
-    before :all do
-      class SimpleObject < ActiveFedora::Base
-        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'
-      end
-
-      # 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'
-        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject'
-      end
-
-      class ComplexCollection < SimpleCollection
-        has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleObject'
-        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject'
-
-        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, :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 "has 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.objects = [complex_object]
-          simple_collection.save!
-          complex_collection.save!
-        end
-        it "has 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
-        end
-      end
-
-      context "Add a complex_object into a complex_collection" do
-        before do
-          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 "has 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
-        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.objects = [complex_object, simple_object]
-          simple_collection.save!
-        end
-        it "ignores objects whose classes aren't specified" do
-          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 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
-        end
-      end
-
-      context "Adding mixed types on a subclass with a filtered has_many relationship" do
-        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 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 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
-        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'
-      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 "has 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 "has 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/caching_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe "Caching" do
-  before do
-    class TestClass < ActiveFedora::Base
-      property :title, predicate: ::RDF::Vocab::DC.title
-    end
-  end
-
-  after { Object.send(:remove_const, :TestClass) }
-
-  let!(:object) { TestClass.create(id: '123') }
-
-  describe "#cache" do
-    it "finds records in the cache" do
-      expect_any_instance_of(Faraday::Connection).to receive(:get).once.and_call_original
-      ActiveFedora::Base.cache do
-        o1 = TestClass.find(object.id)
-        o2 = TestClass.find(object.id)
-        expect(o1.ldp_source.get.body.object_id).to eq o2.ldp_source.get.body.object_id
-      end
-    end
-
-    it "clears the cache at the end of the block" do
-      expect_any_instance_of(Faraday::Connection).to receive(:get).twice.and_call_original
-      ActiveFedora::Base.cache do
-        TestClass.find(object.id)
-      end
-      ActiveFedora::Base.cache do
-        TestClass.find(object.id)
-      end
-    end
-
-    context "an update" do
-      it "flushes the cache" do
-        expect_any_instance_of(Faraday::Connection).to receive(:get).twice.and_call_original
-        ActiveFedora::Base.cache do
-          TestClass.find(object.id)
-          object.title = ['foo']
-          object.save!
-          TestClass.find(object.id)
-        end
-      end
-    end
-  end
-
-  describe "#uncached" do
-    it "does not use the cache" do
-      expect_any_instance_of(Faraday::Connection).to receive(:get).twice.and_call_original
-      ActiveFedora::Base.cache do
-        TestClass.find(object.id)
-        ActiveFedora::Base.uncached do
-          TestClass.find(object.id)
-        end
-        TestClass.find(object.id)
-      end
-    end
-  end
-end

data/spec/integration/clean_connection_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ActiveFedora::CleanConnection do
-  subject { ActiveFedora.fedora.clean_connection }
-  describe "#get" do
-    context "when given an existing resource uri" do
-      let(:uri) { asset.rdf_subject }
-      let(:asset) do
-        ActiveFedora::Base.create do |a|
-          a.resource << [a.rdf_subject, RDF::Vocab::DC.title, "test"]
-        end
-      end
-      let(:result) { subject.get(uri) }
-      it "returns a clean graph" do
-        graph = result.graph
-        expect(graph.statements.to_a.length).to eq 1
-        expect(graph.statements.to_a.first).to contain_exactly asset.rdf_subject, RDF::Vocab::DC.title, RDF::Literal.new("test")
-      end
-    end
-  end
-end

data/spec/integration/collection_association_spec.rb

@@ -1,166 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before do
-    class Library < ActiveFedora::Base
-      has_many :books
-    end
-    class Book < ActiveFedora::Base
-      belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasMember
-    end
-  end
-
-  let(:library) { Library.create! }
-
-  after do
-    Object.send(:remove_const, :Library)
-    Object.send(:remove_const, :Book)
-  end
-
-  describe "load_from_solr" do
-    let!(:book1) { Book.create!(library: library) }
-    let!(:book2) { Book.create!(library: library) }
-
-    it "sets rows to count, if not specified" do
-      expect(library.books(response_format: :solr).size).to eq 2
-    end
-
-    it "limits rows returned if option passed" do
-      expect(library.books(response_format: :solr, rows: 1).size).to eq 1
-    end
-
-    it "does not query solr if rows is 0" do
-      expect(ActiveFedora::SolrService).not_to receive(:query)
-      expect(library.books(response_format: :solr, rows: 0)).to eq []
-    end
-  end
-
-  describe "#delete_all" do
-    let!(:book1) { Book.create!(library: library) }
-    let!(:book2) { Book.create!(library: library) }
-    it "deletes em" do
-      expect {
-        library.books.delete_all
-      }.to change { library.books.count }.by(-2)
-    end
-  end
-
-  describe "#delete" do
-    context "when given items not in collection" do
-      it "returns an empty set" do
-        expect(library.books.delete(Book.new)).to eq []
-      end
-      it "does not act on it" do
-        b = Book.new
-        allow(b).to receive(:persisted?).and_return(true)
-
-        library.books.delete(b)
-
-        expect(b).not_to have_received(:persisted?)
-      end
-    end
-  end
-
-  describe "#destroy_all" do
-    let!(:book1) { Book.create!(library: library) }
-    let!(:book2) { Book.create!(library: library) }
-    it "deletes em" do
-      expect {
-        library.books.destroy_all
-      }.to change { library.books.count }.by(-2)
-    end
-  end
-
-  describe "#find" do
-    let!(:book1) { Book.create!(library: library) }
-    let!(:book2) { Book.create!(library: library) }
-    it "finds the record that matches" do
-      expected = library.books.find(book1.id)
-      expect(expected).to eq book1
-    end
-    describe "with some records that aren't part of the collection" do
-      let!(:book3) { Book.create }
-      it "finds no records" do
-        expect(library.books.find(book3.id)).to be_nil
-      end
-    end
-  end
-
-  describe "#select" do
-    let!(:book1) { Book.create!(library: library) }
-    let!(:book2) { Book.create!(library: library) }
-
-    # TODO: Bug described in issue #609
-    xit "chooses a subset of objects in the relationship" do
-      expect(library.books.select([:id])).to include(book1.id)
-    end
-    it "works as a block" do
-      expect(library.books.select { |x| x.id == book1.id }).to eq [book1]
-    end
-  end
-
-  describe "#size" do
-    context "with associations in memory" do
-      context "and the association is already loaded" do
-        before do
-          library.books.to_a # force the association to be loaded
-          library.books.build
-        end
-        subject { library.books.size }
-        it { is_expected.to eq 1 }
-      end
-
-      context "and the association is not loaded" do
-        before do
-          library.books.build
-        end
-        subject { library.books.size }
-        it { is_expected.to eq 1 }
-      end
-    end
-  end
-
-  describe "finding the inverse" do
-    context "when no inverse exists" do
-      before do
-        class Item < ActiveFedora::Base
-        end
-        class SpecContainer < ActiveFedora::Base
-          has_many :items
-        end
-      end
-      after do
-        Object.send(:remove_const, :Item)
-        Object.send(:remove_const, :SpecContainer)
-      end
-
-      let(:instance) { SpecContainer.new }
-
-      it "raises an error" do
-        expect { instance.items }.to raise_error "No :inverse_of or :predicate attribute was set or could be inferred for has_many :items on SpecContainer"
-      end
-    end
-
-    context "when classes are namespaced" do
-      before do
-        class Item < ActiveFedora::Base
-          has_and_belongs_to_many :container, predicate: ::RDF::Vocab::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
-
-      subject { instance.items }
-      let(:instance) { Foo::Container.new }
-
-      it { is_expected.to eq [] }
-    end
-  end
-end