fb_graph 2.7.3 → 2.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c41a5db1d62f6356aceae001c8aa779c785a6f5e
-  data.tar.gz: d08ed080c63f5278124d1001e52ca480abac4cd7
+  metadata.gz: f394a8d8b3ac2e339d04d51b5cd3cb8f84326acd
+  data.tar.gz: 3ec54684dd935ae3f7f86c2cb7a040e4ffb6c5d7
 SHA512:
-  metadata.gz: 069da1d9cd6cae38ee5c189066c4ea17e3c3f1b02bf28b5f0012d3214046c3d271dac0234b4914b5377cda7a51ca58a5a0ad07de629368bc112d21324c83daf8
-  data.tar.gz: 752610f699973e87cdea79e2c6dfb78c132f72524e11eefa52b25071ed840f95c34dd41a9f5cd1b85b3fa00bfdc5948930d54e6ba44eefcbef633e08b093006f
+  metadata.gz: 738a30bc38006244ac3aeeb59498e7a9565d4ad87004288ff344249df374e78f7f02ff54867c5b06012444cf60c049c29dbfc989cf029911fe9d43e83e181781
+  data.tar.gz: 347d5b4d682d68145126f151374c497836853c4261d65b9ff2be2ab90f29024cb75ab76712dd4d236dbaba02846f705a3cd64529de3cdbb3c3685c6672edbfd4

data/VERSION

@@ -1 +1 @@
-2.7.3
+2.7.4

data/lib/fb_graph/auth.rb

@@ -56,7 +56,7 @@ module FbGraph
       self.access_token = client.access_token! :client_auth_body
       self
     rescue Rack::OAuth2::Client::Error => e
-      Exception.handle_rack_oauth2_error e
+      Exception.handle_response e.status, e.message
     end
 
     private
@@ -69,7 +69,7 @@ module FbGraph
       self.user = User.new(data[:user_id], :access_token => access_token)
       self
     rescue Rack::OAuth2::Client::Error => e
-      Exception.handle_rack_oauth2_error e
+      Exception.handle_response e.status, e.message
     end
 
     def build_access_token(data)

data/lib/fb_graph/exception.rb

@@ -1,6 +1,7 @@
 module FbGraph
   class Exception < StandardError
-    attr_accessor :code, :type
+    attr_accessor :status, :type, :error_code, :error_subcode
+    alias_method :code, :status
 
     ERROR_HEADER_MATCHERS = {
       /not_found/ => "NotFound",
@@ -20,121 +21,123 @@ module FbGraph
       /QueryDuplicateKeyException/          => "QueryDuplicateKey"
     }
 
-    def self.handle_httpclient_error(response, headers)
-      return nil unless (response[:error] || response[:error_code] || response[:error_msg])
-
-      # Sometimes we see an error that does not have the "error" field, but instead has both "error_code" and "error_msg"
-      # example: {"error_code":1,"error_msg":"An unknown error occurred"}
-      if (response[:error_code] && response[:error_msg] && !response[:error])
-        raise InternalServerError.new("#{response[:error_code]} :: #{response[:error_msg]}")
+    class << self
+      def handle_structured_response(status, details, headers)
+        if (error = details[:error])
+          klass = klass_for_header(headers, error) || klass_for_structured_body(error)
+          message = [
+            error[:type]    || 'unknown error type',
+            error[:message] || 'unknown error message'
+          ].join(' :: ')
+          if klass
+            raise klass.new(message, details)
+          else
+            handle_response status, message, details
+          end
+        else
+          message = [
+            details[:error_code] || 'unknown error_code',
+            details[:error_msg]  || 'unknown error_msg'
+          ].compact.join(' :: ')
+          handle_response status, message, details
+        end
       end
 
