active-fedora 13.1.2 → 13.1.3

data/spec/unit/serializers_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Attributes::Serializers do
-  describe "deserialize_dates_from_form" do
-    before do
-      class Foo < ActiveFedora::Base
-        attr_accessor :birthday
-      end
-    end
-    after do
-      Object.send(:remove_const, :Foo)
-    end
-    subject(:serializer) { Foo.new }
-    it "deserializes dates" do
-      serializer.attributes = { 'birthday(1i)' => '2012', 'birthday(2i)' => '10', 'birthday(3i)' => '31' }
-      expect(serializer.birthday).to eq '2012-10-31'
-    end
-  end
-end

data/spec/unit/solr_config_options_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora do
-  before(:all) do
-    module SolrSpecModel
-      class Basic < ActiveFedora::Base
-      end
-    end
-  end
-
-  subject(:test_object) { ActiveFedora::Base.new }
-
-  describe ".id_field" do
-    let(:field) { "MY_SAMPLE_ID".freeze }
-    before do
-      allow(described_class).to receive(:id_field).and_return(field)
-    end
-
-    it "is used by ActiveFedora::Base.to_solr" do
-      allow(test_object).to receive(:id).and_return('changeme:123')
-      expect(test_object.to_solr[field.to_sym]).to eq 'changeme:123'
-      expect(test_object.to_solr[:id]).to be_nil
-    end
-
-    it "is used by ActiveFedora::Base#search_with_conditions" do
-      mock_response = double("SolrResponse")
-      expect(ActiveFedora::SolrService).to receive(:query)
-        .with("_query_:\"{!raw f=has_model_ssim}SolrSpecModel::Basic\" AND " \
-              "_query_:\"{!field f=#{field}}changeme:30\"",
-              sort: ["#{described_class.index_field_mapper.solr_name('system_create', :stored_sortable, type: :date)} asc"])
-        .and_return(mock_response)
-
-      expect(SolrSpecModel::Basic.search_with_conditions(id: "changeme:30")).to equal(mock_response)
-    end
-  end
-
-  describe ".enable_solr_updates?" do
-    context 'with .enable_solr_updates? disabled' do
-      before do
-        allow(described_class).to receive(:enable_solr_updates?).and_return(false)
-      end
-
-      it "prevents Base.save from calling update_index if false" do
-        allow(test_object).to receive(:new_record?).and_return(false)
-        expect(test_object).to receive(:update_index).never
-        expect(test_object).to receive(:refresh)
-        test_object.save
-      end
-
-      it "prevents Base.delete from deleting the corresponding Solr document if false" do
-        expect(ActiveFedora::SolrService.instance.conn).to receive(:delete).with(test_object.id).never
-        expect(test_object).to receive(:delete)
-        test_object.delete
-      end
-    end
-  end
-end

data/spec/unit/solr_hit_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::SolrHit do
-  before(:all) do
-    class AudioRecord < ActiveFedora::Base
-      attr_accessor :id
-      def self.connection_for_id(_id); end
-    end
-  end
-
-  subject(:solr_hit) { described_class.new "id" => "my:_ID1_", ActiveFedora.index_field_mapper.solr_name("has_model", :symbol) => ["AudioRecord"] }
-
-  describe "#reify" do
-    it "uses .find to instantiate objects" do
-      expect(AudioRecord).to receive(:find).with("my:_ID1_", cast: true)
-      solr_hit.reify
-    end
-  end
-
-  describe "#id" do
-    it "extracts the id from the solr hit" do
-      expect(solr_hit.id).to eq "my:_ID1_"
-    end
-  end
-
-  describe "#rdf_uri" do
-    it "provides an RDF URI for the solr hit" do
-      expect(solr_hit.rdf_uri).to eq ::RDF::URI.new(ActiveFedora::Base.id_to_uri("my:_ID1_"))
-    end
-  end
-
-  describe "#model" do
-    it "selects the appropriate model for the solr result" do
-      expect(solr_hit.model).to eq AudioRecord
-    end
-  end
-
-  describe "#models" do
-    it "provides all the relevant models for the solr result" do
-      expect(solr_hit.models).to match_array [AudioRecord]
-    end
-  end
-
-  describe "#model?" do
-    it 'is true if the object has the given model' do
-      expect(solr_hit.model?(AudioRecord)).to eq true
-    end
-
-    it 'is true if the object has an ancestor of the given model' do
-      expect(solr_hit.model?(ActiveFedora::Base)).to eq true
-    end
-
-    it 'is false if the given model is not in the ancestor tree for the models' do
-      expect(solr_hit.model?(String)).to eq false
-    end
-  end
-end

