pietern-simpleflickr 0.2.2

data/History.txt

@@ -0,0 +1,7 @@
+== 0.2.2 2009-01-26
+
+* Moved to Jeweler for gemspec managment.
+
+== 0.2.1 2009-01-13
+
+* Used newgem to generate a Rakefile that is used to build a gemspec.

data/Manifest.txt

@@ -0,0 +1,21 @@
+History.txt
+MIT-LICENSE
+Manifest.txt
+README.rdoc
+Rakefile
+lib/simpleflickr.rb
+lib/simpleflickr/authentication/authentication.rb
+lib/simpleflickr/authentication/desktop.rb
+lib/simpleflickr/authentication/web.rb
+lib/simpleflickr/base.rb
+lib/simpleflickr/http.rb
+lib/simpleflickr/query.rb
+simpleflickr.gemspec
+spec/feeds/auth.getFrob.xml
+spec/feeds/auth.getToken.xml
+spec/flickr/auth_spec.rb
+spec/flickr/base_spec.rb
+spec/flickr/query_spec.rb
+spec/rcov.opts
+spec/spec.opts
+spec/spec_helper.rb

data/README.rdoc

@@ -0,0 +1,140 @@
+= Introduction
+Made as an abstraction to the Flickr API in an extensible way. Where other libraries fully implement the API, this one doesn't. This library signs your requests and performs the HTTP request. Furthermore, it provides you an easy way to authenticate your users.
+
+= Usage
+SimpleFlickr allows you to do authenticated and non-authenticated requests. If you only plan to do non-authenticated requests, skip the section on authentication and read on at "Example request".
+
+In either case, assume we have the following class defined:
+  class SomeClient < SimpleFlickr::Base
+    api_key 'my_key'
+    secret  'my_secret'
+  end
+
+== Authentication
+For doing authenticated requests you first need to request a token for the user. SimpleFlickr implements two methods of Flickr authentication, being web- and desktop-authentication.
+
+You can read up on the process at http://www.flickr.com/services/api/misc.userauth.html
+
+For both methods, you need to generate an URL for the user to visit and authenticate your app. When generating this URL, you can specify what access level you need. This can be either <tt>:read</tt>, <tt>:write</tt>, or <tt>:delete</tt>, and defaults to <tt>:read</tt>.
+
+=== Web Authentication
+
+  web_auth = SomeClient.web_authentication
+  web_auth.authentication_url(:write)   
+  # => "http://www.flickr.com/services/auth/?..."
+  
+When the user authenticated your app, he/she get redirected to your callback URL.
+You can pass this method either the frob in the URL (<tt>params[:frob]</tt>), or
+the entire URL (<tt>request.request_uri</tt>). Assuming this is not part of your original
+request/response cycle, you may need to re-instantiate the +WebAuthentication+ object.
+
+  web_auth = SomeClient.web_authentication
+  token = web_auth.get_token(params[:frob])
+
+=== Desktop authentication
+
+  desktop_auth = SomeClient.desktop_authentication
+  desktop_auth.authentication_url(:write)
+  # => "http://www.flickr.com/services/auth/?..."
+  
+When the user authenticated your app, he/she needs to inform your app that the authentication
+is complete. Then your app can continue requesting a token from Flickr that allows you to
+perform authenticated requests.
+
+This method uses the previously generated frob that was stored in the +DesktopAuthentication+
+object to request a token. If you delete this instance in between, you can specify the frob to request
+a token for by passing it as an argument.
+
+So, if your +desktop_auth+ object is still alive, invoke:
+  token = desktop_auth.get_token
+Otherwise, first store the frob after generating the authentication URL, and pass it to the +get_token+ method later:
+  frob_to_store = desktop_auth.frob
+  
+  # The app quits here, or you do some other magic.
+  
+  desktop_auth = SomeClient.desktop_authentication
+  token = desktop_auth.get_token(frob_that_you_stored_somewhere)
+
+== Example request
+Ofcourse, if we do non-authenticated requests (like searching all publicly available photos), we don't need to use a token. This would look like so:
+
+  client = SomeClient.new
+  client.get 'photos.search' do |params|
+    params.tags = ['drinking', 'beer'].join(',')
+  end
+
+While this is quite self-explanatory, I'll elaborate a bit. You can call the <tt>#get</tt> method with the action to call (refer to the Flickr API which methods are available). As all Flickr methods start with <tt>flickr.</tt>, you can leave that out for readability. If you specify a block, you can define parameters for the call. Any parameter can be called as an accessor.
+
+The method returns a Hpricot XML object. For a full reference to traversal of this object, please look into the Hpricot docs. But to given you an impression:
+
+  doc = client.get 'photos.search' do |params|
+    params.tags = ['drinking', 'beer'].join(',')
+  end
+  
+  (doc / 'photo').collect { |p| [p[:title], p[:id]] }
+  # => [["DSC09104", "3193174165"], ["DSC09130", "3193173953"], ...]
+  
+== Example authenticated request
+Making an authenticated request differs from non-authenticated requests in one way only, being that you need to specify the token to use. This can be done in a number of ways.
+
+Instantiate your client with the token:
+  client = SomeClient.new(token)
+
+Instantiate a client without a token and specify it when doing a method-call:
+  client = SomeClient.new
+  client.with_token(token) do
+    get 'photos.search' do
+      ...
+    end
+  end
+
+Don't instantiate and use the provided class-method:
+  SomeClient.with_token(token) do
+    get 'photos.search' do
+      ...
+    end
+  end
+
+It is even possible to scope calls to a token like this:
+  client.with_token(token_of_user1) do
+    # stuff for user1
+    with_token(token_of_user2) do
+      # other stuff for user2
+    end
+    # some more stuff for user1
+  end
+  
+An example call for getting all private photos for a user would look like this:
+  SomeClient.with_token(token_of_user) do
+    get 'photos.search' do |params|
+      # Look into the Flickr API docs for a full reference of possible parameters
+      # http://www.flickr.com/services/api/flickr.photos.search.html
+      params.user_id = :me
+      params.privacy_level = 5
+    end
+  end
+
+= Author
+* Pieter Noordhuis (pcnoordhuis@gmail.com)
+
+= License
+Copyright (c) 2008 Pieter Noordhuis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 2
+:major: 0
+:minor: 2

