v0.7.2

CHANGELOG.md

@@ -1,3 +1,24 @@
+# 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.

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,6 +152,8 @@ 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`:
 
@@ -150,6 +167,8 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
 end
 ```
 
+#### Session
+
 There is support for sessions using `ActiveSupport::Cache` stores.
 
 ```ruby
@@ -183,6 +202,8 @@ 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:
 
@@ -197,8 +218,8 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   end
 
   # register context handlers to handle this context
-  context_handler :rename do |message|
+  context_handler :rename do |*words|
-    update_name message[:text]
+    update_name words[0]
     reply_with :message, text: 'Renamed!'
   end
 
@@ -222,6 +243,14 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
 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
@@ -263,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
@@ -306,6 +336,42 @@ Check out `telegram/bot/updates_controller/rspec_helpers` and
 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,7 @@ 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."
@@ -34,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

lib/telegram/bot/client_stub.rb

@@ -15,7 +15,8 @@ module Telegram
       end
 
       class << self
-        # Makes all
+        # 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?

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/updates_controller.rb

@@ -50,13 +50,16 @@ module Telegram
     #     ControllerClass.new(bot, from: telegram_user, chat: telegram_chat).
     #       process(:help, *args)
     #
-    class UpdatesController < AbstractController::Base
+    class UpdatesController < AbstractController::Base # rubocop:disable ClassLength
       abstract!
 
       require 'telegram/bot/updates_controller/session'
       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.
@@ -70,6 +73,7 @@ module Telegram
       end
 
       include AbstractController::Translation
+      include ReplyHelpers
       prepend Instrumentation
       extend Session::ConfigMethods
 
@@ -79,6 +83,8 @@ 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)")
@@ -138,13 +144,13 @@ module Telegram
       # Accessor to `'chat'` field of payload. Can be overriden with `chat` option
       # for #initialize.
       def chat
-        @_chat || payload && payload['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']
+        @_from ||= payload && payload['from']
       end
 
       # Processes current update.
@@ -154,16 +160,42 @@ module Telegram
       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.
@@ -171,32 +203,6 @@ module Telegram
       def action_missing(*)
       end
 
-      # 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
-
       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

@@ -10,7 +10,6 @@ module Telegram
         included do
           # As we use before_action context is cleared anyway,
           # no matter we used it or not.
-          before_action :fetch_context
           singleton_class.send :attr_reader, :context_handlers, :context_to_action
           @context_handlers = {}
         end
@@ -18,26 +17,26 @@ module Telegram
         module ClassMethods
           # Registers handler for context.
           #
-          #     context_handler :rename do |message|
+          #     context_handler :rename do |*|
-          #       resource.update!(name: message['text'])
+          #       resource.update!(name: payload['text'])
           #     end
           #
           #     # To run other action with all the callbacks:
-          #     context_handler :rename do |message|
+          #     context_handler :rename do |*words|
-          #       process(:rename, *m['text'].split)
+          #       process(:rename, *words)
           #     end
           #
           #     # Or just
           #     context_handler :rename, :your_action_to_call
           #     context_handler :rename # to call :rename
           #
-          #     # For messages without context use this instead of `message` method:
-          #     context_handle do |message|
-          #     end
-          #
           def context_handler(context = nil, action = nil, &block)
             context &&= context.to_sym
-            context_handlers[context] = block || action || context
+            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
@@ -49,20 +48,9 @@ module Telegram
           end
         end
 
-        # Finds handler for current context and processes message with it.
-        def message(message)
-          handler = handler_for_context
-          return unless handler
-          if handler.respond_to?(:call)
-            instance_exec(message, &handler)
-          else
-            process(handler, *message['text'].split)
-          end
-        end
-
         # Action to clear context.
         def cancel
-          # Context is already cleared in before_action
+          # Context is already cleared in action_for_message
         end
 
         private
@@ -71,11 +59,15 @@ module Telegram
         # according to previous request.
         attr_reader :context
 
-        # Fetches and removes context from session.
+        # Fetches context and finds handler for it. If message has new command,
-        def fetch_context
+        # it has higher priority than contextual action.
+        def action_for_message
           val = session.delete(:context)
           @context = val && val.to_sym
-          true # TODO: remove in Rails 5.0
+          super || context && begin
+            handler = handler_for_context
+            [true, handler, payload['text'].try!(:split) || []] if handler
+          end
         end
 
         # Save context for the next request.

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/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,6 +63,18 @@ module Telegram
           end
         end
 
+        class NullSessionHash < Session::SessionHash
+          def initialize
+            @data = {}
+            @loaded = true
+            @exists = true
+          end
+
+          alias_method :destroy, :clear
+          alias_method :load!, :id
+          alias_method :commit, :id
+        end
+
         module ConfigMethods
           delegate :session_store, to: :config
 

lib/telegram/bot/updates_controller/testing.rb

@@ -27,19 +27,7 @@ module Telegram
 
         # Stubs session.
         def session
-          @_session ||= Testing::SessionHash.new
+          @_session ||= Session::NullSessionHash.new
-        end
-
-        class SessionHash < Session::SessionHash
-          def initialize
-            @data = {}
-            @loaded = true
-            @exists = true
-          end
-
-          alias_method :destroy, :clear
-          alias_method :load!, :id
-          alias_method :commit, :id
         end
       end
     end

lib/telegram/bot/version.rb

@@ -1,6 +1,6 @@
 module Telegram
   module Bot
-    VERSION = '0.5.0'.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
@@ -50,7 +63,7 @@ RSpec.describe Telegram::Bot::Client do
 
       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
@@ -60,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
 
@@ -69,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/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

@@ -10,7 +10,10 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
         self.filter_done = true
       end
 
-      context_handler do |*args|
+      attr_reader :callbacks_runs
+      before_action { @callbacks_runs = (@callbacks_runs || 0) + 1 }
+
+      def message(*args)
         [:no_context, *args]
       end
 
@@ -51,9 +54,20 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
 
     context 'when context is handled by block' do
       before { session[:context] = :block }
-      its(:call) { should eq [:block_result, payload] }
+      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
@@ -61,6 +75,14 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
       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
@@ -72,7 +94,7 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
 
     context 'when context is action`s name but not mapped' do
       before { session[:context] = :action }
-      its(:call) { should eq nil }
+      its(:call) { should eq [:no_context, payload] }
       it { should_not change(controller, :filter_done) }
       it { should change { session[:context] }.to nil }
     end
@@ -80,6 +102,12 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
     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] }

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_spec.rb

@@ -80,11 +80,36 @@ RSpec.describe Telegram::Bot::UpdatesController do
   describe '#action_for_payload' do
     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,6 +134,11 @@ 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
 
@@ -263,39 +293,4 @@ RSpec.describe Telegram::Bot::UpdatesController do
       end
     end
   end
-
-  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_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