active-fedora 8.7.0 → 9.0.0.beta1

data/spec/integration/json_serialization_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe "Objects should be serialized to JSON" do
   it "should have json results" do
-    expect(ActiveFedora::Base.new.to_json).to eq("{\"id\":null}")
+    expect(ActiveFedora::Base.new.to_json).to eq "{\"id\":null}"
   end
 
-  describe "with a more interesting model" do
+  context "with properties and datastream attributes" do
     before do
       class Foo < ActiveFedora::Base
         has_metadata 'descMetadata', type: ActiveFedora::SimpleDatastream do |m|
@@ -14,18 +14,60 @@ describe "Objects should be serialized to JSON" do
         end
         has_attributes :foo, datastream: 'descMetadata', multiple: true
         has_attributes :bar, datastream: 'descMetadata', multiple: false
+        property :title, predicate: ::RDF::DC.title
       end
     end
+
     after do
       Object.send(:remove_const, :Foo)
     end
-    subject { Foo.new(foo: ["baz"], bar: 'quix') }
-    before { allow(subject).to receive_messages(pid: 'test:123') }
+
+    let(:obj) { Foo.new(foo: ["baz"], bar: 'quix', title: ['My Title']) }
+
+    before { allow(obj).to receive(:id).and_return('test-123') }
+
+    subject { JSON.parse(obj.to_json)}
+
     it "should have to_json" do
-      json = JSON.parse(subject.to_json)
-      expect(json['id']).to eq "test:123"
-      expect(json['foo']).to eq ["baz"]
-      expect(json['bar']).to eq "quix"
+      expect(subject['id']).to eq "test-123"
+      expect(subject['foo']).to eq ["baz"]
+      expect(subject['bar']).to eq "quix"
+      expect(subject['title']).to eq ["My Title"]
+    end
+  end
+
+  context "with nested nodes" do
+    before do
+      class DummySubnode < ActiveTriples::Resource
+        property :relation, predicate: ::RDF::DC[:relation]
+      end
+
+      class DummyResource < ActiveFedora::RDFDatastream
+        property :license, predicate: ::RDF::DC[:license], class_name: DummySubnode do |index|
+          index.as :searchable, :displayable
+        end
+        def serialization_format
+          :ntriples
+        end
+      end
+
+      class DummyAsset < ActiveFedora::Base
+        has_metadata  'descMetadata', type: DummyResource
+        has_attributes :relation, datastream: 'descMetadata', at: [:license, :relation], multiple: false
+      end
     end
+
+    after do
+      Object.send(:remove_const, "DummyAsset")
+      Object.send(:remove_const, "DummyResource")
+      Object.send(:remove_const, "DummySubnode")
+    end
+
+    let(:obj) { DummyAsset.new { |a| a.relation = 'Great Grandchild' } }
+    before { allow(obj).to receive(:id).and_return('test-123') }
+
+    subject { JSON.parse(obj.to_json)}
+
+    it { should eq("id"=>"test-123", "relation"=>"Great Grandchild") }
   end
 end

data/spec/integration/model_spec.rb

@@ -7,7 +7,7 @@ describe ActiveFedora::Model do
       
       class Base < ActiveFedora::Base
         include ActiveFedora::Model
-        def self.pid_namespace
+        def self.id_namespace
           "foo"
         end
         has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream, :autocreate => true 
@@ -31,42 +31,25 @@ describe ActiveFedora::Model 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_not be_empty
       result.each do |obj|
-        expect(obj.class).to eq(ModelIntegrationSpec::Basic)
+        expect(obj.class).to eq ModelIntegrationSpec::Basic
       end
     end
   end
 
   describe '#find' do
-    describe "#find with a valid pid without cast" do
-      subject { ActiveFedora::Base.find(@test_instance.pid) }
-      it { is_expected.to be_instance_of ModelIntegrationSpec::Basic}
+    describe "#find with a valid id without cast" do
+      subject { ActiveFedora::Base.find(@test_instance.id) }
+      it { should be_instance_of ModelIntegrationSpec::Basic }
     end
-    describe "#find with a valid pid with cast of false" do
-      subject { ActiveFedora::Base.find(@test_instance.pid, cast: false) }
-      it { is_expected.to be_instance_of ActiveFedora::Base}
+    describe "#find with a valid id with cast of false" do
+      subject { ActiveFedora::Base.find(@test_instance.id, cast: false) }
+      it { should be_instance_of ActiveFedora::Base }
     end
