active-fedora 13.1.2 → 13.1.3

data/spec/integration/relation_delegation_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before(:all) do
-    class TestClass < ActiveFedora::Base
-      property :foo, predicate: ::RDF::URI('http://example.com/foo')
-      property :bar, predicate: ::RDF::URI('http://example.com/bar') do |index|
-        index.as :stored_searchable
-      end
-
-      def to_solr(doc = {})
-        doc = super
-        doc[ActiveFedora.index_field_mapper.solr_name('foo', :sortable)] = doc[ActiveFedora.index_field_mapper.solr_name('foo', type: :string)]
-        doc
-      end
-    end
-  end
-
-  after(:all) do
-    Object.send(:remove_const, :TestClass)
-  end
-
-  describe "with multiple objects" do
-    let!(:instance1) { TestClass.create!(foo: ['Beta'], bar: ['Chips']) }
-    let!(:instance2) { TestClass.create!(foo: ['Alpha'], bar: ['Peanuts']) }
-    let!(:instance3) { TestClass.create!(foo: ['Sigma'], bar: ['Peanuts']) }
-
-    subject(:peanuts) { TestClass.where(bar: 'Peanuts') }
-
-    it "maps" do
-      expect(peanuts.map(&:id)).to contain_exactly instance2.id, instance3.id
-    end
-
-    it "collects" do
-      expect(peanuts.collect(&:id)).to contain_exactly instance2.id, instance3.id
-    end
-
-    it "has each" do
-      expect(peanuts.each.to_a.length).to eq 2
-    end
-
-    it "has all?" do
-      expect(peanuts.all? { |t| t.foo == ['Alpha'] }).to be false
-      expect(peanuts.all? { |t| t.bar == ['Peanuts'] }).to be true
-    end
-
-    it "has include?" do
-      expect(peanuts.include?(instance1)).to be false
-      expect(peanuts.include?(instance2)).to be true
-    end
-  end
-end

data/spec/integration/relation_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before :all do
-    class Library < ActiveFedora::Base
-      has_many :books
-    end
-    class Book < ActiveFedora::Base
-      belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
-    end
-  end
-
-  after :all do
-    Object.send(:remove_const, :Library)
-    Object.send(:remove_const, :Book)
-  end
-
-  subject(:libraries) { Library.all }
-
-  it "is a relation" do
-    expect(libraries.class).to be ActiveFedora::Relation
-  end
-
-  it { is_expected.to respond_to(:each_with_index) }
-  it { expect(libraries.any?).to eq false }
-  it { is_expected.to be_blank }
-  it { is_expected.to be_empty }
-  it { is_expected.not_to be_present }
-
-  context "when some records exist" do
-    before do
-      Library.create
-    end
-
-    let!(:library1) { Library.create }
-
-    describe "is cached" do
-      before do
-        libraries.to_a # trigger initial load
-      end
-
-      it { is_expected.to be_loaded }
-
-      it "does not reload" do
-        expect_any_instance_of(ActiveFedora::Relation).to_not receive :find_each
-        libraries[0]
-      end
-
-      it "does not reload" do
-        expect_any_instance_of(ActiveFedora::Relation).to_not receive :find_each
-        libraries.each { |l| l.id }
-      end
-    end
-
-    it { expect(libraries.any?).to eq true }
-    it { is_expected.not_to be_blank }
-    it { is_expected.not_to be_empty }
-    it { is_expected.to be_present }
-
-    describe '#each' do
-      before { Book.create }
-
-      it 'returns an enumerator' do
-        expect(libraries.each).to be_a Enumerator
-      end
-
-      it 'yields the items' do
-        expect { |b| libraries.each(&b) }
-          .to yield_successive_args(*Library.all.to_a)
-      end
-
-      it 'when called from Base yields all items' do
-        expect { |b| ActiveFedora::Base.all.each(&b) }
-          .to yield_successive_args(*(Library.all.to_a + Book.all.to_a))
-      end
-
-      context 'when cached' do
-        it 'returns an enumerator' do
-          expect(libraries.each).to be_a Enumerator
-        end
-
-        it 'yields the items' do
-          expect { |b| libraries.each(&b) }
-            .to yield_successive_args(*Library.all.to_a)
-        end
-      end
-    end
-
-    describe "#find" do
-      it "finds one of them" do
-        expect(libraries.find(library1.id)).to eq library1
-      end
-      it "finds with a block" do
-        expect(libraries.find { |l| l.id == library1.id }).to eq library1
-      end
-    end
-
-    describe "#select" do
-      it "finds with a block" do
-        expect(libraries.select { |l| l.id == library1.id }).to eq [library1]
-      end
-    end
-
-    context "unpermitted methods" do
-      it "excludes them" do
-        expect { libraries.sort! }.to raise_error NoMethodError
-      end
-    end
-
-    context "when limit is applied" do
-      subject(:libraries) { Library.create books: [Book.create, Book.create] }
-      it "limits the number of books" do
-        expect(libraries.books.limit(1).size).to eq 1
-      end
-    end
-  end
-end

