mogli 0.0.29 → 0.0.30

data/lib/mogli/client.rb

@@ -10,7 +10,7 @@ module Mogli
     include HTTParty
     include Mogli::Client::Event
     include Mogli::Client::User
-    
+
     class ClientException < Exception; end
     class UnrecognizeableClassError < ClientException; end
     class QueryParseException < ClientException; end
@@ -19,6 +19,7 @@ module Mogli
     class OAuthException < ClientException; end
     # represents case that the facebook limit on posts to a feed has been exceeded
     class FeedActionRequestLimitExceeded < ClientException; end
+    class SessionInvalidatedDueToPasswordChange < ClientException; end
     class HTTPException < ClientException; end
 
     def api_path(path)
@@ -32,7 +33,7 @@ module Mogli
     def fql_multiquery_path
       "https://api.facebook.com/method/fql.multiquery"
     end
-    
+
     def initialize(access_token = nil,expiration=nil)
       @access_token = access_token
       # nil expiration means extended access
@@ -49,7 +50,7 @@ module Mogli
       post_data = get(authenticator.access_token_url(code)).parsed_response
       if (response_is_error?(post_data))
         raise_client_exception(post_data)
-      end        
+      end
       parts = post_data.split("&")
       hash = {}
       parts.each do |p| (k,v) = p.split("=")
@@ -61,10 +62,10 @@ module Mogli
       else
         expires = nil
       end
- 
+
       new(hash["access_token"],expires)
     end
-    
+
     def self.raise_client_exception(post_data)
       raise_error_by_type_and_message(post_data["error"]["type"], post_data["error"]["message"])
     end
@@ -72,13 +73,15 @@ module Mogli
     def self.raise_error_by_type_and_message(type, message)
       if type == 'OAuthException' && message =~ /Feed action request limit reached/
         raise FeedActionRequestLimitExceeded.new(message)
+      elsif type == 'OAuthException' && message =~ /The session has been invalidated because the user has changed the password/
+        raise SessionInvalidatedDueToPasswordChange.new(message)
       elsif Mogli::Client.const_defined?(type)
         raise Mogli::Client.const_get(type).new(message)
       else
         raise ClientException.new("#{type}: #{message}")
       end
     end
-    
+
     def self.response_is_error?(post_data)
        post_data.kind_of?(Hash) and
        !post_data["error"].blank?
@@ -87,10 +90,19 @@ module Mogli
     def self.create_from_session_key(session_key, client_id, secret)
       authenticator = Mogli::Authenticator.new(client_id, secret, nil)
       access_data = authenticator.get_access_token_for_session_key(session_key)
-      new(access_data['access_token'],
-          Time.now.to_i + access_data['expires'].to_i)
+      new(access_token_from_access_data(access_data),expiration_from_access_data(access_data))
+    end
+    
+    def self.access_token_from_access_data(access_data)
+      return nil if access_data.nil?
+      access_data['access_token']
     end
     
+    def self.expiration_from_access_data(access_data)
+      return nil if access_data.nil? or access_data['expires'].nil?
+      Time.now.to_i + access_data['expires'].to_i
+    end
+
     def self.create_and_authenticate_as_application(client_id, secret)
       authenticator = Mogli::Authenticator.new(client_id, secret, nil)
       access_data = authenticator.get_access_token_for_application
@@ -123,7 +135,7 @@ module Mogli
       data = self.class.post(fql_multiquery_path,:body=>default_params.merge({:queries=>queries.to_json,:format=>"json"}))
       map_data(data)
     end
-    
+
     def get_and_map(path,klass=nil,body_args = {})
       data = self.class.get(api_path(path),:query=>default_params.merge(body_args))
       data = data.values if body_args.key?(:ids) && !data.key?('error')
@@ -146,13 +158,12 @@ module Mogli
 
     def extract_hash_or_array(hash_or_array,klass)
       hash_or_array = hash_or_array.parsed_response if hash_or_array.respond_to?(:parsed_response)
-      return nil if hash_or_array == false || hash_or_array == true
-
+      return nil if hash_or_array == false
       return hash_or_array if hash_or_array.nil? or hash_or_array.kind_of?(Array)
       return extract_fetching_array(hash_or_array,klass) if is_fetching_array?(hash_or_array)
       return hash_or_array
     end