-    describe "#find with a valid pid without cast on a model extending Base" do
-      subject { ModelIntegrationSpec::Basic.find(@test_instance.pid) }
-      it { is_expected.to be_instance_of ModelIntegrationSpec::Basic}
-    end
-  end
-
-  describe "#load_instance_from_solr" do
-    describe "with a valid pid" do
-      subject { ActiveFedora::Base.load_instance_from_solr(@test_instance.pid) }
-      it { is_expected.to be_instance_of ModelIntegrationSpec::Basic}
-    end
-    describe "with metadata datastream spec" do
-      subject { ActiveFedora::Base.load_instance_from_solr(@test_instance.pid) }
-      it "should create an xml datastream" do
-        expect(subject.datastreams['properties']).to be_kind_of ActiveFedora::SimpleDatastream
-      end
-
-      it "should know the datastreams properties" do
-        expect(subject.properties.dsSize).to eq(9)
-      end
+    describe "#find with a valid id without cast on a model extending Base" do
+      subject { ModelIntegrationSpec::Basic.find(@test_instance.id) }
+      it { should be_instance_of ModelIntegrationSpec::Basic }
     end
   end
 end

data/spec/integration/nested_attribute_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "NestedAttribute behavior" do
   before do
     class Bar < ActiveFedora::Base
-      belongs_to :car, :property=>:has_member
+      belongs_to :car, predicate: ActiveFedora::RDF::RelsExt.hasMember
       has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
         m.field "uno", :string
         m.field "dos", :string
@@ -13,7 +13,7 @@ describe "NestedAttribute behavior" do
 
     # base Car class, used in test for association updates and :allow_destroy flag
     class Car < ActiveFedora::Base
-      has_many :bars, :property=>:has_member
+      has_many :bars, predicate: ActiveFedora::RDF::RelsExt.hasMember
       accepts_nested_attributes_for :bars, :allow_destroy=>true
     end
 
@@ -41,52 +41,60 @@ describe "NestedAttribute behavior" do
       accepts_nested_attributes_for :bars, :limit => 1
     end
   end
+  after do
+    Object.send(:remove_const, :Bar)
+    Object.send(:remove_const, :CarAllBlank)
+    Object.send(:remove_const, :CarProc)
+    Object.send(:remove_const, :CarSymbol)
+    Object.send(:remove_const, :CarWithLimit)
+    Object.send(:remove_const, :Car)
+  end
 
   it "should have _destroy" do
-    expect(Bar.new._destroy).to be_falsey
+    expect(Bar.new._destroy).to be_nil
   end
 
   it "should update the child objects" do
     @car, @bar1, @bar2 = create_car_with_bars
 
-    @car.attributes = {:bars_attributes=>[{:id=>@bar1.pid, :uno=>"bar1 uno"}, {:uno=>"newbar uno"}, {:id=>@bar2.pid, :_destroy=>'1', :uno=>'bar2 uno'}]}
-    expect(Bar.find(@bar1.pid).uno).to eq('bar1 uno')
-    expect(Bar.where(:id => @bar2.pid).first).to be_nil
-    expect(Bar.where(:uno => "newbar uno").first).not_to be_nil
+    @car.update bars_attributes: [{id: @bar1.id, uno: "bar1 uno"}, {uno: "newbar uno"}, {id: @bar2.id, _destroy: '1', uno: 'bar2 uno'}]
+    expect(Bar.find(@bar1.id).uno).to eq 'bar1 uno'
+    expect(Bar.where(:id => @bar2.id).first).to be_nil
+    expect(Bar.where(:uno => "newbar uno").first).to_not be_nil
 
     bars = @car.bars(true)
     expect(bars).to include(@bar1)
-    expect(bars).not_to include(@bar2)
+    expect(bars).to_not include(@bar2)
   end
 
   it "should reject attributes when all blank" do
     @car, @bar1, @bar2 = create_car_with_bars(CarAllBlank)
 
-    expect(@car.bars.count).to eq(2)
-    @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}]}
-    expect(@car.bars(true).count).to eq(2)
+    expect(@car.bars.count).to eq 2
+    @car.update bars_attributes: [{}, {:id=>@bar1.id, :uno=>"bar1 uno"}]
+    expect(@car.bars(true).count).to eq 2
 
     @bar1.reload
-    expect(@bar1.uno).to eq("bar1 uno")
+    expect(@bar1.uno).to eq "bar1 uno"
   end
 
   it "should reject attributes based on proc" do
     @car, @bar1, @bar2 = create_car_with_bars(CarProc)
 
-    @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}, {:id=>@bar2.pid, :dos=>"bar2 dos"}]}
+    @car.update bars_attributes: [{}, {:id=>@bar1.id, :uno=>"bar1 uno"}, {:id=>@bar2.id, :dos=>"bar2 dos"}]
     @bar1.reload
     @bar2.reload
