active-fedora 13.1.2 → 13.1.3

data/spec/integration/attached_files_spec.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::AttachedFiles do
-  describe "#has_subresource" do
-    before do
-      class FooHistory < ActiveFedora::Base
-        has_subresource 'child'
-      end
-    end
-    after do
-      Object.send(:remove_const, :FooHistory)
-    end
-
-    context "when the object exists" do
-      let!(:o) { FooHistory.create }
-      before do
-        o.child.content = "HMMM"
-        o.save
-      end
-
-      it "does not need to do a head on the children" do
-        f = FooHistory.find(o.id)
-        expect(f.ldp_source.client).not_to receive(:head)
-        f.child.content
-      end
-    end
-  end
-
-  describe "Datastreams synched together" do
-    before do
-      class DSTest < ActiveFedora::Base
-        def load_attached_files
-          super
-          return if attached_files.keys.include? :test_ds
-          add_file("XXX", path: 'test_ds', mime_type: 'text/html')
-        end
-      end
-    end
-
-    subject { ds.content }
-    let(:file) { DSTest.create }
-    let(:ds) { file.test_ds }
-
-    after do
-      Object.send(:remove_const, :DSTest)
-    end
-
-    it { is_expected.to eq('XXX') }
-
-    context "After updating" do
-      before do
-        ds.content = "Foobar"
-        file.save!
-      end
-
-      it "updates datastream" do
-        expect(DSTest.find(file.id).attached_files['test_ds'].content).to eq 'Foobar'
-        expect(DSTest.find(file.id).test_ds.content).to eq 'Foobar'
-      end
-    end
-  end
-
-  describe "an instance of ActiveFedora::Base" do
-    let(:obj) { ActiveFedora::Base.new }
-
-    describe ".attached_files" do
-      subject(:attached_files) { obj.attached_files }
-      it "returns a Hash of datastreams from fedora" do
-        expect(attached_files).to be_a_kind_of(ActiveFedora::FilesHash)
-        expect(attached_files).to be_empty
-      end
-
-      it "initializes the datastream pointers with @new_object=false" do
-        attached_files.each_value do |ds|
-          expect(ds).to_not be_new
-        end
-      end
-    end
-
-    describe ".metadata_streams" do
-      before do
-        class Metadata < ActiveFedora::File
-          def metadata?
-            true
-          end
-        end
-
-        obj.attach_file(mds1, 'md1')
-        obj.attach_file(mds2, 'qdc')
-        obj.attach_file(fds, 'fds')
-      end
-
-      let(:mds1) { Metadata.new }
-      let(:mds2) { Metadata.new }
-      let(:fds) { ActiveFedora::File.new }
-
-      after do
-        Object.send(:remove_const, :Metadata)
-      end
-
-      it "returns all of the datastreams from the object that are kinds of OmDatastream" do
-        expect(obj.metadata_streams).to match_array [mds1, mds2]
-      end
-    end
-
-    describe '#add_file' do
-      before do
-        f = File.new(File.join(File.dirname(__FILE__), "../fixtures/dino_jpg_no_file_ext"))
-        obj.add_file(f, mime_type: "image/jpeg")
-        obj.save
-      end
-
-      it "sets the correct mime_type if :mime_type is passed in and path does not contain correct extension" do
-        expect(obj.reload.attached_files["DS1"].mime_type).to eq "image/jpeg"
-      end
-    end
-
-    describe '.attach_file' do
-      let(:ds) { ActiveFedora::File.new }
-
-      it "is able to add datastreams" do
-        expect(obj.attach_file(ds, 'DS1')).to eq 'DS1'
-      end
-
-      it "adding and saving should add the datastream to the datastreams array" do
-        ds.content = fixture('dino.jpg').read
-        expect(obj.attached_files).to_not have_key(:DS1)
-        obj.attach_file(ds, 'DS1')
-        obj.save
-        expect(obj.attached_files).to have_key(:DS1)
-      end
-    end
-
-    describe "retrieving datastream content" do
-      let(:obj) { ActiveFedora::Base.create }
-      after { obj.destroy }
-
-      let(:ds) { ActiveFedora::File.new(obj.uri + '/DS1') { |ds| ds.content = "foo"; ds.save } }
-
-      it "retrieves blobs that match the saved blobs" do
-        obj.attach_file(ds, 'DS1')
-        expect(obj.reload.attached_files["DS1"].content).to eq "foo"
-      end
-    end
-  end
-end