-    
+
     def is_fetching_array?(hash)
       hash.has_key?("data") and hash["data"].instance_of?(Array)
     end
@@ -185,7 +196,7 @@ module Mogli
       end
       klass_to_create.new(data,self)
     end
-    
+
     def capitalize_if_required(string)
       string.downcase == string ? string.capitalize : string
     end
@@ -201,12 +212,12 @@ module Mogli
     end
 
     def raise_error_if_necessary(data)
+      raise HTTPException if data.respond_to?(:code) and data.code != 200
       if data.kind_of?(Hash)
         if data.keys.size == 1 and data["error"]
           self.class.raise_error_by_type_and_message(data["error"]["type"], data["error"]["message"])
         end
       end
-      raise HTTPException if data.respond_to?(:code) and data.code != 200
     end
 
     def fields_to_serialize

data/lib/mogli/education.rb

@@ -1,8 +1,9 @@
 module Mogli
   class Education < Model
 
-    define_properties :start_date, :end_date, :degree
+    define_properties :start_date, :end_date, :degree, :with
 
+    hash_populating_accessor :classes, "Page"
     hash_populating_accessor :school, "Page"
     hash_populating_accessor :year, "Page"
     hash_populating_accessor :concentration, "Page"

data/lib/mogli/page.rb

@@ -16,9 +16,6 @@ module Mogli
     # As a like
     define_properties :created_time
 
-    # Number of checkins, not Checkin assocciation.
-    define_properties :checkins
-
     def client_for_page
       if access_token.blank?
         raise MissingAccessToken.new("You can only get a client for this page if an access_token has been provided. i.e. via /me/accounts")

data/lib/mogli/user.rb

@@ -4,12 +4,16 @@ module Mogli
 
     define_properties :username, :first_name, :last_name, :link, :about, :birthday, :gender,
           :email, :website, :timezone, :updated_time, :verified, :political, :bio,
-          :relationship_status, :locale, :religion, :quotes, :third_party_id
+          :relationship_status, :locale, :religion, :quotes, :third_party_id,
+          :inspirational_people, :sports, :with, :middle_name
 
     def self.recognize?(hash)
       !hash.has_key?("category")
     end
 
+    hash_populating_accessor :favorite_athletes, "Page"
+    hash_populating_accessor :favorite_teams, "Page"
+
     hash_populating_accessor :work, "Work"
     hash_populating_accessor :education, "Education"
 

data/lib/mogli/work.rb

@@ -1,8 +1,9 @@
 module Mogli
   class Work < Model
     
-    define_properties :start_date, :end_date, :description
+    define_properties :start_date, :end_date, :description, :with, :from
     
+    hash_populating_accessor :projects, "Page"
     hash_populating_accessor :employer, "Page"
     hash_populating_accessor :location, "Page"
     hash_populating_accessor :position, "Page"

data/spec/app_client_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+describe Mogli::AppClient do
+  describe "subscribing" do
+    let :client do
+      a=Mogli::AppClient.new('key')
+      a.application_id="123"
+      a
+    end
+    
+    it "should allow you to subscribe with callback url, fields and verify token" do
+      Mogli::Client.should_receive(:post).with("https://graph.facebook.com/123/subscriptions",an_instance_of(Hash))
+      client.subscribe_to_model(Mogli::User,:callback_url=>"http://localhost:3000",:fields=>["username"])
+    end
+    
+    it "should pass the type as the object field" do
+      Mogli::Client.should_receive(:post).with("https://graph.facebook.com/123/subscriptions",{:body=>hash_including(:object=>"user")})
+      client.subscribe_to_model(Mogli::User,:callback_url=>"http://localhost:3000",:fields=>["username"])
+    end
+    
+    it "sends the list of fields comma separated" do
+      Mogli::Client.should_receive(:post).with("https://graph.facebook.com/123/subscriptions",{:body=>hash_including(:fields=>"username,friends")})
+      client.subscribe_to_model(Mogli::User,:callback_url=>"http://localhost:3000",:fields=>["username,friends"])
+    end
+    it "sends the callback url" do
+      Mogli::Client.should_receive(:post).with("https://graph.facebook.com/123/subscriptions",{:body=>hash_including(:callback_url=>"http://localhost:3000")})
+      client.subscribe_to_model(Mogli::User,:callback_url=>"http://localhost:3000",:fields=>["username"])
+    end
+    
+    it "should send the verify token if provided" do
+      Mogli::Client.should_receive(:post).with("https://graph.facebook.com/123/subscriptions",{:body=>hash_including(:verify_token=>"TOKEN")})
+      client.subscribe_to_model(Mogli::User,:callback_url=>"http://localhost:3000",:fields=>["username"],:verify_token=>"TOKEN")
+      
+    end
+    
+    it "Lists the existing subscriptions" do
+     client.should_receive(:get_and_map_url).with("https://graph.facebook.com/123/subscriptions","Subscription")
+     client.subscriptions
+    end
+  end
+
+end

