sword2ruby 1.0.0

data/lib/sword2ruby/rexml_element.rb

@@ -0,0 +1,79 @@
+require 'rexml/element'
+
+module Sword2Ruby
+
+  #Overloads for the rdf:Description tag (REXML::Element), used for describing OAI-ORE Sword Statements.
+  #
+  #For more information, see the Sword2 specification: {section 11.3. "OAI-ORE Serialisation"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_oaiore].
+  class  ::REXML::Element
+
+     #This method returns the string value of the @rdf:about attribute for the <rdf:Description> element (i.e. for each element in the Sword2Ruby::SwordStatementOAIORE#rdf_descriptions array, usually contained in the OAI-ORE Sword Statement),
+     #or nil if it is not defined.
+     #
+     #For more information, see the Sword2 specification: {section 11.3. "OAI-ORE Serialisation"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_oaiore].
+     def rdf_about
+       self.attributes["rdf:about"]
+     end
+
+     #This method returns the string value of the @rdf:resource attribute for the <sword:originalDepsit> tag (usually contained in the OAI-ORE Sword Statement),
+     #or nil if it is not defined.
+     #
+     #For more information, see the Sword2 specification: {section 11.1.1. "sword:originalDeposit"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_predicates_originaldeposit].
+     def sword_original_deposit
+       Utility.find_element_attribute_value(self.elements, "sword:originalDeposit", "rdf:resource")
+     end
+     
+     #This method returns the string value of the @rdf:resource attribute of the <sword:state> tag (usually contained in the OAI-ORE Sword Statement),
+     #or nil if it is not defined.
+     #
+     #For more information, see the Sword2 specification: {section 11.1.2. "sword:state"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_predicates_state].
+     def sword_state
+       Utility.find_element_attribute_value(self.elements, "sword:state", "rdf:resource")
+     end
+
+     
+     
+     #This method returns an array of the string values of the @rdf:resource attribute for the <sword:packaging> tags (usually contained in the OAI-ORE Sword Statement),
+     #or an empty array [ ] if none are defined.
+     #
+     #For more information, see the Sword2 specification: {section 11.1.3. "sword:packaging"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_predicates_packaging].
+     def sword_packagings
+       Utility.find_elements_attribute_value(self.elements, "sword:packaging", "rdf:resource")
+     end
+
+     #This method returns the Time value of the <sword:depositedOn> tag (usually contained in the OAI-ORE Sword Statement),
+     #or nil if it is not defined.
+     #
+     #For more information, see the Sword2 specification: {section 11.1.4. "sword:depositedOn"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_predicates_depositedon].
+     def sword_deposited_on
+       Utility.find_element_time(self.elements, "sword:depositedOn")
+     end
+     
+     #This method returns the string value of the <sword:depositedBy> tag (usually contained in the OAI-ORE Sword Statement),
+     #or nil if it is not defined.
+     #
+     #For more information, see the Sword2 specification: {section 11.1.5. "sword:depositedBy"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_predicates_depositedby].
+     def sword_deposited_by
+       Utility.find_element_text(self.elements, "sword:depositedBy")
+     end
+
+     #This method returns the string value of the <sword:depositedOnBehalfOf> tag (usually contained in the OAI-ORE Sword Statement),
+     #or nil if it is not defined.
+     #
+     #For more information, see the Sword2 specification: {section 11.1.6. "sword:depositedOnBehalfOf"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_predicates_obo].
+     def sword_deposited_on_behalf_of
+       Utility.find_element_text(self.elements, "sword:depositedOnBehalfOf")
+     end
+
+
+     #This method returns the string value of the <sword:stateDescription> tag (usually contained in the OAI-ORE Sword Statement),
+     #or nil if it is not defined.
+     #
+     #For more information, see the Sword2 specification: {section 11.1.7. "sword:stateDescription"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_predicates_description].
+     def sword_state_description
+       Utility.find_element_text(self.elements, "sword:stateDescription")
+     end
+
+
+  end
+end

data/lib/sword2ruby/service.rb

