active-fedora 3.0.7 → 3.1.0.pre1

data/lib/active_fedora/qualified_dublin_core_datastream.rb

@@ -15,37 +15,42 @@ module ActiveFedora
     
     #Constructor. this class will call self.field for each DCTERM. In short, all DCTERMS fields will already exist
     #when this method returns. Each term is marked as a multivalue string.
-    def initialize(attrs=nil)
-      super
+    def initialize(digital_object, dsid, exists_in_fedora=false )
+      super(digital_object, dsid)
       DCTERMS.each do |el|
         field el, :string, :multiple=>true
       end
+      ###TODO this is loading eagerly, but we could make it lazy
+      self.class.from_xml(exists_in_fedora ? content : nil, self)
       self
     end
     
-    def set_blob_for_save # :nodoc:
-      self.blob = self.to_dc_xml
-    end
-    
     # Populate a QualifiedDublinCoreDatastream object based on the "datastream" node from a FOXML file
+    # @param [String] node the xml from the content.  Assumes that the content of this datastream is that of an ActiveFedora QualifiedDublinCoreDatastream 
     # @param [ActiveFedora::Datastream] tmpl the Datastream object that you are building
-    # @param [Nokogiri::XML::Node] node the "foxml:datastream" node from a FOXML file.  Assumes that the content of this datastream is that of an ActiveFedora QualifiedDublinCoreDatastream 
-    def self.from_xml(tmpl, node) # :nodoc:
-     tmpl.fields.each do |z|
-       fname = z.first
-       fspec = z.last
-       node_name = "dcterms:#{fspec[:xml_node] ? fspec[:xml_node] : fname}"
-       attr_modifier= "[@xsi:type='#{fspec[:encoding]}']" if fspec[:encoding]
-       query = "./foxml:datastreamVersion[last()]/foxml:xmlContent/dc/#{node_name}#{attr_modifier}"
-       node.xpath(query, {"foxml"=>"info:fedora/fedora-system:def/foxml#", "dcterms"=>'http://purl.org/dc/terms/', "xsi"=>'http://www.w3.org/2001/XMLSchema-instance'}).each do |f|
-          tmpl.send("#{fname}_append", f.text)
+    def self.from_xml(xml, tmpl) # :nodoc:
+      return if xml.nil?
+      node = Nokogiri::XML::Document.parse(xml)
+      tmpl.fields.each do |z|
+        fname = z.first
+        fspec = z.last
+        node_name = "dcterms:#{fspec[:xml_node] ? fspec[:xml_node] : fname}"
+        attr_modifier= "[@xsi:type='#{fspec[:encoding]}']" if fspec[:encoding]
+        query = "/dc/#{node_name}#{attr_modifier}"
+
+        node.xpath(query).each do |f|
+           tmpl.send("#{fname}_append", f.text)
         end
 
-     end
-     tmpl.instance_variable_set(:@dirty, false)
-     tmpl
+      end
+      tmpl.instance_variable_set(:@dirty, false)
+      tmpl
     end
 
+  def to_xml() 
+    to_dc_xml() 
+  end
+
    #Render self as a Fedora DC xml document.
    def to_dc_xml
      #TODO: pull the modifiers up into MDDS

data/lib/active_fedora/rels_ext_datastream.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/class/inheritable_attributes'
 require 'solrizer/field_name_mapper'
 require 'uri'
 
@@ -8,50 +9,51 @@ module ActiveFedora
     include Solrizer::FieldNameMapper
     
     
-    def initialize(attrs=nil)
-      super
-      self.dsid = "RELS-EXT"
+    # def initialize(digital_object, dsid, exists_in_fedora=nil)
+    #   super(digital_object, 'RELS-EXT')
+    # end
+
+    def changed?
+      relationships_are_dirty || super
+    end
+
+    def serialize!
+      self.content = to_rels_ext(self.pid) if relationships_are_dirty
+      relationships_are_dirty = false
     end
     
-    def save
-      if @dirty == true
-        self.content = to_rels_ext(self.pid)
-      end
-      super
+
+    def to_xml(fields_xml) 
+      to_rels_ext(self.pid) 
     end
       
-    def pid=(pid)
-      super
-      self.blob = <<-EOL
-      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-        <rdf:Description rdf:about="info:fedora/#{pid}">
-        </rdf:Description>
-      </rdf:RDF>
-      EOL
-    end
-    
-    # Populate a RelsExtDatastream object based on the "datastream" node from a FOXML file
+    # Populate a RelsExtDatastream object based on the "datastream" content 
     # Assumes that the datastream contains RDF XML from a Fedora RELS-EXT datastream 
     # @param [ActiveFedora::MetadataDatastream] tmpl the Datastream object that you are populating
-    # @param [Nokogiri::XML::Node] node the "foxml:datastream" node from a FOXML file
-    def self.from_xml(tmpl, node) 
-      # node.xpath("./foxml:datastreamVersion[last()]/foxml:xmlContent/rdf:RDF/rdf:Description/*").each do |f|
-      node.xpath("./foxml:datastreamVersion[last()]/foxml:xmlContent/rdf:RDF/rdf:Description/*", {"rdf"=>"http://www.w3.org/1999/02/22-rdf-syntax-ns#", "foxml"=>"info:fedora/fedora-system:def/foxml#"}).each do |f|
-          if f.namespace
-            ns_mapping = self.predicate_mappings[f.namespace.href]
-            predicate = ns_mapping ?  ns_mapping.invert[f.name] : nil
-            predicate = "#{f.namespace.prefix}_#{f.name}" if predicate.nil?
-          else
-            logger.warn "You have a predicate without a namespace #{f.name}. Verify your rels-ext is correct."
-            predicate = "#{f.name}"
-          end
-          is_obj = f["resource"]
-          object = is_obj ? f["resource"] : f.inner_text
-          r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>object, :is_literal=>!is_obj)
-          tmpl.add_relationship(r)
+    # @param [String] the "rdf" node 
+    def self.from_xml(xml, tmpl) 
+      if (xml.nil?)
+        ### maybe put the template here?
+      else
+        node = Nokogiri::XML::Document.parse(xml)
+        node.xpath("rdf:RDF/rdf:Description/*", {"rdf"=>"http://www.w3.org/1999/02/22-rdf-syntax-ns#"}).each do |f|
+            if f.namespace
+              ns_mapping = self.predicate_mappings[f.namespace.href]
+              predicate = ns_mapping ?  ns_mapping.invert[f.name] : nil
+              predicate = "#{f.namespace.prefix}_#{f.name}" if predicate.nil?
+            else
+              logger.warn "You have a predicate without a namespace #{f.name}. Verify your rels-ext is correct."
+              predicate = "#{f.name}"
+            end
+            is_obj = f["resource"]
+            object = is_obj ? f["resource"] : f.inner_text
+            r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>object, :is_literal=>!is_obj)
+            tmpl.add_relationship(r)
+        end
+        tmpl.relationships_are_dirty = false
+        #tmpl.send(:dirty=, false)
+        tmpl
       end
-      tmpl.send(:dirty=, false)
-      tmpl
     end
     
     # Serialize the datastream's RDF relationships to solr

data/lib/active_fedora/rubydora_connection.rb

@@ -0,0 +1,40 @@
+require 'singleton'
+require 'rubydora'
+
+module ActiveFedora
+  class RubydoraConnection
+    include Singleton
+    
+    attr_reader :connection
+    attr_accessor :options
+
+    def self.connect(params={})
+      if params.kind_of? String
+        u = URI.parse params
+        params = {}
+        params[:user] = u.user
+        params[:password] = u.password
+        params[:url] = "#{u.scheme}://#{u.host}:#{u.port}#{u.path}"
+      end
+      instance = self.instance
+      instance.options = params
+      instance.connect
+      instance
+    end
+
+    def connect()
+      return unless @connection.nil?
+      @connection = Rubydora.connect :url => options[:url], :user => options[:user], :password => options[:password]
+    end
+
+    def nextid(attrs={})
+      d = REXML::Document.new(connection.next_pid(:namespace=>attrs[:namespace]))
+      d.elements['//pid'].text
+    end
+
+    def find_model(pid, klass)
+      klass.new(:pid=>pid)
+    end
+
+  end
+end

data/lib/active_fedora/semantic_node.rb

@@ -16,11 +16,11 @@ module ActiveFedora
     def add_relationship(relationship)
       # Only accept ActiveFedora::Relationships as input arguments
       assert_kind_of 'relationship',  relationship, ActiveFedora::Relationship
-      self.relationships_are_dirty = true
       register_triple(relationship.subject, relationship.predicate, relationship.object)
     end
     
     def register_triple(subject, predicate, object)
