Rails 5.1 deep symbolized secrets support

Fixes #26

.rubocop.yml

@@ -15,6 +15,7 @@ Style/DotPosition: {EnforcedStyle: trailing}
 Style/FirstParameterIndentation: {EnforcedStyle: consistent}
 Style/IfUnlessModifier: {Enabled: false}
 Style/ModuleFunction: {Enabled: false}
+Style/MultilineMethodCallIndentation: {EnforcedStyle: indented}
 Style/MultilineOperationIndentation: {EnforcedStyle: indented}
 Style/NestedParenthesizedCalls: {Enabled: false}
 Style/PredicateName: {Enabled: false}

CHANGELOG.md

@@ -1,4 +1,18 @@
-# 0.10.1
+# 0.11.2
+
+- Rails 5.1 deep symbolized secrets support.
+
+# 0.11.1
+
+- Fixed poller for typed response.
+
+# 0.11.0
+
+- Remove Bot::StaleChat in favor of Bot::Forbidden, as Telegram adds more
+  and more new descriptions.
+  Please open an issue if you face a problem.
+
+# 0.10.2
 
 - Support `(edited_)channel_post` updates.
 - New methods from 2.3, 2.3.1 API updates.

README.md

@@ -43,6 +43,12 @@ Or install it yourself as:
 
     $ gem install telegram-bot
 
+Require if necessary:
+
+```ruby
+require 'telegram/bot'
+```
+
 ## Usage
 
 ### Configuration