data/spec/authenticator_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+describe Mogli::Authenticator do
+
+  let :authenticator do
+    Mogli::Authenticator.new("123456","secret","http://example.com/url")
+  end
+
+  it "has the client id" do
+    authenticator.client_id.should == "123456"
+  end
+
+  it "has the secret" do
+    authenticator.secret.should == "secret"
+  end
+
+  it "has the callback url" do
+    authenticator.callback_url.should == "http://example.com/url"
+  end
+
+  it "creates the authorize_url" do
+    authenticator.authorize_url.should == "https://graph.facebook.com/oauth/authorize?client_id=123456&redirect_uri=http%3A%2F%2Fexample.com%2Furl"
+  end
+
+  it "creates the authorize_url with scopes as an array" do
+    authenticator.authorize_url(:scope=>[:user_photos,:user_videos,:stream_publish]).should ==
+      "https://graph.facebook.com/oauth/authorize?client_id=123456&redirect_uri=http%3A%2F%2Fexample.com%2Furl&scope=user_photos,user_videos,stream_publish"
+  end
+
+  it "creates the access_token_url" do
+    authenticator.access_token_url("mycode").should == "https://graph.facebook.com/oauth/access_token?client_id=123456&redirect_uri=http%3A%2F%2Fexample.com%2Furl&client_secret=secret&code=mycode"
+  end
+
+  it "can trade session_keys for access_tokens" do
+    response = [{"access_token" => "myaccesstoken",   "expires" => 5000},
+                {"access_token" => "youraccesstoken", "expires" => 5000}]
+    response.stub!(:code).and_return(200)
+
+    Mogli::Client.should_receive(:post).
+      with("https://graph.facebook.com/oauth/exchange_sessions",
+           :body => {:type => "client_cred", :client_id => "123456",
+                     :client_secret => "secret",
+                     :sessions => "mysessionkey,yoursessionkey"}).
+      and_return(response)
+
+    authenticator.
+      get_access_token_for_session_key(["mysessionkey","yoursessionkey"]).
+      should == [{"access_token" => "myaccesstoken",   "expires" => 5000},
+                 {"access_token" => "youraccesstoken", "expires" => 5000}]
+  end
+
+  it "can trade one session_key for an access_tokens" do
+    response = {"access_token" => "myaccesstoken", "expires" => 5000}
+    response.stub!(:code).and_return(200)
+    Mogli::Client.should_receive(:post).
+      with("https://graph.facebook.com/oauth/exchange_sessions",
+           :body => {:type => "client_cred", :client_id => "123456",
+                     :client_secret => "secret", :sessions => "mysessionkey"}).
+      and_return(response)
+
+    authenticator.
+      get_access_token_for_session_key("mysessionkey").
+      should == {"access_token" => "myaccesstoken", "expires" => 5000}
+  end
+  
+  it "can ask for an application token" do
+    response = "access_token=123456|3SDdfgdfgv0bbEvYjBH5tJtl-dcBdsfgo"
+    response.stub!(:code).and_return(200)
+    Mogli::Client.should_receive(:post).
+      with("https://graph.facebook.com/oauth/access_token",
+           :body=> {
+             :grant_type => 'client_credentials',
+             :client_id => "123456",
+             :client_secret => "secret"
+           }).
+      and_return(response)
+      
+      
+      token = authenticator.get_access_token_for_application
+      token.should =="123456|3SDdfgdfgv0bbEvYjBH5tJtl-dcBdsfgo"
+  end
+  
+  it "raises an error if not a 200" do
+    response = "access_token=123456|3SDdfgdfgv0bbEvYjBH5tJtl-dcBdsfgo"
+    response.stub!(:code).and_return(500)
+    Mogli::Client.should_receive(:post).and_return(response)
+    lambda do
+      token = authenticator.get_access_token_for_application
+    end.should raise_error(Mogli::Client::HTTPException)
+    
+  end
+
+end

