fb_graph 1.7.5 → 1.8.0.alpha

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    fb_graph (1.7.4)
-      rack-oauth2 (>= 0.6.5)
+    fb_graph (1.8.0.alpha)
+      httpclient (>= 2.2.0.2)
+      rack-oauth2 (>= 0.6.9)
 
 GEM
   remote: http://rubygems.org/
@@ -12,6 +13,7 @@ GEM
     attr_required (0.0.3)
     crack (0.1.8)
     diff-lcs (1.1.2)
+    httpclient (2.2.0.2)
     i18n (0.5.0)
     json (1.5.1)
     mime-types (1.16)

data/VERSION

@@ -1 +1 @@
-1.7.5
+1.8.0.alpha

data/fb_graph.gemspec

@@ -12,7 +12,8 @@ Gem::Specification.new do |s|
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.files = `git ls-files`.split("\n")
   s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.add_runtime_dependency "rack-oauth2", ">= 0.6.5"
+  s.add_runtime_dependency "httpclient", ">= 2.2.0.2"
+  s.add_runtime_dependency "rack-oauth2", ">= 0.6.9"
   s.add_development_dependency "rake", ">= 0.8"
   s.add_development_dependency "rcov", ">= 0.9"
   s.add_development_dependency "rspec", ">= 2"

data/lib/fb_graph/album.rb

@@ -3,7 +3,6 @@ module FbGraph
     include Connections::Photos
     include Connections::Comments
     include Connections::Likes
-    include Connections::Picture
 
     attr_accessor :from, :name, :description, :location, :link, :privacy, :count, :created_time, :updated_time, :type
 
@@ -39,13 +38,5 @@ module FbGraph
       # cached connection
       @_comments_ = Collection.new(attributes[:comments])
     end
-
-    def picture_with_access_token(size = nil)
-      raise Unauthorized.new('Album picture connection requires an access token') unless self.access_token
-      _endpoint_ = URI.parse picture_without_access_token(size)
-      _endpoint_.query = [_endpoint_.query, {:access_token => self.access_token.to_s}.to_query].compact.join('&')
-      _endpoint_.to_s
-    end
-    alias_method_chain :picture, :access_token
   end
 end

data/lib/fb_graph/connections/picture.rb

@@ -4,9 +4,10 @@ module FbGraph
       def picture(size = nil)
         _endpoint_ = "#{self.endpoint}/picture"
         if size
-          _endpoint_ += "?type=#{size}"
+          "#{_endpoint_}?type=#{size}"
+        else
+          _endpoint_
         end
-        _endpoint_
       end
     end
   end

data/lib/fb_graph/node.rb

@@ -36,54 +36,45 @@ module FbGraph
     protected
 
     def get(params = {})
-      _params_ = stringfy_params(params)
-      _endpoint_ = build_endpoint(_params_.merge!(:method => :get))
       handle_response do
-        RestClient.get(_endpoint_)
+        HTTPClient.new.get build_endpoint(params), build_params(params)
       end
     end
 
     def post(params = {})
-      _params_ = stringfy_params(params)
-      _endpoint_ = build_endpoint(_params_.merge!(:method => :post))
       handle_response do
-        RestClient.post(_endpoint_, _params_)
+        HTTPClient.new.post build_endpoint(params), build_params(params)
       end
     end
 
     def delete(params = {})
-      _params_ = stringfy_params(params)
-      _endpoint_ = build_endpoint(_params_.merge!(:method => :delete))
+      _endpoint_, _params_ = build_endpoint(params), build_params(params)
+      _endpoint_ = [_endpoint_, _params_.try(:to_query)].compact.join('?')
       handle_response do
-        RestClient.delete(_endpoint_)
+        HTTPClient.new.delete _endpoint_
       end
     end
 
     private
 
     def build_endpoint(params = {})