+      self.relationships_are_dirty = true
       register_subject(subject)
       register_predicate(subject, predicate)
       relationships[subject][predicate] << object

data/lib/active_fedora/solr_service.rb

@@ -36,7 +36,7 @@ module ActiveFedora
         if opts[:load_from_solr]
           results << classname.load_instance_from_solr(hit[SOLR_DOCUMENT_ID])
         else
-          results << Fedora::Repository.instance.find_model(hit[SOLR_DOCUMENT_ID], classname)
+          results << ActiveFedora::RubydoraConnection.instance.find_model(hit[SOLR_DOCUMENT_ID], classname)
         end
       end
       return results

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-    VERSION = "3.0.7"
+    VERSION = "3.1.0.pre1"
 end

data/lib/ruby-fedora.rb

@@ -10,11 +10,3 @@ class Hash
     self.each {|k,v| self[k.to_sym]=v; self.delete(k) unless self[k.to_sym]}
   end
 end
-require 'fedora/base'
-require 'fedora/connection'
-require 'fedora/datastream'
-require 'fedora/fedora_object'
-require 'fedora/formats'
-require 'fedora/generic_search'
-require 'fedora/repository'
-#require 'util/class_level_inheritable_attributes'

data/lib/tasks/active_fedora.rake

@@ -19,17 +19,15 @@ namespace :af do
       puts "You must specify a valid pid.  Example: rake fedora:delete pid=demo:12"
     else
       pid = ENV["pid"]
-      puts "Deleting '#{pid}' from #{Fedora::Repository.instance.fedora_url}"
+      puts "Deleting '#{pid}' from #{ActiveFedora::RubydoraConnection.instance.options[:url]}"
       begin
         ActiveFedora::Base.load_instance(pid).delete
       rescue ActiveFedora::ObjectNotFoundError
         puts "The object #{pid} has already been deleted (or was never created)."
       rescue Errno::ECONNREFUSED => e
         puts "Can't connect to Fedora! Are you sure jetty is running?"
-      rescue Fedora::ServerError => e
-          logger.error("Received a Fedora error while deleting #{pid}")
       end
-      logger.info "Deleted '#{pid}' from #{Fedora::Repository.instance.fedora_url}"
+      logger.info "Deleted '#{pid}' from #{ActiveFedora::RubydoraConnection.instance.options[:url]}"
     end
   end
   
@@ -53,7 +51,7 @@ namespace :af do
       rescue ActiveFedora::ObjectNotFoundError
         # The object has already been deleted (or was never created).  Do nothing.
       end
-      puts "Deleted '#{pid}' from #{Fedora::Repository.instance.fedora_url}"
+      puts "Deleted '#{pid}' from #{ActiveFedora::RubydoraConnection.instance.options[:url]}"
       i += 1
     end
   end
@@ -63,14 +61,18 @@ namespace :af do
         
     # If a source url has been provided, attampt to export from the fedora repository there.
     if ENV["source"]
-      Fedora::Repository.register(ENV["source"])
+      #FIXME
+      raise "Not Implemented"
+      #Fedora::Repository.register(ENV["source"])
     end
     
     if ENV["pid"].nil? 
       puts "You must specify a valid pid.  Example: rake fedora:harvest_fixture pid=demo:12"
     else
       pid = ENV["pid"]
-      puts "Exporting '#{pid}' from #{Fedora::Repository.instance.fedora_url}"
+      puts "Exporting '#{pid}' from #{ActiveFedora::RubydoraConnection.instance.options[:url]}"
+      #FIXME
+      raise "Not Implemented"
       foxml = Fedora::Repository.instance.export(pid)
       filename = File.join("spec","fixtures","#{pid.gsub(":","_")}.foxml.xml")
       file = File.new(filename,"w")
@@ -84,6 +86,8 @@ namespace :af do
         
     # If a destination url has been provided, attampt to export from the fedora repository there.
     if ENV["destination"]
+      #FIXME
+      raise "Not Implemented"
       Fedora::Repository.register(ENV["destination"])
     end
         
@@ -97,9 +101,10 @@ namespace :af do
     end
     
     if !filename.nil?
-      puts "Importing '#{filename}' to #{Fedora::Repository.instance.fedora_url}"
+      puts "Importing '#{filename}' to #{ActiveFedora::RubydoraConnection.instance.options[:url]}"
       file = File.new(filename, "r")
-      result = foxml = Fedora::Repository.instance.ingest(file.read)
+      result = foxml = ActiveFedora::RubydoraConnection.instance.connection.ingest(:file=>file.read)
+#      result = foxml = Fedora::Repository.instance.ingest(file.read)
       if result
         puts "The fixture has been ingested as #{result.body}"
         if !pid.nil?

data/lib/tasks/active_fedora_dev.rake

@@ -14,18 +14,21 @@ EOS
   exit(0)
 end
 
+APP_ROOT = File.expand_path("#{File.dirname(__FILE__)}/../../")
+require 'jettywrapper'
+
 $: << 'lib'
-def jetty_params 
-  project_root = File.expand_path("#{File.dirname(__FILE__)}/../../")
-  {
-      :quiet => false,
-      :jetty_home => File.join(project_root,'jetty'),
-      :jetty_port => 8983,
-      :solr_home => File.expand_path(File.join(project_root,'jetty','solr')),
-      :fedora_home => File.expand_path(File.join(project_root,'jetty','fedora','default')),
-      :startup_wait=>30
-    }
-end
+# def jetty_params 
+#   project_root = File.expand_path("#{File.dirname(__FILE__)}/../../")
+#   {
+#       :quiet => false,
+#       :jetty_home => File.join(project_root,'jetty'),
+#       :jetty_port => 8983,
+#       :solr_home => File.expand_path(File.join(project_root,'jetty','solr')),
+#       :fedora_home => File.expand_path(File.join(project_root,'jetty','fedora','default')),
+#       :startup_wait=>30
+#     }
+# end
 
 desc "Run active-fedora rspec tests"
 task :spec do
@@ -34,21 +37,17 @@ end
 
 desc "Hudson build"
 task :hudson do
-  require 'jettywrapper'
   
-  if (ENV['environment'] == "test")
-    Rake::Task["active_fedora:doc"].invoke
-    Rake::Task["active_fedora:configure_jetty"].invoke
-    error = Jettywrapper.wrap(jetty_params) do
-      ENV["FEDORA_HOME"]=File.expand_path(File.join(File.dirname(__FILE__),'..','..','jetty','fedora','default'))
-      Rake::Task["active_fedora:load_fixtures"].invoke
-      Rake::Task["active_fedora:rspec"].invoke
-    end
-    raise "test failures: #{error}" if error
-  else
-    system("rake hudson environment=test")
-    fail unless $?.success?
+  ENV['environment'] = "test"
+  Rake::Task["active_fedora:doc"].invoke
+  Rake::Task["active_fedora:configure_jetty"].invoke
+  jetty_params = Jettywrapper.load_config
+  error = Jettywrapper.wrap(jetty_params) do
+    ENV["FEDORA_HOME"]=File.expand_path(File.join(File.dirname(__FILE__),'..','..','jetty','fedora','default'))
+    Rake::Task["active_fedora:load_fixtures"].invoke
+    Rake::Task["active_fedora:rspec"].invoke
   end
+  raise "test failures: #{error}" if error
 end
 
 namespace :active_fedora do
@@ -115,20 +114,6 @@ namespace :active_fedora do
       cp("#{f}", 'jetty/solr/test-core/conf/', :verbose => true)
     end
   end
-
-  namespace :jetty do
-    desc "start jetty" 
-    task :start do
-      require 'jettywrapper'
-      Jettywrapper.start(jetty_params)
-    end
-    desc "stop jetty" 
-    task :stop do
-      require 'jettywrapper'
-      Jettywrapper.stop(jetty_params)
-    end
-  end
-
 end
 
 # Provides an :environment task for use while working within a working copy of active-fedora
@@ -138,6 +123,4 @@ task :environment do
   puts "Initializing ActiveFedora Rake environment.  This should only be called when working within a workign copy of the active-fedora code."
   require 'spec/samples/models/hydrangea_article'
   require 'active_fedora/samples'
-  # $:.unshift(File.dirname(__FILE__) + '/../lib')
-  # Dir[File.join(File.dirname(__FILE__)+'/../lib/')+'**/*.rb'].each{|x| require x}
 end

data/spec/integration/base_loader_spec.rb

@@ -24,22 +24,6 @@ describe ActiveFedora::Base do
     @test_object.delete
   end
   
