active-fedora 13.1.2 → 13.1.3

data/spec/integration/eradicate_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before(:all) do
-    class ResurrectionModel < ActiveFedora::Base
-      after_destroy :eradicate
-    end
-  end
-
-  after(:all) do
-    Object.send(:remove_const, :ResurrectionModel)
-  end
-
-  context "when an object is has already been deleted" do
-    let(:ghost) do
-      obj = described_class.create
-      obj.destroy
-      obj.id
-    end
-    context "in a typical sitation" do
-      specify "it cannot be reused" do
-        expect { described_class.create(id: ghost) }.to raise_error(Ldp::Gone)
-      end
-    end
-    specify "remove its tombstone" do
-      expect(described_class.eradicate(ghost)).to be true
-    end
-  end
-
-  context "when an object has just been deleted" do
-    let(:zombie) do
-      obj = described_class.create
-      obj.destroy
-      return obj
-    end
-    specify "remove its tombstone" do
-      expect(zombie.eradicate).to be true
-    end
-  end
-
-  describe "a model with no tombstones" do
-    let(:lazarus) do
-      body = ResurrectionModel.create
-      soul = body.id
-      body.destroy
-      return soul
-    end
-    it "allows reusing a uri" do
-      expect(ResurrectionModel.create(id: lazarus)).to be_kind_of(ResurrectionModel)
-    end
-  end
-end

data/spec/integration/fedora_solr_sync_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'timeout'
-
-describe "fedora_solr_sync_issues" do
-  before :all do
-    class ParentThing < ActiveFedora::Base
-      has_many :things, class_name: 'ChildThing', predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
-    end
-
-    class ChildThing < ActiveFedora::Base
-      belongs_to :parent, class_name: 'ParentThing', predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
-    end
-  end
-
-  after :all do
-    Object.send(:remove_const, :ChildThing)
-    Object.send(:remove_const, :ParentThing)
-  end
-
-  subject(:child) { ChildThing.create parent: parent }
-  let(:parent) { ParentThing.create }
-
-  before { Ldp::Resource::RdfSource.new(ActiveFedora.fedora.connection, child.uri).delete }
-
-  it "does not go into an infinite loop" do
-    parent.reload
-    expect(ActiveFedora::Base.logger).to receive(:error).with("Solr and Fedora may be out of sync:\n")
-    expect(parent.things).to eq []
-  end
-end

data/spec/integration/file_fixity_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe "Checking fixity" do
-  before(:all) do
-    class MockAFBase < ActiveFedora::Base
-      has_subresource "data", autocreate: true
-    end
-  end
-
-  after(:all) do
-    Object.send(:remove_const, :MockAFBase)
-  end
-
-  subject do
-    obj = MockAFBase.create
-    obj.data.content = "some content"
-    obj.save
-    obj.data.check_fixity
-  end
-
-  context "with a valid resource" do
-    it { is_expected.to be true }
-  end
-  context "when no uri has been set" do
-    subject(:file) { ActiveFedora::File.new }
-    it "raises an error" do
-      expect { file.check_fixity }.to raise_error(ArgumentError, "You must provide a uri")
-    end
-  end
-  context "with missing resource" do
-    subject(:file) { ActiveFedora::File.new(ActiveFedora::Base.id_to_uri('123')) }
-    it "raises an error" do
-      expect { file.check_fixity }.to raise_error(Ldp::NotFound)
-    end
-  end
-end

data/spec/integration/file_spec.rb