data/spec/integration/attributes_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-describe "delegating attributes" do
-  before :all do
-    class TitledObject < ActiveFedora::Base
-      property :title, predicate: ::RDF::Vocab::DC.title
-    end
-
-    class RdfObject < ActiveFedora::Base
-      property :resource_type, predicate: ::RDF::Vocab::DC.type do |index|
-        index.as :stored_searchable, :facetable
-      end
-    end
-  end
-
-  after :all do
-    Object.send(:remove_const, :TitledObject)
-    Object.send(:remove_const, :RdfObject)
-  end
-
-  describe "#index_config" do
-    context "on a class with properties" do
-      subject(:index_config) { RdfObject.index_config }
-      it "has configuration" do
-        expect(index_config[:resource_type].behaviors).to eq [:stored_searchable, :facetable]
-      end
-    end
-
-    context "when a class inherits properties" do
-      before do
-        class InheritedObject < RdfObject
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :InheritedObject)
-      end
-
-      subject(:index_config) { InheritedObject.index_config }
-
-      it "has configuration" do
-        expect(index_config[:resource_type].behaviors).to eq [:stored_searchable, :facetable]
-      end
-
-      context "when the inherited config is modifed" do
-        before do
-          InheritedObject.index_config[:resource_type].behaviors.delete(:stored_searchable)
-        end
-        subject(:index_config) { RdfObject.index_config }
-
-        it "the parent config is unchanged" do
-          expect(index_config[:resource_type].behaviors).to eq [:stored_searchable, :facetable]
-        end
-      end
-    end
-  end
-
-  describe "previous_changes" do
-    subject(:titled_object) { TitledObject.create(title: ["Hydra for Dummies"]) }
-    it "keeps a list of changes after a successful save" do
-      expect(titled_object.previous_changes).to_not be_empty
-      expect(titled_object.previous_changes.keys).to include("title")
-    end
-  end
-
-  describe "#changes" do
-    let(:titled_object) { TitledObject.create(title: ["Hydra for Dummies"]) }
-    it "cleans out changes" do
-      expect(titled_object).to_not be_title_changed
-      expect(titled_object.changes).to be_empty
-    end
-  end
-end

data/spec/integration/autosave_association_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before :all do
-    class MockAFBaseRelationship < ActiveFedora::Base
-    end
-  end
-  after :all do
-    Object.send(:remove_const, :MockAFBaseRelationship)
-  end
-
-  subject(:relationship) { MockAFBaseRelationship.new }
-
-  context '#changed_for_autosave?' do
-    before do
-      expect(relationship).to receive(:new_record?).and_return(false)
-      expect(relationship).to receive(:changed?).and_return(false)
-      expect(relationship).to receive(:marked_for_destruction?).and_return(false)
-    end
-    it {
-      expect { relationship.changed_for_autosave? }.to_not raise_error
-    }
-  end
-end

data/spec/integration/base_spec.rb

