active-fedora 8.7.0 → 9.0.0.beta1

data/spec/unit/rdf_datastream_spec.rb

@@ -3,14 +3,16 @@ require 'spec_helper'
 
 describe ActiveFedora::RDFDatastream do
   describe "a new instance" do
-    its(:metadata?) { should be_truthy}
-    its(:content_changed?) { should be_falsey}
+    subject { ActiveFedora::RDFDatastream.new }
+    it { should be_metadata }
+    it { should_not be_content_changed }
   end
+
   describe "an instance that exists in the datastore, but hasn't been loaded" do
     before do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :title, :predicate => RDF::DC.title
-        property :description, :predicate => RDF::DC.description, :multivalue => false
+        property :title, predicate: ::RDF::DC.title
+        property :description, predicate: ::RDF::DC.description, :multivalue => false
       end
       class MyObj < ActiveFedora::Base
         has_metadata 'descMetadata', type: MyDatastream
@@ -18,89 +20,69 @@ describe ActiveFedora::RDFDatastream do
       @obj = MyObj.new
       @obj.descMetadata.title = 'Foobar'
       @obj.save
-      @obj.reload
     end
     after do
       @obj.destroy
       Object.send(:remove_const, :MyDatastream)
       Object.send(:remove_const, :MyObj)
     end
-    subject { @obj.descMetadata }
+
+    subject { @obj.reload.descMetadata }
+
     it "should not load the descMetadata datastream when calling content_changed?" do
-      expect(@obj.inner_object.repository).not_to receive(:datastream_dissemination).with(hash_including(:dsid=>'descMetadata'))
-      expect(subject).not_to be_content_changed
+      expect(subject).to_not receive(:retrieve_content)
+      expect(subject).to_not be_content_changed
     end
 
     it "should allow asserting an empty string" do
       subject.title = ['']
-      expect(subject.title).to eq([''])
+      expect(subject.title).to eq ['']
     end
 
     describe "when multivalue: false" do
       it "should return single values" do
         subject.description = 'my description'
-        expect(subject.description).to eq('my description')
+        expect(subject.description).to eq 'my description'
       end
     end
 
     it "should clear stuff" do
       subject.title = ['one', 'two', 'three']
       subject.title.clear
-      expect(subject.graph.query([subject.rdf_subject,  RDF::DC.title, nil]).first).to be_nil
+      expect(subject.graph.query([subject.rdf_subject,  ::RDF::DC.title, nil]).first).to be_nil
     end
 
     it "should have a list of fields" do
-      expect(MyDatastream.fields).to eq([:title, :description])
+      expect(MyDatastream.fields).to eq [:title, :description]
     end
   end
 
   describe "deserialize" do
-    let(:ds) { ActiveFedora::NtriplesRDFDatastream.new }
-    subject { ds.deserialize(data) }
-
-    context "with non-utf-8 characters" do
+    subject { ActiveFedora::NtriplesRDFDatastream.new }
+    it "should be able to handle non-utf-8 characters" do
       # see https://github.com/ruby-rdf/rdf/issues/142
-      let(:data) { "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n\xE2\x80\x99 \" .\n".force_encoding('ASCII-8BIT') }
-
-      it "should be able to handle non-utf-8 characters" do
-        expect(subject.dump(:ntriples)).to eq "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n’ \" .\n"
-      end
-    end
+      data = "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n\xE2\x80\x99 \" .\n".force_encoding('ASCII-8BIT')
 
-    context "when the object is saved and has no content in the datastream" do
-      let(:data) { nil }
-      before do
-        allow(ds).to receive(:new?).and_return(false);
-        allow(ds).to receive(:datastream_content).and_return(nil);
-      end
-      it "should return an empty graph" do
-        expect(subject).to be_kind_of RDF::Graph
-      end
+      result = subject.deserialize(data)
+      expect(result.dump(:ntriples)).to eq "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n’ \" .\n"
     end
   end
 
   describe 'content=' do
