active-fedora 8.7.0 → 9.0.0.beta1

data/spec/unit/base_active_model_spec.rb

@@ -23,7 +23,7 @@ describe ActiveFedora::Base do
       has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText" do |m|
         m.field "fubar", :text
       end
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText2", :label=>"withLabel" do |m|
+      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText2" do |m|
         m.field "fubar", :text
       end 
 
@@ -37,18 +37,18 @@ describe ActiveFedora::Base do
     describe "attributes=" do
       it "should set attributes" do
         @n.attributes = {:fubar=>"baz", :duck=>"Quack"}
-        expect(@n.fubar).to eq("baz")
-        expect(@n.withText.get_values(:fubar).first).to eq('baz')
-        expect(@n.duck).to eq("Quack")
-        expect(@n.xmlish.term_values(:duck).first).to eq('Quack')
+        expect(@n.fubar).to eq "baz"
+        expect(@n.withText.get_values(:fubar).first).to eq 'baz'
+        expect(@n.duck).to eq "Quack"
+        expect(@n.xmlish.term_values(:duck).first).to eq 'Quack'
       end
     end
     describe "update_attributes" do
       it "should set attributes and save " do
         @n.update_attributes(:fubar=>"baz", :duck=>"Quack")
-        @q = BarHistory.find(@n.pid)
-        expect(@q.fubar).to eq("baz")
-        expect(@q.duck).to eq("Quack")
+        @q = BarHistory.find(@n.id)
+        expect(@q.fubar).to eq "baz"
+        expect(@q.duck).to eq "Quack"
       end
       after do
         @n.delete

data/spec/unit/base_datastream_management_spec.rb

@@ -1,33 +1,20 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  
-  before(:each) do
-    @test_object = ActiveFedora::Base.new
-  end
-  
-  describe '.add_datastream' do
-    it "should not call Datastream.save" do
-      ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
+
+  describe '.attach_file' do
+    let(:test_object) { ActiveFedora::Base.new }
+    let(:ds) { ActiveFedora::File.new(@test_object, 'ds_to_add') }
+
+    it "should not call File.save" do
       expect(ds).to receive(:save).never
-      @test_object.add_datastream(ds)
+      test_object.attach_file(ds, 'ds1')
     end
+
     it "should add the datastream to the datastreams_in_memory array" do
-      ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
-      expect(@test_object.datastreams).not_to have_key(ds.dsid)
-      @test_object.add_datastream(ds)
-      expect(@test_object.datastreams).to have_key(ds.dsid)
-    end
-    it "should auto-assign dsids using auto-incremented integers if dsid is nil or an empty string" do 
-      ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil)
-      expect(ds.dsid).to eq('DS1')
-      expect(@test_object.add_datastream(ds)).to eq('DS1')
-      ds_emptystringid = ActiveFedora::Datastream.new(@test_object.inner_object, '')
-      expect(@test_object.add_datastream(ds_emptystringid)).to eq('DS2')
-    end
-    it "should accept a prefix option and apply it to automatically assigned dsids" do
-      ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil, :prefix=> "FOO")
-      expect(ds.dsid).to eq('FOO1')
+      expect(test_object.attached_files).to_not have_key(:ds_to_add)
+      test_object.attach_file(ds, 'ds_to_add')
+      expect(test_object.attached_files).to have_key(:ds_to_add)
     end
   end
 end

data/spec/unit/base_extra_spec.rb

@@ -1,75 +1,38 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  
-  before(:each) do
-    @test_object = ActiveFedora::Base.new
-  end
 
   describe ".update_index" do
     before do
       mock_conn = double("SolrConnection")
       expect(mock_conn).to receive(:add) do |_, opts|
-        expect(opts).to eq({:params=>{:softCommit=>true}})
+        expect(opts).to eq(:params=>{:softCommit=>true})
       end
       mock_ss = double("SolrService")
       allow(mock_ss).to receive(:conn).and_return(mock_conn)
       allow(ActiveFedora::SolrService).to receive(:instance).and_return(mock_ss)
     end
-    
-    it "should call .to_solr on all SimpleDatastreams AND RelsExtDatastreams and pass the resulting document to solr" do
-      # Actually uses self.to_solr internally to gather solr info from all metadata datastreams
-      mock1 = double("ds1", :to_solr => {})
-      mock2 = double("ds2", :to_solr => {})
-      mock3 = double("RELS-EXT", :to_solr => {})
-      
-      mock_datastreams = {:ds1 => mock1, :ds2 => mock2, :rels_ext => mock3}
-      expect(mock1).to receive(:solrize_profile).and_return({})
-      expect(mock2).to receive(:solrize_profile).and_return({})
-      expect(mock3).to receive(:solrize_profile).and_return({})
-      expect(@test_object).to receive(:datastreams).twice.and_return(mock_datastreams)
-      expect(@test_object).to receive(:solrize_relationships)
-      @test_object.update_index
-    end
 
