active-fedora 12.2.2 → 13.1.3

data/spec/unit/orders/reflection_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ActiveFedora::Reflection::OrdersReflection do
-  let(:orders_reflection) { described_class.new(name, scope, options, active_fedora) }
-  let(:macro) { :orders }
-  let(:name) { "ordered_member_proxies" }
-  let(:options) { {} }
-  let(:scope) { nil }
-  let(:active_fedora) { instance_double(ActiveFedora::Base) }
-
-  describe "#klass" do
-    it "is a proxy" do
-      expect(orders_reflection.klass).to eq ActiveFedora::Orders::ListNode
-    end
-  end
-
-  describe "#class_name" do
-    it "is a list node" do
-      expect(orders_reflection.class_name).to eq "ActiveFedora::Orders::ListNode"
-    end
-  end
-end

data/spec/unit/pathing_spec.rb

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

data/spec/unit/persistence_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Persistence do
-  describe '#new_record?' do
-    context 'with an new object' do
-      subject(:persistence) { ActiveFedora::Base.new }
-      it { is_expected.to be_new_record }
-    end
-
-    context 'with an destroyed object' do
-      subject(:persistence) { ActiveFedora::Base.create }
-      before { persistence.delete }
-      it { is_expected.not_to be_new_record }
-    end
-  end
-
-  describe '.delete' do
-    context 'with an unsaved object' do
-      subject(:persistence) { ActiveFedora::Base.new }
-      before { persistence.delete }
-      it { is_expected.to eq persistence }
-    end
-
-    context 'with a saved object' do
-      subject(:persistence) { ActiveFedora::Base.create! }
-      before { persistence.delete }
-      it { is_expected.to be_frozen }
-    end
-  end
-
-  describe '.create' do
-    context 'when a block is provided' do
-      it 'passes the block to initialize' do
-        expect_any_instance_of(ActiveFedora::Base).to receive(:save)
-        expect { |b| ActiveFedora::Base.create(&b) }.to yield_with_args(an_instance_of(ActiveFedora::Base))
-      end
-    end
-
-    context "when trying to create it again" do
-      let(:object) { ActiveFedora::Base.create! }
-
-      it "raises an error" do
-        expect { ActiveFedora::Base.create(id: object.id) }.to raise_error(ActiveFedora::IllegalOperation, "Attempting to recreate existing ldp_source: `#{object.uri}'")
-      end
-    end
-  end
-
-  describe '.destroy' do
-    subject(:persistence) { ActiveFedora::Base.create! }
-    context 'with no options' do
-      before { persistence.destroy }
-      it 'does not clear the id' do
-        expect(persistence.id).not_to be_nil
-      end
-    end
-
-    context 'with option eradicate: true' do
-      it 'deletes the tombstone' do
-        expect(persistence.class).to receive(:eradicate).with(persistence.id).and_return(true)
-        persistence.destroy(eradicate: true)
-      end
-    end
-  end
-
-  describe "save" do
-    subject(:persistence) { ActiveFedora::Base.new }
-
-    context "when called with option update_index: false" do
-      context "on a new record" do
-        it "does not update the index" do
-          expect(persistence).to_not receive(:update_index)
-          persistence.save(update_index: false)
-        end
-      end
-
-      context "on a persisted record" do
-        before do
-          allow(persistence).to receive(:new_record?) { false }
-          allow_any_instance_of(Ldp::Orm).to receive(:save) { true }
-          allow(persistence).to receive(:update_modified_date)
-        end
-
-        it "does not update the index" do
-          expect(persistence).to_not receive(:update_index)
-          persistence.save(update_index: false)
-        end
-      end
-    end
-
-    context "when called with option :update_index=>true" do
-      context "on create" do
-        before { allow(persistence).to receive(:create_needs_index?) { false } }
-
-        it "does not override `create_needs_index?'" do
-          expect(persistence).to_not receive(:update_index)
-          persistence.save(update_index: true)
-        end
-      end
-
-      context "on update" do
-        before do
-          allow(persistence).to receive(:new_record?) { false }
-          allow_any_instance_of(Ldp::Orm).to receive(:save) { true }
-          allow(persistence).to receive(:update_needs_index?) { false }
-          allow(persistence).to receive(:update_modified_date)
-        end
-
-        it "does not override `update_needs_index?'" do
-          expect(persistence).to_not receive(:update_index)
-          persistence.save(update_index: true)
-        end
-      end
-    end
-  end
-end