-    let(:ds) {ActiveFedora::NtriplesRDFDatastream.new}
+    let(:ds) {ActiveFedora::NtriplesRDFDatastream.new }
     it "should be able to handle non-utf-8 characters" do
       data = "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n\xE2\x80\x99 \" .\n".force_encoding('ASCII-8BIT')
       ds.content = data
       expect(ds.resource.dump(:ntriples)).to eq "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n’ \" .\n"
     end
-    context "when passed an IO-like object" do
-      let(:file) { File.new(File.join(File.dirname(__FILE__), "..", "fixtures", "dublin_core_rdf_descMetadata.nt")) }
-      it "should read it" do
-        ds.content = file
-        expect(ds.resource.dump(:ntriples)).to eq File.read(file.path)
-      end
-    end
   end
 
   describe 'legacy non-utf-8 characters' do
     let(:ds) do
-      datastream = ActiveFedora::NtriplesRDFDatastream.new
-      allow(datastream).to receive(:new?).and_return(false)
-      allow(datastream).to receive(:datastream_content).and_return("<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n\xE2\x80\x99 \" .\n".force_encoding('ASCII-8BIT'))
-      datastream
+      ActiveFedora::NtriplesRDFDatastream.new.tap do |datastream|
+        allow(datastream).to receive(:new_record?).and_return(false)
+        allow(datastream).to receive(:remote_content).and_return("<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n\xE2\x80\x99 \" .\n".force_encoding('ASCII-8BIT'))
+      end
     end
     it "should not error on access" do
       expect(ds.resource.dump(:ntriples)).to eq "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n’ \" .\n"

data/spec/unit/rdf_resource_datastream_spec.rb

@@ -3,18 +3,18 @@ require 'spec_helper'
 describe ActiveFedora::RDFDatastream do
   before do
     class DummySubnode < ActiveTriples::Resource
-      property :title, :predicate => RDF::DC[:title], :class_name => RDF::Literal
-      property :relation, :predicate => RDF::DC[:relation]
+      property :title, predicate: ::RDF::DC[:title], class_name: ::RDF::Literal
+      property :relation, predicate: ::RDF::DC[:relation]
     end
 
     class DummyResource < ActiveFedora::RDFDatastream
-      property :title, :predicate => RDF::DC[:title], :class_name => RDF::Literal do |index|
+      property :title, predicate: ::RDF::DC[:title], class_name: ::RDF::Literal do |index|
         index.as :searchable, :displayable
       end
-      property :license, :predicate => RDF::DC[:license], :class_name => DummySubnode do |index|
+      property :license, predicate: ::RDF::DC[:license], class_name: DummySubnode do |index|
         index.as :searchable, :displayable
       end
-      property :creator, :predicate => RDF::DC[:creator], :class_name => "DummyAsset" do |index|
+      property :creator, predicate: ::RDF::DC[:creator], class_name: 'DummyAsset' do |index|
         index.as :searchable
       end
       def serialization_format
@@ -23,20 +23,19 @@ describe ActiveFedora::RDFDatastream do
     end
 
     class DummyAsset < ActiveFedora::Base
-      has_metadata :name => 'descMetadata', :type => DummyResource
-      has_attributes :title, datastream: 'descMetadata', multiple: true
-      has_attributes :license, :datastream => 'descMetadata', :multiple => true
-      has_attributes :relation, :datastream => 'descMetadata', :at => [:license, :relation], :multiple => false
+      has_metadata  'descMetadata', type: DummyResource
+      has_attributes :title, :license, datastream: 'descMetadata', multiple: true
+      has_attributes :relation, datastream: 'descMetadata', at: [:license, :relation], multiple: false
     end
   end
 
   after do