@@ -0,0 +1,79 @@
+require 'atom/service'
+
+module Sword2Ruby
+  
+  #Extend existing Atom::Service with Sword methods
+  #
+  #For more information, see the Sword2 specification: {section 6.1. "Retrieving a Service Document"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#protocoloperations_retreivingservicedocument].
+  class ::Atom::Service < ::Atom::Element
+    
+    #This method returns the URI object of the service document.
+    def service_document_uri
+      base.to_s
+    end
+    
+    #This method returns the string value of the <sword:version> tag (usually contained in the Service Document),
+    #or nil if it is not defined.
+    def sword_version
+      Utility.find_element_text(extensions, "sword:version")
+    end
+
+    #This method returns the integer value of the <sword:maxUploadSize> tag (usually contained in the Service Document),
+    #or 0 if it is not defined.     
+    def sword_max_upload_size
+      Utility.find_element_integer(extensions, "sword:maxUploadSize")
+    end
+    
+    #Retrieves and parses an Atom service document.
+    #===Parameters
+    #:\service_uri:: The URI to the Sword Service Document.
+    #:connection:: (optional) Sword2Ruby::Connection object used to perform the operation. If not supplied, a new Connection object will be created.
+    def initialize(service_uri, connection = Connection.new())
+      Utility.check_argument_class('service_uri', service_uri, String)
+      Utility.check_uri(service_uri)
+      Utility.check_argument_class('connection', connection, Connection)
+      
+      
+      super()
+
+      @http = connection
+
+      return if service_uri.empty?
+
+      base = URI.parse(service_uri)
+
+      rxml = nil
+
+      res = connection.get(base, "Accept" => "application/atomsvc+xml")
+      res.validate_content_type(["application/atomsvc+xml"])
+      
+      if res.is_a? Net::HTTPSuccess
+        service = self.class.parse(res.body, base, self)
+
+        #Update workspaces, collections and their feeds to use the Service's http connection
+        set_http(connection)
+
+        service
+      else
+       raise Sword2Ruby::Exception.new("Failed to do get(#{service_uri}): server returned #{res.code} #{res.message}")
+      end
+
+    end
+    
+    
+    private
+    #Update workspaces, collections and their feeds to use the Service's http connection
+    #Unfortunately this is necessary because the atom-tools library does not propagate the
+    #http connection object from Service to Workspace
+    def set_http(connection)
+      workspaces.each do |w|
+        w.http = connection
+        w.collections.each do |c|
+          c.http = connection
+          c.feed.http = connection
+        end
+      end
+    end 
+   
+  end #class
+end #module

data/lib/sword2ruby/sword_accept.rb

@@ -0,0 +1,10 @@
+module Sword2Ruby
+  
+  #This class overrides the Atom <app:accept> class and ensures that the "alternate" attribute
+  #is preserved in the tag, required for processing Sword documents.
+  class SwordAccept < ::Atom::Text
+    is_element ATOM_PUBLISHING_PROTOCOL_NAMESPACE, :accept
+    attrb ATOM_PUBLISHING_PROTOCOL_NAMESPACE, :alternate
+  end
+
+end

data/lib/sword2ruby/sword_statement_oai_ore.rb

@@ -0,0 +1,38 @@
+require 'rexml/document'
+
+module Sword2Ruby
+  #This class models the OAI-ORE Sword Statement.
+  #
+  #For more information, see the Sword2 specification: {section 11.3. "OAI-ORE Serialisation"}[http://sword-app.svn.sourceforge.net/viewvc/sword-app/spec/tags/sword-2.0/SWORDProfile.html?revision=377#statement_oaiore].
+  class SwordStatementOAIORE
+    
+    #The complete statement document, returned as a REXML::Document.
+    attr_reader :statement_document
+    
+    #An array of rdf:descriptions. See the overload methods in REXML::Element for each description's methods.
+    attr_reader :rdf_descriptions
+
+    #Creates a new SwordStatementOAIORE object, using the supplied URI and connection object.
+    #===Parameters
+    #sword_statement_uri:: The URI string to the OAI-ORE Sword Statement.
+    #connection:: Sword2Ruby::Connection object used to perform the operation.
+    def initialize(sword_statement_uri, connection)
+      #Validate parameters
+      Utility.check_argument_class('sword_statement_uri', sword_statement_uri, String)
+      Utility.check_argument_class('connection', connection, Connection)
+      
+      response = connection.get(sword_statement_uri)
+
+      if response.is_a? Net::HTTPSuccess
+         @statement_document = REXML::Document.new(response.body)
+         @rdf_descriptions = []
+         @statement_document.elements.each("/rdf:RDF/rdf:Description") do |description|
+           @rdf_descriptions << description
+         end
+       else
+         raise Sword2Ruby::Exception.new("Failed to do get(#{sword_statement_uri}): server returned code #{response.code} #{response.message}")   
+      end
+    end
+    
+  end
+end

