active-fedora 9.13.0 → 10.0.0.beta1

data/spec/integration/ntriples_datastream_spec.rb

@@ -6,38 +6,21 @@ describe ActiveFedora::NtriplesRDFDatastream do
       property :size
     end
 
-    Deprecation.silence(ActiveFedora::RDFDatastream) do
-      class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :title, predicate: ::RDF::Vocab::DC.title do |index|
-          index.as :stored_searchable, :facetable
-        end
-        property :date_uploaded, predicate: ::RDF::Vocab::DC.dateSubmitted do |index|
-          index.type :date
-          index.as :stored_searchable, :sortable
-        end
-        property :filesize, predicate: FileVocabulary.size do |index|
-          index.type :integer
-          index.as :stored_sortable
-        end
-        property :part, predicate: ::RDF::Vocab::DC.hasPart
-        property :based_near, predicate: ::RDF::FOAF.based_near
-        property :related_url, predicate: ::RDF::RDFS.seeAlso
-      end
+    class MyDatastream < ActiveFedora::NtriplesRDFDatastream
+      property :title, predicate: ::RDF::Vocab::DC.title
+      property :date_uploaded, predicate: ::RDF::Vocab::DC.dateSubmitted
+      property :filesize, predicate: FileVocabulary.size
+      property :part, predicate: ::RDF::Vocab::DC.hasPart
+      property :based_near, predicate: ::RDF::FOAF.based_near
+      property :related_url, predicate: ::RDF::RDFS.seeAlso
     end
 
     class RdfTest < ActiveFedora::Base
       has_subresource 'rdf', class_name: 'MyDatastream'
-      Deprecation.silence(ActiveFedora::Attributes) do
-        has_attributes :based_near, :related_url, :part, :date_uploaded, datastream: 'rdf', multiple: true
-        has_attributes :title, :filesize, datastream: 'rdf', multiple: false
-      end
     end
-    @subject = RdfTest.new
   end
 
-  subject {
-    @subject
-  }
+  subject { MyDatastream.new(described_class.id_to_uri('test:1')) }
 
   after do
     Object.send(:remove_const, :RdfTest)
@@ -45,10 +28,6 @@ describe ActiveFedora::NtriplesRDFDatastream do
     Object.send(:remove_const, :FileVocabulary)
   end
 
-  it "does not try to send an empty datastream" do
-    @subject.save
-  end
-
   let(:remote_content) do
     <<EOF
 <#{ActiveFedora.fedora.host}/test/test:1> <http://purl.org/dc/terms/created> "2010-12-31"^^<http://www.w3.org/2001/XMLSchema#date> .
@@ -60,109 +39,73 @@ describe ActiveFedora::NtriplesRDFDatastream do
 EOF
   end
 
-  it "saves content properly upon save" do
-    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'
-    foo.rdf.content = remote_content
-    foo.save
-    expect(foo.title).to eq 'Title of work'
-  end
-
   it "delegates 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\"\]"
-  end
-
-  it "solrizes even when the object is not new" do
-    foo = RdfTest.new
-    expect(foo).to receive(:update_index).once
-    foo.title = "title1"
-    foo.save
-    foo = RdfTest.find(foo.id)
-    expect(foo).to receive(:update_index).once
-    foo.title = "The Work2"
-    foo.save
+    subject.title = "Title of work"
+    expect(subject.title.as_json).to eq ["Title of work"]
+    expect(subject.title.to_json).to eq "\[\"Title of work\"\]"
   end
 
   describe "serializing" do
     it "handles dates" 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.index_field_mapper.solr_name('rdf__date_uploaded', type: :date)]).to eq ['2012-11-02T00:00:00Z']
     end
     it "handles integers" do
       subject.filesize = 12_345
-      expect(subject.filesize).to be_kind_of Fixnum
-      solr_document = subject.to_solr
-      expect(solr_document[ActiveFedora.index_field_mapper.solr_name('rdf__filesize', :stored_sortable, type: :integer)]).to eq '12345'
+      expect(subject.filesize).to be_kind_of Array
+      expect(subject.filesize.first).to be_kind_of Fixnum
     end
   end
 
-  it "produces a solr document" do
-    @subject = RdfTest.new(title: "War and Peace")
-    solr_document = @subject.to_solr
-    expect(solr_document[ActiveFedora.index_field_mapper.solr_name('rdf__title', :facetable)]).to eq ["War and Peace"]
-    expect(solr_document[ActiveFedora.index_field_mapper.solr_name('rdf__title', type: :string)]).to eq ["War and Peace"]
-  end
-
   it "sets and recall values" do
