active-fedora 13.1.2 → 13.2.4

data/spec/unit/aggregation/ordered_reader_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ActiveFedora::Aggregation::OrderedReader do
-  subject(:ordered_reader) { described_class.new(root) }
-  let(:root) { instance_double(ActiveFedora::Aggregation::ListSource) }
-
-  describe "#each" do
-    it "iterates a linked list" do
-      head = build_node
-      tail = build_node(prev_node: head)
-      allow(head).to receive(:next).and_return(tail)
-      allow(root).to receive(:head).and_return(head)
-      expect(ordered_reader.to_a).to eq [head, tail]
-    end
-    it "only goes as deep as necessary" do
-      head = build_node
-      tail = build_node(prev_node: head)
-      allow(head).to receive(:next).and_return(tail)
-      allow(root).to receive(:head).and_return(head)
-      expect(ordered_reader.first).to eq head
-      expect(head).not_to have_received(:next)
-    end
-    context "when the prev is wrong" do
-      it "fixes it up" do
-        head = build_node
-        bad_node = build_node
-        tail = build_node(prev_node: bad_node)
-        allow(head).to receive(:next).and_return(tail)
-        allow(root).to receive(:head).and_return(head)
-        allow(tail).to receive(:prev=)
-        expect(ordered_reader.to_a).to eq [head, tail]
-        expect(tail).to have_received(:prev=).with(head)
-      end
-    end
-  end
-
-  def build_node(prev_node: nil, next_node: nil)
-    node = instance_double(ActiveFedora::Orders::ListNode)
-    allow(node).to receive(:next).and_return(next_node)
-    allow(node).to receive(:prev).and_return(prev_node)
-    node
-  end
-end

data/spec/unit/association_hash_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::AssociationHash do
-  subject(:association_hash) { described_class.new(model, reflections) }
-
-  let(:model) { instance_double(ActiveFedora::Base, association: nil) }
-  let(:reflections) { { foo: association } }
-  let(:reader) { double("reader") }
-  let(:writer) { double("writer") }
-  let(:association) { double(reader: reader, writer: writer) }
-
-  before do
-    allow(model).to receive(:association).with(:foo).and_return(association)
-  end
-
-  describe "key reader" do
-    describe "when the association exists" do
-      it "calls the association reader" do
-        expect(association_hash["foo"]).to eq(reader)
-      end
-    end
-    describe "when the association does not exist" do
-      it "returns nil" do
-        expect(association_hash["bar"]).to be_nil
-      end
-    end
-  end
-
-  describe "key setter" do
-    let(:obj) { double }
-    describe "when the association exists" do
-      it "calls the association writer" do
-        expect(association).to receive(:writer).with(obj)
-        association_hash["foo"] = obj
-      end
-    end
-    describe "when the association does not exist" do
-      it "doesn't call the association writer" do
-        expect(association).not_to receive(:writer).with(obj)
-        association_hash["bar"] = obj
-      end
-    end
-  end
-
-  describe "#association" do
-    it "works with a string key" do
-      expect(association_hash.association("foo")).to eq(association)
-    end
-    it "works with a symbol key" do
-      expect(association_hash.association(:foo)).to eq(association)
-    end
-  end
-
-  describe "#key?" do
-    it "works with a string" do
-      expect(association_hash.key?("foo")).to be true
-      expect(association_hash.key?("bar")).to be false
-    end
-    it "works with a symbol" do
-      expect(association_hash.key?(:foo)).to be true
-      expect(association_hash.key?(:bar)).to be false
-    end
-  end
-end

data/spec/unit/attached_files_spec.rb