data/lib/sword2ruby/user.rb

@@ -0,0 +1,25 @@
+module Sword2Ruby
+  class User
+  
+    #Username for authenticating with the Sword server
+    attr_accessor :username
+    
+    #On-Behalf-Of username for authenticating with the Sword server
+    attr_accessor :on_behalf_of
+
+    #Password for authenticating with the Sword server
+    attr_accessor :password
+    
+    #Creates a new User object.
+    #===Parameters
+    #username:: (optional) string value of the username.
+    #password:: (optional) string value of the password.
+    #on_behalf_of:: (optional) string value indicating the username on whos behalf the actions will be performed.
+    def initialize(username=nil, password=nil, on_behalf_of=nil)
+      @username = username;
+      @password = password;
+      @on_behalf_of = on_behalf_of;
+    end
+    
+  end #class
+end #module

data/lib/sword2ruby/utility.rb

@@ -0,0 +1,232 @@
+require 'uri'
+require 'digest/md5'
+
+module Sword2Ruby
+  class Utility
+
+    #Method to cast a (typically) string value into a boolean value
+    #===Parameters
+    #value:: the string value to be cast, e.g. "true" or "no"
+    #nil_value:: (optional) value to return if value=nil. If not supplied, this will default to false. Typically used in circumstances when returning something other than false would be preferable if value=nil.
+    def self.to_boolean(value, nil_value = false)
+      value.downcase! if value.class == String
+      case value
+      when "no","false",false, "0", 0
+        false
+      when "yes","true",true, "1", 1
+        true
+      when nil
+        nil_value 
+      else
+        !!value
+      end
+    end 
+
+    #Method to check the supplied argument is the expected class.
+    #===Parameters
+    #name:: the string name of the *argument* parameter, e.g. "update_time" or "username"
+    #argument:: the object to be checked against *expected_class*, e.g. update_time or username
+    #expected_class:: the class used to validate *argument*, e.g. Time or String
+    #It will just return (nothing) if the check passes, or raise an ArgumentError if the check fails. 
+    #===Example
+    # # This is fine
+    # on_behalf_of = "joebloggs"
+    # Utility.check_argument_class('on_behalf_of', on_behalf_of, String)
+    # 
+    # # This will raise an ArgumentError, because on_behalf_of is not a String
+    # on_behalf_of = 12345
+    # Utility.check_argument_class('on_behalf_of', on_behalf_of, String) #Raises an ArgumentError!
+    def self.check_argument_class(name, argument, expected_class)
+      unless argument.is_a? expected_class
+        raise ArgumentError.new("Argument '#{name}=#{argument}' must be of type '#{expected_class}' (and not of type '#{argument.class}')")
+      end
+    end
+    
+    #Method to check the supplied uri uses one of the URI schemes defined in Sword2Ruby::VALID_URI_SCHEMES.
+    #===Parameters
+    #uri:: the string URI to be checked
+    #It will just return (nothing) if the check passes, or raise an InvalidURIError if the check fails.
+    #It will raise an ArgumentError if *uri* is not a String. It wil raise a URI parse error if *uri* could not be parsed.
+    #===Example
+    # # This is fine
+    # Utility.check_uri('http://www.url.com')
+    # 
+    # # This will raise an InvalidURIError, because fishy:// is not a valid URI scheme
+    # Utility.check_uri('fishy://www.url.com')
+    def self.check_uri(uri)
+      self.check_argument_class("uri", uri, String)
+      unless VALID_URI_SCHEMES.include? URI.parse(uri).scheme.downcase.to_sym
+        raise URI::InvalidURIError, "Invalid URI, it must start with either [#{VALID_URI_SCHEMES.join(',')}] (current value: #{uri})"
+      end
+    end
+    
+#Find link methods
+    
+    #Method to return the @href attribute of the Atom::Link found in an array of Atom::Links by its @rel and @type attributes.
+    #===Parameters
+    #links:: an array of Atom::Links
+    #rel:: the string @rel value to search the array for
+    #type:: (optional) the string @type value to search the array for, defaults to nil
+    #It will return the href value of the first link found with matching @rel and @type values, othewise nil.
+    def self.find_link_uri(links, rel, type = nil)
+      links.find(NIL_LAMBDA) {|link| link.rel == rel && link.type == type}.href
+    end
+
+    #Method to return an array of Atom::Links found in an array of Atom::Links by their @rel and @type attributes.
+    #===Parameters
+    #links:: an array of Atom::Links
+    #rel:: the string @rel value to search the array for
+    #type:: (optional) the string @type value to search the array for, defaults to nil
+    #It will return an array of all matching Atom:Links (found with @rel and @type values), othewise an empty array.
+    def self.find_links(links, rel, type = nil)
+      links.find_all{|link| link.rel == rel && link.type == type}
+    end
+    
+    #Method to return an array of Atom::Links found in an array of Atom::Links by their @rel attributes.
+    #===Parameters
+    #links:: an array of Atom::Links
+    #rel:: the string @rel value to search the array for
+    #It will return an array of all matching Atom:Links (found with @rel), othewise an empty array.
+    def self.find_links_all_types(links, rel)
+      links.find_all{|link| link.rel == rel}
+    end
+    
+    
+#Find single element methods
+
+    #Method to return the first Atom::Element found in an array of Atom::Elements by its name.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #name:: the expanded name of the element to search for, e.g. "sword:state" or "sword:verboseDescription"
+    #It will return the first element found with a matching name, othewise nil.
+    def self.find_element_by_name(elements, name)
+      elements.find(NIL_LAMBDA) {|e| e.fully_expanded_name == name}
+    end
+
+    #Method to return the text value of first Atom::Element found in an array of Atom::Elements by its name.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #name:: the expanded name of the element to search for, e.g. "sword:state" or "sword:verboseDescription"
+    #It will return the text value of first element found with a matching name, othewise nil.    
+    def self.find_element_text(elements, name)
+      find_element_by_name(elements, name).text
+    end
+    
+    #Method to return the integer value of first Atom::Element found in an array of Atom::Elements by its name.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #name:: the expanded name of the element to search for, e.g. "sword:state" or "sword:verboseDescription"
+    #It will return the integer value of first element found with a matching name, othewise 0.
+    def self.find_element_integer(elements, name)
+      find_element_text(elements, name).to_i
+    end
+    
+    #Method to return the boolean value of first Atom::Element found in an array of Atom::Elements by its name.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #name:: the expanded name of the element to search for, e.g. "sword:state" or "sword:verboseDescription"
+    #It will return the boolean value of first element found with a matching name, othewise nil.
+    def self.find_element_boolean(elements, name)
+       self.to_boolean(find_element_text(elements, name), nil)
+    end
+    
+    #Method to return the time value of first Atom::Element found in an array of Atom::Elements by its name.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #name:: the expanded name of the element to search for, e.g. "sword:state" or "sword:verboseDescription"
+    #It will return the time value of first element found with a matching name, othewise nil.
+    def self.find_element_time(elements, name)
+      value = find_element_text(elements, name)
+      value.nil? ? nil : Time.parse(find_element_text(elements, name))
+    end
+    
+    #Method to return the attribute value of first Atom::Element found in an array of Atom::Elements by its name.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #name:: the expanded name of the element to search for, e.g. "sword:state" or "sword:verboseDescription"
+    #attribute_name:: the name of the attribute to return the value of, e.g. "href"
+    #It will return the value of the specified attribute of the first element found with a matching name, othewise nil.
+    def self.find_element_attribute_value(elements, name, attribute_name)
+      elements.find(NIL_LAMBDA) {|e| e.fully_expanded_name == name}.attribute(attribute_name).value
+    end
+    
+    #Method to return the first Atom::Element found in an array of Atom::Elements by its scheme and term.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #scheme:: the scheme of the element to search for, e.g. "http://purl.org/net/sword/terms/"
+    #term:: the term of the element to search for, e.g. "http://purl.org/net/sword/terms/originalDeposit"
+    #It will return the first element found with a matching scheme and term, othewise nil.
+    def self.find_element_by_scheme_and_term(elements, scheme, term)
+      elements.find {|e| e.scheme == scheme && e.term == term}
+    end
+    
+    #Method to return the first Atom::Element found in an array of Atom::Elements with a matching @href attribute.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #href:: the value of the @href attribute of the element to search for, e.g. "http://purl.org/net/sword/terms/originalDeposit"
+    #It will return the first element found with a matching href attribute, othewise nil.
+    def self.find_element_by_href(elements, href)
+      elements.find {|e| e.href == href}
+    end
+    
+    
+#Find multiple elements
+    
+    #Method to return an array of text values of matching Atom::Elements found in an array of Atom::Elements by their name.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #name:: the expanded name of the element(s) to search for, e.g. "sword:state" or "sword:verboseDescription"
+    #It will return an array of the text values of elements found with a matching name, othewise an empty array [ ].
+    def self.find_elements_text(elements, name)
+      elements.find_all {|e| e.fully_expanded_name==name}.collect {|e| e.text}
+    end
+
+    #Method to return an array of attribute values of matching Atom::Elements found in an array of Atom::Elements by their name.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #name:: the expanded name of the element(s) to search for, e.g. "sword:state" or "sword:verboseDescription"
+    #attribute_name:: the name of the attributes to return the value of, e.g. "href"
+    #It will return an array of the attribute values of elements found with a matching name, othewise an empty array [ ].    
+    def self.find_elements_attribute_value(elements, name, attribute_name)
+      elements.find_all {|e| e.fully_expanded_name==name}.collect {|e| e.attribute(attribute_name).value}
+    end
+
+    #Method to return an array of matching Atom::Elements found in an array of Atom::Elements by their namespace.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #namespace:: the namespace to search for, e.g. "http://purl.org/dc/terms/"
+    #It will return an array of Atom::Elements found with a matching namespace, othewise an empty array [ ].    
+    def self.find_elements_by_namespace(elements, namespace)
+      elements.find_all {|e| e.namespace == namespace}
+    end
+    
+  
+    #Method to return an array of matching Atom::Elements found in an array of Atom::Elements by their namespace.
+    #===Parameters
+    #elements:: an array of Atom::Elements
+    #scheme:: the scheme to search for, e.g. "http://purl.org/net/sword/terms/state"
+    #It will return an array of Atom::Elements found with a matching scheme, othewise an empty array [ ].
+    def self.find_elements_by_scheme(elements, scheme)
+      elements.find_all {|e| e.scheme == scheme}
+    end
+    
+    #Method to return the filename, MD5 hash and filedata of the supplied filepath.
+    #===Parameters
+    #filepath:: path to an existing file which must be readable to the Ruby process. 
+    #Returns an array of the form [filename, md5_digest, data]
+    def self.read_file(filepath) 
+      data = nil
+      File.open(filepath,'r') do |file|
+        data = file.gets(nil) #Read entire file, no Base64.encode64()
+      end #file is closed automatically
+      return [File.basename(filepath), Digest::MD5.hexdigest(data), data]
+    end
+    
+#:nodoc:    
+private 
+    def initialize()
+      super
+    end
+    
+  end #class
+end #module