data/lib/simpleflickr.rb

@@ -0,0 +1,28 @@
+require 'net/http'
+require 'digest/md5'
+require 'rubygems'
+require 'hpricot'
+
+$:.unshift File.join File.dirname(__FILE__), 'simpleflickr'
+require 'query'
+require 'http'
+require 'base'
+
+require 'authentication/authentication'
+require 'authentication/web'
+require 'authentication/desktop'
+
+SimpleFlickr::Authentication.class_eval do
+  include SimpleFlickr::Query
+end
+
+module SimpleFlickr
+  @verbose = false
+  def self.verbose?
+    @verbose
+  end
+  
+  def self.verbose=(v)
+    @verbose = !!v
+  end
+end

data/lib/simpleflickr/authentication/authentication.rb

@@ -0,0 +1,38 @@
+
+module SimpleFlickr
+  class Authentication
+    
+    AuthenticationService = 'http://www.flickr.com/services/auth/?'
+    attr_reader :permission
+    
+    def initialize(options)
+      # This class must be subclassed
+      if self.class.name =~ /::Authentication$/
+        raise "The Authentication class must be subclassed"
+      end
+      
+      unless options.key?(:api_key) && options.key?(:secret)
+        raise ArgumentError.new("Options should contain at least :api_key and :secret")
+      end
+      
+      @permission = (options[:permission] || :read).to_sym
+      @default_params = { :api_key => options[:api_key], :secret => options[:secret] }
+    end
+    
+    def token_url(frob)
+      params = default_params.merge(:frob => frob, :method => 'flickr.auth.getToken')
+      url_for(params)
+    end
+    
+    def get_token_from_frob(frob)
+      response = HTTP.start do |flickr|
+        flickr.get(token_url(frob))
+      end
+      doc = Hpricot::XML response.body
+      doc.at('token').inner_text
+    end
+    
+    private
+      attr_reader :default_params
+  end
+end