-    expect(@bar1.uno).to eq("bar1 uno")
+    expect(@bar1.uno).to eq "bar1 uno"
     expect(@bar2.dos).to be_nil
   end
 
   it "should reject attributes base on method name" do
     @car, @bar1, @bar2 = create_car_with_bars(CarSymbol)
 
-    @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}, {:id=>@bar2.pid, :dos=>"bar2 dos"}]}
+    @car.update bars_attributes: [{}, {:id=>@bar1.id, :uno=>"bar1 uno"}, {:id=>@bar2.id, :dos=>"bar2 dos"}]
     @bar1.reload
     @bar2.reload
-    expect(@bar1.uno).to eq("bar1 uno")
+    expect(@bar1.uno).to eq "bar1 uno"
     expect(@bar2.dos).to be_nil
   end
 
@@ -95,7 +103,7 @@ describe "NestedAttribute behavior" do
 
     expect {
       @car.attributes = {:bars_attributes=>[{}]}
-    }.not_to raise_exception
+    }.to_not raise_exception
 
     expect {
       @car.attributes = {:bars_attributes=>[{}, {}]}
@@ -111,10 +119,10 @@ describe "NestedAttribute behavior" do
   #
   # @return [car,bar,bar] returns 1 Car and 2 Bars
   def create_car_with_bars(car_class = Car, bar_class = Bar)
-    car = car_class.new; car.save
+    car = car_class.new; car.save!
 
-    bar1 = bar_class.new(:car=>car); bar1.save
-    bar2 = bar_class.new(:car=>car); bar2.save
+    bar1 = bar_class.new(car: car); bar1.save!
+    bar2 = bar_class.new(car: car); bar2.save!
     [car, bar1, bar2]
   end
 

data/spec/integration/ntriples_datastream_spec.rb

@@ -2,16 +2,16 @@ require 'spec_helper'
 
 describe ActiveFedora::NtriplesRDFDatastream do
   before do
-    
+
     class FileVocabulary < RDF::Vocabulary("http://downlode.org/Code/RDF/File_Properties/schema#")
       property :size
     end
 
     class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-      property :title, predicate: RDF::DC.title do |index|
+      property :title, predicate: ::RDF::DC.title do |index|
         index.as :stored_searchable, :facetable
       end
-      property :date_uploaded, predicate: RDF::DC.dateSubmitted do |index|
+      property :date_uploaded, predicate: ::RDF::DC.dateSubmitted do |index|
         index.type :date
         index.as :stored_searchable, :sortable
       end
@@ -19,11 +19,12 @@ describe ActiveFedora::NtriplesRDFDatastream do
         index.type :integer
         index.as :stored_sortable
       end
-      property :part, predicate: RDF::DC.hasPart
-      property :based_near, predicate: RDF::FOAF.based_near
-      property :related_url, predicate: RDF::RDFS.seeAlso
+      property :part, predicate: ::RDF::DC.hasPart
+      property :based_near, predicate: ::RDF::FOAF.based_near
+      property :related_url, predicate: ::RDF::RDFS.seeAlso
     end
-    class RdfTest < ActiveFedora::Base 
+
+    class RdfTest < ActiveFedora::Base
       has_metadata 'rdf', type: MyDatastream
       has_attributes :based_near, :related_url, :part, :date_uploaded, datastream: 'rdf', multiple: true
       has_attributes :title, :filesize, datastream: 'rdf', multiple: false
@@ -46,19 +47,19 @@ describe ActiveFedora::NtriplesRDFDatastream do
   end
 
   it "should save content properly upon save" do
-    foo = RdfTest.new(pid: 'test:1') #Pid needs to match the subject in the loaded file
+    foo = RdfTest.new('test:1') #ID needs to match the subject in the loaded file
     foo.title = 'Hamlet'
     foo.save
-    expect(foo.title).to eq('Hamlet')
+    expect(foo.title).to eq 'Hamlet'
     foo.rdf.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
     foo.save
-    expect(foo.title).to eq('Title of work')
+    expect(foo.title).to eq 'Title of work'
   end
 
   it "should delegate as_json to the fields" do
     @subject = RdfTest.new(title: "Title of work")
-    expect(@subject.rdf.title.as_json).to eq(["Title of work"])
-    expect(@subject.rdf.title.to_json).to eq("\[\"Title of work\"\]")
+    expect(@subject.rdf.title.as_json).to eq ["Title of work"]
+    expect(@subject.rdf.title.to_json).to eq "\[\"Title of work\"\]"
   end
 
   it "should solrize even when the object is not new" do
@@ -66,10 +67,10 @@ describe ActiveFedora::NtriplesRDFDatastream do
     expect(foo).to receive(:update_index).once
     foo.title = "title1"
     foo.save
-    foo = RdfTest.find(foo.pid)
+    foo = RdfTest.find(foo.id)
     expect(foo).to receive(:update_index).once
     foo.title = "The Work2"
-    foo.save  
+    foo.save
   end
 
   describe "serializing" do
@@ -77,21 +78,21 @@ describe ActiveFedora::NtriplesRDFDatastream do
       subject.date_uploaded = [Date.parse('2012-11-02')]
       expect(subject.date_uploaded.first).to be_kind_of Date
       solr_document = subject.to_solr
-      expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__date_uploaded', type: :date)]).to eq(['2012-11-02T00:00:00Z'])
+      expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__date_uploaded', type: :date)]).to eq ['2012-11-02T00:00:00Z']
     end
     it "should handle integers" do
       subject.filesize = 12345 
       expect(subject.filesize).to be_kind_of Fixnum
       solr_document = subject.to_solr
-      expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__filesize', :stored_sortable, type: :integer)]).to eq('12345')
+      expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__filesize', :stored_sortable, type: :integer)]).to eq '12345'
     end
   end
 
   it "should produce a solr document" do
     @subject = RdfTest.new(title: "War and Peace")
     solr_document = @subject.to_solr
-    expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :facetable)]).to eq(["War and Peace"])
-    expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', type: :string)]).to eq(["War and Peace"])
+    expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :facetable)]).to eq ["War and Peace"]
+    expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', type: :string)]).to eq ["War and Peace"]
   end
 
   it "should set and recall values" do