-      # Check the WWW-Authenticate header, since it seems to be more standardized than the response
-      # body error information.
-      # The complex lookup is needed to follow the HTTP spec - headers should be looked up
-      # without regard to case.
-      www_authenticate = headers.select do |name, value|
-        name.upcase == "WWW-Authenticate".upcase
-      end.to_a.flatten.second
-      if www_authenticate
-        # Session expiration/invalidation is very common. Check for that first.
-        if www_authenticate =~ /invalid_token/ && response[:error][:message] =~ /session has been invalidated/
-          raise InvalidSession.new("#{response[:error][:type]} :: #{response[:error][:message]}")
+      def handle_response(status, message, details = {})
+        klass = klass_for_status status
+        exception = if klass
+          klass.new message, details
+        else
+          Exception.new status, message, details
         end
+        raise exception
+      end
 
-        ERROR_HEADER_MATCHERS.keys.each do |matcher|
-          if matcher =~ www_authenticate
-            exception_class = FbGraph::const_get(ERROR_HEADER_MATCHERS[matcher])
-            raise exception_class.new("#{response[:error][:type]} :: #{response[:error][:message]}")
-          end
+      def klass_for_status(status)
+        case status
+        when 400
+          BadRequest
+        when 401
+          Unauthorized
+        when 404
+          NotFound
+        when 500
+          InternalServerError
         end
       end
 
-      # If we can't match on WWW-Authenticate, use the type
-      case response[:error][:type]
-      when /OAuth/
-        raise Unauthorized.new("#{response[:error][:type]} :: #{response[:error][:message]}")
-      else
-        exception_class = nil
-        ERROR_EXCEPTION_MATCHERS.keys.each do |matcher|
-          exception_class = FbGraph::const_get(ERROR_EXCEPTION_MATCHERS[matcher]) if matcher =~ response[:error][:message]
-        end
-        if exception_class
-          raise exception_class.new("#{response[:error][:type]} :: #{response[:error][:message]}")
+      def klass_for_header(headers, error)
+        key, value = headers.detect do |name, value|
+          name.upcase == "WWW-Authenticate".upcase
+        end || return
+        if value =~ /invalid_token/ && error[:message] =~ /session has been invalidated/
+          InvalidSession
         else
-          raise BadRequest.new("#{response[:error][:type]} :: #{response[:error][:message]}")
+          matched, klass_name = ERROR_HEADER_MATCHERS.detect do |matcher, klass_name|
+            matcher =~ value
+          end || return
+          FbGraph::const_get klass_name
         end
       end
-    end
 
-    def self.handle_rack_oauth2_error(e)
-      exception = case e.status
-      when 400
-        BadRequest.new(e.message)
-      when 401
-        Unauthorized.new(e.message)
-      else
-        Exception.new(e.status, e.message)
+      def klass_for_structured_body(error)
+        case error[:type]
+        when /OAuth/
+          Unauthorized
+        else
+          matched, klass_name = ERROR_EXCEPTION_MATCHERS.detect do |matcher, klass_name|
+            matcher =~ error[:message]
+          end || return
+          FbGraph::const_get klass_name
+        end
       end
-      raise exception
     end
 
-    def initialize(code, message, body = '')
-      @code = code
-      if body.present?
-        response = MultiJson.load(body).with_indifferent_access
-        message = response[:error][:message]
-        @type = response[:error][:type]
+    def initialize(status, message, details = {})
+      @status = status
+      if (error = details.try(:[], :error))
+        @type          = error[:type]
+        @error_code    = error[:code]
+        @error_subcode = error[:error_subcode]
       end
       super message
     end
   end
 
   class BadRequest < Exception
-    def initialize(message, body = '')
-      super 400, message, body
+    def initialize(message, details = {})
+      super 400, message, details
     end
   end
 
   class Unauthorized < Exception
-    def initialize(message, body = '')
-      super 401, message, body
+    def initialize(message, details = {})
+      super 401, message, details
     end
   end
 
   class NotFound < Exception
-    def initialize(message, body = '')
-      super 404, message, body
+    def initialize(message, details = {})
+      super 404, message, details
     end
   end
 
   class InternalServerError < Exception
-    def initialize(message, body = '')
-      super 500, message, body
+    def initialize(message, details = {})
+      super 500, message, details
     end
   end
 