-    @subject.title = 'War and Peace'
-    expect(@subject.rdf).to be_changed
-    @subject.based_near = ["Moscow, Russia"]
-    @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"]
-  end
-
-  it "set,s persist, and recall values" do
-    @subject.title = 'War and Peace'
-    @subject.based_near = ["Moscow, Russia"]
-    @subject.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
-    @subject.part = ["this is a part"]
-    @subject.save
-
-    loaded = RdfTest.find(@subject.id)
-    expect(loaded.title).to eq 'War and Peace'
+    subject.title = 'War and Peace'
+    expect(subject).to be_changed
+    subject.based_near = ["Moscow, Russia"]
+    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"]
+  end
+
+  it "set, persist, and recall values" do
+    subject.title = 'War and Peace'
+    subject.based_near = ["Moscow, Russia"]
+    subject.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
+    subject.part = ["this is a part"]
+    subject.save
+
+    loaded = MyDatastream.new(subject.uri)
+    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 "sets multiple values" do
-    @subject.part = ["part 1", "part 2"]
-    @subject.save
+    subject.part = ["part 1", "part 2"]
+    subject.save
 
-    loaded = RdfTest.find(@subject.id)
+    loaded = MyDatastream.new(subject.uri)
     expect(loaded.part).to eq ['part 1', 'part 2']
   end
 
   it "appends values" do
-    @subject.part = ["thing 1"]
-    @subject.save
+    subject.part = ["thing 1"]
+    subject.save
 
-    @subject.part << "thing 2"
-    expect(@subject.part).to eq ["thing 1", "thing 2"]
-  end
-
-  it "is able to save a blank document" do
-    @subject.title = ""
-    @subject.save
+    subject.part << "thing 2"
+    expect(subject.part).to eq ["thing 1", "thing 2"]
   end
 
   it "loads n-triples into the graph" do
     ntrip = '<http://oregondigital.org/ns/62> <http://purl.org/dc/terms/type> "Image" .
 <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
+    subject.content = ntrip
+    expect(subject.graph.dump(:ntriples)).to eq ntrip
   end
 
   describe "using rdf_subject" do
@@ -190,76 +133,71 @@ EOF
   end
 
   it "deletes values" do
-    @subject.title = "Hamlet"
-    @subject.related_url = ["http://psu.edu/"]
-    @subject.related_url << "http://projecthydra.org/"
+    subject.title = "Hamlet"
+    subject.related_url = ["http://psu.edu/"]
+    subject.related_url << "http://projecthydra.org/"
 
-    expect(@subject.title).to eq "Hamlet"
-    expect(@subject.related_url).to include("http://psu.edu/")
-    expect(@subject.related_url).to include("http://projecthydra.org/")
+    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 ''
+    subject.title = "" # empty string can be meaningful, don't assume delete.
+    expect(subject.title).to eq ['']
 
-    @subject.title = nil
-    @subject.related_url.delete("http://projecthydra.org/")
+    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.title).to eq []
+    expect(subject.related_url).to eq ["http://psu.edu/"]
   end
+
   it "deletes multiple values at once" do
-    @subject.part = ["MacBeth"]
-    @subject.part << "Hamlet"
-    @subject.part << "Romeo & Juliet"
-    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"
+    subject.part = ["MacBeth"]
+    subject.part << "Hamlet"
+    subject.part << "Romeo & Juliet"
+    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"
   end
   it "ignores 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"]
+    subject.part = ["title1", "title2", "title3"]
+    subject.part.delete("title2", "title4", "title6")
+    expect(subject.part).to eq ["title1", "title3"]
   end
+
   describe "term proxy methods" do
     before(:each) do
       class TitleDatastream < ActiveFedora::NtriplesRDFDatastream
         property :title, predicate: ::RDF::Vocab::DC.title
       end
-      class Foobar < ActiveFedora::Base
-        has_subresource 'rdf', class_name: 'TitleDatastream'
-        Deprecation.silence(ActiveFedora::Attributes) do
-          has_attributes :title, datastream: 'rdf', multiple: true
-        end
-      end
-      @subject = Foobar.new
-      @subject.title = ["title1", "title2", "title3"]
     end
+    subject { TitleDatastream.new }
+    before { subject.title = ["title1", "title2", "title3"] }
 
     after(:each) do
-      Object.send(:remove_const, :Foobar)
       Object.send(:remove_const, :TitleDatastream)
     end
 
     it "supports the count method to determine # of values" do
-      expect(@subject.title.count).to eq 3
+      expect(subject.title.count).to eq 3
     end
     it "iterates over multiple values" do
-      expect(@subject.title).to respond_to(:each)
+      expect(subject.title).to respond_to(:each)
     end
     it "gets the first value" do