-  describe "deserialize" do
-    it "should return an object whose inner_object is not marked as new.  The datastreams should only be marked new if the model expects a datastream that doesn't exist yet in fedora" do
-      #mocko = mock("object")
-      #ActiveFedora::Base.expects(:new).returns(mocko)
-      @test_object.datastreams["sensitive_passages"].delete
-      doc = Nokogiri::XML::Document.parse(@test_object.inner_object.object_xml)
-      result = OralHistorySampleModel.deserialize(doc)
-      result.new_object?.should be_false
-      result.datastreams_in_memory.should have_key("dublin_core")
-      result.datastreams_in_memory.should have_key("properties")
-      result.datastreams_in_memory.each do |name,ds|
-        ds.new_object?.should be_false unless name == "sensitive_passages"
-      end
-      result.datastreams_in_memory["sensitive_passages"].new_object?.should be_true
-    end
-  end
   describe "load_instance" do
     it "should retain all datastream attributes pulled from fedora" do
       # raw_object = Fedora::Repository.instance.find_objects("pid=#{@test_object.pid}").first
@@ -48,12 +32,11 @@ describe ActiveFedora::Base do
       raw_datastreams = raw_object.datastreams
       loaded_datastreams = loaded.datastreams
       raw_datastreams.each_pair do |k,v|
-        v.attributes.each_pair do |attr_name, attr_value|
-          loaded_datastreams[k].attributes.should have_key(attr_name)
-          loaded_datastreams[k].attributes[attr_name].should == attr_value
-        end
+        v.dsid.should == loaded_datastreams[k].dsid
+        v.dsLabel.should == loaded_datastreams[k].dsLabel
+        v.mimeType.should == loaded_datastreams[k].mimeType
       end
     end
   end
 
-end
+end

data/spec/integration/base_spec.rb

@@ -95,20 +95,19 @@ describe ActiveFedora::Base do
     
     it "should set the CMA hasModel relationship in the Rels-EXT" do 
       @test_object2.save
-      rexml = REXML::Document.new(@test_object.datastreams_in_fedora["RELS-EXT"].content)
+      rexml = REXML::Document.new(@test_object2.datastreams["RELS-EXT"].content)
       # Purpose: confirm that the isMemberOf entries exist and have real RDF in them
       rexml.root.elements["rdf:Description/hasModel"].attributes["rdf:resource"].should == 'info:fedora/afmodel:ActiveFedora_Base'
     end
     it "should merge attributes from fedora into attributes hash" do
       inner_object = @test_object2.inner_object
-      inner_object.attributes.should == {:pid=>@test_object2.pid}
+      inner_object.pid.should == @test_object2.pid
       @test_object2.save
-      inner_object.attributes.should have_key(:state)
-      inner_object.attributes.should have_key(:create_date)
-      inner_object.attributes.should have_key(:modified_date)
-      inner_object.attributes.should have_key(:owner_id)
+      inner_object.should respond_to(:state)
+      inner_object.should respond_to(:lastModifiedDate)
+      inner_object.should respond_to(:ownerId)
       inner_object.state.should == "A"
-      inner_object.owner_id.should == "fedoraAdmin"
+      inner_object.ownerId.should == "fedoraAdmin"
     end
   end
   
@@ -119,19 +118,19 @@ describe ActiveFedora::Base do
     end
   end
   
-  describe ".datastreams_in_fedora" do
+  describe ".datastreams" do
     it "should return a Hash of datastreams from fedora" do
-      datastreams = @test_object.datastreams_in_fedora
-      datastreams.should be_an_instance_of(Hash) 
+      datastreams = @test_object.datastreams
+      datastreams.should be_a_kind_of(Hash) 
       datastreams.each_value do |ds| 
         ds.should be_a_kind_of(ActiveFedora::Datastream)
       end
-      @test_object.datastreams_in_fedora["DC"].should be_an_instance_of(ActiveFedora::Datastream)
+      @test_object.datastreams["DC"].should be_an_instance_of(ActiveFedora::Datastream)
       datastreams["DC"].should_not be_nil
       datastreams["DC"].should be_an_instance_of(ActiveFedora::Datastream)       
     end
     it "should initialize the datastream pointers with @new_object=false" do
-      datastreams = @test_object.datastreams_in_fedora
+      datastreams = @test_object.datastreams
       datastreams.each_value do |ds| 
         ds.new_object?.should be_false
       end
@@ -140,9 +139,9 @@ describe ActiveFedora::Base do
   
   describe ".metadata_streams" do
     it "should return all of the datastreams from the object that are kinds of MetadataDatastreams " do
-      mds1 = ActiveFedora::MetadataDatastream.new(:dsid => "md1")
-      mds2 = ActiveFedora::QualifiedDublinCoreDatastream.new(:dsid => "qdc")
-      fds = ActiveFedora::Datastream.new(:dsid => "fds")
+      mds1 = ActiveFedora::MetadataDatastream.new(@test_object.inner_object, "md1")
+      mds2 = ActiveFedora::QualifiedDublinCoreDatastream.new(@test_object.inner_object, "qdc")
+      fds = ActiveFedora::Datastream.new(@test_object.inner_object, "fds")
       @test_object.add_datastream(mds1)
       @test_object.add_datastream(mds2)
       @test_object.add_datastream(fds)      
@@ -156,9 +155,9 @@ describe ActiveFedora::Base do
   
   describe ".file_streams" do
     it "should return all of the datastreams from the object that are kinds of MetadataDatastreams" do
-      fds1 = ActiveFedora::Datastream.new(:dsid => "fds1")
-      fds2 = ActiveFedora::Datastream.new(:dsid => "fds2")
-      mds = ActiveFedora::MetadataDatastream.new(:dsid => "mds")
+      fds1 = ActiveFedora::Datastream.new(@test_object.inner_object, "fds1")
+      fds2 = ActiveFedora::Datastream.new(@test_object.inner_object, "fds2")
+      mds = ActiveFedora::MetadataDatastream.new(@test_object.inner_object, "mds")
       @test_object.add_datastream(fds1)  
       @test_object.add_datastream(fds2)
       @test_object.add_datastream(mds)    
@@ -169,9 +168,9 @@ describe ActiveFedora::Base do
       result.should include(fds2)
     end
     it "should skip DC and RELS-EXT datastreams" do
-      fds1 = ActiveFedora::Datastream.new(:dsid => "fds1")
-      dc = ActiveFedora::Datastream.new(:dsid => "DC")
-      rels_ext = ActiveFedora::RelsExtDatastream.new
+      fds1 = ActiveFedora::Datastream.new(@test_object.inner_object,"fds1")
+      dc = ActiveFedora::Datastream.new(@test_object.inner_object, "DC")
+      rels_ext = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
       @test_object.add_datastream(fds1)  
       @test_object.add_datastream(dc)
       @test_object.add_datastream(rels_ext)    
@@ -198,10 +197,10 @@ describe ActiveFedora::Base do
     
     it 'should create the RELS-EXT datastream if it doesnt exist' do
       test_object = ActiveFedora::Base.new
-      test_object.datastreams["RELS-EXT"].should == nil
+      #test_object.datastreams["RELS-EXT"].should == nil
       test_object.rels_ext
-      test_object.datastreams_in_memory["RELS-EXT"].should_not == nil
-      test_object.datastreams_in_memory["RELS-EXT"].class.should == ActiveFedora::RelsExtDatastream
+      test_object.datastreams["RELS-EXT"].should_not == nil
+      test_object.datastreams["RELS-EXT"].class.should == ActiveFedora::RelsExtDatastream
     end
   end
 
@@ -214,7 +213,7 @@ describe ActiveFedora::Base do
         @test_object.add_relationship(rel.predicate, rel.object)
       end
       @test_object.save
-      rexml = REXML::Document.new(@test_object.datastreams_in_fedora["RELS-EXT"].content)
+      rexml = REXML::Document.new(@test_object.datastreams["RELS-EXT"].content)
       # Purpose: confirm that the isMemberOf entries exist and have real RDF in them
       rexml.root.elements["rdf:Description/isMemberOf[@rdf:resource='info:fedora/demo:5']"].attributes["xmlns"].should == 'info:fedora/fedora-system:def/relations-external#'
       rexml.root.elements["rdf:Description/isMemberOf[@rdf:resource='info:fedora/demo:10']"].attributes["xmlns"].should == 'info:fedora/fedora-system:def/relations-external#'
@@ -229,50 +228,56 @@ describe ActiveFedora::Base do
      @test_object.save
      test_obj = ActiveFedora::Base.load_instance(@test_object.pid)
      #check case where nothing passed in does not have correct mime type