data/lib/sword2ruby/version.rb

@@ -0,0 +1,4 @@
+module Sword2Ruby
+  #The version of the Sword2Ruby library
+  VERSION = "1.0.0"
+end

data/lib/sword2ruby.rb

@@ -0,0 +1,32 @@
+require "sword2ruby/version"
+require "sword2ruby/constant"
+require "sword2ruby/utility"
+require "sword2ruby/exception"
+
+require "sword2ruby/user"
+require "sword2ruby/connection"
+require "sword2ruby/auto_discover"
+
+require "sword2ruby/rexml_element"
+require "sword2ruby/element"
+require "sword2ruby/entry"
+require "sword2ruby/sword_accept"
+require "sword2ruby/deposit_receipt"
+require "sword2ruby/feed"
+require "sword2ruby/collection"
+require "sword2ruby/service"
+
+require "sword2ruby/sword_statement_oai_ore"
+
+#Sword2Ruby module
+module Sword2Ruby
+
+
+   #Extensions to the {Atom module}[https://github.com/bct/atom-tools/wiki] to support Sword2 operations.
+   #These methods are additive to those supplied by the atom-tools gem.
+   #
+   #For more information on the {Atom module}[https://github.com/bct/atom-tools/wiki], please see the {atom-tools documentation}[http://rdoc.info/github/bct/atom-tools/master/frames] for a complete list of attributes and methods.
+  module Atom
+    
+  end
+end