data/lib/simpleflickr/authentication/desktop.rb

@@ -0,0 +1,41 @@
+module SimpleFlickr
+  class DesktopAuthentication < Authentication
+    
+    # Returns URL where to get a frob.
+    def frob_url
+      url_for(default_params.merge(:method => 'flickr.auth.getFrob'))
+    end
+
+    # Returns the frob from the response
+    def frob_from_response(response)
+      doc = Hpricot::XML response.body
+      doc.at('frob').inner_text
+    end
+
+    # Constructs an URL for the user to go to and authenticate
+    def authentication_url_for_frob(frob)
+      params = default_params.merge(:perms => 'read', :frob => frob)
+      AuthenticationService + query_string(params)
+    end
+    
+    # Goes through the process of requesting a frob and constructing
+    # an authentication URL for the user all in one call
+    def authentication_url
+      response = HTTP.start do |flickr|
+        flickr.get(frob_url)
+      end
+      @frob = frob_from_response(response)
+      authentication_url_for_frob(@frob)
+    end
+    
+    # Tries to get a token from the previously used frob.
+    def get_token(arg = nil)
+      raise "Please specify a frob to use" if frob.nil? && arg.nil?
+      get_token_from_frob(frob.nil? ? arg : frob)
+    end
+    
+    private
+      attr_reader :frob
+    
+  end
+end

data/lib/simpleflickr/authentication/web.rb

@@ -0,0 +1,22 @@
+module SimpleFlickr
+  class WebAuthentication < Authentication
+    
+    def authentication_url
+      params = default_params.merge(:perms => @permission)
+      AuthenticationService + query_string(params)
+    end
+    
+    # Tries to get a frob from an URL
+    def get_frob_from_url(url)
+      url.to_s[/\?frob=([0-9a-f-]+)$/i, 1]
+    end
+    
+    # Gets a token from the frob. The frob or the callback
+    # URL can be given.
+    def get_token(input)
+      input = get_frob_from_url(input) || input
+      get_token_from_frob(input)
+    end
+    
+  end
+end

data/lib/simpleflickr/base.rb

@@ -0,0 +1,100 @@
+module SimpleFlickr
+  class Base
+    @@params = {}
+    
+    def self.default_params
+      @@params
+    end
+    
+    def self.api_key(key)
+      @@params[:api_key] = key
+    end
+
+    def self.secret(secret)
+      @@params[:secret] = secret
+    end
+    
+    private_class_method :api_key, :secret
+    
+    def self.authentication_hash(perm)
+      unless perm.nil? || [:read, :write, :delete].include?(perm)
+        raise ArgumentError.new("Given permission is not one of :read, :write or :delete")
+      end
+      default_params.merge :permission => (perm || :read)
+    end
+    
+    def self.web_authentication(perm = nil)
+      WebAuthentication.new authentication_hash(perm)
+    end
+    
+    def self.desktop_authentication(perm = nil)
+      DesktopAuthentication.new authentication_hash(perm)
+    end
+    
+    # Token scoping on class
+    def self.with_token(t, &block)
+      self.new(t).instance_eval &block
+    end
+    
+    # Token scoping on instance
+    def with_token(t, &block)
+      @tokens.push t
+      instance_eval &block
+      @tokens.pop
+    end
+    
+    def initialize(token = nil)
+      # Store tokens in an array for scoping purposes
+      @tokens = [token].compact
+    end
+    
+    def token
+      @tokens.last
+    end
+    
+    def params_hash
+      params = self.class.default_params
+      if token.nil?
+        params
+      else
+        params.merge(:auth_token => token)
+      end
+    end
+    
+    def get(method, &block)
+      params = Ext.hash_proxy params_hash.merge(:method => "flickr.#{method}"), &block
+      
+      response = HTTP.start do |flickr|
+        flickr.get QueryBuilder.url_for(params)
+      end
+      xml = Hpricot::XML response.body
+    end
+    
+    # Let the included methods from the Query module live in another
+    # namespace to prevent subclasses from overriding them.
+    class QueryBuilder
+      extend Query
+    end
+    
+    class Ext
+      def self.hash_proxy(hsh)
+        # Adds a proxy via method_missing for easy access to hash attributes
+        hsh = hsh.dup
+        class << hsh
+          def method_missing(sym, *args)
+            if property = sym.to_s[/^(\w+)=$/, 1]
+              key = property.to_sym
+              raise ArgumentError.new("Key #{key.inspect} already defined") unless self[key].nil?
+              self[key] = args.first.to_s
+            else
+              super
+            end
+          end
+        end
+
+        yield hsh
+        hsh
+      end
+    end
+  end
+end