-     test_obj.datastreams["DS1"].attributes["mimeType"].should == "application/octet-stream"
+     test_obj.datastreams["DS1"].mimeType.should == "application/octet-stream"
      @test_object2 = ActiveFedora::Base.new
+     f = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino_jpg_no_file_ext" ))
      @test_object2.add_file_datastream(f,{:mimeType=>"image/jpeg"})
      @test_object2.save
      test_obj = ActiveFedora::Base.load_instance(@test_object2.pid)
-     test_obj.datastreams["DS1"].attributes["mimeType"].should == "image/jpeg"
+     test_obj.datastreams["DS1"].mimeType.should == "image/jpeg"
      @test_object3 = ActiveFedora::Base.new
+     f = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino_jpg_no_file_ext" ))
      @test_object3.add_file_datastream(f,{:mime_type=>"image/jpeg"})
      @test_object3.save
      test_obj = ActiveFedora::Base.load_instance(@test_object3.pid)
-     test_obj.datastreams["DS1"].attributes["mimeType"].should == "image/jpeg"
+     test_obj.datastreams["DS1"].mimeType.should == "image/jpeg"
      @test_object4 = ActiveFedora::Base.new
+     f = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino_jpg_no_file_ext" ))
      @test_object4.add_file_datastream(f,{:content_type=>"image/jpeg"})
      @test_object4.save
      test_obj = ActiveFedora::Base.load_instance(@test_object4.pid)
-     test_obj.datastreams["DS1"].attributes["mimeType"].should == "image/jpeg"
+     test_obj.datastreams["DS1"].mimeType.should == "image/jpeg"
    end
   end
   
   describe '.add_datastream' do
   
     it "should be able to add datastreams" do
-      ds = ActiveFedora::Datastream.new(:dsID => 'DS1', :dsLabel => 'hello', :altIDs => '3333', 
-        :controlGroup => 'M', :blob => fixture('dino.jpg'))
+      ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'DS1')
+      # ds = ActiveFedora::Datastream.new(:dsID => 'DS1', :dsLabel => 'hello', :altIDs => '3333', 
+      #   :controlGroup => 'M', :blob => fixture('dino.jpg'))
       @test_object.add_datastream(ds).should be_true
     end
       
-    it "adding and saving should add the datastream to the datastreams_in_fedora array" do
-      ds = ActiveFedora::Datastream.new(:dsid => 'DS1', :dsLabel => 'hello', :altIDs => '3333', 
-        :controlGroup => 'M', :blob => fixture('dino.jpg'))
+    it "adding and saving should add the datastream to the datastreams array" do
+      ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'DS1') 
+      ds.content = fixture('dino.jpg').read
+      # ds = ActiveFedora::Datastream.new(:dsid => 'DS1', :dsLabel => 'hello', :altIDs => '3333', 
+      #   :controlGroup => 'M', :blob => fixture('dino.jpg'))
       @test_object.datastreams.should_not have_key("DS1")
       @test_object.add_datastream(ds)
       ds.save
-      @test_object.datastreams_in_fedora.should have_key("DS1")
+      @test_object.datastreams.should have_key("DS1")
     end
     
   end
   
   it "should retrieve blobs that match the saved blobs" do
-    ds = ActiveFedora::Datastream.new(:dsid => 'DS1', :dsLabel => 'hello', :altIDs => '3333', 
-      :controlGroup => 'M', :blob => fixture('dino.jpg'))
-    @test_object.add_datastream(ds)
-    ds.save
-    @test_object.datastreams_in_fedora["DS1"].content.should == ds.content
+    ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'DS1')
+    ds.content = "foo"
+    new_ds = ds.save
+    @test_object.add_datastream(new_ds)
+    @test_object.class.find(@test_object.pid).datastreams["DS1"].content.should == new_ds.content
   end
   
   describe ".create_date" do 
@@ -298,16 +303,16 @@ describe ActiveFedora::Base do
     describe '#delete' do
       it 'if inbound relationships exist should remove relationships from those inbound targets as well when deleting this object' do
         @test_object2 = MockAFBaseRelationship.new
-        @test_object2.new_object = true
+#        @test_object2.new_object = true
         @test_object2.save
         @test_object3 = MockAFBaseRelationship.new
-        @test_object3.new_object = true
+#        @test_object3.new_object = true
         @test_object3.save
         @test_object4 = MockAFBaseRelationship.new
-        @test_object4.new_object = true
+#        @test_object4.new_object = true
         @test_object4.save
         @test_object5 = MockAFBaseRelationship.new
-        @test_object5.new_object = true
+#        @test_object5.new_object = true
         @test_object5.save
         #append to relationship by 'testing'
         @test_object2.add_relationship_by_name("testing",@test_object3)
@@ -366,16 +371,16 @@ describe ActiveFedora::Base do
   describe '#relationships' do
     it 'should return internal relationships with no parameters and include inbound if false passed in' do
       @test_object2 = MockAFBaseRelationship.new
-      @test_object2.new_object = true
+#      @test_object2.new_object = true
       @test_object2.save
       @test_object3 = MockAFBaseRelationship.new
-      @test_object3.new_object = true
+#      @test_object3.new_object = true
       @test_object3.save
       @test_object4 = MockAFBaseRelationship.new
-      @test_object4.new_object = true
+#      @test_object4.new_object = true
       @test_object4.save
       @test_object5 = MockAFBaseRelationship.new
-      @test_object5.new_object = true
+#      @test_object5.new_object = true
       @test_object5.save
       #append to named relationship 'testing'
       @test_object2.testing_append(@test_object3)
@@ -424,16 +429,16 @@ describe ActiveFedora::Base do
   describe '#inbound_relationships' do
     it 'should return a hash of inbound relationships' do
       @test_object2 = MockAFBaseRelationship.new
-      @test_object2.new_object = true
+      #@test_object2.new_object = true
       @test_object2.save
       @test_object3 = MockAFBaseRelationship.new
-      @test_object3.new_object = true
+      #@test_object3.new_object = true
       @test_object3.save
       @test_object4 = MockAFBaseRelationship.new
-      @test_object4.new_object = true
+      #@test_object4.new_object = true
       @test_object4.save
       @test_object5 = MockAFBaseRelationship.new
-      @test_object5.new_object = true
+      #@test_object5.new_object = true
       @test_object5.save
       #append to named relationship 'testing'
       @test_object2.testing_append(@test_object3)
@@ -459,16 +464,16 @@ describe ActiveFedora::Base do
   describe '#inbound_relationships_by_name' do
     it 'should return a hash of inbound relationship names to array of objects' do
       @test_object2 = MockAFBaseRelationship.new
-      @test_object2.new_object = true
+      #@test_object2.new_object = true
       @test_object2.save
       @test_object3 = MockAFBaseRelationship.new
-      @test_object3.new_object = true
+      #@test_object3.new_object = true
       @test_object3.save
       @test_object4 = MockAFBaseRelationship.new
-      @test_object4.new_object = true
+      #@test_object4.new_object = true
       @test_object4.save
       @test_object5 = MockAFBaseRelationship.new
-      @test_object5.new_object = true
+      #@test_object5.new_object = true
       @test_object5.save
       #append to named relationship 'testing'
       @test_object2.testing_append(@test_object3)
@@ -497,16 +502,16 @@ describe ActiveFedora::Base do
   describe '#relationships_by_name' do
     it '' do
       @test_object2 = MockAFBaseRelationship.new
-      @test_object2.new_object = true
+      #@test_object2.new_object = true
       @test_object2.save
       @test_object3 = MockAFBaseRelationship.new
-      @test_object3.new_object = true
+      #@test_object3.new_object = true
       @test_object3.save
       @test_object4 = MockAFBaseRelationship.new
-      @test_object4.new_object = true
+      #@test_object4.new_object = true
       @test_object4.save
       @test_object5 = MockAFBaseRelationship.new
-      @test_object5.new_object = true
+      #@test_object5.new_object = true
       @test_object5.save
       #append to named relationship 'testing'
       @test_object2.testing_append(@test_object3)
@@ -536,16 +541,16 @@ describe ActiveFedora::Base do
   describe '#add_relationship_by_name' do
     it 'should add a named relationship to an object' do
       @test_object2 = MockAFBaseRelationship.new
-      @test_object2.new_object = true
+      #@test_object2.new_object = true
       @test_object2.save
       @test_object3 = MockAFBaseRelationship.new
-      @test_object3.new_object = true
+      #@test_object3.new_object = true
       @test_object3.save
       @test_object4 = MockAFBaseRelationship.new
-      @test_object4.new_object = true
+      #@test_object4.new_object = true
       @test_object4.save
       @test_object5 = MockAFBaseRelationship.new