-    it "should call .to_solr on all RDFDatastreams and pass the resulting document to solr" do
-      # Actually uses self.to_solr internally to gather solr info from all metadata datastreams
-      mock1 = double("ds1", :to_solr => {})
-      mock2 = double("ds2", :to_solr => {})
-      mock3 = double("RELS-EXT", :to_solr => {})
-      
-      mock_datastreams = {:ds1 => mock1, :ds2 => mock2, :rels_ext => mock3}
-      expect(mock1).to receive(:solrize_profile).and_return({})
-      expect(mock2).to receive(:solrize_profile).and_return({})
-      expect(mock3).to receive(:solrize_profile).and_return({})
-      expect(@test_object).to receive(:datastreams).twice.and_return(mock_datastreams)
-      expect(@test_object).to receive(:solrize_relationships)
-      @test_object.update_index
-    end
-
-    it "should retrieve a solr Connection and call Connection.add" do
-      @test_object.update_index
+    it "should make the solr_document with to_solr and add it" do
+      expect(subject).to receive(:to_solr)
+      subject.update_index
     end
 
   end
-  
+
   describe ".delete" do
-    
-    before(:each) do
+
+    before do
+      allow(subject).to receive(:new_record?).and_return(false)
+      allow(ActiveFedora.fedora.connection).to receive(:delete)
     end
-    
+
     it "should delete object from repository and index" do
-      allow(@test_object.inner_object).to receive(:delete)
-      mock_conn = double("SolrConnection")
-      expect(mock_conn).to receive(:delete_by_id).with(nil, {:params=>{"softCommit"=>true}}) 
-      mock_ss = double("SolrService")
-      allow(mock_ss).to receive(:conn).and_return(mock_conn)
-      allow(ActiveFedora::SolrService).to receive(:instance).and_return(mock_ss)
-      @test_object.delete
+      expect(ActiveFedora::SolrService).to receive(:delete).with(nil)
+      subject.delete
     end
-
   end
-  
+
   describe "to_class_uri" do
     before :all do
       module SpecModel
@@ -77,25 +40,12 @@ describe ActiveFedora::Base do
         end
       end
     end
-    
+
     after :all do
       SpecModel.send(:remove_const, :CamelCased)
     end
-    subject {SpecModel::CamelCased}
-    
-    its(:to_class_uri) {should == 'info:fedora/afmodel:SpecModel_CamelCased' }
-  
-    context "with the namespace declared in the model" do
-      before do
-        allow(subject).to receive(:pid_namespace).and_return("test-cModel")
-      end
-      its(:to_class_uri) {should == 'info:fedora/test-cModel:SpecModel_CamelCased' }
-    end
-    context "with the suffix declared in the model" do
-      before do
-        allow(subject).to receive(:pid_suffix).and_return("-TEST-SUFFIX")
-      end
-      its(:to_class_uri) {should == 'info:fedora/afmodel:SpecModel_CamelCased-TEST-SUFFIX' }
-    end
+    subject {SpecModel::CamelCased.to_class_uri}
+
+    it { should == 'SpecModel::CamelCased' }
   end
 end

data/spec/unit/base_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-@@last_pid = 0
+@@last_id = 0
 
 describe ActiveFedora::Base do
   it_behaves_like "An ActiveModel"
@@ -10,130 +10,66 @@ describe ActiveFedora::Base do
     end
   end
 
-  describe "sharding" do
-    it "should have a shard_index" do
-      expect(ActiveFedora::Base.shard_index(@this_pid)).to eq(0)
+  describe "reindex_everything" do
+    it "should call update_index on every object represented in the sitemap" do
+      allow(ActiveFedora::Base).to receive(:get_descendent_uris) { ['http://localhost/test/XXX', 'http://localhost/test/YYY', 'http://localhost/test/ZZZ'] }
+      mock_update = double(:mock_obj)
+      expect(mock_update).to receive(:update_index).exactly(3).times
+      expect(ActiveFedora::Base).to receive(:find).with(instance_of ActiveFedora::LdpResource ).and_return(mock_update).exactly(3).times
+      ActiveFedora::Base.reindex_everything
     end
+  end
 