@@ -1,221 +0,0 @@
-require 'spec_helper'
-
-require 'active_fedora'
-require "rexml/document"
-
-describe ActiveFedora::File do
-  let(:file) { described_class.new }
-  describe "#save" do
-    context "with new files" do
-      context "with a string" do
-        before { file.content = "hello" }
-        it "saves" do
-          expect(file.save).to be true
-        end
-      end
-
-      context "with no content" do
-        before { file.content = nil }
-        it "does not save" do
-          expect(file.save).to be false
-        end
-      end
-    end
-
-    context "with UploadedFile" do
-      before do
-        module ActionDispatch
-          module Http
-            class UploadedFile
-              def initialize
-                @content = StringIO.new("hello world")
-              end
-
-              def read(a, b)
-                @content.read(a, b)
-              end
-
-              def size
-                @content.length
-              end
-            end
-          end
-        end
-      end
-
-      it "saves" do
-        file.content = ActionDispatch::Http::UploadedFile.new
-        file.save
-        expect(file).not_to be_new_record
-      end
-    end
-  end
-
-  context "with a sub-resource that autocreates" do
-    before do
-      class MockAFBase < ActiveFedora::Base
-        has_subresource "descMetadata", class_name: 'SampleResource', autocreate: true
-      end
-
-      class SampleResource < ActiveFedora::File
-        def content
-          'something to save'
-        end
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :SampleResource)
-      Object.send(:remove_const, :MockAFBase)
-    end
-
-    let(:test_object) { MockAFBase.create }
-    let(:descMetadata) { test_object.descMetadata }
-
-    describe "changed attributes are set" do
-      it "marks profile as changed" do
-        expect_any_instance_of(SampleResource).to receive(:attribute_will_change!).with(:ldp_source)
-        test_object
-      end
-    end
-
-    describe "content_changed? is called" do
-      before do
-        allow_any_instance_of(SampleResource).to receive(:content_changed?).and_return(true)
-      end
-      subject { descMetadata.described_by }
-      it { is_expected.to eq descMetadata.uri + '/fcr:metadata' }
-    end
-  end
-
-  describe "#content" do
-    let(:file) { described_class.new { |ds| ds.content = content } }
-
-    before do
-      file.save
-    end
-
-    describe "#content" do
-      subject(:resource) { described_class.new(file.uri).content }
-
-      before { content.rewind }
-
-      context "when encoding is not set" do
-        let(:content) { fixture('dino.jpg') }
-
-        it "is read from fedora" do
-          expect(resource).to eq content.read
-          expect(resource.encoding).to eq Encoding::ASCII_8BIT
-        end
-      end
-
-      context "when encoding is set" do
-        let(:file) do
-          described_class.new do |f|
-            f.content = content
-            f.mime_type = 'text/plain;charset=UTF-8'
-          end
-        end
-        let(:content) { StringIO.new "I'm a little teåpot" }
-
-        it "is read from fedora" do
-          expect(resource).to eq content.read
-          expect(resource.encoding).to eq Encoding::UTF_8
-        end
-      end
-    end
-  end
-
-  context "with a sub-resource" do
-    before do
-      class MockAFBase < ActiveFedora::Base
-        has_subresource "descMetadata", class_name: 'SampleResource'
-      end
-
-      class SampleResource < ActiveFedora::File
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :SampleResource)
-      Object.send(:remove_const, :MockAFBase)
-    end
-
-    let(:test_object) { MockAFBase.create }
-    let(:descMetadata) { test_object.descMetadata }
-
-    describe "the metadata file" do
-      subject { descMetadata }
-      it { is_expected.to be_a_kind_of(described_class) }
-    end
-
-    context "a binary file" do
-      let(:path) { "ds#{Time.now.to_i}" }
-      let(:content) { fixture('dino.jpg') }
-      let(:file) { described_class.new { |ds| ds.content = content } }
-
-      before do
-        test_object.attach_file(file, path)
-        test_object.save
-      end
-
-      it "is not changed" do
-        expect(test_object.attached_files[path]).to_not be_content_changed
-      end
-
-      describe "streaming the response" do
-        let(:stream_reader) { instance_double(IO) }
-        it "streams the response" do
-          expect(stream_reader).to receive(:read).at_least(:once)
-          test_object.attached_files[path].stream.each { |buff| stream_reader.read(buff) }
-        end
-
-        context "with a range request" do
-          before do
-            test_object.add_file('one1two2threfour', path: 'webm', mime_type: 'video/webm')
-            test_object.save!
-          end
-          subject { str = ''; test_object.webm.stream(range).each { |chunk| str << chunk }; str }
-          context "whole thing" do
-            let(:range) { 'bytes=0-15' }
-            it { is_expected.to eq 'one1two2threfour' }
-          end
-          context "open ended" do
-            let(:range) { 'bytes=0-' }
-            it { is_expected.to eq 'one1two2threfour' }
-          end
-          context "not starting at the beginning" do
-            let(:range) { 'bytes=3-15' }
-            it { is_expected.to eq '1two2threfour' }
-          end
-          context "not ending at the end" do
-            let(:range) { 'bytes=4-11' }
-            it { is_expected.to eq 'two2thre' }
-          end
-        end
-
-        context "when the request results in a redirect" do
-          before do
-            test_object.add_file('one1two2threfour', path: 'webm', mime_type: 'video/webm')
-            test_object.add_file('', path: 'redirector', mime_type: "message/external-body; access-type=URL; url=\"#{test_object.webm.uri}\"")
-            test_object.save!
-          end
-          subject { str = ''; test_object.redirector.stream.each { |chunk| str << chunk }; str }
-          it { is_expected.to eq 'one1two2threfour' }
-        end
-
-        context "when there are more than 3 requests because of redirects" do
-          before do
-            test_object.add_file('', path: 'one', mime_type: "message/external-body; access-type=URL; url=\"#{test_object.attached_files[path].uri}\"")
-            test_object.add_file('', path: 'two', mime_type: "message/external-body; access-type=URL; url=\"#{test_object.one.uri}\"")
-            test_object.add_file('', path: 'three', mime_type: "message/external-body; access-type=URL; url=\"#{test_object.two.uri}\"")
-            test_object.save!
-          end
-          it "raises a HTTP redirect too deep Error" do
-            expect { test_object.three.stream.each { |chunk| chunk } }.to raise_error('HTTP redirect too deep')
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/generators/fedora_generator_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'generators/active_fedora/config/fedora/fedora_generator'
-
-describe ActiveFedora::Config::FedoraGenerator do
-  describe "#fcrepo_wrapper_config" do
-    let(:generator) { described_class.new }
-    let(:files_to_test) { [
-      'config/fcrepo_wrapper_test.yml',
-      '.fcrepo_wrapper.yml'
-    ]}
-
-    before do
-      generator.fcrepo_wrapper_config
-    end
-
-    after do
-      files_to_test.each { |file| File.delete(file) if File.exist?(file) }
-    end
-
-    it "creates config files" do
-      files_to_test.each do |file|
-        expect(File).to exist(file), "Expected #{file} to exist"
-      end
-    end
-  end
-end