-      _endpoint_ = File.join([self.endpoint, params.delete(:connection), params.delete(:connection_scope)].compact.collect(&:to_s))
-      params.delete_if do |k, v|
-        v.blank?
-      end
-      if [:get, :delete].include?(params.delete(:method)) && params.present?
-        _endpoint_ << "?#{params.to_query}"
-      end
-      _endpoint_
+      File.join([self.endpoint, params.delete(:connection), params.delete(:connection_scope)].compact.collect(&:to_s))
     end
 
-    def stringfy_params(params)
+    def build_params(params)
       _params_ = params.dup
-      _params_[:access_token] ||= self.access_token
-      if _params_[:access_token].is_a?(Rack::OAuth2::AccessToken::Legacy)
-        _params_[:access_token] = _params_[:access_token].access_token
+      _params_[:oauth_token] = (_params_.delete(:access_token) || self.access_token).to_s
+      _params_.delete_if do |k, v|
+        v.blank?
       end
       _params_.each do |key, value|
         if value.present? && ![Symbol, String, Numeric, IO].any? { |klass| value.is_a? klass }
           _params_[key] = value.to_json
+        else
+          _params_[key] = value.to_s
         end
       end
-      _params_
+      _params_.blank? ? nil : _params_
     end
 
     def handle_response
@@ -103,27 +94,26 @@ module FbGraph
         nil
       else
         _response_ = JSON.parse(response.body)
-        case _response_
+        _response_ = case _response_
         when Array
           _response_.map!(&:with_indifferent_access)
         when Hash
-          _response_.with_indifferent_access
+          _response_ = _response_.with_indifferent_access
+          handle_httpclient_error(_response_) if _response_[:error]
+          _response_
         end
       end
-    rescue RestClient::Exception => e
-      handle_restclient_error(e)
+    rescue JSON::ParserError
+      raise Exception.new(response.status, 'Unparsable Error Response')
     end
 
-    def handle_restclient_error(e)
-      _response_ = JSON.parse(e.http_body).with_indifferent_access
-      case _response_[:error][:type]
+    def handle_httpclient_error(response)
+      case response[:error][:type]
       when /OAuth/
-        raise Unauthorized.new(e.message, e.http_body)
+        raise Unauthorized.new("#{response[:error][:type]} :: #{response[:error][:message]}")
       else
-        raise BadRequest.new(e.message, e.http_body)
+        raise BadRequest.new("#{response[:error][:type]} :: #{response[:error][:message]}")
       end
-    rescue JSON::ParserError
-      raise Exception.new(e.http_code, e.message, e.http_body)
     end
   end
 end

data/lib/fb_graph/query.rb

@@ -1,5 +1,7 @@
 module FbGraph
   class Query < Node
+    ENDPOINT = 'https://api.facebook.com/method/fql.query'
+
     attr_accessor :access_token, :query
 
     def initialize(query, access_token = nil)
@@ -8,25 +10,19 @@ module FbGraph
     end
 
     def fetch(access_token = nil)
-      self.access_token ||= access_token
       handle_response do
-        RestClient.get build_endpoint
+        HTTPClient.new.get ENDPOINT, :query => build_params(access_token)
       end
     end
 
     private
 