data/spec/unit/property_predicate_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  describe ".property" do
-    context "when the same predicate is used for two properties" do
-      let(:warningMsg) { "Same predicate (http://purl.org/dc/terms/title) used for properties title1 and title2" }
-
-      it "warns" do
-        # Note that the expect test must be before the class is parsed.
-        expect(described_class.logger).to receive(:warn).with(warningMsg)
-
-        module TestModel1
-          class Book < ActiveFedora::Base
-            property :title1, predicate: ::RDF::Vocab::DC.title
-            property :title2, predicate: ::RDF::Vocab::DC.title
-          end
-        end
-      end
-    end
-
-    context "when properties are created with different predicates" do
-      it "does not warn" do
-        # Note that the expect test must be before the class is parsed.
-        expect(described_class.logger).to_not receive(:warn)
-
-        module TestModel2
-          class Book < ActiveFedora::Base
-            property :title1, predicate: ::RDF::Vocab::DC.title
-            property :title2, predicate: ::RDF::Vocab::DC.creator
-          end
-        end
-      end
-    end
-  end
-end

data/spec/unit/property_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Property do
-  before do
-    @test_property = described_class.new(instance_double(ActiveFedora::Base), "file_name", :string)
-  end
-
-  it 'provides .new' do
-    expect(described_class).to respond_to(:new)
-  end
-
-  it 'provides .name' do
-    expect(described_class).to respond_to(:name)
-  end
-
-  it 'provides .instance_variable_name' do
-    expect(@test_property).to respond_to(:instance_variable_name)
-  end
-
-  describe '.instance_variable_name' do
-    it 'returns the value of the name attribute with an @ appended' do
-      expect(@test_property.instance_variable_name).to eql("@#{@test_property.name}")
-    end
-  end
-end

data/spec/unit/query_result_builder_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::QueryResultBuilder do
-  describe "reify solr results" do
-    before(:all) do
-      class AudioRecord < ActiveFedora::Base
-        attr_accessor :id
-        def self.connection_for_id(_id); end
-      end
-      @sample_solr_hits = [{ "id" => "my:_ID1_", ActiveFedora.index_field_mapper.solr_name("has_model", :symbol) => ["AudioRecord"] },
-                           { "id" => "my:_ID2_", ActiveFedora.index_field_mapper.solr_name("has_model", :symbol) => ["AudioRecord"] },
-                           { "id" => "my:_ID3_", ActiveFedora.index_field_mapper.solr_name("has_model", :symbol) => ["AudioRecord"] }]
-    end
-    describe ".reify_solr_results" do
-      it "uses AudioRecord.find to instantiate objects" do
-        expect(AudioRecord).to receive(:find).with("my:_ID1_", cast: true)
-        expect(AudioRecord).to receive(:find).with("my:_ID2_", cast: true)
-        expect(AudioRecord).to receive(:find).with("my:_ID3_", cast: true)
-        described_class.reify_solr_results(@sample_solr_hits)
-      end
-    end
-    describe ".lazy_reify_solr_results" do
-      it "lazilies reify solr results" do
-        expect(AudioRecord).to receive(:find).with("my:_ID1_", cast: true)
-        expect(AudioRecord).to receive(:find).with("my:_ID2_", cast: true)
-        expect(AudioRecord).to receive(:find).with("my:_ID3_", cast: true)
-        described_class.lazy_reify_solr_results(@sample_solr_hits).each { |r| r }
-      end
-    end
-  end
-end

data/spec/unit/query_spec.rb

