active-fedora 12.2.2 → 13.1.3

data/spec/unit/forbidden_attributes_protection_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Attributes, ".new" do
-  before(:all) do
-    class ProtectedParams < ActiveSupport::HashWithIndifferentAccess
-      attr_accessor :permitted
-      alias permitted? permitted
-
-      def initialize(attributes)
-        super(attributes)
-        @permitted = false
-      end
-
-      def permit!
-        @permitted = true
-        self
-      end
-
-      def dup
-        super.tap do |duplicate|
-          duplicate.instance_variable_set :@permitted, @permitted
-        end
-      end
-    end
-
-    class Person < ActiveFedora::Base
-      property :first_name, predicate: ::RDF::Vocab::FOAF.firstName, multiple: false
-      property :gender, predicate: ::RDF::Vocab::FOAF.gender, multiple: false
-    end
-  end
-
-  after(:all) do
-    Object.send(:remove_const, :ProtectedParams)
-    Object.send(:remove_const, :Person)
-  end
-
-  context "forbidden attributes" do
-    let(:params) { ProtectedParams.new(first_name: 'Guille', gender: 'm') }
-    it "cannot be used for mass assignment" do
-      expect { Person.new(params) }.to raise_error ActiveModel::ForbiddenAttributesError
-    end
-  end
-
-  context "permitted attributes" do
-    let(:params) { ProtectedParams.new(first_name: 'Guille', gender: 'm').permit! }
-    it "can be used for mass assignment" do
-      expect { Person.new(params) }.not_to raise_error
-    end
-  end
-end

data/spec/unit/has_and_belongs_to_many_association_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
-  context "creating the reflection" do
-    before do
-      class Book < ActiveFedora::Base
-      end
-      class Page < ActiveFedora::Base
-      end
-
-      allow(book).to receive(:new_record?).and_return(false)
-      allow(book).to receive(:save).and_return(true)
-    end
-
-    after do
-      Object.send(:remove_const, :Book)
-      Object.send(:remove_const, :Page)
-    end
-
-    subject(:book) { Book.new(id: 'subject-a') }
-
-    context "a one way relationship " do
-      describe "adding memeber" do
-        it "sets the relationship attribute" do
-          reflection = ActiveFedora::Reflection.create(:has_and_belongs_to_many, :pages, nil, { predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection }, Book)
-          allow(ActiveFedora::SolrService).to receive(:query).and_return([])
-          ac = described_class.new(book, reflection)
-          expect(ac).to receive(:callback).twice
-          object = Page.new
-          allow(object).to receive(:new_record?).and_return(false)
-          allow(object).to receive(:save).and_return(true)
-          allow(object).to receive(:id).and_return('1234')
-
-          allow(book).to receive(:[]).with('page_ids').and_return([])
-          expect(book).to receive(:[]=).with('page_ids', ['1234'])
-
-          ac.concat object
-        end
-      end
-
-      describe "finding member" do
-        let(:ids) { (0..15).map(&:to_s) }
-        let(:reflection) { ActiveFedora::Reflection.create(:has_and_belongs_to_many, :pages, nil, { predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection }, Book) }
-        let(:association) { described_class.new(book, reflection) }
-        it "calls ActiveFedora::Base.find" do
-          expect(book).to receive(:[]).with('page_ids').and_return(ids)
-          expect(ActiveFedora::Base).to receive(:find).with(ids)
-          association.send(:find_target)
-        end
-      end
-    end
-
-    context "with an inverse reflection" do
-      let!(:inverse) { ActiveFedora::Reflection.create(:has_and_belongs_to_many, :books, nil, { predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection }, Page) }
-      let(:reflection) { ActiveFedora::Reflection.create(:has_and_belongs_to_many, :pages, nil, { predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasCollectionMember, inverse_of: 'books' }, Book) }
-      let(:ac) { described_class.new(book, reflection) }
-      let(:object) { Page.new }
-
-      it "sets the relationship attribute on subject and object when inverse_of is given" do
-        allow(ActiveFedora::SolrService).to receive(:query).and_return([])
-        expect(ac).to receive(:callback).twice
-        allow(object).to receive(:new_record?).and_return(false)
-        allow(object).to receive(:save).and_return(true)
-
-        allow(book).to receive(:[]).with('page_ids').and_return([])
-        expect(book).to receive(:[]=).with('page_ids', [object.id])
-
-        expect(object).to receive(:[]).with('book_ids').and_return([]).twice
-        expect(object).to receive(:[]=).with('book_ids', [book.id])
-
-        ac.concat object
-      end
-    end
-  end
-
-  context "class with association" do
-    before do
-      class Collection < ActiveFedora::Base
-        has_and_belongs_to_many :members, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasCollectionMember, class_name: "ActiveFedora::Base", after_remove: :remove_member
-        def remove_member(_m); end
-      end
-
-      class Thing < ActiveFedora::Base
-        has_many :collections, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasCollectionMember, class_name: "ActiveFedora::Base"
-      end
-    end
-
-    after do
-      Collection.destroy_all
-      Thing.destroy_all
-
-      Object.send(:remove_const, :Collection)
-      Object.send(:remove_const, :Thing)
-    end
-
-    context "with a new collection" do
-      let(:collection) { Collection.new }
-      it "has an empty list of collection members" do
-        expect(collection.member_ids).to eq []
-        expect(collection.members).to eq []
-      end
-    end
-
-    context "with a persisted collection" do
-      let(:collection) { Collection.create.tap { |c| c.members << thing } }
-      let(:thing) { Thing.create }
-
-      context "when the ids are set" do
-        let(:thing2) { Thing.create }
-        let(:thing3) { Thing.create }
-
-        it "clears the object set" do
-          expect(collection.members).to eq [thing]
-          collection.member_ids = [thing2.id, thing3.id]
-          expect(collection.members).to contain_exactly thing2, thing3
-        end
-      end
-
-      it "calls destroy" do
-        # this is a pretty weak test
-        expect { collection.destroy }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/unit/has_many_association_spec.rb