data/spec/client/client_event_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+describe Mogli::Client do
+  let :client do
+    Mogli::Client.new
+  end
+  
+  it "fetches an event by id" do
+    client.should_receive(:get_and_map).with(118515001510745,Mogli::Event).and_return("event")
+    client.event(118515001510745).should == "event"
+  end
+  
+end

data/spec/client/client_user_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+describe Mogli::Client do
+  let :client do
+    Mogli::Client.new
+  end
+  
+  it "fetches a user by id" do
+    client.should_receive(:get_and_map).with(12451752,Mogli::User).and_return("user")
+    client.user(12451752).should == "user"
+  end
+  
+end

data/spec/client_spec.rb

@@ -0,0 +1,354 @@
+require "spec_helper"
+describe Mogli::Client do
+
+  let :client do
+    Mogli::Client.new
+  end
+
+
+  describe "creation" do
+    it "allows creating with an access_token" do
+      client = Mogli::Client.new("myaccesstoken")
+      client.access_token.should == "myaccesstoken"
+    end
+
+    context "when exchanging a session key" do
+      it "allows creating" do
+        Time.stub!(:now).and_return(1270000000)
+        authenticator = Mogli::Authenticator.new('123456', 'secret', nil)
+        authenticator.should_receive(:get_access_token_for_session_key).
+                      with('mysessionkey').
+                      and_return({'access_token' => 'myaccesstoken',
+                                  'expires' => 5000})
+        Mogli::Authenticator.should_receive(:new).and_return(authenticator)
+        client = Mogli::Client.create_from_session_key(
+                   'mysessionkey', '123456', 'secret')
+        client.access_token.should == 'myaccesstoken'
+        client.expiration.should == Time.at(1270005000)
+      end
+
+      it "allows creating and authenticating as an application" do
+        authenticator = Mogli::Authenticator.new('123456', 'secret', nil)
+        authenticator.should_receive(:get_access_token_for_application).
+                      and_return("123456|3SDdfgdfgv0bbEvYjBH5tJtl-dcBdsfgo")
+        Mogli::Authenticator.should_receive(:new).and_return(authenticator)
+        client = Mogli::Client.create_and_authenticate_as_application(
+                   'mysessionkey', '123456')
+        client.access_token.should == '123456|3SDdfgdfgv0bbEvYjBH5tJtl-dcBdsfgo'
+      end
+
+      it "doesn't bail when the session key is stale" do
+        Time.stub!(:now).and_return(1270000000)
+        authenticator = Mogli::Authenticator.new('123456', 'secret', nil)
+        authenticator.should_receive(:get_access_token_for_session_key).
+                      with('mysessionkey').
+                      and_return(nil)
+        Mogli::Authenticator.should_receive(:new).and_return(authenticator)
+        lambda {
+          client = Mogli::Client.create_from_session_key(
+                     'mysessionkey', '123456', 'secret')
+        }.should_not raise_exception(NoMethodError, /nil/)
+      end
+
+      it "treats missing expiries as nonexpiring access tokens" do
+        Time.stub!(:now).and_return(1270000000)
+        authenticator = Mogli::Authenticator.new('123456', 'secret', nil)
+        authenticator.should_receive(:get_access_token_for_session_key).
+                      with('mysessionkey').
+                      and_return({'access_token' => 'myaccesstoken'})
+        Mogli::Authenticator.should_receive(:new).and_return(authenticator)
+        client = Mogli::Client.create_from_session_key(
+                   'mysessionkey', '123456', 'secret')
+        client.expiration.should == Time.at(Time.now + 10*365*24*60*60)
+      end
+    end
+
+    it "sets the access_token into the default params" do
+      client = Mogli::Client.new("myaccesstoken")
+      client.default_params.should == {:access_token=>"myaccesstoken"}
+    end
+
+    it "sets the expiration time if provided" do
+      old_now=Time.now
+      Time.stub!(:now).and_return(old_now)
+      client = Mogli::Client.new("myaccesstoken",old_now.to_i)
+      client.expiration.to_i.should == old_now.to_i
+    end
+
+    it "should know if the session is expired" do
+      client = Mogli::Client.new("myaccesstoken",Time.now - 100)
+      client.should be_expired
+    end
+
+    it "allow creation with no access token" do
+      client = Mogli::Client.new
+      client.access_token.should be_nil
+    end
+
+    it "doesn't include the access_token param when not passed" do
+      client = Mogli::Client.new
+      client.default_params.should == {}
+    end
+    
+
+    it "create get an unescaped access token from an authenticator and code" do
+      Mogli::Client.should_receive(:get).with("url").and_return(mock("response",:parsed_response=>
+      "access_token=114355055262088%7C2.6_s8VD_HRneAq3_tUEHJhA__.3600.1272920400-12451752|udZzWly7ptI7IMgX7KTdzaoDrhU.&expires=4168"))
+      client = Mogli::Client.create_from_code_and_authenticator("code",mock("auth",:access_token_url=>"url"))
+      client.access_token.should == "114355055262088|2.6_s8VD_HRneAq3_tUEHJhA__.3600.1272920400-12451752|udZzWly7ptI7IMgX7KTdzaoDrhU."
+      client.expiration.should_not be_nil
+      (client.expiration > Time.now).should be_true
+    end
+
+    it "create set the expiration into the future if there is on param" do
+      Mogli::Client.should_receive(:get).with("url").and_return(mock("response",:parsed_response=>"access_token=114355055262088%7C2.6_s8VD_HRneAq3_tUEHJhA__.3600.1272920400-12451752|udZzWly7ptI7IMgX7KTdzaoDrhU."))
+      client = Mogli::Client.create_from_code_and_authenticator("code",mock("auth",:access_token_url=>"url"))
+      (client.expiration > Time.now+365*24*60*60).should be_true
+    end
+
+    it "create throw exception if facebook returns exception" do
+      err_msg = "Some message"
+      err_type = "ErrorType"
+      response={"error"=>{"type"=>err_type,"message"=>err_msg}}
+      mock_response = mock("response",:parsed_response=>response,:is_a? => true,:[] => response["error"])
+      Mogli::Client.should_receive(:get).with("url").and_return(mock_response)
+      begin 
+        client = Mogli::Client.create_from_code_and_authenticator("code",mock("auth",:access_token_url=>"url"))
+      rescue Exception => e
+        e.message.should == "#{err_type}: #{err_msg}"
+      end
+    end
+
+  end
+
+
+  describe "Making requests" do
+    it "posts with the parameters in the body" do
+      Mogli::Client.should_receive(:post).with("https://graph.facebook.com/1/feed",:body=>{:message=>"message",:access_token=>"1234"})
+      client = Mogli::Client.new("1234")
+      client.post("1/feed","Post",:message=>"message")
+    end
+
+    it "parses errors in the returns of posts" do
+      Mogli::Client.should_receive(:post).and_return({"error"=>{"type"=>"OAuthAccessTokenException","message"=>"An access token is required to request this resource."}})
+      client = Mogli::Client.new("1234")
+      lambda do
+        result = client.post("1/feed","Post",:message=>"message")
+      end.should raise_error(Mogli::Client::OAuthAccessTokenException, "An access token is required to request this resource.")
+    end
+    
+    it "parses http response errors" do
+      Mogli::Client.should_receive(:post).and_return(mock("httpresponse",:code=>500))
+      client = Mogli::Client.new("1234")
+      lambda do
+        result = client.post("1/feed","Post",:message=>"message")
+      end.should raise_error(Mogli::Client::HTTPException)
+      
+    end
+
+    it "creates objects of the returned type" do
+      Mogli::Client.should_receive(:post).and_return({:id=>123434})
+      client = Mogli::Client.new("1234")
+      result = client.post("1/feed","Post",:message=>"message")
+      result.should == Mogli::Post.new(:id=>123434)
+    end
+    
+    it "creates object in a way that ignore invalid properties" do
+      Mogli::Client.stub!(:post).and_return({:id=>123434,:completely_invalid_property=>1})
+      client = Mogli::Client.new("1234")
+      lambda do
+        result = client.post("1/feed","Post",:message=>"message")
+      end.should_not raise_error
+    end
+
+    it "raises specific exception if Facebook-imposed posting limit exceeded for feed" do
+      error_message = "Feed action request limit reached"
+      Mogli::Client.should_receive(:post).and_return({"error"=>{"type"=>"OAuthException","message"=>error_message}})
+      client = Mogli::Client.new("1234")
+      lambda do
+        result = client.post("1/feed","Post",:message=>"message")
+      end.should raise_error(Mogli::Client::FeedActionRequestLimitExceeded, error_message)
+    end
+
+  end
+
+  it "allows deleting" do
+    Mogli::Client.should_receive(:delete).with("https://graph.facebook.com/1",:query=>{:access_token=>"1234"})
+    client = Mogli::Client.new("1234")
+    client.delete("1")
+  end
+
+
+  describe "fql queries" do 
+    it "defaults to json" do
+      Mogli::Client.should_receive(:post).with("https://api.facebook.com/method/fql.query",:body=>{:query=>"query",:format=>"json",:access_token=>"1234"})
+      client = Mogli::Client.new("1234")
+      client.fql_query("query")
+    end
+
+    it "supports xml" do 
+      Mogli::Client.should_receive(:post).with("https://api.facebook.com/method/fql.query",:body=>{:query=>"query",:format=>"xml",:access_token=>"1234"})
+      client = Mogli::Client.new("1234")
+      client.fql_query("query",nil,"xml")  
+    end
+
+    it "creates objects if given a class" do
+      Mogli::Client.should_receive(:post).and_return({"id"=>12451752, "first_name"=>"Mike", "last_name"=>"Mangino" })
+      client = Mogli::Client.new("1234")
+      client.fql_query("query","user").should be_an_instance_of(Mogli::User)
+    end
+
+    it "returns a hash if no class is given" do
+      Mogli::Client.should_receive(:post).and_return({"id"=>12451752, "first_name"=>"Mike", "last_name"=>"Mangino" })
+      client = Mogli::Client.new("1234")
+      client.fql_query("query").should be_an_instance_of(Hash)
+    end
+
+    it "doesn't create objects if the format is xml" do 
+      Mogli::Client.should_receive(:post).and_return({"id"=>12451752, "first_name"=>"Mike", "last_name"=>"Mangino" })
+      client = Mogli::Client.new("1234")
+      client.fql_query("query","user","xml").should be_an_instance_of(Hash)    
+    end
+  end
+
+  describe "fql multiqueries" do 
+    it "defaults to json" do
+      fql = {"query1"=>"select uid from user"}
+      Mogli::Client.should_receive(:post).with("https://api.facebook.com/method/fql.multiquery",:body=>{:format=>"json",:queries=>fql.to_json,:access_token=>"1234"})
+      client = Mogli::Client.new("1234")
+      client.fql_multiquery(fql)
+    end
+    
+    it "returns hash with query names and values matching desired classes" do
+      Mogli::Client.should_receive(:post).and_return([
+        {"name"=>"users", "fql_result_set"=>[{"uid"=>12451752, "first_name"=>"Mike", "last_name"=>"Mangino"}]},
+        {"name"=>"comment_user","fql_result_set"=>[{"fromid"=>12451752}]}
+      ])
+      
+      f = Mogli::FqlMultiquery.new(Mogli::Client.new("1234"))
+      f.add_named_query_for_class("comment_user", "SELECT fromid FROM comment WHERE post_id = 123343434", Mogli::Comment)
+      f.add_named_query_for_class("users", "SELECT uid, first_name, last_name FROM user WHERE uid IN (SELECT fromid FROM #comment_user)", Mogli::User)
+      results = f.results
+      results["users"].first.class.should == Mogli::User
+      results["comment_user"].first.class.should == Mogli::Comment
+    end
+  end
+  
+  describe "result mapping" do
+
+    let :user_data do
+       {"id"=>12451752, "first_name"=>"Mike", "last_name"=>"Mangino" }
+    end
+
+    it "returns the raw value with no class specified" do
+      client.map_data(user_data).should be_an_instance_of(Hash)
+    end
+    
+    it "returns nil if we get a false response" do
+      client.map_data(false,Mogli::User).should be_false
+    end
+    it "returns false if we get a false response" do
+      client.map_to_class(false,Mogli::User).should be_false
+    end
+    
+
+    it "returns the array if no class is specified and there is only a data parameter" do
+      client.map_data({"data"=>[user_data,user_data]}).should be_kind_of(Array)
+    end
+
+    it "creates an instance of the class when specified" do
+      user = client.map_data(user_data,Mogli::User)
+      user.should be_an_instance_of(Mogli::User)
+      user.id.should == 12451752
+    end
+
+    it "creates an array of instances when the data is an array" do
+      users = client.map_data([user_data,user_data],Mogli::User)
+      users.should be_an_instance_of(Array)
+      users.each {|i| i.should be_an_instance_of(Mogli::User) }
+      users.size.should == 2
+    end
+
+    it "creates an array of instances when the data is just a hash with a single data parameter" do
+      users = client.map_data({"data"=>[user_data,user_data],"paging"=>{}},Mogli::User)
+      users.should be_kind_of(Array)
+      users.each {|i| i.should be_an_instance_of(Mogli::User) }
+      users.size.should == 2
+    end
+
+    it "create an instance of fetching array when there is a data element" do
+      users = client.map_data({"data"=>[user_data,user_data],"paging"=>{}},Mogli::User)
+      users.should be_an_instance_of(Mogli::FetchingArray)
+    end
+
+    it "sets the client on the array" do
+      users = client.map_data({"data"=>[user_data,user_data],"paging"=>{}},Mogli::User)
+      users.client.should == client
+    end
+
+    it "sets the next url on the array" do
+      users = client.map_data({"data"=>[user_data,user_data],"paging"=>{"next"=>"next"}},Mogli::User)
+      users.next_url.should == "next"
+    end
+
+    it "sets the previous url on the array" do
+      users = client.map_data({"data"=>[user_data,user_data],"paging"=>{"previous"=>"prev"}},Mogli::User)
+      users.previous_url.should == "prev"
+    end
+
+    it "sets the classes on the array" do
+      users = client.map_data({"data"=>[user_data,user_data],"paging"=>{"previous"=>"prev"}},Mogli::User)
+      users.classes.should == [Mogli::User]
+    end
+
+    it "sets the client in the newly created instance" do
+      user = client.map_data(user_data,Mogli::User)
+      user.client.should == client
+    end
+
+    it "returns nil if Facebook says false" do
+      Mogli::Client.should_receive(:get).and_return(false)
+      client.get_and_map(148800401968,"User").should be_nil
+    end
+
+    it "raises an exception with specific message when there is just an error" do
+      lambda do
+        client.map_data({"error"=>{"type"=>"OAuthAccessTokenException","message"=>"An access token is required to request this resource."}})
+      end.should raise_error(Mogli::Client::OAuthAccessTokenException, "An access token is required to request this resource.")
+    end
+
+    it "raises a OAuthException when a token is invalidated by a user logging out of Facebook" do
+      lambda do
+        client.map_data({"error"=>{"type"=>"OAuthException","message"=>"Error validating access token."}})
+      end.should raise_error(Mogli::Client::OAuthException, "Error validating access token.")
+    end
+
+    it "raises a generic ClientException when the exception type is not recorgnized" do
+      lambda do
+        client.map_data({"error"=>{"type"=>"Foo","message"=>"Lorem ipsum."}})
+      end.should raise_error(Mogli::Client::ClientException, "Foo: Lorem ipsum.")
+    end
+
+    describe "Instance creation" do
+      it "will find the class in the Mogli namespace if given a string" do
+        client.create_instance("User",{:id=>1}).should be_an_instance_of(Mogli::User)
+      end
+
+      it "will NOT use the value from the type field if it exists" do
+        client.create_instance("Post",{:id=>1,"type"=>"status"}).should be_an_instance_of(Mogli::Post)
+      end
+
+      it "call the recognize method on each class passing the data and will use the one that recognizes it" do
+        Mogli::User.should_receive(:recognize?).with(:id=>1).and_return(false)
+        Mogli::Post.should_receive(:recognize?).with(:id=>1).and_return(true)
+        client.create_instance(["User","Post"],{:id=>1}).should be_an_instance_of(Mogli::Post)
+      end
+
+      it "will use the first class if none are recognized" do
+        Mogli::Page.should_receive(:recognize?).with(:id=>1).and_return(false)
+        client.create_instance(["Page"],{:id=>1}).should be_an_instance_of(Mogli::Page)
+      end
+    end
+  end
+
+end