-      @test_object5.new_object = true
+      #@test_object5.new_object = true
       @test_object5.save
       #append to named relationship 'testing'
       @test_object2.add_relationship_by_name("testing",@test_object3)
@@ -570,16 +575,16 @@ describe ActiveFedora::Base do
   describe '#remove_named_relationship' do
     it 'should remove an existing relationship from an object' do
       @test_object2 = MockAFBaseRelationship.new
-      @test_object2.new_object = true
+      #@test_object2.new_object = true
       @test_object2.save
       @test_object3 = MockAFBaseRelationship.new
-      @test_object3.new_object = true
+      #@test_object3.new_object = true
       @test_object3.save
       @test_object4 = MockAFBaseRelationship.new
-      @test_object4.new_object = true
+      #@test_object4.new_object = true
       @test_object4.save
       @test_object5 = MockAFBaseRelationship.new
-      @test_object5.new_object = true
+      #@test_object5.new_object = true
       @test_object5.save
       #append to named relationship 'testing'
       @test_object2.add_relationship_by_name("testing",@test_object3)
@@ -616,16 +621,16 @@ describe ActiveFedora::Base do
   describe '#find_relationship_by_name' do
     it 'should find relationships based on name passed in for inbound or outbound' do
       @test_object2 = MockAFBaseRelationship.new
-      @test_object2.new_object = true
+#      @test_object2.new_object = true
       @test_object2.save
       @test_object3 = MockAFBaseRelationship.new
-      @test_object3.new_object = true
+#      @test_object3.new_object = true
       @test_object3.save
       @test_object4 = MockAFBaseRelationship.new
-      @test_object4.new_object = true
+#      @test_object4.new_object = true
       @test_object4.save
       @test_object5 = MockAFBaseRelationship.new
-      @test_object5.new_object = true
+#      @test_object5.new_object = true
       @test_object5.save
       #append to named relationship 'testing'
       @test_object2.add_relationship_by_name("testing",@test_object3)
@@ -665,7 +670,7 @@ describe ActiveFedora::Base do
   describe '#add_named_datastream' do
     it 'should add a datastream with the given name to the object in fedora' do
       @test_object2 = MockAFBaseDatastream.new
-      @test_object2.new_object = true
+#      @test_object2.new_object = true
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
       f2.stubs(:original_filename).returns("dino.jpg")
@@ -681,21 +686,25 @@ describe ActiveFedora::Base do
       @test_object2.named_datastreams.keys.include?("high").should == true
       @test_object2.named_datastreams["thumbnail"].size.should == 1
       @test_object2.named_datastreams["high"].size.should == 1
-      @test_object2.named_datastreams["thumbnail"].first.attributes.should == {"label"=>ds.label,"dsid"=>ds.dsid,
-                                                                                 "mimeType"=>ds.attributes[:mimeType],
-                                                                                 :controlGroup=>ds.attributes[:controlGroup],
-                                                                                 :pid=>ds.pid, :dsID=>ds.dsid, :dsLabel=>ds.attributes[:dsLabel]}
-      @test_object2.named_datastreams["high"].first.attributes.should == {"label"=>ds2.label,"dsid"=>ds2.dsid,
-                                                                                 "mimeType"=>ds2.attributes[:mimeType],
-                                                                                 :controlGroup=>ds2.attributes[:controlGroup],
-                                                                                 :pid=>ds2.pid, :dsID=>ds2.dsid, :dsLabel=>ds2.attributes[:dsLabel]}
+      t2_thumb1 = @test_object2.named_datastreams["thumbnail"].first
+      t2_thumb1.dsid.should == ds.dsid
+      t2_thumb1.mimeType.should == ds.mimeType
+      t2_thumb1.pid.should == ds.pid
+      t2_thumb1.dsLabel.should == ds.dsLabel
+      t2_thumb1.controlGroup.should == ds.controlGroup
+      t2_high1 = @test_object2.named_datastreams["high"].first
+      t2_high1.dsid.should == ds2.dsid
+      t2_high1.mimeType.should == ds2.mimeType
+      t2_high1.pid.should == ds2.pid
+      t2_high1.dsLabel.should == ds2.dsLabel
+      t2_high1.controlGroup.should == ds2.controlGroup
     end
   end
   
   describe '#add_named_file_datastream' do
     it 'should add a file datastream with the given name to the object in fedora' do
       @test_object2 = MockAFBaseDatastream.new
-      @test_object2.new_object = true
+#      @test_object2.new_object = true
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       f.stubs(:content_type).returns("image/jpeg")
       @test_object2.add_named_file_datastream("thumbnail",f)
@@ -703,19 +712,30 @@ describe ActiveFedora::Base do
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.load_instance(@test_object2.pid)
       @test_object2.named_datastreams["thumbnail"].size.should == 1
-      @test_object2.named_datastreams["thumbnail"].first.attributes.should == {"label"=>ds.label,"dsid"=>ds.dsid,
-                                                                                 "mimeType"=>ds.attributes[:mimeType],
-                                                                                 :controlGroup=>ds.attributes[:controlGroup],
-                                                                                 :pid=>ds.pid, :dsID=>ds.dsid, :dsLabel=>ds.attributes[:dsLabel]}
+      t2_thumb1 = @test_object2.named_datastreams["thumbnail"].first
+      t2_thumb1.dsid.should == "THUMB1"
+      t2_thumb1.mimeType.should == "image/jpeg"
+      t2_thumb1.pid.should == @test_object2.pid
+      t2_thumb1.dsLabel.should == "minivan.jpg"
+      t2_thumb1.controlGroup.should == "M"
+
+# .attributes.should == {"label"=>ds.label,"dsid"=>ds.dsid,
+#                                                                                  "mimeType"=>ds.attributes[:mimeType],
+#                                                                                  :controlGroup=>ds.attributes[:controlGroup],
+#                                                                                  :pid=>ds.pid, :dsID=>ds.dsid, :dsLabel=>ds.attributes[:dsLabel]}
     end
   end
   
   describe '#update_named_datastream' do
     it 'should update a named datastream to have a new file' do
       @test_object2 = MockAFBaseDatastream.new
-      @test_object2.new_object = true
+#      @test_object2.new_object = true
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
+      minivan = f.read
+      f.rewind
       f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
+      dino = f.read
+      f.rewind
       f.stubs(:content_type).returns("image/jpeg")
       f.stubs(:original_filename).returns("minivan.jpg")
       f2.stubs(:content_type).returns("image/jpeg")
@@ -728,62 +748,32 @@ describe ActiveFedora::Base do
       @test_object2.thumbnail.size.should == 1
       @test_object2.thumbnail_ids == ["THUMB1"]
       ds = @test_object2.thumbnail.first
-      ds.attributes.should == {"mimeType"=>"image/jpeg", 
-                               :controlGroup=>"M", "dsid"=>"THUMB1", 
-                               :pid=>@test_object2.pid, :dsID=>"THUMB1", 
-                               "label"=>"minivan.jpg",:dsLabel=>"minivan.jpg"}
-      expected_content = ""
-      f.each {|line|
-        expected_content << line
-      }
-      raise "Datastream content mismatch on save of datastream" unless ds.content == expected_content
+      ds.dsid.should == "THUMB1"
+      ds.mimeType.should == "image/jpeg"
+      ds.pid.should == @test_object2.pid
+      ds.dsLabel.should == "minivan.jpg"
+      ds.controlGroup.should == "M"
+
+      ds.content.should == minivan 
       @test_object2.update_named_datastream("thumbnail",{:file=>f2,:dsid=>"THUMB1"})
       @test_object2.save
       @test_object2 = MockAFBaseDatastream.load_instance(@test_object2.pid)
       @test_object2.thumbnail.size.should == 1
       @test_object2.thumbnail_ids == ["THUMB1"]
