active-fedora 8.7.0 → 9.0.0.beta1

data/spec/integration/solr_instance_loader_spec.rb

@@ -1,67 +1,83 @@
 require 'spec_helper'
 
-require 'active_fedora'
-
 describe ActiveFedora::SolrInstanceLoader do
-  before(:all) do
-    @test_object = ActiveFedora::Base.create
-    @test_object2 = ActiveFedora::Base.create
-  end
-
-  let(:context) { ActiveFedora::Base }
-  let(:pid) { nil }
-  let(:solr_doc) { nil }
-  let(:active_fedora_object) { ActiveFedora::Base.find(pid) }
-  subject { ActiveFedora::SolrInstanceLoader.new(context, pid, solr_doc) }
-
-  describe 'existing pid' do
-    let(:pid) { @test_object.pid }
-    describe 'without a solr document' do
-      it 'it finds the SOLR document and casts into an AF::Base object' do
-        expect(subject.object).to eq(active_fedora_object)
+  before do
+    class Foo < ActiveFedora::Base
+      has_metadata 'descMetadata', type: ActiveFedora::SimpleDatastream do |m|
+        m.field "foo", :text
+        m.field "bar", :text
       end
-    end
-    describe 'with matching solr document' do
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>pid).first }
-      it 'it casts the SOLR document and casts into an AF::Base object' do
-        expect(subject.object).to eq(active_fedora_object)
-      end
-    end
-    describe 'with a mismatching solr document' do
-      let(:mismatching_pid) { @test_object2.pid }
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>mismatching_pid).first }
-      it 'it raise ObjectNotFoundError' do
-        expect {
-          subject
-        }.to raise_error(ActiveFedora::ObjectNotFoundError)
+      has_attributes :foo, datastream: 'descMetadata', multiple: true
+      has_attributes :bar, datastream: 'descMetadata', multiple: false
+      property :title, predicate: ::RDF::DC.title
+      property :description, predicate: ::RDF::DC.description
+      belongs_to :another, predicate: ActiveFedora::RDF::RelsExt.isPartOf, class_name: 'Foo'
+
+      def title
+        super.first
       end
     end
   end
-  describe 'missing pid' do
-    let(:pid) { 'test:missing_pid' }
-    describe 'without a solr document' do
-      it 'it raise ObjectNotFoundError' do
-        expect {
-          subject.object
-        }.to raise_error(ActiveFedora::ObjectNotFoundError)
+
+  let(:another) { Foo.create }
+
+  let!(:obj) { Foo.create!(id: 'test-123', foo: ["baz"], bar: 'quix', title: 'My Title',
+                           description: ['first desc', 'second desc'], another_id: another.id) }
+
+  after do
+    Object.send(:remove_const, :Foo)
+  end
+
+
+  context "without a solr doc" do
+    subject { loader.object }
+
+    context "with context" do
+      let(:loader) { ActiveFedora::SolrInstanceLoader.new(Foo, obj.id) }
+
+      it "should find the document in solr" do
+        expect(subject).to be_instance_of Foo
+        expect(subject.title).to eq 'My Title'
+        expect(subject.description).to match_array ['first desc', 'second desc']
+        expect(subject.another_id).to eq another.id
       end
-    end
-    describe 'with matching solr document' do
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>pid).first }
-      it 'it raise ObjectNotFoundError' do
-        expect {
-          subject.object
-        }.to raise_error(ActiveFedora::ObjectNotFoundError)
+
+      it "should not be mutable" do
+        expect { subject.title = 'Foo' }.to raise_error ActiveFedora::ReadOnlyRecord
       end
     end
-    describe 'with a mismatching solr document' do
-      let(:mismatching_pid) { @test_object2.pid }
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>mismatching_pid).first }
-      it 'it raise ObjectNotFoundError' do
-        expect {
-          subject
-        }.to raise_error(ActiveFedora::ObjectNotFoundError)
+
+    context "without context" do
+      let(:loader) { ActiveFedora::SolrInstanceLoader.new(ActiveFedora::Base, obj.id) }
+
+      it "should find the document in solr" do
+        expect_any_instance_of(ActiveFedora::Datastream).to_not receive(:retrieve_content)
+        expect_any_instance_of(Ldp::Client).to_not receive(:get)
+        object = loader.object
+        expect(object).to be_instance_of Foo
+        expect(object.title).to eq 'My Title' # object assertion
+        expect(object.foo).to eq ['baz'] # datastream assertion
+
+        # and it's frozen
+        expect { object.title = ['changed'] }.to raise_error ActiveFedora::ReadOnlyRecord
+        expect(object.title).to eq 'My Title'
+
+        expect { object.foo = ['changed'] }.to raise_error ActiveFedora::ReadOnlyRecord
+        expect(object.foo).to eq ['baz']
       end
     end
   end
