active-fedora 13.1.2 → 13.1.3

data/spec/unit/inheritance_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before do
-    class MyDS < ActiveFedora::File
-    end
-
-    class MySample < ActiveFedora::File
-    end
-
-    class MyDeepSample < MySample
-    end
-
-    class Foo < ActiveFedora::Base
-      has_subresource 'foostream', class_name: 'MyDS'
-      has_subresource 'dcstream', class_name: 'MySample'
-    end
-
-    class Bar < ActiveFedora::Base
-      has_subresource 'barstream', class_name: 'MyDS'
-    end
-
-    class Baz < Bar
-    end
-  end
-
-  subject(:attached_files) { f.attached_files }
-  let(:f) { Foo.new }
-
-  it "doesn't overwrite stream specs" do
-    expect(attached_files.values).to match_array [MyDS, MySample]
-  end
-
-  context 'base_class' do
-    it 'shallow < Base' do
-      expect(Bar.base_class).to eq(Bar)
-    end
-
-    it 'deep < Base' do
-      expect(Baz.base_class).to eq(Bar)
-    end
-
-    it 'shallow < File' do
-      expect(MySample.base_class).to eq(ActiveFedora::File)
-    end
-
-    it 'deep < File' do
-      expect(MyDeepSample.base_class).to eq(ActiveFedora::File)
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :Baz)
-    Object.send(:remove_const, :Bar)
-    Object.send(:remove_const, :Foo)
-    Object.send(:remove_const, :MyDS)
-    Object.send(:remove_const, :MyDeepSample)
-    Object.send(:remove_const, :MySample)
-  end
-end

data/spec/unit/ldp_resource_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::LdpResource do
-  let(:obj) { ActiveFedora::Base.create! }
-  let!(:r1) { described_class.new(ActiveFedora.fedora.connection, obj.uri) }
-  let!(:r2) { described_class.new(ActiveFedora.fedora.connection, obj.uri) }
-
-  it "caches requests" do
-    expect_any_instance_of(Faraday::Connection).to receive(:get).once.and_call_original
-    ActiveFedora::Base.cache do
-      r1.get
-      r2.get
-    end
-  end
-end

data/spec/unit/loadable_from_json_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::LoadableFromJson::SolrBackedResource do
-  before do
-    class Foo < ActiveFedora::Base
-      belongs_to :bar, predicate: ::RDF::Vocab::DC.extent
-    end
-
-    class Bar < ActiveFedora::Base
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :Foo)
-    Object.send(:remove_const, :Bar)
-  end
-
-  let(:resource) { described_class.new(Foo) }
-
-  before do
-    resource.insert [nil, ::RDF::Vocab::DC.extent, RDF::URI('http://example.org/123')]
-  end
-
-  describe "#query" do
-    describe "a known relationship" do
-      subject(:resources) { resource.query(predicate: ::RDF::Vocab::DC.extent) }
-
-      it "is enumerable" do
-        expect(resources.map(&:object)).to eq [RDF::URI('http://example.org/123')]
-      end
-    end
-
-    describe "a unknown relationship" do
-      subject(:resources) { resource.query(predicate: ::RDF::Vocab::DC.accrualPeriodicity) }
-      it "raises an error" do
-        expect { resources }.to raise_error "Unable to find reflection for http://purl.org/dc/terms/accrualPeriodicity in Foo"
-      end
-    end
-  end
-end

data/spec/unit/logger_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  let(:logger1) { instance_double(::Logger, debug?: false) }
-
-  before do
-    @initial_logger = described_class.logger
-    described_class.logger = logger1
-  end
-
-  after do
-    described_class.logger = @initial_logger
-  end
-
-  it "Allows loggers to be set" do
-    expect(logger1).to receive(:warn).with("Hey")
-    described_class.new.logger.warn "Hey"
-  end
-end