-      expect(@subject.title.first).to eq "title1"
+      expect(subject.title.first).to eq "title1"
     end
     it "evaluates equality predictably" do
-      expect(@subject.title).to eq ["title1", "title2", "title3"]
+      expect(subject.title).to eq ["title1", "title2", "title3"]
     end
     it "supports the empty? method" do
-      expect(@subject.title).to_not be_empty
-      @subject.title.delete("title1", "title2", "title3")
-      expect(@subject.title).to be_empty
+      expect(subject.title).to_not be_empty
+      subject.title.delete("title1", "title2", "title3")
+      expect(subject.title).to be_empty
     end
     it "supports 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

data/spec/integration/relation_delegation_spec.rb

@@ -1,33 +1,31 @@
 require 'spec_helper'
 
-describe ActiveFedora::Model do
+describe ActiveFedora::Base do
   before(:all) do
-    module ModelIntegrationSpec
-      class Basic < 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
+    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, :ModelIntegrationSpec)
+    Object.send(:remove_const, :TestClass)
   end
 
   describe "with multiple objects" do
-    let!(:instance1) { ModelIntegrationSpec::Basic.create!(foo: ['Beta'], bar: ['Chips']) }
-    let!(:instance2) { ModelIntegrationSpec::Basic.create!(foo: ['Alpha'], bar: ['Peanuts']) }
-    let!(:instance3) { ModelIntegrationSpec::Basic.create!(foo: ['Sigma'], bar: ['Peanuts']) }
+    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 { ModelIntegrationSpec::Basic.where(bar: 'Peanuts') }
+    subject { TestClass.where(bar: 'Peanuts') }
 
     it "maps" do
       expect(subject.map(&:id)).to eq [instance2.id, instance3.id]

data/spec/integration/{model_spec.rb → scoping_spec.rb}

@@ -1,30 +1,25 @@
 require 'spec_helper'
 
-describe ActiveFedora::Model do
+describe ActiveFedora::Scoping::Named do
   before do
-    module ModelIntegrationSpec
-      class Base < ActiveFedora::Base
-        include ActiveFedora::Model
-      end
-      class Basic < Base
-      end
+    class TestClass < ActiveFedora::Base
     end
   end
-  let!(:test_instance) { ModelIntegrationSpec::Basic.create! }
+  let!(:test_instance) { TestClass.create! }
 
   after do
     test_instance.delete
-    Object.send(:remove_const, :ModelIntegrationSpec)
+    Object.send(:remove_const, :TestClass)
   end
 
   describe "#all" do
     it "returns an array of instances of the calling Class" do
-      result = ModelIntegrationSpec::Basic.all.to_a
+      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 ModelIntegrationSpec::Basic
+        expect(obj.class).to eq TestClass
       end
     end
   end
@@ -32,15 +27,16 @@ describe ActiveFedora::Model do
   describe '#find' do
     describe "#find with a valid id without cast" do
       subject { ActiveFedora::Base.find(test_instance.id) }
-      it { should be_instance_of ModelIntegrationSpec::Basic }
+      it { should be_instance_of TestClass }
     end
     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 id without cast on a model extending Base" do
-      subject { ModelIntegrationSpec::Basic.find(test_instance.id) }
-      it { should be_instance_of ModelIntegrationSpec::Basic }
+      subject { TestClass.find(test_instance.id) }
+      it { should be_instance_of TestClass }
     end
   end
 end

data/spec/integration/solr_hit_spec.rb

@@ -2,41 +2,25 @@ require 'spec_helper'
 
 describe ActiveFedora::SolrHit do
   before do
-    class MyDS < ActiveFedora::OmDatastream
-      set_terminology do |t|
-        t.root(path: "durh")
-        t.foo
-        t.bar
-      end
-    end
-
     class Foo < ActiveFedora::Base
-      has_subresource 'descMetadata', class_name: 'MyDS'
-      Deprecation.silence(ActiveFedora::Attributes) do
-        has_attributes :foo, datastream: 'descMetadata', multiple: true
-        has_attributes :bar, datastream: 'descMetadata', multiple: false
-      end
       property :title, predicate: ::RDF::Vocab::DC.title, multiple: false
     end
   end
 
+  after do
+    Object.send(:remove_const, :Foo)
+  end
+
   let(:another) { Foo.create }
 
   let!(:obj) { Foo.create!(
     id: 'test-123',
-    foo: ["baz"],
-    bar: 'quix',
     title: 'My Title'
   ) }
 
   let(:doc) { obj.to_solr }
   let(:solr_hit) { described_class.new(doc) }
 
-  after do
-    Object.send(:remove_const, :Foo)
-    Object.send(:remove_const, :MyDS)
-  end
-
   describe "#reify" do
     subject { solr_hit.reify }