@@ -1,218 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::AttachedFiles do
-  subject(:af_base) { ActiveFedora::Base.new }
-  describe "has_subresource" do
-    before do
-      class Sample1 < ActiveFedora::File
-      end
-      class Sample2 < ActiveFedora::File
-      end
-      class FooHistory < ActiveFedora::Base
-        has_subresource 'dsid', class_name: 'Sample2'
-        has_subresource 'complex_ds', autocreate: true, class_name: 'Sample1'
-        has_subresource 'thumbnail'
-        has_subresource 'child_resource', class_name: 'ActiveFedora::Base'
-      end
-    end
-    after do
-      Object.send(:remove_const, :Sample1)
-      Object.send(:remove_const, :Sample2)
-      Object.send(:remove_const, :FooHistory)
-    end
-
-    it "has a child_resource_reflection" do
-      expect(FooHistory.child_resource_reflections).to have_key(:dsid)
-      expect(FooHistory.child_resource_reflections).to have_key(:thumbnail)
-      expect(FooHistory.child_resource_reflections).not_to have_key(:child_resource)
-    end
-
-    it "lets you override defaults" do
-      expect(FooHistory.child_resource_reflections[:complex_ds].options).to include(autocreate: true)
-      expect(FooHistory.child_resource_reflections[:complex_ds].class_name).to eq 'Sample1'
-    end
-
-    it "raises an error if you don't give a dsid" do
-      expect { FooHistory.has_subresource nil, type: Sample2 }.to raise_error ArgumentError,
-                                                                              "You must provide a path name (f.k.a. dsid) for the resource"
-    end
-  end
-
-  describe "#add_file" do
-    before do
-      class Bar < ActiveFedora::File; end
-
-      class FooHistory < ActiveFedora::Base
-        has_subresource :content, class_name: 'Bar'
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :Bar)
-      Object.send(:remove_const, :FooHistory)
-    end
-    let(:container) { FooHistory.new }
-
-    context "a reflection matches the :path property" do
-      it "builds the reflection" do
-        container.add_file('blah', path: 'content')
-        expect(container.content).to be_instance_of Bar
-        expect(container.content.content).to eq 'blah'
-      end
-    end
-
-    context "no reflection matches the :path property" do
-      it "creates a singleton reflection and build it" do
-        container.add_file('blah', path: 'fizz')
-        expect(container.fizz).to be_instance_of ActiveFedora::File
-        expect(container.fizz.content).to eq 'blah'
-      end
-    end
-  end
-
-  describe "#declared_attached_files" do
-    subject { obj.declared_attached_files }
-
-    context "when there are undeclared attached files" do
-      let(:obj) { ActiveFedora::Base.create }
-      let(:file) { ActiveFedora::File.new }
-      before do
-        obj.attach_file(file, 'Abc')
-      end
-      it { is_expected.to be_empty }
-    end
-
-    context "when there are declared attached files" do
-      before do
-        class FooHistory < ActiveFedora::Base
-          has_subresource 'thumbnail'
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :FooHistory)
-      end
-      let(:obj) { FooHistory.new }
-      it { is_expected.to have_key :thumbnail }
-    end
-  end
-
-  describe "#serialize_attached_files" do
-    it "touches each file" do
-      m1 = instance_double(ActiveFedora::File)
-      m2 = instance_double(ActiveFedora::File)
-
-      expect(m1).to receive(:serialize!)
-      expect(m2).to receive(:serialize!)
-      allow(af_base).to receive(:declared_attached_files).and_return(m1: m1, m2: m2)
-      af_base.serialize_attached_files
-    end
-  end
-
-  describe "#accessor_name" do
-    subject { af_base.send(:accessor_name, value) }
-    context "with lowercase" do
-      let(:value) { 'abc' }
-      it { is_expected.to eq 'abc' }
-    end
-
-    context "with uppercase" do
-      let(:value) { 'ARCHIVAL_XML' }
-      it { is_expected.to eq 'ARCHIVAL_XML' }
-    end
-
-    context "with camelcase" do
-      let(:value) { 'descMetadata' }
-      it { is_expected.to eq 'descMetadata' }
-    end
-
-    context "with dashes" do
-      let(:value) { 'a-b' }
-      it { is_expected.to eq 'a_b' }
-    end
-  end
-
-  describe "#attached_files" do
-    it "returns the datastream hash proxy" do
-      allow(af_base).to receive(:load_datastreams)
-      expect(af_base.attached_files).to be_a_kind_of(ActiveFedora::FilesHash)
-    end
-  end
-
-  describe "#attach_file" do
-    let(:file) { ActiveFedora::File.new }
-
-    it "does not call save on the file" do
-      expect(file).to receive(:save).never
-      af_base.attach_file(file, 'part1')
-    end
-
-    it "adds the file to the attached_files hash" do
-      expect {
-        af_base.attach_file(file, 'part1')
-      }.to change { af_base.attached_files.key?(:part1) }.from(false).to(true)
-    end
-
-    context "after attaching the file" do
-      let(:dsid) { 'Abc' }
-      before do
-        af_base.attach_file(file, dsid)
-      end
-
-      it "adds the datastream to the object" do
-        expect(af_base.attached_files['Abc']).to eq file
-      end
-
-      describe "dynamic accessors" do
-        context "when the file is named with dash" do
-          let(:dsid) { 'eac-cpf' }
-          it "converts dashes to underscores" do
-            expect(af_base.eac_cpf).to eq file
-          end
-        end
-
-        context "when the file is named with underscore" do
-          let(:dsid) { 'foo_bar' }
-          it "preserves the underscore" do
-            expect(af_base.foo_bar).to eq file
-          end
-        end
-      end
-    end
-  end
-
-  describe "#metadata_streams" do
-    it "only is metadata datastreams" do
-      ds1 = instance_double(ActiveFedora::File, metadata?: true)
-      ds2 = instance_double(ActiveFedora::File, metadata?: true)
-      ds3 = instance_double(ActiveFedora::File, metadata?: true)
-      file_ds = instance_double(ActiveFedora::File, metadata?: false)
-      allow(af_base).to receive(:attached_files).and_return(a: ds1, b: ds2, c: ds3, e: file_ds)
-      expect(af_base.metadata_streams).to include(ds1, ds2, ds3)
-      expect(af_base.metadata_streams).to_not include(file_ds)
-    end
-  end
-
-  context "When the resource is using idiomatic basic containment" do
-    before do
-      class Sample1 < ActiveFedora::Base
-        is_a_container
-      end
-    end
-    after do
-      Object.send(:remove_const, :Sample1)
-    end
-
-    before do
-      child = obj.contains.build
-      child.content = "Stuff"
-      child.save!
-    end
-    let(:obj) { Sample1.create! }
-    let(:obj2) { Sample1.find(obj.id) }
-
-    it "doesn't conflate attached_file and contains" do
-      expect(obj2.attached_files.keys).to be_empty
-    end
-  end
-end