data/spec/unit/solr_query_builder_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::SolrQueryBuilder do
-  describe "construct_query" do
-    it "generates a query clause" do
-      expect(described_class.construct_query('id' => "my:_ID1_")).to eq '_query_:"{!field f=id}my:_ID1_"'
-    end
-  end
-
-  describe '#construct_query_for_ids' do
-    it "generates a useable solr query from an array of Fedora ids" do
-      expect(described_class.construct_query_for_ids(["my:_ID1_", "my:_ID2_", "my:_ID3_"])).to eq '{!terms f=id}my:_ID1_,my:_ID2_,my:_ID3_'
-    end
-    it "returns a valid solr query even if given an empty array as input" do
-      expect(described_class.construct_query_for_ids([""])).to eq "id:NEVER_USE_THIS_ID"
-    end
-  end
-end

data/spec/unit/solr_service_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::SolrService do
-  before do
-    described_class.reset!
-  end
-
-  after do
-    described_class.reset!
-  end
-
-  let(:mock_conn) { instance_double(RSolr::Client) }
-
-  describe '#options' do
-    it 'is readable' do
-      expect(described_class.instance.options).to include :read_timeout, :open_timeout, :url
-    end
-  end
-
-  describe '#conn' do
-    it "takes a n-arg constructor and configure for localhost" do
-      expect(RSolr).to receive(:connect).with(read_timeout: 120, open_timeout: 120, url: 'http://localhost:8080/solr')
-      described_class.register.conn
-    end
-    it "clobbers options" do
-      expect(RSolr).to receive(:connect).with(read_timeout: 120, open_timeout: 120, url: 'http://localhost:8080/solr', autocommit: :off, foo: :bar)
-      described_class.register(autocommit: :off, foo: :bar).conn
-    end
-  end
-
-  describe '#conn=' do
-    it 'is settable' do
-      described_class.instance.conn = mock_conn
-      expect(described_class.instance.conn).to eq mock_conn
-    end
-  end
-
-  describe '.instance' do
-    it "sets the threadlocal solr service" do
-      ss = described_class.register(autocommit: :off, foo: :bar)
-      expect(ActiveFedora::RuntimeRegistry.solr_service).to eq ss
-      expect(described_class.instance).to eq ss
-    end
-    it "passes on solr_config when initializing the service" do
-      allow(RSolr).to receive(:connect)
-      allow(ActiveFedora).to receive(:solr_config).and_return(url: 'http://fubar', update_path: 'update_test')
-      expect(described_class).to receive(:register).with(hash_including(url: 'http://fubar', update_path: 'update_test')).and_call_original
-      described_class.instance
-    end
-  end
-
-  describe "#get" do
-    it "calls solr" do
-      stub_result = double("Result")
-      expect(mock_conn).to receive(:get).with('select', params: { q: 'querytext', qt: 'standard' }).and_return(stub_result)
-      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      expect(described_class.get('querytext')).to eq stub_result
-    end
-    it "uses select_path" do
-      stub_result = double("Result")
-      expect(mock_conn).to receive(:get).with('select_test', params: { q: 'querytext', qt: 'standard' }).and_return(stub_result)
-      expect(described_class).to receive(:select_path).and_return('select_test')
-      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      expect(described_class.get('querytext')).to eq stub_result
-    end
-  end
-
-  describe "#post" do
-    it "calls solr" do
-      stub_result = double("Result")
-      expect(mock_conn).to receive(:post).with('select', data: { q: 'querytext', qt: 'standard' }).and_return(stub_result)
-      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      expect(described_class.post('querytext')).to eq stub_result
-    end
-    it "uses select_path" do
-      stub_result = double("Result")
-      expect(mock_conn).to receive(:post).with('select_test', data: { q: 'querytext', qt: 'standard' }).and_return(stub_result)
-      expect(described_class).to receive(:select_path).and_return('select_test')
-      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      expect(described_class.post('querytext')).to eq stub_result
-    end
-  end
-
-  describe "#query" do
-    let(:doc) { { 'id' => 'x' } }
-    let(:docs) { [doc] }
-    let(:stub_result) { { 'response' => { 'docs' => docs } } }
-
-    before do
-      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-    end
-
-    it "defaults to HTTP GET method" do
-      expect(mock_conn).to receive(:get).with('select', params: { rows: 2, q: 'querytext', qt: 'standard' }).and_return(stub_result)
-      described_class.query('querytext', rows: 2)
-    end
-
-    it "allows callers to specify HTTP POST method" do
-      expect(mock_conn).to receive(:post).with('select', data: { rows: 2, q: 'querytext', qt: 'standard' }).and_return(stub_result)
-      described_class.query('querytext', rows: 2, method: :post)
-    end
-
-    it "raises if method not GET or POST" do
-      expect(mock_conn).not_to receive(:head).with('select', data: { rows: 2, q: 'querytext', qt: 'standard' })
-      expect {
-        described_class.query('querytext', rows: 2, method: :head)
-      }.to raise_error(RuntimeError, "Unsupported HTTP method for querying SolrService (:head)")
-    end
-
-    it "wraps the solr response documents in Solr hits" do
-      expect(mock_conn).to receive(:get).with('select', params: { rows: 2, q: 'querytext', qt: 'standard' }).and_return(stub_result)
-      result = described_class.query('querytext', rows: 2)
-      expect(result.size).to eq 1
-      expect(result.first.id).to eq 'x'
-    end
-
-    it "warns about not passing rows" do
-      allow(mock_conn).to receive(:get).and_return(stub_result)
-      expect(ActiveFedora::Base.logger).to receive(:warn).with(/^Calling ActiveFedora::SolrService\.get without passing an explicit value for ':rows' is not recommended/)
-      described_class.query('querytext')
-    end
-  end
-
-  describe ".count" do
-    it "returns a count of matching records" do
-      stub_result = { 'response' => { 'numFound' => '7' } }
-      expect(mock_conn).to receive(:get).with('select', params: { rows: 0, q: 'querytext', qt: 'standard' }).and_return(stub_result)
-      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      expect(described_class.count('querytext')).to eq 7
-    end
-    it "accepts query args" do
-      stub_result = { 'response' => { 'numFound' => '7' } }
-      expect(mock_conn).to receive(:get).with('select', params: { rows: 0, q: 'querytext', qt: 'standard', fq: 'filter' }).and_return(stub_result)
-      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      expect(described_class.count('querytext', fq: 'filter', rows: 10)).to eq 7
-    end
-  end
-  describe ".select_path" do
-    it "gets :select_path from solr_config" do
-      expect(ActiveFedora).to receive(:solr_config).and_return(select_path: 'select_test')
-      expect(described_class.select_path).to eq 'select_test'
-    end
-    it "uses 'select' as default" do
-      expect(ActiveFedora).to receive(:solr_config).and_return({})
-      expect(described_class.select_path).to eq 'select'
-    end
-  end
-
-  describe ".add" do
-    it "calls solr" do
-      doc = { 'id' => '1234' }
-      expect(mock_conn).to receive(:add).with(doc, params: {})
-      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      described_class.add(doc)
-    end
-  end
-
-  describe ".commit" do
-    it "calls solr" do
-      expect(mock_conn).to receive(:commit)
-      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      described_class.commit
-    end
-  end
-end