data/lib/simpleflickr/http.rb

@@ -0,0 +1,36 @@
+
+module SimpleFlickr
+  module HTTP
+    DOMAIN = 'api.flickr.com'
+    
+    def self.start
+      http = Net::HTTP.new(DOMAIN)
+      http.start
+
+      begin
+        response = yield(http)
+        inspect_response(response) if verbose?
+        
+        if response.is_a?(Net::HTTPSuccess)
+          response
+        else
+          response.error!
+        end
+      ensure
+        http.finish
+      end
+    end
+
+    def self.inspect_response(response, out = $stderr)
+      out.puts response.inspect
+      for name, value in response
+        out.puts "#{name}: #{value}"
+      end
+      out.puts "----\n#{response.body}\n----" unless response.body.empty?
+    end
+    
+    def self.verbose?
+      SimpleFlickr::verbose?
+    end
+  end
+end

data/lib/simpleflickr/query.rb

@@ -0,0 +1,40 @@
+
+module SimpleFlickr
+  module Query
+    ServicesPath = '/services/rest/'
+
+    # Use the key-sorted version of the parameters to construct
+    # a string, to which the secret is prepended.
+    def sort_params(params)
+      params.sort do |a,b|
+        a.to_s <=> b.to_s
+      end
+    end
+
+    def string_to_sign(params, secret)
+      string_to_sign = secret + sort_params(params).inject('') do |str, pair|
+        key, value = pair
+        str + key.to_s + value.to_s
+      end
+    end
+
+    # Get the MD5 digest of the string to sign
+    def signature(params, secret)
+      Digest::MD5.hexdigest(string_to_sign(params, secret))
+    end
+
+    def query_string(params)
+      secret = params.delete(:secret)
+      params[:api_sig] = signature(params, secret)
+  
+      params.inject([]) do |arr, pair|
+        key, value = pair
+        arr << "#{key}=#{value}"
+      end.join('&')
+    end
+
+    def url_for(params)
+      ServicesPath + '?' + query_string(params)
+    end
+  end
+end

data/spec/feeds/auth.getFrob.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<rsp stat="ok">
+  <frob>934-746563215463214621</frob>
+</rsp>

data/spec/feeds/auth.getToken.xml

@@ -0,0 +1,5 @@
+<auth>
+	<token>45-76598454353455</token>
+	<perms>read</perms>
+	<user nsid="12037949754@N01" username="Bees" fullname="Cal H" />
+</auth>

data/spec/flickr/auth_spec.rb

