0.9.0.alpha1

Fixes #11

.rubocop.yml

@@ -8,9 +8,11 @@ Style/AlignParameters:
   # EnforcedStyle:
   # - with_first_parameter
   # - with_fixed_indentation
+Style/AndOr: {EnforcedStyle: conditionals}
 Style/ClosingParenthesisIndentation: {Enabled: false}
 Style/Documentation: {Enabled: false}
 Style/DotPosition: {EnforcedStyle: trailing}
+Style/FirstParameterIndentation: {EnforcedStyle: consistent}
 Style/IfUnlessModifier: {Enabled: false}
 Style/ModuleFunction: {Enabled: false}
 Style/MultilineOperationIndentation: {EnforcedStyle: indented}

.travis.yml

@@ -2,5 +2,8 @@ language: ruby
 cache: bundler
 rvm:
   - 2.2.3
+env:
+  - RAILS=4
+  - RAILS=5
 notifications:
   email: false

CHANGELOG.md

@@ -0,0 +1,51 @@
+# Unreleased
+
+- One more description for StaleChat error.
+
+# 0.8.0
+
+- Fixed `#reply_with`, now it sets `reply_to_message_id` as it's supposed to.
+  Added `#respond_with` which works the same way, but doesn't set `reply_to_message_id`.
+  Please, replace all occurrences of `reply_with` to `respond_with` to
+  keep it working the old way.
+- Fixes for Rails 5:
+  - Controller callbacks
+  - Middleware
+  - Setup travis builds
+
+# 0.7.4
+
+- Rails 5 support by @dreyks (#4).
+
+# 0.7.3
+
+-  Fixed issues with poller in production (#3)
+
+# 0.7.2
+
+- Bot API 2.1
+- Fixed possible crashes when payload type is not supported.
+  Provides empty session when neither `from` nor `chat` is defined.
+
+# 0.7.0
+
+- New Bot API methods.
+- Helpers for inline keyboards, support for callback_query (with contextual actions).
+- Changed action methods signature
+  - `#inline_query(payload) -> #inline_query(query, offset)`
+  - `#chosen_inline_result(payload)` -> `#chosen_inline_result(result_id, query)`
+- MessageContext doesn't use second #process call to run contextual action.
+- Botan.io metrics.
+
+# 0.6.0
+
+- StaleChat error.
+- Encode arrays as json in request body.
+
+# 0.5.0
+
+- MessageContext.
+- Running controller action without update.
+- Client.wrap supports symbols.
+- Improved testing utils: ability to process multiple updates on same controller instance,
+  stubbing all clients in application.

Gemfile

@@ -1,6 +1,13 @@
 source 'https://rubygems.org'
 gemspec
 
+case ENV['RAILS']
+when '5'
+  gem 'actionpack', '5.0.0.rc1'
+when '4'
+  gem 'actionpack', '~> 4.2'
+end
+
 group :development do
   gem 'sdoc', '~> 0.4.1'
   gem 'pry', '~> 0.10.1'

README.md

@@ -5,7 +5,8 @@
 [![Build Status](https://travis-ci.org/telegram-bot-rb/telegram-bot.svg)](https://travis-ci.org/telegram-bot-rb/telegram-bot)
 
 Tools for developing bot for Telegram. Best used with Rails, but can be be used in
-standalone app. Supposed to be used in webhook-mode in production, and poller-mode
+[standalone app](https://github.com/telegram-bot-rb/telegram-bot/wiki/Non-rails-application).
+Supposed to be used in webhook-mode in production, and poller-mode
 in development, but you can use poller in production if you want.
 
 Package contains:
@@ -16,6 +17,11 @@ Package contains:
 - Middleware and routes helpers for production env.
 - Poller with automatic source-reloader for development env.
 - Rake tasks to update webhook urls.
+- Async requests for Telegram and/or Botan API. Let the queue adapter handle errors!
+
+Here is sample [telegram_bot_app](https://github.com/telegram-bot-rb/telegram_bot_app)
+with session, keyboards and inline queries.
+Run it on your local machine in 1 minute!
 
 ## Installation
 
@@ -89,6 +95,9 @@ bot.extend Telegram::Bot::Client::TypedResponse
 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.
+
 ### Controller
 
 ```ruby
@@ -96,7 +105,8 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   # use callbacks like in any other controllers
   around_action :with_locale
 
-  # Every update can have one of: message, inline_query & chosen_inline_result.
+  # Every update can have one of: message, inline_query, chosen_inline_result,
+  # callback_query.
   # Define method with same name to respond to this updates.
   def message(message)
     # message can be also accessed via instance method
@@ -104,6 +114,13 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
     # store_message(message['text'])
   end
 
+  # This basic methods receives commonly used params:
+  #
+  #   message(payload)
+  #   inline_query(query, offset)
+  #   chosen_inline_result(result_id, query)
+  #   callback_query(data)
+
   # Define public methods to respond to commands.
   # Command arguments will be parsed and passed to the method.
   # Be sure to use splat args and default values to not get errors when
@@ -116,9 +133,10 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
 
     # There are `chat` & `from` shortcut methods.
     response = from ? "Hello #{from['username']}!" : 'Hi there!'
-    # There is `reply_with` helper to set basic fields
+    # There is `respond_with` helper to set `chat_id` from received message:
-    # like `reply_to_message` & `chat_id`.
+    respond_with :message, text: response
-    reply_with :message, text: response
+    # `reply_with` also sets `reply_to_message_id`:
+    reply_with :photo, photo: File.open('party.jpg')
   end
 
   private
@@ -137,12 +155,14 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
 end
 ```
 
+#### Optional typecasting
+
 You can enable typecasting of `update` with `telegram-bot-types` by including
 `Telegram::Bot::UpdatesPoller::TypedUpdate`:
 
 ```ruby
 class Telegram::WebhookController < Telegram::Bot::UpdatesController
-  include Telegram::Bot::UpdatesPoller::TypedUpdate
+  include Telegram::Bot::UpdatesController::TypedUpdate
 
   def message(message)
     message.class # => Telegram::Bot::Types::Message
@@ -150,6 +170,8 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
 end
 ```
 
+#### Session
+
 There is support for sessions using `ActiveSupport::Cache` stores.
 
 ```ruby
@@ -158,6 +180,9 @@ config.telegram_updates_controller.session_store = :redis_store, {expires_in: 1.
 
 class Telegram::WebhookController < Telegram::Bot::UpdatesController
   include Telegram::Bot::UpdatesController::Session
+  # or just shortcut:
+  use_session!
+
   # You can override global config
   self.session_store = :file_store
 
@@ -166,7 +191,7 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   end
 
   def read
-    session[:text]
+    respond_with :message, text: session[:text]
   end
 
   private
@@ -180,6 +205,69 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
 end
 ```
 
+#### Message context
+
+It's usual to support chain of messages like BotFather: after receiving command
+it asks you for additional argument. There is `MessageContext` for this:
+
+```ruby
+class Telegram::WebhookController < Telegram::Bot::UpdatesController
+  include Telegram::Bot::UpdatesController::MessageContext
+
+  def rename(*)
+    # set context for the next message
+    save_context :rename
+    respond_with :message, text: 'What name do you like?'
+  end
+
+  # register context handlers to handle this context
+  context_handler :rename do |*words|
+    update_name words[0]
+    respond_with :message, text: 'Renamed!'
+  end
+
+  # You can do it in other way:
+  def rename(name = nil, *)
+    if name
+      update_name name
+      respond_with :message, text: 'Renamed!'
+    else
+      save_context :rename
+      respond_with :message, text: 'What name do you like?'
+    end
+  end
+
+  # This will call #rename like if it is called with message '/rename %text%'
+  context_handler :rename
+
+  # If you have a lot of such methods you can use
+  context_to_action!
+  # It'll use context value as action name for all contexts which miss handlers.
+end
+```
+
+You can use `CallbackQueyContext` in the similar way to split `#callback_query` into
+several specific methods. It doesn't require session support, and takes context from
+data. If data has a prefix with colon like this `my_ctx:smth...` it'll call
+`my_ctx_callback_query('smth...')` when there is such action method. Otherwise
+it'll call `callback_query('my_ctx:smth...')` as usual.
+
+#### Processesing updates
+
+To process update run:
+
+```ruby
+ControllerClass.dispatch(bot, update)
+```
+
+There is also ability to run action without update:
+
+```ruby
+# Most likely you'll want to pass :from and :chat
+controller = ControllerClass.new(bot, from: telegram_user, chat: telegram_chat)
+controller.process(:help, *args)
+```
+
 ### Routes
 
 Use `telegram_webhooks` helper to add routes. It will create routes for bots
@@ -207,7 +295,8 @@ telegram_webhooks bot => TelegramChatController,
 # You can override this options or specify others:
 telegram_webhooks TelegramController, as: :my_webhook
 telegram_webhooks bot => [TelegramChatController, as: :chat_webhook],
-                  other_bot => [TelegramAuctionController,
+                  other_bot => TelegramAuctionController,
+                  admin_chat: TelegramAdminChatController
 ```
 
 For Rack applications you can also use `Telegram::Bot::Middleware` or just
@@ -215,18 +304,91 @@ call `.dispatch(bot, update)` on controller.
 
 ### Development & Debugging
 
-Use `rake telegram:bot:poller BOT=chat` to run poller. It'll automatically load
+Use `rake telegram:bot:poller` to run poller. It'll automatically load
-changes without restart in development env. This task will not if you don't use
+changes without restart in development env. Optionally specify bot to run poller for
-`telegram_webhooks`.
+with `BOT` envvar (`BOT=chat`).
 
+This task will not work if you don't use `telegram_webhooks`.
 You can run poller manually with
 `Telegram::Bot::UpdatesPoller.start(bot, controller_class)`.
 
+### Testing
+
+There is `Telegram::Bot::ClientStub` class to stub client for tests.
+Instead of performing API requests it stores them in `requests` hash.
+
+To stub all possible clients use `Telegram::Bot::ClientStub.stub_all!` before
+initializing clients. Most likely you'll want something like this:
+
+```ruby
+RSpec.configure do |config|
+  # ...
+  Telegram.reset_bots
+  Telegram::Bot::ClientStub.stub_all!
+  config.after { Telegram.bot.reset }
+  # ...
+end
+```
+
+There are also some helpers for controller tests.
+Check out `telegram/bot/updates_controller/rspec_helpers` and
+`telegram/bot/updates_controller/testing`.
+
 ### Deploying
 
 Use `rake telegram:bot:set_webhook` to update webhook url for all configured bots.
 Certificate can be specified with `CERT=path/to/cert`.
 
+### Botan.io metrics
+
+Initialize with `bot = Telegram::Bot::Client.new(token, botan: 'botan token')`
+or just add `botan` key in `secrets.yml`:
+
+```yml
+  telegram:
+    bot:
+      token: bot_token
+      botan: botan_token
+```
+
+Access to Botan client with `bot.botan`.
+Use `bot.botan.track(event, uid, payload)` to track events.
+
+There are some helpers for controllers in `Telegram::Bot::Botan::ControllerHelpers`:
+
+```ruby
+class Telegram::WebhookController < Telegram::Bot::UpdatesController
+  include Telegram::Bot::Botan::ControllerHelpers
+
+  # This will track with event: action_name & data: payload
+  before_action :botan_track_action
+
+  def smth(*)
+    # This will track event for current user only when botan is configured.
+    botan_track :my_event, custom_data
+
+    # or get access directly to botan client:
+    botan.track(...)
+  end
+end
+```
+
+There is no stubbing for botan clients, so don't set botan token in tests.
+
+### Async mode
+
+There is built in support for async requests using ActiveJob. Without Rails
+you can implement your own worker class to handle such requests. This allows:
+
+- Process updates very fast, without waiting for telegram and botan responses.
+- Handle and retry network and other errors with queue adapter.
+- ???
+
+To enable this mode add `async: true` to bot's and botan's config.
+For more information and custom configuration check out
+[docs](http://www.rubydoc.info/github/telegram-bot-rb/telegram-bot/master/Telegram/Bot/Async) or
+[source](https://github.com/telegram-bot-rb/telegram-bot/blob/master/lib/telegram/bot/async.rb).
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.
@@ -238,6 +400,16 @@ To release a new version, update the version number in `version.rb`,
 and then run `bundle exec rake release`, which will create a git tag for the version,
 push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+### Different Rails versions
+
+To setup development for specific major Rails version use:
+
+```
+RAILS=5 bundle install
+# or
+RAILS=5 bundle update
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/telegram-bot-rb/telegram-bot.

lib/tasks/telegram-bot.rake

@@ -1,9 +1,14 @@
 namespace :telegram do
   namespace :bot do
-    desc 'Run poller'
+    desc 'Run poller. It broadcasts Rails.logger to STDOUT in dev like `rails s` do. ' \
-    task poller: :environment do
+      'Use LOG_TO_STDOUT to enable/disable broadcasting.'
-      console = ActiveSupport::Logger.new(STDERR)
+    task :poller do
-      Rails.logger.extend ActiveSupport::Logger.broadcast console
+      ENV['BOT_POLLER_MODE'] = 'true'
+      Rake::Task['environment'].invoke
+      if ENV.fetch('LOG_TO_STDOUT') { Rails.env.development? }.present?
+        console = ActiveSupport::Logger.new(STDERR)
+        Rails.logger.extend ActiveSupport::Logger.broadcast console
+      end
       Telegram::Bot::UpdatesPoller.start(ENV['BOT'].try!(:to_sym) || :default)
     end
 

lib/telegram/bot.rb

@@ -7,8 +7,32 @@ module Telegram
     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
+
+    autoload :Async,              'telegram/bot/async'
+    autoload :Botan,              'telegram/bot/botan'
     autoload :Client,             'telegram/bot/client'
     autoload :ClientStub,         'telegram/bot/client_stub'
+    autoload :DebugClient,        'telegram/bot/debug_client'
+    autoload :Initializers,       'telegram/bot/initializers'
     autoload :Middleware,         'telegram/bot/middleware'
     autoload :UpdatesController,  'telegram/bot/updates_controller'
     autoload :UpdatesPoller,      'telegram/bot/updates_poller'

lib/telegram/bot/async.rb

@@ -0,0 +1,138 @@
+module Telegram
+  module Bot
+    # Telegram & Botan clients can perform requests in async way with
+    # any job adapter (ActiveJob by default). Using Rails you don't need any
+    # additional configuration. However you may want to enable async requests
+    # by default with `async: true` in `secrets.yml`. Botan client doesn't inherit
+    # async setting from client and must be configured separately.
+    #
+    #   telegram:
+    #     bots:
+    #       chat_async:
+    #         token: secret
+    #         async: true # enable async mode for client
+    #         botan: botan_token # in this way botan will not be async
+    #         botan: # in this way - it's in async mode
+    #           token: botan_token
+    #           async: true
+    #
+    # Without Rails To start using async requests
+    # initialize client with `id` kwarg and make sure the client is
+    # accessible via `Teletgram.bots[id]` in job worker. Or just use
+    # `Telegram.bots_config=` for configuration.
+    #
+    # Being in async mode `#request` enqueues job instead to perform
+    # http request instead of performing it directly.
+    # Async behavior is controlled with `#async=` writer
+    # and can be enabled/disabled for the block with `#async`:
+    #
+    #   client = Telegram::Bot::Client.new(**config, async: true)
+    #   client.send_message(message)
+    #   client.async(false) { client.send_message(other_one) }
+    #
+    # It can be set with custom job class or classname. By default it defines
+    # job classes for every client class, inherited from ApplicationRecord, which
+    # can be accessed via `.default_async_job`. You can integrate it with any
+    # other job provider by defining a class with `.perform_later(bot_id, *args)`
+    # method. See Async::Job for implemetation.
+    module Async
+      module Job
+        class << self
+          def included(base)
+            base.singleton_class.send :attr_accessor, :client_class
+          end
+        end
+
+        def perform(client_id, *args)
+          client = self.class.client_class.wrap(client_id.to_sym)
+          client.async(false) { client.request(*args) }
+        end
+      end
+
+      module ClassMethods
+        def default_async_job
+          @default_async_job ||= begin
+            begin
+              ApplicationJob
+            rescue NameError
+              raise 'Define ApplicationJob class or setup #async= with custom job class'
+            end
+            klass = Class.new(ApplicationJob) { include Job }
+            klass.client_class = self
+            const_set(:AsyncJob, klass)
+          end
+        end
+
+        # This is used in specs.
+        def default_async_job=(val)
+          @default_async_job = val
+          remove_const(:AsyncJob) if const_defined?(:AsyncJob, false)
+        end
+
+        # Prepares argments for async job. ActiveJob doesn't support
+        # Symbol in argumens. Also we can encode json bodies only once here,
+        # so it would not be unnecessarily serialized-deserialized.
+        #
+        # This is stub method, which returns input. Every client class
+        # must prepare args itself.
+        def prepare_async_args(*args)
+          args
+        end
+      end
+
+      class << self
+        def prepended(base)
+          base.extend(ClassMethods)
+        end
+
+        # Transforms symbols to strings in hash values.
+        def prepare_hash(hash)
+          return hash unless hash.is_a?(Hash)
+          hash = hash.dup
+          hash.each { |key, val| hash[key] = val.to_s if val.is_a?(Symbol) }
+        end
+      end
+
+      attr_reader :id
+
+      def initialize(*, id: nil, async: nil, **options)
+        @id = id
+        self.async = async
+        super
+      end
+
+      # Sets `@async` to `self.class.default_async_job` if `true` is given
+      # or uses given value.
+      # Pass custom job class to perform async calls with.
+      def async=(val)
+        @async =
+          case val
+          when true then self.class.default_async_job
+          when String then const_get(val)
+          else val
+          end
+      end
+
+      # Returns value of `@async` if no block is given. Otherwise sets this value
+      # for a block.
+      def async(val = true)
+        return @async unless block_given?
+        begin
+          old_val = @async
+          self.async = val
+          yield
+        ensure
+          @async = old_val
+        end
+      end
+
+      # Uses job if #async is set.
+      def request(*args)
+        job_class = async
+        return super unless job_class
+        raise 'Can not enqueue job without client id' unless id
+        job_class.perform_later(id.to_s, *self.class.prepare_async_args(*args))
+      end
+    end
+  end
+end

lib/telegram/bot/botan.rb

@@ -0,0 +1,53 @@
+module Telegram
+  module Bot
+    class Botan
+      TRACK_URI = 'https://api.botan.io/track'.freeze
+
+      autoload :ClientHelpers, 'telegram/bot/botan/client_helpers'
+      autoload :ControllerHelpers, 'telegram/bot/botan/controller_helpers'
+      class Error < Bot::Error; end
+
+      extend Initializers
+      prepend Async
+      include DebugClient
+
+      class << self
+        def by_id(id)
+          Telegram.botans[id]
+        end
+
+        def prepare_async_args(method, uri, query = {}, body = nil)
+          [method.to_s, uri.to_s, Async.prepare_hash(query), body]
+        end
+      end
+
+      attr_reader :client, :token
+
+      def initialize(token = nil, **options)
+        @client = HTTPClient.new
+        @token = token || options[:token]
+      end
+
+      def track(event, uid, payload = {})
+        request(:post, TRACK_URI, {name: event, uid: uid}, payload.to_json)
+      end
+
+      def request(method, uri, query = {}, body = nil)
+        res = http_request(method, uri, query.merge(token: token), 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['info'] || '-'}"
+        raise Error, err_msg
+      end
+
+      def http_request(method, uri, query, body)
+        client.request(method, uri, query, body)
+      end
+
+      def inspect
+        "#<#{self.class.name}##{object_id}(#{@id})>"
+      end
+    end
+  end
+end

lib/telegram/bot/botan/client_helpers.rb

@@ -0,0 +1,15 @@
+module Telegram
+  module Bot
+    class Botan
+      # Helpers for botan.io metrics.
+      module ClientHelpers
+        attr_reader :botan
+
+        def initialize(*, botan: nil, **)
+          super
+          @botan = Botan.wrap(botan, id: id) if botan
+        end
+      end
+    end
+  end
+end

lib/telegram/bot/botan/controller_helpers.rb

@@ -0,0 +1,33 @@
+module Telegram
+  module Bot
+    class Botan
+      # Helpers for botan.io metrics.
+      module ControllerHelpers
+        class MissingFrom < Error; end
+
+        protected
+
+        def botan
+          @botan ||= bot.try!(:botan)
+        end
+
+        # Track custom event for user taken from `from` field:
+        #
+        #   botan_track :my_event, {data: :val}
+        #
+        def botan_track(event, data = {})
+          raise MissingFrom, 'Can not track without user' unless from
+          botan.try! { |x| x.track(event, from['id'], data) }
+        end
+
+        # Track current action and payload for current user. Best used with `before_action`:
+        #
+        #   before_action :botan_track_action
+        #
+        def botan_track_action
+          botan_track(action_name, payload)
+        end
+      end
+    end
+  end
+end

lib/telegram/bot/client.rb

@@ -6,22 +6,17 @@ require 'active_support/core_ext/hash/keys'
 module Telegram
   module Bot
     class Client
-      autoload :TypedResponse, 'telegram/bot/client/typed_response'
-
       URL_TEMPLATE = 'https://api.telegram.org/bot%s/'.freeze
 
+      autoload :TypedResponse, 'telegram/bot/client/typed_response'
+      extend Initializers
+      prepend Async
+      prepend Botan::ClientHelpers
+      include DebugClient
+
       class << self
-        # Accepts different options to initialize bot.
+        def by_id(id)
-        def wrap(input)
+          Telegram.bots[id]
-          case input
-          when self then input
-          when Array then input.map(&method(__callee__))
-          when Hash then
-            input = input.stringify_keys
-            new input['token'], input['username']
-          else
-            new(input)
-          end
         end
 
         # Prepend TypedResponse module.
@@ -31,67 +26,67 @@ module Telegram
 
         # Encodes nested hashes as json.
         def prepare_body(body)
+          body = body.dup
           body.each do |k, val|
-            body[k] = val.to_json if val.is_a?(Hash)
+            body[k] = val.to_json if val.is_a?(Hash) || val.is_a?(Array)
           end
         end
+
+        def prepare_async_args(action, body = {})
+          [action.to_s, Async.prepare_hash(prepare_body(body))]
+        end
       end
 
       attr_reader :client, :token, :username, :base_uri
 
-      def initialize(token, username = nil)
+      def initialize(token = nil, username = nil, **options)
         @client = HTTPClient.new
-        @token = token
+        @token = token || options[:token]
-        @username = username
+        @username = username || options[:username]
-        @base_uri = format URL_TEMPLATE, token
+        @base_uri = format URL_TEMPLATE, self.token
       end
 
-      def debug!(dev = STDOUT)
+      def request(action, body = {}) # rubocop:disable PerceivedComplexity
-        if block_given?
-          begin
-            old_dev = client.debug_dev
-            client.debug_dev = dev
-            yield
-          ensure
-            client.debug_dev = old_dev
-          end
-        else
-          client.debug_dev = dev
-        end
-      end
-
-      def debug_off!
-        client.debug_dev = nil
-      end
-
-      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'] || '-'}"
-        # NotFound is raised only for valid responses from Telegram
+        if result
-        raise NotFound, err_msg if 404 == status && 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)
+        end
         raise Error, err_msg
       end
 
       %w(
+        answerCallbackQuery
         answerInlineQuery
         forwardMessage
+        getChat
+        getChatAdministrators
+        getChatMember
+        getChatMembersCount
         getFile
         getMe
         getUpdates
         getUserProfilePhotos
+        kickChatMember
+        leaveChat
         sendAudio
         sendChatAction
+        sendContact
         sendDocument
         sendLocation
         sendMessage
         sendPhoto
         sendSticker
+        sendVenue
         sendVideo
         sendVoice
         setWebhook
+        unbanChatMember
       ).each do |method|
         define_method(method.underscore) { |*args| request(method, *args) }
       end
@@ -104,7 +99,7 @@ module Telegram
       end
 
       def inspect
-        "#<Telegram::Bot::Client##{object_id}(#{@username})>"
+        "#<#{self.class.name}##{object_id}(#{@username})>"
       end
     end
   end

lib/telegram/bot/client_stub.rb

@@ -4,8 +4,38 @@ module Telegram
     class ClientStub < Client
       attr_reader :requests
 
-      def initialize(username = nil)
+      module StubbedConstructor
-        @username = username
+        def new(*args)
+          if self == ClientStub || !ClientStub.stub_all?
+            super
+          else
+            ClientStub.new(*args)
+          end
+        end
+      end
+
+      class << self
+        # Any call to Client.new will return ClientStub instance when `enabled` is true.
+        # Can be used with a block.
+        def stub_all!(enabled = true)
+          Client.extend(StubbedConstructor) unless Client < StubbedConstructor
+          return @_stub_all = enabled unless block_given?
+          begin
+            old = @_stub_all
+            stub_all!(enabled)
+            yield
+          ensure
+            stub_all!(old)
+          end
+        end
+
+        def stub_all?
+          @_stub_all
+        end
+      end
+
+      def initialize(token = nil, username = nil, **options)
+        @username = username || options[:username] || token
         reset
       end
 

lib/telegram/bot/config_methods.rb

@@ -14,14 +14,21 @@ module Telegram
       # It just tells routes helpers whether to add routed bots to
       # Bot::UpdatesPoller, so their config will be available by bot key in
       # Bot::UpdatesPoller.start.
+      #
+      # It's enabled by default in Rails dev environment and `rake telegram:bot:poller`
+      # task. Use `BOT_POLLER_MODE=true` envvar to set it manually.
       def bot_poller_mode?
         return @bot_poller_mode if defined?(@bot_poller_mode)
-        Rails.env.development? if defined?(Rails)
+        @bot_poller_mode = ENV.fetch('BOT_POLLER_MODE') do
+          Rails.env.development? if defined?(Rails)
+        end
       end
 
       # Hash of bots made with bots_config.
       def bots
-        @bots ||= bots_config.transform_values(&Client.method(:wrap))
+        @bots ||= bots_config.each_with_object({}) do |(id, config), h|
+          h[id] = Client.wrap(config, id: id)
+        end
       end
 
       # Default bot.
@@ -29,17 +36,34 @@ module Telegram
         @bot ||= bots[:default]
       end
 
+      # Hash of botan clients made from #bots.
+      def botans
+        @botans ||= bots.transform_values(&:botan)
+      end
+
       # Returns config for .bots method. By default uses `telegram['bots']` section
       # from `secrets.yml` merging `telegram['bot']` at `:default` key.
       #
       # Can be overwritten with .bots_config=
       def bots_config
-        return @bots_config if @bots_config
+        @bots_config ||=
-        telegram_config = Rails.application.secrets[:telegram]
+          if defined?(Rails)
-        (telegram_config['bots'] || {}).symbolize_keys.tap do |config|
+            telegram_config = Rails.application.secrets[:telegram] || {}
-          default = telegram_config['bot']
+            (telegram_config['bots'] || {}).symbolize_keys.tap do |config|
-          config[:default] = default if default
+              default = telegram_config['bot']
-        end
+              config[:default] = default if default
+            end
+          else
+            {}
+          end
+      end
+
+      # Resets all cached bots and their configs.
+      def reset_bots
+        @bots = nil
+        @bot = nil
+        @bots_config = nil
+        @botans = nil
       end
     end
   end

lib/telegram/bot/debug_client.rb

@@ -0,0 +1,23 @@
+module Telegram
+  module Bot
+    module DebugClient
+      def debug!(dev = STDOUT)
+        if block_given?
+          begin
+            old_dev = client.debug_dev
+            client.debug_dev = dev
+            yield
+          ensure
+            client.debug_dev = old_dev
+          end
+        else
+          client.debug_dev = dev
+        end
+      end
+
+      def debug_off!
+        client.debug_dev = nil
+      end
+    end
+  end
+end

lib/telegram/bot/initializers.rb

@@ -0,0 +1,19 @@
+module Telegram
+  module Bot
+    module Initializers
+      # Accepts different options to initialize bot.
+      def wrap(input, **options)
+        case input
+        when Symbol then by_id(input) or raise "#{name} #{input.inspect} not configured"
+        when self   then input
+        when Hash   then new(**input.symbolize_keys, **options)
+        else        new(input, **options)
+        end
+      end
+
+      def by_id(_id)
+        raise 'Not implemented'
+      end
+    end
+  end
+end

lib/telegram/bot/middleware.rb

@@ -1,6 +1,8 @@
 require 'active_support/concern'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/json'
 require 'action_dispatch/http/mime_type'
-require 'action_dispatch/middleware/params_parser'
+require 'action_dispatch/http/request'
 
 module Telegram
   module Bot
@@ -13,7 +15,8 @@ module Telegram
       end
 
       def call(env)
-        update = env['action_dispatch.request.request_parameters']
+        request = ActionDispatch::Request.new(env)
+        update = request.request_parameters
         controller.dispatch(bot, update)
         [200, {}, ['']]
       end

lib/telegram/bot/routes_helper.rb

@@ -20,7 +20,7 @@ module Telegram
         # Replaces colon with underscore so rails don't treat it as
         # route parameter.
         def escape_token(token)
-          token.tr(':', '_')
+          token && token.tr(':', '_')
         end
       end
 
@@ -42,7 +42,9 @@ module Telegram
       #   # You can override this options or specify others:
       #   telegram_webhooks TelegramController, as: :my_webhook
       #   telegram_webhooks bot => [TelegramChatController, as: :chat_webhook],
-      #                     other_bot => [TelegramAuctionController,
+      #                     other_bot => TelegramAuctionController,
+      #                     admin_chat: TelegramAdminChatController
+      #
       def telegram_webhooks(controllers, bots = nil, **options)
         unless controllers.is_a?(Hash)
           bots = bots ? Array.wrap(bots) : Telegram.bots.values

lib/telegram/bot/updates_controller.rb

@@ -4,16 +4,65 @@ require 'active_support/version'
 
 module Telegram
   module Bot
-    class UpdatesController < AbstractController::Base
+    # Base class to create update processors. With callbacks, session and helpers.
+    #
+    # Define public methods for each command and they will be called when
+    # update has this command. Message is automatically parsed and
+    # words are passed as method arguments. Be sure to use default values and
+    # splat arguments in every action method to not get errors, when user
+    # sends command without necessary args / with extra args.
+    #
+    #     def start(token = nil, *)
+    #       if token
+    #         # ...
+    #       else
+    #         # ...
+    #       end
+    #     end
+    #
+    #     def help(*)
+    #       respond_with :message, text:
+    #     end
+    #
+    # To process plain text messages (without commands) or other updates just
+    # define public method with name of payload type. They will receive payload
+    # as an argument.
+    #
+    #     def message(message)
+    #       respond_with :message, text: "Echo: #{message['text']}"
+    #     end
+    #
+    #     def inline_query(query)
+    #       answer_inline_query results_for_query(query), is_personal: true
+    #     end
+    #
+    #     # To process conflicting commands (`/message args`) just use `on_` prefix:
+    #     def on_message(*args)
+    #       # ...
+    #     end
+    #
+    # To process update run:
+    #
+    #     ControllerClass.dispatch(bot, update)
+    #
+    # There is also ability to run action without update:
+    #
+    #     ControllerClass.new(bot, from: telegram_user, chat: telegram_chat).
+    #       process(:help, *args)
+    #
+    class UpdatesController < AbstractController::Base # rubocop:disable ClassLength
       abstract!
 
       require 'telegram/bot/updates_controller/session'
       require 'telegram/bot/updates_controller/log_subscriber'
       require 'telegram/bot/updates_controller/instrumentation'
+      require 'telegram/bot/updates_controller/reply_helpers'
+      autoload :CallbackQueyContext, 'telegram/bot/updates_controller/callback_query_context'
+      autoload :MessageContext, 'telegram/bot/updates_controller/message_context'
 
       include AbstractController::Callbacks
       # Redefine callbacks with default terminator.
-      if ActiveSupport.gem_version >= Gem::Version.new('5')
+      if ActiveSupport::VERSION::MAJOR >= 5
         define_callbacks  :process_action,
                           skip_after_callbacks_if_terminated: true
       else
@@ -23,6 +72,7 @@ module Telegram
       end
 
       include AbstractController::Translation
+      include ReplyHelpers
       prepend Instrumentation
       extend Session::ConfigMethods
 
@@ -32,11 +82,14 @@ module Telegram
         message
         inline_query
         chosen_inline_result
+        callback_query
+        edited_message
       ).freeze
       CMD_REGEX = %r{\A/([a-z\d_]{,31})(@(\S+))?(\s|$)}i
       CONFLICT_CMD_REGEX = Regexp.new("^(#{PAYLOAD_TYPES.join('|')}|\\d)")
 
       class << self
+        # Initialize controller and process update.
         def dispatch(*args)
           new(*args).dispatch
         end
@@ -59,7 +112,7 @@ module Telegram
           match = text.match CMD_REGEX
           return unless match
           return if match[3] && username != true && match[3] != username
-          [match[1], text.split(' ').drop(1)]
+          [match[1], text.split.drop(1)]
         end
       end
 
@@ -67,34 +120,81 @@ module Telegram
       alias_method :command?, :is_command
       delegate :username, to: :bot, prefix: true, allow_nil: true
 
+      # Second argument can be either update object with hash access & string
+      # keys or Hash with `:from` or `:chat` to override this values and assume
+      # that update is nil.
       def initialize(bot = nil, update = nil)
+        if update.is_a?(Hash) && (update.key?(:from) || update.key?(:chat))
+          options = update
+          update = nil
+        end
         @_update = update
         @_bot = bot
+        @_chat, @_from = options && options.values_at(:chat, :from)
 
+        payload_data = nil
         update && PAYLOAD_TYPES.find do |type|
           item = update[type]
-          next unless item
+          payload_data = [item, type] if item
-          @_payload = item
-          @_payload_type = type
         end
+        @_payload, @_payload_type = payload_data
       end
 
+      # Accessor to `'chat'` field of payload. Can be overriden with `chat` option
+      # for #initialize.
+      def chat
+        @_chat ||= payload && payload['chat']
+      end
+
+      # Accessor to `'from'` field of payload. Can be overriden with `from` option
+      # for #initialize.
+      def from
+        @_from ||= payload && payload['from']
+      end
+
+      # Processes current update.
       def dispatch
         @_is_command, action, args = action_for_payload
         process(action, *args)
       end
 
       # Calculates action name and args for payload.
-      # If payload is a message with command, then returned action is an
+      # Uses `action_for_#{payload_type}` methods.
-      # action for this command. Otherwise it's the same as payload type.
+      # If this method doesn't return anything
+      # it uses fallback with action same as payload type.
       # Returns array `[is_command?, action, args]`.
       def action_for_payload
-        case payload_type
+        if payload_type
-        when 'message'
+          send("action_for_#{payload_type}") || [false, payload_type, [payload]]
-          cmd, args = self.class.command_from_text(payload['text'], bot_username)
+        else
-          cmd &&= self.class.action_for_command(cmd)
+          [false, :unsupported_payload_type, []]
-          [true, cmd, args] if cmd
+        end
-        end || [false, payload_type, [payload]]
+      end
+
+      # If payload is a message with command, then returned action is an
+      # action for this command.
+      # Separate method, so it can be easily overriden (ex. MessageContext).
+      def action_for_message
+        cmd, args = self.class.command_from_text(payload['text'], bot_username)
+        cmd &&= self.class.action_for_command(cmd)
+        [true, cmd, args] if cmd
+      end
+
+      # It doesn't extract commands from edited messages. Just process
+      # them as usual ones.
+      def action_for_edited_message
+      end
+
+      def action_for_inline_query
+        [false, payload_type, [payload['query'], payload['offset']]]
+      end
+
+      def action_for_chosen_inline_result
+        [false, payload_type, [payload['result_id'], payload['query']]]
+      end
+
+      def action_for_callback_query
+        [false, payload_type, [payload['data']]]
       end
 
       # Silently ignore unsupported messages.
@@ -102,19 +202,6 @@ module Telegram
       def action_missing(*)
       end
 
-      %w(chat from).each do |field|
-        define_method(field) { payload[field] }
-      end
-
-      def reply_with(type, params)
-        method = "send_#{type}"
-        params = params.merge(
-          chat_id: chat['id'],
-          reply_to_message: payload['message_id'],
-        )
-        bot.public_send(method, params)
-      end
-
       ActiveSupport.run_load_hooks('telegram.bot.updates_controller', self)
     end
   end

lib/telegram/bot/updates_controller/callback_query_context.rb

@@ -0,0 +1,34 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      # Use separate actions for different callback queries.
+      # It doesn't require session support. Simply add `%{context}:` prefix to data.
+      module CallbackQueyContext
+        protected
+
+        # Uses #context_from_callback_query as context name.
+        # If context is present checks if `%context%_callback_query` is valid
+        # action method and returns it if so. Context is stripped from data
+        # in this case. Otherwise returns `super`.
+        #
+        # It wont raise ActionNotFound as MessageContext does,
+        # because `data` param is controlled by client.
+        def action_for_callback_query
+          context, new_data = context_from_callback_query
+          # binding.pry
+          if context
+            action_name = "#{context}_callback_query"
+            [false, action_name, [new_data]] if action_method?(action_name)
+          end || super
+        end
+
+        def context_from_callback_query
+          data = payload['data']
+          return unless data
+          parts = data.split(':', 2)
+          parts if parts.size > 1
+        end
+      end
+    end
+  end
+end

lib/telegram/bot/updates_controller/instrumentation.rb

@@ -6,7 +6,7 @@ module Telegram
       module Instrumentation
         class << self
           def prepended(base)
-            base.config_accessor :logger
+            base.send :config_accessor, :logger
             base.extend ClassMethods
           end
 
@@ -35,8 +35,14 @@ module Telegram
           end
         end
 
-        def reply_with(type, *)
+        def respond_with(type, *)
-          Instrumentation.instrument(:reply_with, type: type) { super }
+          Instrumentation.instrument(:respond_with, type: type) { super }
+        end
+
+        %i(answer_callback_query answer_inline_query).each do |type|
+          define_method(type) do |*args|
+            Instrumentation.instrument(:respond_with, type: type) { super(*args) }
+          end
         end
 
         private

lib/telegram/bot/updates_controller/log_subscriber.rb

@@ -22,8 +22,8 @@ module Telegram
           end
         end
 
-        def reply_with(event)
+        def respond_with(event)
-          info { "Replied with #{event.payload[:type]}" }
+          info { "Responded with #{event.payload[:type]}" }
         end
 
         def halted_callback(event)

lib/telegram/bot/updates_controller/message_context.rb

@@ -0,0 +1,94 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      # Allows to store context in session and treat next message according to this context.
+      module MessageContext
+        extend ActiveSupport::Concern
+
+        include Session
+
+        included do
+          # As we use before_action context is cleared anyway,
+          # no matter we used it or not.
+          singleton_class.send :attr_reader, :context_handlers, :context_to_action
+          @context_handlers = {}
+        end
+
+        module ClassMethods
+          # Registers handler for context.
+          #
+          #     context_handler :rename do |*|
+          #       resource.update!(name: payload['text'])
+          #     end
+          #
+          #     # To run other action with all the callbacks:
+          #     context_handler :rename do |*words|
+          #       process(:rename, *words)
+          #     end
+          #
+          #     # Or just
+          #     context_handler :rename, :your_action_to_call
+          #     context_handler :rename # to call :rename
+          #
+          def context_handler(context = nil, action = nil, &block)
+            context &&= context.to_sym
+            if block
+              action = "_context_handler_#{context}"
+              define_method(action, &block)
+            end
+            context_handlers[context] = action || context
+          end
+
+          # Use it to use context value as action name for all contexts
+          # which miss handlers.
+          # For security reasons it supports only action methods and will
+          # raise AbstractController::ActionNotFound if context is invalid.
+          def context_to_action!
+            @context_to_action = true
+          end
+        end
+
+        # Action to clear context.
+        def cancel
+          # Context is already cleared in action_for_message
+        end
+
+        private
+
+        # Context is read from the session to treat messages
+        # according to previous request.
+        attr_reader :context
+
+        # Fetches context and finds handler for it. If message has new command,
+        # it has higher priority than contextual action.
+        def action_for_message
+          val = session.delete(:context)
+          @context = val && val.to_sym
+          super || context && begin
+            handler = handler_for_context
+            [true, handler, payload['text'].try!(:split) || []] if handler
+          end
+        end
+
+        # Save context for the next request.
+        def save_context(context)
+          session[:context] = context
+        end
+
+        def handler_for_context
+          self.class.context_handlers[context] || self.class.context_to_action && begin
+            action_name = context.to_s
+            unless action_method?(action_name)
+              raise AbstractController::ActionNotFound,
+                "The action '#{action_name}' could not be set from context " \
+                "for #{self.class.name}. " \
+                'context_to_action! supports only action methods for security reasons. ' \
+                'If you need to call this action use context_handler for it.'
+            end
+            action_name
+          end
+        end
+      end
+    end
+  end
+end

lib/telegram/bot/updates_controller/reply_helpers.rb

@@ -0,0 +1,44 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      module ReplyHelpers
+        # Helper to call bot's `send_#{type}` method with already set `chat_id`:
+        #
+        #     respond_with :message, text: 'Hello!'
+        #     respond_with :message, text: '__Hello!__', parse_mode: :Markdown
+        #     respond_with :photo, photo: File.open(photo_to_send), caption: "It's incredible!"
+        def respond_with(type, params)
+          chat = self.chat
+          chat_id = chat && chat['id'] or raise 'Can not respond_with when chat is not present'
+          bot.public_send("send_#{type}", params.merge(chat_id: chat_id))
+        end
+
+        # Same as respond_with but also sets `reply_to_message_id`.
+        def reply_with(type, params)
+          payload = self.payload
+          message_id = payload && payload['message_id']
+          params = params.merge(reply_to_message_id: message_id) if message_id
+          respond_with(type, params)
+        end
+
+        # Same as reply_with, but for inline queries.
+        def answer_inline_query(results, params = {})
+          params = params.merge(
+            inline_query_id: payload['id'],
+            results: results,
+          )
+          bot.answer_inline_query(params)
+        end
+
+        # Same as reply_with, but for callback queries.
+        def answer_callback_query(text, params = {})
+          params = params.merge(
+            callback_query_id: payload['id'],
+            text: text,
+          )
+          bot.answer_callback_query(params)
+        end
+      end
+    end
+  end
+end

lib/telegram/bot/updates_controller/rspec_helpers.rb

@@ -1,23 +1,29 @@
+require 'telegram/bot/updates_controller/testing'
+
 RSpec.shared_context 'telegram/bot/updates_controller' do
   let(:controller_class) { described_class }
-  let(:instance) { controller_class.new(bot, update) }
+  let(:controller) do
-  let(:update) { {payload_type => payload} }
+    controller_class.new(bot, update).tap do |x|
-  let(:payload_type) { 'some_type' }
+      x.extend Telegram::Bot::UpdatesController::Testing
+    end
+  end
+  let(:update) { build_update(payload_type, payload) }
+  let(:payload_type) { :some_type }
   let(:payload) { double(:payload) }
   let(:bot) { Telegram::Bot::ClientStub.new(bot_name) }
   let(:bot_name) { 'bot' }
-  let(:session) do
+  let(:session) { controller.send(:session) }
-    session = Telegram::Bot::UpdatesController::Session::TestSessionHash.new
+
-    allow_any_instance_of(controller_class).to receive(:session) { session }
+  def dispatch(bot = self.bot, update = self.update)
-    session
+    controller.dispatch_again(bot, update)
   end
 
   def dispatch_message(text, options = {})
-    payload = build_payload :message, options.merge(text: text)
+    update = build_update :message, options.merge(text: text)
-    controller_class.dispatch bot, payload
+    dispatch bot, update
   end
 
-  def build_payload(type, content)
+  def build_update(type, content)
     deep_stringify type => content
   end
 

lib/telegram/bot/updates_controller/session.rb

@@ -17,11 +17,15 @@ module Telegram
         protected
 
         def session
-          @_session ||= SessionHash.new(self.class.session_store, session_key)
+          @_session ||= begin
+            key = session_key
+            key ? SessionHash.new(self.class.session_store, key) : NullSessionHash.new
+          end
         end
 
         def session_key
-          "#{bot.username}:#{from ? "from:#{from['id']}" : "chat:#{chat['id']}"}"
+          subject = from || chat
+          "#{bot.username}:#{subject['id']}" if subject
         end
 
         # Rack::Session::Abstract::SessionHash is taken to provide lazy loading.
@@ -59,7 +63,7 @@ module Telegram
           end
         end
 
-        class TestSessionHash < SessionHash
+        class NullSessionHash < Session::SessionHash
           def initialize
             @data = {}
             @loaded = true
@@ -77,6 +81,10 @@ module Telegram
           def session_store=(store)
             config.session_store = ActiveSupport::Cache.lookup_store(store)
           end
+
+          def use_session!
+            include Session
+          end
         end
       end
     end

lib/telegram/bot/updates_controller/testing.rb

@@ -0,0 +1,35 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      module Testing
+        IVARS_TO_KEEP = %i(@_session).freeze
+
+        # Perform multiple dispatches on same instance.
+        def dispatch_again(bot = nil, update = nil)
+          recycle!
+          initialize(bot, update)
+          dispatch
+        end
+
+        # Cleans controller between dispatches.
+        # Seems like there is nothing to clean between requests for now:
+        # everything will be rewriten with #initialize.
+        #
+        # With `full` set to `true` it'll clear all cached instance variables.
+        def recycle!(full = false)
+          return unless full
+          (instance_variables - IVARS_TO_KEEP).each do |ivar|
+            remove_instance_variable(ivar)
+          end
+        end
+
+        protected
+
+        # Stubs session.
+        def session
+          @_session ||= Session::NullSessionHash.new
+        end
+      end
+    end
+  end
+end

lib/telegram/bot/updates_controller/typed_update.rb

@@ -4,7 +4,7 @@ module Telegram
       # Include this module to type cast update to Virtus model
       # using `telegram-bot-types` gem (install this gem first).
       module TypedUpdate
-        def initialize(bot, update)
+        def initialize(bot = nil, update = nil)
           update = Types::Update.new(update) if update && !update.is_a?(Types::Update)
           super
         end

lib/telegram/bot/updates_poller.rb

@@ -64,7 +64,7 @@ module Telegram
       end
 
       def fetch_updates
-        response = bot.get_updates(offset: offset, timeout: timeout)
+        response = bot.async(false) { bot.get_updates(offset: offset, timeout: timeout) }
         return unless response['ok'] && response['result'].any?
         reload! do
           response['result'].each do |update|
@@ -77,11 +77,25 @@ module Telegram
 
       def reload!
         return yield unless reload
-        ActionDispatch::Reloader.prepare!
+        reloading_code do
-        if controller.is_a?(Class) && controller.name
+          if controller.is_a?(Class) && controller.name
-          @controller = Object.const_get(controller.name)
+            @controller = Object.const_get(controller.name)
+          end
+          yield
+        end
+      end
+
+      if defined?(Rails) && Rails.application.respond_to?(:reloader)
+        def reloading_code
+          Rails.application.reloader.wrap do
+            yield
+          end
+        end
+      else
+        def reloading_code
+          ActionDispatch::Reloader.prepare!
+          yield.tap { ActionDispatch::Reloader.cleanup! }
         end
-        yield.tap { ActionDispatch::Reloader.cleanup! }
       end
     end
   end

lib/telegram/bot/version.rb

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

spec/spec_helper.rb

@@ -17,6 +17,8 @@ require 'telegram/bot'
 require 'telegram/bot/updates_controller/rspec_helpers'
 require 'telegram/bot/types'
 
+Dir[GEM_ROOT.join('spec/support/**/*.rb')].each { |f| require f }
+
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
     # This option will default to `true` in RSpec 4. It makes the `description`

spec/support/examples/async.rb

@@ -0,0 +1,89 @@
+RSpec.shared_examples 'async' do |request_args: -> {}|
+  let(:instance) { described_class.new(token: token, id: id, async: async) }
+  let(:id) { :default_bot }
+  let(:async) { true }
+  let!(:application_job_class) do
+    klass = Class.new do
+      def self.perform_later(*)
+      end
+    end
+    klass.tap { |x| stub_const('ApplicationJob', x) }
+  end
+  after { described_class.default_async_job = nil }
+
+  describe '#async' do
+    subject { ->(*args, &block) { instance.async(*args, &block) } }
+    its(:call) { should eq described_class.default_async_job }
+
+    context 'when async is disabled' do
+      let(:async) { false }
+      its(:call) { should eq false }
+    end
+
+    context 'when using with block' do
+      it 'sets value inside block' do
+        expect do
+          expect do
+            subject.call(false) do
+              expect do
+                subject.call(nil) { expect(subject[]).to eq nil }
+              end.to_not change(&subject).from false
+              raise 'TestError'
+            end
+          end.to raise_error(/TestError/)
+        end.to_not change(instance, :async).from(described_class.default_async_job)
+      end
+    end
+  end
+
+  describe '.default_async_job' do
+    subject { described_class.default_async_job }
+    its(:superclass) { should eq application_job_class }
+    it { should include Telegram::Bot::Async::Job }
+    its(:client_class) { should eq described_class }
+
+    context 'when ApplicationJob is not defined' do
+      let(:application_job_class) {}
+      it { expect { subject }.to raise_error(/Define ApplicationJob/) }
+    end
+  end
+
+  describe '#request' do
+    subject { ->(*args) { instance.request(*(args.empty? ? self.args : args)) } }
+    let(:args, &request_args)
+    let(:result) { double(:result) }
+
+    shared_examples 'enqueues job' do
+      it 'enqueues job' do
+        expect(instance).to_not receive(:http_request)
+        expect(described_class).to receive(:prepare_async_args).with(*args) { args }
+        expect(instance.async).to receive(:perform_later).with(id.to_s, *args) { result }
+        expect(subject.call).to eq result
+      end
+    end
+
+    include_examples 'enqueues job'
+
+    context 'with custom job class' do
+      let(:async) { double(:job_class) }
+      include_examples 'enqueues job'
+    end
+
+    context 'when id is not set' do
+      let(:id) {}
+      it { should raise_error(/Can not enqueue/) }
+    end
+
+    context 'when async is disabled' do
+      let(:async) { false }
+      let(:result) { double(status: 200, body: '{"test":"ok"}') }
+      let(:args, &request_args)
+
+      it 'performs request immediately' do
+        expect(instance).to receive(:request).with(*args).and_call_original
+        expect(instance).to receive(:http_request) { result }
+        expect(subject[]).to eq 'test' => 'ok'
+      end
+    end
+  end
+end

spec/support/examples/initializers.rb

@@ -0,0 +1,65 @@
+RSpec.shared_examples 'initializers' do |config_method = :bots|
+  describe '.wrap' do
+    subject { described_class.wrap(input, **options) }
+    let(:options) { {} }
+    let(:result) { double(:result) }
+    let(:username) { 'username' }
+
+    context 'when input is a string' do
+      let(:input) { token }
+
+      it 'treats string as token' do
+        expect(described_class).to receive(:new).with(token, {}) { result }
+        should eq result
+      end
+
+      context 'and additional options are given' do
+        let(:options) { {id: :test} }
+
+        it 'passes them to initializer' do
+          expect(described_class).to receive(:new).with(input, **options) { result }
+          should eq result
+        end
+      end
+    end
+
+    context 'when input is a hash' do
+      let(:input) { {token: token, 'username' => username, other: :options} }
+
+      it 'passes it with symbolized keys' do
+        expect(described_class).to receive(:new).with(**input.symbolize_keys) { result }
+        should eq result
+      end
+
+      context 'and additional options are given' do
+        let(:options) { {id: :test} }
+
+        it 'passes them to initializer' do
+          expect(described_class).to receive(:new).
+            with(**input.symbolize_keys, **options) { result }
+          should eq result
+        end
+      end
+    end
+
+    context 'when input is an instance of described_class' do
+      let!(:input) { instance }
+
+      it 'returns input' do
+        expect(described_class).to_not receive(:new)
+        should eq input
+      end
+    end
+
+    context 'when input is a Symbol' do
+      let(:input) { :client_1 }
+      before { allow(Telegram).to receive(config_method) { {client_1: instance} } }
+      it { should eq Telegram.send(config_method)[:client_1] }
+
+      context 'and there is no such bot' do
+        let(:input) { :invalid }
+        it { expect { subject }.to raise_error(/not configured/) }
+      end
+    end
+  end
+end

spec/telegram/bot/async_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Telegram::Bot::Async::Job do
+  let(:job_class) do
+    described_class = self.described_class
+    client_class = self.client_class
+    Class.new do
+      include described_class
+      self.client_class = client_class
+    end
+  end
+  let(:client_class) { Telegram::Bot::Client }
+  let(:instance) { job_class.new }
+
+  describe '#perform' do
+    subject { instance.perform(id, *args) }
+    let(:id) { 'bot_id' }
+    let(:args) { [double(:action), {body: :content}] }
+    let(:client) { Telegram::Bot::Client.new(async: custom_job_class) }
+    let(:custom_job_class) { Class.new }
+    let(:result) { double(status: 200, body: '{"test":"ok"}') }
+
+    it 'finds client and performs request' do
+      expect(client_class).to receive(:wrap).with(id.to_sym) { client }
+      expect(client).to receive(:request).with(*args).and_call_original
+      expect(client).to receive(:http_request) { result }
+      should eq 'test' => 'ok'
+    end
+  end
+end

spec/telegram/bot/botan/client_helpers_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe Telegram::Bot::Client do
+  let(:instance) { described_class.new(*client_args) }
+  let(:token) { 'token' }
+  let(:botan_token) { double(:botan_token) }
+  let(:client_id) { 'client_id' }
+  let(:client_args) { [token] }
+
+  describe '#botan' do
+    subject { instance.botan }
+    it { should eq nil }
+
+    context 'when botan token is set' do
+      let(:client_args) { [token, id: client_id, async: Class.new, botan: botan_token] }
+      it { should be_instance_of Telegram::Bot::Botan }
+      its(:token) { should eq botan_token }
+      its(:id) { should eq client_id }
+
+      it 'doesnt inherit async from client' do
+        expect(instance.async).to be
+        expect(subject.async).to_not be
+      end
+    end
+
+    context 'when botan is configured with hash' do
+      let(:client_args) { [token, id: client_id, async: Class.new, botan: botan_config] }
+      let(:botan_config) { {token: botan_token, async: Class.new} }
+      it { should be_instance_of Telegram::Bot::Botan }
+      its(:token) { should eq botan_token }
+      its(:id) { should eq client_id }
+      its(:async) { should eq botan_config[:async] }
+    end
+  end
+end

spec/telegram/bot/botan/controller_helpers_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe Telegram::Bot::Botan::ControllerHelpers do
+  include_context 'telegram/bot/updates_controller'
+  let(:controller_class) do
+    described_class = self.described_class
+    Class.new(Telegram::Bot::UpdatesController) do
+      include described_class
+    end
+  end
+  let(:botan) { double(:botan) }
+  let(:result) { double(:result) }
+  let(:payload) { {from: {id: user_id}} }
+  let(:payload_type) { :message }
+  let(:user_id) { double(:user_id) }
+  before { allow(bot).to receive(:botan) { botan } }
+
+  shared_examples 'basic tracking' do
+    context 'when botan is not configured' do
+      let(:botan) {}
+      it { should eq nil }
+    end
+
+    context 'when `from` is empty' do
+      let(:payload) { {text: 'test'} }
+      it { expect { subject }.to raise_error described_class::MissingFrom }
+    end
+  end
+
+  describe '#botan_track' do
+    subject { controller.send(:botan_track, event, data) }
+    let(:event) { double(:event) }
+    let(:data) { double(:data) }
+
+    it 'calls botan#track' do
+      expect(botan).to receive(:track).with(event, user_id, data) { result }
+      should eq result
+    end
+
+    include_examples 'basic tracking'
+  end
+
+  describe '#botan_track_action' do
+    subject { controller.send(:botan_track_action) }
+    let(:action_name) { double(:action_name) }
+
+    it 'calls botan#track with current action and payload' do
+      expect(controller).to receive(:action_name) { action_name }
+      expect(botan).to receive(:track).
+        with(action_name, user_id, deep_stringify(payload)) { result }
+      should eq result
+    end
+
+    include_examples 'basic tracking'
+  end
+end

spec/telegram/bot/botan_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe Telegram::Bot::Botan do
+  let(:instance) { described_class.new 'token' }
+  let(:token) { 'token' }
+
+  include_examples 'initializers', :botans
+  include_examples 'async', request_args: -> { [double(:method), double(:url)] }
+
+  describe '.new' do
+    subject { described_class.new(*args) }
+
+    context 'when usual args are given' do
+      let(:args) { ['secret'] }
+      its(:token) { should eq args[0] }
+    end
+
+    context 'when options are given' do
+      let(:args) { [token: 'secret'] }
+      its(:token) { should eq args[0][:token] }
+    end
+  end
+
+  describe '.prepare_async_args' do
+    subject { described_class.prepare_async_args(*input) }
+    let(:input) { [:post, :uri, {a: 1, b: :sym, 'd' => 'str'}, 'body'] }
+    it { should eq ['post', 'uri', {a: 1, b: 'sym', 'd' => 'str'}, 'body'] }
+  end
+end

spec/telegram/bot/client_spec.rb

@@ -1,55 +1,16 @@
 RSpec.describe Telegram::Bot::Client do
-  describe '.wrap' do
+  let(:instance) { described_class.new 'token' }
-    subject { described_class.wrap(input) }
+  let(:token) { 'token' }
-    let(:result) { double(:result) }
+  let(:botan_token) { double(:botan_token) }
-    let(:token) { 'token' }
-    let(:username) { 'username' }
-    let(:instance) { described_class.new 'token' }
 
-    context 'when input is a string' do
+  include_examples 'initializers'
-      let(:input) { token }
+  include_examples 'async', request_args: -> { [double(:action), {body: :content}] }
-
-      it 'treats string as token' do
-        expect(described_class).to receive(:new).with(token) { result }
-        should eq result
-      end
-    end
-
-    context 'when input is a hash' do
-      let(:input) { {token: token, username: username, ignore: :ignore} }
-
-      it 'extracts token & username' do
-        expect(described_class).to receive(:new).with(token, username) { result }
-        should eq result
-      end
-    end
-
-    context 'when input is an instance of described_class' do
-      let!(:input) { instance }
-
-      it 'returns input' do
-        expect(described_class).to_not receive(:new)
-        should eq input
-      end
-    end
-
-    context 'when input is an array' do
-      let!(:input) { ['other_token', instance, token: token, username: username] }
-      let(:result_2) { double(:result_2) }
-
-      it 'calls wrap for every element' do
-        expect(described_class).to receive(:new).with('other_token') { result }
-        expect(described_class).to receive(:new).with(token, username) { result_2 }
-        should eq [result, instance, result_2]
-      end
-    end
-  end
 
   describe '.prepare_body' do
     subject { described_class.prepare_body(input) }
 
     context 'when plain hash is given' do
-      let(:input) { {a: 1, b: '2', c: [1, 2]} }
+      let(:input) { {a: 1, b: '2', c: nil} }
       it { should eq input }
     end
 
@@ -58,9 +19,33 @@ RSpec.describe Telegram::Bot::Client do
 
       it 'encodes nested hashes to json' do
         expected = input.dup
-        %i(d e).each { |x| expected[x] = expected[x].to_json }
+        %i(c d e).each { |x| expected[x] = expected[x].to_json }
         should eq expected
       end
     end
   end
+
+  describe '.prepare_async_args' do
+    subject { described_class.prepare_async_args(*input) }
+    let(:input) { [:action, a: 1, b: :sym, c: [:other], 'd' => 'str'] }
+    it { should eq ['action', a: 1, b: 'sym', c: '["other"]', 'd' => 'str'] }
+  end
+
+  describe '.new' do
+    subject { described_class.new(*args) }
+
+    context 'when multiple args are given' do
+      let(:args) { %w(secret superbot) }
+      its(:token) { should eq args[0] }
+      its(:username) { should eq args[1] }
+      its(:base_uri) { should include args[0] }
+    end
+
+    context 'when hash is given' do
+      let(:args) { [token: 'secret', username: 'superbot'] }
+      its(:token) { should eq args[0][:token] }
+      its(:username) { should eq args[0][:username] }
+      its(:base_uri) { should include args[0][:token] }
+    end
+  end
 end

spec/telegram/bot/client_stub_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe Telegram::Bot::ClientStub do
+  describe '#stub_all!' do
+    let(:client) { Telegram::Bot::Client.new('token', 'bot_name') }
+    let(:clients) { ['token', token: 'token2'].map(&Telegram::Bot::Client.method(:wrap)) }
+
+    shared_examples 'constructors' do |expected_class|
+      it 'makes Client.new return ClientStub' do
+        expect(client).to be_instance_of expected_class
+        expect(client.username).to eq 'bot_name'
+      end
+
+      it 'makes Client.wrap return ClientStub' do
+        expect(clients).to contain_exactly instance_of(expected_class),
+          instance_of(expected_class)
+      end
+    end
+
+    context 'when not used' do
+      include_examples 'constructors', Telegram::Bot::Client
+    end
+
+    context 'when enabled' do
+      around { |ex| described_class.stub_all! { ex.run } }
+      include_examples 'constructors', Telegram::Bot::ClientStub
+    end
+
+    context 'when redisabled' do
+      around do |ex|
+        described_class.stub_all! do
+          described_class.stub_all!(false) do
+            ex.run
+          end
+        end
+      end
+      include_examples 'constructors', Telegram::Bot::Client
+    end
+  end
+
+  describe '#new' do
+    subject { described_class.new(*args) }
+
+    context 'when only username is given' do
+      let(:args) { 'superbot' }
+      its(:username) { should eq args }
+    end
+
+    context 'when username and token are given' do
+      let(:args) { %w(token superbot) }
+      its(:token) { should eq nil }
+      its(:username) { should eq args[1] }
+    end
+  end
+end

spec/telegram/bot/config_methods_spec.rb

@@ -0,0 +1,94 @@
+RSpec.describe Telegram::Bot::ConfigMethods do
+  let(:registry) do
+    Object.new.tap do |x|
+      x.extend described_class
+      x.bots_config = config
+    end
+  end
+  let(:config) do
+    {
+      default: 'default_token',
+      chat: {
+        token: 'chat_token',
+        username: 'Chat',
+        botan: 'chat_botan_token',
+      },
+      other_chat: {
+        'token' => 'other_chat_token',
+        'username' => 'OtherChat',
+        'botan' => 'other_chat_botan_token',
+      },
+    }
+  end
+
+  describe '#bot' do
+    subject { registry.bot }
+    it { should eq registry.bots[:default] }
+  end
+
+  describe '#bots' do
+    context 'configured by token' do
+      subject { registry.bots[:default] }
+      its(:id) { should eq :default }
+      its(:token) { should eq config[:default] }
+    end
+
+    context 'configured by hash' do
+      subject { registry.bots[:chat] }
+      its(:id) { should eq :chat }
+      its(:token) { should eq config[:chat][:token] }
+      its(:username) { should eq config[:chat][:username] }
+      its('botan.token') { should eq config[:chat][:botan] }
+    end
+
+    context 'configured by hash with stringified keys' do
+      subject { registry.bots[:other_chat] }
+      its(:id) { should eq :other_chat }
+      its(:token) { should eq config[:other_chat]['token'] }
+      its(:username) { should eq config[:other_chat]['username'] }
+      its('botan.token') { should eq config[:other_chat]['botan'] }
+    end
+  end
+
+  describe '#botans' do
+    subject { registry.botans }
+    it do
+      should eq(
+        default: nil,
+        chat: registry.bots[:chat].botan,
+        other_chat: registry.bots[:other_chat].botan,
+      )
+    end
+  end
+
+  describe '#bots_config' do
+    subject { registry.bots_config }
+    it { should eq config }
+
+    context 'when not configured' do
+      let(:registry) { Object.new.tap { |x| x.extend described_class } }
+      it { should eq({}) }
+
+      context 'in rails environment' do
+        before { stub_const('Rails', double(application: double(secrets: secrets))) }
+        let(:secrets) { {} }
+        it { should eq({}) }
+
+        context 'when there is telegram section in secrets' do
+          let(:secrets) { {telegram: config.stringify_keys} }
+          let(:config) do
+            {
+              bot: double(:bot_config),
+              bots: {
+                chat: double(:chat_config),
+                other_chat: double(:other_chat_config),
+              },
+            }
+          end
+          it { should include default: config[:bot] }
+          it { should include config[:bots] }
+        end
+      end
+    end
+  end
+end

spec/telegram/bot/middleware_spec.rb

@@ -1,3 +1,5 @@
+require 'rack/mock'
+
 RSpec.describe Telegram::Bot::Middleware do
   let(:instance) { described_class.new bot, controller }
   let(:bot) { double(:bot) }
@@ -6,10 +8,25 @@ RSpec.describe Telegram::Bot::Middleware do
   describe '#call' do
     subject { instance.call(env) }
     let(:env) { {'action_dispatch.request.request_parameters' => json_body} }
-    let(:json_body) { double(:json_body) }
+    let(:update) { {'message' => {'id' => 1}} }
+    let(:env) do
+      Rack::MockRequest.env_for('/',
+        method: :post,
+        input:  JSON.dump(update),
+        'CONTENT_TYPE' => 'application/json',
+      )
+    end
+
+    require 'action_pack/version'
+    if ActionPack::VERSION::MAJOR < 5
+      # Before Rails 5, params are parsed in middleware.
+      # In Rails 5, they are parsed in Request#request_parameters.
+      require 'action_dispatch/middleware/params_parser'
+      let(:instance) { ActionDispatch::ParamsParser.new(super()) }
+    end
 
     it 'calls dispatch on controller' do
-      expect(controller).to receive(:dispatch).with(bot, json_body)
+      expect(controller).to receive(:dispatch).with(bot, update)
       subject
     end
 

spec/telegram/bot/routes_helper_spec.rb

@@ -50,8 +50,9 @@ RSpec.describe Telegram::Bot::RoutesHelper do
 
     def assert_routes(*expected) # rubocop:disable AbcSize
       expected.each do |(bot, controller, route_name, options)|
+        expected_path = options.delete(:path) || "telegram/#{bot.token}"
         expect(mapper).to receive(:post) do |path, params|
-          expect(path).to eq "telegram/#{bot.token}"
+          expect(path).to eq expected_path
           middleware = params[:to]
           expect(middleware.controller).to eq(controller)
           expect(middleware.bot.token).to eq(bot.token)
@@ -70,6 +71,27 @@ RSpec.describe Telegram::Bot::RoutesHelper do
         assert_routes [bot, controller, 'default_telegram_webhook', option: :val],
                       [other_bot, controller, 'other_telegram_webhook', option: :val]
       end
+
+      context 'and bot does not have configured token' do
+        let(:bot) { create_bot(nil) }
+        it 'creates routes for every bot and this controller' do
+          assert_routes [bot, controller, 'default_telegram_webhook', option: :val],
+                        [other_bot, controller, 'other_telegram_webhook', option: :val]
+        end
+      end
+
+      context 'and bot has colon in token' do
+        let(:bot) { create_bot('some:token') }
+        it 'replaces colon with underscore' do
+          assert_routes [
+            bot,
+            controller,
+            'default_telegram_webhook',
+            option: :val,
+            path: 'telegram/some_token',
+          ], [other_bot, controller, 'other_telegram_webhook', option: :val]
+        end
+      end
     end
 
     context 'when called with hash' do
@@ -78,6 +100,7 @@ RSpec.describe Telegram::Bot::RoutesHelper do
           {
             bot => controller,
             'custom_token' => [other_controller, as: :custom_route, option: :other_val],
+            other: controller,
           },
           option: :val,
         ]
@@ -90,7 +113,8 @@ RSpec.describe Telegram::Bot::RoutesHelper do
                         other_controller,
                         :custom_route,
                         option: :other_val,
-                      ]
+                      ],
+                      [Telegram.bots[:other], controller, 'other_telegram_webhook', option: :val]
       end
     end
 

spec/telegram/bot/updates_controller/callback_query_context_spec.rb

@@ -0,0 +1,65 @@
+RSpec.describe Telegram::Bot::UpdatesController::CallbackQueyContext do
+  include_context 'telegram/bot/updates_controller'
+  let(:controller_class) do
+    described_class = self.described_class
+    Class.new(Telegram::Bot::UpdatesController) do
+      include described_class
+
+      attr_accessor :filter_done
+      before_action only: :ctx2_callback_query do
+        self.filter_done = true
+      end
+
+      def callback_query(data)
+        [:no_context, data]
+      end
+
+      def ctx1_callback_query(data)
+        [:ctx1, data]
+      end
+
+      def ctx2_callback_query(data)
+        [:ctx2, data]
+      end
+    end
+  end
+
+  describe '#dispatch' do
+    subject { -> { dispatch } }
+    let(:payload_type) { :callback_query }
+    let(:payload) { {'data' => data} }
+    let(:data) { text }
+    let(:text) { 'asd qwe zxc' }
+
+    context 'when context is not set' do
+      its(:call) { should eq [:no_context, text] }
+      it { should_not change(controller, :filter_done) }
+    end
+
+    context 'when context is set' do
+      let(:data) { "#{ctx}:#{text}" }
+
+      context 'and valid' do
+        let(:ctx) { 'ctx1' }
+        its(:call) { should eq [:ctx1, text] }
+        it { should_not change(controller, :filter_done) }
+
+        context 'and context has callback' do
+          let(:ctx) { 'ctx2' }
+          its(:call) { should eq [:ctx2, text] }
+          it { should change(controller, :filter_done) }
+        end
+
+        context 'and data has multiple colons' do
+          let(:text) { super().tr(' ', ':') }
+          its(:call) { should eq [:ctx1, text] }
+        end
+      end
+
+      context 'and invalid' do
+        let(:ctx) { 'missing' }
+        its(:call) { should eq [:no_context, data] }
+      end
+    end
+  end
+end

spec/telegram/bot/updates_controller/message_context_spec.rb

@@ -0,0 +1,137 @@
+RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
+  include_context 'telegram/bot/updates_controller'
+  let(:controller_class) do
+    described_class = self.described_class
+    Class.new(Telegram::Bot::UpdatesController) do
+      include described_class
+
+      attr_accessor :filter_done
+      before_action only: :redirect do
+        self.filter_done = true
+      end
+
+      attr_reader :callbacks_runs
+      before_action { @callbacks_runs = (@callbacks_runs || 0) + 1 }
+
+      def message(*args)
+        [:no_context, *args]
+      end
+
+      context_handler :block do |*args|
+        [:block_result, *args]
+      end
+
+      context_handler :redirect
+      context_handler :other_redirect, :redirect
+
+      def redirect(*args)
+        [:method_result, *args]
+      end
+
+      def action(*args)
+        [:action_result, *args]
+      end
+
+      private
+
+      def not_action
+        raise 'Should not be called!'
+      end
+    end
+  end
+
+  describe '#message' do
+    subject { -> { dispatch } }
+    let(:payload_type) { :message }
+    let(:payload) { {'text' => text} }
+    let(:text) { 'asd qwe zxc' }
+
+    context 'when context is not set' do
+      its(:call) { should eq [:no_context, payload] }
+      it { should_not change(controller, :filter_done) }
+      it { should_not change { session[:context] } }
+    end
+
+    context 'when context is handled by block' do
+      before { session[:context] = :block }
+      its(:call) { should eq [:block_result, *text.split] }
+      it { should_not change(controller, :filter_done) }
+      it { should change { session[:context] }.to nil }
+
+      context 'when message has no text' do
+        let(:payload) { {'audio' => {'file_id' => 123}} }
+        its(:call) { should eq [:block_result] }
+      end
+
+      context 'when message has new command' do
+        let(:text) { '/action a s d' }
+        its(:call) { should eq [:action_result, *%w(a s d)] }
+        it { should change { session[:context] }.to nil }
+      end
+    end
+
+    context 'when context is handled by short redirect' do
+      before { session[:context] = :redirect }
+      its(:call) { should eq [:method_result, *text.split] }
+      it { should change(controller, :filter_done).to true }
+      it { should change { session[:context] }.to nil }
+      it { should change(controller, :callbacks_runs).to 1 }
+
+      context 'when message has no text' do
+        let(:payload) { {'audio' => {'file_id' => 123}} }
+        its(:call) { should eq [:method_result] }
+        it { should change(controller, :filter_done).to true }
+        it { should change { session[:context] }.to nil }
+      end
+    end
+
+    context 'when context is handled by custom redirect' do
+      before { session[:context] = :other_redirect }
+      its(:call) { should eq [:method_result, *text.split] }
+      it { should change(controller, :filter_done).to true }
+      it { should change { session[:context] }.to nil }
+    end
+
+    context 'when context is action`s name but not mapped' do
+      before { session[:context] = :action }
+      its(:call) { should eq [:no_context, payload] }
+      it { should_not change(controller, :filter_done) }
+      it { should change { session[:context] }.to nil }
+    end
+
+    context 'when context_to_action is true' do
+      before { controller_class.context_to_action! }
+
+      context 'when context is not set' do
+        its(:call) { should eq [:no_context, payload] }
+        it { should_not change(controller, :filter_done) }
+        it { should_not change { session[:context] } }
+      end
+
+      context 'when context is action`s name but not mapped' do
+        before { session[:context] = :action }
+        its(:call) { should eq [:action_result, *text.split] }
+        it { should_not change(controller, :filter_done) }
+        it { should change { session[:context] }.to nil }
+      end
+
+      context 'when context is invalid' do
+        before { session[:context] = :invalid }
+        it 'raises error and clears context' do
+          expect do
+            should raise_error AbstractController::ActionNotFound
+          end.to change { session[:context] }.to nil
+        end
+      end
+
+      context 'when context is private method`s name' do
+        before { session[:context] = :not_action }
+        it 'raises error and clears context' do
+          expect do
+            should raise_error AbstractController::ActionNotFound
+          end.to change { session[:context] }.to nil
+        end
+      end
+    end
+  end
+end

spec/telegram/bot/updates_controller/reply_helpers_spec.rb

@@ -0,0 +1,51 @@
+RSpec.describe Telegram::Bot::UpdatesController do
+  include_context 'telegram/bot/updates_controller'
+  let(:params) { {arg: 1, 'other_arg' => 2} }
+  let(:respond_type) { :photo }
+  let(:result) { double(:result) }
+  let(:payload_type) { :message }
+  let(:payload) { {message_id: double(:message_id)} }
+  let(:chat) { {'id' => double(:chat_id)} }
+
+  shared_examples 'missing chat' do
+    context 'when chat is missing' do
+      let(:payload_type) { :some_type }
+      it { expect { subject }.to raise_error(/chat/) }
+    end
+  end
+
+  describe '#respond_with' do
+    subject { controller.respond_with respond_type, params }
+    include_examples 'missing chat'
+
+    it 'sets chat_id & reply_to_message_id' do
+      expect(controller).to receive(:chat) { chat }
+      expect(bot).to receive("send_#{respond_type}").
+        with(params.merge(chat_id: chat['id'])) { result }
+      should eq result
+    end
+  end
+
+  describe '#reply_with' do
+    subject { controller.reply_with respond_type, params }
+    include_examples 'missing chat'
+
+    it 'sets chat_id & reply_to_message_id' do
+      expect(controller).to receive(:chat) { chat }
+      expect(bot).to receive("send_#{respond_type}").with(params.merge(
+        chat_id: chat['id'],
+        reply_to_message_id: payload[:message_id],
+      )) { result }
+      should eq result
+    end
+
+    context 'when update is not set' do
+      let(:update) { {chat: chat} }
+      it 'sets chat_id' do
+        expect(bot).to receive("send_#{respond_type}").
+          with(params.merge(chat_id: chat['id'])) { result }
+        should eq result
+      end
+    end
+  end
+end

spec/telegram/bot/updates_controller/session_spec.rb

@@ -26,6 +26,12 @@ RSpec.describe Telegram::Bot::UpdatesController::Session do
         def read
           session[:text]
         end
+
+        def action_missing(*)
+          [:action_missing, session[:text]].tap do
+            session[:text] = 'test'
+          end
+        end
       end
     end
 
@@ -39,5 +45,13 @@ RSpec.describe Telegram::Bot::UpdatesController::Session do
       expect(subject.call(bot, build_message('/read', id: 2))).to eq nil
       expect(subject.call(other_bot, build_message('/read', id: 1))).to eq nil
     end
+
+    context 'payload is not supported' do
+      let(:payload_type) { '_unsupported_' }
+      it 'provides empty session' do
+        2.times { expect(subject.call(bot)).to eq [:action_missing, nil] }
+        expect(subject.call(other_bot)).to eq [:action_missing, nil]
+      end
+    end
   end
 end

spec/telegram/bot/updates_controller/testing_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe Telegram::Bot::UpdatesController::Testing do
+  include_context 'telegram/bot/updates_controller'
+  let(:controller_class) do
+    Class.new(Telegram::Bot::UpdatesController) do
+      attr_accessor :ivar
+    end
+  end
+
+  describe '#recycle!' do
+    subject { -> { controller.recycle!(full) } }
+    before do
+      controller.ivar = :ival
+      session[:key] = 'sval'
+    end
+    let(:full) {}
+
+    it { should_not change(controller, :ivar).from :ival }
+    it { should_not change { controller.send(:session)[:key] }.from 'sval' }
+
+    context 'when full is true' do
+      let(:full) { true }
+      it { should change(controller, :ivar).from(:ival).to nil }
+      it { should change { controller.instance_variable_defined?(:@ivar) }.to false }
+      it { should_not change { controller.send(:session)[:key] }.from 'sval' }
+    end
+  end
+end

spec/telegram/bot/updates_controller/typed_update_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Telegram::Bot::UpdatesController::TypedUpdate do
   end
 
   context 'when `update` is a virtus model' do
-    subject { instance }
+    subject { controller }
     %w(
       message
       inline_query

spec/telegram/bot/updates_controller_spec.rb

@@ -78,13 +78,38 @@ RSpec.describe Telegram::Bot::UpdatesController do
   end
 
   describe '#action_for_payload' do
-    subject { instance.action_for_payload }
+    subject { controller.action_for_payload }
 
-    (described_class::PAYLOAD_TYPES - %w(message)).each do |type|
+    def stub_payload(*fields)
-      context "when payload is #{type}" do
+      Hash[fields.map { |x| [x, double(x)] }]
-        let(:payload_type) { type }
+    end
-        it { should eq [false, type, [payload]] }
+
-      end
+    context 'when payload is inline_query' do
+      let(:payload_type) { 'inline_query' }
+      let(:payload) { stub_payload(:id, :from, :location, :query, :offset) }
+      it { should eq [false, payload_type, payload.values_at(:query, :offset)] }
+    end
+
+    context 'when payload is chosen_inline_result' do
+      let(:payload_type) { 'chosen_inline_result' }
+      let(:payload) { stub_payload(:result_id, :from, :location, :inline_message_id, :query) }
+      it { should eq [false, payload_type, payload.values_at(:result_id, :query)] }
+    end
+
+    context 'when payload is callback_query' do
+      let(:payload_type) { 'callback_query' }
+      let(:payload) { stub_payload(:id, :from, :message, :inline_message_id, :data) }
+      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
@@ -109,11 +134,16 @@ RSpec.describe Telegram::Bot::UpdatesController do
           it { should eq [false, 'message', [payload]] }
         end
       end
+
+      context 'without text' do
+        let(:payload) { {'audio' => {'file_id' => 123}} }
+        it { should eq [false, payload_type, [payload]] }
+      end
     end
   end
 
   context 'when `update` is a virtus model' do
-    subject { instance }
+    subject { controller }
     let(:update) { Telegram::Bot::Types::Update.new(super()) }
     %w(
       message
@@ -131,7 +161,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
   end
 
   describe '#bot_username' do
-    subject { instance.bot_username }
+    subject { controller.bot_username }
 
     context 'when bot is not set' do
       let(:bot) {}
@@ -144,18 +174,44 @@ RSpec.describe Telegram::Bot::UpdatesController do
     end
   end
 
-  describe '#process_action' do
+  describe '#process' do
-    subject { -> { instance.process_action(:action) } }
+    subject { -> { controller.process(:action, *args) } }
+    let(:args) { [:arg1, :arg2] }
+    let(:controller_class) do
+      Class.new(described_class) do
+        attr_reader :acted, :hooked
+
+        def action(*args)
+          @acted = true
+          [from, chat, args]
+        end
+      end
+    end
+
+    context 'when action is protected' do
+      before { controller_class.send :protected, :action }
+      its(:call) { should eq nil }
+
+      context 'when action_missing defined' do
+        before do
+          controller.class_eval do
+            protected
+
+            def action_missing(*args)
+              args
+            end
+          end
+        end
+
+        its(:call) { should eq ['action', *args] }
+      end
+    end
 
     context 'when callbacks are defined' do
-      let(:controller_class) do
+      before do
-        Class.new(described_class) do
+        controller_class.class_eval do
-          before_action :hook
+          before_action :hook, only: :action
-          attr_reader :acted, :hooked
+          attr_reader :hooked
-
-          def action
-            @acted = true
-          end
 
           private
 
@@ -165,21 +221,75 @@ RSpec.describe Telegram::Bot::UpdatesController do
         end
       end
 
-      it { should change(instance, :hooked).to true }
+      it { should change(controller, :hooked).to true }
-      it { should change(instance, :acted).to true }
+      it { should change(controller, :acted).to true }
+      its(:call) { should eq [nil, nil, args] }
 
-      context 'when callback returns false' do
+      context 'when callback halts chain' do
         before do
           controller_class.prepend(Module.new do
             def hook
               super
-              false
+              ActiveSupport::VERSION::MAJOR >= 5 ? throw(:abort) : false
             end
           end)
         end
 
-        it { should change(instance, :hooked).to true }
+        it { should change(controller, :hooked).to true }
-        it { should_not change(instance, :acted).from nil }
+        it { should_not change(controller, :acted).from nil }
+        its(:call) { should eq false }
+      end
+    end
+
+    context 'when initialized without update' do
+      let(:controller) { controller_class.new(bot, from: from, chat: chat) }
+      let(:from) { {'id' => 'user_id'} }
+      let(:chat) { {'id' => 'chat_id'} }
+      its(:call) { should eq [from, chat, args] }
+    end
+  end
+
+  describe '#initialize' do
+    subject { controller }
+    let(:payload_type) { 'message' }
+    let(:payload) { deep_stringify(chat: chat, from: from) }
+    let(:chat) { double(:chat) }
+    let(:from) { double(:from) }
+
+    def self.with_reinitialize(&block)
+      instance_eval(&block)
+      context 'when re-initialized' do
+        let(:controller) do
+          described_class.new(double(:other_bot), build_update(:message,
+            text: 'original message',
+            from: double(:original_from),
+            chat: double(:original_chat),
+          )).tap { |x| x.send(:initialize, bot, update) }
+        end
+        instance_eval(&block)
+      end
+    end
+
+    context 'when update is given' do
+      with_reinitialize do
+        its(:bot) { should eq bot }
+        its(:update) { should eq update }
+        its(:payload) { should eq payload }
+        its(:payload_type) { should eq payload_type }
+        its(:from) { should eq from }
+        its(:chat) { should eq chat }
+      end
+    end
+
+    context 'when options hash is given' do
+      let(:update) { {from: from, chat: chat} }
+      with_reinitialize do
+        its(:bot) { should eq bot }
+        its(:update) { should eq nil }
+        its(:payload) { should eq nil }
+        its(:payload_type) { should eq nil }
+        its(:from) { should eq from }
+        its(:chat) { should eq chat }
       end
     end
   end

spec/telegram/bot_spec.rb

@@ -2,4 +2,25 @@ 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

telegram-bot.gemspec

@@ -20,8 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '~> 2.0'
 
-  spec.add_dependency 'activesupport', '~> 4.0'
+  spec.add_dependency 'activesupport', '>= 4.0', '< 5.1'
-  spec.add_dependency 'actionpack', '~> 4.0'
+  spec.add_dependency 'actionpack', '>= 4.0', '< 5.1'
   spec.add_dependency 'httpclient', '~> 2.7'
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'