-    context "When the repository is NOT sharded" do
-      subject {ActiveFedora::Base.connection_for_pid('test:bar')}
-      before(:each) do
-        allow(ActiveFedora.config).to receive(:sharded?).and_return(false)
-        ActiveFedora::Base.fedora_connection = {}
-        allow(ActiveFedora.config).to receive(:credentials).and_return(:url=>'myfedora')
-        allow_any_instance_of(Rubydora::Fc3Service).to receive(:repository_profile)
-      end
-      it { is_expected.to be_kind_of Rubydora::Repository}
-      it "should be the standard connection" do
-        expect(subject.client.url).to eq('myfedora')
-      end
-      describe "assign_pid" do
-        it "should use fedora to generate pids" do
-          # TODO: This juggling of Fedora credentials & establishing connections should be handled by an establish_fedora_connection method,
-          # possibly wrap it all into a fedora_connection method - MZ 06-05-2012
-          stubfedora = double("Fedora")
-          expect(stubfedora).to receive(:connection).and_return(double("Connection", :mint =>"sample:newpid"))
-          # Should use ActiveFedora.config.credentials as a single hash rather than an array of shards
-          expect(ActiveFedora::RubydoraConnection).to receive(:new).with(ActiveFedora.config.credentials).and_return(stubfedora)
-          ActiveFedora::Base.assign_pid(ActiveFedora::Base.new.inner_object)
-        end
-      end
-      describe "shard_index" do
-        it "should always return zero (the first and only connection)" do
-          expect(ActiveFedora::Base.shard_index('test:bar')).to eq(0)
-        end
+  describe "get_descendent_uris" do
+
+    before :each do
+      ids.each do |id|
+        ActiveFedora::Base.create id: id
       end
     end
-    context "When the repository is sharded" do
-      before :each do
-        allow(ActiveFedora.config).to receive(:sharded?).and_return(true)
-        ActiveFedora::Base.fedora_connection = {}
-        allow(ActiveFedora.config).to receive(:credentials).and_return([{:url=>'shard1'}, {:url=>'shard2'} ])
-      end
-      describe "assign_pid" do
-        it "should always use the first shard to generate pids" do
-          stubhard1 = double("Shard")
-          stubhard2 = double("Shard")
-          expect(stubhard1).to receive(:connection).and_return(double("Connection", :mint =>"sample:newpid"))
-          expect(stubhard2).to receive(:connection).never
-          ActiveFedora::Base.fedora_connection = {0 => stubhard1, 1 => stubhard2}
-          ActiveFedora::Base.assign_pid(ActiveFedora::Base.new.inner_object)
-        end
-      end
-      describe "shard_index" do
-        it "should use modulo of md5 of the pid to distribute objects across shards" do
-          expect(ActiveFedora::Base.shard_index('test:bar')).to eq(0)
-          expect(ActiveFedora::Base.shard_index('test:nanana')).to eq(1)
-        end
-      end
-      describe "the repository" do
-        before do
-          allow_any_instance_of(Rubydora::Fc3Service).to receive(:repository_profile)
-        end
-        describe "for test:bar" do
-          subject {ActiveFedora::Base.connection_for_pid('test:bar')}
-          it "should be shard1" do
-            expect(subject.client.url).to eq('shard1')
-          end
-        end
-        describe "for test:baz" do
-          subject {ActiveFedora::Base.connection_for_pid('test:nanana')}
-          it "should be shard1" do
-            expect(subject.client.url).to eq('shard2')
-          end
-        end
-      end
+
+    def root_uri(ids=[])
+      ActiveFedora::Base.id_to_uri(ids.first)
     end
 
-  end
+    context 'when there there are no descendents' do
 
-  describe "reindex_everything" do
-    it "should call update_index on every object except for the fedora-system objects" do
-       expect_any_instance_of(Rubydora::Repository).to receive(:search).
-            and_yield(double(pid:'XXX')).and_yield(double(pid:'YYY')).and_yield(double(pid:'ZZZ')).
-            and_yield(double(pid:'fedora-system:ServiceDeployment-3.0')).
-            and_yield(double(pid:'fedora-system:ServiceDefinition-3.0')).
-            and_yield(double(pid:'fedora-system:FedoraObject-3.0'))
-
-       mock_update = double(:mock_obj)
-       expect(mock_update).to receive(:update_index).exactly(3).times
-       expect(ActiveFedora::Base).to receive(:find).with('XXX').and_return(mock_update)
-       expect(ActiveFedora::Base).to receive(:find).with('YYY').and_return(mock_update)
-       expect(ActiveFedora::Base).to receive(:find).with('ZZZ').and_return(mock_update)
-       ActiveFedora::Base.reindex_everything
+      let(:ids) { ['foo'] }
+
+      it 'returns an array containing only the URI passed to it' do
+        expect(ActiveFedora::Base.get_descendent_uris(root_uri(ids))).to eq ids.map {|id| ActiveFedora::Base.id_to_uri(id) }
+      end
     end
 
-    it "should accept a query param for the search" do
-       query_string = "pid~*"
-       expect_any_instance_of(Rubydora::Repository).to receive(:search).with(query_string).
-            and_yield(double(pid:'XXX')).and_yield(double(pid:'YYY')).and_yield(double(pid:'ZZZ'))
-       mock_update = double(:mock_obj)
-       expect(mock_update).to receive(:update_index).exactly(3).times
-       expect(ActiveFedora::Base).to receive(:find).with('XXX').and_return(mock_update)
-       expect(ActiveFedora::Base).to receive(:find).with('YYY').and_return(mock_update)
-       expect(ActiveFedora::Base).to receive(:find).with('ZZZ').and_return(mock_update)
-       ActiveFedora::Base.reindex_everything(query_string)
+    context 'when there are > 1 descendents' do
+
+      let(:ids) { ['foo', 'foo/bar', 'foo/bar/chu'] }
+
+      it 'returns an array containing the URI passed to it, as well as all descendent URIs' do
+        expect(ActiveFedora::Base.get_descendent_uris(root_uri(ids))).to eq ids.map {|id| ActiveFedora::Base.id_to_uri(id) }
+      end
     end
   end
 
   describe "With a test class" do
