v0.14.0

Refactor actions system

CHANGELOG.md

@@ -1,3 +1,25 @@
+# Unreleased
+
+# 0.14.0
+
+- Make integration & controller specs consistent.
+  __Breaking changes__ for controller specs:
+    - Changed signature `dispatch(bot, update) => dispatch(update, bot)`.
+    - `update` helper is symbolized by default.
+    - `build_update(type, data)` is dropped in favor of `deep_stringify(type => data)`.
+- Provide support for integration testing of bots in poller mode and non-Rails apps.
+  __Breaking changes__:
+    - Requiring `telegram/bot/rspec/integration` is deprecated in favor of
+      `telegram/bot/rspec/integration/rails`.
+    - `:telegram_bot` rspec tag is replaced with `telegram_bot: :rails`.
+- __Breaking change__. Use bang-methods as actions for commands.
+  This prevents calling context contextual actions and payload specific actions with commands.
+  Translation helper strips `!` from action name for lazy translations.
+- __Breaking change__. Drop `.context_handler`, `.context_to_action!` methods.
+  Use pass action name directly to `#save_context`.
+  It's the same as `.context_to_action!` is enabled by default.
+- Class-level helper for lazy translations.
+
 # 0.13.1
 
 - Extracted typed response mappings to telegram-bot-types gem.

README.md