-      ds = @test_object2.thumbnail.first
-      ds.attributes.should == {"mimeType"=>"image/jpeg", 
-                               :controlGroup=>"M", "dsid"=>"THUMB1", 
-                               :pid=>@test_object2.pid, :dsID=>"THUMB1", 
-                               "label"=>"dino.jpg", :dsLabel=>"dino.jpg"}
-      expected_content = ""
-      f2.each {|line|
-        expected_content << line
-      }
-      raise "Datastream content mismatch after update of datastream" unless ds.content == expected_content
-    end
-  end
-  
-  describe '#named_datastreams_attributes' do
-    it 'should return a hash of name to hash of dsid to attribute hashes for each named datastream' do
-      @test_object2 = MockAFBaseDatastream.new
-      @test_object2.new_object = true
-      f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
-      f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
-      f2.stubs(:original_filename).returns("dino.jpg")
-      f.stubs(:content_type).returns("image/jpeg")
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f, :label=>"testDS"})
-      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>f2})
-      ds = @test_object2.thumbnail.first
-      ds2 = @test_object2.high.first
-      @test_object2.save
-      @test_object2 = MockAFBaseDatastream.load_instance(@test_object2.pid)
-      @test_object2.named_datastreams_attributes.should == {"thumbnail"=>{"THUMB1"=>{"label"=>ds.label,"dsid"=>ds.dsid,
-                                                                                 "mimeType"=>ds.attributes[:mimeType],
-                                                                                 :controlGroup=>ds.attributes[:controlGroup],
-                                                                                 :pid=>ds.pid, :dsID=>ds.dsid, :dsLabel=>ds.attributes[:dsLabel]}},
-                                                            "high"=>{"HIGH1"=>{"label"=>ds2.label,"dsid"=>ds2.dsid,
-                                                                                 "mimeType"=>ds2.attributes[:mimeType],
-                                                                                 :controlGroup=>ds2.attributes[:controlGroup],
-                                                                                 :pid=>ds2.pid, :dsID=>ds2.dsid, :dsLabel=>ds2.attributes[:dsLabel]}}}
+      ds2 = @test_object2.thumbnail.first
+      ds2.dsid.should == "THUMB1"
+      ds2.mimeType.should == "image/jpeg"
+      ds2.pid.should == @test_object2.pid
+      ds2.dsLabel.should == "dino.jpg"
+      ds2.controlGroup.should == "M"
+      (ds2.content == dino).should be_true
     end
   end
   
   describe '#named_datastreams_ids' do
     it 'should return a hash of datastream name to an array of dsids' do
       @test_object2 = MockAFBaseDatastream.new
-      @test_object2.new_object = true
+#      @test_object2.new_object = true
       f = File.new(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"))
       f2 = File.new(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ))
       f2.stubs(:original_filename).returns("dino.jpg")
@@ -796,183 +786,183 @@ describe ActiveFedora::Base do
     end
   end
   