-    before :all do
+    before :each do
       class FooHistory < ActiveFedora::Base
-        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData", :autocreate => true do |m|
+        has_metadata 'someData', type: ActiveFedora::SimpleDatastream, autocreate: true do |m|
           m.field "fubar", :string
           m.field "swank", :text
         end
-        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText", :autocreate => true do |m|
+        has_metadata "withText", type: ActiveFedora::SimpleDatastream, autocreate: true do |m|
           m.field "fubar", :text
         end
-        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText2", :label=>"withLabel", :autocreate => true do |m|
+        has_metadata "withText2", type: ActiveFedora::SimpleDatastream, autocreate: true do |m|
           m.field "fubar", :text
         end
         has_attributes :fubar, datastream: 'withText', multiple: true
         has_attributes :swank, datastream: 'someData', multiple: true
       end
+
       class FooAdaptation < ActiveFedora::Base
-        has_metadata :type=>ActiveFedora::OmDatastream, :name=>'someData'
+        has_metadata 'someData', type: ActiveFedora::OmDatastream
       end
 
       class FooInherited < FooHistory
@@ -141,120 +77,98 @@ describe ActiveFedora::Base do
       end
     end
 
-    after :all do
+    after :each do
       Object.send(:remove_const, :FooHistory)
       Object.send(:remove_const, :FooAdaptation)
       Object.send(:remove_const, :FooInherited)
     end
 
-    def increment_pid
-      @@last_pid += 1
+    def increment_id
+      @@last_id += 1
     end
 
-    before(:each) do
-      @this_pid = increment_pid.to_s
-      stub_get(@this_pid)
-      allow_any_instance_of(Rubydora::Repository).to receive(:client).and_return(@mock_client)
-      allow(ActiveFedora::Base).to receive(:assign_pid).and_return(@this_pid)
-
+    before do
+      @this_id = increment_id.to_s
       @test_object = ActiveFedora::Base.new
-    end
-
-    after(:each) do
-      begin
-      allow(ActiveFedora::SolrService).to receive(:instance)
-      #@test_object.delete
-      rescue
-      end
+      allow(@test_object).to receive(:assign_id).and_return(@this_id)
     end
 
 
     describe '#new' do
-      it "should create an inner object" do
-        # for doing AFObject.new(params[:foo]) when nothing is in params[:foo]
-        expect_any_instance_of(Rubydora::DigitalObject).to receive(:save).never
-        result = ActiveFedora::Base.new(nil)
-        expect(result.inner_object).to be_kind_of(ActiveFedora::UnsavedDigitalObject)
+      before do
+        allow_any_instance_of(FooHistory).to receive(:assign_id).and_return(@this_id)
+      end
+      context "with no arguments" do
+        it "should not get an id on init" do
+          expect(FooHistory.new.id).to be_nil
+        end
       end
 
-      it "should not save or get an pid on init" do
-        expect_any_instance_of(Rubydora::DigitalObject).to receive(:save).never
-        expect(ActiveFedora::Base).to receive(:assign_pid).never
-        f = FooHistory.new
+      context "with an id argument" do
+        it "should be able to create with a custom id" do
+          expect(FooHistory).to receive(:id_to_uri).and_call_original
+          f = FooHistory.new('baz_1')
+          expect(f.id).to eq 'baz_1'
+          expect(f.id).to eq 'baz_1'
+        end
       end
 
-      it "should be able to create with a custom pid" do
-        f = FooHistory.new(:pid=>'numbnuts:1')
-        expect(f.pid).to eq('numbnuts:1')
+      context "with a hash argument" do
+        context "that has an id" do
+          it "should be able to create with a custom id" do
+            expect(FooHistory).to receive(:id_to_uri).and_call_original
+            f = FooHistory.new(id: 'baz_1')
+            expect(f.id).to eq 'baz_1'
+            expect(f.id).to eq 'baz_1'
+          end
+        end
+
+        context "that doesn't have an id" do
+          it "should be able to create with a custom id" do
+            f = FooHistory.new(fubar: ['baz_1'])
+            expect(f.id).to be_nil
+          end
+        end
       end
     end
 
-    describe ".datastream_class_for_name" do
-      it "should return the specifed class" do
-        expect(FooAdaptation.datastream_class_for_name('someData')).to eq(ActiveFedora::OmDatastream)
+    ### Methods for ActiveModel::Conversions
+    context "before saving" do
+      context "#to_param" do
+        subject { @test_object.to_param }
+        it { should be_nil }
       end