@@ -4,6 +4,8 @@
 [![Code Climate](https://codeclimate.com/github/telegram-bot-rb/telegram-bot/badges/gpa.svg)](https://codeclimate.com/github/telegram-bot-rb/telegram-bot)
 [![Build Status](https://travis-ci.org/telegram-bot-rb/telegram-bot.svg)](https://travis-ci.org/telegram-bot-rb/telegram-bot)
 
+__Breaking changes in v0.14!__ See [upgrading guide](https://github.com/telegram-bot-rb/telegram-bot/wiki/Upgrading-to-0.14).
+
 Tools for developing Telegram bots. Best used with Rails, but can be used in
 [standalone app](https://github.com/telegram-bot-rb/telegram-bot/wiki/Not-rails-application).
 Supposed to be used in webhook-mode in production, and poller-mode
@@ -154,14 +156,11 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   #   chosen_inline_result(result_id, query)
   #   callback_query(data)
 
-  # Define public methods to respond to commands.
+  # Define public methods ending with `!` to handle 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
   # someone passed more or less arguments in the message.
-  #
-  # For some commands like /message or /123 method names should start with
-  # `on_` to avoid conflicts.
-  def start(data = nil, *)
+  def start!(data = nil, *)
     # do_smth_with(data)
 
     # There are `chat` & `from` shortcut methods.
@@ -192,8 +191,9 @@ end
 #### Reply helpers
 
 There are helpers to respond for basic actions. They just set chat/message/query
-identifiers from update. See [`ReplyHelpers`](https://github.com/telegram-bot-rb/telegram-bot/blob/master/lib/telegram/bot/updates_controller/reply_helpers.rb) module for more information.
-Here are this methods signatures:
+identifiers from update. See
+[`ReplyHelpers`](https://github.com/telegram-bot-rb/telegram-bot/blob/master/lib/telegram/bot/updates_controller/reply_helpers.rb)
+module for more information. Here are this methods signatures:
 
 ```ruby
 def respond_with(type, params); end
@@ -256,11 +256,11 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   # You can override global config for this controller.
   self.session_store = :file_store
 
-  def write(text = nil, *)
+  def write!(text = nil, *)
     session[:text] = text
   end
 
-  def read(*)
+  def read!(*)
     respond_with :message, text: session[:text]
   end
 
@@ -283,35 +283,28 @@ it asks you for additional argument. There is `MessageContext` for this:
 class Telegram::WebhookController < Telegram::Bot::UpdatesController
   include Telegram::Bot::UpdatesController::MessageContext
 
-  def rename(*)
+  def rename!(*)
     # set context for the next message
-    save_context :rename
+    save_context :rename_from_message
     respond_with :message, text: 'What name do you like?'
   end
 
   # register context handlers to handle this context
-  context_handler :rename do |*words|
+  def rename_from_message(*words)
     update_name words[0]
     respond_with :message, text: 'Renamed!'
   end
 
-  # You can do it in other way:
-  def rename(name = nil, *)
+  # You can use same action name as context name:
+  def rename!(name = nil, *)
     if name
       update_name name
       respond_with :message, text: 'Renamed!'
     else
-      save_context :rename
+      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 call this method
-  # to use context value as action name for all contexts which miss handlers:
-  context_to_action!
 end
 ```
 
@@ -394,11 +387,11 @@ 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.
+There is a `Telegram::Bot::ClientStub` class to stub client for tests.
+Instead of performing API requests it stores them in a `requests` hash.
 
 To stub all possible clients use `Telegram::Bot::ClientStub.stub_all!` before
-initializing clients. Here is template for RSpec:
+initializing clients. Here is a template for RSpec:
 
 ```ruby
 # environments/test.rb
@@ -416,47 +409,82 @@ RSpec.configure do |config|
 end
 ```
 
-There are integration and controller contexts for RSpec and some built-in matchers:
+RSpec contexts and helpers are included automatically for groups and examples with matching
+tags. In RSpec < 3.4 it's required to use `include_context` explicitly.
+See [list of available helpers](https://github.com/telegram-bot-rb/telegram-bot/tree/master/lib/telegram/bot/rspec)
+for details.
+
+There are 3 types of integration tests:
+
+- `:rails` - for testing bot in webhooks-mode in Rails application.
+  It simulates webhook requests POSTing data to controller's endpoint.
+  It works on the top of requests specs, so `rspec-rails` gem is required.
+- `:rack` - For testing bot in webhooks-mode in non-Rails application.
+  It uses `rack-test` gem to POST requests to bot's endpoint.
+- `:poller` - Calls `.dispatch` directly on controller class.
+
+Pick the appropriate one, then require `telegram/bot/rspec/integration/#{type}`
+and mark spec group with tag `telegram_bot: type`. See configuration options
+for each type in
+[telegram/bot/rspec/integration/](https://github.com/telegram-bot-rb/telegram-bot/tree/master/lib/telegram/bot/rspec/integration).
+
+Here is an example test for a Rails app:
 
 ```ruby
 # spec/requests/telegram_webhooks_spec.rb
-require 'telegram/bot/rspec/integration'
+require 'telegram/bot/rspec/integration/rails'
 
-RSpec.describe TelegramWebhooksController, :telegram_bot do
-  # for old rspec add:
-  # include_context 'telegram/bot/integration'
+RSpec.describe TelegramWebhooksController, telegram_bot: :rails do
+  # for old RSpec:
+  # include_context 'telegram/bot/integration/rails'
 
-  describe '#start' do
+  # Main method is #dispatch(update). Some helpers are:
+  #   dispatch_message(text, options = {})
+  #   dispatch_command(cmd, *args)
+
+  # Available matchers can be found in Telegram::Bot::RSpec::ClientMatchers.
+  it 'shows usage of basic matchers'
+    # The most basic one is #make_telegram_request(bot, endpoint, params_matcher)
+    expect { dispatch_command(:start) }.
+      to make_telegram_request(bot, :sendMessage, hash_including(text: 'msg text'))
+
+    # There are some shortcuts for dispatching basic updates and testing responses.
+    expect { dispatch_message('Hi') }.to send_telegram_message(bot, /msg regexp/, some: :option)
+  end
+
+  describe '#start!' do
     subject { -> { dispatch_command :start } }
+    # Using built in matcher for `respond_to`:
     it { should respond_with_message 'Hi there!' }
   end
 
-  # There is context for callback queries with related matchers.
+  # There is context for callback queries with related matchers,
+  # use :callback_query tag to include it.
   describe '#hey_callback_query', :callback_query do
     let(:data) { "hey:#{name}" }
     let(:name) { 'Joe' }
     it { should answer_callback_query('Hey Joe') }
     it { should edit_current_message :text, text: 'Done' }
+  end
 end
-
-# For controller specs use
-require 'telegram/bot/updates_controller/rspec_helpers'
-RSpec.describe TelegramWebhooksController, type: :telegram_bot_controller do
-  # for old rspec add:
-  # include_context 'telegram/bot/updates_controller'
-end
-
-# Matchers are available for custom specs:
-include Telegram::Bot::RSpec::ClientMatchers
-
-expect(&process_update).to send_telegram_message(bot, /msg regexp/, some: :option)
-expect(&process_update).
-  to make_telegram_request(bot, :sendMessage, hash_including(text: 'msg text'))
 ```
 
-Place integration tests inside `spec/requests`
-when using RSpec's `infer_spec_type_from_file_location!`,
-or just add `type: :request` to `describe`.
+There is a context for testing bot controller in the way similar to Rails controller tests.
+It's supposed to be a low-level alternative for integration tests. Among the differences is
+that controller tests use a single controller instance for all dispatches in specific exaple,
+session is stubbed (does not use configured store engine), and update is not serialized
+so it also supports mocks. This can be useful for unit testing, but should not be used as
+the default way to test the bot.
+
+```ruby
+require 'telegram/bot/updates_controller/rspec_helpers'
+RSpec.describe TelegramWebhooksController, type: :telegram_bot_controller do
+  # for old RSpec:
+  # include_context 'telegram/bot/updates_controller'
+
+  # Same helpers and matchers like dispatch_command, answer_callback_query are available here.
+end
+```
 
 See sample app for more examples.
 

lib/telegram/bot.rb

@@ -14,10 +14,10 @@ module Telegram
 
     module_function
 
-    def deprecation_0_14
+    def deprecation_0_15
       @deprecation ||= begin
         require 'active_support/deprecation'
-        ActiveSupport::Deprecation.new('0.14', 'Telegram::Bot')
+        ActiveSupport::Deprecation.new('0.15', 'Telegram::Bot')
       end
     end
 

lib/telegram/bot/middleware.rb

@@ -1,8 +1,7 @@
 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/http/request'
+require 'action_dispatch'
 
 module Telegram
   module Bot

lib/telegram/bot/routes_helper.rb

@@ -24,33 +24,6 @@ module Telegram
         end
       end
 
-      #   # Create routes for all Telegram.bots to use same controller:
-      #   telegram_webhooks TelegramController
-      #
-      #   # Or pass custom bots usin any of supported config options:
-      #   telegram_webhooks TelegramController, [
-      #     bot,
-      #     {token: token, username: username},
-      #     other_bot_token,
-      #   ]
-      def telegram_webhooks(controllers, bots = nil, **options)
-        Bot.deprecation_0_14.deprecation_warning(:telegram_webhooks, <<-TXT.strip_heredoc)
-          It brings unnecessary complexity and encourages writeng less readable code.
-          Please use telegram_webhook method instead.
-          It's signature `telegram_webhook(controller, bot = :default, **options)`.
-          Multiple-bot environments now requires calling this method in a loop
-          or using statement for each bot.
-        TXT
-        unless controllers.is_a?(Hash)
-          bots = bots ? Array.wrap(bots) : Telegram.bots.values
-          controllers = Hash[bots.map { |x| [x, controllers] }]
-        end
-        controllers.each do |bot, controller|
-          controller, bot_options = controller if controller.is_a?(Array)
-          telegram_webhook(controller, bot, options.merge(bot_options || {}))
-        end
-      end
-
       # Define route which processes requests using given controller and bot.
       #
       #   telegram_webhook TelegramController, bot

lib/telegram/bot/rspec.rb

@@ -2,6 +2,15 @@ module Telegram
   module Bot
     module RSpec
       autoload :ClientMatchers, 'telegram/bot/rspec/client_matchers'
+
+      module_function
+
+      # Yelds a block if `include_context` is supported.
+      def with_include_context
+        ::RSpec.configure do |config|
+          yield(config) if config.respond_to?(:include_context)
+        end
+      end
     end
   end
 end

lib/telegram/bot/rspec/callback_query_helpers.rb

@@ -0,0 +1,39 @@
+require 'telegram/bot/rspec'
+require 'telegram/bot/rspec/message_helpers'
+
+# Shared helpers for testing callback query updates.
+RSpec.shared_context 'telegram/bot/callback_query' do
+  include_context 'telegram/bot/message_helpers'
+
+  subject { -> { dispatch callback_query: payload } }
+  let(:payload) { {id: callback_query_id, from: from, message: message, data: data} }
+  let(:callback_query_id) { 11 }
+  let(:message_id) { 22 }
+  let(:message) { {message_id: message_id, chat: chat, text: 'message text'} }
+  let(:data) { raise '`let(:data) { "callback query data here" }` is required' }
+
+  # Matcher to check that origin message got edited.
+  def edit_current_message(type, options = {})
+    description = 'edit current message'
+    options = options.merge(
+      message_id: message[:message_id],
+      chat_id: chat_id,
+    )
+    Telegram::Bot::RSpec::ClientMatchers::MakeTelegramRequest.new(
+      bot, :"editMessage#{type.to_s.camelize}", description: description
+    ).with(hash_including(options))
+  end
+
+  # Matcher to check that callback query is answered.
+  def answer_callback_query(text = Regexp.new(''), options = {})
+    description = "answer callback query with #{text.inspect}"
+    text = a_string_matching(text) if text.is_a?(Regexp)
+    options = options.merge(
+      callback_query_id: payload[:id],
+      text: text,
+    )
+    Telegram::Bot::RSpec::ClientMatchers::MakeTelegramRequest.new(
+      bot, :answerCallbackQuery, description: description
+    ).with(hash_including(options))
+  end
+end

lib/telegram/bot/rspec/integration.rb

@@ -1,85 +1,10 @@
-RSpec.shared_context 'telegram/bot/integration' do
-  let(:bot) { Telegram.bot }
-  let(:default_message_options) { {from: from, chat: chat} }
-  let(:from) { {id: from_id} }
-  let(:from_id) { 123 }
-  let(:chat) { {id: chat_id} }
-  let(:chat_id) { 456 }
-  let(:controller_path) do
-    route_name = Telegram::Bot::RoutesHelper.route_name_for_bot(bot)
-    Rails.application.routes.url_helpers.public_send("#{route_name}_path")
-  end
-  let(:request_headers) do
-    {
-      'ACCEPT' => 'application/json',
-      'Content-Type' => 'application/json',
-    }
-  end
-  let(:clear_session?) { described_class.respond_to?(:session_store) }
-  before { described_class.session_store.try!(:clear) if clear_session? }
+require 'telegram/bot'
+Telegram::Bot.deprecation_0_15.warn(
+  "`require 'telegram/bot/rspec/integration'` is deprecated in favor of " \
+  "`require 'telegram/bot/rspec/integration/rails'`"
+)
+require 'telegram/bot/rspec/integration/rails'
 
-  include Telegram::Bot::RSpec::ClientMatchers
-
-  def dispatch(update)
-    if ActionPack::VERSION::MAJOR >= 5
-      post(controller_path, params: update.to_json, headers: request_headers)
-    else
-      post(controller_path, update.to_json, request_headers)
-    end
-  end
-
-  def dispatch_message(text, options = {})
-    dispatch message: default_message_options.merge(options).merge(text: text)
-  end
-
-  def dispatch_command(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    dispatch_message("/#{args.join ' '}", options)
-  end
-
-  # Matcher to check response. Make sure to define `let(:chat_id)`.
-  def respond_with_message(expected = Regexp.new(''))
-    raise 'Define chat_id to use respond_with_message' unless defined?(chat_id)
-    send_telegram_message(bot, expected, chat_id: chat_id)
-  end
-end
-
-RSpec.shared_context 'telegram/bot/callback_query', callback_query: true do
-  include_context 'telegram/bot/integration'
-
-  subject { -> { dispatch callback_query: payload } }
-  let(:payload) { {id: 11, from: from, message: message, data: data} }
-  let(:message) { {message_id: 22, chat: chat, text: 'message text'} }
-
-  # Matcher to check that origin message got edited.
-  def edit_current_message(type, options = {})
-    description = 'edit current message'
-    options = options.merge(
-      message_id: message[:message_id],
-      chat_id: chat_id,
-    )
-    Telegram::Bot::RSpec::ClientMatchers::MakeTelegramRequest.new(
-      bot, :"editMessage#{type.to_s.camelize}", description: description
-    ).with(hash_including(options))
-  end
-
-  # Matcher to check that callback query is answered.
-  def answer_callback_query(text = Regexp.new(''), options = {})
-    description = "answer callback query with #{text.inspect}"
-    text = a_string_matching(text) if text.is_a?(Regexp)
-    options = options.merge(
-      callback_query_id: payload[:id],
-      text: text,
-    )
-    Telegram::Bot::RSpec::ClientMatchers::MakeTelegramRequest.new(
-      bot, :answerCallbackQuery, description: description
-    ).with(hash_including(options))
-  end
-end
-
-RSpec.configure do |config|
-  if config.respond_to?(:include_context)
-    config.include_context 'telegram/bot/integration', :telegram_bot
-    config.include_context 'telegram/bot/callback_query', :telegram_bot, :callback_query
-  end
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/integration/rails', telegram_bot: true
 end

lib/telegram/bot/rspec/integration/poller.rb

@@ -0,0 +1,14 @@
+require 'telegram/bot/rspec/integration/shared'
+
+RSpec.shared_context 'telegram/bot/integration/poller' do
+  include_context 'telegram/bot/integration/shared'
+  let(:controller_class) { described_class }
+
+  def dispatch(update)
+    controller_class.dispatch(bot, update.as_json)
+  end
+end
+
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/integration/poller', telegram_bot: :poller
+end

lib/telegram/bot/rspec/integration/rack.rb

@@ -0,0 +1,24 @@
+require 'telegram/bot/rspec/integration/shared'
+require 'rack/test'
+
+RSpec.shared_context 'telegram/bot/integration/rack' do
+  include_context 'telegram/bot/integration/shared'
+  include Rack::Test::Methods
+
+  let(:request_path) { raise '`let(:request_path) { path to bot }` is required' }
+  let(:app) { raise '`let(:app) { your rack app here }` is required' }
+  let(:request_headers) do
+    {
+      'ACCEPT' => 'application/json',
+      'CONTENT_TYPE' => 'application/json',
+    }
+  end
+
+  def dispatch(update)
+    post request_path, update.to_json, request_headers
+  end
+end
+
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/integration/rack', telegram_bot: :rack
+end

lib/telegram/bot/rspec/integration/rails.rb

@@ -0,0 +1,28 @@
+require 'telegram/bot/rspec/integration/shared'
+
+RSpec.shared_context 'telegram/bot/integration/rails', type: :request do
+  include_context 'telegram/bot/integration/shared'
+
+  let(:controller_path) do
+    route_name = Telegram::Bot::RoutesHelper.route_name_for_bot(bot)
+    Rails.application.routes.url_helpers.public_send("#{route_name}_path")
+  end
+  let(:request_headers) do
+    {
+      'Accept' => 'application/json',
+      'Content-Type' => 'application/json',
+    }
+  end
+
+  def dispatch(update)
+    if ActionPack::VERSION::MAJOR >= 5
+      post(controller_path, params: update.to_json, headers: request_headers)
+    else
+      post(controller_path, update.to_json, request_headers)
+    end
+  end
+end
+
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/integration/rails', telegram_bot: :rails
+end

lib/telegram/bot/rspec/integration/shared.rb

@@ -0,0 +1,14 @@
+require 'active_support/json'
+require 'telegram/bot'
+require 'telegram/bot/rspec/message_helpers'
+require 'telegram/bot/rspec/callback_query_helpers'
+
+RSpec.shared_context 'telegram/bot/integration/shared' do
+  include Telegram::Bot::RSpec::ClientMatchers
+  include_context 'telegram/bot/message_helpers'
+  include_context 'telegram/bot/callback_query', :callback_query
+
+  let(:bot) { Telegram.bot }
+  let(:clear_session?) { described_class.respond_to?(:session_store) }
+  before { described_class.session_store.try!(:clear) if clear_session? }
+end

lib/telegram/bot/rspec/message_helpers.rb

@@ -0,0 +1,26 @@
+# Shared helpers for testing message updates.
+RSpec.shared_context 'telegram/bot/message_helpers' do
+  let(:default_message_options) { {from: from, chat: chat} }
+  let(:from) { {id: from_id} }
+  let(:from_id) { 123 }
+  let(:chat) { {id: chat_id} }
+  let(:chat_id) { 456 }
+
+  # Shortcut for dispatching messages with default params.
+  def dispatch_message(text, options = {})
+    dispatch message: default_message_options.merge(options).merge(text: text)
+  end
+
+  # Dispatch command message.
+  def dispatch_command(cmd, *args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    args.unshift("/#{cmd}")
+    dispatch_message(args.join(' '), options)
+  end
+
+  # Matcher to check response. Make sure to define `let(:chat_id)`.
+  def respond_with_message(expected = Regexp.new(''))
+    raise 'Define chat_id to use respond_with_message' unless defined?(chat_id)
+    send_telegram_message(bot, expected, chat_id: chat_id)
+  end
+end

lib/telegram/bot/updates_controller.rb

@@ -1,4 +1,5 @@
 require 'abstract_controller'
+require 'active_support/core_ext/string/inflections'
 require 'active_support/callbacks'
 require 'active_support/version'
 
@@ -54,12 +55,14 @@ module Telegram
       abstract!
 
       %w[
-        instrumentation
-        log_subscriber
-        reply_helpers
-        rescue
-        session
-      ].each { |file| require "telegram/bot/updates_controller/#{file}" }
+        Commands
+        Instrumentation
+        LogSubscriber
+        ReplyHelpers
+        Rescue
+        Session
+        Translation
+      ].each { |name| require "telegram/bot/updates_controller/#{name.underscore}" }
 
       %w[
         CallbackQueryContext
@@ -78,9 +81,12 @@ module Telegram
                           skip_after_callbacks_if_terminated: true
       end
 
-      include AbstractController::Translation
+      include Commands
       include Rescue
       include ReplyHelpers
+      include Translation
+      # Add instrumentations hooks at the bottom, to ensure they instrument
+      # all the methods properly.
       include Instrumentation
 
       extend Session::ConfigMethods
@@ -96,8 +102,6 @@ module Telegram
         shipping_query
         pre_checkout_query
       ].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.
@@ -105,27 +109,6 @@ module Telegram
           new(*args).dispatch
         end
 
-        # Overrid it to filter or transform commands.
-        # Default implementation is to convert to downcase and add `on_` prefix
-        # for conflicting commands.
-        def action_for_command(cmd)
-          cmd.downcase!
-          cmd.match(CONFLICT_CMD_REGEX) ? "on_#{cmd}" : cmd
-        end
-
-        # Fetches command from text message. All subsequent words are returned
-        # as arguments.
-        # If command has mention (eg. `/test@SomeBot`), it returns commands only
-        # for specified username. Set `username` to `true` to accept
-        # any commands.
-        def command_from_text(text, username = nil)
-          return unless text
-          match = text.match(CMD_REGEX)
-          return unless match
-          mention = match[3]
-          [match[1], text.split.drop(1)] if username == true || !mention || mention == username
-        end
-
         def payload_from_update(update)
           update && PAYLOAD_TYPES.find do |type|
             item = update[type]
@@ -134,8 +117,7 @@ module Telegram
         end
       end
 
-      attr_internal_reader :update, :bot, :payload, :payload_type, :is_command
-      alias_method :command?, :is_command
+      attr_internal_reader :update, :bot, :payload, :payload_type
       delegate :username, to: :bot, prefix: true, allow_nil: true
 
       # Second argument can be either update object with hash access & string
@@ -175,54 +157,64 @@ module Telegram
 
       # Processes current update.
       def dispatch
-        @_is_command, action, args = action_for_payload
+        action, args = action_for_payload
         process(action, *args)
       end
 
+      attr_internal_reader :action_options
+
+      # It provides support for passing array as action, where first vaule
+      # is action name and second is action metadata.
+      # This metadata is stored inside action_options
+      def process(action, *args)
+        action, options = action if action.is_a?(Array)
+        @_action_options = options || {}
+        super
+      end
+
+      # There are multiple ways how action name is calculated for update
+      # (see Commands, MessageContext, etc.). This method represents the
+      # way how action was calculated for current udpate.
+      #
+      # Some of possible values are `:payload, :command, :message_context`.
+      def action_type
+        action_options[:type] || :payload
+      end
+
       # Calculates action name and args for payload.
       # Uses `action_for_#{payload_type}` methods.
       # If this method doesn't return anything
       # it uses fallback with action same as payload type.
-      # Returns array `[is_command?, action, args]`.
+      # Returns array `[action, args]`.
       def action_for_payload
         if payload_type
           send("action_for_#{payload_type}") || action_for_default_payload
         else
-          [false, :unsupported_payload_type, []]
+          [:unsupported_payload_type, []]
         end
       end
 
       def action_for_default_payload
-        [false, payload_type, [payload]]
+        [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).
-      #
-      # This is not used for edited messages/posts. It process them as basic updates.
-      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
-      alias_method :action_for_channel_post, :action_for_message
-
       def action_for_inline_query
-        [false, payload_type, [payload['query'], payload['offset']]]
+        [payload_type, [payload['query'], payload['offset']]]
       end
 
       def action_for_chosen_inline_result
-        [false, payload_type, [payload['result_id'], payload['query']]]
+        [payload_type, [payload['result_id'], payload['query']]]
       end
 
       def action_for_callback_query
-        [false, payload_type, [payload['data']]]
+        [payload_type, [payload['data']]]
       end
 
-      # Silently ignore unsupported messages.
-      # Params are `action, *args`.
-      def action_missing(*)
+      # Silently ignore unsupported messages to not fail when user crafts
+      # an update with usupported command, callback query context, etc.
+      def action_missing(action, *_args)
+        logger.debug { "The action '#{action}' is not defined in #{self.class.name}" } if logger
+        nil
       end
 
       PAYLOAD_TYPES.each do |type|

lib/telegram/bot/updates_controller/callback_query_context.rb

@@ -17,8 +17,12 @@ module Telegram
           context, new_data = context_from_callback_query
           if context
             action_name = "#{context}_callback_query"
-            [false, action_name, [new_data]] if action_method?(action_name)
-          end || super
+            if action_method?(action_name)
+              action_options = {type: :callback_query_context, context: context}
+              return [[action_name, action_options], [new_data]]
+            end
+          end
+          super
         end
 
         def context_from_callback_query

lib/telegram/bot/updates_controller/commands.rb

@@ -0,0 +1,44 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      #  Support for parsing commands
+      module Commands
+        CMD_REGEX = %r{\A/([a-z\d_]{,31})(@(\S+))?(\s|$)}i
+
+        class << self
+          # Fetches command from text message. All subsequent words are returned
+          # as arguments.
+          # If command has mention (eg. `/test@SomeBot`), it returns commands only
+          # for specified username. Set `username` to `true` to accept
+          # any commands.
+          def command_from_text(text, username = nil)
+            return unless text
+            match = text.match(CMD_REGEX)
+            return unless match
+            mention = match[3]
+            [match[1], text.split.drop(1)] if username == true || !mention || mention == username
+          end
+        end
+
+        # Override it to filter or transform commands.
+        # Default implementation is to downcase and add `!` suffix.
+        def action_for_command(cmd)
+          "#{cmd.downcase}!"
+        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).
+        #
+        # This is not used for edited messages/posts. It process them as basic updates.
+        def action_for_message
+          cmd, args = Commands.command_from_text(payload['text'], bot_username)
+          return unless cmd
+          [[action_for_command(cmd), type: :command, command: cmd], args]
+        end
+
+        alias_method :action_for_channel_post, :action_for_message
+      end
+    end
+  end
+end

lib/telegram/bot/updates_controller/message_context.rb

@@ -2,62 +2,42 @@ module Telegram
   module Bot
     class UpdatesController
       # Allows to store context in session and treat next message according to this context.
+      #
+      # It provides `save_context` method to store method name
+      # to be used as action for next update:
+      #
+      #     def set_location!(*)
+      #       save_context(:set_location_from_message)
+      #       respond_with :message, text: 'Where are you?'
+      #     end
+      #
+      #     def set_location_from_messge(city = nil, *)
+      #       # update
+      #     end
+      #
+      #     # OR
+      #     # This will support both `/set_location city_name`, and `/set_location`
+      #     # with subsequent refinement.
+      #     def set_location!(city = nil, *)
+      #       if city
+      #         # update
+      #       else
+      #         save_context(:set_location!)
+      #         respond_with :message, text: 'Where are you?'
+      #       end
+      #     end
       module MessageContext
         extend ActiveSupport::Concern
 
         include Session
 
-        module ClassMethods
-          def context_handlers
-            @_context_handlers ||= {}
-          end
-
-          # 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
-
-          attr_reader :context_to_action
-
-          # 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
+        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
-
         # Controller may have multiple sessions, let it be possible
         # to select session for message context.
         def message_context_session
@@ -68,10 +48,11 @@ module Telegram
         # it has higher priority than contextual action.
         def action_for_message
           val = message_context_session.delete(:context)
-          @context = val && val.to_sym
+          context = val && val.to_s
           super || context && begin
-            handler = handler_for_context
-            [true, handler, payload['text'].try!(:split) || []] if handler
+            args = payload['text'].try!(:split) || []
+            action = action_for_message_context(context)
+            [[action, type: :message_context, context: context], args]
           end
         end
 
@@ -80,18 +61,16 @@ module Telegram
           message_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
+        # Returns action name for message context. By default it's the same as context name.
+        # Raises AbstractController::ActionNotFound if action is not available.
+        # This differs from other cases where invalid actions are silently ignored,
+        # because message context is controlled by developer, and users are not able
+        # to construct update to run any specific context.
+        def action_for_message_context(context)
+          action = context.to_s
+          return action if action_method?(action)
+          raise AbstractController::ActionNotFound,
+            "The context action '#{action}' is not found in #{self.class.name}"
         end
       end
     end

lib/telegram/bot/updates_controller/rspec_helpers.rb

@@ -1,37 +1,32 @@
 require 'telegram/bot/updates_controller/testing'
+require 'telegram/bot/rspec/message_helpers'
+require 'telegram/bot/rspec/callback_query_helpers'
 
 RSpec.shared_context 'telegram/bot/updates_controller' do
+  include Telegram::Bot::RSpec::ClientMatchers
+  include_context 'telegram/bot/message_helpers'
+  include_context 'telegram/bot/callback_query', :callback_query
+
   let(:controller_class) { described_class }
   let(:controller) do
-    controller_class.new(bot, update).tap do |x|
+    controller_class.new(*controller_args).tap do |x|
       x.extend Telegram::Bot::UpdatesController::Testing
     end
   end
-  let(:update) { build_update(payload_type, payload) }
+  let(:controller_args) { [bot, deep_stringify(update)] }
+  let(: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) { controller.send(:session) }
-  let(:from_id) { 123 }
-  let(:chat_id) { 456 }
-  let(:default_message_options) { {from: {id: from_id}, chat: {id: chat_id}} }
 
-  include Telegram::Bot::RSpec::ClientMatchers
-
-  def dispatch(bot = self.bot, update = self.update)
-    controller.dispatch_again(bot, update)
-  end
-
-  def dispatch_message(text, options = {})
-    update = build_update :message, default_message_options.merge(options).merge(text: text)
-    dispatch bot, update
-  end
-
-  def build_update(type, content)
-    deep_stringify type => content
+  # Process update.
+  def dispatch(update = self.update, bot = self.bot)
+    controller.dispatch_again(bot, deep_stringify(update))
   end
 
+  # Same as `.as_json` but mocks-friendly.
   def deep_stringify(input)
     case input
     when Array then input.map(&method(__callee__))
@@ -39,15 +34,8 @@ RSpec.shared_context 'telegram/bot/updates_controller' do
     else input
     end
   end
-
-  # Matcher to check response. Make sure to define `let(:chat_id)`.
-  def respond_with_message(expected)
-    send_telegram_message(bot, expected, chat_id: chat_id)
-  end
 end
 
-RSpec.configure do |config|
-  if config.respond_to?(:include_context)
-    config.include_context 'telegram/bot/updates_controller', type: :telegram_bot_controller
-  end
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/updates_controller', type: :telegram_bot_controller
 end

lib/telegram/bot/updates_controller/translation.rb

@@ -0,0 +1,47 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      # Provides helpers similar to AbstractController::Translation
+      # but by default uses `action_name_i18n_key` in lazy translation keys
+      # which strips `!` from action names by default. This makes translating
+      # strings for commands more convenient.
+      #
+      # To disable this behaviour use `alias_method :action_name_i18n_key, :action_name`.
+      module Translation
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # Class-level helper for lazy translations.
+          def translate(key, options = {})
+            key = "#{controller_path.tr('/', '.')}#{key}" if key.to_s.start_with?('.')
+            I18n.translate(key, options)
+          end
+          alias :t :translate
+        end
+
+        # See toplevel description.
+        def translate(key, options = {})
+          if key.to_s.start_with?('.')
+            path = controller_path.tr('/', '.')
+            defaults = [:"#{path}#{key}"]
+            defaults << options[:default] if options[:default]
+            options[:default] = defaults.flatten
+            key = "#{path}.#{action_name_i18n_key}#{key}"
+          end
+          I18n.translate(key, options)
+        end
+        alias :t :translate
+
+        # Strips trailing `!` from action_name.
+        def action_name_i18n_key
+          action_name.chomp('!')
+        end
+
+        def localize(*args)
+          I18n.localize(*args)
+        end
+        alias :l :localize
+      end
+    end
+  end
+end

lib/telegram/bot/version.rb

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

spec/integration/requests/default_bot_spec.rb

@@ -1,6 +1,6 @@
 require 'integration_helper'
 
-RSpec.describe DefaultBotController, :telegram_bot, type: :request do
+RSpec.describe DefaultBotController, telegram_bot: :rails do
   describe '#start' do
     subject { -> { dispatch_command :start } }
     it { should respond_with_message 'from default' }

spec/integration/requests/named_bot_spec.rb

@@ -1,6 +1,6 @@
 require 'integration_helper'
 
-RSpec.describe NamedBotController, :telegram_bot, type: :request do
+RSpec.describe NamedBotController, telegram_bot: :rails do
   let(:bot) { Telegram.bots[:named] }
   describe '#start' do
     subject { -> { dispatch_command :start } }

spec/integration/requests/other_bot_spec.rb

@@ -1,6 +1,6 @@
 require 'integration_helper'
 
-RSpec.describe OtherBotController, :telegram_bot, type: :request do
+RSpec.describe OtherBotController, telegram_bot: :rails do
   let(:bot) { Telegram.bots[:other] }
   describe '#start' do
     subject { -> { dispatch_command :start } }

spec/integration_helper.rb

@@ -1,7 +1,6 @@
-require 'telegram/bot/rspec/integration'
+require 'telegram/bot/rspec/integration/rails'
 require 'action_controller'
 require 'action_dispatch'
-require 'action_dispatch/testing/integration'
 
 require 'rails'
 require 'telegram/bot/railtie'
@@ -36,7 +35,7 @@ Rails.application.initialize!
 # # Controllers
 %w[default other named].each do |bot_name|
   controller = Class.new(Telegram::Bot::UpdatesController) do
-    define_method :start do |*|
+    define_method :start! do |*|
       respond_with :message, text: "from #{bot_name}"
     end
   end
@@ -47,7 +46,7 @@ end
   klass.class_eval do
     use_session!
 
-    define_method :load_session do |*|
+    define_method :load_session! do |*|
       session[:test]
     end
   end

spec/spec_helper.rb

@@ -32,6 +32,14 @@ RSpec.configure do |config|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end
 
+  # This config option will be enabled by default on RSpec 4,
+  # but for reasons of backwards compatibility, you have to
+  # set it on RSpec 3.
+  #
+  # It causes the host group and examples to inherit metadata
+  # from the shared context.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
   config.mock_with :rspec do |mocks|
     # Prevents you from mocking or stubbing a method that does not exist on
     # a real object. This is generally recommended, and will default to

spec/support/examples/integration.rb

@@ -0,0 +1,24 @@
+RSpec.shared_examples 'shared integration examples' do
+  let(:bot) { Telegram::Bot::ClientStub.new('token') }
+  let(:controller_class) do
+    Class.new(Telegram::Bot::UpdatesController) do
+      def start!(data = nil, *)
+        respond_with :message, text: "Hi #{data}"
+      end
+
+      def callback_query(data, *)
+        answer_callback_query "pong: #{data}"
+      end
+    end
+  end
+
+  describe '#start' do
+    subject { -> { dispatch_command(:start, :test_data) } }
+    it { should respond_with_message('Hi test_data') }
+  end
+
+  describe '#callback_query', :callback_query do
+    let(:data) { :test_data }
+    it { should answer_callback_query "pong: #{data}" }
+  end
+end

spec/telegram/bot/middleware_spec.rb

@@ -7,7 +7,6 @@ RSpec.describe Telegram::Bot::Middleware do
 
   describe '#call' do
     subject { instance.call(env) }
-    let(:env) { {'action_dispatch.request.request_parameters' => json_body} }
     let(:update) { {'message' => {'id' => 1}} }
     let(:env) do
       Rack::MockRequest.env_for('/',
@@ -21,7 +20,6 @@ RSpec.describe Telegram::Bot::Middleware do
     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
 

spec/telegram/bot/routes_helper_spec.rb

@@ -95,108 +95,4 @@ RSpec.describe Telegram::Bot::RoutesHelper do
       end
     end
   end
-
-  describe '#telegram_webhooks' do
-    subject { mapper.telegram_webhooks(*input) }
-    let(:mapper) { double(:mapper).tap { |x| x.extend described_class } }
-    let(:bots) { {default: bot, other: other_bot} }
-    let(:controller) { double(:controller, name: :controller) }
-    let(:other_controller) { double(:other_controller, name: :other_controller) }
-    before { allow(Telegram).to receive(:bots) { bots } }
-    around { |ex| Telegram::Bot.deprecation_0_14.silence { ex.run } }
-
-    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 expected_path
-          middleware = params[:to]
-          expect(middleware.controller).to eq(controller)
-          expect(middleware.bot.token).to eq(bot.token)
-          expect(middleware.bot.username).to eq(bot.username)
-          expect(params[:as]).to eq route_name
-          expect(params).to include(options) if options
-        end
-      end
-      subject
-    end
-
-    context 'when called with controller' do
-      let(:input) { [controller, option: :val] }
-
-      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
-
-      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
-      let(:input) do
-        [
-          {
-            bot => controller,
-            'custom_token' => [other_controller, as: :custom_route, option: :other_val],
-            other: controller,
-          },
-          option: :val,
-        ]
-      end
-
-      it 'creates routes for every bot and its controller' do
-        assert_routes [bot, controller, 'default_telegram_webhook', option: :val],
-                      [
-                        create_bot('custom_token'),
-                        other_controller,
-                        :custom_route,
-                        option: :other_val,
-                      ],
-                      [Telegram.bots[:other], controller, 'other_telegram_webhook', option: :val]
-      end
-    end
-
-    context 'when called with controller and smth castable to bot' do
-      let(:input) do
-        [
-          controller,
-          ['custom_token', token: bot.token, username: 'new_name'],
-          option: :val,
-        ]
-      end
-
-      it 'creates routes for every created bot and controller' do
-        assert_routes [
-          create_bot('custom_token'),
-          controller,
-          'telegram_webhook',
-          option: :val,
-        ], [
-          create_bot(bot.token, 'new_name'),
-          controller,
-          'telegram_webhook',
-          option: :val,
-        ]
-      end
-    end
-  end
 end

spec/telegram/bot/rspec/callback_query_helpers_spec.rb

@@ -0,0 +1,42 @@
+require 'telegram/bot/rspec/integration/poller'
+
+RSpec.describe 'Integration spec helpers', telegram_bot: :poller do
+  let(:bot) { Telegram::Bot::ClientStub.new('token') }
+  let(:controller_class) do
+    Class.new(Telegram::Bot::UpdatesController) do
+      include Telegram::Bot::UpdatesController::CallbackQueryContext
+
+      def callback_query(data = nil, *)
+        answer_callback_query "data: #{data}"
+      end
+
+      def context_callback_query(data = nil, *)
+        answer_callback_query "data: #{data}", extra: :param
+      end
+
+      def answer_and_edit_callback_query(data = nil, *)
+        answer_callback_query "data: #{data}"
+        edit_message :text, text: 'edited-text', extra: :param
+      end
+    end
+  end
+
+  describe '#callback_query', :callback_query do
+    let(:data) { 'unknown:command' }
+    it { should answer_callback_query("data: #{data}") }
+  end
+
+  describe '#context_callback_query', :callback_query do
+    let(:data) { 'context:test:payload' }
+    it { should answer_callback_query('data: test:payload', extra: :param) }
+    it { should_not edit_current_message(:text) }
+  end
+
+  describe '#answer_and_edit_callback_query', :callback_query do
+    let(:data) { 'answer_and_edit:test:payload' }
+    it do
+      should answer_callback_query(/test:payload/).
+        and edit_current_message(:text, text: /edited/, extra: :param)
+    end
+  end
+end

spec/telegram/bot/rspec/integration/poller_spec.rb

@@ -0,0 +1,5 @@
+require 'telegram/bot/rspec/integration/poller'
+
+RSpec.describe 'Poller integration spec', telegram_bot: :poller do
+  include_examples 'shared integration examples'
+end

spec/telegram/bot/rspec/integration/rack_spec.rb

@@ -0,0 +1,20 @@
+require 'telegram/bot/rspec/integration/rack'
+
+RSpec.describe 'Rack integration spec', telegram_bot: :rack do
+  include_examples 'shared integration examples'
+  let(:request_path) { '/bot' }
+  let(:app) do
+    path = request_path
+    bot_app = Telegram::Bot::Middleware.new(bot, controller_class)
+    app = Rack::Builder.new do
+      map(path) { run bot_app }
+      run ->(env) { raise "Route is not mapped: #{env['PATH_INFO']}" }
+    end
+    if ActionPack::VERSION::MAJOR >= 5
+      app
+    else
+      require 'action_dispatch/middleware/params_parser'
+      ActionDispatch::ParamsParser.new(app)
+    end
+  end
+end

spec/telegram/bot/rspec/integration/rails_spec.rb

@@ -0,0 +1 @@
+# Tested in spec/integration

spec/telegram/bot/rspec/integration_spec.rb

@@ -1,112 +0,0 @@
-require 'telegram/bot/rspec/integration'
-require 'action_controller'
-require 'action_dispatch'
-require 'action_dispatch/testing/integration'
-
-RSpec.describe 'Integrations helper', :telegram_bot do
-  include ActionDispatch::Integration::Runner
-  def reset_template_assertion
-  end
-
-  let(:app) do
-    app = Telegram::Bot::Middleware.new(bot, controller)
-    if ActionPack::VERSION::MAJOR >= 5
-      app
-    else
-      require 'action_dispatch/middleware/params_parser'
-      ActionDispatch::ParamsParser.new(app)
-    end
-  end
-  let(:bot) { Telegram::Bot::ClientStub.new('token') }
-  let(:controller_path) { '/' }
-  let(:controller) do
-    Class.new(Telegram::Bot::UpdatesController) do
-      def start(*args)
-        respond_with :message, text: "Start: #{args.inspect}, option: #{payload[:option]}"
-      end
-    end
-  end
-
-  describe '#default_message_options' do
-    subject { default_message_options }
-    it { should eq from: {id: from_id}, chat: {id: chat_id} }
-  end
-
-  describe '#dispatch' do
-    subject { -> { dispatch message: {text: '/start', **default_message_options} } }
-    it { should respond_with_message 'Start: [], option: ' }
-  end
-
-  describe '#dispatch_message' do
-    subject { -> { dispatch_message "/start #{args.join ' '}", options } }
-    let(:args) { %w[asd qwe] }
-    let(:options) { {} }
-    it { should respond_with_message "Start: #{args.inspect}, option: " }
-
-    context 'with options' do
-      let(:options) { {option: 1} }
-      it { should respond_with_message "Start: #{args.inspect}, option: 1" }
-
-      context 'and chat_id is not set' do
-        let(:options) { super().merge(chat: nil) }
-        it { should raise_error(/chat is not present/) }
-      end
-    end
-  end
-
-  describe '#dispatch_command' do
-    subject { -> { dispatch_command :start, *args } }
-    let(:args) { [] }
-    it { should respond_with_message "Start: #{args.inspect}, option: " }
-
-    context 'with args' do
-      let(:args) { %w[asd qwe] }
-      it { should respond_with_message "Start: #{args.inspect}, option: " }
-    end
-
-    context 'with options' do
-      let(:args) { ['asd', 'qwe', option: 1] }
-      it { should respond_with_message "Start: #{args[0...-1].inspect}, option: 1" }
-    end
-  end
-
-  describe 'callback queries', :callback_query do
-    let(:controller) do
-      Class.new(Telegram::Bot::UpdatesController) do
-        include Telegram::Bot::UpdatesController::CallbackQueryContext
-
-        def callback_query(data = nil, *)
-          answer_callback_query "data: #{data}"
-        end
-
-        def context_callback_query(data = nil, *)
-          answer_callback_query "data: #{data}", extra: :param
-        end
-
-        def answer_and_edit_callback_query(data = nil, *)
-          answer_callback_query "data: #{data}"
-          edit_message :text, text: 'edited-text', extra: :param
-        end
-      end
-    end
-
-    describe '#callback_query' do
-      let(:data) { 'unknown:command' }
-      it { should answer_callback_query("data: #{data}") }
-    end
-
-    describe '#context_callback_query' do
-      let(:data) { 'context:test:payload' }
-      it { should answer_callback_query('data: test:payload', extra: :param) }
-      it { should_not edit_current_message(:text) }
-    end
-
-    describe '#answer_and_edit_callback_query' do
-      let(:data) { 'answer_and_edit:test:payload' }
-      it do
-        should answer_callback_query(/test:payload/).
-          and edit_current_message(:text, text: /edited/, extra: :param)
-      end
-    end
-  end
-end

spec/telegram/bot/rspec/message_helpers_spec.rb

@@ -0,0 +1,115 @@
+require 'telegram/bot/rspec/integration/poller'
+
+RSpec.describe 'Integration: message helpers', telegram_bot: :poller do
+  describe '#default_message_options' do
+    subject { default_message_options }
+    it { should eq from: {id: from_id}, chat: {id: chat_id} }
+  end
+
+  describe '#dispatch_message' do
+    subject { -> { dispatch_message text, options } }
+    let(:text) { '/start asd qwe' }
+    let(:options) { {} }
+    let(:result) { double(:result) }
+
+    it 'invokes dispatch' do
+      expect(self).to receive(:dispatch).with(
+        message: hash_including(default_message_options.merge(
+          text: text,
+        )),
+      ) { result }
+      expect(subject.call).to eq result
+    end
+
+    context 'with options' do
+      let(:options) { {option: 1} }
+      it 'invokes dispatch' do
+        expect(self).to receive(:dispatch).with(
+          message: hash_including(default_message_options.merge(
+            text: text,
+          ).merge(options)),
+        ) { result }
+        expect(subject.call).to eq result
+      end
+    end
+  end
+
+  describe '#dispatch_command' do
+    subject { -> { dispatch_command :start, *args } }
+    let(:args) { [] }
+    let(:result) { double(:result) }
+
+    it 'invokes dispatch' do
+      expect(self).to receive(:dispatch).with(
+        message: hash_including(default_message_options.merge(
+          text: '/start',
+        )),
+      ) { result }
+      expect(subject.call).to eq result
+    end
+
+    context 'with args & options' do
+      let(:args) { [*params, options] }
+      let(:params) { %w[qwe asd] }
+      let(:options) { {option: 1} }
+      it 'invokes dispatch' do
+        expect(self).to receive(:dispatch).with(
+          message: hash_including(default_message_options.merge(
+            text: "/start #{params.join(' ')}",
+          ).merge(options)),
+        ) { result }
+        expect(subject.call).to eq result
+      end
+    end
+  end
+end
+
+# Old specs
+RSpec.describe 'Integration: message helpers', telegram_bot: :poller do
+  let(:bot) { Telegram::Bot::ClientStub.new('token') }
+  let(:controller_class) do
+    Class.new(Telegram::Bot::UpdatesController) do
+      def start!(*args)
+        respond_with :message, text: "Start: #{args.inspect}, option: #{payload['option']}"
+      end
+    end
+  end
+
+  describe '#default_message_options' do
+    subject { default_message_options }
+    it { should eq from: {id: from_id}, chat: {id: chat_id} }
+  end
+
+  describe '#dispatch_message' do
+    subject { -> { dispatch_message "/start #{args.join ' '}", options } }
+    let(:args) { %w[asd qwe] }
+    let(:options) { {} }
+    it { should respond_with_message "Start: #{args.inspect}, option: " }
+
+    context 'with options' do
+      let(:options) { {option: 1} }
+      it { should respond_with_message "Start: #{args.inspect}, option: 1" }
+
+      context 'and chat_id is not set' do
+        let(:options) { super().merge(chat: nil) }
+        it { should raise_error(/chat is not present/) }
+      end
+    end
+  end
+
+  describe '#dispatch_command' do
+    subject { -> { dispatch_command :start, *args } }
+    let(:args) { [] }
+    it { should respond_with_message "Start: #{args.inspect}, option: " }
+
+    context 'with args' do
+      let(:args) { %w[asd qwe] }
+      it { should respond_with_message "Start: #{args.inspect}, option: " }
+    end
+
+    context 'with options' do
+      let(:args) { ['asd', 'qwe', option: 1] }
+      it { should respond_with_message "Start: #{args[0...-1].inspect}, option: 1" }
+    end
+  end
+end

spec/telegram/bot/updates_controller/callback_query_context_spec.rb

@@ -27,7 +27,7 @@ RSpec.describe Telegram::Bot::UpdatesController::CallbackQueryContext do
   describe '#dispatch' do
     subject { -> { dispatch } }
     let(:payload_type) { :callback_query }
-    let(:payload) { {'data' => data} }
+    let(:payload) { {data: data} }
     let(:data) { text }
     let(:text) { 'asd qwe zxc' }
 

spec/telegram/bot/updates_controller/commands_spec.rb

@@ -0,0 +1,111 @@
+RSpec.describe Telegram::Bot::UpdatesController::Commands do
+  describe '#action_for_command' do
+    subject { ->(*args) { object.action_for_command(*args) } }
+    let(:object) { Object.new.tap { |x| x.extend described_class } }
+
+    def assert_subject(input, expected)
+      expect(subject.call input).to eq expected
+    end
+
+    it 'bypasses and downcases not conflictint commands' do
+      assert_subject 'test', 'test!'
+      assert_subject 'TeSt', 'test!'
+      assert_subject '_Te1St', '_te1st!'
+    end
+  end
+
+  describe '.command_from_text' do
+    subject { ->(*args) { described_class.command_from_text(*args) } }
+
+    def assert_subject(input, cmd, *args)
+      expected = cmd ? [cmd, args] : cmd
+      expect(subject.call(*input)).to eq expected
+    end
+
+    let(:max_cmd_size) { 32 }
+    let(:long_cmd) { 'a' * (max_cmd_size - 1) }
+    let(:too_long_cmd) { 'a' * max_cmd_size }
+
+    it 'works for simple commands' do
+      assert_subject '/test', 'test'
+      assert_subject '/tE_2_St', 'tE_2_St'
+      assert_subject '/123', '123'
+      assert_subject "/#{long_cmd}", long_cmd
+    end
+
+    it 'works for simple messages' do
+      assert_subject 'text', nil
+      assert_subject ' ', nil
+      assert_subject ' text', nil
+      assert_subject ' 1', nil
+      assert_subject ' /text', nil
+      assert_subject '/te-xt', nil
+      assert_subject 'text /cmd ', nil
+      assert_subject "/#{too_long_cmd}", nil
+    end
+
+    it 'works for mentioned commands' do
+      assert_subject ['/test@bot', 'bot'], 'test'
+      assert_subject ['/test@otherbot', 'bot'], nil
+      assert_subject ['/test@Bot', 'bot'], nil
+      assert_subject '/test@bot', nil
+      assert_subject ['/test@bot', true], 'test'
+      assert_subject ['/test@otherbot', true], 'test'
+    end
+
+    it 'works for commands with args' do
+      assert_subject '/test arg', 'test', 'arg'
+      assert_subject '/test  arg  1  2', 'test', 'arg', '1', '2'
+      assert_subject ['/test@bot arg', 'bot'], 'test', 'arg'
+      assert_subject ['/test@otherbot arg', 'bot'], nil
+      assert_subject '/test@bot arg', nil
+    end
+
+    it 'works for commands with multiline args' do
+      assert_subject "/test arg\nother", 'test', 'arg', 'other'
+      assert_subject "/test one\ntwo\n\nthree", 'test', 'one', 'two', 'three'
+    end
+  end
+
+  describe '#action_for_payload' do
+    include_context 'telegram/bot/updates_controller'
+    let(:controller_class) { Telegram::Bot::UpdatesController }
+    subject { controller.action_for_payload }
+
+    %w[message channel_post].each do |type|
+      context "when payload is edited_#{type}" do
+        let(:payload_type) { "edited_#{type}" }
+        it { should eq [payload_type, [payload]] }
+      end
+
+      context 'when payload is message' do
+        let(:payload_type) { type }
+        let(:payload) { {'text' => text} }
+        let(:text) { 'test' }
+
+        it { should eq [payload_type, [payload]] }
+
+        context 'with command' do
+          let(:text) { "/test#{"@#{mention}" if mention} arg 1 2" }
+          let(:mention) {}
+          it { should eq [['test!', type: :command, command: 'test'], %w[arg 1 2]] }
+
+          context 'with mention' do
+            let(:mention) { bot.username }
+            it { should eq [['test!', type: :command, command: 'test'], %w[arg 1 2]] }
+          end
+
+          context 'with mention for other bot' do
+            let(:mention) { 'other_bot_name' }
+            it { should eq [payload_type, [payload]] }
+          end
+        end
+
+        context 'without text' do
+          let(:payload) { {'audio' => {'file_id' => 123}} }
+          it { should eq [payload_type, [payload]] }
+        end
+      end
+    end
+  end
+end

spec/telegram/bot/updates_controller/instrumentation_spec.rb

@@ -2,13 +2,11 @@ RSpec.describe Telegram::Bot::UpdatesController::Instrumentation do
   include_context 'telegram/bot/updates_controller'
 
   subject { -> { dispatch } }
-  let(:update) do
-    build_update :message, default_message_options.merge(text: '/start')
-  end
+  let(:update) { {message: default_message_options.merge(text: '/start')} }
 
   let(:controller_class) do
     Class.new(Telegram::Bot::UpdatesController) do
-      def start(*)
+      def start!(*)
       end
     end
   end
@@ -36,11 +34,11 @@ RSpec.describe Telegram::Bot::UpdatesController::Instrumentation do
 
       action = action_name(:start_processing)
       expect(events[action].size).to eq(1)
-      expect(events[action][0].last).to include(update: update)
+      expect(events[action][0].last).to include(update: deep_stringify(update))
 
       action = action_name(:process_action)
       expect(events[action].size).to eq(1)
-      expect(events[action][0].last).to include(update: update)
+      expect(events[action][0].last).to include(update: deep_stringify(update))
     end
   end
 
@@ -74,7 +72,7 @@ RSpec.describe Telegram::Bot::UpdatesController::Instrumentation do
 
   describe '#respond_with' do
     before do
-      def controller.start(*)
+      def controller.start!(*)
         respond_with :message, text: 'sample response'
       end
     end

spec/telegram/bot/updates_controller/message_context_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
       include described_class
 
       attr_accessor :filter_done
-      before_action only: :redirect do
+      before_action only: :context_with_filter do
         self.filter_done = true
       end
 
@@ -17,19 +17,16 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
         [:no_context, *args]
       end
 
-      context_handler :block do |*args|
-        [:block_result, *args]
+      def handler_method(*args)
+        [:method_result_1, *args]
       end
 
-      context_handler :redirect
-      context_handler :other_redirect, :redirect
-
-      def redirect(*args)
-        [:method_result, *args]
+      def context_with_filter(*args)
+        [:method_result_2, *args]
       end
 
-      def action(*args)
-        [:action_result, *args]
+      def action!(*args)
+        [:command_result, *args]
       end
 
       private
@@ -52,85 +49,59 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
       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] }
+    context 'when context is handled by handler_method' do
+      before { session[:context] = :handler_method }
+      its(:call) { should eq [:method_result_1, *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] }
+        its(:call) { should eq [:method_result_1] }
       end
 
       context 'when message has new command' do
         let(:text) { '/action a s d' }
-        its(:call) { should eq [:action_result, 'a', 's', 'd'] }
+        its(:call) { should eq [:command_result, '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] }
+    context 'when context is handled by short context_with_filter' do
+      before { session[:context] = :context_with_filter }
+      its(:call) { should eq [:method_result_2, *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] }
+        its(:call) { should eq [:method_result_2] }
         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] }
+    context 'when context is command-action`s name' do
+      before { session[:context] = :action! }
+      its(:call) { should eq [:command_result, *text.split] }
       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] } }
+    context 'when context is not an action`s name' do
+      before { session[:context] = :not_action }
+      it do
+        should raise_error(AbstractController::ActionNotFound).
+          and change { session[:context] }.to nil
       end
+    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
+    context 'when context is invalid name' do
+      before { session[:context] = :invalid }
+      it do
+        should raise_error(AbstractController::ActionNotFound).
+          and change { session[:context] }.to nil
       end
     end
   end

spec/telegram/bot/updates_controller/reply_helpers_spec.rb

@@ -4,8 +4,8 @@ RSpec.describe Telegram::Bot::UpdatesController do
   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)} }
+  let(:payload) { {message_id: double(:message_id), chat: chat} }
+  let(:chat) { {id: double(:chat_id)} }
 
   shared_examples 'missing chat' do
     context 'when chat is missing' do
@@ -19,9 +19,8 @@ RSpec.describe Telegram::Bot::UpdatesController do
     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 }
+        with(params.merge(chat_id: chat[:id])) { result }
       should eq result
     end
   end
@@ -31,19 +30,18 @@ RSpec.describe Telegram::Bot::UpdatesController do
     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'],
+        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} }
+      let(:controller_args) { [bot, chat: deep_stringify(chat)] }
       it 'sets chat_id' do
         expect(bot).to receive("send_#{respond_type}").
-          with(params.merge(chat_id: chat['id'])) { result }
+          with(params.merge(chat_id: chat[:id])) { result }
         should eq result
       end
     end
@@ -70,7 +68,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
       it 'sets chat_id & message_id' do
         expect(bot).to receive("edit_message_#{type}").with(params.merge(
           message_id: payload[:message][:message_id],
-          chat_id: payload[:message][:chat]['id'],
+          chat_id: payload[:message][:chat][:id],
         )) { result }
         should eq result
       end

spec/telegram/bot/updates_controller/rescue_spec.rb

@@ -8,11 +8,11 @@ RSpec.describe Telegram::Bot::UpdatesController::Rescue do
       Class.new(Telegram::Bot::UpdatesController) do
         rescue_from ArgumentError, with: -> { respond_with :message, text: 'Rescued' }
 
-        def rescuable(*)
+        def rescuable!(*)
           raise ArgumentError, 'rescuable'
         end
 
-        def not_rescuable(*)
+        def not_rescuable!(*)
           raise 'not_rescuable'
         end
       end

spec/telegram/bot/updates_controller/session_spec.rb

@@ -19,11 +19,11 @@ RSpec.describe Telegram::Bot::UpdatesController::Session do
       controller_class.class_eval do
         self.session_store = :memory_store
 
-        def write(text)
+        def write!(text)
           session[:text] = text
         end
 
-        def read
+        def read!
           session[:text]
         end
 
@@ -36,7 +36,7 @@ RSpec.describe Telegram::Bot::UpdatesController::Session do
     end
 
     def build_message(text, from)
-      {'message' => {'text' => text, 'from' => from.stringify_keys}}
+      deep_stringify(message: {text: text, from: from})
     end
 
     it 'stores session between requests' do

spec/telegram/bot/updates_controller/translation_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe Telegram::Bot::UpdatesController::Translation do
+  describe '#translate' do
+    let(:controller) do
+      double(
+        controller_path: 'telegram/webhooks',
+        action_name: 'start!',
+      ).tap { |x| x.extend(described_class) }
+    end
+
+    it 'uses action_name without ! for lazy translations' do
+      expect(I18n).to receive(:translate).with('telegram.webhooks.start.hello',
+        default: [:'telegram.webhooks.hello'],
+      )
+      controller.t('.hello')
+    end
+  end
+
+  describe described_class::ClassMethods do
+    describe '#translate' do
+      let(:controller_class) do
+        double(controller_path: 'telegram/webhooks').
+          tap { |x| x.extend(described_class) }
+      end
+
+      it 'uses controller_path for lazy translations' do
+        expect(I18n).to receive(:translate).with('telegram.webhooks.hello', {})
+        controller_class.t('.hello')
+      end
+    end
+  end
+end

spec/telegram/bot/updates_controller_spec.rb

@@ -1,81 +1,5 @@
 RSpec.describe Telegram::Bot::UpdatesController do
   include_context 'telegram/bot/updates_controller'
-  let(:other_bot_name) { 'other_bot' }
-
-  describe '.action_for_command' do
-    subject { ->(*args) { described_class.action_for_command(*args) } }
-
-    def assert_subject(input, expected)
-      expect(subject.call input).to eq expected
-    end
-
-    it 'bypasses and downcases not conflictint commands' do
-      assert_subject 'test', 'test'
-      assert_subject 'TeSt', 'test'
-      assert_subject '_Te1St', '_te1st'
-    end
-
-    it 'adds _on to conflicting commands' do
-      described_class::PAYLOAD_TYPES.each do |x|
-        assert_subject x, "on_#{x}"
-        assert_subject x.upcase, "on_#{x}"
-      end
-      assert_subject '1TeSt', 'on_1test'
-    end
-  end
-
-  describe '.command_from_text' do
-    subject { ->(*args) { described_class.command_from_text(*args) } }
-
-    def assert_subject(input, cmd, *args)
-      expected = cmd ? [cmd, args] : cmd
-      expect(subject.call(*input)).to eq expected
-    end
-
-    let(:max_cmd_size) { 32 }
-    let(:long_cmd) { 'a' * (max_cmd_size - 1) }
-    let(:too_long_cmd) { 'a' * max_cmd_size }
-
-    it 'works for simple commands' do
-      assert_subject '/test', 'test'
-      assert_subject '/tE_2_St', 'tE_2_St'
-      assert_subject '/123', '123'
-      assert_subject "/#{long_cmd}", long_cmd
-    end
-
-    it 'works for simple messages' do
-      assert_subject 'text', nil
-      assert_subject ' ', nil
-      assert_subject ' text', nil
-      assert_subject ' 1', nil
-      assert_subject ' /text', nil
-      assert_subject '/te-xt', nil
-      assert_subject 'text /cmd ', nil
-      assert_subject "/#{too_long_cmd}", nil
-    end
-
-    it 'works for mentioned commands' do
-      assert_subject ['/test@bot', 'bot'], 'test'
-      assert_subject ['/test@otherbot', 'bot'], nil
-      assert_subject ['/test@Bot', 'bot'], nil
-      assert_subject '/test@bot', nil
-      assert_subject ['/test@bot', true], 'test'
-      assert_subject ['/test@otherbot', true], 'test'
-    end
-
-    it 'works for commands with args' do
-      assert_subject '/test arg', 'test', 'arg'
-      assert_subject '/test  arg  1  2', 'test', 'arg', '1', '2'
-      assert_subject ['/test@bot arg', 'bot'], 'test', 'arg'
-      assert_subject ['/test@otherbot arg', 'bot'], nil
-      assert_subject '/test@bot arg', nil
-    end
-
-    it 'works for commands with multiline args' do
-      assert_subject "/test arg\nother", 'test', 'arg', 'other'
-      assert_subject "/test one\ntwo\n\nthree", 'test', 'one', 'two', 'three'
-    end
-  end
 
   describe '#action_for_payload' do
     subject { controller.action_for_payload }
@@ -87,60 +11,24 @@ RSpec.describe Telegram::Bot::UpdatesController do
     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)] }
