active-fedora 9.1.2 → 9.2.0.rc1

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -7,7 +7,7 @@ describe "Nesting attribute behavior of RDF resources" do
     end
 
     class ComplexResource < ActiveFedora::Base
-      property :topic, predicate: DummyMADS.Topic, class_name: "Topic"
+      property :topic, predicate: DummyMADS.Topic, class_name: "ComplexResource::Topic"
 
       class Topic < ActiveTriples::Resource
         property :subject, predicate: ::RDF::DC.subject

data/spec/integration/relation_spec.rb

@@ -3,10 +3,13 @@ require 'spec_helper'
 describe ActiveFedora::Base do
   before :all do
     class Library < ActiveFedora::Base
-      has_many :books, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
+      has_many :books
+    end
+    class Book < ActiveFedora::Base
+      belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
     end
-    class Book < ActiveFedora::Base; end
   end
+
   after :all do
     Object.send(:remove_const, :Library)
     Object.send(:remove_const, :Book)
@@ -18,40 +21,53 @@ describe ActiveFedora::Base do
     expect(subject.class).to be ActiveFedora::Relation
   end
 
-  before :each do
-    Library.create
-    @library = Library.create
-  end
-
-  let(:library1) { @library }
-
-  describe "is cached" do
+  context "when some records exist" do
     before do
-      subject.to_a # trigger initial load
+      Library.create
     end
 
-    it "should be loaded" do
-      expect(subject).to be_loaded
+    let!(:library1) { Library.create }
+
+    describe "is cached" do
+      before do
+        subject.to_a # trigger initial load
+      end
+
+      it "should be loaded" do
+        expect(subject).to be_loaded
+      end
+      it "shouldn't reload" do
+        expect_any_instance_of(ActiveFedora::Relation).to_not receive :find_each
+        subject[0]
+      end
     end
-    it "shouldn't reload" do
-      expect_any_instance_of(ActiveFedora::Relation).to_not receive :find_each
-      subject[0]
+
+    describe "#find" do
+      it "should find one of them" do
+        expect(subject.find(library1.id)).to eq library1
+      end
+      it "should find with a block" do
+        expect(subject.find { |l| l.id == library1.id}).to eq library1
+      end
     end
-  end
 
-  describe "#find" do
-    it "should find one of them" do
-      expect(subject.find(library1.id)).to eq library1
+    describe "#select" do
+      it "should find with a block" do
+        expect(subject.select { |l| l.id == library1.id}).to eq [library1]
+      end
     end
-    it "should find with a block" do
-      expect(subject.find { |l| l.id == library1.id}).to eq library1
+
+    context "unpermitted methods" do
+      it "excludes them" do
+        expect{ subject.sort! }.to raise_error NoMethodError
+      end
     end
-  end
 
-  describe "#select" do
-    it "should find with a block" do
-      expect(subject.select { |l| l.id == library1.id}).to eq [library1]
+    context "when limit is applied" do
+      subject { Library.create books: [Book.create, Book.create] }
+      it "limits the number of books" do
+        expect(subject.books.limit(1).size).to eq 1
+      end
     end
   end
 end
-

data/spec/spec_helper.rb

@@ -17,7 +17,7 @@ require 'rspec'
 require 'rspec/its'
 require 'equivalent-xml/rspec_matchers'
 require 'logger'
-require 'byebug' unless ENV['TRAVIS']
+require 'pry' unless ENV['TRAVIS']
 
 ActiveFedora::Base.logger = Logger.new(STDERR)
 ActiveFedora::Base.logger.level = Logger::WARN

data/spec/unit/attributes_spec.rb

@@ -407,12 +407,14 @@ describe ActiveFedora::Base do
 
     subject { BarHistory4.new }
 
-    it "should raise an error on get" do
-      expect {subject.description}.to raise_error(ArgumentError, "Undefined datastream id: `rdfish' in has_attributes")
+    let(:error_message) { "Undefined file: `rdfish' in property description" }
+
+    it "raises an error on get" do
+      expect { subject.description }.to raise_error(ArgumentError, error_message)
     end
 
