active-fedora 13.1.2 → 13.2.4

data/spec/integration/indexing/descendant_fetcher_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ActiveFedora::Indexing::DescendantFetcher do
-  before do
-    class Thing < ActiveFedora::Base
-      property :title, predicate: ::RDF::Vocab::DC.title
-    end
-    class Source < ActiveFedora::Base
-      is_a_container class_name: 'Thing'
-    end
-  end
-  after do
-    Object.send(:remove_const, :Source)
-    Object.send(:remove_const, :Thing)
-  end
-
-  let(:parent) { Source.create }
-  let(:child) { parent.contains.create(title: ['my title']) }
-  let(:other_parent) { Source.create }
-  let!(:source_uris) { [parent, other_parent].map(&:uri).map(&:to_s) }
-  let!(:thing_uris) { [child].map(&:uri).map(&:to_s) }
-  let(:uri) { ActiveFedora.fedora.base_uri }
-  let(:fetcher) { described_class.new(uri) }
-
-  describe '.descendant_and_self_uris' do
-    context 'with default priority models' do
-      it 'returns uris for all objects by walking tree' do
-        expect(fetcher.descendant_and_self_uris).to match_array(source_uris + thing_uris)
-      end
-    end
-    context 'when supplying priority models' do
-      let(:priority_models) { ['Thing'] }
-      let(:fetcher) { described_class.new(uri, priority_models: priority_models) }
-      it 'returns priority model uris first' do
-        expect(fetcher.descendant_and_self_uris.slice(0..(thing_uris.count - 1))).to match_array(thing_uris)
-      end
-    end
-  end
-  describe '.descendant_and_self_uris_partitioned' do
-    context 'with default priority models' do
-      it 'returns' do
-        expect(fetcher.descendant_and_self_uris_partitioned.to_a).to match_array([[:priority, []], [:other, match_array(source_uris + thing_uris)]])
-      end
-    end
-    context 'when supplying priority models' do
-      let(:priority_models) { ['Thing'] }
-      let(:fetcher) { described_class.new(uri, priority_models: priority_models) }
-      it 'returns' do
-        expect(fetcher.descendant_and_self_uris_partitioned.to_a).to match_array([[:priority, match_array(thing_uris)], [:other, match_array(source_uris)]])
-      end
-    end
-  end
-  describe '.descendant_and_self_uris_partitioned_by_model' do
-    it 'returns' do
-      expect(fetcher.descendant_and_self_uris_partitioned_by_model.to_a).to match_array([['Source', match_array(source_uris)], ['Thing', match_array(thing_uris)]])
-    end
-    context 'excluding self' do
-      let(:fetcher) { described_class.new(parent.uri, exclude_self: true) }
-      it 'returns' do
-        expect(fetcher.descendant_and_self_uris_partitioned_by_model.to_a).to match_array([['Thing', [child.uri.to_s]]])
-      end
-    end
-  end
-end

data/spec/integration/indexing_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-@@last_id = 0
-
-describe ActiveFedora::Base do
-  describe "descendant_uris" do
-    before do
-      ids.each do |id|
-        described_class.create id: id
-      end
-    end
-
-    def root_uri(ids = [])
-      ActiveFedora::Base.id_to_uri(ids.first)
-    end
-
-    context 'when there there are no descendants' do
-      let(:ids) { ['foo'] }
-
-      it 'returns an array containing only the URI passed to it' do
-        expect(described_class.descendant_uris(root_uri(ids))).to eq ids.map { |id| described_class.id_to_uri(id) }
-      end
-    end
-
-    context 'when there are > 1 descendants' do
-      let(:ids) { ['foo', 'foo/bar', 'foo/bar/chu'] }
-
-      it 'returns an array containing the URI passed to it, as well as all descendant URIs' do
-        expect(described_class.descendant_uris(root_uri(ids))).to eq ids.map { |id| described_class.id_to_uri(id) }
-      end
-    end
-
-    context 'when some of the decendants are not RDFSources' do
-      let(:ids) { ['foo', 'foo/bar'] }
-      let(:file) { ActiveFedora::File.new(described_class.id_to_uri('foo/bar/bax')) }
-
-      before do
-        file.content = "Hello!!!"
-        file.save
-      end
-
-      it "does not put the datastream in the decendants list" do
-        expect(described_class.descendant_uris(root_uri(ids))).not_to include file.uri
-      end
-    end
-
-    describe "when some of the descendants are prioritized models" do
-      around do |example|
-        class PriorityModel < ActiveFedora::Base
-        end
-        original_defaults = ActiveFedora::Indexing::DescendantFetcher.default_priority_models
-        ActiveFedora::Indexing::DescendantFetcher.default_priority_models = ["PriorityModel"]
-
-        example.run
-
-        ActiveFedora::Indexing::DescendantFetcher.default_priority_models = original_defaults
-        Object.send(:remove_const, :PriorityModel)
-      end
-      let(:ids) { ['foo', 'bar'] }
-      let!(:priority_models) { [PriorityModel.create, PriorityModel.create] }
-
-      it "puts prioritized model ids first" do
-        expect(described_class.descendant_uris(ActiveFedora.fedora.base_uri).slice(0..(priority_models.count - 1))).to contain_exactly(*priority_models.collect(&:uri).collect(&:to_s))
-      end
-    end
-
-    describe "reindex_everything" do
-      let(:ids) { ['foo', 'bar'] }
-      let(:solr) { ActiveFedora::SolrService.instance.conn }
-      before do
-        solr.delete_by_query('*:*', params: { 'softCommit' => true })
-      end
-      it "adds object to solr" do
-        expect {
-          described_class.reindex_everything
-        }.to change { ActiveFedora::SolrService.query('id:foo').size }.from(0).to(1)
-      end
-    end
-  end
-
-  describe "with an autosave association, where some records are deleted" do
-    before do
-      class GenericFile < ActiveFedora::Base
-        has_many :permissions, predicate: ::RDF::Vocab::ACL.accessTo
-        accepts_nested_attributes_for :permissions, allow_destroy: true
-        property :title, predicate: ::RDF::Vocab::DC.title
-
-        def to_solr
-          super.tap do |doc|
-            doc['permissions_ssim'] = permission_ids
-          end
-        end
-      end
-
-      class Permission < ActiveFedora::Base
-        belongs_to :generic_file, predicate: ::RDF::Vocab::ACL.accessTo
-      end
-    end
-
-    let(:p1) { Permission.create! }
-    let(:p2) { Permission.create! }
-    let(:gf) { GenericFile.create(permissions: [p1, p2]) }
-
-    before { gf.update(permissions_attributes: [{ id: p1.id, _destroy: 'true' }]) }
-
-    it "saves to solr correctly" do
-      result = ActiveFedora::SolrService.query("id:#{gf.id}", rows: 10).first['permissions_ssim']
-      expect(result).to eq [p2.id]
-    end
-  end
-end