-    Object.send(:remove_const, "DummyAsset") if Object
-    Object.send(:remove_const, "DummyResource") if Object
-    Object.send(:remove_const, "DummySubnode") if Object
+    Object.send(:remove_const, "DummyAsset")
+    Object.send(:remove_const, "DummyResource")
+    Object.send(:remove_const, "DummySubnode")
   end
 
-  subject {DummyAsset.new}
+  subject { DummyAsset.new }
 
   describe "#to_solr" do
     before do
@@ -67,19 +66,6 @@ describe ActiveFedora::RDFDatastream do
       subject.title = ["blah"]
       expect(subject.descMetadata.title).to eq ["blah"]
     end
-
-    context "when the delegation is deep" do
-      before(:each) do
-        dummy = DummySubnode.new
-        dummy.relation = 'subbla'
-        subject.descMetadata.license = dummy
-      end
-
-      # This test is pending. For now we have no use case for deep delegation into an RDF graph.
-      xit "should retrieve values" do
-        expect(subject.relation).to eq ["subbla"]
-      end
-    end
   end
 
   describe "attribute setting" do
@@ -103,7 +89,7 @@ describe ActiveFedora::RDFDatastream do
         end
 
         it "should be persisted" do
-          expect(subject.descMetadata.resource.persisted?).to be true
+          expect(subject.descMetadata.resource).to be_persisted
         end
 
         context "and it's reloaded" do
@@ -122,7 +108,7 @@ describe ActiveFedora::RDFDatastream do
 
         context "and it is found again" do
           before do
-            @object = DummyAsset.find(subject.pid)
+            @object = DummyAsset.find(subject.id)
           end
 
           it "should serialize to content" do
@@ -134,7 +120,7 @@ describe ActiveFedora::RDFDatastream do
           end
 
           it "should have datastream content" do
-            expect(@object.descMetadata.datastream_content).not_to be_blank
+            expect(@object.descMetadata.remote_content).not_to be_blank
           end
         end
       end
@@ -144,7 +130,7 @@ describe ActiveFedora::RDFDatastream do
       context "persisted to parent" do
         before do
           dummy = DummySubnode.new
-          dummy.title = ['subbla']
+          dummy.title = 'subbla'
           subject.descMetadata.license = dummy
         end
 
@@ -161,7 +147,7 @@ describe ActiveFedora::RDFDatastream do
           DummySubnode.configure :repository => :default
           allow_any_instance_of(DummySubnode).to receive(:repository).and_return(RDF::Repository.new)
           dummy = DummySubnode.new(RDF::URI('http://example.org/dummy/blah'))
-          dummy.title = ['subbla']
+          dummy.title = 'subbla'
           # We want to have to manually persist to the repository.
           # Parent objects shouldn't be persisting children they share with other parents
           dummy.persist!
@@ -179,18 +165,6 @@ describe ActiveFedora::RDFDatastream do
     end
   end
 
-  describe "asset.load_instance_from_solr" do
-    before do
-      subject.descMetadata.title = "Monkeys"
-      subject.save
-      @loaded_object = DummyAsset.load_instance_from_solr(subject.pid)
-    end
-
-    it "should load the datastream" do
-      expect(@loaded_object.title).to eq ["Monkeys"]
-    end
-  end
-
   describe "relationships" do
     before do
       @new_object = DummyAsset.new
@@ -209,6 +183,7 @@ describe ActiveFedora::RDFDatastream do
       subject.reload
       expect(subject.descMetadata.creator.first).to be_kind_of(ActiveFedora::Base)
     end
+
     context "when the AF:Base object is deleted" do
       before do
         subject.save
@@ -228,11 +203,15 @@ describe ActiveFedora::RDFDatastream do
 
     context "when the subject is set with base_uri" do
       before do
+        @old_uri = DummyResource.resource_class.base_uri
         DummyResource.resource_class.configure :base_uri => 'http://example.org/'
         new_object = DummyAsset.new
         new_object.save
         subject.descMetadata.creator = new_object
       end
