Ability to use type-castion with telegram-bot-types

spec/spec_helper.rb

@@ -14,6 +14,8 @@ GEM_ROOT = Pathname.new File.expand_path('../..', __FILE__)
 
 $LOAD_PATH.unshift GEM_ROOT.join('lib')
 require 'telegram/bot'
+require 'telegram/bot/updates_controller/rspec_helpers'
+require 'telegram/bot/types'
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|

spec/telegram/bot/client/typed_response_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Telegram::Bot::Client::TypedResponse do
+  let(:bot) { Telegram::Bot::Client.new('token').tap { |x| x.extend described_class } }
+
+  describe '#get_me' do
+    subject { bot.get_me }
+    before { expect(bot).to receive(:request).with(:getMe) { response } }
+    let(:response) { {'ok' => true, 'result' => {'id' => user_id}} }
+    let(:user_id) { 123 }
+    it { should be_instance_of Telegram::Bot::Types::User }
+    its(:id) { should eq user_id }
+
+    context 'on error' do
+      let(:response) { raise Telegram::Bot::Error }
+      it { expect { subject }.to raise_error Telegram::Bot::Error }
+    end
+  end
+
+  describe '#get_updates' do
+    subject { bot.get_updates }
+    before { expect(bot).to receive(:request).with(:getUpdates) { response } }
+    let(:response) { {'ok' => true, 'result' => [{'update_id' => update_id}]} }
+    let(:update_id) { 123 }
+    it { should be_instance_of Array }
+    its(:first) { should be_instance_of Telegram::Bot::Types::Update }
+    its('first.update_id') { should eq update_id }
+
+    context 'on error' do
+      let(:response) { raise Telegram::Bot::Error }
+      it { expect { subject }.to raise_error Telegram::Bot::Error }
+    end
+  end
+end

spec/telegram/bot/client_spec.rb

@@ -0,0 +1,47 @@
+RSpec.describe Telegram::Bot::Client do
+  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 }
+
+      it 'treats string as token' do
+        expect(described_class).to receive(:new).with(token) { result }
+        should eq result
+      end
+    end
+
+    context 'when input is a hash' do
+      let(:input) { {token: token, username: username, ignore: :ignore} }
+
+      it 'extracts token & username' do
+        expect(described_class).to receive(:new).with(token, username) { result }
+        should eq result
+      end
+    end
+
+    context 'when input is an instance of described_class' do
+      let!(:input) { instance }
+
+      it 'returns input' do
+        expect(described_class).to_not receive(:new)
+        should eq input
+      end
+    end
+
+    context 'when input is an array' do
+      let!(:input) { ['other_token', instance, token: token, username: username] }
+      let(:result_2) { double(:result_2) }
+
+      it 'calls wrap for every element' do
+        expect(described_class).to receive(:new).with('other_token') { result }
+        expect(described_class).to receive(:new).with(token, username) { result_2 }
+        should eq [result, instance, result_2]
+      end
+    end
+  end
+end

spec/telegram/bot/routes_helper_spec.rb

@@ -1,10 +1,14 @@
 require 'telegram/bot/routes_helper'
 
 RSpec.describe Telegram::Bot::RoutesHelper do
-  let(:bot) { Telegram::Bot.new('bot_token') }
-  let(:other_bot) { Telegram::Bot.new('other_token') }
+  let(:bot) { create_bot('bot_token') }
+  let(:other_bot) { create_bot('other_token') }
   let(:bots) { {default: bot, other: other_bot} }
 
+  def create_bot(*args)
+    Telegram::Bot::Client.new(*args)
+  end
+
   describe '.route_name_for_bot' do
     subject { described_class.route_name_for_bot(input) }
     before { expect(Telegram).to receive(:bots) { bots } }