data/spec/unit/attributes_spec.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  context "when properties are defined on an object" do
-    before :all do
-      class BarHistory4 < ActiveFedora::Base
-        property :title, predicate: ::RDF::Vocab::DC.title do |index|
-          index.as :symbol
-        end
-        property :abstract, predicate: ::RDF::Vocab::DC.abstract, multiple: false
-      end
-    end
-
-    after :all do
-      Object.send(:remove_const, :BarHistory4)
-    end
-
-    subject(:history) { obj }
-    let(:obj) { BarHistory4.new(title: ['test1'], id: 'test:123') }
-
-    describe "#attribute_names" do
-      context "on an instance" do
-        it "lists the attributes" do
-          expect(history.attribute_names).to eq ["title", "abstract"]
-        end
-      end
-
-      context "on a class" do
-        it "lists the attributes" do
-          expect(BarHistory4.attribute_names).to eq ["title", "abstract"]
-        end
-      end
-    end
-
-    describe "#inspect" do
-      it "shows the attributes" do
-        expect(history.inspect).to eq "#<BarHistory4 id: \"test:123\", title: [\"test1\"], abstract: nil>"
-      end
-
-      describe "with no attributes" do
-        subject(:object) { described_class.new }
-        it "shows a id" do
-          expect(object.inspect).to eq "#<ActiveFedora::Base id: nil>"
-        end
-      end
-
-      describe "with relationships" do
-        before do
-          class BarHistory2 < BarHistory4
-            belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasConstituent, class_name: 'BarHistory4'
-          end
-          history.library = library
-        end
-
-        subject(:history) { BarHistory2.new }
-        let(:library) { BarHistory4.create }
-
-        after do
-          Object.send(:remove_const, :BarHistory2)
-        end
-
-        it "shows the library_id" do
-          expect(history.inspect).to eq "#<BarHistory2 id: nil, title: [], abstract: nil, library_id: \"#{library.id}\">"
-        end
-      end
-    end
-
-    describe "#unique?" do
-      it "reveals the unique properties" do
-        expect(BarHistory4.unique?(:abstract)).to be true
-        expect(BarHistory4.unique?(:title)).to be false
-      end
-    end
-
-    describe "accessing attributes" do
-      context "using generated methods" do
-        it "returns values" do
-          expect(history.title).to eq ['test1']
-        end
-      end
-
-      context "using hash accessors" do
-        context "on single value fields" do
-          it "has a default value" do
-            expect(history[:abstract]).to be_nil
-          end
-
-          context "when there are two assertions for the predicate" do
-            before do
-              history.resource[:abstract] = ['foo', 'bar']
-            end
-            it "raises an error if just returning the first value would cause data loss" do
-              expect { history[:abstract] }.to raise_error ActiveFedora::ConstraintError, "Expected \"abstract\" of test:123 to have 0-1 statements, but there are 2"
-            end
-          end
-        end
-
-        context "multiple values" do
-          it "returns values" do
-            expect(history[:title]).to eq ['test1']
-          end
-        end
-
-        context "on Fedora attributes" do
-          it "return values" do
-            expect(history[:type]).to be_empty
-            expect(history[:rdf_label]).to contain_exactly("test1")
-          end
-        end
-      end
-    end
-
-    describe 'change tracking' do
-      it "is able to track change status" do
-        expect {
-          history.abstract = "Moo"
-        }.to change { history.abstract_changed? }.from(false).to(true)
-      end
-    end
-
-    describe "indexing" do
-      let(:solr_doc) { obj.to_solr }
-
-      it "indexs the attributes" do
-        expect(solr_doc['title_ssim']).to eq ['test1']
-      end
-    end
-
-    describe "when an object of the wrong cardinality is set" do
-      it "does not allow passing a string to a multiple property writer" do
-        expect { history.title = "Quack" }.to raise_error ArgumentError
-        expect { history.title = ["Quack"] }.not_to raise_error
-        expect { history.title = nil }.not_to raise_error
-        expect { history.title = ActiveTriples::Resource.new }.to raise_error
-      end
-
-      it "does not allow an enumerable to a unique attribute writer" do
-        expect { history.abstract = "Low" }.not_to raise_error
-        expect { history.abstract = ["Low"] }
-          .to raise_error ArgumentError, "You attempted to set the property `abstract' of test:123 to an enumerable value. However, this property is declared as singular."
-        expect { history.abstract = nil }.not_to raise_error
-        expect { history.abstract = ActiveTriples::Resource.new }.not_to raise_error
-      end
-    end
-  end
-end