-  class InvalidToken < Unauthorized; end
-
-  class InvalidSession < InvalidToken; end
-
-  class InvalidRequest < BadRequest; end
-
-  class CreativeNotSaved < InternalServerError; end
-
-  class QueryLockTimeout < InternalServerError; end
-
-  class TargetingSpecNotSaved < InternalServerError; end
-
-  class AdgroupFetchFailure < InternalServerError; end
-
-  class OpenProcessFailure < InternalServerError; end
-
+  class InvalidToken             < Unauthorized; end
+  class InvalidSession           < InvalidToken; end
+  class InvalidRequest           < BadRequest;   end
+  class CreativeNotSaved         < InternalServerError; end
+  class QueryLockTimeout         < InternalServerError; end
+  class TargetingSpecNotSaved    < InternalServerError; end
+  class AdgroupFetchFailure      < InternalServerError; end
+  class OpenProcessFailure       < InternalServerError; end
   class TransactionCommitFailure < InternalServerError; end
-
-  class QueryError < InternalServerError; end
-
-  class QueryConnection < InternalServerError; end
-
-  class QueryDuplicateKey < InternalServerError; end
-end
+  class QueryError               < InternalServerError; end
+  class QueryConnection          < InternalServerError; end
+  class QueryDuplicateKey        < InternalServerError; end
+end

data/lib/fb_graph/node.rb

@@ -150,7 +150,7 @@ module FbGraph
         if (200...300).include?(response.status)
           _response_
         else
-          Exception.handle_httpclient_error(_response_, response.headers)
+          Exception.handle_structured_response(response.status, _response_, response.headers)
         end
       end
     rescue MultiJson::DecodeError

data/spec/fb_graph/exception_spec.rb

@@ -7,16 +7,19 @@ describe FbGraph::Exception do
   end
 
   context 'when response body is given' do
-    it 'should setup message and type from error' do
+    it 'should setup type, error code, and subcode from error' do
       err = FbGraph::Exception.new(400, 'This is the original message', {
         :error => {
           :type => 'SomeError',
-          :message => 'This is the error message'
+          :message => 'This is the error message',
+          :code => 190,
+          :error_subcode => 460
         }
-      }.to_json)
+      })
       err.code.should == 400
       err.type.should == 'SomeError'
-      err.message.should == 'This is the error message'
+      err.error_code.should == 190
+      err.error_subcode.should == 460
     end
   end
 
@@ -28,157 +31,189 @@ describe FbGraph::Exception do
       err.message.should == 'This is the original message'
     end
   end
-end
-
-describe FbGraph::BadRequest do
-  it 'should have 400 status code' do
-    err = FbGraph::BadRequest.new 'Bad Request'
-    err.code.should == 400
-  end
-end
-
-describe FbGraph::Unauthorized do
-  it 'should have 401 status code' do
-    err = FbGraph::Unauthorized.new 'Unauthorized'
-    err.code.should == 401
-  end
-end
-
-describe FbGraph::NotFound do
-  it 'should have 404 status code' do
-    err = FbGraph::NotFound.new 'Not Found'
-    err.code.should == 404
-  end
-end
 
-describe FbGraph::Exception, ".handle_httpclient_error" do
-  context "when WWW-Authenticate header is present" do
-    context "with an expired access token" do
-      let(:parsed_response) do
-        {
-          :error => {
-            :message => "Error validating access token: The session has been invalidated because the user has changed the password.",
-            :type => "OAuthException"
+  describe ".handle_structured_response" do
+    context "with WWW-Authenticate header" do
+      context "when token expired" do
+        let(:details) do
+          {
+            :error => {
+              :message => "Error validating access token: The session has been invalidated because the user has changed the password.",
+              :type => "OAuthException"
+            }
           }
-        }
-      end
-      let(:headers) do
-        {
-          "WWW-Authenticate" => 'OAuth "Facebook Platform" "invalid_token" "Error validating access token: The session has been invalidated because the user has changed the password.'
-        }
-      end
+        end
+        let(:headers) do
+          {
+            "WWW-Authenticate" => 'OAuth "Facebook Platform" "invalid_token" "Error validating access token: The session has been invalidated because the user has changed the password.'
+          }
+        end
 
-      it "should raise an InvalidSession exception" do
-        lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, headers)}.should raise_exception(FbGraph::InvalidSession)
+        it do
+          expect do
+            FbGraph::Exception.handle_structured_response(999, details, headers)
+          end.to raise_exception FbGraph::InvalidSession
+        end
       end