-      it "should return the specifed class" do
-        expect(FooAdaptation.datastream_class_for_name('content')).to eq(ActiveFedora::Datastream)
+      context "#to_key" do
+        subject { @test_object.to_key }
+        it { should be_nil }
       end
     end
 
-    describe ".internal_uri" do
-      it "should return pid as fedors uri" do
-        expect(@test_object.internal_uri).to eql("info:fedora/#{@test_object.pid}")
+    context "when its saved" do
+      before do
+        allow(@test_object).to receive(:new_record?).and_return(false)
+        allow(@test_object).to receive(:uri).and_return('http://localhost:8983/fedora/rest/test/one/two/three')
       end
-    end
 
-    ### Methods for ActiveModel::Conversions
-    it "should have to_param once it's saved" do
-      expect(@test_object.to_param).to be_nil
-      allow(@test_object.inner_object).to receive_messages(new_record?: false, pid: 'foo:123')
-      expect(@test_object.to_param).to eq('foo:123')
-    end
-
-    it "should have to_key once it's saved" do
-      expect(@test_object.to_key).to be_nil
-      allow(@test_object.inner_object).to receive_messages(new_record?: false, pid: 'foo:123')
-      expect(@test_object.to_key).to eq(['foo:123'])
-    end
+      context "#to_param" do
+        subject { @test_object.to_param }
+        it { should eq 'one/two/three' }
+      end
 
-    it "should have to_model when it's saved" do
-      expect(@test_object.to_model).to be @test_object
+      context "#to_key" do
+        subject { @test_object.to_key }
+        it { should eq ['one/two/three'] }
+      end
     end
     ### end ActiveModel::Conversions
 
     ### Methods for ActiveModel::Naming
     it "Should know the model_name" do
-      expect(FooHistory.model_name).to eq('FooHistory')
-      expect(FooHistory.model_name.human).to eq('Foo history')
+      expect(FooHistory.model_name).to eq 'FooHistory'
+      expect(FooHistory.model_name.human).to eq 'Foo history'
     end
     ### End ActiveModel::Naming
 
-
-    describe ".datastreams" do
-      let(:test_history) { FooHistory.new }
-      it "should create accessors for datastreams declared with has_metadata" do
-        expect(test_history.withText).to eq(test_history.datastreams['withText'])
-      end
-      describe "dynamic accessors" do
-        before do
-          test_history.add_datastream(ds)
-          test_history.class.build_datastream_accessor(ds.dsid)
-        end
-        describe "when the datastream is named with dash" do
-          let(:ds) {double('datastream', :dsid=>'eac-cpf')}
-          it "should convert dashes to underscores" do
-            expect(test_history.eac_cpf).to eq(ds)
-          end
-        end
-        describe "when the datastream is named with underscore" do
-          let (:ds) { double('datastream', :dsid=>'foo_bar') }
-          it "should preserve the underscore" do
-            expect(test_history.foo_bar).to eq(ds)
-          end
-        end
-      end
-    end
-
     it 'should provide #find' do
       expect(ActiveFedora::Base).to respond_to(:find)
     end
@@ -267,116 +181,67 @@ describe ActiveFedora::Base do
       expect(@test_object).to respond_to(:modified_date)
     end
 