@@ -1,184 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before(:all) do
-    class Foo < ActiveFedora::Base
-      property :person, predicate: ::RDF::Vocab::DC.creator
-    end
-  end
-  after(:all) { Object.send(:remove_const, :Foo) }
-
-  describe '#reload' do
-    context "when persisted" do
-      let(:object) { Foo.create(person: ['bob']) }
-      let(:object2) { Foo.find(object.id) }
-      before { object2.update(person: ['dave']) }
-
-      it 're-queries Fedora' do
-        object.reload
-        expect(object.person).to eq ['dave']
-      end
-    end
-
-    context "when not persisted" do
-      it 'raises an error' do
-        expect { Foo.new.reload }.to raise_error(ActiveFedora::ObjectNotFoundError)
-      end
-    end
-  end
-
-  describe "a saved object" do
-    before(:all) do
-      class Book < ActiveFedora::Base
-        type [::RDF::URI("http://www.example.com/Book")]
-        property :title, predicate: ::RDF::Vocab::DC.title
-      end
-    end
-    after(:all) { Object.send(:remove_const, :Book) }
-    after { obj.destroy unless obj.destroyed? }
-    let!(:obj) { Book.create }
-
-    describe "#errors" do
-      subject { obj.errors }
-      it { is_expected.to be_empty }
-    end
-
-    describe "#id" do
-      subject { obj.id }
-      it { is_expected.to_not be_nil }
-    end
-
-    context "when updated with changes after one second" do
-      before do
-        obj.title = ['sample']
-        sleep 1
-      end
-
-      it 'updates the modification time field in solr' do
-        expect { obj.save }.to change {
-          ActiveFedora::SolrService.query("id:\"#{obj.id}\"").first['system_modified_dtsi']
-        }
-      end
-    end
-
-    describe "#create_date" do
-      subject { obj.create_date }
-      it { is_expected.to_not be_nil }
-    end
-
-    describe "#modified_date" do
-      subject { obj.modified_date }
-      it { is_expected.to_not be_nil }
-    end
-
-    describe "delete" do
-      it "deletes the object from Fedora and Solr" do
-        expect {
-          obj.delete
-        }.to change { described_class.exists?(obj.id) }.from(true).to(false)
-      end
-    end
-
-    describe "#type" do
-      subject { obj.type }
-      it { is_expected.to include(::RDF::URI("http://www.example.com/Book")) }
-      context "when adding additional types" do
-        before do
-          t = obj.get_values(:type)
-          t << ::RDF::URI("http://www.example.com/Novel")
-          obj.set_value(:type, t)
-        end
-        it { is_expected.to include(::RDF::URI("http://www.example.com/Novel")) }
-      end
-    end
-  end
-
-  describe "#apply_schema" do
-    before do
-      class ExampleSchema < ActiveTriples::Schema
-        property :title, predicate: RDF::Vocab::DC.title
-      end
-      class ExampleBase < ActiveFedora::Base
-        apply_schema ExampleSchema, ActiveFedora::SchemaIndexingStrategy.new(ActiveFedora::Indexers::GlobalIndexer.new(:symbol))
-      end
-    end
-    after do
-      Object.send(:remove_const, :ExampleSchema)
-      Object.send(:remove_const, :ExampleBase)
-    end
-    let(:obj) { ExampleBase.new }
-    it "configures properties and solrize them" do
-      obj.title = ["Test"]
-      expect(obj.to_solr[ActiveFedora.index_field_mapper.solr_name("title", :symbol)]).to eq ["Test"]
-    end
-  end
-
-  shared_examples 'ActiveFedora::Base#exists?' do
-    let(:obj) { test_class.create }
-    it "returns true for objects that exist" do
-      expect(test_class.exists?(obj)).to be true
-    end
-    it "returns true for ids that exist" do
-      expect(test_class.exists?(obj.id)).to be true
-    end
-    it "returns false for ids that don't exist" do
-      expect(test_class.exists?('test_missing_object')).to be false
-    end
-    it "returns false for nil, false and empty" do
-      expect(test_class.exists?(nil)).to be false
-      expect(test_class.exists?(false)).to be false
-      expect(test_class.exists?('')).to be false
-    end
-    context "when passed a hash of conditions" do
-      let(:conditions) { { foo: "bar" } }
-      context "and at least one object matches the conditions" do
-        it "returns true" do
-          allow(ActiveFedora::SolrService).to receive(:query) { [instance_double(RSolr::HashWithResponse)] }
-          expect(test_class.exists?(conditions)).to be true
-        end
-      end
-      context "and no object matches the conditions" do
-        it "returns false" do
-          allow(ActiveFedora::SolrService).to receive(:query) { [] }
-          expect(test_class.exists?(conditions)).to be false
-        end
-      end
-    end
-  end
-
-  context 'base class' do
-    let(:test_class) { described_class }
-    it_behaves_like 'ActiveFedora::Base#exists?'
-  end
-
-  context 'subclass' do
-    let(:test_class) { Foo }
-    it_behaves_like 'ActiveFedora::Base#exists?'
-
-    it 'does not mistake other fedora objects for subclass' do
-      obj = described_class.create
-      expect { test_class.exists?(obj.id) }.not_to raise_error
-      expect(test_class.exists?(obj.id)).to be false
-    end
-  end
-
-  describe "overriding resource_class_factory" do
-    subject(:test_base) { TestBase.new }
-    before do
-      class TestResource < ActiveTriples::Resource
-      end
-      class TestBase < ActiveFedora::Base
-        def self.resource_class_factory
-          TestResource
-        end
-      end
-    end
-    after do
-      Object.send(:remove_const, :TestResource)
-      Object.send(:remove_const, :TestBase)
-    end
-    it "uses that factory for #resource" do
-      expect(test_base.resource.class.ancestors).to include TestResource
-    end
-  end
-end