-  describe '#load_instance_from_solr' do
-    it 'should populate an instance of an ActiveFedora::Base object using solr instead of Fedora' do
-      
-      @test_object2 = MockAFBaseFromSolr.new
-      @test_object2.new_object = true
-      attributes = {"holding_id"=>{0=>"Holding 1"},
-                    "language"=>{0=>"Italian"},
-                    "creator"=>{0=>"Linguist, A."},
-                    "geography"=>{0=>"Italy"},
-                    "title"=>{0=>"Italian and Spanish: A Comparison of Common Phrases"}}
-      @test_object2.update_indexed_attributes(attributes)
-      @test_object2.save
-      @test_object3 = MockAFBaseFromSolr.new
-      @test_object3.new_object = true
-      attributes = {"holding_id"=>{0=>"Holding 2"},
-                    "language"=>{0=>"Spanish;Latin"},
-                    "creator"=>{0=>"Linguist, A."},
-                    "geography"=>{0=>"Spain"},
-                    "title"=>{0=>"A study of the evolution of Spanish from Latin"}}
-      @test_object3.update_indexed_attributes(attributes)
-      @test_object3.save
-      @test_object4 = MockAFBaseFromSolr.new
-      attributes = {"holding_id"=>{0=>"Holding 3"},
-                    "language"=>{0=>"Spanish;Latin"},
-                    "creator"=>{0=>"Linguist, A."},
-                    "geography"=>{0=>"Spain"},
-                    "title"=>{0=>"An obscure look into early nomadic tribes of Spain"}}
-      @test_object4.update_indexed_attributes(attributes)
-      @test_object4.new_object = true
-      @test_object4.save
-      @test_object5 = MockAFBaseFromSolr.new
-      @test_object5.new_object = true
-      @test_object5.save
-      
-      #append to named relationship 'testing'
-      @test_object2.testing_append(@test_object3)
-      @test_object2.testing2_append(@test_object4)
-      @test_object5.testing_append(@test_object2)
-      @test_object5.testing2_append(@test_object3)
-      @test_object2.save
-      @test_object5.save
-      r2 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object2)
-      r3 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object3)
-      r4 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object4)
-      r5 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object5)
-      model_rel = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>ActiveFedora::ContentModel.pid_from_ruby_class(MockAFBaseFromSolr))
-      #check inbound correct, testing goes to :has_part and testing2 goes to :has_member
-      test_from_solr_object2 = MockAFBaseFromSolr.load_instance_from_solr(@test_object2.pid)
-      test_from_solr_object3 = MockAFBaseFromSolr.load_instance_from_solr(@test_object3.pid)
-      test_from_solr_object4 = MockAFBaseFromSolr.load_instance_from_solr(@test_object4.pid)
-      test_from_solr_object5 = MockAFBaseFromSolr.load_instance_from_solr(@test_object5.pid)
-      
-      # need to check pid, system create and system modify
-      test_from_solr_object2.pid.should == @test_object2.pid
-      test_from_solr_object3.pid.should == @test_object3.pid
-      test_from_solr_object4.pid.should == @test_object4.pid
-      test_from_solr_object5.pid.should == @test_object5.pid
-      
-      Time.parse(test_from_solr_object2.create_date).should == Time.parse(@test_object2.create_date)
-      Time.parse(test_from_solr_object3.create_date).should == Time.parse(@test_object3.create_date)
-      Time.parse(test_from_solr_object4.create_date).should == Time.parse(@test_object4.create_date)
-      Time.parse(test_from_solr_object5.create_date).should == Time.parse(@test_object5.create_date)
-      
-      Time.parse(test_from_solr_object2.modified_date).should == Time.parse(@test_object2.modified_date)
-      Time.parse(test_from_solr_object3.modified_date).should == Time.parse(@test_object3.modified_date)
-      Time.parse(test_from_solr_object4.modified_date).should == Time.parse(@test_object4.modified_date)
-      Time.parse(test_from_solr_object5.modified_date).should == Time.parse(@test_object5.modified_date)
-
-      # need to test outbound and inbound relationships
-      test_from_solr_object2.relationships(false).should == {:self=>{:has_model=>[model_rel.object],
-                                                            :has_part=>[r3.object],
-                                                            :has_member=>[r4.object]},
-                                                    :inbound=>{:has_part=>[r5.object]}}
-      test_from_solr_object2.relationships_by_name(false).should == {:self=>{"testing"=>[r3.object],"testing2"=>[r4.object],
-        "collection_members"=>[],"part_of"=>[],"parts_outbound"=>[r3.object]},
-        :inbound=>{"testing_inbound"=>[r5.object],"testing_inbound2"=>[],"parts_inbound"=>[]}}
-      test_from_solr_object3.relationships(false).should == {:self=>{:has_model=>[model_rel.object]},
-                                                   :inbound=>{:has_part=>[r2.object],
-                                                               :has_member=>[r5.object]}}
-      test_from_solr_object3.relationships_by_name(false).should == {:self=>{"testing"=>[],"testing2"=>[], "collection_members"=>[],"part_of"=>[],"parts_outbound"=>[]},
-                                                                   :inbound=>{"testing_inbound"=>[r2.object],"testing_inbound2"=>[r5.object], "parts_inbound"=>[]}}                                                                  
-      test_from_solr_object4.relationships(false).should == {:self=>{:has_model=>[model_rel.object]},
-                                                    :inbound=>{:has_member=>[r2.object]}}
-      test_from_solr_object4.relationships_by_name(false).should == {:inbound=>{"parts_inbound"=>[], "testing_inbound"=>[], "testing_inbound2"=>[r2.object]}, :self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}}                       
-      test_from_solr_object5.relationships(false).should == {:self=>{:has_model=>[model_rel.object],
-                                                            :has_part=>[r2.object],
-                                                            :has_member=>[r3.object]},
-                                                    :inbound=>{}}
-      test_from_solr_object5.relationships_by_name(false).should == {:inbound=>{"parts_inbound"=>[], "testing_inbound"=>[], "testing_inbound2"=>[]}, :self=>{"testing2"=>[r3.object], "collection_members"=>[], "part_of"=>[], "testing"=>[r2.object], "parts_outbound"=>[r2.object]}}
-      #all inbound should now be empty if no parameter supplied to relationships
-      test_from_solr_object2.relationships.should == {:self=>{:has_part=>[r3.object],:has_member=>[r4.object],:has_model=>[model_rel.object]}}
-      test_from_solr_object2.relationships_by_name.should == {:self=>{"testing2"=>[r4.object], "collection_members"=>[], "part_of"=>[], "testing"=>[r3.object], "parts_outbound"=>[r3.object]}}
-      test_from_solr_object3.relationships.should == {:self=>{:has_model=>[model_rel.object]}}
-      test_from_solr_object3.relationships_by_name.should == {:self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}}
-      test_from_solr_object4.relationships.should == {:self=>{:has_model=>[model_rel.object]}}
-      test_from_solr_object4.relationships_by_name.should == {:self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}} 
-      test_from_solr_object5.relationships.should == {:self=>{:has_model=>[model_rel.object],
-                                                             :has_part=>[r2.object],
-                                                             :has_member=>[r3.object]}}
-      test_from_solr_object5.relationships_by_name.should == {:self=>{"testing2"=>[r3.object], "collection_members"=>[], "part_of"=>[], "testing"=>[r2.object], "parts_outbound"=>[r2.object]}}
-      # need to check metadata
-      test_from_solr_object2.fields[:language][:values].should == ["Italian"]
-      test_from_solr_object2.fields[:creator][:values].should == ["Linguist, A."]
-      test_from_solr_object2.fields[:geography][:values].should == ["Italy"]
-      test_from_solr_object2.fields[:title][:values].should == ["Italian and Spanish: A Comparison of Common Phrases"]
-      test_from_solr_object2.fields[:holding_id][:values].should == ["Holding 1"]
-      
-      test_from_solr_object3.fields[:language][:values].should == ["Spanish;Latin"]
-      test_from_solr_object3.fields[:creator][:values].should == ["Linguist, A."]
-      test_from_solr_object3.fields[:geography][:values].should == ["Spain"]
-      test_from_solr_object3.fields[:title][:values].should == ["A study of the evolution of Spanish from Latin"]
-      test_from_solr_object3.fields[:holding_id][:values].should == ["Holding 2"]
-      
-      test_from_solr_object4.fields[:language][:values].should == ["Spanish;Latin"]
-      test_from_solr_object4.fields[:creator][:values].should == ["Linguist, A."]
-      test_from_solr_object4.fields[:geography][:values].should == ["Spain"]
-      test_from_solr_object4.fields[:title][:values].should == ["An obscure look into early nomadic tribes of Spain"]
-      test_from_solr_object4.fields[:holding_id][:values].should == ["Holding 3"]
-
-      #need to check system modified and system created values correct
-      # need to implement for nokogiri datastream as well
-      #false.should == true
-    end
-  end
-  
-  describe 'load_from_solr using relationship finders'
-    it 'resulting finder should accept :load_from_solr as :response_format and return object instantiated using load_instance_from_solr' do
-#      solr_result = mock("solr result")
-#      SpecNode.create_inbound_relationship_finders("constituents", :is_constituent_of, :inbound => true)
-#      local_node = SpecNode.new
-#      mock_repo = mock("repo")
-#      mock_repo.expects(:find_model).never
-#      SpecNode.expects(:load_instance_from_solr).times(1)
-#      local_node.expects(:internal_uri).returns("info:fedora/test:sample_pid")
-#      ActiveFedora::SolrService.instance.conn.expects(:query).with("is_constituent_of_s:info\\:fedora/test\\:sample_pid").returns(solr_result)
-#      local_node.constituents(:response_format => :solr).should equal(solr_result)
-    end
-    
-    it 'when an object is loaded via solr instead of fedora it should automatically load objects from finders from solr as well' do
-      @test_object2 = MockAFBaseFromSolr.new
-      @test_object2.save
-      @test_object3 = MockAFBaseFromSolr.new
-      @test_object3.save
-      @test_object2.testing_append(@test_object3)
-      @test_object2.save
-      
-      test_object2_from_solr = MockAFBaseFromSolr.load_instance_from_solr(@test_object2.pid)
-      test_object3_from_solr = MockAFBaseFromSolr.load_instance_from_solr(@test_object3.pid)
-      MockAFBaseFromSolr.expects(:load_instance_from_solr).times(4)
-      test_object2_from_solr.testing({:response_format=>:load_from_solr})
-      test_object3_from_solr.testing_inbound({:response_format=>:load_from_solr})
-      test_object2_from_solr.testing
-      test_object3_from_solr.testing_inbound
-    end
-  
-    it 'when a load_from_solr is not set it should not call load_instance_from_solr for finders unless passing option in' do
-      @test_object2 = MockAFBaseFromSolr.new
-      @test_object2.save
-      @test_object3 = MockAFBaseFromSolr.new
-      @test_object3.save
-      @test_object2.testing_append(@test_object3)
-      @test_object2.save
-      
-      MockAFBaseFromSolr.expects(:load_instance_from_solr).never()
-      @test_object2.testing
-      @test_object3.testing_inbound
-      
-      #now try calling with option
-      MockAFBaseFromSolr.expects(:load_instance_from_solr).twice()
-      @test_object2.testing({:response_format=>:load_from_solr})
-      @test_object3.testing_inbound({:response_format=>:load_from_solr})
-      
-      #now call other finder method
-      MockAFBaseFromSolr.expects(:load_instance_from_solr).twice()
-      @test_object2.testing_from_solr
-      @test_object3.testing_inbound_from_solr
-      
-    end
+#   describe '#load_instance_from_solr' do
+#     it 'should populate an instance of an ActiveFedora::Base object using solr instead of Fedora' do
+#       
+#       @test_object2 = MockAFBaseFromSolr.new
+# #      @test_object2.new_object = true
+#       attributes = {"holding_id"=>{0=>"Holding 1"},
+#                     "language"=>{0=>"Italian"},
+#                     "creator"=>{0=>"Linguist, A."},
+#                     "geography"=>{0=>"Italy"},
+#                     "title"=>{0=>"Italian and Spanish: A Comparison of Common Phrases"}}
+#       @test_object2.update_indexed_attributes(attributes)
+#       @test_object2.save
+#       @test_object3 = MockAFBaseFromSolr.new
+# #      @test_object3.new_object = true
+#       attributes = {"holding_id"=>{0=>"Holding 2"},
+#                     "language"=>{0=>"Spanish;Latin"},
+#                     "creator"=>{0=>"Linguist, A."},
+#                     "geography"=>{0=>"Spain"},
+#                     "title"=>{0=>"A study of the evolution of Spanish from Latin"}}
+#       @test_object3.update_indexed_attributes(attributes)
+#       @test_object3.save
+#       @test_object4 = MockAFBaseFromSolr.new
+#       attributes = {"holding_id"=>{0=>"Holding 3"},
+#                     "language"=>{0=>"Spanish;Latin"},
+#                     "creator"=>{0=>"Linguist, A."},
+#                     "geography"=>{0=>"Spain"},
+#                     "title"=>{0=>"An obscure look into early nomadic tribes of Spain"}}
+#       @test_object4.update_indexed_attributes(attributes)
+# #      @test_object4.new_object = true
+#       @test_object4.save
+#       @test_object5 = MockAFBaseFromSolr.new
+# #      @test_object5.new_object = true
+#       @test_object5.save
+#       
+#       #append to named relationship 'testing'
+#       @test_object2.testing_append(@test_object3)
+#       @test_object2.testing2_append(@test_object4)
+#       @test_object5.testing_append(@test_object2)
+#       @test_object5.testing2_append(@test_object3)
+#       @test_object2.save
+#       @test_object5.save
+#       r2 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object2)
+#       r3 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object3)
+#       r4 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object4)
+#       r5 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object5)
+#       model_rel = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>ActiveFedora::ContentModel.pid_from_ruby_class(MockAFBaseFromSolr))
+#       #check inbound correct, testing goes to :has_part and testing2 goes to :has_member
+#       test_from_solr_object2 = MockAFBaseFromSolr.load_instance_from_solr(@test_object2.pid)
+#       test_from_solr_object3 = MockAFBaseFromSolr.load_instance_from_solr(@test_object3.pid)
+#       test_from_solr_object4 = MockAFBaseFromSolr.load_instance_from_solr(@test_object4.pid)
+#       test_from_solr_object5 = MockAFBaseFromSolr.load_instance_from_solr(@test_object5.pid)
+#       
+#       # need to check pid, system create and system modify
+#       test_from_solr_object2.pid.should == @test_object2.pid
+#       test_from_solr_object3.pid.should == @test_object3.pid
+#       test_from_solr_object4.pid.should == @test_object4.pid
+#       test_from_solr_object5.pid.should == @test_object5.pid
+#       
+#       Time.parse(test_from_solr_object2.create_date).should == Time.parse(@test_object2.create_date)
+#       Time.parse(test_from_solr_object3.create_date).should == Time.parse(@test_object3.create_date)
+#       Time.parse(test_from_solr_object4.create_date).should == Time.parse(@test_object4.create_date)
+#       Time.parse(test_from_solr_object5.create_date).should == Time.parse(@test_object5.create_date)
+#       
+#       Time.parse(test_from_solr_object2.modified_date).should == Time.parse(@test_object2.modified_date)
+#       Time.parse(test_from_solr_object3.modified_date).should == Time.parse(@test_object3.modified_date)
+#       Time.parse(test_from_solr_object4.modified_date).should == Time.parse(@test_object4.modified_date)
+#       Time.parse(test_from_solr_object5.modified_date).should == Time.parse(@test_object5.modified_date)
+# 
+#       # need to test outbound and inbound relationships
+#       test_from_solr_object2.relationships(false).should == {:self=>{:has_model=>[model_rel.object],
+#                                                             :has_part=>[r3.object],
+#                                                             :has_member=>[r4.object]},
+#                                                     :inbound=>{:has_part=>[r5.object]}}
+#       test_from_solr_object2.relationships_by_name(false).should == {:self=>{"testing"=>[r3.object],"testing2"=>[r4.object],
+#         "collection_members"=>[],"part_of"=>[],"parts_outbound"=>[r3.object]},
+#         :inbound=>{"testing_inbound"=>[r5.object],"testing_inbound2"=>[],"parts_inbound"=>[]}}
+#       test_from_solr_object3.relationships(false).should == {:self=>{:has_model=>[model_rel.object]},
+#                                                    :inbound=>{:has_part=>[r2.object],
+#                                                                :has_member=>[r5.object]}}
+#       test_from_solr_object3.relationships_by_name(false).should == {:self=>{"testing"=>[],"testing2"=>[], "collection_members"=>[],"part_of"=>[],"parts_outbound"=>[]},
+#                                                                    :inbound=>{"testing_inbound"=>[r2.object],"testing_inbound2"=>[r5.object], "parts_inbound"=>[]}}                                                                  
+#       test_from_solr_object4.relationships(false).should == {:self=>{:has_model=>[model_rel.object]},
+#                                                     :inbound=>{:has_member=>[r2.object]}}
+#       test_from_solr_object4.relationships_by_name(false).should == {:inbound=>{"parts_inbound"=>[], "testing_inbound"=>[], "testing_inbound2"=>[r2.object]}, :self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}}                       
+#       test_from_solr_object5.relationships(false).should == {:self=>{:has_model=>[model_rel.object],
+#                                                             :has_part=>[r2.object],
+#                                                             :has_member=>[r3.object]},
+#                                                     :inbound=>{}}
+#       test_from_solr_object5.relationships_by_name(false).should == {:inbound=>{"parts_inbound"=>[], "testing_inbound"=>[], "testing_inbound2"=>[]}, :self=>{"testing2"=>[r3.object], "collection_members"=>[], "part_of"=>[], "testing"=>[r2.object], "parts_outbound"=>[r2.object]}}
+#       #all inbound should now be empty if no parameter supplied to relationships
+#       test_from_solr_object2.relationships.should == {:self=>{:has_part=>[r3.object],:has_member=>[r4.object],:has_model=>[model_rel.object]}}
+#       test_from_solr_object2.relationships_by_name.should == {:self=>{"testing2"=>[r4.object], "collection_members"=>[], "part_of"=>[], "testing"=>[r3.object], "parts_outbound"=>[r3.object]}}
+#       test_from_solr_object3.relationships.should == {:self=>{:has_model=>[model_rel.object]}}
+#       test_from_solr_object3.relationships_by_name.should == {:self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}}
+#       test_from_solr_object4.relationships.should == {:self=>{:has_model=>[model_rel.object]}}
+#       test_from_solr_object4.relationships_by_name.should == {:self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}} 
+#       test_from_solr_object5.relationships.should == {:self=>{:has_model=>[model_rel.object],
+#                                                              :has_part=>[r2.object],
+#                                                              :has_member=>[r3.object]}}
+#       test_from_solr_object5.relationships_by_name.should == {:self=>{"testing2"=>[r3.object], "collection_members"=>[], "part_of"=>[], "testing"=>[r2.object], "parts_outbound"=>[r2.object]}}
+#       # need to check metadata
+#       test_from_solr_object2.fields[:language][:values].should == ["Italian"]
+#       test_from_solr_object2.fields[:creator][:values].should == ["Linguist, A."]
+#       test_from_solr_object2.fields[:geography][:values].should == ["Italy"]
+#       test_from_solr_object2.fields[:title][:values].should == ["Italian and Spanish: A Comparison of Common Phrases"]
+#       test_from_solr_object2.fields[:holding_id][:values].should == ["Holding 1"]
+#       
+#       test_from_solr_object3.fields[:language][:values].should == ["Spanish;Latin"]
+#       test_from_solr_object3.fields[:creator][:values].should == ["Linguist, A."]
+#       test_from_solr_object3.fields[:geography][:values].should == ["Spain"]
+#       test_from_solr_object3.fields[:title][:values].should == ["A study of the evolution of Spanish from Latin"]
+#       test_from_solr_object3.fields[:holding_id][:values].should == ["Holding 2"]
+#       
+#       test_from_solr_object4.fields[:language][:values].should == ["Spanish;Latin"]
+#       test_from_solr_object4.fields[:creator][:values].should == ["Linguist, A."]
+#       test_from_solr_object4.fields[:geography][:values].should == ["Spain"]
+#       test_from_solr_object4.fields[:title][:values].should == ["An obscure look into early nomadic tribes of Spain"]
+#       test_from_solr_object4.fields[:holding_id][:values].should == ["Holding 3"]
+# 
+#       #need to check system modified and system created values correct
+#       # need to implement for nokogiri datastream as well
+#       #false.should == true
+#     end
+#   end
+#   
+#   describe 'load_from_solr using relationship finders'
+#     it 'resulting finder should accept :load_from_solr as :response_format and return object instantiated using load_instance_from_solr' do
+# #      solr_result = mock("solr result")
+# #      SpecNode.create_inbound_relationship_finders("constituents", :is_constituent_of, :inbound => true)
+# #      local_node = SpecNode.new
+# #      mock_repo = mock("repo")
+# #      mock_repo.expects(:find_model).never
+# #      SpecNode.expects(:load_instance_from_solr).times(1)
+# #      local_node.expects(:internal_uri).returns("info:fedora/test:sample_pid")
+# #      ActiveFedora::SolrService.instance.conn.expects(:query).with("is_constituent_of_s:info\\:fedora/test\\:sample_pid").returns(solr_result)
+# #      local_node.constituents(:response_format => :solr).should equal(solr_result)
+#     end
+#     
+#     it 'when an object is loaded via solr instead of fedora it should automatically load objects from finders from solr as well' do
+#       @test_object2 = MockAFBaseFromSolr.new
+#       @test_object2.save
+#       @test_object3 = MockAFBaseFromSolr.new
+#       @test_object3.save
+#       @test_object2.testing_append(@test_object3)
+#       @test_object2.save
+#       
+#       test_object2_from_solr = MockAFBaseFromSolr.load_instance_from_solr(@test_object2.pid)
+#       test_object3_from_solr = MockAFBaseFromSolr.load_instance_from_solr(@test_object3.pid)
+#       MockAFBaseFromSolr.expects(:load_instance_from_solr).times(4)
+#       test_object2_from_solr.testing({:response_format=>:load_from_solr})
+#       test_object3_from_solr.testing_inbound({:response_format=>:load_from_solr})
+#       test_object2_from_solr.testing
+#       test_object3_from_solr.testing_inbound
+#     end
+#   
+#     it 'when a load_from_solr is not set it should not call load_instance_from_solr for finders unless passing option in' do
+#       @test_object2 = MockAFBaseFromSolr.new
+#       @test_object2.save
+#       @test_object3 = MockAFBaseFromSolr.new
+#       @test_object3.save
+#       @test_object2.testing_append(@test_object3)
+#       @test_object2.save
+#       
+#       MockAFBaseFromSolr.expects(:load_instance_from_solr).never()
+#       @test_object2.testing
+#       @test_object3.testing_inbound
+#       
+#       #now try calling with option
+#       MockAFBaseFromSolr.expects(:load_instance_from_solr).twice()
+#       @test_object2.testing({:response_format=>:load_from_solr})
+#       @test_object3.testing_inbound({:response_format=>:load_from_solr})
+#       
+#       #now call other finder method
+#       MockAFBaseFromSolr.expects(:load_instance_from_solr).twice()
+#       @test_object2.testing_from_solr
+#       @test_object3.testing_inbound_from_solr
+#       
+#     end
 
 end