@@ -1,307 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before(:all) do
-    module SpecModel
-      class Basic < ActiveFedora::Base
-      end
-    end
-  end
-  let(:sort_query) { ActiveFedora.index_field_mapper.solr_name("system_create", :stored_sortable, type: :date) + ' asc' }
-  let(:model_query) { "_query_:\"{!raw f=has_model_ssim}SpecModel::Basic\"" }
-
-  after(:all) do
-    Object.send(:remove_const, :SpecModel)
-  end
-
-  describe ":all" do
-    before { allow(described_class).to receive(:relation).and_return(relation) }
-    describe "called on a concrete class" do
-      let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
-
-      it "queries solr for all objects with has_model_ssim of self.class" do
-        expect(relation).to receive(:load_from_fedora).with("changeme:30", nil)
-          .and_return("Fake Object1")
-        expect(relation).to receive(:load_from_fedora).with("changeme:22", nil)
-          .and_return("Fake Object2")
-        mock_docs = [{ "id" => "changeme:30" }, { "id" => "changeme:22" }]
-        expect(mock_docs).to receive(:has_next?).and_return(false)
-        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate)
-          .with(1, 1000, 'select',
-                params: { q: model_query, qt: 'standard', sort: [sort_query], fl: 'id' })
-          .and_return('response' => { 'docs' => mock_docs })
-        expect(SpecModel::Basic.all).to eq ["Fake Object1", "Fake Object2"]
-      end
-    end
-
-    describe "called without a specific class" do
-      let(:relation) { ActiveFedora::Relation.new(described_class) }
-      it "specifies a q parameter" do
-        expect(relation).to receive(:load_from_fedora).with("changeme:30", true)
-          .and_return("Fake Object1")
-        expect(relation).to receive(:load_from_fedora).with("changeme:22", true)
-          .and_return("Fake Object2")
-        mock_docs = [{ "id" => "changeme:30" }, { "id" => "changeme:22" }]
-        expect(mock_docs).to receive(:has_next?).and_return(false)
-        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate)
-          .with(1, 1000, 'select',
-                params: { q: '*:*', qt: 'standard', sort: [sort_query], fl: 'id' })
-          .and_return('response' => { 'docs' => mock_docs })
-        expect(described_class.all).to eq ["Fake Object1", "Fake Object2"]
-      end
-    end
-  end
-
-  describe '#find' do
-    describe "with :cast false" do
-      describe "and an id is specified" do
-        it "raises an exception if it is not found" do
-          expect { SpecModel::Basic.find("_ID_") }.to raise_error ActiveFedora::ObjectNotFoundError, "Couldn't find SpecModel::Basic with 'id'=_ID_"
-        end
-      end
-    end
-
-    context "with a blank string" do
-      it 'raises ActiveFedora::ObjectNotFoundError' do
-        expect {
-          SpecModel::Basic.find('')
-        }.to raise_error(ActiveFedora::ObjectNotFoundError)
-      end
-    end
-  end
-
-  describe "#where" do
-    before do
-      allow(described_class).to receive(:relation).and_return(relation)
-      allow(relation).to receive(:clone).and_return(relation)
-    end
-    let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
-    let(:solr) { ActiveFedora::SolrService.instance.conn }
-    let(:expected_query) { "#{model_query} AND " \
-                           "_query_:\"{!field f=foo}bar\" AND " \
-                           "(_query_:\"{!field f=baz}quix\" OR " \
-                           "_query_:\"{!field f=baz}quack\")" }
-    let(:expected_params) { { params: { sort: [sort_query], fl: 'id', q: expected_query, qt: 'standard' } } }
-    let(:expected_sort_params) { { params: { sort: ["title_t desc"], fl: 'id', q: expected_query, qt: 'standard' } } }
-    let(:mock_docs) { [{ "id" => "changeme:30" }, { "id" => "changeme:22" }] }
-
-    it "filters by the provided fields" do
-      expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
-      expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
-
-      expect(mock_docs).to receive(:has_next?).and_return(false)
-      expect(solr).to receive(:paginate).with(1, 1000, 'select', expected_params).and_return('response' => { 'docs' => mock_docs })
-      expect(SpecModel::Basic.where(foo: 'bar', baz: ['quix', 'quack'])).to eq ["Fake Object1", "Fake Object2"]
-    end
-
-    it "queries for empty strings" do
-      expect(SpecModel::Basic.where(has_model_ssim: '').count).to eq 0
-    end
-
-    it 'queries for empty arrays' do
-      expect(SpecModel::Basic.where(has_model_ssim: []).count).to eq 0
-    end
-
-    it "adds options" do
-      expect(relation).to receive(:load_from_fedora).with("changeme:30", nil)
-        .and_return("Fake Object1")
-      expect(relation).to receive(:load_from_fedora).with("changeme:22", nil)
-        .and_return("Fake Object2")
-
-      expect(mock_docs).to receive(:has_next?).and_return(false)
-      expect(solr).to receive(:paginate).with(1, 1000, 'select', expected_sort_params)
-        .and_return('response' => { 'docs' => mock_docs })
-      expect(SpecModel::Basic.where(foo: 'bar', baz: ['quix', 'quack'])
-                                .order('title_t desc')).to eq ["Fake Object1", "Fake Object2"]
-    end
-  end
-
-  describe '#find_each' do
-    before { allow(described_class).to receive(:relation).and_return(relation) }
-    let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
-    it "queries solr for all objects with :has_model_ssim of self.class" do
-      mock_docs = [{ "id" => "changeme-30" }, { "id" => "changeme-22" }]
-      expect(mock_docs).to receive(:has_next?).and_return(false)
-      expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate)
-        .with(1, 1000, 'select',
-              params: { q: model_query, qt: 'standard', sort: [sort_query], fl: 'id' })
-        .and_return('response' => { 'docs' => mock_docs })
-
-      allow(relation).to receive(:load_from_fedora).with("changeme-30", nil)
-        .and_return(SpecModel::Basic.new(id: 'changeme-30'))
-      allow(relation).to receive(:load_from_fedora).with("changeme-22", nil)
-        .and_return(SpecModel::Basic.new(id: 'changeme-22'))
-      SpecModel::Basic.find_each { |obj| obj.class == SpecModel::Basic }
-    end
-
-    describe "with conditions" do
-      let(:solr) { ActiveFedora::SolrService.instance.conn }
-      let(:expected_query) { "#{model_query} AND " \
-                             "_query_:\"{!field f=foo}bar\" AND " \
-                             "(_query_:\"{!field f=baz}quix\" OR " \
-                             "_query_:\"{!field f=baz}quack\")" }
-      let(:expected_params) { { params: { sort: [sort_query], fl: 'id', q: expected_query, qt: 'standard' } } }
-      let(:mock_docs) { [{ "id" => "changeme-30" }, { "id" => "changeme-22" }] }
-
-      it "filters by the provided fields" do
-        expect(relation).to receive(:load_from_fedora).with("changeme-30", nil).and_return(SpecModel::Basic.new(id: 'changeme-30'))
-        expect(relation).to receive(:load_from_fedora).with("changeme-22", nil).and_return(SpecModel::Basic.new(id: 'changeme-22'))
-
-        expect(mock_docs).to receive(:has_next?).and_return(false)
-        expect(solr).to receive(:paginate).with(1, 1000, 'select', expected_params).and_return('response' => { 'docs' => mock_docs })
-        SpecModel::Basic.find_each(foo: 'bar', baz: ['quix', 'quack']) { |obj| obj.class == SpecModel::Basic }
-      end
-    end
-  end
-
-  describe '#search_in_batches' do
-    describe "with conditions hash" do
-      let(:solr) { ActiveFedora::SolrService.instance.conn }
-      let(:expected_query) { "#{model_query} AND " \
-                             "_query_:\"{!field f=foo}bar\" AND " \
-                             "(_query_:\"{!field f=baz}quix\" OR " \
-                             "_query_:\"{!field f=baz}quack\")" }
-      let(:expected_params) { { params: { sort: [sort_query], fl: 'id', q: expected_query, qt: 'standard' } } }
-      let(:mock_docs) { double('docs') }
-
-      it "filters by the provided fields" do
-        expect(mock_docs).to receive(:has_next?).and_return(false)
-        expect(solr).to receive(:paginate).with(1, 1002, 'select', expected_params).and_return('response' => { 'docs' => mock_docs })
-        yielded = double("yielded method")
-        expect(yielded).to receive(:run).with(mock_docs)
-        SpecModel::Basic.search_in_batches({ foo: 'bar', baz: ['quix', 'quack'] }, batch_size: 1002, fl: 'id') { |group| yielded.run group }
-      end
-    end
-  end
-
-  describe '#count' do
-    let(:mock_result) { { 'response' => { 'numFound' => 7 } } }
-
-    it "returns a count" do
-      expect(ActiveFedora::SolrService).to receive(:get)
-        .with(model_query, rows: 0)
-        .and_return(mock_result)
-      expect(SpecModel::Basic.count).to eq 7
-    end
-
-    it "allows conditions" do
-      expect(ActiveFedora::SolrService).to receive(:get)
-        .with("#{model_query} AND (foo:bar)", rows: 0)
-        .and_return(mock_result)
-      expect(SpecModel::Basic.count(conditions: 'foo:bar')).to eq 7
-    end
-
-    it "counts without a class specified" do
-      expect(ActiveFedora::SolrService).to receive(:get)
-        .with("(foo:bar)", rows: 0)
-        .and_return(mock_result)
-      expect(described_class.count(conditions: 'foo:bar')).to eq 7
-    end
-  end
-
-  describe '#last' do
-    describe 'with multiple objects' do
-      before do
-        SpecModel::Basic.create!(id: '0001')
-        SpecModel::Basic.create!(id: '0002')
-        @c = SpecModel::Basic.create!(id: '0003')
-      end
-
-      it 'returns the last object sorted by id' do
-        expect(SpecModel::Basic.last).to eq @c
-      end
-    end
-
-    describe 'with one object' do
-      it 'equals the first object when there is only one' do
-        SpecModel::Basic.create!
-        expect(SpecModel::Basic.first).to eq SpecModel::Basic.last
-      end
-    end
-  end
-
-  describe '#first' do
-    describe 'with multiple objects' do
-      before do
-        @a = SpecModel::Basic.create!(id: '0001')
-        SpecModel::Basic.create!(id: '0002')
-        SpecModel::Basic.create!(id: '0003')
-      end
-
-      it 'returns the first object sorted by id' do
-        expect(SpecModel::Basic.first).to eq @a
-      end
-    end
-
-    describe 'with one object' do
-      it 'equals the first object when there is only one' do
-        SpecModel::Basic.create!
-        expect(SpecModel::Basic.first).to eq SpecModel::Basic.last
-      end
-    end
-  end
-
-  describe '#search_with_conditions' do
-    subject(:search_with_conditions) { klass.search_with_conditions(conditions) }
-    let(:mock_result) { double('Result') }
-    let(:klass) { SpecModel::Basic }
-
-    before do
-      expect(ActiveFedora::SolrService).to receive(:query)
-        .with(expected_query, sort: [sort_query]).and_return(mock_result)
-    end
-
-    context "with a hash of conditions" do
-      let(:expected_query) { "#{model_query} AND " \
-                             "_query_:\"{!field f=foo}bar\" AND " \
-                             "(_query_:\"{!field f=baz}quix\" OR " \
-                             "_query_:\"{!field f=baz}quack\")" }
-      let(:conditions) { { foo: 'bar', baz: ['quix', 'quack'] } }
-
-      it "makes a query to solr and returns the results" do
-        expect(search_with_conditions).to eq mock_result
-      end
-    end
-
-    context "with quotes in the params" do
-      let(:expected_query) { "#{model_query} AND " \
-                             "_query_:\"{!field f=foo}9\\\" Nails\" AND " \
-                             "(_query_:\"{!field f=baz}7\\\" version\" OR " \
-                             "_query_:\"{!field f=baz}quack\")" }
-      let(:conditions) { { foo: '9" Nails', baz: ['7" version', 'quack'] } }
-
-      it "escapes quotes" do
-        expect(search_with_conditions).to eq mock_result
-      end
-    end
-
-    context "called on AF::Base" do
-      let(:klass) { described_class }
-
-      context "with a hash" do
-        let(:conditions) { { baz: 'quack' } }
-        let(:expected_query) { "_query_:\"{!field f=baz}quack\"" }
-        it "doesn't use the class if it's called on AF:Base " do
-          expect(search_with_conditions).to eq mock_result
-        end
-      end
-
-      context "called with a string" do
-        let(:conditions) { 'chunky:monkey' }
-        let(:expected_query) { '(chunky:monkey)' }
-        it "uses the query string if it's provided and wrap it in parentheses" do
-          expect(search_with_conditions).to eq mock_result
-        end
-      end
-    end
-  end
-
-  describe "#load_from_fedora" do
-    let(:relation) { ActiveFedora::Relation.new(described_class) }
-    before { @obj = SpecModel::Basic.create(id: "test_123") }
-    after { @obj.destroy }
-    it "casts when klass == ActiveFedora::Base and cast argument is nil" do
-      expect(relation.send(:load_from_fedora, "test_123", nil)).to be_a SpecModel::Basic
-    end
-  end
-end