data/spec/unit/sparql_insert_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::SparqlInsert do
-  subject(:sparql_insert) { described_class.new(change_set.changes) }
-  let(:change_set) { ActiveFedora::ChangeSet.new(base, base.resource, base.changed_attributes.keys) }
-
-  context "with a changed object" do
-    before do
-      class Library < ActiveFedora::Base
-      end
-
-      class Book < ActiveFedora::Base
-        belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasConstituent
-        property :title, predicate: ::RDF::Vocab::DC.title
-      end
-
-      base.library_id = 'foo'
-      base.title = ['bar']
-    end
-    after do
-      Object.send(:remove_const, :Library)
-      Object.send(:remove_const, :Book)
-    end
-
-    let(:base) { Book.create }
-
-    it "returns the string" do
-      expect(sparql_insert.build).to eq "DELETE { <> <info:fedora/fedora-system:def/relations-external#hasConstituent> ?change . }\n  WHERE { <> <info:fedora/fedora-system:def/relations-external#hasConstituent> ?change . } ;\nDELETE { <> <http://purl.org/dc/terms/title> ?change . }\n  WHERE { <> <http://purl.org/dc/terms/title> ?change . } ;\nINSERT { \n<> <info:fedora/fedora-system:def/relations-external#hasConstituent> <#{ActiveFedora.fedora.host}/test/foo> .\n<> <http://purl.org/dc/terms/title> \"bar\" .\n}\n WHERE { }"
-    end
-  end
-end

