active-fedora 3.0.7 → 3.1.0.pre1

data/lib/fedora/formats.rb

@@ -1,30 +0,0 @@
-module Fedora
-  module XmlFormat
-    extend self
-    
-    def extension
-      "xml"
-    end
-    
-    def mime_type
-      "text/xml"
-    end
-    
-    def encode(hash)
-      hash.to_xml
-    end
-    
-    def decode(xml)
-      from_xml_data(Hash.from_xml(xml))
-    end
-    
-    private
-      def from_xml_data(data)
-        if data.is_a?(Hash) && data.keys.size == 1
-          data.values.first
-        else
-          data
-        end
-      end      
-  end
-end

data/lib/fedora/generic_search.rb

@@ -1,71 +0,0 @@
-# 
-#  @Creator Matt Zumwalt, MediaShelf LLC
-#  @Copyright Matt Zumwalt, 2007.  All Rights Reserved.
-#
- 
-module Fedora
-  class GenericSearch
-  
-    def initialize(uri, service_name)
-      @uri = "#{uri}/#{service_name}"
-      @client = HTTPClient.new(@uri)
-      @extheader = {'User-Agent'=>"RubyFedora"}
-    end
-  
-    def call_resource
-    
-    end
-  
-    # TODO: Handle ruby-tyle params, camel-casing them before passing to call_resource...
-    def update_index(params)
-      query = {:action=>action,:value=>value,:repositoryName=>repository_name,:indexName=>indexname,:restXslt=>"copyXML"}.merge(params)
-      query.merge {:operation> "updateIndex"}
-    
-      @client.get(@uri, query, @extheader)
-      return "update_index Not Implemented."
-    end
-  
-  
-    def browse_index(params)
-      # Sample: /fedoragsearch/rest?operation=browseIndex&startTerm=&fieldName=PID&termPageSize=20&indexName=FedoraIndex&restXslt=copyXml&resultPageXslt=browseIndexToResultPage
-      query = {:startTerm=>URLEncoder.encode(start_term, "UTF-8"),:fieldName=>"",:indexName=>"",:termPageSize=>"", :restXslt=>"copyXml", :resultPageXslt=>""}.merge(params)
-      query.merge {:operation> "browseIndex"}
-      @client.get(@uri, query, @extheader)
-      return "browse_index Not Implemented."
-    end
-  
-    def gfind_objects(params)
-      # Sample: /fedoragsearch/rest?operation=gfindObjects&query=test&hitPageSize=10&restXslt=copyXml
-      # fieldMaxLength limits the number of characters returned from the value of each object field.
-      # Snippets will highlight matched words within the search results.  To keep the xml as simple as possible, set snippetsMax to 0.
-      query = {:query=>URLEncoder.encode(query, "UTF-8"),:value=>value,:indexName=>indexname,:hitPageStart=>"",:hitPageSize=>"",:snippetsMax=>"0",:fieldMaxLength=>"",:restXslt=>"copyXML",:resultPageXslt=>""}.merge(params)
-      query.merge {:operation> "gfindObjects"}
-      @client.get(@uri, query, @extheader)
-      return "gfind_objects Not Implemented."
-    end
-  
-    def get_index_info(params)
-      # Sample: /fedoragsearch/rest?operation=getIndexInfo&restXslt=copyXml
-      query = {:indexName=>"",:restXslt=>"copyXml", :resultPageXslt=>""}.merge(params)
-      query.merge {:operation> "getIndexInfo"}
-      @client.get(@uri, query, @extheader)
-      return "get_index_info Not Implemented."
-    end
-  
-    def get_repository_info(params)
-      # Sample: /fedoragsearch/rest?operation=getRepositoryInfo&restXslt=copyXml
-      query = {:repositoryName=>"",:restXslt=>"copyXml", :resultPageXslt=>""}.merge(params)
-      query.merge {:operation> "getRepositoryInfo"}
-      @client.get(@uri, query, @extheader)
-      return "get_repository_info Not Implemented."
-    end
-  
-    def configure(params)
-      query = {:configName=>""}.merge(params)
-      query.merge {:operation> "configure"}
-      @client.get(@uri, query, @extheader)
-      return "configure Not Implemented."
-    end
-  
-  end
-end

