active-fedora 9.13.0 → 10.0.0.beta1

data/spec/integration/field_to_solr_name_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe "An object with RDF backed attributes" do
-  before do
-    class MyMetadata < ActiveFedora::NtriplesRDFDatastream
-      Deprecation.silence(ActiveFedora::RDFDatastream) do
-        property :title, predicate: ::RDF::Vocab::DC.title do |index|
-          index.as :stored_searchable
-        end
-        property :date_uploaded, predicate: ::RDF::Vocab::DC.dateSubmitted do |index|
-          index.type :date
-          index.as :stored_searchable, :sortable
-        end
-      end
-    end
-    class TestOne < ActiveFedora::Base
-      has_subresource 'descMetadata', class_name: 'MyMetadata'
-      Deprecation.silence(ActiveFedora::Attributes) do
-        has_attributes :title, :date_uploaded, datastream: 'descMetadata'
-      end
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :TestOne)
-    Object.send(:remove_const, :MyMetadata)
-  end
-
-  it "is able to grab the solr name" do
-    expect(TestOne.delegated_attributes[:title].primary_solr_name).to eq 'desc_metadata__title_tesim'
-  end
-
-  it "is able to grab the solr name for a date" do
-    expect(TestOne.delegated_attributes[:date_uploaded].primary_solr_name).to eq 'desc_metadata__date_uploaded_dtsim'
-  end
-end

data/spec/unit/base_datastream_management_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  describe '.attach_file' do
-    let(:test_object) { described_class.new }
-    let(:ds) { ActiveFedora::File.new(@test_object, 'ds_to_add') }
-
-    it "does not call File.save" do
-      expect(ds).to receive(:save).never
-      test_object.attach_file(ds, 'ds1')
-    end
-
-    it "adds the datastream to the datastreams_in_memory array" do
-      expect(test_object.attached_files).to_not have_key(:ds_to_add)
-      test_object.attach_file(ds, 'ds_to_add')
-      expect(test_object.attached_files).to have_key(:ds_to_add)
-    end
-  end
-end

data/spec/unit/model_spec.rb

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