@@ -82,7 +86,7 @@ RSpec.describe Telegram::Bot::RoutesHelper do
       it 'creates routes for every bot and its controller' do
         assert_routes [bot, controller, 'default_telegram_webhook', option: :val],
                       [
-                        Telegram::Bot.new('custom_token'),
+                        create_bot('custom_token'),
                         other_controller,
                         :custom_route,
                         option: :other_val,
@@ -101,12 +105,12 @@ RSpec.describe Telegram::Bot::RoutesHelper do
 
       it 'creates routes for every created bot and controller' do
         assert_routes [
-          Telegram::Bot.new('custom_token'),
+          create_bot('custom_token'),
           controller,
           'telegram_webhook',
           option: :val,
         ], [
-          Telegram::Bot.new(bot.token, 'new_name'),
+          create_bot(bot.token, 'new_name'),
           controller,
           'telegram_webhook',
           option: :val,

spec/telegram/bot/updates_controller/typed_update_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe Telegram::Bot::UpdatesController::TypedUpdate do
+  include_context 'telegram/bot/updates_controller'
+  let(:instance) { controller_class.new(bot, update) }
+  let(:controller_class) do
+    described_class = self.described_class
+    Class.new(Telegram::Bot::UpdatesController) do
+      include described_class
+    end
+  end
+
+  context 'when `update` is a virtus model' do
+    subject { instance }
+    %w(
+      message
+      inline_query
+      chosen_inline_result
+    ).each do |type|
+      context "with #{type}" do
+        type_class = Telegram::Bot::Types.const_get(type.camelize)
+        let(:payload_type) { type }
+        let(:payload) { {} }
+        its(:payload_type) { should eq payload_type }
+        its(:payload) { should be_instance_of type_class }
+      end
+    end
+  end
+end

spec/telegram/bot/updates_controller_spec.rb

@@ -1,10 +1,5 @@
 RSpec.describe Telegram::Bot::UpdatesController do
-  let(:instance) { described_class.new(bot, update) }
-  let(:update) { {payload_type => payload} }
-  let(:payload_type) { 'some_type' }
-  let(:payload) { double(:payload) }
-  let(:bot) { double(username: bot_name) }
-  let(:bot_name) { 'bot' }
+  include_context 'telegram/bot/updates_controller'
   let(:other_bot_name) { 'other_bot' }
 
   describe '.action_for_command' do
@@ -117,6 +112,24 @@ RSpec.describe Telegram::Bot::UpdatesController do
     end
   end
 
+  context 'when `update` is a virtus model' do
+    subject { instance }
+    let(:update) { Telegram::Bot::Types::Update.new(super()) }
+    %w(
+      message
+      inline_query
+      chosen_inline_result
+    ).each do |type|
+      context "with #{type}" do
+        type_class = Telegram::Bot::Types.const_get(type.camelize)
+        let(:payload_type) { type }
+        let(:payload) { {} }
+        its(:payload_type) { should eq payload_type }
+        its(:payload) { should be_instance_of type_class }
+      end
+    end
+  end
+
   describe '#bot_username' do
     subject { instance.bot_username }
 

spec/telegram/bot_spec.rb

@@ -1,51 +1,5 @@
 RSpec.describe Telegram::Bot do
   it 'has a version number' do
-    expect(Telegram::Bot::VERSION).not_to be nil
-  end
-
-  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 }
-
-      it 'treats string as token' do
-        expect(described_class).to receive(:new).with(token) { result }
-        should eq result
-      end
-    end
-
-    context 'when input is a hash' do
-      let(:input) { {token: token, username: username, ignore: :ignore} }
-
-      it 'extracts token & username' do
-        expect(described_class).to receive(:new).with(token, username) { result }
-        should eq result
-      end
-    end
-
-    context 'when input is an instance of described_class' do
-      let!(:input) { instance }
-
-      it 'returns input' do
-        expect(described_class).to_not receive(:new)
-        should eq input
-      end
-    end
-
-    context 'when input is an array' do
-      let!(:input) { ['other_token', instance, token: token, username: username] }
-      let(:result_2) { double(:result_2) }
-
-      it 'calls wrap for every element' do
-        expect(described_class).to receive(:new).with('other_token') { result }
-        expect(described_class).to receive(:new).with(token, username) { result_2 }
-        should eq [result, instance, result_2]
-      end
-    end
+    expect(described_class::VERSION).not_to be nil
   end
 end