data/spec/unit/model_classifier_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::ModelClassifier do
-  module ParentClass
-    class SiblingClass
-    end
-    class OtherSiblingClass
-    end
-    class SubclassClass < SiblingClass
-    end
-  end
-
-  subject(:classifier) { described_class.new class_names }
-  let(:class_names) { ["ParentClass::SiblingClass", "ParentClass::OtherSiblingClass", "ParentClass::SubclassClass", "ParentClass::NoSuchClass"] }
-
-  describe ".class_from_string" do
-    it "returns class constants based on strings" do
-      expect(described_class.class_from_string("String")).to eq String
-      expect(described_class.class_from_string("ActiveFedora::RDF::IndexingService")).to eq ActiveFedora::RDF::IndexingService
-      expect(described_class.class_from_string("IndexingService", ActiveFedora::RDF)).to eq ActiveFedora::RDF::IndexingService
-    end
-
-    it "finds sibling classes" do
-      expect(described_class.class_from_string("SiblingClass", ParentClass::OtherSiblingClass)).to eq ParentClass::SiblingClass
-    end
-
-    it "raises a NameError if the class isn't found" do
-      expect {
-        described_class.class_from_string("FooClass", ParentClass::OtherSiblingClass)
-      }.to raise_error NameError, /uninitialized constant (Object::)?FooClass/
-    end
-  end
-
-  describe '#models' do
-    it 'converts class names to classes' do
-      expect(classifier.models).to match_array [ParentClass::SiblingClass, ParentClass::OtherSiblingClass, ParentClass::SubclassClass]
-    end
-  end
-
-  describe '#best_model' do
-    it 'selects the most specific matching model' do
-      expect(classifier.best_model(default: nil)).to eq ParentClass::SubclassClass
-    end
-
-    it 'filters models to subclasses of the default' do
-      expect(classifier.best_model(default: ActiveFedora::Base)).to eq ActiveFedora::Base
-    end
-  end
-end

data/spec/unit/ordered_spec.rb