-    end
 
-    context "with an invalid access token" do
-      let(:parsed_response) do
-        {
-          :error => {
-            :message => 'Invalid OAuth access token.',
-            :type => "OAuthException"
+      context "when token invalid" do
+        let(:details) do
+          {
+            :error => {
+              :message => 'Invalid OAuth access token.',
+              :type => "OAuthException"
+            }
           }
-        }
-      end
-      let(:headers) do
-        {
-          "WWW-Authenticate" => 'OAuth "Facebook Platform" "invalid_token" "Invalid OAuth access token."'
-        }
-      end
+        end
+        let(:headers) do
+          {
+            "WWW-Authenticate" => 'OAuth "Facebook Platform" "invalid_token" "Invalid OAuth access token."'
+          }
+        end
+
+        it do
+          expect do
+            FbGraph::Exception.handle_structured_response(999, details, headers)
+          end.to raise_exception FbGraph::InvalidToken
+        end
+
+        context "with a variant capitalization of the header" do
+          let(:headers) do
+            {
+              "Www-Authenticate" => 'OAuth "Facebook Platform" "invalid_token" "Invalid OAuth access token."'
+            }
+          end
 
-      it "should raise an InvalidToken exception" do
-        lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, headers)}.should raise_exception(FbGraph::InvalidToken)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::InvalidToken
+          end
+        end
       end
 
-      context "with a variant capitalization of the header" do
+      context "with an invalid request" do
+        let(:details) do
+          {
+            :error => {
+              :message => '(#100) Must include the \"campaign_id\" index',
+              :type => "OAuthException"
+            }
+          }
+        end
         let(:headers) do
           {
-            "Www-Authenticate" => 'OAuth "Facebook Platform" "invalid_token" "Invalid OAuth access token."'
+            "WWW-Authenticate" =>'OAuth "Facebook Platform" "invalid_request" "(#100) Must include the \"campaign_id\" index"'
           }
         end
 
-        it "should raise an InvalidToken exception" do
-          lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, headers)}.should raise_exception(FbGraph::InvalidToken)
+        it do
+          expect do
+            FbGraph::Exception.handle_structured_response(999, details, headers)
+          end.to raise_exception FbGraph::InvalidRequest
         end
       end
-    end
 
-    context "with an invalid request" do
-      let(:parsed_response) do
-        {
-          :error => {
-            :message => '(#100) Must include the \"campaign_id\" index',
-            :type => "OAuthException"
+      context "to an an alias that does not exist" do
+        let(:details) do
+          {
+            :error => {
+              :message => '(#803) Some of the aliases you requested do not exist: test',
+              :type => "OAuthException"
+            }
           }
-        }
-      end
-      let(:headers) do
-        {
-          "WWW-Authenticate" =>'OAuth "Facebook Platform" "invalid_request" "(#100) Must include the \"campaign_id\" index"'
-        }
-      end
+        end
+        let(:headers) do
+          {
+            "WWW-Authenticate" =>'OAuth "Facebook Platform" "not_found" "(#803) Some of the aliases you requested do not exist: test"'
+          }
+        end
 
-      it "should raise an InvalidRequest exception" do
-        lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, headers)}.should raise_exception(FbGraph::InvalidRequest)
+        it do
+          expect do
+            FbGraph::Exception.handle_structured_response(999, details, headers)
+          end.to raise_exception FbGraph::NotFound
+        end
       end
     end
 
-    context "to an an alias that does not exist" do
-      let(:parsed_response) do
-        {
-          :error => {
-            :message => '(#803) Some of the aliases you requested do not exist: test',
-            :type => "OAuthException"
-          }
-        }
-      end
+    context "without the WWW-Authenticate header" do
       let(:headers) do
