feat: specific exception classes for errors (#142)

groyoh · web-flow · commit ccf0b943eda2 · 2022-09-21T17:08:01.000+02:00
diff --git a/lib/stream/client.rb b/lib/stream/client.rb
@@ -203,17 +203,12 @@ def make_http_request(method, relative_url, params = nil, data = nil, headers =
   class RaiseHttpException < Faraday::Middleware
     def call(env)
       @app.call(env).on_complete do |response|
-        case response[:status].to_i
+        status_code = response[:status].to_i
+        case status_code
         when 200..203
           return response
-        when 401
-          raise StreamApiResponseException, error_message(response, 'Bad feed')
-        when 403
-          raise StreamApiResponseException, error_message(response, 'Bad auth/headers')
-        when 404
-          raise StreamApiResponseException, error_message(response, 'url not found')
-        when 204...600
-          raise StreamApiResponseException, error_message(response, _build_error_message(response.body))
+        else
+          parse_error(response, status_code: status_code)
         end
       end
     end
@@ -225,11 +220,48 @@ def initialize(app)
 
     private
 
-    def _build_error_message(response)
-      response = JSON.parse(response)
-      msg = "#{response['exception']} details: #{response['detail']}"
-      if response.key?('exception_fields')
-        response['exception_fields'].map do |field, messages|
+    EXCEPTION_CLASS_MAPPING = {
+      2 => StreamApiResponseApiKeyException,
+      3 => StreamApiResponseSignatureException,
+      4 => StreamApiResponseInputException,
+      5 => StreamApiResponseCustomFieldException,
+      6 => StreamApiResponseFeedConfigException,
+      7 => StreamApiResponseSiteSuspendedException,
+      8 => StreamApiResponseInvalidPaginationException,
+      9 => StreamApiResponseRateLimitReached,
+      10 => StreamApiResponseMissingUserException,
+      11 => StreamApiResponseRankingException,
+      12 => StreamApiResponseMissingRankingException,
+      13 => StreamApiResponseOldStorageBackendException,
+      14 => StreamApiResponseJinjaRuntimeException,
+      15 => StreamApiResponseBestPracticeException,
+      16 => StreamApiResponseDoesNotExistException,
+      17 => StreamApiResponseNotAllowedException,
+      22 => StreamApiResponseConflictException
+    }.freeze
+    private_constant :EXCEPTION_CLASS_MAPPING
+
+    def parse_error(response, status_code:)
+      body = JSON.parse(response.body)
+      code = body['code']
+
+      exception_class = EXCEPTION_CLASS_MAPPING[code] || StreamApiResponseException
+      case status_code
+      when 401
+        raise exception_class, error_message(response, 'Bad feed')
+      when 403
+        raise exception_class, error_message(response, 'Bad auth/headers')
+      when 404
+        raise exception_class, error_message(response, 'url not found')
+      when 204...600
+        raise exception_class, error_message(response, _build_error_message(body))
+      end
+    end
+
+    def _build_error_message(body)
+      msg = "#{body['exception']} details: #{body['detail']}"
+      if body.key?('exception_fields')
+        body['exception_fields'].map do |field, messages|
           msg << "\n#{field}: #{messages}"
         end
       end
diff --git a/lib/stream/errors.rb b/lib/stream/errors.rb
@@ -3,5 +3,39 @@ class Error < StandardError; end
 
   class StreamApiResponseException < Error; end
 
+  class StreamApiResponseApiKeyException < StreamApiResponseException; end
+
+  class StreamApiResponseSignatureException < StreamApiResponseException; end
+
+  class StreamApiResponseInputException < StreamApiResponseException; end
+
+  class StreamApiResponseCustomFieldException < StreamApiResponseException; end
+
+  class StreamApiResponseFeedConfigException < StreamApiResponseException; end
+
+  class StreamApiResponseSiteSuspendedException < StreamApiResponseException; end
+
+  class StreamApiResponseInvalidPaginationException < StreamApiResponseException; end
+
+  class StreamApiResponseRateLimitReached < StreamApiResponseException; end
+
+  class StreamApiResponseMissingRankingException < StreamApiResponseFeedConfigException; end
+
+  class StreamApiResponseMissingUserException < StreamApiResponseException; end
+
+  class StreamApiResponseRankingException < StreamApiResponseFeedConfigException; end
+
+  class StreamApiResponseOldStorageBackendException < StreamApiResponseException; end
+
+  class StreamApiResponseJinjaRuntimeException < StreamApiResponseException; end
+
+  class StreamApiResponseBestPracticeException < StreamApiResponseException; end
+
+  class StreamApiResponseDoesNotExistException < StreamApiResponseException; end
+
+  class StreamApiResponseNotAllowedException < StreamApiResponseException; end
+
+  class StreamApiResponseConflictException < StreamApiResponseException; end
+
   class StreamInputData < Error; end
 end
diff --git a/spec/errors_spec.rb b/spec/errors_spec.rb
@@ -4,5 +4,23 @@
 describe Stream::Error do
   it { expect(Stream::Error).to be < StandardError }
   it { expect(Stream::StreamApiResponseException).to be < Stream::Error }
+  it { expect(Stream::StreamApiResponseDoesNotExistException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseApiKeyException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseSignatureException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseInputException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseCustomFieldException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseFeedConfigException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseSiteSuspendedException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseInvalidPaginationException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseRateLimitReached).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseMissingUserException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseMissingRankingException).to be < Stream::StreamApiResponseFeedConfigException }
+  it { expect(Stream::StreamApiResponseRankingException).to be < Stream::StreamApiResponseFeedConfigException }
+  it { expect(Stream::StreamApiResponseOldStorageBackendException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseJinjaRuntimeException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseBestPracticeException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseDoesNotExistException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseNotAllowedException).to be < Stream::StreamApiResponseException }
+  it { expect(Stream::StreamApiResponseConflictException).to be < Stream::StreamApiResponseException }
   it { expect(Stream::StreamInputData).to be < Stream::Error }
 end
diff --git a/spec/integration_spec.rb b/spec/integration_spec.rb
@@ -9,6 +9,7 @@
 describe 'Integration tests' do
   before(:all) do
     @client = Stream::Client.new(ENV.fetch('STREAM_API_KEY'), ENV.fetch('STREAM_API_SECRET'), nil, location: ENV.fetch('STREAM_REGION', nil), default_timeout: 10)
+    @url = @client.get_http_client.conn.url_prefix.to_s.gsub(%r{/+$}, '')
     @feed42 = @client.feed('flat', generate_uniq_feed_name)
     @feed43 = @client.feed('flat', generate_uniq_feed_name)
 
@@ -363,7 +364,7 @@
     example 'add incomplete activity' do
       expect do
         @feed42.add_activity({})
-      end.to raise_error Stream::StreamApiResponseException
+      end.to raise_error Stream::StreamApiResponseInputException
     end
 
     it 'should be able to follow many feeds in one request' do
@@ -379,12 +380,11 @@
         { source: 'badfeed:1', target: 'alsobad:1' },
         { source: 'extrabadfeed:1', target: 'reallybad:3' }
       ]