-    it 'should respond to .rels_ext' do
-      expect(@test_object).to respond_to(:rels_ext)
-    end
-
-    describe '.rels_ext' do
-
-      it 'should return the RelsExtDatastream object from the datastreams array' do
-        allow(@test_object).to receive_messages(:datastreams => {"RELS-EXT" => "foo"})
-        expect(@test_object.rels_ext).to eq("foo")
-      end
-    end
-
-    it 'should provide #add_relationship' do
-      expect(@test_object).to respond_to(:add_relationship)
-    end
-
-    describe '#add_relationship' do
-      it 'should call #add_relationship on the rels_ext datastream' do
-        @test_object.add_relationship("predicate", "info:fedora/object")
-        pred = ActiveFedora::Predicates.vocabularies["info:fedora/fedora-system:def/relations-external#"]["predicate"]
-        expect(@test_object.relationships).to have_statement(RDF::Statement.new(RDF::URI.new(@test_object.internal_uri), pred, RDF::URI.new("info:fedora/object")))
-      end
-
-      it "should update the RELS-EXT datastream and set the datastream as dirty when relationships are added" do
-        mock_ds = double("Rels-Ext")
-        allow(mock_ds).to receive(:content_will_change!)
-        @test_object.datastreams["RELS-EXT"] = mock_ds
-        @test_object.add_relationship(:is_member_of, "info:fedora/demo:5")
-        @test_object.add_relationship(:is_member_of, "info:fedora/demo:10")
-      end
-
-      it 'should add a relationship to an object only if it does not exist already' do
-        next_pid = increment_pid.to_s
-        allow(ActiveFedora::Base).to receive(:assign_pid).and_return(next_pid)
-        stub_get(next_pid)
-
-        @test_object3 = ActiveFedora::Base.new
-        @test_object.add_relationship(:has_part,@test_object3)
-        expect(@test_object.ids_for_outbound(:has_part)).to eq([@test_object3.pid])
-        #try adding again and make sure not there twice
-        @test_object.add_relationship(:has_part,@test_object3)
-        expect(@test_object.ids_for_outbound(:has_part)).to eq([@test_object3.pid])
-      end
-
-      it 'should add literal relationships if requested' do
-        @test_object.add_relationship(:conforms_to,"AnInterface",true)
-        expect(@test_object.ids_for_outbound(:conforms_to)).to eq(["AnInterface"])
-      end
-    end
-
-    it 'should provide #remove_relationship' do
-      expect(@test_object).to respond_to(:remove_relationship)
-    end
-
-    describe '#remove_relationship' do
-      it 'should remove a relationship from the relationships hash' do
-        @test_object3 = ActiveFedora::Base.new()
-        allow(@test_object3).to receive_messages(:pid=>'7')
-        @test_object4 = ActiveFedora::Base.new()
-        allow(@test_object4).to receive_messages(:pid=>'8')
-        @test_object.add_relationship(:has_part,@test_object3)
-        @test_object.add_relationship(:has_part,@test_object4)
-        #check both are there
-        expect(@test_object.ids_for_outbound(:has_part)).to eq([@test_object3.pid,@test_object4.pid])
-        @test_object.remove_relationship(:has_part,@test_object3)
-        #check only one item removed
-        expect(@test_object.ids_for_outbound(:has_part)).to eq([@test_object4.pid])
-        @test_object.remove_relationship(:has_part,@test_object4)
-        #check last item removed and predicate removed since now emtpy
-        expect(@test_object.relationships.size).to eq(0)
+    describe '.save' do
+      it "should create a new record" do
+        allow(@test_object).to receive(:new_record?).and_return(true)
+        expect(@test_object).to receive(:serialize_attached_files)
+        expect(@test_object).to receive(:assign_rdf_subject)
+        expect(@test_object.ldp_source).to receive(:create)
+        expect(@test_object).to receive(:refresh)
+        expect(@test_object).to receive(:update_index)
+        @test_object.save
       end
-    end
 
-    it 'should provide #relationships' do
-      expect(@test_object).to respond_to(:relationships)
-    end
+      context "on an existing record" do
 
-    describe '#relationships' do
-      it 'should return a graph' do
-        expect(@test_object.relationships.kind_of?(RDF::Graph)).to be_truthy
-        expect(@test_object.relationships.size).to eq(0)
+        it "should update" do
+          allow(@test_object).to receive(:new_record?).and_return(false)
+          expect(@test_object).to receive(:serialize_attached_files)
+          allow_any_instance_of(Ldp::Orm).to receive(:save) { true }
+          expect(@test_object).to receive(:refresh)
+          expect(@test_object).to receive(:update_index)
+          @test_object.save
+        end
       end
-    end
 
-    describe '.assert_content_model' do
-      it "should default to the name of the class" do
-        stub_get(@this_pid)
-        stub_add_ds(@this_pid, ['RELS-EXT'])
-        @test_object.assert_content_model
-        expect(@test_object.relationships(:has_model)).to eq(["info:fedora/afmodel:ActiveFedora_Base"])
+      context "when assign id returns a value" do
+        context "an no id has been set" do
 
-      end
-    end
+          it "should set the id" do
+            @test_object.save
+            expect(@test_object.id).to eq @this_id
+          end
 
-    describe '.save' do
-      it "should create a new record" do
-        allow(@test_object).to receive_messages(:new_record? => true)
-        expect(@test_object).to receive(:assign_pid)
-        expect(@test_object).to receive(:serialize_datastreams)
-        expect(@test_object.inner_object).to receive(:save)
-        expect(@test_object).to receive(:update_index)
-        @test_object.save
-      end
+          context "and the object has properties" do
+            let(:test_object) { WithProperty.new(title: 'foo') }
+            before do
+              class WithProperty < ActiveFedora::Base
+                property :title, predicate: ::RDF::DC.title
+              end
+              allow(test_object).to receive(:assign_id).and_return(@this_id)
+              test_object.save
+            end
+            after do
+              Object.send(:remove_const, :WithProperty)
+            end
+
+            it "should update the resource" do
+              expect(test_object.resource.rdf_subject).to eq ::RDF::URI.new("#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/#{@this_id}")
+              expect(test_object.title).to eq ['foo']
+            end
+          end
+        end
 