-    it "should raise an error on set" do
-      expect { subject.description = ['Neat'] }.to raise_error(ArgumentError, "Undefined datastream id: `rdfish' in has_attributes")
+    it "raises an error on set" do
+      expect { subject.description = ['Neat'] }.to raise_error(ArgumentError, error_message)
     end
 
     describe ".datastream_class_for_name" do
@@ -520,5 +522,3 @@ describe ActiveFedora::Base do
     end
   end
 end
-
-

data/spec/unit/collection_proxy_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ActiveFedora::Associations::CollectionProxy do
+
+  before do
+    class Book < ActiveFedora::Base
+    end
+    class Page < ActiveFedora::Base
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Page)
+    Object.send(:remove_const, :Book)
+  end
+
+  describe "#spawn" do
+
+    let(:reflection)  { Book.create_reflection(:has_many, :pages, { predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection }, Book) }
+    let(:association) { ActiveFedora::Associations::HasManyAssociation.new(Book.new, reflection ) }
+    let(:proxy)       { described_class.new(association) }
+
+    subject { proxy.spawn }
+    it { is_expected.to be_instance_of ActiveFedora::Relation }
+
+  end
+
+end

data/spec/unit/file_spec.rb

@@ -228,7 +228,7 @@ describe ActiveFedora::Datastream do
     context "when there is nothing to save" do
       it "should not write" do
         expect(file.ldp_source).not_to receive(:create)
-        expect(file.save).to be true
+        expect(file.save).to be false
       end
     end
   end

data/spec/unit/files_hash_spec.rb

@@ -2,18 +2,18 @@ require 'spec_helper'
 
 describe ActiveFedora::FilesHash do
   before do
-    class Container; end
-    allow(Container).to receive(:child_resource_reflections).and_return(file: reflection)
+    class FilesContainer; end
+    allow(FilesContainer).to receive(:child_resource_reflections).and_return(file: reflection)
     allow(container).to receive(:association).with(:file).and_return(association)
     allow(container).to receive(:undeclared_files).and_return([])
   end
 
-  after { Object.send(:remove_const, :Container) }
+  after { Object.send(:remove_const, :FilesContainer) }
 
   let(:reflection) { double('reflection') }
   let(:association) { double('association', reader: object) }
   let(:object) { double('object') }
-  let(:container) { Container.new }
+  let(:container) { FilesContainer.new }
 
   subject { ActiveFedora::FilesHash.new(container) }
 

data/spec/unit/has_and_belongs_to_many_association_spec.rb

@@ -42,17 +42,19 @@ describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
 
       describe "finding member" do
         let(:ids) { (0..15).map(&:to_s) }
-        let(:query1) { ids.slice(0,10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(" OR ") }
-        let(:query2) { ids.slice(10,10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(" OR ") }
-
-        it "should call solr query multiple times" do
-          reflection = Book.create_reflection(:has_and_belongs_to_many, :pages, { predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection, solr_page_size: 10}, Book)
+        let(:reflection) { Book.create_reflection(:has_and_belongs_to_many, :pages, { predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection }, Book) }
+        let(:association) { ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, reflection) }
+        it "calls ActiveFedora::Base.find" do
           expect(subject).to receive(:[]).with('page_ids').and_return(ids)
-          expect(ActiveFedora::SolrService).to receive(:query).with(query1, rows: 10).and_return([])
-          expect(ActiveFedora::SolrService).to receive(:query).with(query2, rows: 10).and_return([])
+          expect(ActiveFedora::Base).to receive(:find).with(ids)
+          association.send(:find_target)
+        end
+      end
 
-          ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, reflection)
-          ac.find_target
+      describe "solr page size option" do
+        it "sends a deprecation warning" do
+          expect(Deprecation).to receive(:warn)
+          Book.has_and_belongs_to_many(:pages, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection, solr_page_size: 123)
         end
       end
     end