@@ -1,131 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Associations::HasManyAssociation do
-  before do
-    class Book < ActiveFedora::Base
-    end
-    class Page < ActiveFedora::Base
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :Book)
-    Object.send(:remove_const, :Page)
-  end
-  let(:book) { Book.new(id: 'subject-a') }
-  let(:page) { Page.new(id: 'object-b') }
-
-  describe "setting the foreign key" do
-    before do
-      allow(book).to receive(:new_record?).and_return(false)
-      allow(page).to receive(:save).and_return(true)
-      allow(ActiveFedora::SolrService).to receive(:query).and_return([])
-    end
-
-    let(:reflection) { ActiveFedora::Reflection.create(:has_many, 'pages', nil, { predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf }, Book) }
-    let(:association) { described_class.new(book, reflection) }
-
-    it "sets the book_id attribute" do
-      expect(association).to receive(:callback).twice
-      expect(page).to receive(:[]=).with('book_id', book.id)
-      association.concat page
-    end
-  end
-
-  describe "#find_polymorphic_inverse" do
-    subject(:af_page) { association.send(:find_polymorphic_inverse, page) }
-
-    let(:book_reflection) { ActiveFedora::Reflection.create(:has_many, 'pages', nil, { predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf }, Book) }
-    let(:association) { described_class.new(book, book_reflection) }
-
-    context "when a has_many is present" do
-      before do
-        # :books must come first, so that we can test that is being passed over in favor of :contents
-        Page.has_many :books, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
-        Page.has_and_belongs_to_many :contents, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
-      end
-
-      it "finds the HABTM reflection" do
-        expect(af_page.name).to eq :contents
-      end
-    end
-
-    context "when multiple belongs_to are present" do
-      before do
-        # :foo must come first, so that we can test that is being passed over in favor of :bar
-        Page.belongs_to :foo, predicate: ::RDF::Vocab::DC.isPartOf, class_name: 'ActiveFedora::Base'
-        Page.belongs_to :bar, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
-      end
-
-      it "finds the belongs_to reflection" do
-        expect(af_page.name).to eq :bar
-      end
-    end
-  end
-
-  context "when inverse doesn't have a predictable name" do
-    before do
-      class TimeSpan < ActiveFedora::Base
-        has_many :images, inverse_of: :created # predicate: ::RDF::Vocab::DC.created
-      end
-
-      class Image < ActiveFedora::Base
-        has_and_belongs_to_many :created, predicate: ::RDF::Vocab::DC.created, class_name: 'TimeSpan'
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :TimeSpan)
-      Object.send(:remove_const, :Image)
-    end
-
-    let(:owner) { TimeSpan.new }
-    let(:reflection) { TimeSpan._reflect_on_association(:images) }
-
-    it "finds the predicate" do
-      expect { described_class.new(owner, reflection) }.not_to raise_error
-    end
-  end
-
-  describe "scope" do
-    before do
-      class Library < ActiveFedora::Base
-        has_many :images
-      end
-
-      class Image < ActiveFedora::Base
-        belongs_to :library, predicate: ::RDF::URI('http://example.com/library')
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :Library)
-      Object.send(:remove_const, :Image)
-    end
-
-    context "of an unsaved target" do
-      subject { Library.new.images.scope }
-      it { is_expected.to be_kind_of ActiveFedora::NullRelation }
-    end
-  end
-
-  describe "#ids_reader" do
-    let(:owner) { instance_double(ActiveFedora::Base) }
-    let(:reflection) { instance_double(ActiveFedora::Reflection::AssociationReflection, check_validity!: true) }
-    let(:association) { described_class.new(owner, reflection) }
-
-    let(:r1) { ActiveFedora::Base.new(id: 'r1-id', &:mark_for_destruction) }
-    let(:r2) { ActiveFedora::Base.new(id: 'r2-id') }
-
-    context "when some records are marked_for_destruction" do
-      before do
-        allow(association).to receive(:loaded?).and_return(true)
-        allow(association).to receive(:load_target).and_return([r1, r2])
-      end
-
-      it "only returns the records not marked for destruction" do
-        expect(association.ids_reader).to eq ['r2-id']
-      end
-    end
-  end
-end