data/spec/integration/indirect_container_spec.rb

@@ -1,290 +0,0 @@
-require 'spec_helper'
-
-describe "Indirect containers" do
-  before do
-    class RelatedObject < ActiveFedora::Base
-      property :title, predicate: ::RDF::Vocab::DC.title, multiple: false
-    end
-    class Proxy < ActiveFedora::Base
-      belongs_to :proxy_for, predicate: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'), class_name: 'ActiveFedora::Base'
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :RelatedObject)
-    Object.send(:remove_const, :Proxy)
-  end
-
-  describe "#include?" do
-    before do
-      class FooHistory < ActiveFedora::Base
-        indirectly_contains :related_objects,
-                            has_member_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/aggregates'),
-                            inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'),
-                            through: 'Proxy', foreign_key: :proxy_for
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :FooHistory)
-    end
-
-    let(:foo) { FooHistory.new }
-
-    let(:file1) { RelatedObject.create }
-
-    before do
-      foo.related_objects << file1
-      foo.save
-    end
-
-    context "when it is not loaded" do
-      context "and it contains the file" do
-        subject { foo.reload.related_objects.include? file1 }
-        it { is_expected.to be true }
-      end
-
-      context "and it doesn't contain the file" do
-        let!(:file2) { RelatedObject.create }
-        subject { foo.reload.related_objects.include? file2 }
-        it { is_expected.to be false }
-      end
-    end
-
-    context "when it is loaded" do
-      before { foo.related_objects.to_a } # initial load of the association
-
-      context "and it contains the file" do
-        subject { foo.related_objects.include? file1 }
-        it { is_expected.to be true }
-      end
-
-      context "and it doesn't contain the file" do
-        let!(:file2) { RelatedObject.create }
-        subject { foo.related_objects.include? file2 }
-        it { is_expected.to be false }
-      end
-    end
-  end
-
-  describe "delete" do
-    before do
-      class FooHistory < ActiveFedora::Base
-        indirectly_contains :related_objects,
-                            has_member_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/aggregates'), inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'),
-                            through: 'Proxy',
-                            foreign_key: :proxy_for
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :FooHistory)
-    end
-
-    it "deletes only one object" do
-      foo = FooHistory.new
-      foo.related_objects.build
-      file2 = foo.related_objects.build
-      foo.save
-      expect(foo.related_objects.each.count).to eq(2)
-      foo.related_objects.delete(file2)
-      expect(foo.related_objects.each.count).to eq 1
-      foo = FooHistory.find(foo.id)
-      expect(foo.related_objects.each.count).to eq(1)
-    end
-  end
-
-  describe "#indirectly_contains" do
-    context "when the class is implied" do
-      before do
-        class FooHistory < ActiveFedora::Base
-          # TODO: inserted_content_relation can look up the predicate at options[:through].constantize._reflect_on_association(options[:foreign_key]).predicate
-          indirectly_contains :related_objects,
-                              has_member_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/aggregates'),
-                              inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'),
-                              through: 'Proxy',
-                              foreign_key: :proxy_for
-        end
-      end
-      after do
-        Object.send(:remove_const, :FooHistory)
-      end
-
-      let(:file) { o.related_objects.build }
-      let(:reloaded) { FooHistory.find(o.id) }
-
-      context "with no related_objects" do
-        subject { o.related_objects }
-        let(:o) { FooHistory.new }
-
-        it { is_expected.to be_empty }
-        it { is_expected.to eq [] }
-      end
-
-      context "when the object exists" do
-        let(:o) { FooHistory.create }
-
-        before do
-          file.title = "HMMM"
-          o.save
-        end
-
-        describe "#first" do
-          subject(:first) { reloaded.related_objects.first }
-          it "has the content" do
-            expect(first.title).to eq 'HMMM'
-          end
-        end
-
-        describe "#==" do
-          subject { reloaded.related_objects }
-
-          # it delegates to to_a
-          it { is_expected.to eq [file] }
-        end
-
-        describe "#concat" do
-          it "doesn't load all the members" do
-            other = FooHistory.find(o.id)
-            r3 = RelatedObject.create
-            other.related_objects << r3
-            expect(other.related_objects.loaded?).to be false
-            # Calling the reader method triggers a load
-            expect(other.related_objects.size).to eq 2
-            expect(other.related_objects.loaded?).to be true
-            expect(other.related_objects).to include(r3)
-          end
-        end
-
-        describe "#append" do
-          let(:file2) { o.related_objects.build }
-          it "has two related_objects" do
-            expect(o.related_objects).to contain_exactly file, file2
-          end
-
-          context "and then saved/reloaded" do
-            before do
-              file2.title = "Derp"
-              o.save!
-            end
-
-            it "has two related_objects" do
-              expect(reloaded.related_objects).to contain_exactly file, file2
-            end
-          end
-        end
-
-        describe "#ids_reader" do
-          context "with persisted members" do
-            it "returns the ids" do
-              expect(reloaded.related_object_ids).to eq [file.id]
-            end
-          end
-
-          context "after save" do
-            it "returns correctly" do
-              o.save
-              expect(o.related_object_ids).to eq [file.id]
-            end
-          end
-
-          context "with some members in memory" do
-            let(:file2) { RelatedObject.create }
-            before do
-              reloaded.related_objects << file2
-            end
-
-            it "returns the ids" do
-              expect(reloaded.related_object_ids).to contain_exactly file.id, file2.id
-            end
-          end
-        end
-
-        describe "remove" do
-          it "is able to remove" do
-            o.related_objects = []
-            o.save!
-
-            expect(reloaded.related_objects).to eq []
-          end
-        end
-      end
-    end
-
-    context "when the class is provided" do
-      before do
-        class Different < ActiveFedora::Base
-          property :title, predicate: ::RDF::Vocab::DC.title, multiple: false
-        end
-        class FooHistory < ActiveFedora::Base
-          indirectly_contains :related_objects, has_member_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/aggregates'), inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'), class_name: 'Different', through: 'Proxy', foreign_key: :proxy_for
-        end
-      end
-      after do
-        Object.send(:remove_const, :FooHistory)
-        Object.send(:remove_const, :Different)
-      end
-
-      let(:o) { FooHistory.create }
-      let(:file) { o.related_objects.build }
-      let(:reloaded) { FooHistory.find(o.id) }
-
-      describe "#build" do
-        subject { file }
-        it { is_expected.to be_kind_of Different }
-      end
-
-      context "when the object exists" do
-        before do
-          file.title = "HMMM"
-          o.save
-        end
-
-        describe "#first" do
-          subject(:first) { reloaded.related_objects.first }
-          it "has the content" do
-            expect(first.title).to eq 'HMMM'
-          end
-        end
-      end
-    end
-
-    context "when using is_member_of_relation" do # , skip: "As far as I can tell, FC4 doesn't support IndirectContainer with isMemberOfRelation" do
-      before do
-        class FooHistory < ActiveFedora::Base
-          indirectly_contains :related_objects, is_member_of_relation: ::RDF::URI.new("http://example.com/isWithin"), inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'), through: 'Proxy', foreign_key: :proxy_for
-        end
-      end
-      after do
-        Object.send(:remove_const, :FooHistory)
-      end
-
-      let(:file) { o.related_objects.build }
-      let(:reloaded) { FooHistory.find(o.id) }
-
-      context "with no related_objects" do
-        subject { o.related_objects }
-        let(:o) { FooHistory.new }
-
-        it { is_expected.to be_empty }
-        it { is_expected.to eq [] }
-      end
-
-      context "when the object exists" do
-        let(:o) { FooHistory.create }
-
-        before do
-          file.title = "HMMM"
-          o.save
-        end
-
-        describe "#first" do
-          subject(:first) { reloaded.related_objects.first }
-          it "has the content" do
-            expect(first.title).to eq 'HMMM'
-          end
-        end
-      end
-    end
-  end
-end