data/lib/fedora/repository.rb

@@ -1,298 +0,0 @@
-
-require 'fedora/base'
-require 'fedora/connection'
-require 'fedora/formats'
-require 'fedora/fedora_object'
-require 'fedora/datastream'
-require "nokogiri"
-
-module Fedora
-  NAMESPACE = "fedora:info/"
-  ALL_FIELDS = [
-    :pid, :label, :fType, :cModel, :state, :ownerId, :cDate, :mDate, :dcmDate, 
-    :bMech, :title, :creator, :subject, :description, :contributor,
-    :date, :type, :format, :identifier, :source, :language, :relation, :coverage, :rights 
-  ]
-  
-  class Repository
-    
-    attr_accessor :repository_name, :base_url, :fedora_version, :pid_namespace, :pid_delimiter
-    
-    def self.flush
-      Thread.current[:repo]=nil
-    end
-    def self.register(url, surrogate=nil)
-      url = url.to_s.chop if url.to_s =~ /\/\Z/
-      Thread.current[:repo]= Fedora::Repository.new(url, surrogate)
-      begin
-        repo = Thread.current[:repo]
-        attributes = repo.describe_repository
-        repo.repository_name = attributes["repositoryName"].first
-        repo.base_url = attributes["repositoryBaseURL"].first
-        repo.fedora_version = attributes["repositoryVersion"].first
-        repo.pid_namespace = attributes["repositoryPID"].first["PID-namespaceIdentifier"].first
-        repo.pid_delimiter = attributes["repositoryPID"].first["PID-delimiter"].first
-      rescue
-      end
-      Thread.current[:repo]
-    end
-    def self.instance
-      raise "did you register a repo?" unless Thread.current[:repo]
-      Thread.current[:repo]
-    end
-    class StringResponse < String
-      attr_reader :content_type
-      
-      def initialize(s, content_type)
-        super(s)
-        @content_type = content_type
-      end
-    end
-    
-    attr_accessor :fedora_url
-
-    def initialize(fedora_url, surrogate=nil)
-      @fedora_url = fedora_url.is_a?(URI) ? fedora_url : URI.parse(fedora_url)
-      @surrogate = surrogate
-      @connection = nil
-    end
-    
-    # Fetch the raw content of either a fedora object or datastream
-    def fetch_content(object_uri)
-      response = connection.raw_get("#{url_for(object_uri)}?format=xml")
-      StringResponse.new(response.body, response.content_type)
-    end
-    
-
-    
-    # Find fedora objects with http://www.fedora.info/wiki/index.php/API-A-Lite_findObjects
-    #
-    # == Parameters
-    # query<String>:: the query string to be sent to Fedora.
-    # options<Hash>:: see below
-    #
-    # == Options<Hash> keys
-    # limit<String|Number>:: set the maxResults parameter in fedora
-    # select<Symbol|Array>:: the fields to returned.  To include all fields, pass :all as the value.
-    #                           The field "pid" is always included.
-    #
-    # == Examples
-    #    find_objects("label=Image1")
-    #    find_objects("pid~demo:*", "label=test")
-    #    find_objects("label=Image1", :include => :all)
-    #    find_objects("label=Image1", :include => [:label])
-    #-
-    def find_objects(*args)
-      raise ArgumentError, "Missing query string" unless args.length >= 1
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      
-      fields = options[:select]
-      fields = (fields.nil? || (fields == :all)) ? ALL_FIELDS : ([:pid] + ([fields].flatten! - [:pid]))
-      
-      query = args.join(' ')
-      params = { :resultFormat => 'xml', :query => query }
-      params[:maxResults] = options[:limit] if options[:limit]
-      params[:sessionToken] = options[:sessionToken] if options[:sessionToken]
-      includes = fields.inject("") { |s, f| s += "&#{f}=true"; s }
-      
-      convert_xml(connection.get("#{fedora_url.path}/objects?#{params.to_fedora_query}#{includes}"))
-    end
-    
-    # Retrieve an object from fedora and load it as an instance of the given model/class
-    #
-    # @param pid of the Fedora object to retrieve and deserialize
-    # @param klazz the Model whose deserialize method the object's FOXML will be passed into
-    def find_model(pid, klazz)
-      obj = self.find_objects("pid=#{pid}").first
-      if obj.nil?
-        raise ActiveFedora::ObjectNotFoundError, "The repository does not have an object with pid #{pid}.  The repository URL is #{self.base_url}"
-      end
-      doc = Nokogiri::XML::Document.parse(obj.object_xml)     
-      klazz.deserialize(doc)
-    end
-    
-    # Create the given object if it's new (not obtained from a find method).  Otherwise update the object.
-    #
-    # == Return
-    # boolean:: whether the operation is successful
-    #-
-    def save(object)
-      object.new_object? ? create(object) : update(object)
-    end
-
-    def nextid(attrs={})
-      request_url = fedora_url.path+"/management/getNextPID?xml=true"
-      request_url += "&namespace=#{attrs[:namespace]}" if attrs[:namespace]
-      d = REXML::Document.new(connection.post(request_url).body)
-      d.elements['//pid'].text
-    end
-
-  
-    def create(object)
-      case object
-        when Fedora::FedoraObject
-          pid = (object.pid ? object : 'new')
-          response = connection.post("#{url_for(pid)}?" + object.attributes.to_fedora_query, object.blob)
-          if response.code == '201'
-            object.pid = extract_pid(response) 
-            object.new_object = false
-            true
-          else
-            false
-          end
-        when Fedora::Datastream
-          raise ArgumentError, "Missing dsID attribute" if object.dsid.nil?
-          extra_headers = {}
-          extra_headers['Content-Type'] = object.attributes[:mimeType] if object.attributes[:mimeType]
-          response = connection.post("#{url_for(object)}?" + object.attributes.to_fedora_query, 
-            object.blob, extra_headers)
-          if response.code == '201'
-            object.new_object = false
-            true
-          else
-            false
-          end
-        else
-          raise ArgumentError, "Unknown object type"
-      end
-      
-    end
-  
-    # Update the given object
-    # == Return
-    # boolean:: whether the operation is successful
-    #-
-    def update(object)
-      raise ArgumentError, "Missing pid attribute" if object.nil? || object.pid.nil?
-      case object
-      when Fedora::FedoraObject
-        response = connection.put("#{url_for(object)}?" + object.attributes.to_fedora_query)
-        response.code == '200' || '307'
-      when Fedora::Datastream
-        raise ArgumentError, "Missing dsID attribute" if object.dsid.nil?
-        response = connection.put("#{url_for(object)}?" + object.attributes.to_fedora_query, object.blob)
-        response.code == '200' || '201'
-        return response.code
-      else
-        raise ArgumentError, "Unknown object type"
-      end
-    end
-  
-    # Delete the given pid
-    # == Parameters
-    # object<Object|String>:: The object to delete.  
-    #       This can be a uri String ("demo:1", "fedora:info/demo:1") or any object that responds uri method.
-    #
-    # == Return
-    # boolean:: whether the operation is successful
-    #-
-    def delete(object)
-      raise ArgumentError, "Object must not be nil" if object.nil?
-      response = connection.delete("#{url_for(object)}")
-      response.code == '200' or response.code == '204'  # Temporary hack around error in Fedora 3.0 Final's REST API
-    end
-    
-    # Export the given object
-    # == Parameters
-    # object<String|Object>:: a fedora uri, pid, FedoraObject instance
-    # method<Symbol>::        the method to fetch such as :export, :history, :versions, etc
-    # extra_params<Hash>::    any other extra parameters to pass to fedora
-    #
-    def export(object, extra_params={})
-      extra_params = {:format=>:foxml, :context=>:archive}.merge!(extra_params)
-      if extra_params[:format].kind_of?(String)
-        format = extra_params[:format]
-      else
-        format = case extra_params[:format]
-          when :atom then "info:fedora/fedora-system:ATOM-1.1"
-          when :atom_zip then "info:fedora/fedora-system:ATOMZip-1.1"
-          when :mets then "info:fedora/fedora-system:METSFedoraExt-1.1"
-          when :foxml then "info:fedora/fedora-system:FOXML-1.1"
-          else "info:fedora/fedora-system:FOXML-1.1"
-        end
-      end
-      fetch_custom(object, "export", :format=>format, :context=>extra_params[:context].to_s)
-    end
-    
-    def ingest(content_to_ingest, extra_params={})
-      if extra_params[:pid]
-        url = url_for(extra_params[:pid])
-      else
-        url = url_for("new")
-      end
-      
-      if content_to_ingest.kind_of?(File) 
-        content_to_ingest = content_to_ingest.read
-      end
-        
-      connection.post(url,content_to_ingest)
-    end
-
-    # Fetch the given object using custom method.  This is used to fetch other aspects of a fedora object,
-    # such as profile, versions, etc...
-    # == Parameters
-    # object<String|Object>:: a fedora uri, pid, FedoraObject instance
-    # method<Symbol>::        the method to fetch such as :export, :history, :versions, etc
-    # extra_params<Hash>::    any other extra parameters to pass to fedora
-    #
-    # == Returns
-    # This method returns raw xml response from the server
-    #-
-    def fetch_custom(object, method, extra_params = { :format => 'xml' })
-      path = case method
-        when :profile then ""
-        else "/#{method}"
-      end
-      
-      extra_params.delete(:format) if method == :export
-      connection.raw_get("#{url_for(object)}#{path}?#{extra_params.to_fedora_query}").body
-    end
-    
-    def describe_repository
-      result_body = connection.raw_get("#{fedora_url.path}/describe?xml=true").body
-      XmlSimple.xml_in(result_body)
-    end
-    
-  private
-    def convert_xml(response)
-      results = FedoraObjects.new
-      return results unless response && response['resultList']
-
-      results.session_token = response['listSession']['token'] if response['listSession']
-      objectFields = response['resultList']['objectFields']
-      case objectFields
-        when Array
-          objectFields.each { |attrs| results << FedoraObject.new(attrs.rekey!) }
-        when Hash
-          results << FedoraObject.new(objectFields.rekey!)
-      end
-      results.each {|result| result.new_object = false}
-      results
-    end
-    
-    def url_for(object)
-      uri = object.respond_to?(:uri) ? object.uri : object.to_s
-      uri = (uri[0..NAMESPACE.length-1] == NAMESPACE ? uri[NAMESPACE.length..-1] : uri) # strip of fedora:info namespace
-      "#{fedora_url.path}/objects/#{uri}"
-    end
-    
-    # Low level access to the remote fedora server
-    # The +refresh+ parameter toggles whether or not the connection is refreshed at every request
-    # or not (defaults to +false+).
-    def connection(refresh = false)
-      if refresh || @connection.nil?
-        @connection = Fedora::Connection.new(@fedora_url, Fedora::XmlFormat, @surrogate)
-      end
-      @connection
-    end
-    
-    def extract_pid(response)
-      CGI.unescape(response['Location'].split('/').last)
-    end
-  end
-end
-
-class FedoraObjects < Array
-  attr_accessor :session_token
-end
-

