v0.7.2

.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}

CHANGELOG.md

@@ -0,0 +1,28 @@
+# 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.

README.md

@@ -17,6 +17,10 @@ Package contains:
 - Poller with automatic source-reloader for development env.
 - Rake tasks to update webhook urls.
 
+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
 
 Add this line to your application's Gemfile:
@@ -89,6 +93,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 +103,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 +112,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
@@ -137,12 +152,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 +167,8 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
 end
 ```
 
+#### Session
+
 There is support for sessions using `ActiveSupport::Cache` stores.
 
 ```ruby
@@ -158,6 +177,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 +188,7 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   end
 
   def read
-    session[:text]
+    reply_with :message, text: session[:text]
   end
 
   private
@@ -180,6 +202,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
+    reply_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]
+    reply_with :message, text: 'Renamed!'
+  end
+
+  # You can do it in other way:
+  def rename(name = nil, *)
+    if name
+      update_name name
+      reply_with :message, text: 'Renamed!'
+    else
+      save_context :rename
+      reply_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 +292,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 +301,77 @@ 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::UpdatesController::Botan`:
+
+```ruby
+class Telegram::WebhookController < Telegram::Bot::UpdatesController
+  include Telegram::Bot::UpdatesController::Botan
+
+  # 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.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

lib/telegram/bot.rb

@@ -7,6 +7,26 @@ 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 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 :Botan,              'telegram/bot/botan'
     autoload :Client,             'telegram/bot/client'
     autoload :ClientStub,         'telegram/bot/client_stub'
     autoload :Middleware,         'telegram/bot/middleware'

lib/telegram/bot/botan.rb

@@ -0,0 +1,36 @@
+module Telegram
+  module Bot
+    class Botan
+      TRACK_URI = 'https://api.botan.io/track'.freeze
+
+      class Error < Bot::Error; end
+
+      include DebugClient
+
+      attr_reader :client, :token
+
+      def initialize(token)
+        @client = HTTPClient.new
+        @token = token
+      end
+
+      def track(event, uid, payload = {})
+        res = http_request(
+          :post,
+          TRACK_URI,
+          {token: token, name: event, uid: uid},
+          payload.to_json,
+        )
+        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
+    end
+  end
+end

lib/telegram/bot/client.rb

@@ -2,14 +2,16 @@ require 'json'
 require 'httpclient'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/hash/keys'
+require 'telegram/bot/debug_client'
 
 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'
+      include DebugClient
+
       class << self
         # Accepts different options to initialize bot.
         def wrap(input)
@@ -18,7 +20,10 @@ module Telegram
           when Array then input.map(&method(__callee__))
           when Hash then
             input = input.stringify_keys
-            new input['token'], input['username']
+            new input['token'], input['username'], botan: input['botan']
+          when Symbol
+            Telegram.bots[input] or
+              raise "Bot #{input} not configured, check Telegram.bots_config."
           else
             new(input)
           end
@@ -31,67 +36,64 @@ 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
       end
 
-      attr_reader :client, :token, :username, :base_uri
+      attr_reader :client, :token, :username, :base_uri, :botan
 
-      def initialize(token, username = nil)
+      def initialize(token, username = nil, botan: nil)
         @client = HTTPClient.new
         @token = token
         @username = username
         @base_uri = format URL_TEMPLATE, token
+        @botan = Botan.new(botan) if botan
       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 +106,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,6 +4,36 @@ module Telegram
     class ClientStub < Client
       attr_reader :requests
 
+      module StubbedConstructor
+        def new(*args)
+          if self == ClientStub || !ClientStub.stub_all?
+            super
+          else
+            ClientStub.new(args[1])
+          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(username = nil)
         @username = username
         reset

lib/telegram/bot/config_methods.rb

@@ -41,6 +41,13 @@ module Telegram
           config[:default] = default if default
         end
       end
+
+      # Resets all cached bots and their configs.
+      def reset_bots
+        @bots = nil
+        @bot = nil
+        @bots_config = nil
+      end
     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/middleware.rb

@@ -15,7 +15,7 @@ module Telegram
       def call(env)
         update = env['action_dispatch.request.request_parameters']
         controller.dispatch(bot, update)
-        [200, {}, '']
+        [200, {}, ['']]
       end
 
       def inspect

lib/telegram/bot/routes_helper.rb

@@ -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,12 +4,62 @@ 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(*)
+    #       reply_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)
+    #       reply_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'
+      autoload :Botan, 'telegram/bot/updates_controller/botan'
 
       include AbstractController::Callbacks
       # Redefine callbacks with default terminator.
@@ -23,6 +73,7 @@ module Telegram
       end
 
       include AbstractController::Translation
+      include ReplyHelpers
       prepend Instrumentation
       extend Session::ConfigMethods
 
@@ -32,11 +83,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 +113,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 +121,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 +203,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/botan.rb

@@ -0,0 +1,33 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      # Helpers for botan.io metrics.
+      module Botan
+        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/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

@@ -39,6 +39,12 @@ module Telegram
           Instrumentation.instrument(:reply_with, type: type) { super }
         end
 