@@ -101,11 +102,12 @@ describe ActiveFedora::NtriplesRDFDatastream do
     @subject.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
     @subject.part = ["this is a part"]
     @subject.save
-    expect(@subject.title).to eq('War and Peace')
-    expect(@subject.based_near).to eq(["Moscow, Russia"])
-    expect(@subject.related_url).to eq(["http://en.wikipedia.org/wiki/War_and_Peace"])
-    expect(@subject.part).to eq(["this is a part"])    
+    expect(@subject.title).to eq 'War and Peace'
+    expect(@subject.based_near).to eq ["Moscow, Russia"]
+    expect(@subject.related_url).to eq ["http://en.wikipedia.org/wiki/War_and_Peace"]
+    expect(@subject.part).to eq ["this is a part"]
   end
+
   it "should set, persist, and recall values" do
     @subject.title = 'War and Peace'
     @subject.based_near = ["Moscow, Russia"]
@@ -113,25 +115,27 @@ describe ActiveFedora::NtriplesRDFDatastream do
     @subject.part = ["this is a part"]
     @subject.save
 
-    loaded = RdfTest.find(@subject.pid)
-    expect(loaded.title).to eq('War and Peace')
-    expect(loaded.based_near).to eq(['Moscow, Russia'])
-    expect(loaded.related_url).to eq(['http://en.wikipedia.org/wiki/War_and_Peace'])
-    expect(loaded.part).to eq(['this is a part'])
+    loaded = RdfTest.find(@subject.id)
+    expect(loaded.title).to eq 'War and Peace'
+    expect(loaded.based_near).to eq ['Moscow, Russia']
+    expect(loaded.related_url).to eq ['http://en.wikipedia.org/wiki/War_and_Peace']
+    expect(loaded.part).to eq ['this is a part']
   end
+
   it "should set multiple values" do
     @subject.part = ["part 1", "part 2"]
     @subject.save
 
-    loaded = RdfTest.find(@subject.pid)
-    expect(loaded.part).to eq(['part 1', 'part 2'])
+    loaded = RdfTest.find(@subject.id)
+    expect(loaded.part).to eq ['part 1', 'part 2']
   end
+
   it "should append values" do
     @subject.part = ["thing 1"]
     @subject.save
 
     @subject.part << "thing 2"
-    expect(@subject.part).to eq(["thing 1", "thing 2"])
+    expect(@subject.part).to eq ["thing 1", "thing 2"]
   end
 
   it "should be able to save a blank document" do
@@ -144,30 +148,30 @@ describe ActiveFedora::NtriplesRDFDatastream do
 <http://oregondigital.org/ns/62> <http://purl.org/dc/terms/spatial> "Benton County (Ore.)" .
 '
     @subject.rdf.content = ntrip