data/spec/unit/indexers/global_indexer_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+RSpec.describe ActiveFedora::Indexers::GlobalIndexer do
+  subject { 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 "should return itself" do
+      expect(subject.new("bla")).to eq subject
+    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 "should pass that to index_obj" do
+        subject.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 "should pass that to index_obj" do
+        subject.index(index_obj)
+
+        expect(index_obj).to have_received(:as).with(:symbol, :stored_searchable)
+      end
+    end
+    context "with no index types" do
+      subject { described_class.new }
+      it "should not pass anything to index_obj" do
+        subject.index(index_obj)
+
+        expect(index_obj).not_to have_received(:as)
+      end
+    end
+  end
+end

data/spec/unit/indexing_service_spec.rb

@@ -4,27 +4,6 @@ describe ActiveFedora::IndexingService do
   let(:indexer) { described_class.new(object) }
   let(:object) { ActiveFedora::Base.new }
 
-  describe "#solrize_relationships" do
-    subject { indexer.send(:solrize_relationships) }
-    let(:person_reflection) { double('person', foreign_key: 'person_id', kind_of?: true, solr_key: member_of) }
-    let(:location_reflection) { double('location', foreign_key: 'location_id', kind_of?: true, solr_key: part_of) }
-    let(:reflections) { { 'person' => person_reflection, 'location' => location_reflection } }
-
-    let(:member_of) { ActiveFedora::SolrQueryBuilder.solr_name("info:fedora/fedora-system:def/relations-external#isMemberOf", :symbol) }
-    let(:part_of) { ActiveFedora::SolrQueryBuilder.solr_name("info:fedora/fedora-system:def/relations-external#isPartOf", :symbol) }
-
-    before do
-      expect(object).to receive(:[]).with('person_id').and_return('info:fedora/demo:10')
-      expect(object).to receive(:[]).with('location_id').and_return('info:fedora/demo:11')
-      expect(object.class).to receive(:reflections).and_return(reflections)
-    end
-
-    it "should serialize the relationships into a Hash" do
-      expect(subject[member_of]).to eq "info:fedora/demo:10"
-      expect(subject[part_of]).to eq "info:fedora/demo:11"
-    end
-  end
-
   describe "#generate_solr_document" do
     context "when no block is passed" do
       subject { indexer.generate_solr_document }

data/spec/unit/loadable_from_json_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe ActiveFedora::LoadableFromJson::SolrBackedResource do
+  before do
+    class Foo < ActiveFedora::Base
+      belongs_to :bar, predicate: ::RDF::DC.extent
+    end
+
+    class Bar < ActiveFedora::Base
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Foo)
+    Object.send(:remove_const, :Bar)
+  end
+
+  let(:resource) { described_class.new(Foo) }
+
+  before do
+    resource.insert [nil, ::RDF::DC.extent, RDF::URI('http://example.org/123')]
+  end
+
+  describe "#query" do
+    subject { resource.query(predicate: ::RDF::DC.extent) }
+
+    it "is enumerable" do
+      expect(subject.map { |g| g.object }).to eq [RDF::URI('http://example.org/123')]
+    end
+  end
+end

data/spec/unit/pathing_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe ActiveFedora::Base do
+  describe ".uri_prefix" do
+    let(:path) { "foo" }
+
+    before do
+      class FooHistory < ActiveFedora::Base
+        def uri_prefix
+          "foo"
+        end
+        property :title, predicate: ::RDF::DC.title
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :FooHistory)
+    end
+
+    subject { FooHistory.new(title: ["Root foo"]) }
+
+    it { is_expected.to have_uri_prefix }
+
+    it "uses the root path in the uri" do
+      expect(subject.uri_prefix).to eql path
+    end
+
+    context "when the object is saved" do
+      before { subject.save }
+
+      it "should persist the path in the uri" do
+        expect(subject.uri.to_s).to include(path)
+      end
+
+    end
+  end
+end

data/spec/unit/rdf/indexing_service_spec.rb

@@ -78,12 +78,12 @@ describe ActiveFedora::RDF::IndexingService do
     end
 
     it "should return the right values" do
-      expect(fields[:related_url][:values]).to eq ["http://example.org/blogtastic/"]
-      expect(fields[:based_near][:values]).to eq ["Tacoma, WA", "Renton, WA"]
+      expect(fields["related_url"].values).to eq ["http://example.org/blogtastic/"]
+      expect(fields["based_near"].values).to eq ["Tacoma, WA", "Renton, WA"]
     end
 
     it "should return the right type information" do