-      it "should update an existing record" do
-        allow(@test_object).to receive_messages(:new_record? => false)
-        expect(@test_object).to receive(:serialize_datastreams)
-        expect(@test_object.inner_object).to receive(:save)
-        expect(@test_object).to receive(:update_index)
-        @test_object.save
+        context "when an id is set" do
+          before do
+            @test_object = ActiveFedora::Base.new(id: '999')
+            allow(@test_object).to receive(:assign_id).and_return(@this_id)
+          end
+          it "should not set the id" do
+            @test_object.save
+            expect(@test_object.id).to eq '999'
+          end
+        end
       end
     end
 
@@ -385,155 +250,43 @@ describe ActiveFedora::Base do
         obj = double()
         expect(obj).to receive(:save)
         expect(FooHistory).to receive(:new).and_return(obj)
-        @hist = FooHistory.create(:fubar=>'ta', :swank=>'da')
-      end
-
-    end
-
-    describe ".adapt_to" do
-      it "should return an adapted object of the requested type" do
-        @test_object = FooHistory.new()
-        expect(@test_object.adapt_to(FooAdaptation).class).to eq(FooAdaptation)
-      end
-      it "should not make an additional call to fedora to create the adapted object" do
-        @test_object = FooHistory.new()
-        adapted = @test_object.adapt_to(FooAdaptation)
-      end
-      it "should propagate new datastreams to the adapted object" do
-        @test_object = FooHistory.new()
-        @test_object.add_file_datastream("XXX", :dsid=>'MY_DSID')
-        adapted = @test_object.adapt_to(FooAdaptation)
-        expect(adapted.datastreams.keys).to include 'MY_DSID'
-        expect(adapted.datastreams['MY_DSID'].content).to eq("XXX")
-        expect(adapted.datastreams['MY_DSID'].changed?).to be_truthy
-      end
-      it "should propagate modified datastreams to the adapted object" do
-        @test_object = FooHistory.new()
-        orig_ds = @test_object.datastreams['someData']
-        orig_ds.content="<YYY/>"
-        adapted = @test_object.adapt_to(FooAdaptation)
-        expect(adapted.datastreams.keys).to include 'someData'
-        expect(adapted.datastreams['someData']).to eq(orig_ds)
-        expect(adapted.datastreams['someData'].content.strip).to eq("<YYY/>")
-        expect(adapted.datastreams['someData'].changed?).to be_truthy
-      end
-      it "should use the datastream definitions from the adapted object" do
-        @test_object = FooHistory.new()
-        adapted = @test_object.adapt_to(FooAdaptation)
-        expect(adapted.datastreams.keys).to include 'someData'
-        expect(adapted.datastreams['someData'].class).to eq(ActiveFedora::OmDatastream)
-      end
-    end
-
-    describe ".adapt_to_cmodel with implemented (non-ActiveFedora::Base) cmodel" do
-      subject { FooHistory.new }
-
-      it "should raise an exception if the object class is not equal to or a subclass of any known model" do
-        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooAdaptation])
-        expect { subject.adapt_to_cmodel }.to raise_error(ActiveFedora::ModelNotAsserted)
+        @hist = FooHistory.create(fubar: 'ta', swank: 'da')
       end
-      it "should cast to an inherited model over a random one" do
-        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooAdaptation, FooInherited])
-        expect(subject.adapt_to_cmodel).to be_kind_of FooInherited
-      end
-      it "should not cast when a cmodel is same as the class" do
-        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooHistory])
-        expect(subject.adapt_to_cmodel).to be === subject
-      end
-    end
-
-    describe ".adapt_to_cmodel with ActiveFedora::Base" do
-      subject { ActiveFedora::Base.new }
-
-      it "should cast to the first cmodel if ActiveFedora::Base (or no specified cmodel)" do
-        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooAdaptation, FooHistory])
-        expect(subject.adapt_to_cmodel).to be_kind_of FooAdaptation
-      end
-    end
-
-    describe '#has_model' do
-      subject { FooHistory.new.has_model }
-      it { is_expected.to eq 'FooHistory' }
     end
 
-    describe '#to_solr' do
+    describe ".to_solr" do
       it "should provide .to_solr" do
         expect(@test_object).to respond_to(:to_solr)
       end
 
-      it "should add pid, system_create_date, system_modified_date and object_state from object attributes" do
-        expect(@test_object).to receive(:create_date).and_return("2012-03-04T03:12:02Z")
-        expect(@test_object).to receive(:modified_date).and_return("2012-03-07T03:12:02Z")
-        allow(@test_object).to receive_messages(pid: 'changeme:123')
-        @test_object.state = "D"
+      it "should add id, system_create_date, system_modified_date from object attributes" do
+        expect(@test_object).to receive(:create_date).and_return(DateTime.parse("2012-03-04T03:12:02Z")).twice
+        expect(@test_object).to receive(:modified_date).and_return(DateTime.parse("2012-03-07T03:12:02Z")).twice
+        allow(@test_object).to receive(:id).and_return('changeme:123')
         solr_doc = @test_object.to_solr
         expect(solr_doc[ActiveFedora::SolrService.solr_name("system_create", :stored_sortable, type: :date)]).to eql("2012-03-04T03:12:02Z")
         expect(solr_doc[ActiveFedora::SolrService.solr_name("system_modified", :stored_sortable, type: :date)]).to eql("2012-03-07T03:12:02Z")
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("object_state", :stored_sortable)]).to eql("D")
         expect(solr_doc[:id]).to eql("changeme:123")
       end
 
