active-fedora 13.1.2 → 13.2.4

data/spec/unit/querying_spec.rb

@@ -1,24 +0,0 @@
-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

data/spec/unit/rdf/indexing_service_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::RDF::IndexingService do
-  before do
-    class MyObj < ActiveFedora::Base
-      property :created, predicate: ::RDF::Vocab::DC.created
-      property :title, predicate: ::RDF::Vocab::DC.title
-      property :publisher, predicate: ::RDF::Vocab::DC.publisher
-      property :based_near, predicate: ::RDF::Vocab::FOAF.based_near
-      property :related_url, predicate: ::RDF::Vocab::RDFS.seeAlso
-      property :rights, predicate: ::RDF::Vocab::DC.rights
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :MyObj)
-  end
-
-  let(:f2) do
-    MyObj.new.tap do |obj|
-      obj.created = [Date.parse("2012-03-04")]
-      obj.title = ["Of Mice and Men, The Sequel"]
-      obj.publisher = [RDF::Literal.new("Bob's Blogtastic Publishing", language: :fr)]
-      obj.based_near = ["Tacoma, WA", "Renton, WA"]
-      obj.related_url = ["http://example.org/blogtastic/"]
-      obj.rights = ["Totally open, y'all"]
-    end
-  end
-
-  let(:index_config) do
-    {}.tap do |index_config|
-      index_config[:created] = ActiveFedora::Indexing::Map::IndexObject.new(:created) do |index|
-        index.as :sortable, :displayable
-        index.type :date
-      end
-      index_config[:title] = ActiveFedora::Indexing::Map::IndexObject.new(:title) do |index|
-        index.as :stored_searchable, :sortable
-        index.type :text
-      end
-      index_config[:publisher] = ActiveFedora::Indexing::Map::IndexObject.new(:publisher) do |index|
-        index.as :facetable, :sortable, :stored_searchable
-      end
-      index_config[:based_near] = ActiveFedora::Indexing::Map::IndexObject.new(:based_near) do |index|
-        index.as :facetable, :stored_searchable
-        index.type :text
-      end
-      index_config[:related_url] = ActiveFedora::Indexing::Map::IndexObject.new(:related_url) do |index|
-        index.as :stored_searchable
-      end
-    end
-  end
-
-  describe "#index_config" do
-    subject { indexer.index_config }
-    context "without passing one in" do
-      before do
-        expect(Deprecation).to receive(:warn)
-        allow(MyObj).to receive(:index_config).and_return(index_config)
-      end
-
-      let(:indexer) { described_class.new(f2) }
-      it { is_expected.to eq(index_config) }
-    end
-
-    context "when passing one in" do
-      let(:indexer) { described_class.new(f2, index_config) }
-      it { is_expected.to eq(index_config) }
-    end
-  end
-
-  let(:indexer) { described_class.new(f2, index_config) }
-
-  describe "#generate_solr_document" do
-    let(:solr_obj) { indexer.generate_solr_document(lambda { |key| "solr_rdf__#{key}" }) }
-    it "returns the right fields" do
-      expect(solr_obj.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(solr_obj[ActiveFedora.index_field_mapper.solr_name("solr_rdf__related_url", type: :string)]).to eq ["http://example.org/blogtastic/"]
-      expect(solr_obj[ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", type: :string)]).to contain_exactly "Tacoma, WA", "Renton, WA"
-      expect(solr_obj[ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", :facetable)]).to contain_exactly "Tacoma, WA", "Renton, WA"
-      expect(solr_obj[ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", type: :string)]).to eq ["Bob's Blogtastic Publishing"]
-      expect(solr_obj[ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :sortable)]).to eq "Bob's Blogtastic Publishing"
-      expect(solr_obj[ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :facetable)]).to eq ["Bob's Blogtastic Publishing"]
-    end
-  end
-
-  describe "#fields" do
-    let(:fields) { indexer.send(:fields) }
-
-    it "returns the right fields" do
-      expect(fields.keys).to eq ["created", "title", "publisher", "based_near", "related_url"]
-    end
-
-    it "returns the right values" do
-      expect(fields["related_url"].values).to eq ["http://example.org/blogtastic/"]
-      expect(fields["based_near"].values).to contain_exactly "Tacoma, WA", "Renton, WA"
-    end
-
-    it "returns the right type information" do
-      expect(fields["created"].type).to eq :date
-    end
-  end
-end

data/spec/unit/rdf_vocab_spec.rb

@@ -1,30 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'spec_helper'
-
-describe ActiveFedora::RDF do
-  describe ActiveFedora::RDF::Fcrepo do
-    it "registers the vocabularies" do
-      namespaces = [
-        "info:fedora/fedora-system:def/model#",
-        "info:fedora/fedora-system:def/view#",
-        "info:fedora/fedora-system:def/relations-external#",
-        "info:fedora/fedora-system:"
-      ]
-      namespaces.each do |namespace|
-        vocab = RDF::Vocabulary.find(namespace)
-        expect(vocab.superclass).to be(RDF::StrictVocabulary)
-      end
-    end
-  end
-  describe ActiveFedora::RDF::ProjectHydra do
-    it "registers the vocabularies" do
-      namespaces = [
-        "http://projecthydra.org/ns/relations#"
-      ]
-      namespaces.each do |namespace|
-        vocab = RDF::Vocabulary.find(namespace)
-        expect(vocab.superclass).to be(RDF::StrictVocabulary)
-      end
-    end
-  end
-end

data/spec/unit/readonly_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  subject(:object) { described_class.new }
-  it { is_expected.not_to be_readonly }
-
-  describe "#readonly!" do
-    it "makes the object readonly" do
-      expect { object.readonly! }.to change { object.readonly? }.from(false).to(true)
-    end
-  end
-
-  context "a readonly record" do
-    before { object.readonly! }
-
-    it "does not be destroyable" do
-      expect { object.destroy }.to raise_error ActiveFedora::ReadOnlyRecord
-    end
-
-    it "does not be mutable" do
-      expect { object.save }.to raise_error ActiveFedora::ReadOnlyRecord
-    end
-  end
-end

data/spec/unit/reflection_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Reflection::AssociationReflection do
-  describe "#derive_foreign_key" do
-    subject { instance.send :derive_foreign_key }
-    let(:name) { 'dummy' }
-    let(:options) { { inverse_of: :default_permissions } }
-    let(:active_fedora) { instance_double(ActiveFedora::Base) }
-
-    context "when a has_many" do
-      let(:instance) { ActiveFedora::Reflection::HasManyReflection.new(name, nil, options, active_fedora) }
-
-      context "and the inverse is a collection association" do
-        let(:inverse) { instance_double(ActiveFedora::Reflection::HasAndBelongsToManyReflection, collection?: true) }
-        before { allow(instance).to receive(:inverse_of).and_return(inverse) }
-        it { is_expected.to eq 'default_permission_ids' }
-      end
-    end
-  end
-
-  describe "#automatic_inverse_of" do
-    before do
-      class Dummy < ActiveFedora::Base
-        belongs_to :foothing, predicate: ::RDF::Vocab::DC.extent
-      end
-    end
-
-    after { Object.send(:remove_const, :Dummy) }
-    subject { instance.send :automatic_inverse_of }
-    let(:name) { 'dummy' }
-    let(:options) { { as: 'foothing' } }
-    let(:active_fedora) { instance_double(ActiveFedora::Base) }
-
-    context "when a has_many" do
-      let(:instance) { ActiveFedora::Reflection::HasManyReflection.new(name, nil, options, active_fedora) }
-
-      context "and the inverse is a collection association" do
-        it { is_expected.to eq :foothing }
-      end
-    end
-  end
-end

data/spec/unit/rspec_matchers/belong_to_associated_active_fedora_object_matcher_spec.rb

@@ -1,37 +0,0 @@
-require "spec_helper"
-require 'ostruct'
-require "active_fedora/rspec_matchers/belong_to_associated_active_fedora_object_matcher"
-
-describe RSpec::Matchers, ".belong_to_associated_active_fedora_object" do
-  let(:open_struct) { OpenStruct.new(id: id) }
-  let(:id) { 123 }
-  let(:object1) { Object.new }
-  let(:object2) { Object.new }
-  let(:association) { :association }
-
-  it 'matches when association is properly stored in fedora' do
-    expect(open_struct.class).to receive(:find).with(id).and_return(open_struct)
-    expect(open_struct).to receive(association).and_return(object1)
-    expect(open_struct).to belong_to_associated_active_fedora_object(association).with_object(object1)
-  end
-
-  it 'does not match when association is different' do
-    expect(open_struct.class).to receive(:find).with(id).and_return(open_struct)
-    expect(open_struct).to receive(association).and_return(object1)
-    expect {
-      expect(open_struct).to belong_to_associated_active_fedora_object(association).with_object(object2)
-    }.to raise_error RSpec::Expectations::ExpectationNotMetError,
-                     /expected #{open_struct.class} ID=#{id} association: #{association.inspect}/
-  end
-
-  it 'requires :with_object option' do
-    expect {
-      expect(open_struct).to belong_to_associated_active_fedora_object(association)
-    }.to(
-      raise_error(
-        ArgumentError,
-        "expect(subject).to belong_to_associated_active_fedora_object(<association_name>).with_object(<object>)"
-      )
-    )
-  end
-end

data/spec/unit/rspec_matchers/have_many_associated_active_fedora_objects_matcher_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-require 'ostruct'
-require "active_fedora/rspec_matchers/have_many_associated_active_fedora_objects_matcher"
-
-describe RSpec::Matchers, ".have_many_associated_active_fedora_objects" do
-  let(:open_struct) { OpenStruct.new(id: id) }
-  let(:id) { 123 }
-  let(:object1) { Object.new }
-  let(:object2) { Object.new }
-  let(:object3) { Object.new }
-  let(:association) { :association }
-
-  it 'matches when association is properly stored in fedora' do
-    expect(open_struct.class).to receive(:find).with(id).and_return(open_struct)
-    expect(open_struct).to receive(association).and_return([object1, object2])
-    expect(open_struct).to have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
-  end
-
-  it 'does not match when association is different' do
-    expect(open_struct.class).to receive(:find).with(id).and_return(open_struct)
-    expect(open_struct).to receive(association).and_return([object1, object3])
-    expect {
-      expect(open_struct).to have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
-    }.to raise_error RSpec::Expectations::ExpectationNotMetError,
-                     /expected #{open_struct.class} ID=#{id} association: #{association.inspect}/
-  end
-
-  it 'requires :with_objects option' do
-    expect {
-      expect(open_struct).to have_many_associated_active_fedora_objects(association)
-    }.to(
-      raise_error(
-        ArgumentError,
-        "expect(subject).to have_many_associated_active_fedora_objects(<association_name>).with_objects(<objects[]>)"
-      )
-    )
-  end
-end

data/spec/unit/rspec_matchers/have_predicate_matcher_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-require 'ostruct'
-require "active_fedora/rspec_matchers/have_predicate_matcher"
-
-describe RSpec::Matchers, ".have_predicate" do
-  let(:open_struct) { OpenStruct.new(id: id) }
-  let(:id) { 123 }
-  let(:object1) { Object.new }
-  let(:object2) { Object.new }
-  let(:object3) { Object.new }
-  let(:predicate) { :predicate }
-
-  it 'matches when relationship is "what we have in Fedora"' do
-    expect(open_struct.class).to receive(:find).with(id).and_return(open_struct)
-    expect(open_struct).to receive(:relationships).with(predicate).and_return([object1, object2])
-    expect(open_struct).to have_predicate(predicate).with_objects([object1, object2])
-  end
-
-  it 'does not match when relationship is different' do
-    expect(open_struct.class).to receive(:find).with(id).and_return(open_struct)
-    expect(open_struct).to receive(:relationships).with(predicate).and_return([object1, object3])
-    expect {
-      expect(open_struct).to have_predicate(predicate).with_objects([object1, object2])
-    }.to raise_error RSpec::Expectations::ExpectationNotMetError,
-                     /expected #{open_struct.class} ID=#{id} relationship: #{predicate.inspect}/
-  end
-
-  it 'requires :with_objects option' do
-    expect {
-      expect(open_struct).to have_predicate(predicate)
-    }.to(
-      raise_error(
-        ArgumentError,
-        "expect(subject).to have_predicate(<predicate>).with_objects(<objects[]>)"
-      )
-    )
-  end
-end

data/spec/unit/schema_indexing_strategy_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ActiveFedora::SchemaIndexingStrategy do
-  subject(:index_strategy) { 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(:index_strategy) { described_class.new }
-      it "does not try to index it" do
-        index_strategy.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 "applies that one" do
-        index_strategy.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 "applies all of them" do
-        index_strategy.apply(object, property)
-
-        expect(index_configuration).to have_received(:as).with(:symbol, :stored_searchable)
-      end
-    end
-  end
-end

data/spec/unit/scoping_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Scoping::Default do
-  describe "when default_scope is overridden" do
-    before do
-      class Book < ActiveFedora::Base
-        property :published, predicate: ::RDF::Vocab::EBUCore.pubStatus do |index|
-          index.as :symbol
-        end
-
-        def self.default_scope
-          where published_ssim: 'true'
-        end
-      end
-
-      Book.destroy_all
-      Book.create!(published: [true])
-      Book.create!(published: [true])
-      Book.create!(published: [false])
-    end
-
-    after do
-      Object.send(:remove_const, :Book)
-    end
-
-    it "returns only the scoped records" do
-      expect(Book.all.size).to eq 2
-    end
-
-    it "returns all the records" do
-      Book.unscoped do
-        expect(Book.all.size).to eq 3
-      end
-    end
-  end
-
-  describe "when default_scope is called" do
-    before do
-      class Book < ActiveFedora::Base
-        property :published, predicate: ::RDF::Vocab::EBUCore.pubStatus do |index|
-          index.as :symbol
-        end
-
-        default_scope -> { where published_ssim: 'true' }
-      end
-
-      Book.destroy_all
-      Book.create!(published: [true])
-      Book.create!(published: [true])
-      Book.create!(published: [false])
-    end
-
-    after do
-      Object.send(:remove_const, :Book)
-    end
-
-    it "returns only the scoped records" do
-      expect(Book.all.size).to eq 2
-    end
-
-    it "returns all the records" do
-      Book.unscoped do
-        expect(Book.all.size).to eq 3
-      end
-    end
-  end
-end