+        %i(answer_callback_query answer_inline_query).each do |type|
+          define_method(type) do |*args|
+            Instrumentation.instrument(:reply_with, type: type) { super(*args) }
+          end
+        end
+
         private
 
         # A hook invoked every time a before callback is halted.

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,42 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      module ReplyHelpers
+        # Helper to call bot's `send_#{type}` method with already set `chat_id` and
+        # `reply_to_message_id`:
+        #
+        #     reply_with :message, text: 'Hello!'
+        #     reply_with :message, text: '__Hello!__', parse_mode: :Markdown
+        #     reply_with :photo, photo: File.open(photo_to_send), caption: "It's incredible!"
+        def reply_with(type, params)
+          method = "send_#{type}"
+          chat = self.chat
+          payload = self.payload
+          params = params.merge(
+            chat_id: (chat && chat['id'] or raise 'Can not reply_with when chat is not present'),
+            reply_to_message: payload && payload['message_id'],
+          )
+          bot.public_send(method, 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/version.rb

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

spec/telegram/bot/client_spec.rb

@@ -1,10 +1,12 @@
 RSpec.describe Telegram::Bot::Client do
+  let(:instance) { described_class.new 'token' }
+  let(:token) { 'token' }
+  let(:botan_token) { double(:botan_token) }
+
   describe '.wrap' do
     subject { described_class.wrap(input) }
     let(:result) { double(:result) }
-    let(:token) { 'token' }
     let(:username) { 'username' }
-    let(:instance) { described_class.new 'token' }
 
     context 'when input is a string' do
       let(:input) { token }
@@ -19,9 +21,20 @@ RSpec.describe Telegram::Bot::Client do
       let(:input) { {token: token, username: username, ignore: :ignore} }
 
       it 'extracts token & username' do
-        expect(described_class).to receive(:new).with(token, username) { result }
+        expect(described_class).to receive(:new).
+          with(token, username, botan: nil) { result }
         should eq result
       end
+
+      context 'when `botan` is given' do
+        let(:input) { super().merge(botan: botan_token) }
+
+        it 'passes it to initializer' do
+          expect(described_class).to receive(:new).
+            with(token, username, botan: botan_token) { result }
+          should eq result
+        end
+      end
     end
 
     context 'when input is an instance of described_class' do
@@ -33,13 +46,24 @@ RSpec.describe Telegram::Bot::Client do
       end
     end
 
+    context 'when input is a Symbol' do
+      let(:input) { :bot_1 }
+      before { allow(Telegram).to receive(:bots) { {bot_1: instance} } }
+      it { should eq Telegram.bots[:bot_1] }
+
+      context 'and there is no such bot' do
+        let(:input) { :invalid }
+        it { expect { subject }.to raise_error(/not configured/) }
+      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 }
+        expect(described_class).to receive(:new).with(token, username, botan: nil) { result_2 }
         should eq [result, instance, result_2]
       end
     end
@@ -49,7 +73,7 @@ RSpec.describe Telegram::Bot::Client 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 +82,20 @@ 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 '#botan' do
+    subject { instance.botan }
+    it { should eq nil }
+
+    context 'when botan token is set' do
+      let(:instance) { described_class.new token, botan: botan_token }
+      it { should be_instance_of Telegram::Bot::Botan }
+      its(:token) { should eq botan_token }
+    end
+  end
 end

spec/telegram/bot/client_stub_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe Telegram::Bot::ClientStub do
+  describe '#stub_all!' do
+    let(:client) { Telegram::Bot::Client.new('token', 'bot_name') }
+    let(:clients) { Telegram::Bot::Client.wrap(['token', token: 'token2']) }
+
+    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 raturn 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
+end

spec/telegram/bot/middleware_spec.rb

@@ -13,6 +13,6 @@ RSpec.describe Telegram::Bot::Middleware do
       subject
     end
 
-    it { should eq [200, {}, ''] }
+    it { should eq [200, {}, ['']] }
   end
 end

spec/telegram/bot/routes_helper_spec.rb

@@ -78,6 +78,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 +91,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/botan_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe Telegram::Bot::UpdatesController::Botan 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/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,38 @@
+RSpec.describe Telegram::Bot::UpdatesController do
+  include_context 'telegram/bot/updates_controller'
+
+  describe '#reply_with' do
+    subject { controller.reply_with type, params }
+    let(:params) { {arg: 1, 'other_arg' => 2} }
+    let(:type) { :photo }
+    let(:result) { double(:result) }
+    let(:payload_type) { :message }
+    let(:payload) { {message_id: double(:message_id)} }
+    let(:chat) { {'id' => double(:chat_id)} }
+
+    it 'sets chat_id & reply_to_message' do
+      expect(controller).to receive(:chat) { chat }
+      expect(bot).to receive("send_#{type}").with(params.merge(
+        chat_id: chat['id'],
+        reply_to_message: payload[:message_id],
+      )) { result }
+      should eq result
+    end
+
+    context 'when chat is missing' do
+      let(:payload_type) { :some_type }
+      it { expect { subject }.to raise_error(/chat/) }
+    end
+
+    context 'when update is not set' do
+      let(:update) { {chat: chat} }
+      it 'sets chat_id & reply_to_message' do
+        expect(bot).to receive("send_#{type}").with(params.merge(
+          chat_id: chat['id'],
+          reply_to_message: nil,
+        )) { 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,8 +221,9 @@ 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
         before do
@@ -178,8 +235,61 @@ RSpec.describe Telegram::Bot::UpdatesController do
           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,22 @@ 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
+      end
+    end
+  end
 end