-      expect(fields[:created][:type]).to eq :date
+      expect(fields["created"].type).to eq :date
     end
   end
 

data/spec/unit/rdf_resource_datastream_spec.rb

@@ -42,10 +42,8 @@ describe ActiveFedora::RDFDatastream do
   subject { DummyAsset.new }
 
   describe "#to_solr" do
-    before do
-      subject.descMetadata.title = "bla"
-      subject.descMetadata.license = DummySubnode.new('http://example.org/blah')
-    end
+
+    before { subject.descMetadata.title = "bla" }
 
     it "should not be blank" do
       expect(subject.to_solr).not_to be_blank
@@ -55,9 +53,31 @@ describe ActiveFedora::RDFDatastream do
       expect(subject.to_solr["desc_metadata__title_teim"]).to eq ["bla"]
     end
 
-    it "should solrize uris" do
-      expect(subject.to_solr["desc_metadata__license_teim"]).to eq ['http://example.org/blah']
+    context "with ActiveFedora::Base resources" do
+
+      let(:dummy_asset) { DummyAsset.new }
+
+      before do
+        allow(dummy_asset).to receive(:uri).and_return("http://foo")
+        subject.descMetadata.creator = dummy_asset
+      end
+
+      it "should solrize objects" do
+        expect(subject.to_solr["desc_metadata__creator_teim"]).to eq ["http://foo"]
+      end
+
     end
+
+    context "with ActiveTriples resources" do
+
+      before { subject.descMetadata.license = DummySubnode.new('http://example.org/blah') }
+
+      it "should solrize uris" do
+        expect(subject.to_solr["desc_metadata__license_teim"]).to eq ['http://example.org/blah']
+      end
+
+   end
+
   end
 
   describe "delegation" do
@@ -148,7 +168,6 @@ describe ActiveFedora::RDFDatastream do
       end
       context "persisted to repository" do
         before do
-          DummySubnode.configure :repository => :default
           allow_any_instance_of(DummySubnode).to receive(:repository).and_return(RDF::Repository.new)
           dummy = DummySubnode.new(RDF::URI('http://example.org/dummy/blah'))
           dummy.title = 'subbla'

data/spec/unit/schema_indexing_strategy_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+RSpec.describe ActiveFedora::SchemaIndexingStrategy do
+  subject { described_class.new(property_indexer_factory) }
+
+  describe "#apply" do
+    let(:property) do
+      p = object_double(ActiveTriples::Property.new(:name => nil))
+      allow(p).to receive(:to_h).and_return(options)
+      allow(p).to receive(:name).and_return(name)
+      p
+    end
+    let(:name) { "Name" }
+    let(:options) do
+      {
+        :class_name => "Test"
+      }
+    end
+    let(:object) do
+      o = object_double(ActiveFedora::Base)
+      allow(o).to receive(:property).and_yield(index_configuration)
+      o
+    end
+    let(:index_configuration) do
+      d = double("index configuration")
+      allow(d).to receive(:as)
+      d
+    end
+    let(:property_indexer) do
+      p = double("property_indexer")
+      allow(p).to receive(:index).with(anything) do |index|
+        index.as(*Array.wrap(index_types))
+      end
+      p
+    end
+    let(:property_indexer_factory) do
+      p = double("property indexer factory")
+      allow(p).to receive(:new).with(anything).and_return(property_indexer)
+      p
+    end
+    let(:index_types) {}
+    context "with no index types" do
+      subject { described_class.new }
+      it "should not try to index it" do
+        subject.apply(object, property)
+
+        expect(object).to have_received(:property).with(property.name, property.to_h)
+        expect(index_configuration).not_to have_received(:as)
+      end
+    end
+    context "with one index type" do
+      let(:index_types) { :symbol }
+      it "should apply that one" do
+        subject.apply(object, property)
+
+        expect(index_configuration).to have_received(:as).with(:symbol)
+      end
+    end
+    context "with multiple index types" do
+      let(:index_types) { [:symbol, :stored_searchable] }
+      it "should apply all of them" do
+        subject.apply(object, property)
+
+        expect(index_configuration).to have_received(:as).with(:symbol, :stored_searchable)
+      end
+    end
+  end
+end