+      it { should eq [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)] }
+      it { should eq [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)] }
+      it { should eq [payload_type, payload.values_at(:data)] }
     end
 
     context 'when payload is not supported' do
       let(:payload_type) { '_unsupported_' }
-      it { should eq [false, :unsupported_payload_type, []] }
-    end
-
-    %w[message channel_post].each do |type|
-      context "when payload is edited_#{type}" do
-        let(:payload_type) { "edited_#{type}" }
-        it { should eq [false, payload_type, [payload]] }
-      end
-
-      context 'when payload is message' do
-        let(:payload_type) { type }
-        let(:payload) { {'text' => text} }
-        let(:text) { 'test' }
-
-        it { should eq [false, payload_type, [payload]] }
-
-        context 'with command' do
-          let(:text) { "/test#{"@#{mention}" if mention} arg 1 2" }
-          let(:mention) {}
-          it { should eq [true, 'test', %w[arg 1 2]] }
-
-          context 'with mention' do
-            let(:mention) { bot.username }
-            it { should eq [true, 'test', %w[arg 1 2]] }
-          end
-
-          context 'with mention for other bot' do
-            let(:mention) { other_bot_name }
-            it { should eq [false, payload_type, [payload]] }
-          end
-        end
-
-        context 'without text' do
-          let(:payload) { {'audio' => {'file_id' => 123}} }
-          it { should eq [false, payload_type, [payload]] }
-        end
-      end
+      it { should eq [:unsupported_payload_type, []] }
     end
 
     custom_payload_types = %w[
@@ -155,7 +43,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
     (described_class::PAYLOAD_TYPES - custom_payload_types).each do |type|
       context "when payload is #{type}" do
         let(:payload_type) { type }
-        it { should eq [false, payload_type, [payload]] }
+        it { should eq [payload_type, [payload]] }
       end
     end
   end
@@ -278,11 +166,13 @@ RSpec.describe Telegram::Bot::UpdatesController do
       instance_eval(&block)
       context 'when re-initialized' do
         let(:controller) do
-          described_class.new(double(:other_bot), build_update(:message,
+          initial_update = deep_stringify message: {
             text: 'original message',
             from: double(:original_from),
             chat: double(:original_chat),
-          )).tap { |x| x.send(:initialize, bot, update) }
+          }
+          described_class.new(double(:other_bot), initial_update).
+            tap { |x| x.send(:initialize, *controller_args) }
         end
         instance_eval(&block)
       end
@@ -300,7 +190,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
     end
 
     context 'when options hash is given' do
-      let(:update) { {from: from, chat: chat} }
+      let(:controller_args) { [bot, from: from, chat: chat] }
       with_reinitialize do
         its(:bot) { should eq bot }
         its(:update) { should eq nil }

telegram-bot.gemspec

@@ -17,6 +17,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.post_install_message = 'Breaking changes in v0.14! ' \
+    'See upgrade guide at https://github.com/telegram-bot-rb/telegram-bot/wiki/Upgrading-to-0.14'
+
   spec.required_ruby_version = '~> 2.0'
 
   spec.add_dependency 'actionpack', '>= 4.0', '< 6.0'