active-fedora 9.13.0 → 10.0.0.beta1

data/spec/unit/base_active_model_spec.rb

@@ -2,61 +2,26 @@ require 'spec_helper'
 
 describe ActiveFedora::Base do
   describe "active model methods" do
-    class BarStream < ActiveFedora::OmDatastream
-      set_terminology do |t|
-        t.root(path: "first", xmlns: "urn:foobar")
-        t.duck
-      end
-
-      def self.xml_template
-        Nokogiri::XML::Document.parse '<first xmlns="urn:foobar">
-          <duck></duck>
-        </first>'
-      end
-    end
-
-    class BazStream < ActiveFedora::OmDatastream
-      set_terminology do |t|
-        t.root(path: "first", xmlns: "urn:foobar")
-        t.fubar
-      end
-
-      def self.xml_template
-        Nokogiri::XML::Document.parse '<first xmlns="urn:foobar">
-          <fubar></fubar>
-        </first>'
-      end
-    end
-
     class BarHistory < ActiveFedora::Base
-      has_subresource 'xmlish', class_name: 'BarStream'
-      has_subresource 'withText', class_name: 'BazStream'
-      Deprecation.silence(ActiveFedora::Attributes) do
-        has_attributes :fubar, datastream: 'withText', multiple: false
-        has_attributes :duck, datastream: 'xmlish', multiple: false
-      end
-    end
-    before :each do
-      @n = BarHistory.new
+      property :fubar, predicate: ::RDF::URI('http://example.com/fubar'), multiple: false
+      property :duck, predicate: ::RDF::URI('http://example.com/duck'), multiple: false
     end
+    subject { BarHistory.new }
+
     describe "attributes=" do
       it "sets attributes" do
-        @n.attributes = { fubar: "baz", duck: "Quack" }
-        expect(@n.fubar).to eq "baz"
-        expect(@n.withText.get_values(:fubar).first).to eq 'baz'
-        expect(@n.duck).to eq "Quack"
-        expect(@n.xmlish.term_values(:duck).first).to eq 'Quack'
+        subject.attributes = { fubar: "baz", duck: "Quack" }
+        expect(subject.fubar).to eq "baz"
+        expect(subject.duck).to eq "Quack"
       end
     end
+
     describe "update_attributes" do
       it "sets attributes and save" do
-        @n.update_attributes(fubar: "baz", duck: "Quack")
-        @q = BarHistory.find(@n.id)
-        expect(@q.fubar).to eq "baz"
-        expect(@q.duck).to eq "Quack"
-      end
-      after do
-        @n.delete
+        subject.update_attributes(fubar: "baz", duck: "Quack")
+        subject.reload
+        expect(subject.fubar).to eq "baz"
+        expect(subject.duck).to eq "Quack"
       end
     end
   end

data/spec/unit/base_extra_spec.rb

@@ -39,7 +39,7 @@ describe ActiveFedora::Base do
     end
 
     after :all do
-      SpecModel.send(:remove_const, :CamelCased)
+      Object.send(:remove_const, :SpecModel)
     end
     subject { SpecModel::CamelCased.to_class_uri }
 

data/spec/unit/code_configurator_spec.rb

@@ -4,24 +4,17 @@ require 'config_helper'
 describe ActiveFedora::FileConfigurator do
   before :all do
     class TestConfigurator
-      attr_reader :fedora_config, :solr_config, :predicate_config
+      attr_reader :fedora_config, :solr_config
 
       def init(options = {})
         @fedora_config = options[:fedora_config]
         @solr_config = options[:solr_config]
-        @predicate_config = options[:predicate_config]
       end
     end
 
     @config_params = {
       fedora_config: { url: 'http://codeconfig.example.edu/fedora/', user: 'fedoraAdmin', password: 'configurator', cert_file: '/path/to/cert/file' },
-      solr_config: { url: 'http://codeconfig.example.edu/solr/' },
-      predicate_config: {
-        default_namespace: 'info:fedora/fedora-system:def/relations-external#',
-        predicate_mapping: {
-          'info:fedora/fedora-system:def/relations-external#' => { has_part: 'hasPart' }
-        }
-      }
+      solr_config: { url: 'http://codeconfig.example.edu/solr/' }
     }
   end
 
@@ -44,6 +37,5 @@ describe ActiveFedora::FileConfigurator do
     ActiveFedora.init(@config_params)
     expect(ActiveFedora.fedora_config.credentials).to eq @config_params[:fedora_config]
     expect(ActiveFedora.solr_config).to eq @config_params[:solr_config]
-    expect(ActiveFedora::Predicates.predicate_mappings['info:fedora/fedora-system:def/relations-external#'].length).to eq 1
   end
 end

data/spec/unit/core_spec.rb

@@ -2,19 +2,12 @@ require 'spec_helper'
 
 describe ActiveFedora::Base do
   before do