data/spec/integration/scoped_query_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Querying do
-  before do
-    module ModelIntegrationSpec
-      class Basic < ActiveFedora::Base
-        property :foo, predicate: ::RDF::URI('http://example.com/foo') do |index|
-          index.as :stored_searchable
-        end
-        property :bar, predicate: ::RDF::URI('http://example.com/bar') do |index|
-          index.as :stored_searchable
-        end
-        property :baz, predicate: ::RDF::URI('http://example.com/baz')
-
-        def to_solr(doc = {})
-          doc = super
-          doc[ActiveFedora.index_field_mapper.solr_name('foo', :sortable)] = doc[ActiveFedora.index_field_mapper.solr_name('foo', type: :string)]
-          doc
-        end
-      end
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :ModelIntegrationSpec)
-  end
-
-  describe "When there is one object in the store" do
-    let!(:test_instance) { ModelIntegrationSpec::Basic.create! }
-
-    after do
-      test_instance.delete
-    end
-
-    describe ".all" do
-      it "returns an array of instances of the calling Class" do
-        result = ModelIntegrationSpec::Basic.all.to_a
-        expect(result).to be_instance_of(Array)
-        # this test is meaningless if the array length is zero
-        expect(result.length).to be > 0
-        expect(result).to all(be_an(ModelIntegrationSpec::Basic))
-      end
-    end
-
-    describe ".first" do
-      it "returns one instance of the calling class" do
-        expect(ModelIntegrationSpec::Basic.first).to eq test_instance
-      end
-    end
-  end
-
-  describe "with multiple objects" do
-    let!(:test_instance1) { ModelIntegrationSpec::Basic.create!(foo: ['Beta'], bar: ['Chips']) }
-    let!(:test_instance2) { ModelIntegrationSpec::Basic.create!(foo: ['Alpha'], bar: ['Peanuts']) }
-    let!(:test_instance3) { ModelIntegrationSpec::Basic.create!(foo: ['Sigma'], bar: ['Peanuts']) }
-
-    describe "when the objects are in fedora" do
-      after do
-        test_instance1.delete
-        test_instance2.delete
-        test_instance3.delete
-      end
-
-      it "queries" do
-        field = ActiveFedora.index_field_mapper.solr_name('foo', type: :string)
-        expect(ModelIntegrationSpec::Basic.where(field => 'Beta')).to eq [test_instance1]
-        expect(ModelIntegrationSpec::Basic.where('foo' => 'Beta')).to eq [test_instance1]
-        expect(ModelIntegrationSpec::Basic.where('foo' => ['Beta', 'Alpha'])).to eq [test_instance1, test_instance2]
-      end
-      it "orders" do
-        expect(ModelIntegrationSpec::Basic.order(ActiveFedora.index_field_mapper.solr_name('foo', :sortable) + ' asc')).to contain_exactly test_instance2, test_instance1, test_instance3
-      end
-      it "limits" do
-        expect(ModelIntegrationSpec::Basic.limit(1)).to eq [test_instance1]
-      end
-      it "offsets" do
-        expect(ModelIntegrationSpec::Basic.offset(1)).to contain_exactly test_instance2, test_instance3
-      end
-
-      it "chains queries" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora.index_field_mapper.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora.index_field_mapper.solr_name('foo', :sortable) + ' asc').limit(1)).to eq [test_instance2]
-      end
-
-      it "wraps string conditions with parentheses" do
-        expect(ModelIntegrationSpec::Basic.where("foo:bar OR bar:baz").where_values).to eq ["(foo:bar OR bar:baz)"]
-      end
-
-      it "chains where queries" do
-        first_condition = { ActiveFedora.index_field_mapper.solr_name('bar', type: :string) => 'Peanuts' }
-        second_condition = "foo_tesim:bar"
-        where_values = ModelIntegrationSpec::Basic.where(first_condition)
-                                                  .where(second_condition).where_values
-        expect(where_values).to eq ["_query_:\"{!field f=bar_tesim}Peanuts\"",
-                                    "(foo_tesim:bar)"]
-      end
-
-      it "chains count" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora.index_field_mapper.solr_name('bar', type: :string) => 'Peanuts').count).to eq 2
-      end
-
-      it "calling first should not affect the relation's ability to get all results later" do
-        relation = ModelIntegrationSpec::Basic.where(ActiveFedora.index_field_mapper.solr_name('bar', type: :string) => 'Peanuts')
-        expect { relation.first }.not_to change { relation.to_a.size }
-      end
-
-      it "calling where should not affect the relation's ability to get all results later" do
-        relation = ModelIntegrationSpec::Basic.where(ActiveFedora.index_field_mapper.solr_name('bar', type: :string) => 'Peanuts')
-        expect { relation.where(ActiveFedora.index_field_mapper.solr_name('foo', type: :string) => 'bar') }.not_to change { relation.to_a.size }
-      end
-
-      it "calling order should not affect the original order of the relation later" do
-        relation = ModelIntegrationSpec::Basic.order(ActiveFedora.index_field_mapper.solr_name('foo', :sortable) + ' asc')
-        expect { relation.order(ActiveFedora.index_field_mapper.solr_name('foo', :sortable) + ' desc') }.not_to change { relation.to_a }
-      end
-    end
-
-    describe "when one of the objects in solr isn't in fedora" do
-      let!(:id) { test_instance2.id }
-      before { Ldp::Resource::RdfSource.new(ActiveFedora.fedora.connection, test_instance2.uri).delete }
-      after do
-        ActiveFedora::SolrService.instance.conn.tap do |conn|
-          conn.delete_by_query "id:\"#{id}\""
-          conn.commit
-        end
-        test_instance1.delete
-        test_instance3.delete
-      end
-      it "logs an error" do
-        expect(ActiveFedora::Base.logger).to receive(:error).with("Although #{id} was found in Solr, it doesn't seem to exist in Fedora. The index is out of synch.")
-        expect(ModelIntegrationSpec::Basic.all).to contain_exactly test_instance1, test_instance3
-      end
-    end
-  end
-end