@@ -1,367 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Orders do
-  subject(:image) { Image.new }
-  before do
-    class Member < ActiveFedora::Base
-    end
-    class BadClass < ActiveFedora::Base
-    end
-    class Image < ActiveFedora::Base
-      ordered_aggregation :members, through: :list_source
-    end
-  end
-  after do
-    Object.send(:remove_const, :Image)
-    Object.send(:remove_const, :Member)
-    Object.send(:remove_const, :BadClass)
-  end
-  describe "<<" do
-    it "does not accept base objects" do
-      member = Member.new
-      expect { image.ordered_member_proxies << member }.to raise_error ActiveFedora::AssociationTypeMismatch
-      expect(image).not_to be_changed
-      expect(image.list_source).not_to be_changed
-    end
-  end
-
-  describe "ordered_by" do
-    let(:image) { Image.new }
-
-    context "an element aggregated by one record" do
-      it "can find the record that contains it" do
-        m = Member.create
-        image.ordered_members << m
-        image.save
-
-        expect(m.ordered_by.to_a).to eq [image]
-      end
-    end
-
-    context "a new element" do
-      it "returns an empty array" do
-        m = Member.new
-        expect(m.ordered_by.to_a).to eq []
-      end
-    end
-
-    context "an element aggregated by multiple records" do
-      let(:image2) { Image.new }
-      it "can find all of the records that contain it" do
-        m = Member.create
-        image.ordered_members << m
-        image2.ordered_members << m
-        image.save
-        image2.save
-        expect(m.ordered_by).to contain_exactly(image2, image)
-      end
-    end
-  end
-
-  describe "#ordered_members" do
-    describe "<<" do
-      it "appends" do
-        member = Member.new
-        image.save!
-        expect(image.ordered_members << member).to eq [member]
-        expect(image.ordered_members).to eq [member]
-        expect(image.members).to eq [member]
-        expect(image.ordered_member_proxies.to_a.length).to eq 1
-        image.save!
-        expect(image.head).not_to be_blank
-        expect(image.reload.head).not_to be_blank
-      end
-      it "maintains member associations" do
-        member = Member.create
-        image.ordered_members << member
-        image.save
-        image.reload
-        expect(image.members).to eq [member]
-      end
-    end
-    describe "#=" do
-      it "sets ordered members" do
-        member = Member.new
-        member_2 = Member.new
-        image.ordered_members << member
-        expect(image.ordered_members).to eq [member]
-        image.ordered_members = [member_2, member_2]
-        expect(image.ordered_members).to eq [member_2, member_2]
-        # Removing from ordering is not the same as removing from aggregation.
-        expect(image.members).to contain_exactly member, member_2
-      end
-    end
-    describe "+=" do
-      it "appends ordered members" do
-        member = Member.new
-        member_2 = Member.new
-        image.ordered_members << member
-        expect(image.ordered_members += [member, member_2]).to eq [member, member, member_2]
-        expect(image.ordered_members).to eq [member, member, member_2]
-        expect(image.ordered_member_proxies.map(&:target)).to eq [member, member, member_2]
-      end
-    end
-    describe "#delete_at" do
-      it "deletes that position" do
-        member = Member.new
-        member_2 = Member.new
-        image.ordered_members += [member, member_2]
-
-        expect(image.ordered_members.delete_at(0)).to eq member
-        expect(image.ordered_members).to eq [member_2]
-      end
-    end
-
-    describe "#delete" do
-      let(:member) { Member.create }
-      let(:member_2) { Member.create }
-      before do
-        image.ordered_members += [member, member_2, member]
-        image.save!
-      end
-
-      context "with an object found in the list" do
-        it "deletes all occurences of the object" do
-          expect(image.ordered_members.delete(member)).to eq member
-          expect(image.ordered_members.to_a).to eq [member_2]
-        end
-        it "can delete all" do
-          expect(image.ordered_members.delete(member)).to eq member
-          expect(image.ordered_members.delete(member_2)).to eq member_2
-          image.save!
-          expect(image.reload.ordered_members.to_a).to eq []
-        end
-      end
-
-      context "with an object not found in the list" do
-        it "returns nil" do
-          expect(image.ordered_members.delete(Member.create)).to be_nil
-          expect(image.ordered_members.to_a).to eq [member, member_2, member]
-        end
-      end
-    end
-
-    describe "#insert_at" do
-      it "adds at a given position" do
-        member = Member.new
-        member_2 = Member.new
-        image.ordered_members += [member, member_2]
-
-        image.ordered_members.insert_at(0, member_2)
-        expect(image.ordered_members).to eq [member_2, member, member_2]
-      end
-      it "adds a proxy_in statement" do
-        member = Member.new
-        member_2 = Member.new
-        image.ordered_members += [member, member_2]
-
-        image.ordered_members.insert_at(0, member_2)
-        expect(image.ordered_member_proxies.map(&:proxy_in).uniq).to eq [image]
-      end
-    end
-    describe "lazy loading" do
-      it "does not instantiate every record on append" do
-        member = Member.new
-        member_2 = Member.new
-        image.ordered_members += [member, member_2]
-        image.save
-        allow(ActiveFedora::Base).to receive(:find).and_call_original
-
-        reloaded = image.class.find(image.id)
-        reloaded.ordered_members << member
-
-        expect(ActiveFedora::Base).not_to have_received(:find).with(member_2.id)
-      end
-      it "does not instantiate every record on #insert_at" do
-        member = Member.new
-        member_2 = Member.new
-        image.ordered_members += [member, member_2]
-        image.save
-        allow(ActiveFedora::Base).to receive(:find).and_call_original
-
-        reloaded = image.class.find(image.id)
-        reloaded.ordered_members.insert_at(0, member)
-
-        expect(ActiveFedora::Base).not_to have_received(:find).with(member_2.id)
-      end
-    end
-  end
-  describe "append_target" do
-    it "doesn't add all members" do
-      member = Member.new
-      image.members << member
-      expect(image.ordered_members).to eq []
-    end
-    it "can handle adding many objects" do
-      member = Member.new
-      60.times do
-        image.ordered_member_proxies.append_target member
-      end
-      expect(image.ordered_member_proxies.to_a.length).to eq 60
-    end
-    it "can't add items not accepted by indirect container" do
-      bad_class = BadClass.new
-      expect { image.ordered_member_proxies.append_target bad_class }.to raise_error ActiveFedora::AssociationTypeMismatch
-    end
-    it "adds a member if it doesn't exist in members" do
-      member = Member.new
-      image.ordered_member_proxies.append_target member
-      expect(image.members).to eq [member]
-      expect(image.ordered_members).to eq [member]
-    end
-    it "doesn't add a member twice" do
-      member = Member.new
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      expect(image.members).to eq [member]
-      expect(image.ordered_members).to eq [member, member]
-    end
-    it "survives persistence" do
-      member = Member.new
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      image.save
-      image.reload
-      expect(image.ordered_members).to eq [member, member]
-      expect(image.ordered_member_ids).to eq [member.id, member.id]
-      expect(image.list_source.resource.query([nil, ::RDF::Vocab::ORE.proxyIn, image.resource.rdf_subject]).to_a.length).to eq 2
-      expect(image.head_ids).to eq image.list_source.head_id
-      expect(image.tail_ids).to eq image.list_source.tail_id
-    end
-    it "can add already persisted items" do
-      member = Member.create
-      image.ordered_member_proxies.append_target member
-      image.save
-      image.reload
-      expect(image.ordered_members).to eq [member]
-    end
-    it "can append to a pre-persisted item" do
-      member = Member.new
-      image.ordered_member_proxies.append_target member
-      image.save
-      image.reload
-      member_2 = Member.new
-      image.ordered_member_proxies.append_target member_2
-      image.save
-      image.reload
-      expect(image.ordered_members).to eq [member, member_2]
-    end
-  end
-  describe "insert_target_at" do
-    it "can add between items" do
-      member = Member.new
-      member2 = Member.new
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.insert_target_at(1, member2)
-      expect(image.ordered_members).to eq [member, member2, member]
-      image.save
-      image.reload
-      expect(image.ordered_members).to eq [member, member2, member]
-      image.ordered_member_proxies.insert_target_at(2, member2)
-      image.save
-      image.reload
-      expect(image.ordered_members).to eq [member, member2, member2, member]
-    end
-  end
-  describe "insert_target_id_at" do
-    it "can add between items" do
-      member = Member.create
-      member2 = Member.create
-      image.ordered_members += [member, member2]
-
-      allow(ActiveFedora::Base).to receive(:find).and_call_original
-      image.ordered_member_proxies.insert_target_id_at(1, member2.id)
-      expect(ActiveFedora::Base).not_to have_received(:find).with(member2.id)
-      expect(image.ordered_members).to eq [member, member2, member2]
-      expect(ActiveFedora::Base).to have_received(:find).with(member2.id)
-    end
-    context "when given a nil id" do
-      it "raises an ArgumentError" do
-        expect { image.ordered_member_proxies.insert_target_id_at(0, nil) }.to raise_error ArgumentError, "ID can not be nil"
-      end
-    end
-    context "when given an ID not in members" do
-      it "raises an ArgumentError" do
-        expect { image.ordered_member_proxies.insert_target_id_at(0, "test") }.to raise_error "test is not a part of members"
-      end
-    end
-  end
-  describe "-=" do
-    it "can remove proxies" do
-      member = Member.new
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies -= [image.ordered_member_proxies.last]
-      expect(image.ordered_members).to eq []
-      expect(image.list_source.resource.statements.to_a.length).to eq 1
-    end
-    it "can remove proxies in the middle" do
-      member = Member.new
-      member_2 = Member.new
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member_2
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies -= [image.ordered_member_proxies[1]]
-      expect(image.ordered_members).to eq [member, member]
-    end
-    it "can remove proxies post-create" do
-      member = Member.new
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      image.save
-      image.reload
-      image.ordered_member_proxies -= [image.ordered_member_proxies[1]]
-      expect(image.ordered_members).to eq [member, member]
-      image.save
-      image.reload
-      expect(image.ordered_members).to eq [member, member]
-      # THIS NEEDS TO PASS - can't delete fragment URI resources via sparql
-      # update?
-      # Blocked by https://jira.duraspace.org/browse/FCREPO-1764
-      # expect(image.list_source.resource.subjects.to_a.length).to eq 5
-    end
-  end
-  describe ".delete_at" do
-    it "can remove in the middle" do
-      member = Member.new
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.delete_at(1)
-      expect(image.ordered_members).to eq [member, member]
-    end
-    it "returns the node" do
-      member = Member.new
-      image.ordered_members << member
-      image.ordered_members << member
-      second_node = image.ordered_member_proxies[1]
-      expect(image.ordered_member_proxies.delete_at(1)).to eq second_node
-    end
-    context "when the node doesn't exist" do
-      it "returns nil" do
-        expect(image.ordered_member_proxies.delete_at(0)).to eq nil
-      end
-    end
-    it "doesn't do anything if passed a bad value" do
-      member = Member.new
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.delete_at(3)
-      image.ordered_member_proxies.delete_at(nil)
-      expect(image.ordered_members).to eq [member, member, member]
-    end
-    it "can persist a deletion" do
-      member = Member.new
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      image.ordered_member_proxies.append_target member
-      expect(image.ordered_members).to eq [member, member, member]
-      image.ordered_member_proxies.delete_at(1)
-      image.save
-      image.reload
-      expect(image.ordered_members).to eq [member, member]
-    end
-  end
-end