data/spec/unit/validations_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before :all do
-    class ValidationStub < ActiveFedora::Base
-      property :fubar, predicate: ::RDF::URI('http://example.com/fubar')
-      property :swank, predicate: ::RDF::URI('http://example.com/swank'), multiple: false
-
-      validates_presence_of :fubar
-      validates_length_of :swank, minimum: 5
-
-      before_validation :before_validation_callback
-      after_validation :after_validation_callback
-
-      def before_validation_callback
-        # no-op
-      end
-      def after_validation_callback
-        # no-op
-      end
-    end
-  end
-
-  subject(:validation_stub) { ValidationStub.new }
-
-  after :all do
-    Object.send(:remove_const, :ValidationStub)
-  end
-
-  describe "a valid object" do
-    before do
-      validation_stub.attributes = { fubar: ['here'], swank: 'long enough' }
-    end
-
-    it { is_expected.to be_valid }
-  end
-  describe "an invalid object" do
-    before do
-      validation_stub.attributes = { swank: 'smal' }
-    end
-    it "has errors" do
-      expect(validation_stub).to_not be_valid
-      expect(validation_stub.errors[:fubar]).to eq ["can't be blank"]
-      expect(validation_stub.errors[:swank]).to eq ["is too short (minimum is 5 characters)"]
-    end
-  end
-
-  describe "required terms" do
-    it { is_expected.to be_required(:fubar) }
-    it { is_expected.to_not be_required(:swank) }
-  end
-
-  describe "#save!" do
-    before { expect(validation_stub).to receive(:_create_record) } # prevent saving to Fedora/Solr
-
-    it "validates only once" do
-      expect(validation_stub).to receive(:perform_validations).once.and_return(true)
-      validation_stub.save!
-    end
-  end
-
-  describe "#update!" do
-    before do
-      allow(validation_stub).to receive(:new_record?).and_return(false)
-    end
-    context "when validations work" do
-      it "saves the record" do
-        expect(validation_stub).to receive(:_update_record) # prevent saving to Fedora/Solr
-        expect(validation_stub).to receive(:perform_validations).once.and_return(true)
-        validation_stub.update!(fubar: ['here'], swank: 'long enough')
-        expect(validation_stub.fubar).to eq ['here']
-      end
-    end
-
-    context "when validations fail" do
-      it "raises an error" do
-        expect(validation_stub).not_to receive(:_update_record)
-        expect(validation_stub).to receive(:perform_validations).once.and_return(false)
-        expect { validation_stub.update!(fubar: ['here'], swank: 'long enough') }.to raise_error ActiveFedora::RecordInvalid
-        expect(validation_stub.fubar).to eq ['here']
-      end
-    end
-  end
-
-  describe 'validation callbacks' do
-    it 'calls callbacks' do
-      expect(validation_stub).to receive(:before_validation_callback)
-      expect(validation_stub).to receive(:after_validation_callback)
-      validation_stub.validate
-    end
-  end
-end

data/spec/unit/with_metadata/default_metadata_class_factory_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::WithMetadata::DefaultMetadataClassFactory do
-  let(:parent) { class_double(ActiveFedora::File) }
-  let(:object) { described_class.new }
-
-  describe "default class attributes" do
-    its(:metadata_base_class)    { is_expected.to eq(ActiveFedora::WithMetadata::MetadataNode) }
-    its(:file_metadata_schemas)  { is_expected.to eq([ActiveFedora::WithMetadata::DefaultSchema]) }
-    its(:file_metadata_strategy) { is_expected.to eq(ActiveFedora::WithMetadata::DefaultStrategy) }
-  end
-
-  describe "::build" do
-    it "sets MetadataNode to the default schema using the default strategy" do
-      expect(parent).to receive(:const_set)
-      expect(parent).to receive(:delegate).with(:label, :label=, :label_changed?, to: :metadata_node)
-      expect(parent).to receive(:delegate).with(:file_name, :file_name=, :file_name_changed?, to: :metadata_node)
-      expect(parent).to receive(:delegate).with(:file_size, :file_size=, :file_size_changed?, to: :metadata_node)
-      expect(parent).to receive(:delegate).with(:date_created, :date_created=, :date_created_changed?, to: :metadata_node)
-      expect(parent).to receive(:delegate).with(:date_modified,
-                                                :date_modified=,
-                                                :date_modified_changed?,
-                                                to: :metadata_node)
-      expect(parent).to receive(:delegate).with(:byte_order, :byte_order=, :byte_order_changed?, to: :metadata_node)
-      expect(parent).to receive(:delegate).with(:file_hash, :file_hash=, :file_hash_changed?, to: :metadata_node)
-      object.class.build(parent)
-    end
-  end
-end