divshare 0.1.0 → 0.3.0

data/{License.txt → LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2007 Eric Watson
+Copyright (c) 2007-2009 Eric Watson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,4 +1,34 @@
-require 'config/requirements'
-require 'config/hoe' # setup Hoe + all gem configuration
+begin
+  require "spec/rake/spectask"
+  desc "Run all specs"
+  Spec::Rake::SpecTask.new('spec') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.libs = ['spec', 'lib']
+    t.spec_opts = ["-c", "-f s"]
+    t.ruby_opts = ["-r rubygems"] # If you want to use rubygems for requires
+  end
+rescue LoadError
+  puts "RSpec not available. Can't run specs without it. Install with: sudo gem install rspec"
+end
 
-Dir['tasks/**/*.rake'].each { |rake| load rake }
+task :default => :spec
+
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name            = "divshare"
+    gemspec.description     = "A Ruby interface to the DivShare file hosting service"
+    gemspec.summary         = "A Ruby interface to the DivShare file hosting service"
+    gemspec.date            = Time.now.strftime("%Y-%m-%d")
+    gemspec.files           = ["README", "LICENSE", "VERSION", "Rakefile", Dir::glob("lib/**/**")].flatten
+    gemspec.authors         = ["Eric Watson"]
+    gemspec.email           = "wasnotrice@gmail.com"
+    gemspec.homepage        = "http://github.com/wasnotrice/divshare"
+    gemspec.rubyforge_project = "divshare"
+
+    gemspec.add_dependency "hpricot"
+    gemspec.add_dependency "mime-types"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/lib/divshare.rb

@@ -1,4 +1 @@
 require 'divshare/client'
-require 'divshare/divshare_file'
-require 'divshare/post_args'
-require 'divshare/errors'

data/lib/divshare/client.rb

@@ -1,11 +1,11 @@
-require 'rubygems'
 require 'cgi'
 require 'net/http'
 require 'hpricot'
 require 'digest/md5'
-require 'divshare/errors'
 require 'divshare/divshare_file'
-require 'divshare/post_args'
+require 'divshare/encoder'
+require 'divshare/errors'
+require 'divshare/multipart'
 require 'divshare/user'
 
 module Divshare
@@ -18,19 +18,49 @@ module Divshare
   #   client.logout
   #
   class Client
+    
+    API_URL = 'http://www.divshare.com/api/'
+    UPLOAD_URL = 'http://upload.divshare.com'
+    UPLOAD_PATH = '/api/upload'
+    
     SUCCESS = '1'
     FAILURE = '0'
   
-    attr_reader :api_key, :api_secret, :post_url, :api_session_key, :email, :password
+    attr_accessor :debug # If true, extended debugging information is printed
+
+    def initialize(key, secret)
+      @encoder = Encoder.new(key, secret)
+      # @debug = true
+    end
+    
+    def key
+      @encoder.key
+    end
     
-    # Creates a Divshare::Client. The <tt>api_key</tt> and <tt>api_secret</tt>
-    # are required, but <tt>email</tt> and <tt>password</tt> are optional. If
-    # you omit <tt>email</tt> and <tt>password</tt> here, you must send them
-    # with link:login when you call it.
-    def initialize(api_key, api_secret, email=nil, password=nil)
-      @api_key, @api_secret, @email, @password = api_key, api_secret, email, password
-      @api_session_key = nil
-      @post_url = "http://www.divshare.com/api/"
+    def secret
+      @encoder.secret
+    end
+
+    def session_key
+      @encoder.session_key
+    end
+    
+    def login(email, password)
+      logout if @encoder.session_key
+      response = send_method(:login, {'user_email' => email, 'user_password' => password})
+      @encoder.session_key = response.at(:api_session_key).inner_html
+    end
+
+    # Returns true if logout is successful. 
+    def logout
+      response = send_method(:logout)
+      debug response.to_html
+      if response[:status] == SUCCESS
+        @encoder.session_key = nil
+        true
+      else
+        false
+      end
     end
 
     # file_ids should be an array of file ids
@@ -45,8 +75,8 @@ module Divshare
     # logged-in user.
     def get_files(file_ids)
       file_ids = [file_ids] unless file_ids.is_a? Array
+      debug "DivShare.get_files(): #{file_ids.class}"
       files = get_user_files
-      puts file_ids.class
       files.delete_if {|f| file_ids.include?(f.file_id) == false}
     end
     
@@ -57,8 +87,9 @@ module Divshare
       get_files(file_id).first
     end
 
-    # Returns an array of Divshare::DivshareFile objects belonging to the logged-in user. Use <tt>limit</tt> and
-    # <tt>offset</tt> to narrow things down.
+    # Returns an array of Divshare::DivshareFile objects belonging to the
+    # logged-in user. Use <tt>limit</tt> and <tt>offset</tt> to narrow things
+    # down.
     def get_user_files(limit=nil, offset=nil)
       args = {}
       args['limit'] = limit unless limit.nil?
@@ -67,8 +98,8 @@ module Divshare
       files_from response
     end
     
-    # Returns an array of Divshare::DivshareFile objects in the specified folder. Use <tt>limit</tt> and
-    # <tt>offset</tt> to narrow things down. 
+    # Returns an array of Divshare::DivshareFile objects in the specified
+    # folder. Use <tt>limit</tt> and <tt>offset</tt> to narrow things down. 
     def get_folder_files(folder_id, limit=nil, offset=nil)
       args = {}
       args['limit'] = limit unless limit.nil?
@@ -80,51 +111,63 @@ module Divshare
 
     # Returns information about the logged-in user
     def get_user_info
-      response = send_method :get_user_info
-      user_from response
+      response = send_method(:get_user_info)
+      user_from(response)
     end
     
     # Returns an upload ticket string for use in uploading files. See
     # http://www.divshare.com/integrate/api#uploading for more information on
     # how to use the upload ticket once you've got it.
     def get_upload_ticket
-      response = send_method :get_upload_ticket
-      upload_ticket_from response
+      send_method(:get_upload_ticket).at(:upload_ticket).inner_html
     end
 
-    # Login to the Divshare service. Raises Divshare::APIError if login is
-    # unsuccessful.
-    def login(email=nil, password=nil)
-      logout if @api_session_key
-      email ||= @email
-      password ||= @password
-      response = send_method(:login, {'user_email' => email, 'user_password' => password})
-      if response.at(:api_session_key)
-        @api_session_key = response.at(:api_session_key).inner_html
-      else
-        raise Divshare::APIError, "Couldn't log in. Received: \n" + response.to_s
-      end
-    end
+    # Uploads a file or files to the user's DivShare account, and returns the
+    # file id(s). 
+    #
+    # The DivShare API is written for use with actual HTML forms, so the API
+    # method requires a 'response_url', and makes a GET request to that url,
+    # sending the file id(s) as query parameters.
+    #
+    # Here, we're simulating the form, so we parse DivShare's GET request and
+    # simply return the file id(s). In this case, response_url is just a 
+    # filler so that the server doesn't complain.
+    def upload(ticket, file_path, response_url='www.divshare.com/upload_result')      
+      location = nil
+      File.open(file_path, 'r') { |file|
+        uri = URI.parse(UPLOAD_URL)
+        http = Net::HTTP.new(uri.host, uri.port)
+        # API methods can be SLOW. Timeout interval should be long.
+        http.read_timeout = 15*60
+        request = Net::HTTP::Post.new(UPLOAD_PATH)
+        fields = Hash.new
+        fields['upload_ticket'] = ticket
+        # API doesn't allow blank response_url. This is just filler.
+        fields['response_url'] = response_url
 
-    # Returns true if logout is successful. Raises Divshare::APIError if logout is
-    # unsuccessful.
-    def logout
-      response = send_method(:logout)
-      if response.at(:logged_out) && (%w(true 1).include? response.at(:logged_out).inner_html)
-        @api_session_key = nil
+        fields['file1'] = file
+        request.multipart_params = fields
+        # Until DivShare supports direct upload API, we deal with its response location field
+        location = http.request(request)['location']
+      }
+      
+      # if error, throw, otherwise return file ID for caller to do whatever they like
+      resp = {}
+      location.split('?')[1].split('&').each { |param| 
+        k, v = param.split('=', 2)  # some params could contain two '=' for some reason
+        resp[k]=CGI.unescape(v)
+      }
+      if resp['error']
+        raise Divshare::APIError, resp['description']
       else
-        raise Divshare::APIError, "Couldn't log out. Received: \n" + response.to_s
+        resp['file1']   # return the file ID
       end
-      true
     end
 
-    # Generates the required MD5 signature as described in
-    # http://www.divshare.com/integrate/api#sig
-    def sign(method, args)
-      Digest::MD5.hexdigest(string_to_sign(args))
-    end
+
 
     private
+    
     def files_from(xml)
       xml = xml/:file
       xml = [xml] unless xml.respond_to?(:each)    
@@ -136,11 +179,6 @@ module Divshare
       Divshare::User.new(xml)
     end
     
-    def upload_ticket_from(xml)
-      xml = xml.at(:upload_ticket).inner_html
-    end
-    
-    # Since login and logout aren't easily re-nameable to use method missing
     def send_method(method_id, *params)
       response = http_post(method_id, *params)
       xml = Hpricot(response).at(:response)
@@ -149,44 +187,30 @@ module Divshare
         raise Divshare::APIError, errors.join("\n")
       end
       xml
-    end      
-    
-    def post_args(method, args)
-      PostArgs.new(self, method, args)
     end
-    
+
     def http_post(method, args={})
-      url = URI.parse(@post_url)
+      url = URI.parse(API_URL)
       tries = 3
       response = ""
+      form_args = @encoder.encode(method, args)
       begin
-        response = Net::HTTP.post_form(url, post_args(method, args)).body
+        response = Net::HTTP.post_form(url, form_args).body
       rescue
         tries -= 1
-          puts "Tries == '#{tries}'"
+          debug "DivShare\#http_post() failed: #{tries} tries remaining"
         if tries > 0
           retry
         else
-          raise Divshare::ConnectionError, "Couldn't connect for '#{method}' using #{post_args(method, args)}"
+          raise Divshare::ConnectionError, "Couldn't connect to #{API_URL} for '#{method}' using #{form_args.inspect}"
         end
       end
       response
     end
-    
-    # From http://www.divshare.com/integrate/api
-    #
-    # * Your secret key is 123-secret. 
-    # * Your session key is 456-session. 
-    # * You are using the get_user_files method, and you're sending the
-    #   parameters limit=5 and offset=10.
-    #
-    # The string used to create your signature will be:
-    # 123-secret456-sessionlimit5offset10. Note that the parameters must be in
-    # alphabetical order, so limit always comes before offset. Each parameter
-    # should be paired with its value as shown.
-    def string_to_sign(args)
-      args_for_string = args.dup.delete_if {|k,v| %w(api_key method api_sig api_session_key).include?(k) }
-      "#{@api_secret}#{@api_session_key}#{args_for_string.to_a.sort.flatten.join}"
+   
+    # Outputs whatever is given to $stderr if debugging is enabled.
+    def debug(*args)
+      $stderr.puts(sprintf(*args)) if @debug
     end
   end
-end
+end

data/lib/divshare/divshare_file.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'hpricot'
 
 module Divshare
@@ -64,11 +63,10 @@ module Divshare
     def find_medium
       ext = @file_name ? File.extname(@file_name) : nil
       medium = case
-        when AUDIO.match(ext): "audio"
-        when VIDEO.match(ext): "video"
-        when DOCUMENT.match(ext): "document"
-        when IMAGE.match(ext): "image"
-        else nil
+        when AUDIO.match(ext) then "audio"
+        when VIDEO.match(ext) then "video"
+        when DOCUMENT.match(ext) then "document"
+        when IMAGE.match(ext) then "image"
       end
     end
     
@@ -102,11 +100,10 @@ module Divshare
     
     def image_embed_tag_template(opts={:size=>:midsize})
       size = case opts[:size]
-        when :midsize, :mid:     "midsize/"
-        when :thumb, :thumbnail: "thumb/"
-        else ""
-      end
+        when :midsize, :mid     then "midsize/"
+        when :thumb, :thumbnail then "thumb/"
+      end || ""
       tag = "http://www.divshare.com/img/#{size}[FILE ID]"
     end
   end
-end
+end

data/lib/divshare/encoder.rb

@@ -0,0 +1,50 @@
+module Divshare
+  
+  # Manages the arguments send along with a POST to the DivShare API URL.
+  # Takes care of organizing arguments and generating API signatures for
+  # requests 
+  class Encoder # :nodoc:
+    attr_reader :key, :secret
+    attr_accessor :session_key
+
+    def initialize(key, secret)
+      @key, @secret = key, secret
+    end
+    
+    # Prepares arguments for a post using the given method and arguments.
+    # Returns a hash of arguments and values
+    def encode(method, args={})
+      # Stringifies incoming keys and values
+      post_args = Hash.new
+      args.each { |k, v| post_args[k.to_s] = v.to_s }
+      post_args.merge!({'method' => method.to_s, 'api_key' => @key.to_s})
+      if @session_key
+        sig = sign(post_args)
+        post_args.merge!({'api_session_key' => @session_key.to_s, 'api_sig' => sig})
+      end
+      post_args
+    end
+
+    # Generates the required MD5 signature as described in
+    # http://www.divshare.com/integrate/api#sig
+    def sign(args)
+      Digest::MD5.hexdigest(string_to_sign(args))
+    end
+    
+    # From http://www.divshare.com/integrate/api
+    #
+    # * Your secret key is 123-secret. 
+    # * Your session key is 456-session. 
+    # * You are using the get_user_files method, and you're sending the
+    #   parameters limit=5 and offset=10.
+    #
+    # The string used to create your signature will be:
+    # 123-secret456-sessionlimit5offset10. Note that the parameters must be in
+    # alphabetical order, so limit always comes before offset. Each parameter
+    # should be paired with its value as shown.
+    def string_to_sign(args)
+      args_for_string = args.dup.delete_if {|k,v| %w(api_key method api_sig api_session_key).include?(k) }
+      "#{@secret}#{@session_key}#{args_for_string.to_a.sort.flatten.join}"
+    end
+  end
+end

data/lib/divshare/multipart.rb

@@ -0,0 +1,37 @@
+# This is based on this article from Pivot Labs:
+# http://pivots.pivotallabs.com/users/damon/blog/articles/227-standup-04-27-07-testing-file-uploads
+
+require 'net/https'
+require "mime/types" # Requires gem install mime-types
+
+module Net #:nodoc:all
+  class HTTP::Post
+    def multipart_params=(param_hash={})
+      boundary_token = [Array.new(8) {rand(256)}].join
+      self.content_type = "multipart/form-data; boundary=#{boundary_token}"
+      boundary_marker = "--#{boundary_token}\r\n"
+      self.body = param_hash.map { |param_name, param_value|
+        boundary_marker + case param_value
+        when File
+          file_to_multipart(param_name, param_value)
+        else
+          text_to_multipart(param_name, param_value.to_s)
+        end
+      }.join('') + "--#{boundary_token}--\r\n"
+    end
+
+    protected
+    def file_to_multipart(key,file)
+      filename = File.basename(file.path)
+      mime_types = MIME::Types.of(filename)
+      mime_type = mime_types.empty? ? "application/octet-stream" : mime_types.first.content_type
+      part = %Q|Content-Disposition: form-data; name="#{key}"; filename="#{filename}"\r\n|
+      part += "Content-Transfer-Encoding: binary\r\n"
+      part += "Content-Type: #{mime_type}\r\n\r\n#{file.read}\r\n"
+    end
+
+    def text_to_multipart(key,value)
+      "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n#{value}\r\n"
+    end
+  end
+end

data/spec/client_spec.rb

@@ -1,175 +1,150 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require 'spec_helper'
 require 'divshare/client'
 include Divshare
 
 module ClientSpecHelper
   include DivshareMockXML
-  def new_client
-    Client.new('api_key', 'api_secret')
-  end
-
-  def new_client_with_email_and_password
-    Client.new('api_key', 'api_secret', 'email', 'password')
-  end
-  
-  def login(client, api_session_key='123-abcdefghijkl')
-    client.stub!(:login).and_return(api_session_key)
-    client.instance_variable_set(:@api_session_key, client.login)
-    api_session_key
-  end
-  
+ 
   # Each setup must declare what @mock_response will return
-  def common_setup(opts={})
-    options = {:login => true, :stub_sign => true}.merge(opts)
-    @client = new_client
-    @api_session_key = login(@client) if options[:login]
+  def common_setup()
+    @api_key = 'api_key'
+    @api_secret = 'api_secret'
+    @api_session_key = '123-abcdefghijkl'
+    @user_email = 'fake_user_email'
+    @password = 'fake_password'
     @files = ['2734485-1fc', '2735059-62d']
-    if opts[:stub_sign]
-      @api_sig = 'api_sig'
-      @client.stub!(:sign).and_return(@api_sig)
-    end
+    @api_url = URI.parse(Divshare::Client::API_URL)
+  end
+  
+  def no_login_setup
     @mock_response = mock('response')
-    Net::HTTP.stub!(:post_form).and_return(@mock_response)
+    Net::HTTP.should_receive(:post_form).once.and_return(@mock_response)       
+    @client = Client.new(@api_key, @api_secret)
   end
   
-  def basic_post_args(to_merge={})
-    {'api_key' => 'api_key', "api_sig" => @api_sig, "api_session_key" => @api_session_key}.merge(to_merge)
+  def login_setup
+    @mock_response = mock('response')
+    @mock_login_response = mock('login_response')
+    Net::HTTP.should_receive(:post_form).twice.and_return(@mock_login_response, @mock_response)   
+    @mock_login_response.should_receive(:body).and_return(successful_login_xml)
+    @client = Client.new(@api_key, @api_secret)
+    @client.login(@user_email, @password)
   end
 end
 
 describe "A new Divshare Client" do
   include ClientSpecHelper
-
-  it "should be created with api key and secret only" do
-    new_client.should be_instance_of(Divshare::Client)
+  before :all do
+    common_setup
   end
   
-  it "should be created with api key, api_secret, email, and password" do
-    new_client_with_email_and_password.should be_instance_of(Divshare::Client)
+  before :each do
+    @client = Client.new(@api_key, @api_secret)
   end
-  
-  it "should assign api key, api_secret, email, and password correctly" do
-    client = new_client_with_email_and_password
-    [client.api_key, client.api_secret, client.email, client.password].should == ['api_key', 'api_secret', 'email', 'password']
+
+  it "should be created successfully" do
+    @client.should be_instance_of(Divshare::Client)
   end
   
   it "should know the proper post url" do
-    new_client.post_url.should == "http://www.divshare.com/api/"
-  end
-  
-  # Using string 'api_secret123-abcdefghijklfiles2734485-1fc'
-  it "should generate a correct signature" do
-    api_sig = '0e1c483506dd413808c80183333e1fc2'
-    common_setup(:stub_sign => false)
-    @client.sign("get_files", {"files" => @files.first}).should == api_sig
+    Divshare::Client::API_URL.should == "http://www.divshare.com/api/"
   end
   
   it "should raise Divshare::ConnectionError on timeout" do
-    # Net::HTTP.should_receive(:post_form).once.and_raise
-    Net::HTTP.stub!(:post_form).and_raise(Net::HTTPServerError)
-    lambda { new_client_with_email_and_password.login }.should raise_error(Divshare::ConnectionError)
+    pending 'Timeout code implementation'
+    lambda { @client.login('email', 'password') }.should raise_error(Divshare::ConnectionError)
   end
   
 end
 
+describe Divshare::Client, "making a request to the API" do
+  # spec the request format. This should suffice for all requests.
+  
+end
+
 describe "A Divshare Client getting one file" do
   include ClientSpecHelper
-  before(:each) do
+  before(:all) do
     common_setup
   end
-
-  # If it generates a PostArgs object, it's doing the right thing
-  it "should generate arguments for post" do
-    pending("Fix to API that allows correct get_files method")
-    @mock_response.should_receive(:body).and_return(get_one_file_xml)
-    PostArgs.should_receive(:new).with(@client,:get_files,{'files' => @files.first})
-    @client.get_files(@files.first)
-  end
   
   it "should return an array of one DivshareFile when requesting a file through get_files" do
+    login_setup
     @mock_response.should_receive(:body).and_return(get_one_file_xml)
     @client.get_files('123456-abc').map {|f| f.class}.should == [DivshareFile]
   end
   
   it "should return a DivshareFile when requesting a file through get_file" do
+    login_setup
     @mock_response.should_receive(:body).and_return(get_one_file_xml)
     @client.get_file('123456-abc').class.should == DivshareFile
   end
   
   it "should raise ArgumentError if an array is passed to get_file" do
+    @client = Client.new(@api_key, @api_secret)
     lambda {@client.get_file(['123456-abc'])}.should raise_error(ArgumentError)
   end
 end
 
 describe "A Divshare Client getting two files" do
   include ClientSpecHelper
-  before(:each) do
+  before(:all) do
     common_setup
   end
 
+  before :each do
+    login_setup
+    @mock_response.should_receive(:body).and_return(get_two_files_xml)
+  end
+
   it "should return an array of two DivshareFiles" do
-    mock_response = mock('response')
-    Net::HTTP.stub!(:post_form).and_return(mock_response)
-    mock_response.should_receive(:body).and_return(get_two_files_xml)
     @client.get_files(['123456-abc', '456789-def']).map {|f| f.class}.should == [DivshareFile, DivshareFile]
   end
 end
 
 describe "A Divshare Client getting user files" do
   include ClientSpecHelper
-  before(:each) do
+  before :all do
    common_setup
-   @mock_response.should_receive(:body).and_return(get_two_files_xml)
+  end
+
+  before :each do
+    login_setup
+    @mock_response.should_receive(:body).and_return(get_two_files_xml)
   end
 
   it "should return an array of files" do
     @client.get_user_files.map {|f| f.class }.should == [DivshareFile, DivshareFile]
   end
-  
-  # If it generates a PostArgs object, it's doing the right thing
-  it "should generate arguments for post" do
-    PostArgs.should_receive(:new).with(@client,:get_user_files, {})
-    @client.get_user_files
-  end
-  
-  it "should generate arguments for post with limit and offset" do
-    PostArgs.should_receive(:new).with(@client, :get_user_files, {"limit" => 5, "offset" => 2})
-    @client.get_user_files(5, 2)
-  end
-  
 end
 
 describe "A Divshare Client getting folder files" do
   include ClientSpecHelper
-  before(:each) do
+  before :all do
    common_setup
-   @mock_response.should_receive(:body).and_return(get_two_files_xml)
   end
 
-  it "should return an array of files" do
-    @client.get_folder_files('12345').map {|f| f.class }.should == [DivshareFile, DivshareFile]
-  end
-  
-  # If it generates a PostArgs object, it's doing the right thing
-  it "should generate arguments for post" do
-    PostArgs.should_receive(:new).with(@client,:get_folder_files, {'folder_id' => '12345'})
-    @client.get_folder_files('12345')
+  before :each do
+    login_setup
+    @mock_response.should_receive(:body).and_return(get_two_files_xml)
   end
 
-  it "should generate arguments for post with limit and offset" do
-    PostArgs.should_receive(:new).with(@client, :get_folder_files, {'folder_id' => '12345', "limit" => 5, "offset" => 2})
-    @client.get_folder_files('12345', 5, 2)
+  it "should return an array of files" do
+    @client.get_folder_files('12345').map {|f| f.class }.should == [DivshareFile, DivshareFile]
   end
-  
-
 end
 
 describe "A Divshare Client, creating an upload ticket" do
   include ClientSpecHelper
-  before(:each) do
+  before :all do
     common_setup
+  end
+
+  before :each do
+    login_setup
     @mock_response.should_receive(:body).and_return(get_upload_ticket_xml)
   end
+  
   it "should return an upload ticket" do
     @client.get_upload_ticket.should == '123-abcdefghijkl'
   end
@@ -177,45 +152,60 @@ end
 
 describe "A Divshare Client, logging in" do
   include ClientSpecHelper
-  before(:each) do
-    common_setup(:login => false)
-    @api_session_key = login(new_client)
-    @mock_response.should_receive(:body).and_return(successful_login_xml)
+  before :all do
+    common_setup
   end
 
-  it "should login" do
-    @client.login.should == @api_session_key
+  before :each do
+    no_login_setup
+    @mock_response.should_receive(:body).and_return(successful_login_xml)
   end
-  
+
   it "should set api session key" do
-    @client.api_session_key.should be_nil
-    @client.login
-    @client.api_session_key.should == @api_session_key
+    @client.session_key.should_not == @api_session_key
+    @client.login(@user_email, @password)
+    @client.session_key.should == @api_session_key
   end
 end
 
 describe "A DivshareClient, unsuccessfully logging in" do
   include ClientSpecHelper
   it "should raise Divshare::APIError" do
-    common_setup(:login => false)
+    common_setup
+    no_login_setup
     @mock_response.should_receive(:body).and_return(error_xml("Couldn't log in"))
-    lambda {@client.login}.should raise_error(Divshare::APIError)
+    lambda {@client.login(@user_email, @password)}.should raise_error(Divshare::APIError)
   end
 end
 
-describe "A Divshare Client, logging out" do
+describe "A Divshare Client, successfully logging out" do
   include ClientSpecHelper
-  before(:each) do
+  before :all do
     common_setup
+  end
+
+  before :each do
+    login_setup
     @mock_response.should_receive(:body).and_return(successful_logout_xml)
   end
 
-  it "should logout" do
+  it "should return true" do
     @client.logout.should be_true
   end
-  
-  it "should remove api session key on logout" do
+
+  it "should remove api session key" do
     @client.logout
-    @client.api_session_key.should be_nil
+    @client.session_key.should be_nil
+  end
+end
+
+describe "A Divshare Client, unsuccessfully logging out" do
+  include ClientSpecHelper
+  
+  it "should return false" do
+    common_setup
+    login_setup
+    @mock_response.should_receive(:body).and_return(unsuccessful_logout_xml)
+    lambda {@client.logout}.should raise_error(Divshare::APIError)
   end
 end