-    class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-      property :publisher, predicate: ::RDF::Vocab::DC.publisher
-    end
     class Library < ActiveFedora::Base
     end
     class Book < ActiveFedora::Base
       belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasConstituent
-      has_subresource "foo", class_name: 'ActiveFedora::QualifiedDublinCoreDatastream'
-      has_subresource "bar", class_name: 'MyDatastream'
-      Deprecation.silence(ActiveFedora::Attributes) do
-        has_attributes :title, datastream: 'foo' # Om backed property
-        has_attributes :publisher, datastream: 'bar' # RDF backed property
-      end
+      property :title, predicate: ::RDF::Vocab::DC.title, multiple: false
+      property :publisher, predicate: ::RDF::Vocab::DC.publisher, multiple: false
     end
   end
 
@@ -24,7 +17,6 @@ describe ActiveFedora::Base do
   after do
     Object.send(:remove_const, :Book)
     Object.send(:remove_const, :Library)
-    Object.send(:remove_const, :MyDatastream)
   end
 
   it "asserts a content model" do
@@ -60,14 +52,7 @@ describe ActiveFedora::Base do
       end
     end
 
-    it "makes the om properties immutable" do
-      expect {
-        subject.title = "HEY"
-      }.to raise_error RuntimeError, "can't modify frozen ActiveFedora::QualifiedDublinCoreDatastream"
-      expect(subject.title).to eq "War and Peace"
-    end
-
-    it "makes the RDF properties immutable" do
+    it "makes the properties immutable" do
       expect {
         subject.publisher = "HEY"
       }.to raise_error TypeError

data/spec/unit/file_configurator_spec.rb

@@ -58,15 +58,6 @@ describe ActiveFedora::FileConfigurator do
     end
   end
 
-  describe "#get_config_path" do
-    it "calls #config_path" do
-      expect(subject).to receive(:config_path)
-      Deprecation.silence(described_class) do
-        subject.get_config_path(:fedora)
-      end
-    end
-  end
-
   describe "initialization methods" do
     describe "config_path(:fedora)" do
       it "uses the config_options[:config_path] if it exists" do
@@ -100,38 +91,6 @@ describe ActiveFedora::FileConfigurator do
       end
     end
 
-    describe "config_path(:predicate_mappings)" do
-      it "uses the config_options[:config_path] if it exists" do
-        expect(subject).to receive(:config_options).and_return(predicate_mappings_config_path: "/path/to/predicate_mappings.yml")
-        expect(File).to receive(:file?).with("/path/to/predicate_mappings.yml").and_return(true)
-        expect(subject.config_path(:predicate_mappings)).to eql("/path/to/predicate_mappings.yml")
-      end
-
-      it "looks in Rails.root/config/predicate_mappings.yml if it exists and no predicate_mappings_config_path passed in" do
-        expect(subject).to receive(:config_options).and_return({})
-        stub_rails(root: "/rails/root")
-        expect(File).to receive(:file?).with("/rails/root/config/predicate_mappings.yml").and_return(true)
-        expect(subject.config_path(:predicate_mappings)).to eql("/rails/root/config/predicate_mappings.yml")
-        unstub_rails
-      end
-
-      it "looks in ./config/predicate_mappings.yml if neither rails.root nor :predicate_mappings_config_path are set" do
-        expect(subject).to receive(:config_options).and_return({})
-        allow(Dir).to receive(:getwd).and_return("/current/working/directory")
-        expect(File).to receive(:file?).with("/current/working/directory/config/predicate_mappings.yml").and_return(true)
-        expect(subject.config_path(:predicate_mappings)).to eql("/current/working/directory/config/predicate_mappings.yml")
-      end
-
-      it "returns default predicate_mappings.yml that ships with active-fedora if none of the above" do
-        expect(subject).to receive(:config_options).and_return({})
-        expect(Dir).to receive(:getwd).and_return("/current/working/directory")
-        expect(File).to receive(:file?).with("/current/working/directory/config/predicate_mappings.yml").and_return(false)
-        expect(File).to receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'predicate_mappings.yml'))).and_return(true)
-        expect(ActiveFedora::Base.logger).to receive(:warn).with("Using the default predicate_mappings.yml that comes with active-fedora.  If you want to override this, pass the path to predicate_mappings.yml to ActiveFedora - ie. ActiveFedora.init(:predicate_mappings_config_path => '/path/to/predicate_mappings.yml') - or set Rails.root and put predicate_mappings.yml into \#{Rails.root}/config.")
-        expect(subject.config_path(:predicate_mappings)).to eql(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'predicate_mappings.yml')))
-      end
-    end
-
     describe "config_path(:solr)" do
       it "returns the solr_config_path if set in config_options hash" do
         allow(subject).to receive(:config_options).and_return(solr_config_path: "/path/to/solr.yml")