data/spec/integration/scoping_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Scoping::Named do
-  before(:all) do
-    class TestClass < ActiveFedora::Base; end
-    class OtherClass < ActiveFedora::Base; end
-  end
-  after(:all) do
-    Object.send(:remove_const, :TestClass)
-    Object.send(:remove_const, :OtherClass)
-  end
-
-  let!(:test_instance) { TestClass.create! }
-  after { test_instance.delete }
-
-  describe "#all" do
-    it "returns an array of instances of the calling Class" do
-      result = TestClass.all.to_a
-      expect(result).to be_instance_of(Array)
-      # this test is meaningless if the array length is zero
-      expect(result).to_not be_empty
-      result.each do |obj|
-        expect(obj.class).to eq TestClass
-      end
-    end
-  end
-
-  describe '#find' do
-    describe "a valid id without cast" do
-      subject { ActiveFedora::Base.find(test_instance.id) }
-      it { is_expected.to be_instance_of TestClass }
-    end
-    describe "a valid id with cast of false" do
-      subject { ActiveFedora::Base.find(test_instance.id, cast: false) }
-      it { is_expected.to be_instance_of ActiveFedora::Base }
-    end
-    describe "a valid id without cast on a model extending Base" do
-      subject { TestClass.find(test_instance.id) }
-      it { is_expected.to be_instance_of TestClass }
-    end
-    it "a valid id on an incompatible class raises ModelMismatch" do
-      expect { OtherClass.find(test_instance.id) }.to raise_error(ActiveFedora::ModelMismatch)
-    end
-    it "invalid id raises ObjectNotFoundError" do
-      expect { TestClass.find('some_unused_identifier') }.to raise_error(ActiveFedora::ObjectNotFoundError)
-    end
-  end
-end