-      url = @client.get_http_client.conn.url_prefix.to_s.gsub(%r{/+$}, '')
       expect do
         @client.follow_many(follows, 5000)
       end.to raise_error(
-        Stream::StreamApiResponseException,
-        %r{^POST #{url}/follow_many/\?activity_copy_limit=5000&api_key=[^:]+: 400: InputException details: activity_copy_limit must be a non-negative number not greater than 1000$}
+        Stream::StreamApiResponseInputException,
+        %r{^POST #{@url}/follow_many/\?activity_copy_limit=5000&api_key=[^:]+: 400: InputException details: activity_copy_limit must be a non-negative number not greater than 1000$}
       )
     end
 
@@ -401,12 +401,11 @@
         { source: 'user:1', target: 'timeline:1' },
         { source: 'user:2', target: 42, keep_history: false }
       ]
-      url = @client.get_http_client.conn.url_prefix.to_s.gsub(%r{/+$}, '')
       expect do
         @client.unfollow_many(unfollows)
       end.to raise_error(
-        Stream::StreamApiResponseException,
-        %r{^POST #{url}/unfollow_many/\?api_key=[^:]+: 400: InputException details: invalid request payload$}
+        Stream::StreamApiResponseInputException,
+        %r{^POST #{@url}/unfollow_many/\?api_key=[^:]+: 400: InputException details: invalid request payload$}
       )
     end
 
@@ -416,9 +415,48 @@
       @client.add_to_many(activity_data, feeds)
     end
 
+    # Create a `invalid_aggregation_format` aggregated feed group with the aggregation format
+    # `{{test[]}}`.
+    it 'should return an error if the aggregation format is invalid' do
+      feed_name = generate_uniq_feed_name
+      feed = @client.feed('invalid_aggregation_format', feed_name)
+      feed.add_activity(actor: 1, verb: 'tweet', object: 1)
+
+      expect do
+        feed.get(limit: 5)
+      end.to raise_error(
+        Stream::StreamApiResponseJinjaRuntimeException,
+        %r{^GET #{@url}/feed/invalid_aggregation_format/#{feed_name}/\?api_key=[^&]+&limit=5: 400: JinjaRuntimeException details: the format contains syntax errors$}
+      )
+    end
+
+    it 'should return an error if the api key is invalid' do
+      client = Stream::Client.new('invalid', 'invalid', nil, location: ENV.fetch('STREAM_REGION', nil), default_timeout: 10)
+      feed_name = generate_uniq_feed_name
+      feed = client.feed('notification', feed_name)
+      expect do
+        feed.get(limit: 5)
+      end.to raise_error(
+        Stream::StreamApiResponseApiKeyException,
+        %r{^GET #{@url}/feed/notification/#{feed_name}/\?api_key=[^&]+&limit=5: 401: Bad feed$}
+      )
+    end
+
+    it 'should return an error if the api secret is invalid' do
+      client = Stream::Client.new(ENV.fetch('STREAM_API_KEY'), 'invalid', nil, location: ENV.fetch('STREAM_REGION', nil), default_timeout: 10)
+      feed_name = generate_uniq_feed_name
+      feed = client.feed('notification', feed_name)
+      expect do
+        feed.get(limit: 5)
+      end.to raise_error(
+        Stream::StreamApiResponseNotAllowedException,
+        %r{^GET #{@url}/feed/notification/#{feed_name}/\?api_key=[^&]+&limit=5: 403: Bad auth/headers$}
+      )
+    end
+
     example 'updating many feed activities' do
       activities = []
-      (0..10).each do |i|
+      11.times do |i|
         activities << {
           actor: 'user:1',
           verb: 'do',
@@ -464,7 +502,7 @@
       end
       example 'add object to collection twice' do
         @client.collections.add('animals', { type: 'bear' }, id: @item_id)
-        expect { @client.collections.add('animals', {}, id: @item_id) }.to raise_error Stream::StreamApiResponseException
+        expect { @client.collections.add('animals', {}, id: @item_id) }.to raise_error Stream::StreamApiResponseInputException
       end
       example 'get collection item' do
         @client.collections.add('animals', { type: 'fox' }, id: @item_id)
@@ -482,7 +520,7 @@
       example 'collection item delete' do
         @client.collections.add('animals', { type: 'snake' }, id: @item_id)
         @client.collections.delete('animals', @item_id)
-        expect { @client.collections.get('animals', @item_id) }.to raise_error Stream::StreamApiResponseException
+        expect { @client.collections.get('animals', @item_id) }.to raise_error Stream::StreamApiResponseDoesNotExistException
       end
     end
 
@@ -604,7 +642,7 @@
                                         })
         activity.delete('duration')
 
-        expect { @client.get_activities }.to raise_error Stream::StreamApiResponseException
+        expect { @client.get_activities }.to raise_error Stream::StreamApiResponseInputException
 
         # get by ID
         by_id = @client.get_activities(
@@ -837,7 +875,7 @@
       end
       example 'add user twice with error' do
         @client.users.add(@user_id)
-        expect { @client.users.add(@user_id) }.to raise_error Stream::StreamApiResponseException
+        expect { @client.users.add(@user_id) }.to raise_error Stream::StreamApiResponseConflictException
       end
       example 'get user' do
         create_response = @client.users.add(@user_id, data: { animal: 'wolf' })
@@ -848,6 +886,14 @@
 
         expect(get_response).to eq create_response
       end
+      example 'get user with does not exist error' do
+        expect do
+          @client.users.get(@user_id)
+        end.to raise_error(
+          Stream::StreamApiResponseDoesNotExistException,
+          %r{^GET #{@url}/user/#{@user_id}/\?api_key=[^:]+: 404: url not found$}
+        )
+      end
       example 'update user' do
         @client.users.add(@user_id)
         response = @client.users.update(@user_id, data: { animal: 'dog' })
@@ -857,7 +903,7 @@
       example 'delete user' do
         @client.users.add(@user_id)
         @client.users.delete(@user_id)
-        expect { @client.users.get(@user_id) }.to raise_error Stream::StreamApiResponseException
+        expect { @client.users.get(@user_id) }.to raise_error Stream::StreamApiResponseDoesNotExistException
       end
     end
 
@@ -903,7 +949,7 @@
       example 'delete reaction' do
         reaction = @client.reactions.add('like', @activity['id'], 'jim')
         @client.reactions.delete(reaction['id'])
-        expect { @client.reactions.get(reaction['id']) }.to raise_error Stream::StreamApiResponseException
+        expect { @client.reactions.get(reaction['id']) }.to raise_error Stream::StreamApiResponseDoesNotExistException
       end
       example 'filter reactions' do
         parent = @client.reactions.add('like', @activity['id'], 'jim')