@@ -0,0 +1,184 @@
+$:.unshift File.join(File.dirname(__FILE__), '..')
+require 'spec_helper'
+require 'uri'
+
+describe SimpleFlickr::Authentication do
+  before(:all) do
+    @options = {
+      :api_key => '1234',
+      :secret => 'tell no one',
+      :permission => :write
+    }
+  end
+  
+  it "should not be possible to instantiate the base class" do
+    lambda {
+      SimpleFlickr::Authentication.new(@options)
+    }.should raise_error
+  end
+  
+  it "should raise an error when not provided with an api key" do
+    lambda {
+      SimpleFlickr::DesktopAuthentication.new(@options.without(:api_key))
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise an error when not provided with a secret" do
+    lambda {
+      SimpleFlickr::DesktopAuthentication.new(@options.without(:secret))
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should not raise an error when provided with the right options" do
+    lambda {
+      SimpleFlickr::DesktopAuthentication.new(@options)
+    }.should_not raise_error
+  end
+  
+  it "should default to read permission" do
+    @f = SimpleFlickr::DesktopAuthentication.new(@options.without(:permission))
+    @f.permission.should == :read
+  end
+end
+
+describe "Authentication subclasses" do
+
+  before(:all) do
+    @api_key  = '9a0554259914a86fb9e7eb014e4e5d52'
+    @secret   = '000005fab4534d05'
+    @options  = { :api_key => @api_key, :secret => @secret, :permission => :write }
+  end
+  
+  describe SimpleFlickr::WebAuthentication do
+
+    before(:all) do
+      @frob = '72157607642075605-dc0f15086c86023b-22944155'
+      @callback_url = "http://www.somehost.com/somedir?frob=#{@frob}"
+    end
+
+    before(:each) do
+      @f = SimpleFlickr::WebAuthentication.new(@options)
+    end
+
+    it "should generate a valid authentication url" do
+      uri = URI.parse @f.authentication_url
+      uri.host.should == 'www.flickr.com'
+      uri.path.should == '/services/auth/'
+      
+      hsh = hash_from_query(uri.query)
+      hsh[:api_key].should == @api_key
+      hsh[:perms].should == 'write'
+    end
+    
+    it "should return a frob from the return uri" do
+      @f.get_frob_from_url(@callback_url).should == @frob
+    end
+    
+    it "should get a token when given an uri" do
+      @f.expects(:get_token_from_frob).with(@frob)
+      @f.get_token(@callback_url)
+    end
+    
+    it "should get a token when given the frob" do
+      @f.expects(:get_token_from_frob).with(@frob)
+      @f.get_token(@frob)
+    end
+    
+  end
+
+  describe SimpleFlickr::DesktopAuthentication do
+  
+    before(:each) do
+      @f = SimpleFlickr::DesktopAuthentication.new({
+        :api_key => '9a0554259914a86fb9e7eb014e4e5d52',
+        :secret => '000005fab4534d05'
+      })
+    end
+  
+    describe "authentication for desktop apps" do
+      # Key, secret and signature come from the Flickr API docs.
+      # http://www.flickr.com/services/api/auth.howto.desktop.html
+      it "should generate a correct url to retrieve a frob" do
+        path, query = @f.frob_url.split('?')
+        path.should == '/services/rest/'
+
+        hsh = hash_from_query(query)
+        hsh[:method].should == 'flickr.auth.getFrob'
+        hsh[:api_key].should == '9a0554259914a86fb9e7eb014e4e5d52'
+        hsh[:api_sig].should == '8ad70cd3888ce493c8dde4931f7d6bd0'
+        hsh[:secret].should be_nil
+      end
+
+      it "should generate an authentication url from a response with a frob" do
+        response = mock_response
+        response.stubs(:body).returns sample_xml('auth.getFrob')
+        @f.frob_from_response(response).should == '934-746563215463214621'
+      end
+
+      # The :api_sig parameter is documented wronly in the Flickr API docs. It says the string
+      # to sign ends in 'permswread', but this should be 'permsread' of course. Therefore
+      # the :api_sig here does not correspond to the Flickr docs, but it makes the spec valid.
+      it "should return an url to authenticate to containing a frob" do
+        response = mock_response
+        response.stubs(:body).returns sample_xml('auth.getFrob')
+        SimpleFlickr::HTTP.expects(:start).returns(response)
+        uri = URI.parse @f.authentication_url
+      
+        uri.host.should == 'www.flickr.com'
+        uri.scheme.should == 'http'
+        uri.path.should == '/services/auth/'
+        hsh = hash_from_query(uri.query)
+        hsh[:api_key].should == '9a0554259914a86fb9e7eb014e4e5d52'
+        hsh[:api_sig].should == '0d08a9522d152d2e43daaa2a932edf67'
+        hsh[:frob].should == '934-746563215463214621'
+        hsh[:perms].should == 'read'
+        hsh[:secret].should be_nil
+      end
+      
+      it "should throw an error when no frob is available" do
+        lambda do
+          @f.get_token
+        end.should raise_error
+      end
+      
+      describe "with the frob available" do
+        before(:each) do
+          response = mock_response
+          response.stubs(:body).returns sample_xml('auth.getToken')
+          connection = mock('Connection')
+          connection.expects(:get).with do |value|
+            path, query = value.split('?')
+            path.should == '/services/rest/'
+
+            hsh = hash_from_query(query)
+            hsh[:method].should == 'flickr.auth.getToken'
+            hsh[:api_key].should == '9a0554259914a86fb9e7eb014e4e5d52'
+            hsh[:api_sig].should == 'a5902059792a7976d03be67bdb1e98fd'
+            hsh[:frob].should == '934-746563215463214621'
+            hsh[:secret].should be_nil
+            true
+          end
+          SimpleFlickr::HTTP.expects(:start).returns(response).yields(connection)
+        end
+        
+        it "should get a token when frob is available" do
+          @f.expects(:frob).at_least_once.returns('934-746563215463214621')
+          @f.get_token.should == '45-76598454353455'
+        end
+
+        it "should get a token with the given frob" do
+          @f.get_token('934-746563215463214621').should == '45-76598454353455'
+        end
+      end
+    end
+  end
+  
+  def hash_from_query(str)
+    str.split('&').inject({}) do |hsh, pair|
+      key, value = pair.split('=')
+      hsh[key.to_sym] = value
+      hsh
+    end
+  end
+  
+end

data/spec/flickr/base_spec.rb

@@ -0,0 +1,146 @@
+$:.unshift File.join(File.dirname(__FILE__), '..')
+require 'spec_helper'
+
+class TestClient < SimpleFlickr::Base
+end
+
+describe SimpleFlickr::Base, "defining api_key and secret" do
+  
+  it "should declare #api_key and #secret as private" do
+    TestClient.private_methods.should include('api_key', 'secret')
+  end
+  
+  it "should set an api key" do
+    TestClient.class_eval do
+      api_key 'my_key'
+    end
+    TestClient.class_eval{default_params}[:api_key].should == 'my_key'
+  end
+  
+  it "should set a secret" do
+    TestClient.class_eval do
+      secret 'my_secret'
+    end
+    TestClient.class_eval{default_params}[:secret].should == 'my_secret'
+  end
+  
+end
+
+describe SimpleFlickr::Base do
+  before(:all) do
+    TestClient.class_eval do
+      api_key 'my_key'
+      secret 'my_secret'
+    end
+  end
+  
+  describe "authentication" do
+    it "should default to :read permission" do
+      web_auth = TestClient.web_authentication
+      web_auth.permission.should == :read
+    end
+    
+    it "should accept setting the permission" do
+      web_auth = TestClient.web_authentication(:write)
+      web_auth.permission.should == :write
+    end
+    
+    it "should throw an error when a non-valid permission was given" do
+      lambda do
+        TestClient.web_authentication(:rule_the_world)
+      end.should raise_error
+    end
+    
+    it "should return a valid web authentication object" do
+      web_auth = TestClient.web_authentication
+      web_auth.should be_an_instance_of(SimpleFlickr::WebAuthentication)
+      
+      hsh = web_auth.instance_eval { @default_params }
+      hsh[:api_key].should == 'my_key'
+      hsh[:secret].should == 'my_secret'
+    end
+  
+    it "should return a valid desktop authentication object" do
+      desktop_auth = TestClient.desktop_authentication
+      desktop_auth.should be_an_instance_of(SimpleFlickr::DesktopAuthentication)
+      
+      hsh = desktop_auth.instance_eval { @default_params }
+      hsh[:api_key].should == 'my_key'
+      hsh[:secret].should == 'my_secret'
+    end
+  end
+  
+  describe "instantiation" do
+    it "should allow instantiation without arguments" do
+      t = TestClient.new
+      t.token.should be_nil
+    end
+    
+    it "should accept a token for instantiation" do
+      t = TestClient.new('my_token')
+      t.token.should == 'my_token'
+    end
+  end
+  
+  describe "token scoping" do
+    it "should be possible to call as class method" do
+      TestClient.with_token('token1') do
+        token.should == 'token1'
+      end
+    end
+    
+    it "should be possible to call as instance method" do
+      TestClient.new.with_token('token1') do
+        token.should == 'token1'
+      end
+    end
+    
+    it "should allow nesting of scopes" do
+      TestClient.with_token('token1') do
+        token.should == 'token1'
+        with_token 'token2' do
+          token.should == 'token2'
+          with_token 'token3' do
+            token.should == 'token3'
+          end
+          token.should == 'token2'
+        end
+        token.should == 'token1'
+      end
+    end
+  end
+  
+  describe "doing a request" do
+    before(:each) do
+      @t = TestClient.new('some_token')
+    end
+    
+    it "should throw an error when trying to define the same key twice" do
+      # To prevent redefining api_key or secret
+      lambda do
+        @t.get('some.action') do |p|
+          p.some_key = 'WIN'
+          p.some_key = 'FAIL'
+        end
+      end.should raise_error
+    end
+  
+    it "should make an authenticated request" do
+      SimpleFlickr::Base::QueryBuilder.expects(:url_for).with do |hsh|
+        hsh[:api_key].should    == 'my_key'
+        hsh[:secret].should     == 'my_secret'
+        hsh[:method].should     == 'flickr.photos.search'
+        hsh[:user_id].should    == 'me'
+        hsh[:auth_token].should == 'some_token'
+      end.returns('my_generated_url')
+    
+      connection = mock(:get => 'my_generated_url')
+      response = mock(:body => "<tag/>")
+      SimpleFlickr::HTTP.expects(:start).yields(connection).returns(response)
+    
+      @t.get('photos.search') do |p|
+        p.user_id = :me
+      end.root.name.should == 'tag'
+    end
+  end
+end

data/spec/flickr/query_spec.rb

@@ -0,0 +1,40 @@
+$:.unshift File.join(File.dirname(__FILE__), '..')
+require 'spec_helper'
+
+class QueryTester
+  include SimpleFlickr::Query
+end
+
+describe SimpleFlickr::Query do
+  # The parameters used here come from:
+  # http://www.flickr.com/services/api/auth.howto.desktop.html
+  
+  before(:all) do
+    @params = { :api_key => '9a0554259914a86fb9e7eb014e4e5d52', :method => 'flickr.auth.getFrob' }
+    @secret = '000005fab4534d05';
+    @signature_string = '000005fab4534d05api_key9a0554259914a86fb9e7eb014e4e5d52methodflickr.auth.getFrob'
+    @signature = '8ad70cd3888ce493c8dde4931f7d6bd0'
+    @query = QueryTester.new
+  end
+  
+  it "should sort paramers by key" do
+    @query.sort_params({:b => '1', :c => '3', :a => '2'}).should == [[:a, '2'], [:b, '1'], [:c, '3']]
+  end
+  
+  it "should return a valid string to sign" do
+    @query.string_to_sign(@params, @secret).should == @signature_string
+  end
+  
+  it "should produce a valid signed string" do
+    @query.signature(@params, @secret).should == @signature
+  end
+  
+  it "should produce a valid query part of an url" do
+    str = @query.query_string(@params.merge(:secret => @secret))
+    pairs = str.split('&')
+    pairs.size.should == 3
+    pairs.should include("api_key=#{@params[:api_key]}")
+    pairs.should include("method=#{@params[:method]}")
+    pairs.should include("api_sig=#{@signature}")
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,2 @@
+--exclude ^\/,^spec\/
+--no-validator-links

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,93 @@
+require 'rubygems'
+# Include mocha before rspec because of some funky bug in
+# rspec that depends on the constant Test being defined 
+gem 'mocha', '~> 0.9.0'
+require 'mocha'
+gem 'rspec', '~> 1.1.3'
+require 'spec'
+
+$:.unshift File.join File.dirname(__FILE__), %w{.. lib}
+require 'simpleflickr'
+
+module SampleFeeds
+  FEED_DIR = File.dirname(__FILE__) + '/feeds/'
+  
+  def sample_xml(name)
+    File.read "#{FEED_DIR}#{name}.xml"
+  end
+end
+
+module HttpMocks
+  def mock_response(type = :success)
+    klass = case type
+    when :success  then Net::HTTPSuccess
+    when :redirect then Net::HTTPRedirection
+    when :fail     then Net::HTTPClientError
+    else type
+    end
+    
+    klass.new(nil, nil, nil)
+  end
+  
+  def mock_connection(ssl = true)
+    connection = mock('HTTP connection')
+    connection.stubs(:start)
+    connection.stubs(:finish)
+    if ssl
+      connection.expects(:use_ssl=).with(true)
+      connection.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+    end
+    connection
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include SampleFeeds, HttpMocks
+  # config.predicate_matchers[:swim] = :can_swim?
+  
+  config.mock_with :mocha
+end
+
+module Mocha
+  module ParameterMatchers
+    def query_string(entries, partial = false)
+      QueryStringMatcher.new(entries, partial)
+    end
+  end
+end
+
+class QueryStringMatcher < Mocha::ParameterMatchers::Base
+  
+  def initialize(entries, partial)
+    @entries = entries
+    @partial = partial
+  end
+  
+  def matches?(available_parameters)
+    string = available_parameters.shift.split('?').last
+    broken = string.split('&').map { |pair| pair.split('=').map { |value| CGI.unescape(value) } }
+    hash = Hash[*broken.flatten]
+    
+    if @partial
+      has_entry_matchers = @entries.map do |key, value|
+        Mocha::ParameterMatchers::HasEntry.new(key, value)
+      end
+      Mocha::ParameterMatchers::AllOf.new(*has_entry_matchers).matches?([hash])
+    else
+      @entries == hash
+    end
+  end
+  
+  def mocha_inspect
+    "query_string(#{@entries.mocha_inspect})"
+  end
+  
+end
+
+class Hash
+  def without(key)
+    r = self.clone
+    r.delete(key)
+    r
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: pietern-simpleflickr
+version: !ruby/object:Gem::Version 
+  version: 0.2.2
+platform: ruby
+authors: 
+- Pieter Noordhuis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-26 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Rolling your own Flickr libs was never *this* easy
+email: pcnoordhuis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- VERSION.yml
+- lib/simpleflickr
+- lib/simpleflickr/authentication
+- lib/simpleflickr/authentication/authentication.rb
+- lib/simpleflickr/authentication/desktop.rb
+- lib/simpleflickr/authentication/web.rb
+- lib/simpleflickr/base.rb
+- lib/simpleflickr/http.rb
+- lib/simpleflickr/query.rb
+- lib/simpleflickr.rb
+- spec/feeds
+- spec/feeds/auth.getFrob.xml
+- spec/feeds/auth.getToken.xml
+- spec/flickr
+- spec/flickr/auth_spec.rb
+- spec/flickr/base_spec.rb
+- spec/flickr/query_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/pietern/simpleflickr
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Rolling your own Flickr libs was never *this* easy
+test_files: []
+