data/spec/unit/indexers/global_indexer_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ActiveFedora::Indexers::GlobalIndexer do
-  let(:global_indexer) { described_class.new(index_types) }
-  let(:index_types) {}
-
-  describe "#new" do
-    # The global indexer acts as both an indexer factory and an indexer, since
-    # the property doesn't matter.
-    it "returns itself" do
-      expect(global_indexer.new("bla")).to eq global_indexer
-    end
-  end
-  describe "#index" do
-    let(:index_obj) { instance_double(ActiveFedora::Indexing::Map::IndexObject, as: nil) }
-    context "with one index type" do
-      let(:index_types) { :symbol }
-      it "passes that to index_obj" do
-        global_indexer.index(index_obj)
-
-        expect(index_obj).to have_received(:as).with(:symbol)
-      end
-    end
-    context "with multiple index types" do
-      let(:index_types) { [:symbol, :stored_searchable] }
-      it "passes that to index_obj" do
-        global_indexer.index(index_obj)
-
-        expect(index_obj).to have_received(:as).with(:symbol, :stored_searchable)
-      end
-    end
-    context "with no index types" do
-      let(:global_indexer) { described_class.new }
-      it "does not pass anything to index_obj" do
-        global_indexer.index(index_obj)
-
-        expect(index_obj).not_to have_received(:as)
-      end
-    end
-  end
-end

data/spec/unit/indexing/map/index_object_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ActiveFedora::Indexing::Map::IndexObject do
-  describe "with a block" do
-    subject(:instance) do
-      described_class.new(:name) do |index|
-        index.as :stored_searchable, :facetable
-      end
-    end
-
-    it "can set behaviors" do
-      expect(instance.behaviors).to eq [:stored_searchable, :facetable]
-    end
-  end
-
-  describe "with an initializer parameters" do
-    subject(:instance) do
-      described_class.new(:name, behaviors: [:stored_searchable, :facetable])
-    end
-
-    it "can set behaviors" do
-      expect(instance.behaviors).to eq [:stored_searchable, :facetable]
-    end
-  end
-end

data/spec/unit/indexing/map_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ActiveFedora::Indexing::Map do
-  describe ".merge" do
-    subject(:merged) { first_map.merge(extra) }
-    let(:index_object1) { instance_double(described_class::IndexObject) }
-    let(:index_object2) { instance_double(described_class::IndexObject) }
-    let(:index_object3) { instance_double(described_class::IndexObject) }
-    let(:first_map) { described_class.new(one: index_object1, two: index_object2) }
-
-    context "with a hash" do
-      let(:extra) { { three: index_object3 } }
-      it "merges with a hash" do
-        expect(merged).to be_instance_of described_class
-        expect(merged.keys).to match_array [:one, :two, :three]
-      end
-    end
-
-    context "with another Indexing::Map" do
-      let(:extra) { described_class.new(three: index_object3) }
-      it "merges with the other map" do
-        expect(merged).to be_instance_of described_class
-        expect(merged.keys).to match_array [:one, :two, :three]
-      end
-    end
-  end
-end