data/spec/integration/generators/solr_generator_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-require 'generators/active_fedora/config/solr/solr_generator'
-
-describe ActiveFedora::Config::SolrGenerator do
-  describe "#solr_wrapper_config" do
-    let(:generator) { described_class.new }
-    let(:files_to_test) { [
-      'config/solr_wrapper_test.yml',
-      '.solr_wrapper.yml'
-    ]}
-
-    it "creates config files" do
-      Dir.mktmpdir do |dir|
-        Dir.chdir(dir) do
-          generator.solr_wrapper_config
-          files_to_test.each do |file|
-            expect(File).to exist(file), "Expected #{file} to exist"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/gone_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before(:all) do
-    class ResurrectionModel < ActiveFedora::Base
-      after_destroy :eradicate
-    end
-  end
-
-  after(:all) do
-    Object.send(:remove_const, :ResurrectionModel)
-  end
-
-  context "when an object is has already been deleted" do
-    let(:ghost) do
-      obj = described_class.create
-      obj.destroy
-      obj.id
-    end
-    it "is gone" do
-      expect(described_class.gone?(ghost)).to be true
-    end
-  end
-
-  context "when the id has never been used" do
-    let(:id) { "abc123" }
-    it "is not gone" do
-      expect(described_class.gone?(id)).to be false
-    end
-  end
-
-  context "when the id is in use" do
-    let(:active) do
-      obj = described_class.create
-      obj.id
-    end
-    it "is not gone" do
-      expect(described_class.gone?(active)).to be false
-    end
-  end
-end

data/spec/integration/has_and_belongs_to_many_associations_spec.rb