data/spec/auto_discover_spec.rb

@@ -0,0 +1,30 @@
+#auto_discover_spec.rb
+
+require 'test_constants'
+
+
+describe Sword2Ruby::AutoDiscover do
+  
+  it "Testing AutoDiscover on Service html" do
+    autodiscover = Sword2Ruby::AutoDiscover.new(TEST_AUTODISCOVER_SERVICE_HTML_URI)
+
+    #Test that the service_document_uri was found
+    autodiscover.service_document_uri.should_not be_nil
+  end
+
+  it "Testing AutoDiscover on Collection html" do
+    autodiscover = Sword2Ruby::AutoDiscover.new(TEST_AUTODISCOVER_COLLECTION_HTML_URI)
+    
+    #Test that the collection deposit_endpoint_uri was found
+    autodiscover.deposit_endpoint_uri.should_not be_nil
+  end
+  
+  it "Testing AutoDiscover on Entry html" do
+    autodiscover = Sword2Ruby::AutoDiscover.new(TEST_AUTODISCOVER_ENTRY_HTML_URI)
+    
+    #Test that the collection deposit_endpoint_uri was found
+    autodiscover.entry_edit_uris.count.should > 0
+    autodiscover.sword_statement_links.count.should > 0
+  end
+  
+end

data/spec/collection_spec.rb