-    ENDPOINT = 'https://api.facebook.com/method/fql.query'
-    def build_endpoint
-      params = stringfy_params(
+    def build_params(access_token)
+      super(
         :query => self.query,
-        :access_token => self.access_token,
+        :access_token => access_token || self.access_token,
         :format => :json
       )
-      params.delete_if do |k, v|
-        v.blank?
-      end
-      ENDPOINT + "?#{params.to_query}"
     end
 
     def handle_response

data/lib/fb_graph.rb

@@ -1,3 +1,4 @@
+require 'httpclient'
 require 'rack/oauth2'
 
 module FbGraph

data/spec/fb_graph/album_spec.rb

@@ -1,84 +1,63 @@
 require 'spec_helper'
 
-describe FbGraph::Album do
+describe FbGraph::Album, '.new' do
 
-  describe '.new' do
-    it 'should setup all supported attributes' do
-      attributes = {
-        :id => '12345',
-        :from => {
-          :id => '23456',
-          :name => 'nov matake'
-        },
-        :name => 'album 1',
-        :description => 'an album for fb_graph test',
-        :location => 'Tokyo, Japan',
-        :link => 'http://www.facebook.com/album/12345',
-        :count => 10,
-        :type => 'normal',
-        :created_time => '2009-12-29T15:24:50+0000',
-        :updated_time => '2010-01-02T15:37:41+0000',
-        :comments => {
-          :data => [{
-            :id => '909694472945_418735',
-            :from => {
-              :id => '520739622',
-              :name => 'Alison Marie Weber',
-            },
-            :message => 'Love all the pix!',
-            :created_time => '2009-08-15T14:57:36+0000'
-          }]
-        }
-      }
-      album = FbGraph::Album.new(attributes.delete(:id), attributes)
-      album.identifier.should     == '12345'
-      album.from.should           == FbGraph::User.new('23456', :name => 'nov matake')
-      album.name.should           == 'album 1'
-      album.description.should    == 'an album for fb_graph test'
-      album.location.should       == 'Tokyo, Japan'
-      album.link.should           == 'http://www.facebook.com/album/12345'
-      album.count.should          == 10
-      album.type.should           == 'normal'
-      album.created_time.should   == Time.parse('2009-12-29T15:24:50+0000')
-      album.updated_time.should   == Time.parse('2010-01-02T15:37:41+0000')
-      album.comments.should       == [FbGraph::Comment.new(
-        '909694472945_418735',
-        :from => {
-          :id => '520739622',
-          :name => 'Alison Marie Weber',
-        },
-        :message => 'Love all the pix!',
-        :created_time => '2009-08-15T14:57:36+0000'
-      )]
-    end
-
-    it 'should support page as from' do
-      page_album = FbGraph::Album.new('12345', :from => {
+  it 'should setup all supported attributes' do
+    attributes = {
+      :id => '12345',
+      :from => {
         :id => '23456',
-        :name => 'Smart.fm',
-        :category => 'Web Site'
-      })
-      page_album.from.should == FbGraph::Page.new('23456', :name => 'Smart.fm', :category => 'Web Site')
-    end
+        :name => 'nov matake'
+      },
+      :name => 'album 1',
+      :description => 'an album for fb_graph test',
+      :location => 'Tokyo, Japan',
+      :link => 'http://www.facebook.com/album/12345',
+      :count => 10,
+      :type => 'normal',
+      :created_time => '2009-12-29T15:24:50+0000',
+      :updated_time => '2010-01-02T15:37:41+0000',
+      :comments => {
+        :data => [{
+          :id => '909694472945_418735',
+          :from => {
+            :id => '520739622',
+            :name => 'Alison Marie Weber',
+          },
+          :message => 'Love all the pix!',
+          :created_time => '2009-08-15T14:57:36+0000'
+        }]
+      }
+    }
+    album = FbGraph::Album.new(attributes.delete(:id), attributes)
+    album.identifier.should     == '12345'
+    album.from.should           == FbGraph::User.new('23456', :name => 'nov matake')
+    album.name.should           == 'album 1'
+    album.description.should    == 'an album for fb_graph test'
+    album.location.should       == 'Tokyo, Japan'
+    album.link.should           == 'http://www.facebook.com/album/12345'
+    album.count.should          == 10
+    album.type.should           == 'normal'
+    album.created_time.should   == Time.parse('2009-12-29T15:24:50+0000')
+    album.updated_time.should   == Time.parse('2010-01-02T15:37:41+0000')
+    album.comments.should       == [FbGraph::Comment.new(
+      '909694472945_418735',
+      :from => {
+        :id => '520739622',
+        :name => 'Alison Marie Weber',
+      },
+      :message => 'Love all the pix!',
+      :created_time => '2009-08-15T14:57:36+0000'
+    )]
   end
 
-  describe '#picture' do
-    let(:album) { FbGraph::Album.new('12345') }
-    subject { album }
-
-    context 'when access token is given' do
-      before { album.access_token = 'access_token' }
-      its(:picture) { should == File.join(FbGraph::ROOT_URL, '12345/picture?access_token=access_token') }
-      it 'should support size' do
-        album.picture(:small).should == File.join(FbGraph::ROOT_URL, '12345/picture?type=small&access_token=access_token')
-      end
-    end
-
-    context 'otherwise' do
-      it do
-        expect { album.picture }.should raise_error(FbGraph::Unauthorized)
-      end
-    end
+  it 'should support page as from' do
+    page_album = FbGraph::Album.new('12345', :from => {
+      :id => '23456',
+      :name => 'Smart.fm',
+      :category => 'Web Site'
+    })
+    page_album.from.should == FbGraph::Page.new('23456', :name => 'Smart.fm', :category => 'Web Site')
   end
 
 end

data/spec/fb_graph/app_request_spec.rb

@@ -33,8 +33,8 @@ end
 
 describe FbGraph::AppRequest, '#destroy' do
   it 'should request DELETE /:request_id' do
-    lambda do
+    mock_graph :delete, '12345', 'true', :access_token => 'access_token' do
       FbGraph::AppRequest.new('12345', :access_token => 'access_token').destroy
-    end.should request_to '12345?access_token=access_token', :delete
+    end
   end
 end

data/spec/fb_graph/checkin_spec.rb

@@ -29,9 +29,8 @@ describe FbGraph::Checkin, '.search' do
 
   context 'when access_token is given' do
     it 'should return checkins as FbGraph::Checkin' do
-      mock_graph :get, 'search', 'checkins/search_private', :params => {
-        :type => 'checkin',
-        :access_token => 'access_token'
+      mock_graph :get, 'search', 'checkins/search_private', :access_token => 'access_token', :params => {
+        :type => 'checkin'
       } do
         checkins = FbGraph::Checkin.search(:access_token => 'access_token')
         checkins.each do |checkin|

data/spec/fb_graph/collection_spec.rb

@@ -3,9 +3,7 @@ require 'spec_helper'
 describe FbGraph::Collection, '.new' do
 
   it 'should return an array with pagination info' do
-    mock_graph :get, 'platform/statuses', 'pages/statuses/platform_private', :params => {
-      :access_token => 'access_token'
-    } do
+    mock_graph :get, 'platform/statuses', 'pages/statuses/platform_private', :access_token => 'access_token' do
       collection = FbGraph::Page.new('platform', :access_token => 'access_token').statuses.collection
       collection.should be_kind_of(Array)
       collection.previous.should be_kind_of(Hash)

data/spec/fb_graph/connection_spec.rb

@@ -2,9 +2,7 @@ require 'spec_helper'
 
 describe FbGraph::Connection, '.new' do
   it 'should return an array with connection info' do
-    mock_graph :get, 'platform/statuses', 'pages/statuses/platform_private', :params => {
-      :access_token => 'access_token'
-    } do
+    mock_graph :get, 'platform/statuses', 'pages/statuses/platform_private', :access_token => 'access_token' do
       page = FbGraph::Page.new('platform', :access_token => 'access_token')
       statuses = page.statuses
       statuses.should be_kind_of(Array)
@@ -19,26 +17,22 @@ describe FbGraph::Connection do
   it 'should be useful for pagenation' do
     me = FbGraph::User.new('me', :access_token => 'access_token')
     posts = nil
-    mock_graph :get, 'me/home', 'users/home/me_private', :params => {
-      :access_token => 'access_token'
-    } do
+    mock_graph :get, 'me/home', 'users/home/me_private', :access_token => 'access_token' do
       posts = me.home
       posts.first.created_time.should == Time.parse('2010-04-27T13:06:14+0000')
       posts.last.created_time.should  == Time.parse('2010-04-27T11:07:48+0000')
     end
-    mock_graph :get, 'me/home', 'users/home/me_private_previous', :params => {
-      :access_token => 'access_token',
+    mock_graph :get, 'me/home', 'users/home/me_private_previous', :access_token => 'access_token', :params => {
       :limit => '25',
-      :since => '2010-04-27T13:06:14+0000'
+      :since => '123456789'
     } do
       previous_posts = posts.previous
       previous_posts.first.created_time.should == Time.parse('2010-04-27T13:23:08+0000')
       previous_posts.last.created_time.should  == Time.parse('2010-04-27T13:10:56+0000')
     end
-    mock_graph :get, 'me/home', 'users/home/me_private_next', :params => {
-      :access_token => 'access_token',
+    mock_graph :get, 'me/home', 'users/home/me_private_next', :access_token => 'access_token', :params => {
       :limit => '25',
-      :until => '2010-04-27T11:07:48+0000'
+      :until => '123456789'
     } do
       next_posts = posts.next
       next_posts.first.created_time.should == Time.parse('2010-04-27T11:06:29+0000')

data/spec/fb_graph/connections/accounts_spec.rb

@@ -14,9 +14,7 @@ describe FbGraph::Connections::Accounts, '#accounts' do
 
     context 'when access_token is given' do
       it 'should return accounts as FbGraph::Page' do
-        mock_graph :get, 'matake/accounts', 'users/accounts/matake_private', :params => {
-          :access_token => 'access_token'
-        } do
+        mock_graph :get, 'matake/accounts', 'users/accounts/matake_private', :access_token => 'access_token' do
           accounts = FbGraph::User.new('matake', :access_token => 'access_token').accounts
           accounts.class.should == FbGraph::Connection
           accounts.first.should == FbGraph::Page.new(
@@ -33,9 +31,7 @@ describe FbGraph::Connections::Accounts, '#accounts' do
 
       context 'when manage_pages permission given' do
         it 'should has special access_token behalf of the page' do
-          mock_graph :get, 'matake/accounts', 'users/accounts/matake_private_with_manage_pages_permission', :params => {
-            :access_token => 'access_token_for_user'
-          } do
+          mock_graph :get, 'matake/accounts', 'users/accounts/matake_private_with_manage_pages_permission', :access_token => 'access_token_for_user' do
             accounts = FbGraph::User.new('matake', :access_token => 'access_token_for_user').accounts
             accounts.first.should == FbGraph::Page.new(
               '140478125968442',

data/spec/fb_graph/connections/activities_spec.rb

@@ -15,9 +15,7 @@ describe FbGraph::Connections::Activities, '#activities' do
 
     context 'when access_token is given' do
       it 'should return activities as FbGraph::Page' do
-        mock_graph :get, 'arjun/activities', 'users/activities/arjun_private', :params => {
-          :access_token => 'access_token'
-        } do
+        mock_graph :get, 'arjun/activities', 'users/activities/arjun_private', :access_token => 'access_token' do
           activities = FbGraph::User.new('arjun', :access_token => 'access_token').activities
           activities.class.should == FbGraph::Connection
           activities.first.should == FbGraph::Page.new(

data/spec/fb_graph/connections/albums_spec.rb

@@ -15,9 +15,7 @@ describe FbGraph::Connections::Albums, '#albums' do
 
     context 'when access_token is given' do
       it 'should return albums as FbGraph::Album' do
-        mock_graph :get, 'matake/albums', 'users/albums/matake_private', :params => {
-          :access_token => 'access_token'
-        } do
+        mock_graph :get, 'matake/albums', 'users/albums/matake_private', :access_token => 'access_token' do
           albums = FbGraph::User.new('matake', :access_token => 'access_token').albums
           albums.first.should == FbGraph::Album.new(
             '19351532276',
@@ -47,8 +45,7 @@ end
 describe FbGraph::Connections::Albums, '#album!' do
   context 'when included by FbGraph::User' do
     it 'should return generated album' do
-      mock_graph :post, 'matake/albums', 'users/albums/post_with_valid_access_token', :params => {
-        :access_token => 'valid',
+      mock_graph :post, 'matake/albums', 'users/albums/post_with_valid_access_token', :access_token => 'valid', :params => {
         :name => 'FbGraph test',
         :message => 'test test test'
       } do

data/spec/fb_graph/connections/app_requests_spec.rb

@@ -2,9 +2,7 @@ require 'spec_helper'
 
 describe FbGraph::Connections::AppRequests, '#app_requests' do
   it 'should return app_requests as FbGraph::AppRequest' do
-    mock_graph :get, 'me/apprequests', 'users/app_requests/me_private', :params => {
-      :access_token => 'access_token'
-    } do
+    mock_graph :get, 'me/apprequests', 'users/app_requests/me_private', :access_token => 'access_token' do
       app_requests = FbGraph::User.me('access_token').app_requests
       app_requests.each do |app_request|
         app_request.should be_instance_of(FbGraph::AppRequest)

data/spec/fb_graph/connections/attending_spec.rb

@@ -2,9 +2,7 @@ require 'spec_helper'
 
 describe FbGraph::Connections::Attending, '#attending' do
   it 'should return attending users as FbGraph::User' do
-    mock_graph :get, 'smartday/attending', 'events/attending/smartday_private', :params => {
-      :access_token => 'access_token'
-    } do
+    mock_graph :get, 'smartday/attending', 'events/attending/smartday_private', :access_token => 'access_token' do
       users = FbGraph::Event.new('smartday', :access_token => 'access_token').attending
       users.each do |user|
         user.should be_instance_of(FbGraph::User)
@@ -15,9 +13,7 @@ end
 
 describe FbGraph::Connections::Attending, '#attending!' do
   it 'should return true' do
-    mock_graph :post, '12345/attending', 'events/attending/post_with_valid_access_token', :params => {
-      :access_token => 'valid'
-    } do
+    mock_graph :post, '12345/attending', 'events/attending/post_with_valid_access_token', :access_token => 'valid' do
       FbGraph::Event.new('12345', :access_token => 'valid').attending!.should be_true
     end
   end

data/spec/fb_graph/connections/books_spec.rb

@@ -14,9 +14,7 @@ describe FbGraph::Connections::Books, '#books' do
 
     context 'when access_token is given' do
       it 'should return books as FbGraph::Page' do
-        mock_graph :get, 'matake/books', 'users/books/matake_private', :params => {
-          :access_token => 'access_token'
-        } do
+        mock_graph :get, 'matake/books', 'users/books/matake_private', :access_token => 'access_token' do
           books = FbGraph::User.new('matake', :access_token => 'access_token').books
           books.first.should == FbGraph::Page.new(
             '102253616477130',

data/spec/fb_graph/connections/checkins_spec.rb

@@ -14,9 +14,7 @@ describe FbGraph::Connections::Checkins, '#checkins' do
 
     context 'when access_token is given' do
       it 'should return checkins as FbGraph::Checkin' do
-        mock_graph :get, 'mattt/checkins', 'users/checkins/mattt_private', :params => {
-          :access_token => 'access_token'
-        } do
+        mock_graph :get, 'mattt/checkins', 'users/checkins/mattt_private', :access_token => 'access_token' do
           checkins = FbGraph::User.new('mattt', :access_token => 'access_token').checkins
           checkins.first.should == FbGraph::Checkin.new(
             '696876187499',
@@ -67,9 +65,7 @@ describe FbGraph::Connections::Checkins, '#checkins' do
 
     context 'when access_token is given' do
       it 'should return checkins as FbGraph::Checkin' do
-        mock_graph :get, 'gowalla/checkins', 'pages/checkins/gowalla_private', :params => {
-          :access_token => 'access_token'
-        } do
+        mock_graph :get, 'gowalla/checkins', 'pages/checkins/gowalla_private', :access_token => 'access_token' do
           checkins = FbGraph::Page.new('gowalla', :access_token => 'access_token').checkins
           checkins.first.should == FbGraph::Checkin.new(
             '696876187499',

data/spec/fb_graph/connections/comments_spec.rb

@@ -96,7 +96,7 @@ end
 
 describe FbGraph::Connections::Comments, '#unlike!' do
   it 'should DELETE /:object_id/likes' do
-    mock_graph :delete, '12345/likes', 'true', :params => {:access_token => 'valid'} do
+    mock_graph :delete, '12345/likes', 'true', :access_token => 'valid' do
       FbGraph::Post.new('12345', :access_token => 'valid').unlike!
     end
   end

data/spec/fb_graph/connections/declined_spec.rb

@@ -6,9 +6,7 @@ describe FbGraph::Connections::Declined, '#declined' do
   end
 
   it 'should return declined users as FbGraph::User' do
-    mock_graph :get, 'smartday/declined', 'events/declined/smartday_private', :params => {
-      :access_token => 'access_token'
-    } do
+    mock_graph :get, 'smartday/declined', 'events/declined/smartday_private', :access_token => 'access_token' do
       users = FbGraph::Event.new('smartday', :access_token => 'access_token').declined
       users.each do |user|
         user.should be_instance_of(FbGraph::User)
@@ -19,9 +17,7 @@ end
 
 describe FbGraph::Connections::Declined, '#declined!' do
   it 'should return true' do
-    mock_graph :post, '12345/declined', 'events/declined/post_with_valid_access_token', :params => {
-      :access_token => 'valid'
-    } do
+    mock_graph :post, '12345/declined', 'events/declined/post_with_valid_access_token', :access_token => 'valid' do
       FbGraph::Event.new('12345', :access_token => 'valid').declined!.should be_true
     end
   end

data/spec/fb_graph/connections/events_spec.rb

@@ -14,9 +14,7 @@ describe FbGraph::Connections::Events, '#events' do
 
     context 'when access_token is given' do
       it 'should return events as FbGraph::Event' do
-        mock_graph :get, 'matake/events', 'users/events/matake_private', :params => {
-          :access_token => 'access_token'
-        } do
+        mock_graph :get, 'matake/events', 'users/events/matake_private', :access_token => 'access_token' do
           events = FbGraph::User.new('matake', :access_token => 'access_token').events
           events.first.should == FbGraph::Event.new(
             '116600818359630',

data/spec/fb_graph/connections/family_spec.rb

@@ -14,9 +14,7 @@ describe FbGraph::Connections::Family, '#family' do
 
     context 'when access_token is given' do
       it 'should return family members as FbGraph::User' do
-        mock_graph :get, 'me/family', 'users/family/me_public', :params => {
-          :access_token => 'access_token'
-        } do
+        mock_graph :get, 'me/family', 'users/family/me_public', :access_token => 'access_token' do
           users = FbGraph::User.new('me', :access_token => 'access_token').family
           users.first.should == FbGraph::User.new(
             '720112389',

data/spec/fb_graph/connections/feed_spec.rb

@@ -33,9 +33,7 @@ describe FbGraph::Connections::Feed, '#feed' do
 
     context 'when access_token is given' do
       it 'should return posts on the user\'s wall as FbGraph::Post' do
-        mock_graph :get, 'arjun/feed', 'users/feed/arjun_private', :params => {
-          :access_token => 'access_token'
-        } do
+        mock_graph :get, 'arjun/feed', 'users/feed/arjun_private', :access_token => 'access_token' do
           posts = FbGraph::User.new('arjun').feed(:access_token => 'access_token')
           posts.first.should == FbGraph::Post.new(
             '7901103_121392141207495',