data/spec/integration/basic_contains_association_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Associations::BasicContainsAssociation do
-  context "with a file" do
-    before do
-      class Source < ActiveFedora::Base
-        is_a_container
-      end
-    end
-
-    let(:model) { Source.new }
-
-    after do
-      Object.send(:remove_const, :Source)
-    end
-
-    it 'is empty' do
-      expect(model.contains).to eq []
-    end
-
-    it 'can build a child' do
-      child = model.contains.build
-      expect(child).to be_kind_of ActiveFedora::File
-      child.content = "hello"
-      model.save!
-      expect(child).to be_persisted
-      expect(child.uri.to_s).to include model.uri.to_s
-    end
-
-    it 'can create a child on a persisted parent' do
-      model.save!
-      child = model.contains.build
-      expect(child).to be_kind_of ActiveFedora::File
-      child.content = "hello"
-      model.save!
-      expect(child).to be_persisted
-      expect(child.uri.to_s).to include model.uri.to_s
-    end
-  end
-
-  context "with an AF::Base object" do
-    before do
-      class Thing < ActiveFedora::Base
-        property :title, predicate: ::RDF::Vocab::DC.title
-      end
-      class Source < ActiveFedora::Base
-        is_a_container class_name: 'Thing'
-      end
-    end
-    after do
-      Object.send(:remove_const, :Source)
-      Object.send(:remove_const, :Thing)
-    end
-
-    let(:model) { Source.new }
-
-    it 'is empty' do
-      expect(model.contains).to eq []
-    end
-
-    describe "creating" do
-      it 'can build a child' do
-        child = model.contains.build
-        expect(model.contains.build(title: ['my title'])).to be_kind_of Thing
-        model.save!
-        expect(child).to be_persisted
-        expect(child.uri.to_s).to include model.uri.to_s
-      end
-
-      it 'can create a child on a persisted parent' do
-        model.save!
-        child = model.contains.create(title: ['my title'])
-        expect(child).to be_kind_of Thing
-        expect(child).to be_persisted
-        expect(child.uri.to_s).to include model.uri.to_s
-      end
-    end
-
-    describe "loading" do
-      before do
-        model.save!
-        model.contains.create(title: ['title 1'])
-        model.contains.create(title: ['title 2'])
-        model.reload
-      end
-
-      it "has the two contained objects" do
-        expect(model.contains.size).to eq 2
-        expect(model.contains.map(&:title)).to contain_exactly ['title 1'], ['title 2']
-      end
-    end
-
-    describe "#destroy_all" do
-      before do
-        model.save!
-        model.contains.create(title: ['title 1'])
-        model.contains.create(title: ['title 2'])
-        model.reload
-      end
-
-      it "destroys the two contained objects" do
-        expect { model.contains.destroy_all }
-          .to change { model.contains.size }.by(-2)
-          .and change { Thing.count }.by(-2)
-      end
-    end
-
-    describe "#reload" do
-      before do
-        model.save!
-        child = model.contains.create(title: ['title 1'])
-        model.reload # Cause the model to load its graph that contains the child ids.
-        ActiveFedora::Base.find(child.id).destroy
-      end
-
-      it "can reload without attempting to load any deleted objects" do
-        expect { model.contains.reload }.not_to raise_error
-      end
-    end
-  end
-end