data/spec/unit/predicates_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Predicates do
-  describe "#short_predicate" do
-    it 'parses strings' do
-      expect(described_class.short_predicate('http://www.openarchives.org/OAI/2.0/itemID')).to eq :oai_item_id
-    end
-    it 'parses uris' do
-      expect(described_class.short_predicate(RDF::Vocab::DC.creator)).to eq 'dc_terms_creator'
-      expect(described_class.short_predicate(RDF::SKOS.hasTopConcept)).to eq '2004_02_skos_core_has_top_concept'
-    end
-    before do
-      @original_mapping = described_class.predicate_config[:predicate_mapping]
-    end
-    after do
-      described_class.predicate_config[:predicate_mapping] = @original_mapping
-    end
-    it "finds predicates regardless of order loaded or shared namespace prefixes" do
-      described_class.predicate_config[:predicate_mapping] = {
-        "http://example.org/" => { ceo: 'Manager' },
-        "http://example.org/zoo/wolves/" => { alpha: 'Manager' },
-        "http://example.org/zoo/" => { keeper: 'Manager' }
-      }
-      expect(described_class.short_predicate("http://example.org/zoo/Manager")).to eq :keeper
-      expect(described_class.short_predicate("http://example.org/zoo/wolves/Manager")).to eq :alpha
-      expect(described_class.short_predicate("http://example.org/Manager")).to eq :ceo
-    end
-  end
-
-  it 'provides .default_predicate_namespace' do
-    expect(described_class.default_predicate_namespace).to eq 'info:fedora/fedora-system:def/relations-external#'
-  end
-
-  describe "#predicate_mappings" do
-    it 'returns a hash' do
-      expect(described_class.predicate_mappings).to be_kind_of Hash
-    end
-
-    it "provides mappings to the fedora ontology via the info:fedora/fedora-system:def/relations-external# default namespace mapping" do
-      expect(described_class.predicate_mappings.keys.include?(described_class.default_predicate_namespace)).to be true
-      expect(described_class.predicate_mappings[described_class.default_predicate_namespace]).to be_kind_of Hash
-    end
-
-    it 'provides predicate mappings for entire Fedora Relationship Ontology' do
-      desired_mappings = Hash[is_member_of: "isMemberOf",
-                              has_member: "hasMember",
-                              is_part_of: "isPartOf",
-                              has_part: "hasPart",
-                              is_member_of_collection: "isMemberOfCollection",
-                              has_collection_member: "hasCollectionMember",
-                              is_constituent_of: "isConstituentOf",
-                              has_constituent: "hasConstituent",
-                              is_subset_of: "isSubsetOf",
-                              has_subset: "hasSubset",
-                              is_derivation_of: "isDerivationOf",
-                              has_derivation: "hasDerivation",
-                              is_dependent_of: "isDependentOf",
-                              has_dependent: "hasDependent",
-                              is_description_of: "isDescriptionOf",
-                              has_description: "hasDescription",
-                              is_metadata_for: "isMetadataFor",
-                              has_metadata: "hasMetadata",
-                              is_annotation_of: "isAnnotationOf",
-                              has_annotation: "hasAnnotation",
-                              has_equivalent: "hasEquivalent",
-                              conforms_to: "conformsTo",
-                              has_model: "hasModel"]
-      desired_mappings.each_pair do |k, v|
-        expect(described_class.predicate_mappings[described_class.default_predicate_namespace]).to have_key(k)
-        expect(described_class.predicate_mappings[described_class.default_predicate_namespace][k]).to eq v
-      end
-    end
-  end
-
-  it 'provides #predicate_lookup that maps symbols to common RELS-EXT predicates' do
-    expect(described_class).to respond_to(:predicate_lookup)
-    expect(described_class.predicate_lookup(:is_part_of)).to eq "isPartOf"
-    expect(described_class.predicate_lookup(:is_member_of)).to eq "isMemberOf"
-    expect(described_class.predicate_lookup("isPartOfCollection")).to eq "isPartOfCollection"
-    described_class.predicate_config[:predicate_mapping]["some_namespace"] = { has_foo: "hasFOO" }
-    expect(described_class.find_predicate(:has_foo)).to eq ["hasFOO", "some_namespace"]
-    expect(described_class.predicate_lookup(:has_foo, "some_namespace")).to eq "hasFOO"
-    expect(lambda { described_class.predicate_lookup(:has_foo) }).to raise_error ActiveFedora::UnregisteredPredicateError
-  end
-
-  context 'initialization' do
-    before :each do
-      @old_predicate_config = Marshal.load(Marshal.dump(described_class.predicate_config))
-    end
-
-    after :each do
-      described_class.predicate_config = @old_predicate_config
-    end
-
-    it 'allows explicit initialization of predicates' do
-      expect(described_class.find_predicate(:is_part_of)).to eq ["isPartOf", "info:fedora/fedora-system:def/relations-external#"]
-      described_class.predicate_config = {
-        default_namespace: 'http://example.com/foo',
-        predicate_mapping: {
-          'http://example.com/foo' => { has_bar: 'hasBAR' }
-        }
-      }
-      expect(described_class.find_predicate(:has_bar)).to eq ["hasBAR", "http://example.com/foo"]
-      expect(lambda { described_class.find_predicate(:is_part_of) }).to raise_error ActiveFedora::UnregisteredPredicateError
-    end
-
-    it 'ensures that the configuration has the correct keys' do
-      expect(lambda { described_class.predicate_config = { foo: 'invalid!' } }).to raise_error TypeError
-    end
-
-    it "allows adding predicates without wiping out existing predicates" do
-      described_class.set_predicates("http://projecthydra.org/ns/relations#" => { has_profile: "hasProfile" },
-                                     "info:fedora/fedora-system:def/relations-external#" => {
-                                       references: "references",
-                                       has_derivation: "cameFrom"
-                                     })
-      # New & Modified Predicates
-      expect(described_class.find_predicate(:has_profile)).to eq ["hasProfile", "http://projecthydra.org/ns/relations#"]
-      expect(described_class.find_predicate(:references)).to eq ["references", "info:fedora/fedora-system:def/relations-external#"]
-      expect(described_class.find_predicate(:has_derivation)).to eq ["cameFrom", "info:fedora/fedora-system:def/relations-external#"]
-      # Pre-Existing predicates should be unharmed
-      expect(described_class.find_predicate(:is_part_of)).to eq ["isPartOf", "info:fedora/fedora-system:def/relations-external#"]
-      expect(described_class.find_predicate(:is_governed_by)).to eq ["isGovernedBy", "http://projecthydra.org/ns/relations#"]
-    end
-  end
-end

