active-fedora 9.13.0 → 10.0.0.beta1

data/spec/integration/solr_instance_loader_spec.rb

@@ -11,12 +11,7 @@ describe ActiveFedora::SolrInstanceLoader do
     end
 
     class Foo < ActiveFedora::Base
-      extend Deprecation
       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
       property :description, predicate: ::RDF::Vocab::DC.description
       belongs_to :another, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'Foo'
@@ -33,8 +28,6 @@ describe ActiveFedora::SolrInstanceLoader do
 
   let!(:obj) { Foo.create!(
     id: 'test-123',
-    foo: ["baz"],
-    bar: 'quix',
     title: 'My Title',
     description: ['first desc', 'second desc'],
     another_id: another.id,
@@ -58,7 +51,6 @@ describe ActiveFedora::SolrInstanceLoader do
         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
-        expect(subject.bar).to eq 'quix'
       end
 
       it "does not be mutable" do
@@ -78,19 +70,15 @@ describe ActiveFedora::SolrInstanceLoader do
       let(:loader) { described_class.new(ActiveFedora::Base, obj.id) }
 
       it "finds the document in solr" do
-        expect_any_instance_of(ActiveFedora::Datastream).to_not receive(:retrieve_content)
+        expect_any_instance_of(ActiveFedora::File).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
 

data/spec/integration/versionable_spec.rb

@@ -124,15 +124,6 @@ describe ActiveFedora::Versionable do
         end
       end
     end
-
-    describe ".has_many_versions" do
-      it "has a warning" do
-        expect(Deprecation).to receive(:warn)
-        class WithVersions < ActiveFedora::Base
-          has_many_versions
-        end
-      end
-    end
   end
 
   describe ActiveFedora::NtriplesRDFDatastream do

data/spec/samples/models/mods_article.rb

@@ -5,10 +5,5 @@ require_relative '../hydra-mods_article_datastream.rb'
 #
 # See lib/samples/sample_thing.rb for a fuller, annotated example of an ActiveFedora Model
 class ModsArticle < ActiveFedora::Base
-  # Mute deprecation of has_metadata
-  @original_behavior = Deprecation.default_deprecation_behavior
-  Deprecation.default_deprecation_behavior = :silence
-  has_metadata name: "descMetadata", type: Hydra::ModsArticleDatastream
-  has_metadata name: "properties", type: ActiveFedora::SimpleDatastream
-  Deprecation.default_deprecation_behavior = @original_behavior
+  has_subresource "descMetadata", class_name: 'Hydra::ModsArticleDatastream'
 end

data/spec/spec_helper.rb

@@ -35,9 +35,6 @@ def restore_spec_configuration
 end
 restore_spec_configuration
 
-# Shut those Rails deprecation warnings up
-ActiveSupport::Deprecation.behavior = proc { |_message, _callstack| }
-
 require 'active_fedora/cleaner'
 RSpec.configure do |config|
   # Stub out test stuff.

data/spec/unit/attached_files_spec.rb

@@ -35,82 +35,6 @@ describe ActiveFedora::AttachedFiles do
     end
   end
 
-  describe '.has_metadata' do
-    before do
-      class Z < ActiveFedora::File
-      end
-      class FooHistory < ActiveFedora::Base
-        extend Deprecation
-        Deprecation.silence(FooHistory) do
-          has_metadata name: 'dsid', type: ActiveFedora::QualifiedDublinCoreDatastream
-          has_metadata 'complex_ds', autocreate: true, type: 'Z'
-        end
-      end
-    end
-    after do
-      Object.send(:remove_const, :FooHistory)
-      Object.send(:remove_const, :Z)
-    end
-
-    it "has a child_resource_reflection" do
-      expect(FooHistory.child_resource_reflections).to have_key(:dsid)
-    end
-
-    it "has reasonable defaults" do
-      expect(FooHistory.child_resource_reflections[:dsid].options).to include(class_name: 'ActiveFedora::QualifiedDublinCoreDatastream')
-    end
-
-    it "lets you override defaults" do
-      expect(FooHistory.child_resource_reflections[:complex_ds].options).to include(autocreate: true)
-      expect(FooHistory.child_resource_reflections[:complex_ds].class_name).to eq 'Z'
-    end
-
-    it "raises an error if you don't give a type" do
-      expect {
-        Deprecation.silence(FooHistory) do
-          FooHistory.has_metadata "bob"
-        end
-      }.to raise_error ArgumentError,
-                       "You must provide a :type property for the datastream 'bob'"
-    end
-
-    it "raises an error if you don't give a dsid" do
-      expect {
-        Deprecation.silence(FooHistory) do
-          FooHistory.has_metadata type: ActiveFedora::QualifiedDublinCoreDatastream
-        end
-      }.to raise_error ArgumentError,
-                       "You must provide a path name (f.k.a. dsid) for the resource"
-    end
-
-    describe "creates accessors" do
-      subject { FooHistory.new }
-      it "exists on the instance" do
-        expect(subject.dsid).to eq subject.attached_files['dsid']
-      end
-    end
-  end
-
-  describe '.has_file_datastream' do
-    before do
-      class FooHistory < ActiveFedora::Base
-        extend Deprecation
-        Deprecation.silence(FooHistory) do
-          has_file_datastream name: 'dsid'
-          has_file_datastream 'another'
-        end
-      end
-    end
-    after do
-      Object.send(:remove_const, :FooHistory)
-    end
-
-    it "has reasonable defaults" do
-      expect(FooHistory.child_resource_reflections[:dsid].klass).to eq ActiveFedora::File
-      expect(FooHistory.child_resource_reflections[:another].klass).to eq ActiveFedora::File
-    end
-  end
-
   describe "#add_file" do
     before do
       class Bar < ActiveFedora::File; end
@@ -126,24 +50,6 @@ describe ActiveFedora::AttachedFiles do
     end
     let(:container) { FooHistory.new }
 
-    describe "#add_file_datastream" do
-      context "a reflection matches the :dsid property" do
-        it "builds the reflection" do
-          expect(Deprecation).to receive(:warn)
-          container.add_file_datastream('blah', path: 'content')
-          expect(container.content).to be_instance_of Bar
-          expect(container.content.content).to eq 'blah'
-        end
-      end
-    end
-    context "with the deprecated :dsid property" do
-      it "builds the reflection" do
-        expect(Deprecation).to receive(:warn)
-        container.add_file('blah', dsid: 'content')
-        expect(container.content).to be_instance_of Bar
-        expect(container.content.content).to eq 'blah'
-      end
-    end
     context "a reflection matches the :path property" do
       it "builds the reflection" do
         container.add_file('blah', path: 'content')
@@ -152,24 +58,6 @@ describe ActiveFedora::AttachedFiles do
       end
     end
 
-    context "the deprecated 3 args erasure" do
-      it "builds the reflection" do
-        expect(Deprecation).to receive(:warn)
-        container.add_file('blah', 'content', 'name.png')
-        expect(container.content).to be_instance_of Bar
-        expect(container.content.content).to eq 'blah'
-      end
-    end
-
-    context "the deprecated 4 args erasure" do
-      it "builds the reflection" do
-        expect(Deprecation).to receive(:warn)
-        container.add_file('blah', 'content', 'name.png', 'image/png')
-        expect(container.content).to be_instance_of Bar
-        expect(container.content.content).to eq 'blah'
-      end
-    end
-
     context "no reflection matches the :path property" do
       it "creates a singleton reflection and build it" do
         container.add_file('blah', path: 'fizz')
@@ -244,28 +132,42 @@ describe ActiveFedora::AttachedFiles do
   end
 
   describe "#attach_file" do
-    let(:dsid) { 'Abc' }
     let(:file) { ActiveFedora::File.new }
-    before do
-      subject.attach_file(file, dsid)
+
+    it "does not call save on the file" do
+      expect(file).to receive(:save).never
+      subject.attach_file(file, 'part1')
     end
 
-    it "adds the datastream to the object" do
-      expect(subject.attached_files['Abc']).to eq file
+    it "adds the file to the attached_files hash" do
+      expect {
+        subject.attach_file(file, 'part1')
+      }.to change { subject.attached_files.key?(:part1) }.from(false).to(true)
     end
 
-    describe "dynamic accessors" do
-      context "when the file is named with dash" do
-        let(:dsid) { 'eac-cpf' }
-        it "converts dashes to underscores" do
-          expect(subject.eac_cpf).to eq file
-        end
+    context "after attaching the file" do
+      let(:dsid) { 'Abc' }
+      before do
+        subject.attach_file(file, dsid)
       end
 
-      context "when the file is named with underscore" do
-        let(:dsid) { 'foo_bar' }
-        it "preserves the underscore" do
-          expect(subject.foo_bar).to eq file
+      it "adds the datastream to the object" do
+        expect(subject.attached_files['Abc']).to eq file
+      end
+
+      describe "dynamic accessors" do
+        context "when the file is named with dash" do
+          let(:dsid) { 'eac-cpf' }
+          it "converts dashes to underscores" do
+            expect(subject.eac_cpf).to eq file
+          end
+        end
+
+        context "when the file is named with underscore" do
+          let(:dsid) { 'foo_bar' }
+          it "preserves the underscore" do
+            expect(subject.foo_bar).to eq file
+          end
         end
       end
     end

data/spec/unit/attributes_spec.rb

@@ -1,517 +1,85 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  context "with an om datastream" do
+  context "when properties are defined on an object" do
     before :all do
-      class BarStream2 < ActiveFedora::OmDatastream
-        set_terminology do |t|
-          t.root(path: "animals", xmlns: "urn:zoobar")
-          t.waterfowl do
-            t.ducks do
-              t.duck
-            end
-          end
-          t.donkey
-          t.cow
-          t.pig
-          t.horse
-        end
-
-        def self.xml_template
-          Nokogiri::XML::Document.parse '<animals xmlns="urn:zoobar">
-            <waterfowl>
-              <ducks>
-                <duck/>
-              </ducks>
-            </waterfowl>
-            <cow></cow>
-          </animals>'
+      class BarHistory4 < ActiveFedora::Base
+        property :title, predicate: ::RDF::Vocab::DC.title do |index|
+          index.as :symbol
         end
+        property :abstract, predicate: ::RDF::Vocab::DC.abstract, multiple: false
       end
     end
+
     after :all do
-      Object.send(:remove_const, :BarStream2)
+      Object.send(:remove_const, :BarHistory4)
     end
 
-    describe "#property" do
-      context "with an xml property (default cardinality)" do
-        before do
-          class BarHistory4 < ActiveFedora::Base
-            has_subresource 'xmlish', class_name: 'BarStream2'
-            Deprecation.silence(ActiveFedora::Attributes) do
-              property :cow, delegate_to: 'xmlish'
-            end
-          end
-        end
-        after do
-          Object.send(:remove_const, :BarHistory4)
-        end
-
-        let(:obj) { BarHistory4.new }
-
-        before { obj.cow = ['one', 'two'] }
-        describe "the object accessor" do
-          subject { obj.cow }
-          it { is_expected.to eq ['one', 'two'] }
-        end
-
-        describe "the datastream accessor" do
-          subject { obj.xmlish.cow }
-          it { is_expected.to eq ['one', 'two'] }
-        end
-      end
-
-      context "with multiple set to false" do
-        before do
-          class BarHistory4 < ActiveFedora::Base
-            has_subresource 'xmlish', class_name: 'BarStream2'
-            Deprecation.silence(ActiveFedora::Attributes) do
-              property :cow, delegate_to: 'xmlish', multiple: false
-            end
-          end
-        end
-        after do
-          Object.send(:remove_const, :BarHistory4)
-        end
-
-        let(:obj) { BarHistory4.new }
+    let(:obj) { BarHistory4.new(title: ['test1']) }
+    subject { obj }
 
-        before { obj.cow = 'one' }
-        describe "the object accessor" do
-          subject { obj.cow }
-          it { is_expected.to eq 'one' }
+    describe "#attribute_names" do
+      context "on an instance" do
+        it "lists the attributes" do
+          expect(subject.attribute_names).to eq ["title", "abstract"]
         end
       end
 
-      context "when updating and saving a property" do
-        before do
-          class BarHistory4 < ActiveFedora::Base
-            has_subresource 'xmlish', class_name: 'BarStream2'
-            Deprecation.silence(ActiveFedora::Attributes) do
-              property :cow, delegate_to: 'xmlish', multiple: false
-            end
-          end
-        end
-        after do
-          Object.send(:remove_const, :BarHistory4)
-        end
-
-        let(:obj) { BarHistory4.new }
-
-        before do
-          obj.cow = 'two'
-          obj.save
-          obj.attached_files[:xmlish].content
-          obj.cow = 'three'
-          obj.save
-        end
-        describe "the attached datastream" do
-          subject { obj.attached_files[:xmlish].content }
-          it { is_expected.to include '<cow>three</cow>' }
+      context "on a class" do
+        it "lists the attributes" do
+          expect(BarHistory4.attribute_names).to eq ["title", "abstract"]
         end
       end
     end
 
-    describe "first level delegation" do
-      before do
-        class MyDS1 < ActiveFedora::NtriplesRDFDatastream
-          property :animal_id, predicate: ::RDF::Vocab::DC.publisher
-        end
-        class MyDS2 < ActiveFedora::OmDatastream
-          set_terminology do |t|
-            t.root(path: "durh")
-            t.fubar
-          end
-        end
-        class BarHistory2 < ActiveFedora::Base
-          has_subresource 'someData', class_name: 'MyDS1'
-          has_subresource "withText", class_name: 'MyDS2'
-          has_subresource 'xmlish', class_name: 'BarStream2'
-          Deprecation.silence(ActiveFedora::Attributes) do
-            has_attributes :cow, datastream: 'xmlish'                      # for testing the default value of multiple
-            has_attributes :fubar, datastream: 'withText', multiple: true  # test alternate datastream
-            has_attributes :pig, datastream: 'xmlish', multiple: false
-            has_attributes :horse, datastream: 'xmlish', multiple: true
-            has_attributes :duck, datastream: 'xmlish', at: [:waterfowl, :ducks, :duck], multiple: true
-            has_attributes :animal_id, datastream: 'someData', multiple: false
-          end
-
-          property :goose, predicate: ::RDF::URI.new('http://example.com#hasGoose')
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :BarHistory2)
-      end
-
-      subject { BarHistory2.new }
-
-      describe "#attribute_names" do
-        context "on an instance" do
-          it "lists the attributes" do
-            expect(subject.attribute_names).to eq ["cow", "fubar", "pig", "horse", "duck", "animal_id", "goose"]
-          end
-        end
-
-        context "on a class" do
-          it "lists the attributes" do
-            expect(BarHistory2.attribute_names).to eq ["cow", "fubar", "pig", "horse", "duck", "animal_id", "goose"]
-          end
-        end
-      end
-
-      describe "inspect" do
-        it "shows the attributes" do
-          expect(subject.inspect).to eq "#<BarHistory2 id: nil, cow: \"\", fubar: [], pig: nil, horse: [], duck: [\"\"], animal_id: nil, goose: []>"
-        end
-
-        describe "with a id" do
-          before { allow(subject).to receive(:id).and_return('test:123') }
-
-          it "shows a id" do
-            expect(subject.inspect).to eq "#<BarHistory2 id: \"test:123\", cow: \"\", fubar: [], pig: nil, horse: [], duck: [\"\"], animal_id: nil, goose: []>"
-          end
-        end
-
-        describe "with no attributes" do
-          subject { described_class.new }
-          it "shows a id" do
-            expect(subject.inspect).to eq "#<ActiveFedora::Base id: nil>"
-          end
-        end
-
-        describe "with relationships" do
-          before do
-            class BarHistory3 < BarHistory2
-              belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasConstituent, class_name: 'BarHistory2'
-            end
-            subject.library = library
-          end
-
-          let(:library) { BarHistory2.create }
-          subject { BarHistory3.new }
-
-          after do
-            Object.send(:remove_const, :BarHistory3)
-          end
-
-          it "shows the library_id" do
-            expect(subject.inspect).to eq "#<BarHistory3 id: nil, cow: \"\", fubar: [], pig: nil, horse: [], duck: [\"\"], animal_id: nil, goose: [], library_id: \"#{library.id}\">"
-          end
-        end
-      end
-
-      it "reveals the unique properties" do
-        expect(BarHistory2.unique?(:horse)).to be false
-        expect(BarHistory2.unique?(:pig)).to be true
-        expect(BarHistory2.unique?(:cow)).to be true
-      end
-
-      it "saves a delegated property" do
-        subject.fubar = ["Quack"]
-        expect(subject.fubar).to eq ["Quack"]
-        expect(subject.withText.get_values(:fubar).first).to eq 'Quack'
-        subject.cow = "Low"
-        expect(subject.cow).to eq "Low"
-        expect(subject.xmlish.term_values(:cow).first).to eq 'Low'
-
-        subject.pig = "Oink"
-        expect(subject.pig).to eq "Oink"
-      end
-
-      it "allows passing parameters to the delegate accessor" do
-        subject.fubar = ["one", "two"]
-        expect(subject.fubar(1)).to eq ['two']
-      end
-
-      describe "assigning wrong cardinality" do
-        it "does not allow passing a string to a multiple attribute writer" do
-          expect { subject.fubar = "Quack" }.to raise_error ArgumentError
-          expect { subject.fubar = ["Quack"] }.not_to raise_error
-          expect { subject.fubar = nil }.not_to raise_error
-        end
-
-        it "does not allow passing an enumerable to a unique attribute writer" do
-          expect { subject.cow = "Low" }.not_to raise_error
-          expect { subject.cow = ["Low"]
-          }.to raise_error ArgumentError, "You attempted to set the attribute `cow' on `BarHistory2' to an enumerable value. However, this attribute is declared as being singular."
-          expect { subject.cow = nil }.not_to raise_error
-        end
-      end
-
-      it "returns an array if marked as multiple" do
-        subject.horse = ["neigh", "whinny"]
-        expect(subject.horse).to eq ["neigh", "whinny"]
+    describe "#inspect" do
+      it "shows the attributes" do
+        expect(subject.inspect).to eq "#<BarHistory4 id: nil, title: [\"test1\"], abstract: nil>"
       end
 
-      it "is able to delegate deeply into the terminology" do
-        subject.duck = ["Quack", "Peep"]
-        expect(subject.duck).to eq ["Quack", "Peep"]
-      end
+      describe "with a id" do
+        before { allow(subject).to receive(:id).and_return('test:123') }
 
-      context "change tracking" do
-        it "works for delegated attributes" do
-          expect {
-            subject.fubar = ["Meow"]
-          }.to change { subject.fubar_changed? }.from(false).to(true)
-        end
-
-        context "when a change is made to a property" do
-          it "is marked changed" do
-            expect {
-              subject.goose = ["honk!"]
-            }.to change { subject.goose_changed? }.from(false).to(true)
-          end
-        end
-
-        context "when a property is set to the same value" do
-          before do
-            subject.goose = ['honk!', 'Honk']
-            if ActiveModel.version < Gem::Version.new('4.2.0')
-              subject.send(:reset_changes)
-            else
-              subject.send(:clear_changes_information)
-            end
-          end
-
-          it "is not marked changed" do
-            subject.goose = ['honk!', 'Honk']
-            expect(subject.goose_changed?).to be false
-          end
-        end
-      end
-
-      describe "hash getters and setters" do
-        it "accepts symbol keys" do
-          subject[:duck] = ["Cluck", "Gobble"]
-          expect(subject[:duck]).to eq ["Cluck", "Gobble"]
-        end
-
-        it "accepts string keys" do
-          subject['duck'] = ["Cluck", "Gobble"]
-          expect(subject['duck']).to eq ["Cluck", "Gobble"]
-        end
-
-        it "accepts field names with _id that are not associations" do
-          subject['animal_id'] = "lemur"
-          expect(subject['animal_id']).to eq "lemur"
-        end
-
-        it "raises an error on the reader when the field isn't delegated" do
-          expect { subject['donkey'] }.to raise_error ActiveFedora::UnknownAttributeError, "unknown attribute 'donkey' for BarHistory2."
-        end
-
-        it "raises an error on the setter when the field isn't delegated" do
-          expect { subject['donkey'] = "bray" }.to raise_error ActiveFedora::UnknownAttributeError, "unknown attribute 'donkey' for BarHistory2."
+        it "shows a id" do
+          expect(subject.inspect).to eq "#<BarHistory4 id: \"test:123\", title: [\"test1\"], abstract: nil>"
         end
       end
 
-      describe "attributes=" do
-        it "raises an error on an invalid attribute" do
-          expect { subject.attributes = { 'donkey' => "bray" } }.to raise_error ActiveFedora::UnknownAttributeError, "unknown attribute 'donkey' for BarHistory2."
+      describe "with no attributes" do
+        subject { described_class.new }
+        it "shows a id" do
+          expect(subject.inspect).to eq "#<ActiveFedora::Base id: nil>"
         end
       end
 
-      describe "attributes" do
-        let(:vals) { { 'cow' => "moo", 'pig' => 'oink', 'horse' => ['neigh'], "fubar" => [], 'duck' => ['quack'], 'animal_id' => '', 'goose' => [] } }
-        before { subject.attributes = vals }
-        it "returns a hash" do
-          expect(subject.attributes).to eq(vals.merge('id' => nil))
-        end
-      end
-
-      describe '.multiple?', focus: true do
-        it 'returns false if attribute has not been defined as multi-valued' do
-          expect(BarHistory2.multiple?(:pig)).to be false
-        end
-
-        it 'returns true if attribute is a ActiveTriples property' do
-          expect(BarHistory2.multiple?(:goose)).to be true
-        end
-
-        it 'returns true if attribute has been defined as multi-valued' do
-          expect(BarHistory2.multiple?(:horse)).to be true
-        end
-
-        it 'raises an error if the attribute does not exist' do
-          expect { BarHistory2.multiple?(:arbitrary_nonexistent_attribute) }.to raise_error ActiveFedora::UnknownAttributeError, "unknown attribute 'arbitrary_nonexistent_attribute' for BarHistory2."
-        end
-      end
-
-      describe ".datastream_class_for_name" do
-        it "returns the specifed class" do
-          expect(BarHistory2.send(:datastream_class_for_name, 'someData')).to eq MyDS1
-        end
-      end
-    end
-
-    describe "with a superclass" do
-      before :all do
-        class BarHistory2 < ActiveFedora::Base
-          has_subresource 'xmlish', class_name: 'BarStream2'
-          Deprecation.silence(ActiveFedora::Attributes) do
-            has_attributes :donkey, :cow, datastream: 'xmlish', multiple: true
+      describe "with relationships" do
+        before do
+          class BarHistory2 < BarHistory4
+            belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasConstituent, class_name: 'BarHistory4'
           end
+          subject.library = library
         end
-        class BarHistory3 < BarHistory2
-        end
-      end
-
-      after :all do
-        Object.send(:remove_const, :BarHistory3)
-        Object.send(:remove_const, :BarHistory2)
-      end
-
-      subject { BarHistory3.new }
-
-      it "is able to delegate deeply into the terminology" do
-        subject.donkey = ["Bray", "Hee-haw"]
-        expect(subject.donkey).to eq ["Bray", "Hee-haw"]
-      end
-
-      it "is able to track change status" do
-        expect {
-          subject.cow = ["Moo"]
-        }.to change { subject.cow_changed? }.from(false).to(true)
-      end
-    end
-  end
-
-  context "with a RDF datastream" do
-    before :all do
-      class BarRdfDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :title, predicate: ::RDF::Vocab::DC.title
-        property :description, predicate: ::RDF::Vocab::DC.description
-      end
-      class BarHistory4 < ActiveFedora::Base
-        has_subresource 'rdfish', class_name: 'BarRdfDatastream'
-        Deprecation.silence(ActiveFedora::Attributes) do
-          has_attributes :title, datastream: 'rdfish', multiple: true
-          has_attributes :description, datastream: 'rdfish', multiple: false
-        end
-      end
-    end
 
-    after :all do
-      Object.send(:remove_const, :BarHistory4)
-      Object.send(:remove_const, :BarRdfDatastream)
-    end
-
-    subject { BarHistory4.new }
-
-    context "with a multivalued field" do
-      it "is able to track change status" do
-        expect {
-          subject.title = ["Title1", "Title2"]
-        }.to change { subject.title_changed? }.from(false).to(true)
-      end
-    end
+        let(:library) { BarHistory4.create }
+        subject { BarHistory2.new }
 
-    context "with a single-valued field" do
-      it "is able to track change status" do
-        expect {
-          subject.description = "A brief description"
-        }.to change { subject.description_changed? }.from(false).to(true)
-      end
-    end
-  end
-
-  context "without a datastream" do
-    before :all do
-      class BarHistory4 < ActiveFedora::Base
-      end
-    end
-
-    after :all do
-      Object.send(:remove_const, :BarHistory4)
-    end
-
-    subject { BarHistory4 }
-
-    describe "has_attributes" do
-      it "raises an error" do
-        Deprecation.silence(ActiveFedora::Attributes) do
-          expect { subject.has_attributes :title, :description, multiple: true }.to raise_error
-        end
-      end
-    end
-  end
-
-  context "when an unknown datastream is specified" do
-    before :all do
-      class BarHistory4 < ActiveFedora::Base
-        Deprecation.silence(ActiveFedora::Attributes) do
-          has_attributes :description, datastream: 'rdfish', multiple: true
+        after do
+          Object.send(:remove_const, :BarHistory2)
         end
-      end
-    end
 
-    after :all do
-      Object.send(:remove_const, :BarHistory4)
-    end
-
-    subject { BarHistory4.new }
-
-    let(:error_message) { "Undefined file: `rdfish' in property description" }
-
-    it "raises an error on get" do
-      expect { subject.description }.to raise_error(ArgumentError, error_message)
-    end
-
-    it "raises an error on set" do
-      expect { subject.description = ['Neat'] }.to raise_error(ArgumentError, error_message)
-    end
-
-    describe ".datastream_class_for_name" do
-      it "returns the default class" do
-        expect(BarHistory4.send(:datastream_class_for_name, 'content')).to eq ActiveFedora::File
-      end
-    end
-  end
-
-  context "when a datastream is specified as a symbol" do
-    before :all do
-      class BarRdfDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :title, predicate: ::RDF::Vocab::DC.title
-        property :description, predicate: ::RDF::Vocab::DC.description
-      end
-      class BarHistory4 < ActiveFedora::Base
-        has_subresource 'rdfish', class_name: 'BarRdfDatastream'
-        Deprecation.silence(ActiveFedora::Attributes) do
-          has_attributes :description, datastream: :rdfish
+        it "shows the library_id" do
+          expect(subject.inspect).to eq "#<BarHistory2 id: nil, title: [], abstract: nil, library_id: \"#{library.id}\">"
         end
       end
     end
 
-    after :all do
-      Object.send(:remove_const, :BarHistory4)
-      Object.send(:remove_const, :BarRdfDatastream)
-    end
-
-    subject { BarHistory4.new(description: 'test1') }
-
-    it "is able to access the attributes" do
-      expect(subject.description).to eq 'test1'
-    end
-  end
-
-  context "when properties are defined on an object" do
-    before :all do
-      class BarHistory4 < ActiveFedora::Base
-        property :title, predicate: ::RDF::Vocab::DC.title do |index|
-          index.as :symbol
-        end
-        property :abstract, predicate: ::RDF::Vocab::DC.abstract, multiple: false
+    describe "#unique?" do
+      it "reveals the unique properties" do
+        expect(BarHistory4.unique?(:abstract)).to be true
+        expect(BarHistory4.unique?(:title)).to be false
       end
     end
 
-    after :all do
-      Object.send(:remove_const, :BarHistory4)
-    end
-
-    let(:obj) { BarHistory4.new(title: ['test1']) }
-    subject { obj }
-
     describe "accessing attributes" do
       context "using generated methods" do
         it "returns values" do
@@ -550,7 +118,15 @@ describe ActiveFedora::Base do
       end
     end
 
-    context "indexing" do
+    describe 'change tracking' do
+      it "is able to track change status" do
+        expect {
+          subject.abstract = "Moo"
+        }.to change { subject.abstract_changed? }.from(false).to(true)
+      end
+    end
+
+    describe "indexing" do
       let(:solr_doc) { obj.to_solr }
 
       it "indexs the attributes" do