data/spec/integration/datastreams_crud_spec.rb

@@ -1,208 +0,0 @@
-require File.join( File.dirname(__FILE__),  "../spec_helper" )
-# Datastream API:
-#  - To list datastream
-#    curl -i http://localhost:8080/fedora/objects/test:02/datastreams
-#    curl -i http://localhost:8080/fedora/objects/test:02/datastreams?format=xml
-#    
-#    invalid: curl -i http://localhost:8080/fedora/objects/test:02/datastreams.xml
-#    
-#  - To obtain a datastream
-#    curl -i http://localhost:8080/fedora/objects/test:02/datastreams/DC
-#    curl -i http://localhost:8080/fedora/objects/test:02/datastreams/DS1
-# 
-#  - To create create a new datastream
-#  
-#  regular post (always creates inline (I) datastream.  Will fail if not valid XML):
-#    curl -i -H "Content-type: text/xml" -XPOST --data-binary @build.xml -u fedoraAdmin:fedoraAdmin "http://localhost:8080/fedora/objects/test:02/datastreams/DS1?dsLabel=A%20Test%20Datastream&altIDs=3333" 
-# 
-#  "E" and "R" datastreams
-#    curl -i -H "Content-type: text/html" -XPOST "http://localhost:8080/fedora/objects/test:02/datastreams/REDIRECT?dsLabel=A%20Redirect%20Datastream&altIDs=3333&controlGroup=R&dsLocation=http://www.yourmediashelf.com" -u fedoraAdmin:fedoraAdmin
-#    curl -i -H "Content-type: text/html" -XPOST "http://localhost:8080/fedora/objects/test:02/datastreams/EXT?dsLabel=A%20Ext%20Datastream&altIDs=3333&controlGroup=E&dsLocation=http://www.yahoo.com" -u fedoraAdmin:fedoraAdmin   
-#    
-#  multipart/form-data (always creates managed content (M) datastream):
-#    curl -i -H -XPOST -F file=@build.xml -u fedoraAdmin:fedoraAdmin "http://localhost:8080/fedora/objects/test:02/datastreams/DS3?dsLabel=hello&altIDs=3333" 
-#    curl -i -H -XPOST -F file=@dino.jpg -u fedoraAdmin:fedoraAdmin "http://localhost:8080/fedora/objects/test:02/datastreams/JPEG?dsLabel=hello&altIDs=3333" 
-#  MIME Type is set according to Content Type Header:
-#    curl -i -H -XPOST -F "file=@01 Float On.m4a;type=audio/mp4a-latm"  -u fedoraAdmin:fedoraAdmin "http://localhost:8080/fedora/objects/test:02/datastreams/Float_On.m4a?dsLabel=hello&altIDs=3333" 
-#    curl -i -H -XPOST -F "file=@educause2004Fedora.ppt;type=application/vnd.ms-powerpoint"  -u fedoraAdmin:fedoraAdmin "http://localhost:8080/fedora/objects/test:02/datastreams/PPT.ppt?dsLabel=hello&altIDs=3333" 
-#  
-#  mutipart/related is also supported but can only be tested with xform clients.
-#  
-#  - To update a datastream
-#    curl -i -H "Content-type: text/xml" -XPUT "http://localhost:8080/fedora/objects/test:02/datastreams/DS1?dsLabel=hello&altIDs=3333" --data-binary @build.xml -u fedoraAdmin:fedoraAdmin
-#    curl -i -H "Content-type: text/xml" -XPOST "http://localhost:8080/fedora/objects/test:02/datastreams/DS1?dsLabel=hello&altIDs=3333" --data-binary @build.xml -u fedoraAdmin:fedoraAdmin
-#   
-#  - To delete a datastream 
-#    curl -i -XDELETE "http://localhost:8080/fedora/objects/test:02/datastreams/DS1" -u fedoraAdmin:fedoraAdmin
-# 
-#    curl -i -H -XPOST -F file=@test/fixtures/minivan-in-minneapolis.jpg  -u fedoraAdmin:fedoraAdmin "http://localhost:8080/fedora/objects/test:test_xml_post/datastreams/FOO" 
-# 
-#    curl -i -XDELETE -u admin:muradora "http://localhost:9090/fedora/objects/test:test:test_object_1" 
-#  
-#    curl -i -H "Content-type: text/xml" -XPOST --data-binary @test/fixtures/mods-mskcc-filledsample.xml -u fedoraAdmin:fedoraAdmin "http://localhost:9090/fedora/objects/test:02/datastreams/DS1?dsLabel=A%20Test%20Datastream" 
-# 
-#    curl -i -H "Content-type: image/jpeg" -XPOST -F file=@test/fixtures/dino.jpg -u admin:muradora "http://localhost:9090/fedora/objects/test:02/datastreams/DINO?dsLabel=A%20Test%20Datastream"
-describe Fedora::Repository do
-  def sample_mods
-    xml = <<-EOS
-    <mods:mods xmlns:xlink="http://www.w3.org/1999/xlink" version="3.2"
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mods="http://www.loc.gov/mods/v3"
-        xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"
-        xmlns="http://www.w3.org/1999/xhtml">
-        <mods:identifier>mskcc:2045</mods:identifier>
-        <mods:titleInfo authority="" displayLabel="">
-            <mods:title>Sample Title</mods:title>
-            <mods:subTitle>Sample SubTitle</mods:subTitle>
-        </mods:titleInfo>
-        <mods:name type="personal" authority="" ID="owner">
-        	<mods:namePart type="family">Smith</mods:namePart>
-    	<mods:namePart type="given">John</mods:namePart>
-    	<mods:namePart type="termsOfAddress">Mr.</mods:namePart>
-             <mods:affiliation>Surgery</mods:affiliation>
-            <mods:role>
-                <mods:roleTerm type="text" authority="">Owner</mods:roleTerm>
-            </mods:role>
-        </mods:name>
-        <mods:name type="personal" authority="non-owner">
-        	<mods:namePart type="family">Rushdie</mods:namePart>
-    	<mods:namePart type="given">Salman</mods:namePart>
-    	<mods:namePart type="termsOfAddress">Mr.</mods:namePart>
-             <mods:affiliation>Surgery</mods:affiliation>
-            <mods:role>
-                <mods:roleTerm type="text" authority="">Contributor</mods:roleTerm>
-            </mods:role>
-        </mods:name>
-        <mods:originInfo>
-            <mods:place>
-                <mods:placeTerm type="text">Sample Place of Creation</mods:placeTerm>
-            </mods:place>
-            <mods:publisher>MSKCC</mods:publisher>
-            <mods:dateIssued encoding="" keydate="" qualifier="" point=""/>
-            <mods:dateCreated encoding="" keydate="" qualifier="" point=""/>
-            <mods:dateModified encoding="" keydate="" qualifier="" point=""/>
-            <mods:copyrightDate encoding="" keydate="" qualifier="" point=""/>
-            <mods:dateOther encoding="" keydate="" qualifier="" point=""/>
-        </mods:originInfo>
-        <mods:abstract displayLabel="" type=""></mods:abstract>
-        <mods:note type=""/>
-        <mods:subject authority="lcsh">
-            <mods:topic>carcinoma</mods:topic>
-            <mods:topic>adinoma</mods:topic>
-         </mods:subject>
-        <!-- part, extension -->
-    </mods:mods>    
-    EOS
-  end
-  
-  before(:all) do
-    Fedora::Repository.register(ActiveFedora.fedora_config[:url])
-    @fedora = Fedora::Repository.instance
-  end
-
-  before(:each) do
-    @test_object = Fedora::FedoraObject.new(:label => 'test', 
-      :contentModel => 'Image',
-      :state => 'A',
-      :ownerID => 'fedoraAdmin')
-
-    @fedora.save(@test_object).should be_true
-  end
-  
-  after(:each) do
-    @fedora.delete(@test_object).should be_true
-  end
-  
-  def fetch_content(pid, dsID)
-    content = @fedora.fetch_content("#{pid}/datastreams/#{dsID}/content")
-  end
-  
-  it "should create/update xml datastream" do
-    ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DS1', :dsLabel => 'foo', :altIDs => '3333', 
-      :blob => sample_mods)
-    @fedora.save(ds).should be_true
-    
-    ds.attributes[:dsLabel] = 'bar'
-    @fedora.save(ds).should be_true
-  end
-
-  it "should be able to save file objects" do
-    ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DS1', :dsLabel => 'hello', :altIDs => '3333', 
-      :controlGroup => 'M', :blob => fixture('dino.jpg'))
-      
-    ds.control_group.should == 'M'
-    @fedora.save(ds).should be_true
-  end
-
-  it "should be able to save StringIO objects" do
-    ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DS1', :dsLabel => 'hello', :altIDs => '3333', :controlGroup => 'M', :blob => StringIO.new("hi there"))
-      
-    @fedora.save(ds).should be_true
-end
-  
-  it "should create/update image/file datastream" do
-    ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DS1', :dsLabel => 'hello', :altIDs => '3333', 
-      :controlGroup => 'M', :blob => fixture('dino.jpg').read, :mimeType=>'image/jpeg')
-      
-    @fedora.save(ds).should be_true
-    
-    content = fetch_content(@test_object.pid, 'DS1')
-    content.content_type.should == 'image/jpeg'
-        
-    ds.blob = fixture('minivan.jpg')
-    @fedora.save(ds).should be_true
-  end
-
-  it "should set controlGroup to 'M' if mimeType is specified" do
-    ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DS1', :dsLabel => 'foo',
-      :mimeType => 'text/plain', :blob => "This is plain text")
-  end
-  
-  it "should create datastream with custom mimeType for text blob" do
-    blob = "This is plain text"
-    ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DS1', :dsLabel => 'foo',
-      :mimeType => 'text/plain', :blob => blob)
-    @fedora.save(ds).should be_true
-    
-    content = @fedora.fetch_content("#{@test_object.pid}/datastreams/DS1/content")
-    content.should == blob
-    content.content_type.should == 'text/plain'
-  end
-  
-  it "should create datastream with custom mimeType for file blob" do
-    blob = "This is plain text"
-    ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DS1', :dsLabel => 'foo',
-      :mimeType => 'image/jpeg', :blob => fixture('dino.jpg'))
-    @fedora.save(ds).should be_true
-    
-    content = fetch_content(@test_object.pid, "DS1")
-    content.content_type.should == 'image/jpeg'
-  end
-  
-  it "should delete datastream by ref" do
-    ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DS1', :dsLabel => 'foo', :altIDs => '3333', :blob => sample_mods)
-    @fedora.save(ds).should be_true
-    @fedora.delete(ds).should be_true
-  end
-  
-  it "should delete datastream by uri" do
-    ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DS1', :dsLabel => 'foo', :altIDs => '3333', :blob => sample_mods)
-    @fedora.save(ds).should be_true    
-    @fedora.delete(ds.uri).should be_true
-  end
-  
-  it "should fetch thumbnail jpg for Image of Coliseum in Rome" do
-    # Have to check for two possible sizes because the image size changed between Fedora 3.0 and Fedora 3.1
-    fetch_content("demo:26", "TEI_SOURCE").length.should satisfy{ |l| l == 1098 || 1086}
-  end
-  
-  describe ".label" do
-    it "should apply to the dsLabel when you save the datastream" do 
-      ds = Fedora::Datastream.new(:pid => @test_object.pid, :dsID => 'DSLabelTest', :blob => sample_mods)
-      ds.label = "My Test dsLabel"
-      @fedora.save(ds)
-      object_rexml = REXML::Document.new(@test_object.object_xml)
-      #puts object_rexml.root.elements["foxml:datastream[@ID='DSLabelTest']/foxml:datastreamVersion"].inspect
-      object_rexml.root.elements["foxml:datastream[@ID='DSLabelTest']/foxml:datastreamVersion[last()]"].attributes["LABEL"].should == ds.label
-    end
-  end
-end