data/spec/unit/simple_datastream_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::SimpleDatastream do
-  let(:sample_xml) { "<fields><coverage>coverage1</coverage><coverage>coverage2</coverage><creation_date>2012-01-15</creation_date><mydate>fake-date</mydate><publisher>publisher1</publisher></fields>" }
-
-  before do
-    @original_behavior = Deprecation.default_deprecation_behavior
-    Deprecation.default_deprecation_behavior = :silence
-    @test_ds = described_class.new
-    allow(@test_ds).to receive(:retrieve_content).and_return('') # DS grabs the old content to compare against the new
-    @test_ds.content = sample_xml
-    @test_ds.field :coverage
-    @test_ds.field :creation_date, :date
-    @test_ds.field :mydate
-    @test_ds.field :publisher
-  end
-
-  it "ng_xml should parse everything correctly" do
-    expect(@test_ds.ng_xml).to be_equivalent_to sample_xml
-  end
-
-  describe '#new' do
-    describe "model methods" do
-      [:coverage, :mydate, :publisher].each do |el|
-        it "should respond to getters and setters for the string typed #{el} element" do
-          value = "Hey #{el}"
-          @test_ds.send("#{el}=", value)
-          expect(@test_ds.send(el).first).to eq value # Looking at first because creator has 2 nodes
-        end
-      end
-
-      it "sets date elements" do
-        d = Date.parse('1939-05-23')
-        @test_ds.creation_date = d
-        expect(@test_ds.creation_date.first).to eq d
-      end
-    end
-  end
-
-  describe '.to_xml' do
-    it 'outputs the fields hash as Qualified Dublin Core XML' do
-      @test_ds.publisher = "charlie"
-      @test_ds.coverage = ["80%", "20%"]
-
-      expect(@test_ds.to_xml).to be_equivalent_to('
-        <fields>
-          <coverage>80%</coverage>
-          <coverage>20%</coverage>
-          <creation_date>2012-01-15</creation_date>
-          <mydate>fake-date</mydate>
-          <publisher>charlie</publisher>
-        </fields>')
-    end
-  end
-
-  describe "#to_solr" do
-    it "has title" do
-      solr = @test_ds.to_solr
-      expect(solr[ActiveFedora.index_field_mapper.solr_name('publisher', type: :string)]).to eq "publisher1"
-      expect(solr[ActiveFedora.index_field_mapper.solr_name('creation_date', type: :date)]).to eq "2012-01-15"
-    end
-  end
-
-  describe "datastream configuration" do
-    let(:foo) do
-      ActiveFedora::Base.create! do |obj|
-        obj.add_file(%(<?xml version="1.0"?>\n<fields><fubar>test</fubar></fields>), path: 'someData')
-      end
-    end
-    let(:resource) { Ldp::Resource::RdfSource.new(ActiveFedora.fedora.connection, foo.uri) }
-    let(:orm) { Ldp::Orm.new(resource) }
-
-    before do
-      class FooHistory < ActiveFedora::Base
-        extend Deprecation
-        Deprecation.silence(FooHistory) do
-          has_metadata type: ActiveFedora::SimpleDatastream, name: "someData" do |m|
-            m.field "fubar", :string
-          end
-        end
-        Deprecation.silence(ActiveFedora::Attributes) do
-          has_attributes :fubar, datastream: 'someData', multiple: false
-        end
-      end
-
-      orm.graph.delete([orm.resource.subject_uri, ActiveFedora::RDF::Fcrepo::Model.hasModel, nil])
-      orm.graph.insert([orm.resource.subject_uri, ActiveFedora::RDF::Fcrepo::Model.hasModel, 'FooHistory'])
-      orm.save
-      foo.reload
-      foo.update_index
-    end
-
-    after do
-      Object.send(:remove_const, :FooHistory)
-      Deprecation.default_deprecation_behavior = @original_behavior
-    end
-
-    subject { FooHistory.find(foo.id) }
-    its(:fubar) { is_expected.to eq 'test' }
-  end
-end