@@ -1,414 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  describe "with inverse" do
-    context "that is also a HABTM" do
-      before do
-        class Book < ActiveFedora::Base
-          has_and_belongs_to_many :topics, predicate: ::RDF::Vocab::FOAF.primaryTopic, inverse_of: :books
-        end
-
-        class Topic < ActiveFedora::Base
-          has_and_belongs_to_many :books, predicate: ::RDF::Vocab::FOAF.isPrimaryTopicOf
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :Book)
-        Object.send(:remove_const, :Topic)
-      end
-
-      describe "an unsaved instance" do
-        let(:topic1) { Topic.create }
-        let(:book) { Book.create }
-
-        it "habtm should set and remove relationships bidirectionally" do
-          book.topics << topic1
-          expect(book.topics).to eq [topic1]
-          expect(topic1.books).to eq [book]
-          expect(topic1.reload.books).to eq [book]
-
-          book.topics.delete(topic1)
-          expect(book.topics).to be_empty
-          expect(topic1.books).to be_empty
-        end
-
-        it "allows for more than 10 items" do
-          12.times do
-            book.topics << Topic.create
-          end
-          book.save
-          expect(book.topics.count).to eq 12
-          book2 = Book.find(book.id)
-          expect(book2.topics.count).to eq 12
-        end
-
-        context "with subclassed objects" do
-          before do
-            class SpecialInheritedBook < Book
-            end
-          end
-
-          after do
-            Object.send(:remove_const, :SpecialInheritedBook)
-          end
-
-          let!(:special_book) { SpecialInheritedBook.create }
-          it "finds inherited objects along with base objects" do
-            book.topics << topic1
-            special_book.topics << topic1
-            expect(topic1.books).to match_array [book, special_book]
-            expect(topic1.reload.books).to match_array [book, special_book]
-          end
-        end
-      end
-
-      describe "a saved instance" do
-        let!(:book) { Book.create }
-        let!(:topic1) { Topic.create }
-        let!(:topic2) { Topic.create }
-
-        it "sets relationships bidirectionally" do
-          book.topics << topic1
-          expect(book.topics).to eq [topic1]
-          expect(book['topic_ids']).to eq [topic1.id]
-          expect(topic1['book_ids']).to eq [book.id]
-          expect(Topic.find(topic1.id).books).to eq [book] # Can't have saved it because book isn't saved yet.
-        end
-
-        it "saves new child objects" do
-          book.topics << Topic.new
-          expect(book.topics.first.id).to_not be_nil
-        end
-
-        it "clears out the old associtions" do
-          book.topics = [topic1]
-          book.topics = [topic2]
-          expect(book.topic_ids).to eq [topic2.id]
-        end
-
-        context "with members" do
-          before do
-            book.topics = [topic1, topic2]
-            book.save
-          end
-
-          context "destroy" do
-            it "removes the associations" do
-              book.destroy
-            end
-          end
-        end
-      end
-    end
-
-    context "that is a has_many" do
-      before do
-        class Book < ActiveFedora::Base
-          has_many :collections
-        end
-
-        class Collection < ActiveFedora::Base
-          has_and_belongs_to_many :books, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :Book)
-        Object.send(:remove_const, :Collection)
-      end
-
-      describe "add and remove members" do
-        let(:collection) { Collection.create }
-        let(:book) { Book.create }
-
-        it "is successful" do
-          collection.books << book
-          expect {
-            collection.books.delete(book)
-          }.to change { collection.books.size }.from(1).to(0)
-        end
-      end
-    end
-  end
-
-  describe "when inverse is not specified" do
-    before do
-      class Book < ActiveFedora::Base
-        has_and_belongs_to_many :collections, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection
-      end
-
-      class Collection < ActiveFedora::Base
-        has_and_belongs_to_many :books, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :Book)
-      Object.send(:remove_const, :Collection)
-    end
-
-    let(:book) { Book.create }
-    let(:collection) { Collection.create }
-
-    context "when the book is a member of the collection" do
-      before do
-        book.collections << collection
-        book.save!
-      end
-
-      it "has a collection" do
-        expect(book['collection_ids']).to eq [collection.id]
-        expect(book.collections).to eq [collection]
-      end
-      it "habtm should not set foreign relationships if :inverse_of is not specified" do
-        expect(collection['book_ids']).to be_empty
-      end
-      it "loads the collections" do
-        reloaded = Book.find(book.id)
-        expect(reloaded.collections).to eq [collection]
-      end
-
-      describe "#empty?" do
-        subject { book.collections }
-        it { is_expected.to_not be_empty }
-      end
-    end
-
-    context "when a book isn't in a collection" do
-      describe "#empty?" do
-        subject { book.collections }
-        it { is_expected.to be_empty }
-      end
-    end
-  end
-
-  describe "when destroying the association" do
-    describe "without callbacks" do
-      before do
-        class Book < ActiveFedora::Base
-          has_and_belongs_to_many :collections, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection
-        end
-
-        class Collection < ActiveFedora::Base
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :Book)
-        Object.send(:remove_const, :Collection)
-      end
-
-      let(:book) { Book.create }
-      let(:collection1) { Collection.create }
-      let(:collection2) { Collection.create }
-      before do
-        book.collections << collection1 << collection2
-        book.save!
-      end
-
-      it "delete should cause the entries to be removed from RELS-EXT, but not destroy the original record" do
-        expect(book.collections).to contain_exactly collection1, collection2
-        book.collections.delete(collection1)
-        expect(book.collections).to eq [collection2]
-        book.save!
-        book.reload
-        expect(book.collections).to eq [collection2]
-        expect(Collection.find(collection1.id)).to_not be_nil
-      end
-
-      it "destroy should cause the entries to be removed from RELS-EXT, but not destroy the original record" do
-        expect(book.collections).to contain_exactly collection1, collection2
-        book.collections.destroy(collection1)
-        expect(book.collections).to eq [collection2]
-        book.save!
-        book.reload
-        expect(book.collections).to eq [collection2]
-        expect(Collection.find(collection1.id)).to_not be_nil
-      end
-    end
-
-    describe "with remove callbacks" do
-      before do
-        class Book < ActiveFedora::Base
-          has_and_belongs_to_many :collections,
-                                  predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection,
-                                  before_remove: :foo, after_remove: :bar
-        end
-
-        class Collection < ActiveFedora::Base
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :Book)
-        Object.send(:remove_const, :Collection)
-      end
-
-      let(:book) { Book.create }
-      let(:collection) { Collection.create }
-      before do
-        book.collections << collection
-        book.save!
-      end
-
-      it "destroy should cause the before_remove and after_remove callback to be triggered" do
-        expect(book).to receive(:foo).with(collection)
-        expect(book).to receive(:bar).with(collection)
-        book.collections.destroy(collection)
-      end
-
-      it "delete should cause the before_remove and after_remove callback to be triggered" do
-        expect(book).to receive(:foo).with(collection)
-        expect(book).to receive(:bar).with(collection)
-        book.collections.delete(collection)
-      end
-
-      it "does not remove if an exception is thrown in before_remove" do
-        expect(book).to receive(:foo).with(collection).and_raise
-        expect(book).to_not receive(:bar)
-        begin
-          book.collections.delete(collection)
-        rescue RuntimeError
-        end
-        expect(book.collections).to eq [collection]
-      end
-    end
-
-    describe "with add callbacks" do
-      before do
-        class Book < ActiveFedora::Base
-          has_and_belongs_to_many :collections,
-                                  predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection,
-                                  before_add: :foo, after_add: :bar
-        end
-
-        class Collection < ActiveFedora::Base
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :Book)
-        Object.send(:remove_const, :Collection)
-      end
-
-      let(:book) { Book.create }
-      let(:collection) { Collection.create }
-
-      it "shift should cause the before_add and after_add callback to be triggered" do
-        expect(book).to receive(:foo).with(collection)
-        expect(book).to receive(:bar).with(collection)
-        book.collections << collection
-      end
-
-      it "assignment should cause the before_add and after_add callback to be triggered" do
-        expect(book).to receive(:foo).with(collection)
-        expect(book).to receive(:bar).with(collection)
-        book.collections = [collection]
-      end
-
-      it "does not add if an exception is thrown in before_add" do
-        expect(book).to receive(:foo).with(collection).and_raise
-        expect(book).to_not receive(:bar)
-        begin
-          book.collections << collection
-        rescue RuntimeError
-        end
-        expect(book.collections).to eq []
-      end
-    end
-  end
-
-  describe "create" do
-    before do
-      class Book < ActiveFedora::Base
-        has_and_belongs_to_many :collections, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isMemberOfCollection
-      end
-
-      class Collection < ActiveFedora::Base
-        property :title, predicate: ::RDF::Vocab::DC.title
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :Book)
-      Object.send(:remove_const, :Collection)
-    end
-
-    let(:book) { Book.create }
-
-    it "creates" do
-      collection = book.collections.create(title: ["Permanent"])
-      expect(collection).to be_kind_of Collection
-      expect(book.collections).to include collection
-      book.save
-      expect(book.reload.collections.first.title).to eq ['Permanent']
-    end
-  end
-
-  describe "Autosave" do
-    before do
-      class Item < ActiveFedora::Base
-        has_many :components
-        property :title, predicate: ::RDF::Vocab::DC.title
-      end
-
-      class Component < ActiveFedora::Base
-        has_and_belongs_to_many :items, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
-        property :description, predicate: ::RDF::Vocab::DC.description
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :Item)
-      Object.send(:remove_const, :Component)
-    end
-
-    describe "From the has_and_belongs_to_many side" do
-      describe "dependent records" do
-        let(:component) { Component.create(items: [Item.new(title: ['my title'])]) }
-
-        it "is saved" do
-          component.reload
-          expect(component.items.first.title).to eq ['my title']
-        end
-      end
-
-      describe "shifting" do
-        let(:component) { Component.new }
-        let(:item) { Item.create }
-
-        it "sets item_ids" do
-          component.items << item
-          expect(component.item_ids).to eq [item.id]
-        end
-      end
-
-      context "when the has_and_belongs_to_many provides an inverse_of" do
-        let(:reflection) { Component._reflect_on_association(:items) }
-        before do
-          reflection.options[:inverse_of] = :components
-        end
-
-        describe "shifting" do
-          let(:component) { Component.create }
-          let(:item) { Item.new }
-
-          it "sets item_ids" do
-            component.items << item
-            expect(component.item_ids).to eq [item.id]
-          end
-        end
-      end
-    end
-
-    describe "From the has_many side" do
-      let(:item) { Item.create(components: [Component.new(description: ['my description'])]) }
-
-      it "saves dependent records" do
-        item.reload
-        expect(item.components.first.description).to eq ['my description']
-      end
-    end
-  end
-end