active-fedora 8.7.0 → 9.0.0.beta1

data/spec/unit/file_path_builder_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe ActiveFedora::FilePathBuilder do
+  describe ".build" do
+    let(:parent) { ActiveFedora::Base.new(id: '1234') }
+    subject { ActiveFedora::FilePathBuilder.build(parent, nil, 'FOO') }
+
+    it { should eq 'FOO1' }
+
+    context "when some datastreams exist" do
+      before do
+        allow(parent).to receive(:attached_files).and_return('FOO56' => double)
+      end
+
+      it { should eq 'FOO57' }
+    end
+  end
+end

data/spec/unit/file_spec.rb

@@ -0,0 +1,221 @@
+require 'spec_helper'
+
+describe ActiveFedora::Datastream do
+  let(:datastream) { ActiveFedora::Datastream.new }
+
+  subject { datastream }
+
+  it { should_not be_metadata }
+
+  describe "#behaves_like_io?" do
+    subject { datastream.send(:behaves_like_io?, object) }
+
+    context "with a File" do
+      let(:object) { File.new __FILE__ }
+      it { should be true }
+    end
+
+    context "with a Tempfile" do
+      after { object.close; object.unlink }
+      let(:object) { Tempfile.new('foo') }
+      it { should be true }
+    end
+
+    context "with a StringIO" do
+      let(:object) { StringIO.new('foo') }
+      it { should be true }
+    end
+  end
+
+  describe "to_param" do
+    before { allow(subject).to receive(:dsid).and_return('foo.bar') }
+    it "should escape dots" do
+      expect(subject.to_param).to eq 'foo%2ebar'
+    end
+  end
+
+  describe "#uri" do
+    let(:parent) { ActiveFedora::Base.new(id: '1234') }
+    before { allow(Deprecation).to receive(:warn) }
+    subject { ActiveFedora::Datastream.new(parent, 'FOO1') }
+
+    it "should set the uri" do
+      expect(subject.uri).to eq "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/1234/FOO1"
+    end
+  end
+
+  context "content" do
+    let(:mock_conn) do
+      Faraday.new do |builder|
+        builder.adapter :test, conn_stubs do |stub|
+        end
+      end
+    end
+
+    let(:mock_client) do
+      Ldp::Client.new mock_conn
+    end
+
+    let(:conn_stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.head(path) { [200, {'Content-Length' => '9999' }] }
+      end
+    end
+
+    let(:path) { '/fedora/rest/test/1234/abcd' }
+
+    let(:ldp_source) { Ldp::Resource.new(mock_client, path) }
+
+    before do
+      allow(subject).to receive(:ldp_source).and_return(ldp_source)
+    end
+
+    describe '#persisted_size' do
+      it 'should load the datastream size attribute from the fedora repository' do
+        expect(subject.size).to eq 9999
+      end
+
+      it 'returns nil without making a head request to Ldp::Resource::BinarySource if it is a new record' do
+        allow(subject).to receive(:new_record?).and_return(true)
+        expect(subject.ldp_source).not_to receive(:head)
+        expect(subject.persisted_size).to eq nil
+      end
+    end
+
+    describe '#dirty_size' do
+      context 'when content has changed from what is currently persisted' do
+        context 'and has been set to something that has a #size method (i.e. string or File)' do
+          it 'returns the size of the dirty content' do
+            dirty_content = double
+            allow(dirty_content).to receive(:size) { 8675309 }
+            subject.content = dirty_content
+            expect(subject.size).to eq dirty_content.size
+          end
+        end
+
+      end
+
+      context 'when content has not changed from what is currently persisted' do
+        it 'returns nil, indicating that the content is not "dirty", but its not necessarily 0 either.' do
+          expect(subject.dirty_size).to be_nil
+        end
+      end
+    end
+
+    describe '#size' do
+      context 'when content has not changed' do
+        it 'returns the value of .persisted_size' do
+          expect(subject.size).to eq subject.persisted_size
+        end
+      end
+
+      context 'when content has changed' do
+        it 'returns the value of .dirty_size' do
+          subject.content = "i have changed!"
+          expect(subject.size).to eq subject.dirty_size
+        end
+      end
+
+      it 'returns nil when #persisted_size and #dirty_size return nil' do
+        allow(subject).to receive(:persisted_size) { nil }
+        allow(subject).to receive(:dirty_size) { nil }
+        expect(subject.size).to be_nil
+      end
+    end
+
+    describe ".empty?" do
+      it "should not be empty" do
+        expect(subject.empty?).to be false
+      end
+    end
+
+    describe ".has_content?" do
+      context "when there's content" do
+        before do
+          allow(subject).to receive(:size).and_return(10)
+        end
+        it "should return true" do
+          expect(subject.has_content?).to be true
+        end
+      end
+
+      context "when size is nil" do
+        before do
+          allow(subject).to receive(:size).and_return(nil)
+        end
+        it "should not have content" do
+          expect(subject).to_not have_content
+        end
+      end
+
+      context "when content is zero" do
+        before do
+          allow(subject).to receive(:size).and_return(0)
+        end
+        it "should return false" do
+          expect(subject.has_content?).to be false
+        end
+      end
+    end
+  end
+
+  context "when the datastream has local content" do
+
+    before do
+      datastream.uri = "http://localhost:8983/fedora/rest/test/1234/abcd"
+      datastream.content = "hi there"
+    end
+
+    describe "#inspect" do
+      subject { datastream.inspect }
+      it { should eq "#<ActiveFedora::Datastream uri=\"http://localhost:8983/fedora/rest/test/1234/abcd\" >" }
+    end
+  end
+
+  context "original_name" do
+    subject { datastream.original_name }
+
+    context "on a new datastream" do
+      context "that has a name set locally" do
+        before { datastream.original_name = "my_image.png" }
+        it { is_expected.to eq "my_image.png" }
+      end
+
+      context "that doesn't have a name set locally" do
+        it { is_expected.to be_nil }
+      end
+    end
+
+    context "when it's saved" do
+      let(:parent) { ActiveFedora::Base.create }
+      before do
+        parent.add_file_datastream('one1two2threfour', dsid: 'abcd', mime_type: 'video/webm', original_name: "my_image.png")
+        parent.save!
+      end
+
+      it "should have original_name" do
+        expect(parent.reload.abcd.original_name).to eq 'my_image.png'
+      end
+    end
+  end
+
+  context "digest" do
+    subject { datastream.digest }
+
+    context "on a new datastream" do
+      it { should be_empty }
+    end
+
+    context "when it's saved" do
+      let(:parent) { ActiveFedora::Base.create }
+      before do
+        parent.add_file_datastream('one1two2threfour', dsid: 'abcd', mime_type: 'video/webm')
+        parent.save!
+      end
+
+      it "should have digest" do
+        expect(parent.reload.abcd.digest.first).to be_kind_of RDF::URI
+      end
+    end
+  end
+end

data/spec/unit/files_hash_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe ActiveFedora::FilesHash do
+  before do
+    class Container; end
+    allow(Container).to receive(:child_resource_reflections).and_return(file: reflection)
+    allow(container).to receive(:association).with(:file).and_return(association)
+    allow(container).to receive(:undeclared_files).and_return([])
+  end
+
+  after { Object.send(:remove_const, :Container) }
+
+  let(:reflection) { double('reflection') }
+  let(:association) { double('association', reader: object) }
+  let(:object) { double('object') }
+  let(:container) { Container.new }
+
+  subject { ActiveFedora::FilesHash.new(container) }
+
+  describe "#key?" do
+    context 'when the key is present' do
+      it "should be true" do
+        expect(subject.key?(:file)).to be true
+      end
+      it "should return true if a string is passed" do
+        expect(subject.key?('file')).to be true
+      end
+    end
+
+    context 'when the key is not present' do
+      it "should be false" do
+        expect(subject.key?(:foo)).to be false
+      end
+    end
+  end
+
+  describe "#[]" do
+    context 'when the key is present' do
+      it "should return the object" do
+        expect(subject[:file]).to eq object
+      end
+      it "should return the object if a string is passed" do
+        expect(subject['file']).to eq object
+      end
+    end
+
+    context 'when the key is not present' do
+      it "should be nil" do
+        expect(subject[:foo]).to be_nil
+      end
+    end
+  end
+end

data/spec/unit/fixity_service_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe ActiveFedora::FixityService do
+
+  subject { ActiveFedora::FixityService.new("http://path/to/resource") }
+
+  it { is_expected.to respond_to(:target) }
+  it { is_expected.to respond_to(:response) }
+
+  describe "#check" do
+    before do
+      expect(subject).to receive(:get_fixity_response_from_fedora).and_return(response)
+    end
+    context "with a passing result" do
+      let(:response) do
+        instance_double("Response", body: '<subject> <http://fedora.info/definitions/v4/repository#status> "SUCCESS"^^<http://www.w3.org/2001/XMLSchema#string> .')
+      end
+      specify "returns true" do
+        expect(subject.check).to be true
+      end
+
+    end
+
+    context "with a failing result" do
+      let(:response) do
+        instance_double("Response", body: '<subject> <http://fedora.info/definitions/v4/repository#status> "BAD_CHECKSUM"^^<http://www.w3.org/2001/XMLSchema#string> .')
+      end
+      specify "returns false" do
+        expect(subject.check).to be false
+      end
+    end
+  end
+
+end

data/spec/unit/has_and_belongs_to_many_association_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
+
+  context "creating the reflection" do
+    before do
+      class Book < ActiveFedora::Base
+      end
+      class Page < ActiveFedora::Base
+      end
+      allow_any_instance_of(Book).to receive(:load_datastreams).and_return(false)
+      allow_any_instance_of(Page).to receive(:load_datastreams).and_return(false)
+
+      allow(subject).to receive(:new_record?).and_return(false)
+      allow(subject).to receive(:save).and_return(true)
+    end
+
+    after do
+      Object.send(:remove_const, :Book)
+      Object.send(:remove_const, :Page)
+    end
+    subject { Book.new('subject-a') }
+
+    context "a one way relationship " do
+      describe "adding memeber" do
+        it "should set the relationship attribute" do
+          reflection = Book.create_reflection(:has_and_belongs_to_many, :pages, {predicate: ActiveFedora::RDF::RelsExt.isMemberOfCollection}, Book)
+          allow(ActiveFedora::SolrService).to receive(:query).and_return([])
+          ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, reflection)
+          expect(ac).to receive(:callback).twice
+          object = Page.new
+          allow(object).to receive(:new_record?).and_return(false)
+          allow(object).to receive(:save).and_return(true)
+          allow(object).to receive(:id).and_return('1234')
+
+          allow(subject).to receive(:[]).with('page_ids').and_return([])
+          expect(subject).to receive(:[]=).with('page_ids', ['1234'])
+
+          ac.concat object
+        end
+      end
+
+      describe "finding member" do
+        let(:ids) { (0..15).map(&:to_s) }
+        let(:query1) { ids.slice(0,10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(" OR ") }
+        let(:query2) { ids.slice(10,10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(" OR ") }
+
+        it "should call solr query multiple times" do
+          reflection = Book.create_reflection(:has_and_belongs_to_many, :pages, { predicate: ActiveFedora::RDF::RelsExt.isMemberOfCollection, solr_page_size: 10}, Book)
+          expect(subject).to receive(:[]).with('page_ids').and_return(ids)
+          expect(ActiveFedora::SolrService).to receive(:query).with(query1, rows: 10).and_return([])
+          expect(ActiveFedora::SolrService).to receive(:query).with(query2, rows: 10).and_return([])
+
+          ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, reflection)
+          ac.find_target
+        end
+      end
+    end
+
+    context "with an inverse reflection" do
+      let!(:inverse) { Page.create_reflection(:has_and_belongs_to_many, :books, { predicate: ActiveFedora::RDF::RelsExt.isMemberOfCollection }, Page) }
+      let(:reflection) { Book.create_reflection(:has_and_belongs_to_many, :pages, { predicate: ActiveFedora::RDF::RelsExt.hasCollectionMember, inverse_of: 'books'}, Book) }
+      let(:ac) { ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, reflection) }
+      let(:object) { Page.new }
+
+      it "should set the relationship attribute on subject and object when inverse_of is given" do
+        allow(ActiveFedora::SolrService).to receive(:query).and_return([])
+        expect(ac).to receive(:callback).twice
+        allow(object).to receive(:new_record?).and_return(false)
+        allow(object).to receive(:save).and_return(true)
+
+        allow(subject).to receive(:[]).with('page_ids').and_return([])
+        expect(subject).to receive(:[]=).with('page_ids', [object.id])
+
+        expect(object).to receive(:[]).with('book_ids').and_return([]).twice
+        expect(object).to receive(:[]=).with('book_ids', [subject.id])
+
+        ac.concat object
+      end
+    end
+
+  end
+
+  context "class with association" do
+    before do
+      class Collection < ActiveFedora::Base
+        has_and_belongs_to_many :members, predicate: ActiveFedora::RDF::RelsExt.hasCollectionMember, class_name: "ActiveFedora::Base", after_remove: :remove_member
+        def remove_member (m)
+        end
+      end
+
+      class Thing < ActiveFedora::Base
+        has_many :collections, predicate: ActiveFedora::RDF::RelsExt.hasCollectionMember, class_name: "ActiveFedora::Base"
+      end
+    end
+
+    after do
+      Collection.destroy_all
+      Thing.destroy_all
+
+      Object.send(:remove_const, :Collection)
+      Object.send(:remove_const, :Thing)
+    end
+
+    context "with a new collection" do
+      let(:collection) { Collection.new }
+      it "should have an empty list of collection members" do
+        expect(collection.member_ids).to eq []
+        expect(collection.members).to eq []
+      end
+    end
+
+    context "with a persisted collection" do
+      let(:collection) { Collection.create.tap {|c| c.members << thing} }
+      let(:thing) { Thing.create }
+
+      context "when the ids are set" do
+        let(:thing2) { Thing.create }
+        let(:thing3) { Thing.create }
+
+        it "should clear the object set" do
+          expect(collection.members).to eq [thing]
+          collection.member_ids = [thing2.id, thing3.id]
+          expect(collection.members).to eq [thing2, thing3]
+        end
+      end
+
+      it "should call destroy" do
+        # this is a pretty weak test
+        expect { collection.destroy }.to_not raise_error
+      end
+    end
+  end
+end