+      after do
+        DummyResource.resource_class.configure :base_uri => @old_uri
+      end
 
       it "should let me get to an AF:Base object" do
         subject.save
@@ -244,7 +223,7 @@ describe ActiveFedora::RDFDatastream do
     context "when the object with a relationship is saved" do
       before do
         subject.save
-        @object = subject.class.find(subject.pid)
+        @object = subject.class.find(subject.id)
       end
 
       it "should be retrievable" do
@@ -255,7 +234,7 @@ describe ActiveFedora::RDFDatastream do
     context "when the object with a relationship is frozen" do
       before do
         subject.save
-        @object = subject.class.find(subject.pid)
+        @object = subject.class.find(subject.id)
         @object.freeze
         subject.freeze
       end
@@ -264,83 +243,5 @@ describe ActiveFedora::RDFDatastream do
         expect(subject.descMetadata.creator.first.title).to eq ["subbla"]
       end
     end
-
-    context 'when the object has no Rdf::Resource' do
-      before do
-        class DummyOmAsset < ActiveFedora::Base
-          has_metadata :name => 'descMetadata', :type => ActiveFedora::OmDatastream
-        end
-
-        @new_object = DummyOmAsset.new
-        @new_object.save
-        subject.title = ["bla"]
-        subject.descMetadata.creator = @new_object
-        subject.save
-        subject.reload
-      end
-
-      after do
-        Object.send(:remove_const, "DummyOmAsset") if Object
-      end
-
-      it "should let me get to an AF:Base object" do
-        expect(subject.descMetadata.creator.first).to be_kind_of(ActiveFedora::Base)
-      end
-
-      it "should not allow writing to the graph" do
-        expect{@new_object.resource << RDF::Statement.new(RDF::Node.new, RDF::DC.title, 'title')
-}.to raise_error TypeError
-      end
-    end    
-  end
-
-  context 'with custom resource' do
-    before do
-
-      class DummyATResource < ActiveTriples::Resource
-        configure :base_uri => 'http://example.org/at/obj#', :type => RDF::OWL.Thing
-        property :title, :predicate => RDF::DC.alternative
-        property :my_special_property, :predicate => RDF::DC.spatial
-      end
-
-      DummyResource.resource_class DummyATResource
-    end
-
-    after do
-      Object.send(:remove_const, "DummyATResource")
-    end
-
-    it 'lets me specify a resource class' do
-      expect(DummyResource.resource_class < DummyATResource).to eq true
-    end
-
-    it 'creates underlying resource of type resource_class' do
-      expect(subject.resource).to be_a DummyATResource
-    end
-
-    it 'has properties from resource_class' do
-      expect(subject.resource.class.properties).to include :my_special_property.to_s
-    end
-
-    it 'favors property configuration from datastream' do
-      expect(subject.resource.class.properties['title'].predicate).to eq RDF::DC.title
-    end
-
-    it 'exposes resource propreties to parent object via datastream' do
-      subject.resource.title = 'Wizard of Oz'
-      expect(subject.title).to eq subject.resource.title
-    end
-
-    it 'applies base_uri from resource class' do
-      expect(subject.resource.class.base_uri).to eq DummyATResource.base_uri
-    end
-
-    it 'applies rdf type from resource class' do
-      expect(subject.resource.class.type).to eq DummyATResource.type
-    end
-
-    it 'refuses to change resource_class once set' do
-      expect { DummyResource.resource_class(ActiveTriples::Resource) }.to raise_error ArgumentError
-    end
   end
 end

data/spec/unit/{rdfxml_rdf_datastream_spec.rb → rdfxml_datastream_spec.rb}

@@ -1,20 +1,22 @@
 require 'spec_helper'
 
-describe ActiveFedora::RdfxmlRDFDatastream do
+describe ActiveFedora::RDFXMLDatastream do
   describe "a new instance" do
     before(:each) do