-        {
-          "WWW-Authenticate" =>'OAuth "Facebook Platform" "not_found" "(#803) Some of the aliases you requested do not exist: test"'
-        }
+        {}
       end
 
-      it "should raise a NotFound exception" do
-        lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, headers)}.should raise_exception(FbGraph::NotFound)
+      context "with an OAuthException" do
+        let(:details) do
+          {
+            :error => {
+              :message => 'Some kind of OAuthException',
+              :type => "OAuthException"
+            }
+          }
+        end
+
+        it do
+          expect do
+            FbGraph::Exception.handle_structured_response(999, details, headers)
+          end.to raise_exception FbGraph::Unauthorized
+        end
       end
-    end
-  end
 
-  context "without the WWW-Authenticate header" do
-    context "with an OAuthException" do
-      let(:parsed_response) do
-        {
-          :error => {
-            :message => 'Some kind of OAuthException',
-            :type => "OAuthException"
+      context "with a general exception" do
+        let(:details) do
+          {
+            :error => {
+              :message => 'Some kind of Exception',
+              :type => "Exception"
+            }
           }
-        }
-      end
+        end
 
-      it "should raise an Unauthorized exception" do
-        lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::Unauthorized)
+        {
+          400 => FbGraph::BadRequest,
+          401 => FbGraph::Unauthorized,
+          404 => FbGraph::NotFound,
+          500 => FbGraph::InternalServerError,
+          999 => FbGraph::Exception
+        }.each do |status, exception_klass|
+          context "when status=#{status}" do
+            it do
+              expect do
+                FbGraph::Exception.handle_structured_response(status, details, headers)
+              end.to raise_exception exception_klass
+            end
+          end
+        end
       end
-    end
 
-    context "with an Exception" do
-      let(:parsed_response) do
-        {
-          :error => {
-            :message => 'Some kind of Exception',
-            :type => "Exception"
+      context "with an unknown exception" do
+        let(:details) do
+          {
+            :error_code => 1,
+            :error_msg => "An unknown error occurred."
           }
-        }
-      end
+        end
 
-      it "should raise a BadRequest exception" do
-        lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::BadRequest)
+        {
+          400 => FbGraph::BadRequest,
+          401 => FbGraph::Unauthorized,
+          404 => FbGraph::NotFound,
+          500 => FbGraph::InternalServerError,
+          999 => FbGraph::Exception
+        }.each do |status, exception_klass|
+          context "when status=#{status}" do
+            it do
+              expect do
+                FbGraph::Exception.handle_structured_response(status, details, headers)
+              end.to raise_exception exception_klass
+            end
+          end
+        end
       end
 
-      context "with an Ads API Exception" do
+      describe "Ads API Exception" do
         context "of Could not save creative" do
-          let(:parsed_response) do
+          let(:details) do
             {
               :error => {
                 :message => 'Could not save creative',
@@ -187,88 +222,102 @@ describe FbGraph::Exception, ".handle_httpclient_error" do
             }
           end
 
-          it "should raise a CreativeNotSaved exception" do
-            lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::CreativeNotSaved)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::CreativeNotSaved
           end
         end
 
-        context "of QueryLockTimeout" do
-          let(:parsed_response) do
+        context "of Could not create targeting spec" do
+          let(:details) do
             {
               :error => {
-                :message => 'QueryLockTimeoutException',
+                :message => 'Could not create targeting spec',
                 :type => "Exception"
               }
             }
           end
 
-          it "should raise a QueryLockTimeout exception" do
-            lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::QueryLockTimeout)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::TargetingSpecNotSaved
           end
         end
 
-        context "of Could not create targeting spec" do
-          let(:parsed_response) do
+        context "of Could not fetch adgroups" do
+          let(:details) do
             {
               :error => {
-                :message => 'Could not create targeting spec',
+                :message => 'Could not fetch adgroups',
                 :type => "Exception"
               }
             }
           end
 