-      it "should omit base metadata and RELS-EXT if :model_only==true" do
-        @test_object.add_relationship(:has_part, "foo", true)
-        solr_doc = @test_object.to_solr(Hash.new, :model_only => true)
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("system_create", type: :date)]).to be_nil
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("system_modified", type: :date)]).to be_nil
-        expect(solr_doc["id"]).to be_nil
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("has_part", :symbol)]).to be_nil
-      end
-
-      it "adds has_model as the :active_fedora_model" do
-        stub_get(@this_pid)
-        stub_get_content(@this_pid, ['RELS-EXT', 'someData', 'withText2', 'withText'])
-        solr_doc = FooHistory.new.to_solr
+      it "should add self.class as the :active_fedora_model" do
+        @test_history = FooHistory.new()
+        solr_doc = @test_history.to_solr
         expect(solr_doc[ActiveFedora::SolrService.solr_name("active_fedora_model", :stored_sortable)]).to eql("FooHistory")
       end
 
-      it "should call .to_solr on all SimpleDatastreams and OmDatastreams, passing the resulting document to solr" do
-        mock1 = double("ds1", :to_solr => {})
-        mock2 = double("ds2", :to_solr => {})
-        ngds = double("ngds", :to_solr => {})
-        expect(ngds).to receive(:solrize_profile)
-        expect(mock1).to receive(:solrize_profile)
-        expect(mock2).to receive(:solrize_profile)
-
-        expect(@test_object).to receive(:datastreams).twice.and_return({:ds1 => mock1, :ds2 => mock2, :ngds => ngds})
-        expect(@test_object).to receive(:solrize_relationships)
-        @test_object.to_solr
-      end
-      it "should call .to_solr on all RDFDatastreams, passing the resulting document to solr" do
-        mock = double("ds1", :to_solr => {})
-        expect(mock).to receive(:solrize_profile)
+      it "should call .to_solr on all datastreams, passing the resulting document to solr" do
+        mock1 = double("ds1")
+        expect(mock1).to receive(:to_solr).and_return({})
+        mock2 = double("ds2")
+        expect(mock2).to receive(:to_solr).and_return({})
 
-        expect(@test_object).to receive(:datastreams).twice.and_return({:ds1 => mock})
-        expect(@test_object).to receive(:solrize_relationships)
+        allow(@test_object).to receive(:attached_files).and_return(ds1: mock1, ds2: mock2)
+        expect(@test_object.indexing_service).to receive(:solrize_relationships)
         @test_object.to_solr
       end
-
-      it "should call .to_solr on the relationships rels-ext is dirty" do
-        @test_object.add_relationship(:has_collection_member, "info:fedora/test:member")
-        rels_ext = @test_object.rels_ext
-        expect(rels_ext).to be_changed
-        expect(@test_object).to receive(:solrize_relationships)
-        @test_object.to_solr
-      end
-
     end
 
-    describe ".label" do
-      it "should return the label of the inner object" do
-        expect(@test_object.inner_object).to receive(:label).and_return("foo label")
-        expect(@test_object.label).to eq("foo label")
-      end
-    end
-
-    describe ".label=" do
-      it "should set the label of the inner object" do
-        expect(@test_object.label).not_to eq("foo label")
-        @test_object.label = "foo label"
-        expect(@test_object.label).to eq("foo label")
-      end
-    end
     describe "update_attributes" do
       it "should set the attributes and save" do
         m = FooHistory.new
@@ -557,23 +310,5 @@ describe ActiveFedora::Base do
         m.update(att)
       end
     end
-
-    describe ".solrize_relationships" do
-      it "should serialize the relationships into a Hash" do
-        graph = RDF::Graph.new
-        subject = RDF::URI.new "info:fedora/test:sample_pid"
-        graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:is_member_of),  RDF::URI.new('info:fedora/demo:10'))
-        graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:is_part_of),  RDF::URI.new('info:fedora/demo:11'))
-        graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_part),  RDF::URI.new('info:fedora/demo:12'))
-        graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:conforms_to),  "AnInterface")
-
-        expect(@test_object).to receive(:relationships).and_return(graph)
-        solr_doc = @test_object.solrize_relationships
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("is_member_of", :symbol)]).to eq("info:fedora/demo:10")
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("is_part_of", :symbol)]).to eq("info:fedora/demo:11")
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("has_part", :symbol)]).to eq("info:fedora/demo:12")
-        expect(solr_doc[ActiveFedora::SolrService.solr_name("conforms_to", :symbol)]).to eq("AnInterface")
-      end
-    end
   end
 end