-      class MyRdfxmlDatastream < ActiveFedora::RdfxmlRDFDatastream
-        property :publisher, :predicate => RDF::DC.publisher
+      class MyRdfxmlDatastream < ActiveFedora::RDFXMLDatastream
+        property :publisher, predicate: ::RDF::DC.publisher
       end
-      @subject = MyRdfxmlDatastream.new(@inner_object, 'mixed_rdf')
-      allow(@subject).to receive_messages(:pid => 'test:1')
+      @subject = MyRdfxmlDatastream.new
+      allow(@subject).to receive(:id).and_return('test:1')
     end
+
     after(:each) do
       Object.send(:remove_const, :MyRdfxmlDatastream)
     end
+
     it "should save and reload" do
       @subject.publisher = ["St. Martin's Press"]
-      expect(@subject.serialize).to match(/<rdf:RDF/)
+      expect(@subject.serialize).to match /<rdf:RDF/
     end
   end
 
@@ -49,22 +51,22 @@ describe ActiveFedora::RdfxmlRDFDatastream do
         end
       end
 
-      class MyDatastream < ActiveFedora::RdfxmlRDFDatastream
-        property :resource_type, :predicate => DAMS.typeOfResource
-        property :title, :predicate => DAMS.title, :class_name => 'Description'
+      class MyDatastream < ActiveFedora::RDFXMLDatastream
+        property :resource_type, predicate: DAMS.typeOfResource
+        property :title, predicate: DAMS.title, :class_name => 'Description'
 
         rdf_subject { |ds| RDF::URI.new(ds.about) }
 
-        attr_reader :about
+        attr_accessor :about
 
-        def initialize(digital_object=nil, dsid=nil, options={})
+        def initialize(options={})
           @about = options.delete(:about)
           super
         end
 
         class Description < ActiveTriples::Resource
           configure :type => DAMS.Description
-          property :value, :predicate => RDF.value do |index|
+          property :value, predicate: ::RDF.value do |index|
               index.as :searchable
           end
         end
@@ -77,34 +79,28 @@ describe ActiveFedora::RdfxmlRDFDatastream do
     end
 
     describe "a new instance" do
-      subject { MyDatastream.new(double('inner object', :pid=>'test:1', :new_record? =>true), 'descMetadata', about:"http://library.ucsd.edu/ark:/20775/") }
+      subject { MyDatastream.new(about: "http://library.ucsd.edu/ark:/20775/") }
       it "should have a subject" do
-        expect(subject.rdf_subject.to_s).to eq("http://library.ucsd.edu/ark:/20775/")
+        expect(subject.rdf_subject.to_s).to eq "http://library.ucsd.edu/ark:/20775/"
       end
 
     end
 
     describe "an instance with content" do
       subject do
-        subject = MyDatastream.new(double('inner object', :pid=>'test:1', :new_record? =>true), 'descMetadata', about:"http://library.ucsd.edu/ark:/20775/")
+        subject = MyDatastream.new(about: "http://library.ucsd.edu/ark:/20775/")
         subject.content = File.new('spec/fixtures/damsObjectModel.xml').read
         subject
       end
       it "should have a subject" do
-        expect(subject.rdf_subject.to_s).to eq("http://library.ucsd.edu/ark:/20775/")
-      end
-      it "should have controlGroup" do
-        expect(subject.controlGroup).to eq('M')
+        expect(subject.rdf_subject.to_s).to eq "http://library.ucsd.edu/ark:/20775/"
       end
       it "should have mimeType" do
-        expect(subject.mimeType).to eq('text/xml')
-      end
-      it "should have dsid" do
-        expect(subject.dsid).to eq('descMetadata')
+        expect(subject.mime_type).to eq 'text/xml'
       end
       it "should have fields" do
-        expect(subject.resource_type).to eq(["image"])
-        expect(subject.title.first.value).to eq(["example title"])
+        expect(subject.resource_type).to eq ["image"]
+        expect(subject.title.first.value).to eq ["example title"]
       end
     end
   end