+
+  context "with a solr doc" do
+    let(:profile) { { "foo"=>["baz"], "bar"=>"quix", "title"=>["My Title"]}.to_json }
+    let(:doc) { { 'id' => 'test-123', 'has_model_ssim'=>['Foo'], 'object_profile_ssm' => profile } }
+    let(:loader) { ActiveFedora::SolrInstanceLoader.new(Foo, obj.id, doc) }
+
+    subject { loader.object }
+
+    it "should find the document in solr" do
+      expect(subject).to be_instance_of Foo
+      expect(subject.title).to eq 'My Title'
+    end
+  end
 end

data/spec/integration/solr_service_spec.rb

@@ -1,21 +1,17 @@
 require 'spec_helper'
 
-require 'active_fedora'
-
 describe ActiveFedora::SolrService do
   describe "#reify_solr_results" do
-    before(:all) do
+    before(:each) do
       class FooObject < ActiveFedora::Base
-        def self.pid_namespace
+        def self.id_namespace
           "foo"
         end
   
         has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream
       end
       @test_object = ActiveFedora::Base.new
-      @test_object.label = 'test_object'
       @foo_object = FooObject.new
-      @foo_object.label = 'foo_object'
       attributes = {"language"=>{0=>"Italian"},
                     "creator"=>{0=>"Linguist, A."},
                     "geography"=>{0=>"Italy"},
@@ -24,89 +20,32 @@ describe ActiveFedora::SolrService do
       @test_object.save
       @foo_object.save
       @profiles = {
-        'test' => @test_object.inner_object.profile,
-        'foo' => @foo_object.inner_object.profile,
-        'foo_descMetadata' => @foo_object.datastreams['descMetadata'].profile
+        # 'test' => @test_object.profile,
+        # 'foo' => @foo_object.profile,
+        # 'foo_descMetadata' => @foo_object.datastreams['descMetadata'].profile
       }
-      @foo_content = @foo_object.datastreams['descMetadata'].content
+      @foo_content = @foo_object.attached_files['descMetadata'].content
     end
-    after(:all) do
+    after(:each) do
       @test_object.delete
       @foo_object.delete
       Object.send(:remove_const, :FooObject)
     end
     it "should return an array of objects that are of the class stored in active_fedora_model_s" do
-      query = "id\:#{RSolr.solr_escape(@test_object.pid)} OR id\:#{RSolr.solr_escape(@foo_object.pid)}"
+      query = "id\:#{RSolr.escape(@test_object.id)} OR id\:#{RSolr.escape(@foo_object.id)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result)
-      expect(result.length).to eq(2)
+      expect(result.length).to eq 2
       result.each do |r|
-        expect(r.class == ActiveFedora::Base || r.class == FooObject).to be_truthy
+        expect((r.class == ActiveFedora::Base || r.class == FooObject)).to be true
       end
     end
     
-    it 'should load objects from solr data if a :load_from_solr option is passed in' do
-      query = "id\:#{RSolr.solr_escape(@test_object.pid)} OR id\:#{RSolr.solr_escape(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
-      expect(result.length).to eq(2)
-      result.each do |r|
-        expect(r.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
-        expect([ActiveFedora::Base, FooObject]).to include(r.class)
-        expect(['test_object','foo_object']).to include(r.label)
-        expect(@test_object.inner_object.profile).to eq(@profiles['test'])
-        expect(@foo_object.inner_object.profile).to eq(@profiles['foo'])
-        expect(@foo_object.datastreams['descMetadata'].profile).to eq(@profiles['foo_descMetadata'])
-        expect(@foo_object.datastreams['descMetadata'].content).to be_equivalent_to(@foo_content)
-      end
-    end
-    
-    it 'should instantiate all datastreams in the solr doc, even ones undeclared by the class' do
-      obj = ActiveFedora::Base.load_instance_from_solr @foo_object.pid 
-      expect(obj.datastreams.keys).to include('descMetadata')
-    end
-    
     it 'should #reify a lightweight object as a new instance' do
-      query = "id\:#{RSolr.solr_escape(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
-      solr_foo = result.first
-      real_foo = solr_foo.reify
-      expect(solr_foo.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
-      expect(real_foo.inner_object).to be_a(ActiveFedora::DigitalObject)
-      expect(solr_foo.label).to eq('foo_object')
-      expect(real_foo.label).to eq('foo_object')
-    end
-    
-    it 'should #reify! a lightweight object within the same instance' do
-      query = "id\:#{RSolr.solr_escape(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
-      solr_foo = result.first
-      expect(solr_foo.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
-      solr_foo.reify!
-      expect(solr_foo.inner_object).to be_a(ActiveFedora::DigitalObject)
-      expect(solr_foo.label).to eq('foo_object')
-    end
-    
-    it 'should raise an exception when attempting to reify a first-class object' do
-      query = "id\:#{RSolr.solr_escape(@foo_object.pid)}"
+      query = "id\:#{RSolr.escape(@foo_object.id)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
-      solr_foo = result.first
-      expect {solr_foo.reify}.not_to raise_exception
-      expect {solr_foo.reify!}.not_to raise_exception
-      expect {solr_foo.reify!}.to raise_exception(/already a full/)
-      expect {solr_foo.reify}.to raise_exception(/already a full/)
+      expect(result.first).to be_instance_of FooObject
     end
-  
-    it 'should call load_instance_from_solr if :load_from_solr option passed in' do
-      query = "id\:#{RSolr.solr_escape(@test_object.pid)} OR id\:#{RSolr.solr_escape(@foo_object.pid)}"
-      solr_result = ActiveFedora::SolrService.query(query)
-      expect(ActiveFedora::Base).to receive(:load_instance_from_solr).once
-      expect(FooObject).to receive(:load_instance_from_solr).once
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
-    end
-    
   end
 end

data/spec/integration/versionable_spec.rb

@@ -0,0 +1,477 @@
+require 'spec_helper'
+
+describe "a versionable class" do
+  before do
+    class WithVersions < ActiveFedora::Base
+      has_many_versions
+      property :title, predicate: ::RDF::DC.title
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :WithVersions)
+  end
+
+  subject { WithVersions.new }
+
+  it { is_expected.to be_versionable }
+
+  context "after saving" do
+    before do
+      subject.title = "Greetings Earthlings"
+      subject.save
+      subject.create_version
+    end
+
+    it "should set model_type to versionable" do
+      expect(subject.reload.model_type).to include ::RDF::URI.new('http://www.jcp.org/jcr/mix/1.0versionable')
+    end
+
+    it "should have one version" do
+      expect(subject.versions.size).to eq 1
+      expect(subject.versions.first).to be_kind_of ::RDF::Literal
+    end
+
+    context "two times" do
+      before do
+        subject.title = "Surrender and prepare to be boarded"
+        subject.save
+        subject.create_version
+      end
+
+      it "should have two versions" do
+        expect(subject.versions.size).to eq 2
+        subject.versions.each do |version|
+          expect(version).to be_kind_of ::RDF::Literal
+        end
+      end
+
+      context "then restoring" do
+        let(:first_version) { "version1" }
+        before do
+          subject.restore_version(first_version)
+        end
+
+        it "will return to the first version's values" do
+          expect(subject.title).to eql(["Greetings Earthlings"])
+        end
+
+        context "and creating additional versions" do
+          before do
+            subject.title = "Now, surrender and prepare to be boarded"
+            subject.save!
+            subject.create_version
+          end
+
+          it "should have three versions" do
+            expect(subject.versions.size).to eq 3
+            expect(subject.title).to eql(["Now, surrender and prepare to be boarded"])
+          end
+
+        end
+      end
+    end
+  end
+end
+
+describe "a versionable rdf datastream" do
+  before(:all) do
+    class VersionableDatastream < ActiveFedora::NtriplesRDFDatastream
+      has_many_versions
+      property :title, predicate: ::RDF::DC.title
+    end
+
+    class MockAFBase < ActiveFedora::Base
+      has_metadata "descMetadata", type: VersionableDatastream, autocreate: true
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :MockAFBase)
+    Object.send(:remove_const, :VersionableDatastream)
+  end
+
+  it "should create the object" do
+    MockAFBase.create
+  end
+
+  subject { test_object.descMetadata }
+
+  context "that exists in the repository" do
+    let(:test_object) { MockAFBase.create }
+
+    it "should be versionable" do
+      expect(subject).to be_versionable
+    end
+
+    context "before creating the datastream" do
+      it "should not have versions" do
+        expect(subject.versions).to be_empty
+      end
+      it "should not have a title" do
+        expect(subject.title).to be_empty
+      end
+    end
+
+    context "after creating the datastream" do
+      before do
+        subject.title = "Greetings Earthlings"
+        subject.save
+        subject.create_version
+        @original_size = subject.size
+      end
+
+      it "should set model_type to versionable" do
+        expect(subject.model_type).to include RDF::URI.new('http://www.jcp.org/jcr/mix/1.0versionable')
+      end
+
+      it "should have one version" do
+        expect(subject.versions.first).to be_kind_of ::RDF::Literal
+      end
+
+      it "should have a title" do
+        expect(subject.title).to eql(["Greetings Earthlings"])
+      end
+
+      it "should have a size" do
+        expect(subject.size).to_not be_nil
+      end
+
+      context "two times" do
+        before do
+          subject.title = "Surrender and prepare to be boarded"
+          subject.save
+          subject.create_version
+        end
+
+        it "should have two versions" do
+          expect(subject.versions.size).to eq 2
+          subject.versions.each do |version|
+            expect(version).to be_kind_of ::RDF::Literal
+          end
+        end
+
+        it "should have the new title" do
+          expect(subject.title).to eql(["Surrender and prepare to be boarded"])
+        end
+
+        it "should have a new size" do
+          expect(subject.size).to_not be_nil
+          expect(subject.size).to_not eq(@original_size)
+        end
+
+        context "then restoring" do
+          let(:first_version) { "version1" }
+          before do
+            subject.restore_version(first_version)
+          end
+
+          it "should have two unique versions" do
+            expect(subject.versions.size).to eq 2      
+          end
+
+          it "should load the restored datastream's content" do
+            expect(subject.title).to eql(["Greetings Earthlings"])
+          end
+
+          it "should be the same size as the original datastream" do
+            expect(subject.size).to eq @original_size
+          end
+
+          context "and creating additional versions" do
+            before do
+              subject.title = "Now, surrender and prepare to be boarded"
+              subject.save
+              subject.create_version
+            end
+
+            it "should have three unique versions" do
+              expect(subject.versions.size).to eq 3
+            end
+
+            it "should have a new title" do
+              expect(subject.title).to eql(["Now, surrender and prepare to be boarded"])
+            end
+
+            it "should have a new size" do
+              expect(subject.size).to_not eq @original_size
+            end
+
+          end
+        end
+      end
+    end
+  end
+end
+
+describe "a versionable OM datastream" do
+  before(:all) do
+    class VersionableDatastream < ActiveFedora::OmDatastream
+      has_many_versions
+      set_terminology do |t|
+        t.root(path: "foo")
+        t.title
+      end
+    end
+
+    class MockAFBase < ActiveFedora::Base
+      has_metadata "descMetadata", type: VersionableDatastream, autocreate: true
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :MockAFBase)
+    Object.send(:remove_const, :VersionableDatastream)
+  end
+
+  subject { test_object.descMetadata }
+
+  context "that exists in the repository" do
+    let(:test_object) { MockAFBase.create }
+
+    it "should be versionable" do
+      expect(subject).to be_versionable
+    end
+
+    context "before creating the datastream" do
+      it "should not have versions" do
+        expect(subject.versions).to be_empty
+      end
+      it "should not have a title" do
+        expect(subject.title).to be_empty
+      end
+    end
+
+    context "after creating the datastream" do
+      before do
+        subject.title = "Greetings Earthlings"
+        subject.save
+        subject.create_version
+        @original_size = subject.size
+      end
+
+      it "should set model_type to versionable" do
+        expect(subject.model_type).to include RDF::URI.new('http://www.jcp.org/jcr/mix/1.0versionable')
+      end
+
+      it "should have one version" do
+        expect(subject.versions.size).to eq 1
+        expect(subject.versions.first).to be_kind_of ::RDF::Literal
+      end
+
+      it "should have a title" do
+        expect(subject.title).to eql(["Greetings Earthlings"])
+      end
+
+      it "should have a size" do
+        expect(subject.size).to_not be_nil
+      end
+
+      context "two times" do
+
+        before do
+          subject.title = "Surrender and prepare to be boarded"
+          subject.save
+          subject.create_version
+        end
+
+        it "should have two unique versions" do
+          expect(subject.versions.size).to eq 2
+          subject.versions.each do |version|
+            expect(version).to be_kind_of ::RDF::Literal
+          end
+        end
+
+        it "should have the new title" do
+          expect(subject.title).to eql(["Surrender and prepare to be boarded"])
+        end
+
+        it "should have a new size" do
+          expect(subject.size).to_not be_nil
+          expect(subject.size).to_not eq(@original_size)
+        end
+
+        context "then restoring" do
+          let(:first_version) { "version1" }
+          before do
+            subject.restore_version(first_version)
+          end
+
+          it "should still have two unique versions" do
+            expect(subject.versions.size).to eq 2
+          end
+
+          it "should load the restored datastream's content" do
+            expect(subject.title).to eql(["Greetings Earthlings"])
+          end
+
+          it "should be the same size as the original datastream" do
+            expect(subject.size).to eq @original_size
+          end
+
+          context "and creating additional versions" do
+            before do
+              subject.title = "Now, surrender and prepare to be boarded"
+              subject.save
+              subject.create_version
+            end
+
+            it "should have three unique versions" do
+              expect(subject.versions.size).to eq 3
+            end
+
+            it "should have a new title" do
+              expect(subject.title).to eql(["Now, surrender and prepare to be boarded"])
+            end
+
+            it "should have a new size" do
+              expect(subject.size).to_not eq @original_size
+            end
+
+          end
+        end
+      end
+    end
+  end
+end
+
+describe "a versionable binary datastream" do
+  before(:all) do
+    class BinaryDatastream < ActiveFedora::File
+      has_many_versions
+    end
+
+    class MockAFBase < ActiveFedora::Base
+      has_file_datastream "content", type: BinaryDatastream, autocreate: true
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :MockAFBase)
+    Object.send(:remove_const, :BinaryDatastream)
+  end
+
+  subject { test_object.content }
+
+  context "that exists in the repository" do
+    let(:test_object) { MockAFBase.create }
+
+    it "should be versionable" do
+      expect(subject).to be_versionable
+    end
+
+    context "before creating the datastream" do
+      it "should not have versions" do
+        expect(subject.versions).to be_empty
+      end
+    end
+
+    context "after creating the datastream" do
+      let(:first_file) { File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" )) }
+      let(:first_name) { "dino.jpg" }
+      before do
+        subject.content = first_file
+        subject.original_name = first_name
+        subject.save
+        subject.create_version
+      end
+
+      it "should set model_type to versionable" do
+        expect(subject.model_type).to include RDF::URI.new('http://www.jcp.org/jcr/mix/1.0versionable')
+      end
+
+      it "should have one version" do
+        expect(subject.versions.size).to eq 1
+        expect(subject.original_name).to eql(first_name)
+        expect(subject.content.size).to eq first_file.size
+        expect(subject.versions.first).to be_kind_of ::RDF::Literal
+      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
+          subject.content = second_file
+          subject.original_name = second_name
+          subject.save
+          subject.create_version
+        end
+
+        it "should have two unique versions" do
+          expect(subject.versions.size).to eq 2
+          expect(subject.original_name).to eql(second_name)
+          expect(subject.content.size).to eq second_file.size
+          subject.versions.each do |version|
+            expect(version).to be_kind_of ::RDF::Literal
+          end
+        end
+
+        context "then restoring" do
+          let(:first_version) { "version1" }
+          before do
+            subject.restore_version(first_version)
+          end
+
+          it "should still have two unique versions" do
+            expect(subject.versions.size).to eq 2
+          end
+
+          it "should load the restored datastream's content" do
+            expect(subject.content.size).to eq first_file.size
+          end
+
+          it "should load the restored datastream's original name" do
+            expect(subject.original_name).to eql(first_name)
+          end
+
+          context "and creating additional versions" do
+            before do
+              subject.content = first_file
+              subject.original_name = first_name
+              subject.save
+              subject.create_version
+            end
+
+            it "should have three unique versions" do
+              expect(subject.versions.size).to eq 3
+              expect(subject.original_name).to eql(first_name)
+              expect(subject.content.size).to eq first_file.size
+              expect(subject.versions.first).to be_kind_of ::RDF::Literal
+            end
+
+          end
+        end
+      end
+    end
+  end
+end
+
+describe "a non-versionable resource" do 
+  before(:all) do
+    class NotVersionableWithVersions < ActiveFedora::Base
+      # explicitly don't call has_many_versions 
+      property :title, predicate: ::RDF::DC.title
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :NotVersionableWithVersions)
+  end
+
+  subject { NotVersionableWithVersions.new }
+
+  context "saved with no versions" do
+    it "should not have versions" do
+      subject.update(title: "Greetings Earthlings")
+      expect(subject).not_to have_versions
+    end
+  end
+
+  context "saved with versions" do
+    it "should have versions" do
+      subject.update(title: "Greetings Earthlings")
+      subject.create_version
+      expect(subject).to have_versions
+    end
+  end
+end