data/spec/unit/indexing_service_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::IndexingService do
-  let(:indexer) { described_class.new(object) }
-  let(:object) { ActiveFedora::Base.new }
-
-  describe "#generate_solr_document" do
-    context "when no block is passed" do
-      subject(:solr_doc) { indexer.generate_solr_document }
-      it "produces a document" do
-        expect(solr_doc['has_model_ssim']).to eq ['ActiveFedora::Base']
-      end
-    end
-
-    context "when a block is passed" do
-      subject(:solr_doc) do
-        indexer.generate_solr_document do |solr_doc|
-          solr_doc['noid'] = '12345'
-        end
-      end
-
-      it "produces and yield the document" do
-        expect(solr_doc['has_model_ssim']).to eq ['ActiveFedora::Base']
-        expect(solr_doc['noid']).to eq '12345'
-      end
-    end
-  end
-end

data/spec/unit/indexing_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Indexing do
-  describe '.indexer' do
-    let(:indexing_class) { Class.new }
-    let(:klass) { Class.new }
-    before do
-      klass.include described_class
-    end
-
-    it "is settable as a class attribute" do
-      expect(klass.indexer).to eq ActiveFedora::IndexingService
-      klass.indexer = indexing_class
-      expect(klass.indexer).to eq indexing_class
-    end
-  end
-
-  context "internal methods" do
-    before :all do
-      class SpecNode
-        include ActiveFedora::Indexing
-      end
-    end
-    after :all do
-      Object.send(:remove_const, :SpecNode)
-    end
-
-    subject(:node) { SpecNode.new }
-
-    describe "#create_needs_index?" do
-      subject { SpecNode.new.send(:create_needs_index?) }
-      it { is_expected.to be true }
-    end
-
-    describe "#update_needs_index?" do
-      subject { SpecNode.new.send(:update_needs_index?) }
-      it { is_expected.to be true }
-    end
-  end
-
-  describe "#to_solr" do
-    before :all do
-      class SpecNode < ActiveFedora::Base
-        property :title, predicate: ::RDF::Vocab::DC.title do |index|
-          index.as :stored_searchable
-        end
-        property :abstract, predicate: ::RDF::Vocab::DC.abstract, multiple: false do |index|
-          index.as :stored_sortable
-        end
-      end
-    end
-    after :all do
-      Object.send(:remove_const, :SpecNode)
-    end
-
-    subject(:solr_doc) { test_object.to_solr }
-    let(:test_object) { SpecNode.new(title: ['first title'], abstract: 'The abstract') }
-
-    it "indexs the rdf properties" do
-      expect(solr_doc).to include('title_tesim' => ['first title'], 'abstract_ssi' => 'The abstract')
-    end
-
-    it "adds id, system_create_date, system_modified_date from object attributes" do
-      expect(test_object).to receive(:create_date).and_return(DateTime.parse("2012-03-04T03:12:02Z")).twice
-      expect(test_object).to receive(:modified_date).and_return(DateTime.parse("2012-03-07T03:12:02Z")).twice
-      allow(test_object).to receive(:id).and_return('changeme:123')
-      solr_doc = test_object.to_solr
-      expect(solr_doc[ActiveFedora.index_field_mapper.solr_name("system_create", :stored_sortable, type: :date)]).to eql("2012-03-04T03:12:02Z")
-      expect(solr_doc[ActiveFedora.index_field_mapper.solr_name("system_modified", :stored_sortable, type: :date)]).to eql("2012-03-07T03:12:02Z")
-      expect(solr_doc[:id]).to eql("changeme:123")
-    end
-
-    context "with attached files" do
-      let(:mock1) { instance_double(ActiveFedora::File) }
-      let(:mock2) { instance_double(ActiveFedora::File) }
-
-      it "calls .to_solr on all datastreams, passing the resulting document to solr" do
-        expect(mock1).to receive(:to_solr).and_return("one" => "title one")
-        expect(mock2).to receive(:to_solr).and_return("two" => "title two")
-
-        allow(test_object).to receive(:declared_attached_files).and_return(ds1: mock1, ds2: mock2)
-        expect(solr_doc).to include('one' => 'title one', 'two' => 'title two')
-      end
-    end
-  end
-end