@@ -342,43 +301,4 @@ describe ActiveFedora::FileConfigurator do
       end
     end
   end
-
-  ##########################
-
-  describe ".build_predicate_config_path" do
-    it "returns the path to the default config/predicate_mappings.yml if no valid path is given" do
-      expect(subject.send(:build_predicate_config_path)).to eq default_predicate_mapping_file
-    end
-  end
-
-  describe ".predicate_config" do
-    before do
-      subject.instance_variable_set :@config_loaded, nil
-    end
-    it "returns the default mapping if it has not been initialized" do
-      expect(subject.predicate_config).to eq Psych.load(File.read(default_predicate_mapping_file))
-    end
-  end
-
-  describe ".valid_predicate_mapping" do
-    it "returns true if the predicate mapping has the appropriate keys and value types" do
-      expect(subject.send(:valid_predicate_mapping?, default_predicate_mapping_file)).to be true
-    end
-    it "returns false if the mapping is missing the :default_namespace" do
-      mock_yaml({ default_namespace0: "my_namespace", predicate_mapping: { key0: "value0", key1: "value1" } }, "/path/to/predicate_mappings.yml")
-      expect(subject.send(:valid_predicate_mapping?, "/path/to/predicate_mappings.yml")).to be false
-    end
-    it "returns false if the :default_namespace is not a string" do
-      mock_yaml({ default_namespace: { foo: "bar" }, predicate_mapping: { key0: "value0", key1: "value1" } }, "/path/to/predicate_mappings.yml")
-      expect(subject.send(:valid_predicate_mapping?, "/path/to/predicate_mappings.yml")).to be false
-    end
-    it "returns false if the :predicate_mappings key is missing" do
-      mock_yaml({ default_namespace: "a string" }, "/path/to/predicate_mappings.yml")
-      expect(subject.send(:valid_predicate_mapping?, "/path/to/predicate_mappings.yml")).to be false
-    end
-    it "returns false if the :predicate_mappings key is not a hash" do
-      mock_yaml({ default_namespace: "a string", predicate_mapping: "another string" }, "/path/to/predicate_mappings.yml")
-      expect(subject.send(:valid_predicate_mapping?, "/path/to/predicate_mappings.yml")).to be false
-    end
-  end
 end

data/spec/unit/file_spec.rb

@@ -32,12 +32,6 @@ describe ActiveFedora::File do
 
     context "when the file is in an ldp:BasicContainer" do
       let(:parent) { ActiveFedora::Base.new(id: '1234') }
-      before { allow(Deprecation).to receive(:warn) }
-      let(:file) { described_class.new(parent, 'FOO1') }
-
-      it "sets the uri using the parent as the base" do
-        expect(subject).to eq "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/1234/FOO1"
-      end
 
       context "and it's initialized with the URI" do
         let(:file) { described_class.new(parent.uri + "/FOO1") }

data/spec/unit/has_and_belongs_to_many_association_spec.rb

@@ -49,13 +49,6 @@ describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
           association.send(:find_target)
         end
       end
-
-      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
 
     context "with an inverse reflection" do

data/spec/unit/inheritance_spec.rb

@@ -5,12 +5,10 @@ describe ActiveFedora::Base do
     class MyDS < ActiveFedora::OmDatastream
     end
     class Foo < ActiveFedora::Base
-      extend Deprecation
       has_subresource 'foostream', class_name: 'MyDS'
       has_subresource 'dcstream', class_name: 'ActiveFedora::QualifiedDublinCoreDatastream'
     end
     class Bar < ActiveFedora::Base
-      extend Deprecation
       has_subresource 'barstream', class_name: 'MyDS'
     end
   end
@@ -23,16 +21,6 @@ describe ActiveFedora::Base do
     expect(streams.pop).to eq "ActiveFedora::QualifiedDublinCoreDatastream"
   end
 
-  it "works for multiple types" do
-    b = Foo.new
-    f = Bar.new
-    Deprecation.silence(Foo) do
-      Deprecation.silence(Bar) do
-        expect(b.class.ds_specs).to_not eq f.class.ds_specs
-      end
-    end
-  end
-
   after do
     Object.send(:remove_const, :Bar)
     Object.send(:remove_const, :Foo)

data/spec/unit/ntriples_datastream_spec.rb

@@ -143,28 +143,7 @@ EOF
 
   describe "solr integration" do
     before(:all) do