@@ -0,0 +1,33 @@
+#collection_spec.rb
+
+require 'test_constants'
+
+describe ::Atom::Collection do
+
+  it "Get the test collection, post an entry to it" do
+    current_collection = ::Atom::Collection.new(TEST_COLLECTION_HREF, TEST_CONNECTION_VALID)
+    current_collection.should_not be_nil 
+    current_collection.href.should == TEST_COLLECTION_HREF
+    current_collection.collection_uri.should == TEST_COLLECTION_HREF
+    
+    current_feed = current_collection.feed
+    current_feed.update!
+    current_feed.entries.count.should >= 0
+    
+    entry = Atom::Entry.new()
+    entry.title = "Test Entry created by Sword2Ruby Collection test"
+    entry.summary = "This entry was created during a test on #{Time.now}"
+    entry.updated = Time.now
+      
+    #Generate a slug based on the date and time
+    current_slug = "sword2ruby_test_#{Time.now.strftime("%FT%H-%M-%S")}"
+
+    deposit_receipt = current_collection.post!(:entry=>entry, :slug=>current_slug, :in_progress=>false)
+
+    #There SHOULD be a deposit receipt entry received from the Sword server
+    deposit_receipt.has_entry.should == true
+    deposit_receipt.entry.should_not be_nil
+    
+  end
+  
+end

data/spec/connection_spec.rb

@@ -0,0 +1,21 @@
+#connection_spec.rb
+require 'test_constants'
+
+
+describe Sword2Ruby::Connection do
+  
+    it "initialise without parameters" do
+      connection = Sword2Ruby::Connection.new()
+      connection.user.should == nil
+    end
+  
+    it "initialise with invalid parameters" do
+      expect{Sword2Ruby::Connection.new(12345)}.to raise_error(ArgumentError);
+    end
+        
+    it "try to retrieve malformed URI" do
+      expect{TEST_CONNECTION_VALID.get(TEST_SERVICE_DOCUMENT_URI_MALFORMED)}.to raise_error(URI::InvalidURIError);
+    end
+    
+    
+end