data/spec/integration/solr_hit_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::SolrHit do
-  before do
-    class Foo < ActiveFedora::Base
-      property :title, predicate: ::RDF::Vocab::DC.title, multiple: false
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :Foo)
-  end
-
-  subject(:solr_hit) { described_class.new(doc) }
-  let(:another) { Foo.create }
-
-  let!(:obj) { Foo.create!(
-    id: 'test-123',
-    title: 'My Title'
-  ) }
-
-  let(:doc) { obj.to_solr }
-
-  describe "#reify" do
-    let(:solr_reified) { solr_hit.reify }
-
-    it "finds the document in solr" do
-      expect(solr_reified).to be_instance_of Foo
-      expect(solr_reified.title).to eq 'My Title'
-    end
-  end
-end

data/spec/integration/versionable_spec.rb

@@ -1,256 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Versionable do
-  context "For ActiveFedora::Base" do
-    before do
-      class WithVersions < ActiveFedora::Base
-        property :title, predicate: ::RDF::Vocab::DC.title
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :WithVersions)
-    end
-
-    subject(:object) { WithVersions.new }
-
-    let(:current_year) { DateTime.now.year.to_s }
-
-    context "saved with no versions" do
-      it "does not have versions" do
-        object.update(title: ["Greetings Earthlings"])
-        expect(object).not_to have_versions
-      end
-    end
-
-    context "saved with versions" do
-      it "has versions" do
-        object.update(title: ["Greetings Earthlings"])
-        object.create_version
-        expect(object).to have_versions
-      end
-    end
-
-    describe 'sorting versions' do
-      subject(:graph) { ActiveFedora::VersionsGraph.new }
-
-      before do
-        allow(graph).to receive(:fedora_versions) { versions }
-      end
-
-      let(:version1) { instance_double(ActiveFedora::VersionsGraph::ResourceVersion, uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e711aa993d-e1d2-4a65-93ee-3a12fc9541ab', label: 'version1', created: '2015-04-02T19:54:45.962Z') }
-      let(:version2) { instance_double(ActiveFedora::VersionsGraph::ResourceVersion, uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e790373a67-c9ee-447d-b740-4faa882b1a1f', label: 'version2', created: '2015-04-02T19:54:45.96Z') }
-      let(:versions) { [version1, version2] }
-
-      it 'sorts by DateTime' do
-        expect(graph.first).to eq version2
-      end
-
-      context 'with an unparseable created date' do
-        let(:version2) { instance_double(ActiveFedora::VersionsGraph::ResourceVersion, uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e790373a67-c9ee-447d-b740-4faa882b1a1f', label: 'version2', created: '') }
-
-        it 'raises an exception' do
-          expect { graph.first }.to raise_error(ActiveFedora::VersionLacksCreateDate)
-        end
-      end
-
-      context 'with a missing created date' do
-        before do
-          # Because mocks raise RSpec::Mocks::MockExpectationError instead
-          allow(version2).to receive(:created) { raise NoMethodError }
-        end
-
-        let(:version2) { instance_double(ActiveFedora::VersionsGraph::ResourceVersion, uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e790373a67-c9ee-447d-b740-4faa882b1a1f', label: 'version2') }
-
-        it 'raises an exception' do
-          expect { graph.first }.to raise_error(ActiveFedora::VersionLacksCreateDate)
-        end
-      end
-    end
-
-    context "after saving" do
-      before do
-        object.title = ["Greetings Earthlings"]
-        object.save
-        object.create_version
-      end
-
-      it { is_expected.to have_versions }
-
-      it "has one version" do
-        expect(object.versions).to be_kind_of ActiveFedora::VersionsGraph
-        expect(object.versions.all.first).to be_kind_of ActiveFedora::VersionsGraph::ResourceVersion
-        expect(object.versions.all.first.label).to eql "version1"
-        expect(object.versions.all.first.created).to start_with current_year
-      end
-
-      context "two times" do
-        before do
-          object.title = ["Surrender and prepare to be boarded"]
-          object.save
-          object.create_version
-        end
-
-        it "has two versions" do
-          expect(object.versions.all.size).to eq 2
-          object.versions.all.each_index do |index|
-            expect(object.versions.all[index].label).to end_with "version" + (index + 1).to_s
-            expect(object.versions.all[index].created).to start_with current_year
-          end
-        end
-
-        context "then restoring" do
-          let(:first_version) { "version1" }
-          before do
-            object.restore_version(first_version)
-          end
-
-          it "will return to the first version's values" do
-            expect(object.title).to eq(["Greetings Earthlings"])
-          end
-
-          context "and creating additional versions" do
-            before do
-              object.title = ["Now, surrender and prepare to be boarded"]
-              object.save!
-              object.create_version
-            end
-
-            it "has three versions" do
-              expect(object.versions.all.size).to eq 3
-              expect(object.title).to eq(["Now, surrender and prepare to be boarded"])
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe ActiveFedora::File do
-    before(:all) do
-      class BinaryDatastream < ActiveFedora::File
-      end
-
-      class MockAFBase < ActiveFedora::Base
-        has_subresource "content", class_name: 'BinaryDatastream', autocreate: true
-      end
-    end
-
-    after(:all) do
-      Object.send(:remove_const, :MockAFBase)
-      Object.send(:remove_const, :BinaryDatastream)
-    end
-
-    let(:content) { test_object.content }
-
-    let(:current_year) { DateTime.now.year.to_s }
-
-    context "that exists in the repository" do
-      let(:test_object) { MockAFBase.create }
-
-      context "before creating the file" do
-        it "does not have versions" do
-          expect(content.versions).to be_empty
-        end
-      end
-
-      context "after creating the file" do
-        let(:first_file) { File.new(File.join(File.dirname(__FILE__), "../fixtures/dino.jpg")) }
-        let(:first_name) { "dino.jpg" }
-        before do
-          content.content = first_file
-          content.original_name = first_name
-          content.save
-          content.create_version
-        end
-
-        it "links to versions endpoint" do
-          expect(content.metadata.ldp_source.graph.query(predicate: ::RDF::Vocab::Fcrepo4.hasVersions).objects).to_not be_empty
-        end
-
-        it "has one version" do
-          expect(content.versions.all.size).to eq 1
-          expect(content.original_name).to eql(first_name)
-          expect(content.content.size).to eq first_file.size
-          expect(content.versions.first.label).to eql "version1"
-          expect(content.versions.first.created).to start_with current_year
-        end
-
-        context "two times" do
-          let(:second_file) { File.new(File.join(File.dirname(__FILE__), "../fixtures/minivan.jpg")) }
-          let(:second_name) { "minivan.jpg" }
-          before do
-            content.content = second_file
-            content.original_name = second_name
-            content.save
-            content.create_version
-          end
-
-          it "has two unique versions" do
-            expect(content.versions.all.size).to eq 2
-            expect(content.original_name).to eql(second_name)
-            expect(content.content.size).to eq second_file.size
-            content.versions.all.each_index do |index|
-              expect(content.versions.all[index].label).to end_with "version" + (index + 1).to_s
-              expect(content.versions.all[index].created).to start_with current_year
-            end
-          end
-
-          context "with fixity checking" do
-            let(:results) do
-              results = []
-              content.versions.all.each do |version|
-                results << ActiveFedora::FixityService.new(version.uri).check
-              end
-              return results
-            end
-
-            it "reports on the fixity of each version" do
-              results.each do |result|
-                expect(result).to be true
-              end
-            end
-          end
-
-          context "then restoring" do
-            let(:first_version) { "version1" }
-            before do
-              content.restore_version(first_version)
-            end
-
-            it "stills have two unique versions" do
-              expect(content.versions.all.size).to eq 2
-            end
-
-            it "loads the restored file's content" do
-              expect(content.content.size).to eq first_file.size
-            end
-
-            it "loads the restored file's original name" do
-              expect(content.original_name).to eql(first_name)
-            end
-
-            context "and creating additional versions" do
-              before do
-                content.content = first_file
-                content.original_name = first_name
-                content.save
-                content.create_version
-              end
-
-              it "has three unique versions" do
-                expect(content.versions.all.size).to eq 3
-                expect(content.original_name).to eql(first_name)
-                expect(content.content.size).to eq first_file.size
-                content.versions.all.each_index do |index|
-                  expect(content.versions.all[index].label).to end_with "version" + (index + 1).to_s
-                  expect(content.versions.all[index].created).to start_with current_year
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end