-      Deprecation.silence(ActiveFedora::RDFDatastream) do
-        class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-          property :created, predicate: ::RDF::Vocab::DC.created do |index|
-            index.as :sortable, :displayable
-            index.type :date
-          end
-          property :title, predicate: ::RDF::Vocab::DC.title do |index|
-            index.as :stored_searchable, :sortable
-            index.type :text
-          end
-          property :publisher, predicate: ::RDF::Vocab::DC.publisher do |index|
-            index.as :facetable, :sortable, :stored_searchable
-          end
-          property :based_near, predicate: ::RDF::FOAF.based_near do |index|
-            index.as :facetable, :stored_searchable
-            index.type :text
-          end
-          property :related_url, predicate: ::RDF::RDFS.seeAlso do |index|
-            index.as :stored_searchable
-          end
-          property :rights, predicate: ::RDF::Vocab::DC.rights
-        end
+      class MyDatastream < ActiveFedora::NtriplesRDFDatastream
       end
     end
 
@@ -183,60 +162,9 @@ EOF
       expect(@subject.to_solr).to be_kind_of(Hash)
     end
 
-    it "has a solr_name method" do
-      expect(MyDatastream.new.primary_solr_name(:based_near, 'descMetadata')).to eq 'desc_metadata__based_near_tesim'
-      expect(MyDatastream.new.primary_solr_name(:title, 'props')).to eq 'props__title_tesim'
-    end
-
-    it "optionallies allow you to provide the Solr::Document to add fields to and return that document when done" do
+    it "optionally allows you to provide the Solr::Document to add fields to and return that document when done" do
       doc = {}
       expect(@subject.to_solr(doc)).to eq doc
     end
-
-    describe "with an actual object" do
-      before(:each) do
-        class Foo < ActiveFedora::Base
-          has_subresource "descMetadata", class_name: 'MyDatastream'
-          Deprecation.silence(ActiveFedora::Attributes) do
-            has_attributes :created, :title, :publisher, :based_near, :related_url, :rights, datastream: :descMetadata, multiple: true
-          end
-        end
-        @obj = MyDatastream.new
-        @obj.created = Date.parse("2012-03-04")
-        @obj.title = "Of Mice and Men, The Sequel"
-        @obj.publisher = "Bob's Blogtastic Publishing"
-        @obj.based_near = ["Tacoma, WA", "Renton, WA"]
-        @obj.related_url = "http://example.org/blogtastic/"
-        @obj.rights = "Totally open, y'all"
-      end
-      after do
-        Object.send(:remove_const, :Foo)
-      end
-
-      describe ".to_solr()" do
-        subject { @obj.to_solr({}, name: 'solrRdf') }
-        it "returns the right fields" do
-          expect(subject.keys).to include(ActiveFedora.index_field_mapper.solr_name("solr_rdf__related_url", type: :string),
-                                          ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", type: :string),
-                                          ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :sortable),
-                                          ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :facetable),
-                                          ActiveFedora.index_field_mapper.solr_name("solr_rdf__created", :sortable, type: :date),
-                                          ActiveFedora.index_field_mapper.solr_name("solr_rdf__created", :displayable),
-                                          ActiveFedora.index_field_mapper.solr_name("solr_rdf__title", type: :string),
-                                          ActiveFedora.index_field_mapper.solr_name("solr_rdf__title", :sortable),
-                                          ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", type: :string),
-                                          ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", :facetable))
-        end
-
-        it "returns the right values" do
-          expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__related_url", type: :string)]).to eq ["http://example.org/blogtastic/"]
-          expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", type: :string)]).to eq ["Tacoma, WA", "Renton, WA"]
-          expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", :facetable)]).to eq ["Tacoma, WA", "Renton, WA"]
-          expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", type: :string)]).to eq ["Bob's Blogtastic Publishing"]
-          expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :sortable)]).to eq "Bob's Blogtastic Publishing"
-          expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :facetable)]).to eq ["Bob's Blogtastic Publishing"]
-        end
-      end
-    end
   end
 end

data/spec/unit/property_spec.rb

@@ -1,8 +1,5 @@
 require 'spec_helper'
 
-require 'active_fedora'
-require 'active_fedora/model'
-
 describe ActiveFedora::Property do
   before(:each) do
     @test_property = described_class.new(double("model_stub"), "file_name", :string)

data/spec/unit/query_spec.rb

@@ -61,13 +61,6 @@ describe ActiveFedora::Base do
       end
     end
 
-    describe "using an options hash" do
-      it "is deprecated" do
-        expect(Deprecation).to receive(:warn)
-        SpecModel::Basic.find(id: "_ID_")
-      end
-    end
-
     context "with a blank string" do
       it 'raises ActiveFedora::ObjectNotFoundError' do
         expect {

data/spec/unit/querying_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe ActiveFedora::Querying do
+  before do
+    class SpecModel < ActiveFedora::Base
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :SpecModel)
+  end
+
+  describe '.solr_query_handler' do
+    subject { SpecModel.solr_query_handler }
+
+    it { is_expected.to eq 'standard' }
+
+    context "when setting to something besides the default" do
+      before { SpecModel.solr_query_handler = 'search' }
+
+      it { is_expected.to eq 'search' }
+    end
+  end
+end