-          it "should raise a TargetingSpecNotSaved exception" do
-            lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::TargetingSpecNotSaved)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::AdgroupFetchFailure
           end
         end
 
-        context "of Could not fetch adgroups" do
-          let(:parsed_response) do
+        context "of Failed to open process" do
+          let(:details) do
             {
               :error => {
-                :message => 'Could not fetch adgroups',
+                :message => 'Failed to open process',
                 :type => "Exception"
               }
             }
           end
 
-          it "should raise a AdgroupFetchFailure exception" do
-            lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::AdgroupFetchFailure)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::OpenProcessFailure
           end
         end
 
-        context "of Failed to open process" do
-          let(:parsed_response) do
+        context "of Could not commit transaction" do
+          let(:details) do
             {
               :error => {
-                :message => 'Failed to open process',
+                :message => 'Could not commit transaction',
                 :type => "Exception"
               }
             }
           end
 
-          it "should raise a OpenProcessFailure exception" do
-            lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::OpenProcessFailure)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::TransactionCommitFailure
           end
         end
+      end
 
-        context "of Could not commit transaction" do
-          let(:parsed_response) do
+      describe 'FQL Exceptions' do
+        context "of QueryLockTimeout" do
+          let(:details) do
             {
               :error => {
-                :message => 'Could not commit transaction',
+                :message => 'QueryLockTimeoutException',
                 :type => "Exception"
               }
             }
           end
 
-          it "should raise a TransactionCommitFailure exception" do
-            lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::TransactionCommitFailure)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::QueryLockTimeout
           end
         end
 
         context "of QueryErrorException" do
-          let(:parsed_response) do
+          let(:details) do
             {
               :error => {
                 :message => 'DB Error: QueryErrorException',
@@ -277,13 +326,15 @@ describe FbGraph::Exception, ".handle_httpclient_error" do
             }
           end
 
-          it "should raise a QueryError exception" do
-            lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::QueryError)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::QueryError
           end
         end
 
         context "of QueryConnectionException" do
-          let(:parsed_response) do
+          let(:details) do
             {
               :error => {
                 :message => 'QueryConnectionException',
@@ -292,13 +343,15 @@ describe FbGraph::Exception, ".handle_httpclient_error" do
             }
           end
 
-          it "should raise a QueryConnection exception" do
-            lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::QueryConnection)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::QueryConnection
           end
         end
 
         context "of QueryDuplicateKeyException" do
-          let(:parsed_response) do
+          let(:details) do
             {
               :error => {
                 :message => 'QueryDuplicateKeyException',
@@ -307,24 +360,34 @@ describe FbGraph::Exception, ".handle_httpclient_error" do
             }
           end
 
-          it "should raise a QueryDuplicateKey exception" do
-            lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::QueryDuplicateKey)
+          it do
+            expect do
+              FbGraph::Exception.handle_structured_response(999, details, headers)
+            end.to raise_exception FbGraph::QueryDuplicateKey
           end
         end
       end
     end
-    context "with an Exception not containing the error field" do
-      let(:parsed_response) do
-        {
-          :error_code => 1,
-          :error_msg => "An unknown error occurred."
-        }
-      end
+  end
+end
 
-      it "should raise an InternalServerError exception" do
-        lambda {FbGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(FbGraph::InternalServerError)
-      end
+describe FbGraph::BadRequest do
+  it 'should have 400 status code' do
+    err = FbGraph::BadRequest.new 'Bad Request'
+    err.code.should == 400
+  end
+end
 
-    end
+describe FbGraph::Unauthorized do
+  it 'should have 401 status code' do
+    err = FbGraph::Unauthorized.new 'Unauthorized'
+    err.code.should == 401
+  end
+end
+
+describe FbGraph::NotFound do
+  it 'should have 404 status code' do
+    err = FbGraph::NotFound.new 'Not Found'
+    err.code.should == 404
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fb_graph
 version: !ruby/object:Gem::Version
-  version: 2.7.3
+  version: 2.7.4
 platform: ruby
 authors:
 - nov matake