-    expect(@subject.rdf.graph.dump(:ntriples)).to eq(ntrip)
+    expect(@subject.rdf.graph.dump(:ntriples)).to eq ntrip
   end
 
   describe "using rdf_subject" do
     before do
       # reopening existing class
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        rdf_subject { |ds| RDF::URI.new("http://oregondigital.org/ns/#{ds.pid.split(':')[1]}") }
-        property :dctype, predicate: RDF::DC.type
-        property :spatial, predicate: RDF::DC.spatial
+        rdf_subject { |ds| RDF::URI.new("http://oregondigital.org/ns/#{parent_uri(ds).split('/')[-1].split(':')[1]}") }
+        property :dctype, predicate: ::RDF::DC.type
       end
+      subject.rdf.dctype = "Frog"
+      subject.save!
     end
+
     after do
-      @subject.destroy
+      subject.destroy
     end
 
-    it "should write rdf with proper subjects" do
-      @subject.inner_object.pid = 'test:99'
-      @subject.rdf.dctype = "Frog"
-      @subject.save!
-      @subject.reload
-      expect(@subject.rdf.graph.dump(:ntriples)).to eq("<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n")
-      @subject.rdf.dctype == ['Frog']
+    subject { RdfTest.new('/test:99') }
 
+    it "should write rdf with proper subjects" do
+      subject.reload
+      expect(subject.rdf.graph.dump(:ntriples)).to eq "<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n"
+      subject.rdf.dctype == ['Frog']
     end
 
   end
@@ -178,37 +182,37 @@ describe ActiveFedora::NtriplesRDFDatastream do
     @subject.related_url = ["http://psu.edu/"]
     @subject.related_url << "http://projecthydra.org/"
 
-    expect(@subject.title).to eq("Hamlet")
+    expect(@subject.title).to eq "Hamlet"
     expect(@subject.related_url).to include("http://psu.edu/")
     expect(@subject.related_url).to include("http://projecthydra.org/")
 
     @subject.title = "" #empty string can be meaningful, don't assume delete.
-    expect(@subject.title).to eq('')
+    expect(@subject.title).to eq ''
 
     @subject.title = nil
     @subject.related_url.delete("http://projecthydra.org/")
 
     expect(@subject.title).to be_nil
-    expect(@subject.related_url).to eq(["http://psu.edu/"])
+    expect(@subject.related_url).to eq ["http://psu.edu/"]
   end
   it "should delete multiple values at once" do
     @subject.part = ["MacBeth"]
     @subject.part << "Hamlet"
     @subject.part << "Romeo & Juliet"
-    expect(@subject.part.first).to eq("MacBeth")
+    expect(@subject.part.first).to eq "MacBeth"
     @subject.part.delete("MacBeth", "Romeo & Juliet")
-    expect(@subject.part).to eq(["Hamlet"])
-    expect(@subject.part.first).to eq("Hamlet")
+    expect(@subject.part).to eq ["Hamlet"]
+    expect(@subject.part.first).to eq "Hamlet"
   end
   it "should ignore values to be deleted that do not exist" do
     @subject.part = ["title1", "title2", "title3"]
     @subject.part.delete("title2", "title4", "title6")
-    expect(@subject.part).to eq(["title1", "title3"])
+    expect(@subject.part).to eq ["title1", "title3"]
   end
   describe "term proxy methods" do
     before(:each) do
       class TitleDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :title, predicate: RDF::DC.title
+        property :title, predicate: ::RDF::DC.title
       end
       class Foobar < ActiveFedora::Base 
         has_metadata 'rdf', type: TitleDatastream
@@ -224,25 +228,24 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
 
     it "should support the count method to determine # of values" do
-      expect(@subject.title.count).to eq(3)
+      expect(@subject.title.count).to eq 3
     end
     it "should iterate over multiple values" do
       expect(@subject.title).to respond_to(:each)
     end
     it "should get the first value" do
-      expect(@subject.title.first).to eq("title1")
+      expect(@subject.title.first).to eq "title1"
     end
     it "should evaluate equality predictably" do
-      expect(@subject.title).to eq(["title1", "title2", "title3"])
+      expect(@subject.title).to eq ["title1", "title2", "title3"]
     end
     it "should support the empty? method" do
-      expect(@subject.title).to respond_to(:empty?)
-      expect(@subject.title.empty?).to be_falsey
+      expect(@subject.title).to_not be_empty
       @subject.title.delete("title1", "title2", "title3")
-      expect(@subject.title.empty?).to be_truthy
+      expect(@subject.title).to be_empty
     end
     it "should support the is_a? method" do
-      expect(@subject.title.is_a?(Array)).to eq(true)
+      expect(@subject.title.is_a?(Array)).to eq true
     end
   end
 end