@@ -100,7 +106,7 @@ bot.get_me.class # => Telegram::Bot::Types::User
 ```
 
 Any API request error will raise `Telegram::Bot::Error` with description in its message.
-Special `Telegram::Bot::StaleChat` is raised when bot can't post messages to the chat anymore.
+Special `Telegram::Bot::Forbidden` is raised when bot can't post messages to the chat anymore.
 
 ### Controller
 

lib/telegram/bot.rb

@@ -6,26 +6,7 @@ module Telegram
   module Bot
     class Error < StandardError; end
     class NotFound < Error; end
-
-    # Error class for events when chat is not available anymore for bot.
-    # While Telegram has same error codes for different messages and there is no
-    # official docs for this error codes it uses `description` to
-    # check response.
-    class StaleChat < Error
-      DESCRIPTIONS = [
-        'Bot was blocked',
-        'bot was kicked',
-        "can't write to",
-        'group chat is deactivated',
-      ].freeze
-
-      class << self
-        def match_response?(response)
-          description = response['description'].to_s
-          DESCRIPTIONS.any? { |x| description[x] }
-        end
-      end
-    end
+    class Forbidden < Error; end
 
     autoload :Async,              'telegram/bot/async'
     autoload :Botan,              'telegram/bot/botan'

lib/telegram/bot/client.rb

@@ -46,18 +46,20 @@ module Telegram
         @base_uri = format URL_TEMPLATE, self.token
       end
 
-      def request(action, body = {}) # rubocop:disable PerceivedComplexity
+      def request(action, body = {})
         res = http_request("#{base_uri}#{action}", self.class.prepare_body(body))
         status = res.status
         return JSON.parse(res.body) if 300 > status
         result = JSON.parse(res.body) rescue nil # rubocop:disable RescueModifier
-        err_msg = "#{res.reason}: #{result && result['description'] || '-'}"
+        err_msg = result && result['description'] || '-'
         if result
-          # NotFound is raised only for valid responses from Telegram
-          raise NotFound, err_msg if 404 == status
-          raise StaleChat, err_msg if StaleChat.match_response?(result)
+          # This errors are raised only for valid responses from Telegram
+          case status
+          when 403 then raise Forbidden, err_msg
+          when 404 then raise NotFound, err_msg
+          end
         end
-        raise Error, err_msg
+        raise Error, "#{res.reason}: #{err_msg}"
       end
 
       # Splited to the sections similar to API docs.

lib/telegram/bot/config_methods.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/hash/transform_values'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module Telegram
   module Bot
@@ -48,9 +49,10 @@ module Telegram
       def bots_config
         @bots_config ||=
           if defined?(Rails.application)
-            telegram_config = Rails.application.secrets[:telegram] || {}
-            (telegram_config['bots'] || {}).symbolize_keys.tap do |config|
-              default = telegram_config['bot']
+            secrets = Rails.application.secrets.
+              fetch(:telegram, {}).with_indifferent_access
+            secrets.fetch(:bots, {}).symbolize_keys.tap do |config|
+              default = secrets[:bot]
               config[:default] = default if default
             end
           else

lib/telegram/bot/updates_controller.rb

@@ -50,7 +50,7 @@ module Telegram
     #     ControllerClass.new(bot, from: telegram_user, chat: telegram_chat).
     #       process(:help, *args)
     #
-    class UpdatesController < AbstractController::Base
+    class UpdatesController < AbstractController::Base # rubocop:disable ClassLength
       abstract!
 
       require 'telegram/bot/updates_controller/session'
@@ -183,11 +183,13 @@ module Telegram
         cmd &&= self.class.action_for_command(cmd)
         [true, cmd, args] if cmd
       end
+      alias_method :action_for_channel_post, :action_for_message
 
       # It doesn't extract commands from edited messages. Just process
       # them as usual ones.
       def action_for_edited_message
       end
+      alias_method :action_for_edited_channel_post, :action_for_edited_message
 
       def action_for_inline_query
         [false, payload_type, [payload['query'], payload['offset']]]

lib/telegram/bot/updates_poller.rb

@@ -65,14 +65,16 @@ module Telegram
 
       def fetch_updates
         response = bot.async(false) { bot.get_updates(offset: offset, timeout: timeout) }
-        return unless response['ok'] && response['result'].any?
+        updates = response.is_a?(Array) ? response : response['result']
+        return unless updates && updates.any?
         reload! do
-          response['result'].each do |update|
+          updates.each do |update|
             @offset = update['update_id'] + 1
             yield update
           end
         end
-      rescue Timeout::Error # rubocop:disable HandleExceptions
+      rescue Timeout::Error
+        log { 'Fetch timeout' }
       end
 
       def reload!

lib/telegram/bot/version.rb

@@ -1,6 +1,6 @@
 module Telegram
   module Bot
-    VERSION = '0.10.1'.freeze
+    VERSION = '0.11.2'.freeze
 
     def self.gem_version
       Gem::Version.new VERSION

spec/spec_helper.rb

@@ -16,6 +16,7 @@ $LOAD_PATH.unshift GEM_ROOT.join('lib')
 require 'telegram/bot'
 require 'telegram/bot/updates_controller/rspec_helpers'
 require 'telegram/bot/types'
+require 'active_support/core_ext/object/json'
 
 Dir[GEM_ROOT.join('spec/support/**/*.rb')].each { |f| require f }
 

spec/telegram/bot/botan_spec.rb

@@ -3,7 +3,7 @@ RSpec.describe Telegram::Bot::Botan do
   let(:token) { 'token' }
 
   include_examples 'initializers', :botans
-  include_examples 'async', request_args: -> { [double(:method), double(:url)] }
+  it_behaves_like 'async', request_args: -> { [double(:method), double(:url)] }
 
   describe '.new' do
     subject { described_class.new(*args) }

spec/telegram/bot/client_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Telegram::Bot::Client do
   let(:botan_token) { double(:botan_token) }
 
   include_examples 'initializers'
-  include_examples 'async', request_args: -> { [double(:action), {body: :content}] }
+  it_behaves_like 'async', request_args: -> { [double(:action), {body: :content}] }
 
   describe '.prepare_body' do
     subject { described_class.prepare_body(input) }
@@ -48,4 +48,49 @@ RSpec.describe Telegram::Bot::Client do
       its(:base_uri) { should include args[0][:token] }
     end
   end
+
+  describe '#request' do
+    subject { -> { instance.request(action, request_body) } }
+    let(:action) { :some_action }
+    let(:url) { "#{format described_class::URL_TEMPLATE, token}#{action}" }
+    let(:request_body) { double(:body) }
+    let(:prepared_body) { double(:prepared_body) }
+    let(:response) { HTTP::Message.new_response(body).tap { |x| x.status = status } }
+
+    let(:status) { 200 }
+    let(:body) { body_json.to_json }
+    let(:body_json) { {'param' => 'val', 'description' => 'some description'} }
+    before do
+      expect(described_class).to receive(:prepare_body).with(request_body) { prepared_body }
+      expect(instance).to receive(:http_request).with(url, prepared_body) { response }
+    end
+    around { |ex| Telegram::Bot::ClientStub.stub_all!(false) { ex.run } }
+
+    shared_examples 'invalid body' do |error = Telegram::Bot::Error|
+      context 'when body is not json' do
+        let(:body) { '{' }
+        it { should raise_error error }
+      end
+    end
+
+    its(:call) { should eq body_json }
+    include_examples 'invalid body', JSON::ParserError
+
+    context 'when status is 403' do
+      let(:status) { 403 }
+      it { should raise_error Telegram::Bot::Forbidden, body_json['description'] }
+      include_examples 'invalid body'
+    end
+
+    context 'when status is 404' do
+      let(:status) { 404 }
+      it { should raise_error Telegram::Bot::NotFound, body_json['description'] }
+      include_examples 'invalid body'
+    end
+
+    context 'when status is other' do
+      let(:status) { 500 }
+      it { should raise_error Telegram::Bot::Error, /#{body_json['description']}/ }
+    end
+  end
 end

spec/telegram/bot/config_methods_spec.rb

@@ -87,6 +87,12 @@ RSpec.describe Telegram::Bot::ConfigMethods do
           end
           it { should include default: config[:bot] }
           it { should include config[:bots] }
+
+          context 'on rails >5.1 (deep symbolized keys)' do
+            let(:secrets) { {telegram: config.deep_symbolize_keys} }
+            it { should include default: config[:bot] }
+            it { should include config[:bots] }
+          end
         end
       end
     end

spec/telegram/bot/updates_controller_spec.rb

@@ -102,42 +102,44 @@ RSpec.describe Telegram::Bot::UpdatesController do
       it { should eq [false, payload_type, payload.values_at(:data)] }
     end
 
-    context 'when payload is edited_message' do
-      let(:payload_type) { 'edited_message' }
-      it { should eq [false, payload_type, [payload]] }
-    end
-
     context 'when payload is not supported' do
       let(:payload_type) { '_unsupported_' }
       it { should eq [false, :unsupported_payload_type, []] }
     end
 
-    context 'when payload is message' do
-      let(:payload_type) { 'message' }
-      let(:payload) { {'text' => text} }
-      let(:text) { 'test' }
-
-      it { should eq [false, payload_type, [payload]] }
-
-      context 'with command' do
-        let(:text) { "/test#{"@#{mention}" if mention} arg 1 2" }
-        let(:mention) {}
-        it { should eq [true, 'test', %w(arg 1 2)] }
-
-        context 'with mention' do
-          let(:mention) { bot.username }
-          it { should eq [true, 'test', %w(arg 1 2)] }
-        end
-
-        context 'with mention for other bot' do
-          let(:mention) { other_bot_name }
-          it { should eq [false, 'message', [payload]] }
-        end
+    %w(message channel_post).each do |type|
+      context 'when payload is edited_message' do
+        let(:payload_type) { "edited_#{type}" }
+        it { should eq [false, payload_type, [payload]] }
       end
 
-      context 'without text' do
-        let(:payload) { {'audio' => {'file_id' => 123}} }
+      context 'when payload is message' do
+        let(:payload_type) { type }
+        let(:payload) { {'text' => text} }
+        let(:text) { 'test' }
+
         it { should eq [false, payload_type, [payload]] }
+
+        context 'with command' do
+          let(:text) { "/test#{"@#{mention}" if mention} arg 1 2" }
+          let(:mention) {}
+          it { should eq [true, 'test', %w(arg 1 2)] }
+
+          context 'with mention' do
+            let(:mention) { bot.username }
+            it { should eq [true, 'test', %w(arg 1 2)] }
+          end
+
+          context 'with mention for other bot' do
+            let(:mention) { other_bot_name }
+            it { should eq [false, payload_type, [payload]] }
+          end
+        end
+
+        context 'without text' do
+          let(:payload) { {'audio' => {'file_id' => 123}} }
+          it { should eq [false, payload_type, [payload]] }
+        end
       end
     end
   end

spec/telegram/bot/updates_poller_spec.rb

@@ -1,9 +1,39 @@
 RSpec.describe Telegram::Bot::UpdatesPoller do
-  describe '#initialize' do
-    subject { described_class.new bot, controller }
-    let(:bot) { double }
-    let(:controller) { double }
+  let(:instance) { described_class.new(bot, controller) }
+  let(:bot) { Telegram::Bot::Client.new('token') }
+  let(:controller) { double(:controller) }
 
+  describe '#initialize' do
+    subject { instance }
     it { should be }
   end
+
+  describe '#fetch_updates' do
+    subject { -> { instance.fetch_updates(&block) } }
+    let(:block) { ->(x) { expect(x).to eq expected_results.shift } }
+    let(:results) { [{update_id: 12}, {update_id: 34}] }
+    let(:expected_results) { results.as_json }
+    let(:request_result) { {ok: true, result: results}.as_json }
+    before do
+      allow(bot).to receive(:get_updates) do
+        expect(bot.async).to be_falsy
+        request_result
+      end
+    end
+
+    it { should change(instance, :offset).to(results.last[:update_id] + 1) }
+    it { should change { expected_results }.to([]) }
+
+    context 'with typed response' do
+      let(:request_result) { results.as_json.map { |x| Telegram::Bot::Types::Update.new(x) } }
+      let(:expected_results) { request_result.dup }
+      it { should change(instance, :offset).to(results.last[:update_id] + 1) }
+      it { should change { expected_results }.to([]) }
+    end
+
+    context 'when bot is in async mode' do
+      let(:bot) { Telegram::Bot::Client.new('token', async: Class.new) }
+      it { should change { expected_results }.to([]) }
+    end
+  end
 end

spec/telegram/bot_spec.rb

@@ -2,25 +2,4 @@ RSpec.describe Telegram::Bot do
   it 'has a version number' do
     expect(described_class::VERSION).not_to be nil
   end
-
-  describe described_class::StaleChat do
-    describe '.match_response?' do
-      subject { ->(val) { described_class.match_response?(val) } }
-
-      it 'returns true for specific errors' do
-        expect(subject.call({})).to eq false
-        expect(subject.call('description' => 'test')).to eq false
-        expect(subject.call('description' => 'Error: bot was kicked from')).to eq true
-        expect(subject.call(
-          'description' => "Forbidden: can't write to private chat with deleted user"
-        )).to eq true
-        expect(subject.call(
-          'description' => 'Bad request: group chat is deactivated'
-        )).to eq true
-        expect(subject.call(
-          'description' => 'Forbidden: Bot was blocked by the user'
-        )).to eq true
-      end
-    end
-  end
 end