max_bot 0.1.1 → 0.2.1

data/test/max/bot/api_send_test.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'faraday'
+
+module Max
+  module Bot
+    class RecordingHttp
+      attr_reader :posts, :gets, :deletes
+
+      def initialize
+        @posts = []
+        @gets = []
+        @deletes = []
+      end
+
+      def post(path, query: nil, body: nil)
+        @posts << { path: path, query: query, body: body }
+        { ok: true }
+      end
+
+      def get(path, query: {})
+        @gets << { path: path, query: query }
+        { updates: [] }
+      end
+
+      def delete(path, query: nil)
+        @deletes << { path: path, query: query }
+        { success: true }
+      end
+    end
+
+    class ApiSendTest < Minitest::Test
+      def test_send_message_merges_attachment_and_attachments
+        rec = RecordingHttp.new
+        api = Api.new('token', http: rec)
+
+        api.send_message(
+          'Hello',
+          chat_id: 10,
+          attachment: Attachments.sticker(code: 'smile'),
+          attachments: [Attachments.share(url: 'https://a.example')]
+        )
+
+        atts = rec.posts.first[:body][:attachments]
+        assert_equal 2, atts.size
+        assert_equal 'sticker', atts[0][:type]
+        assert_equal 'share', atts[1][:type]
+        assert_equal 10, rec.posts.first[:query][:chat_id]
+      end
+
+      def test_get_updates_forwards_query
+        rec = RecordingHttp.new
+        api = Api.new('tok', http: rec)
+        api.get_updates(marker: 7, limit: 50, timeout: 15, types: %w[message_created])
+
+        q = rec.gets.first[:query]
+        assert_equal 7, q[:marker]
+        assert_equal 50, q[:limit]
+        assert_equal 15, q[:timeout]
+        assert_equal 'message_created', q[:types]
+      end
+
+      def test_set_webhook_json_body
+        rec = RecordingHttp.new
+        api = Api.new('tok', http: rec)
+        api.set_webhook(url: 'https://hook', update_types: %w[a], secret: 'sec')
+
+        body = rec.posts.first[:body]
+        assert_equal 'https://hook', body[:url]
+        assert_equal %w[a], body[:update_types]
+        assert_equal 'sec', body[:secret]
+      end
+
+      def test_delete_webhook_query
+        rec = RecordingHttp.new
+        api = Api.new('tok', http: rec)
+        api.delete_webhook('https://hook')
+
+        assert_equal({ url: 'https://hook' }, rec.deletes.first[:query])
+      end
+
+      def test_chats_query
+        rec = RecordingHttp.new
+        api = Api.new('tok', http: rec)
+        api.chats(count: 25, marker: 3)
+
+        assert_equal({ count: 25, marker: 3 }, rec.gets.first[:query])
+      end
+
+      def test_create_upload_posts_type
+        stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+          stub.post('/uploads') do |env|
+            assert_equal 'image', env.params['type']
+            [200, { 'Content-Type' => 'application/json' }, '{"url":"https://cdn.example/up"}']
+          end
+        end
+
+        conn = Faraday.new do |f|
+          f.adapter :test, stubs
+        end
+
+        http = Http.new('tok', 'https://platform-api.max.ru', connection: conn)
+        api = Api.new('tok', http: http)
+
+        result = api.create_upload(type: :image)
+        assert_equal 'https://cdn.example/up', result[:url]
+        stubs.verify_stubbed_calls
+      end
+
+      def test_create_upload_rejects_unknown_type
+        api = Api.new('tok', http: RecordingHttp.new)
+        assert_raises(ArgumentError) { api.create_upload(type: :photo) }
+      end
+
+      def test_upload_file_raises_when_slot_has_no_url
+        api = Api.new('tok', http: RecordingHttp.new)
+
+        def api.create_upload(*)
+          { token: 'only' }
+        end
+
+        err = assert_raises(ApiError) { api.upload_file(type: :image, path: __FILE__) }
+        assert_match(/url/i, err.message)
+      end
+    end
+  end
+end

data/test/max/bot/api_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Max
+  module Bot
+    class ApiTest < Minitest::Test
+      def test_rejects_blank_token
+        assert_raises(ArgumentError) { Api.new(nil) }
+        assert_raises(ArgumentError) { Api.new('   ') }
+      end
+
+      def test_send_message_requires_recipient
+        api = Api.new('token')
+        err = assert_raises(ArgumentError) { api.send_message('hi') }
+        assert_match(/chat_id|user_id/, err.message)
+      end
+
+      def test_send_message_requires_payload
+        api = Api.new('token')
+        err = assert_raises(ArgumentError) { api.send_message(nil, chat_id: 1) }
+        assert_match(/text|attachments|attachment|link/, err.message)
+      end
+    end
+  end
+end

data/test/max/bot/attachments_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Max
+  module Bot
+    class AttachmentsTest < Minitest::Test
+      def test_image_with_token
+        att = Attachments.image(token: 'abc')
+        assert_equal 'image', att[:type]
+        assert_equal({ token: 'abc' }, att[:payload])
+      end
+
+      def test_inline_keyboard_structure
+        rows = [
+          [
+            Attachments.callback_button('OK', 'payload-1', intent: 'positive'),
+            Attachments.link_button('Site', 'https://example.com')
+          ]
+        ]
+        att = Attachments.inline_keyboard(rows)
+        assert_equal 'inline_keyboard', att[:type]
+        assert_equal rows, att[:payload][:buttons]
+      end
+
+      def test_location_top_level_coordinates
+        att = Attachments.location(latitude: 55.75, longitude: 37.61)
+        assert_equal 'location', att[:type]
+        assert_in_delta 55.75, att[:latitude]
+        assert_in_delta 37.61, att[:longitude]
+      end
+
+      def test_share_payload
+        att = Attachments.share(url: 'https://example.com')
+        assert_equal 'share', att[:type]
+        assert_equal 'https://example.com', att[:payload][:url]
+      end
+    end
+  end
+end

data/test/max/bot/client_test.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Max
+  module Bot
+    class ClientTest < Minitest::Test
+      class DummyApi
+        attr_reader :get_updates_calls
+
+        def initialize(responses)
+          @responses = responses.dup
+          @get_updates_calls = []
+        end
+
+        def get_updates(**kwargs)
+          @get_updates_calls << kwargs
+          @responses.shift || { updates: [], marker: nil }
+        end
+      end
+
+      def test_initialize_accepts_injected_api
+        dummy = DummyApi.new([])
+        client = Client.new('token', api: dummy)
+        assert_same dummy, client.api
+      end
+
+      def test_run_requires_block
+        client = Client.new('token', api: DummyApi.new([]))
+        err = assert_raises(ArgumentError) { client.run }
+        assert_match(/block/, err.message)
+      end
+
+      def test_class_run_requires_block
+        assert_raises(ArgumentError) { Client.run('token') }
+      end
+
+      def test_run_yields_updates_and_passes_marker_on_next_poll
+        responses = [
+          { updates: [{ id: 1 }], marker: 10 },
+          { updates: [{ id: 2 }], marker: 20 }
+        ]
+        dummy = DummyApi.new(responses)
+        seen = []
+        client = Client.new('token', api: dummy, sleep: ->(_) {})
+
+        client.run do |u|
+          seen << u
+          raise StopIteration if seen.size >= 2
+        end
+
+        assert_equal 2, seen.size
+        assert_equal({ id: 1 }, seen[0])
+        assert_equal({ id: 2 }, seen[1])
+        assert_nil dummy.get_updates_calls[0][:marker]
+        assert_equal 10, dummy.get_updates_calls[1][:marker]
+      end
+    end
+  end
+end

data/test/max/bot/errors_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Max
+  module Bot
+    class ErrorsTest < Minitest::Test
+      def test_api_error_to_s_includes_message_field
+        err = ApiError.new('HTTP 400', status: 400, body: { message: 'bad request' })
+        assert_match(/HTTP 400/, err.to_s)
+        assert_match(/bad request/, err.to_s)
+      end
+
+      def test_api_error_attributes
+        err = ApiError.new('x', status: 404, body: { code: 1 })
+        assert_equal 404, err.status
+        assert_equal({ code: 1 }, err.body)
+      end
+    end
+  end
+end

data/test/max/bot/http_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'faraday'
+
+module Max
+  module Bot
+    class HttpTest < Minitest::Test
+      def test_get_parses_json
+        stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+          stub.get('/updates') { [200, { 'Content-Type' => 'application/json' }, '{"updates":[],"marker":null}'] }
+        end
+
+        conn = Faraday.new do |f|
+          f.adapter :test, stubs
+        end
+
+        http = Http.new('secret-token', 'https://platform-api.max.ru', connection: conn)
+        result = http.get('/updates', query: {})
+
+        assert_equal [], result[:updates]
+        assert_nil result[:marker]
+        stubs.verify_stubbed_calls
+      end
+
+      def test_post_sends_json_body_and_auth
+        stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+          stub.post('/messages', '{"text":"hi"}') do |env|
+            assert_equal 'secret-token', env.request_headers['Authorization']
+            assert_match %r{application/json}, env.request_headers['Content-Type']
+            [200, { 'Content-Type' => 'application/json' }, '{"message":{"body":{}}}']
+          end
+        end
+
+        conn = Faraday.new do |f|
+          f.adapter :test, stubs
+        end
+
+        http = Http.new('secret-token', 'https://platform-api.max.ru', connection: conn)
+        result = http.post('/messages', query: { chat_id: 1 }, body: { text: 'hi' })
+
+        assert result.key?(:message)
+        stubs.verify_stubbed_calls
+      end
+
+      def test_raises_api_error_on_http_error
+        stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+          stub.get('/updates') { [401, {}, '{"message":"unauthorized"}'] }
+        end
+
+        conn = Faraday.new do |f|
+          f.adapter :test, stubs
+        end
+
+        http = Http.new('bad', 'https://platform-api.max.ru', connection: conn)
+
+        err = assert_raises(ApiError) { http.get('/updates') }
+        assert_equal 401, err.status
+        assert_equal 'unauthorized', err.body[:message]
+      end
+
+      def test_delete_sends_query_and_auth
+        stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+          stub.delete('/subscriptions') do |env|
+            assert_equal 'tok', env.request_headers['Authorization']
+            assert_equal 'https://h', env.params['url']
+            [200, { 'Content-Type' => 'application/json' }, '{"success":true}']
+          end
+        end
+
+        conn = Faraday.new do |f|
+          f.adapter :test, stubs
+        end
+
+        http = Http.new('tok', 'https://platform-api.max.ru', connection: conn)
+        result = http.delete('/subscriptions', query: { url: 'https://h' })
+        assert_equal true, result[:success]
+        stubs.verify_stubbed_calls
+      end
+    end
+  end
+end

data/test/max/bot/json_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Max
+  module Bot
+    class JsonTest < Minitest::Test
+      FakeResponse = Struct.new(:status, :body) do
+        def success?
+          status >= 200 && status < 300
+        end
+      end
+
+      def test_deep_symbolize_nested
+        input = { 'a' => 1, 'b' => [{ 'c' => 'd' }] }
+        out = Json.deep_symbolize(input)
+
+        assert_equal({ a: 1, b: [{ c: 'd' }] }, out)
+      end
+
+      def test_decode_response_success
+        r = FakeResponse.new(200, '{"a":1}')
+        assert_equal({ a: 1 }, Json.decode_response(r))
+      end
+
+      def test_decode_response_empty_body
+        r = FakeResponse.new(200, '')
+        assert_equal({}, Json.decode_response(r))
+      end
+
+      def test_decode_response_error_raises_api_error
+        r = FakeResponse.new(422, '{"message":"nope"}')
+        err = assert_raises(ApiError) { Json.decode_response(r) }
+        assert_equal 422, err.status
+        assert_equal 'nope', err.body[:message]
+      end
+
+      def test_decode_response_invalid_json
+        r = FakeResponse.new(200, '{')
+        assert_raises(ApiError) { Json.decode_response(r) }
+      end
+    end
+  end
+end

data/test/max/bot/update_helpers_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Max
+  module Bot
+    class UpdateHelpersTest < Minitest::Test
+      def test_message_created_predicate
+        assert UpdateHelpers.message_created?(update_type: 'message_created')
+        refute UpdateHelpers.message_created?(update_type: 'other')
+      end
+
+      def test_message_text_from_body_hash
+        msg = { body: { text: 'hello' } }
+        assert_equal 'hello', UpdateHelpers.message_text(msg)
+      end
+
+      def test_message_destination_chat_id
+        msg = { recipient: { chat_id: -100 } }
+        assert_equal [:chat_id, -100], UpdateHelpers.message_destination(msg)
+      end
+
+      def test_message_destination_user_id_fallback
+        msg = { recipient: { user_id: 42 } }
+        assert_equal [:user_id, 42], UpdateHelpers.message_destination(msg)
+      end
+    end
+  end
+end

data/test/max/bot/webhook_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Max
+  module Bot
+    class WebhookTest < Minitest::Test
+      def test_secret_valid_when_no_secret_configured
+        assert Webhook.secret_valid?('anything', nil)
+        assert Webhook.secret_valid?('anything', '')
+      end
+
+      def test_secret_valid_compares_constant_time
+        assert Webhook.secret_valid?('abc', 'abc')
+        refute Webhook.secret_valid?('abc', 'abd')
+        refute Webhook.secret_valid?('abc', 'ab')
+      end
+
+      def test_extract_secret_header_rack_style
+        env = { 'HTTP_X_MAX_BOT_API_SECRET' => 'sekret' }
+        assert_equal 'sekret', Webhook.extract_secret_header(env)
+      end
+
+      def test_parse_json_empty
+        assert_equal({}, Webhook.parse_json(nil))
+        assert_equal({}, Webhook.parse_json(''))
+      end
+
+      def test_parse_json_object
+        h = Webhook.parse_json('{"update_type":"message_created"}')
+        assert_equal 'message_created', h[:update_type]
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'max_bot'
+require 'minitest/autorun'

metadata

@@ -1,23 +1,113 @@
 --- !ruby/object:Gem::Specification
 name: max_bot
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Sergey Syabrenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-22 00:00:00.000000000 Z
-dependencies: []
-description: Max messenger bot
+date: 2026-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '15'
+description: Send messages, long-poll GET /updates, manage webhook subscriptions.
+  See https://dev.max.ru/docs-api
 email: darthpains@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/polling_bot.rb
+- lib/max/bot.rb
+- lib/max/bot/api.rb
+- lib/max/bot/api/request_builders.rb
+- lib/max/bot/attachments.rb
+- lib/max/bot/client.rb
+- lib/max/bot/configuration.rb
+- lib/max/bot/errors.rb
+- lib/max/bot/http.rb
+- lib/max/bot/json.rb
+- lib/max/bot/multipart_upload.rb
+- lib/max/bot/update_helpers.rb
+- lib/max/bot/version.rb
+- lib/max/bot/webhook.rb
 - lib/max_bot.rb
-homepage: https://rubygems.org/gems/max_bot
+- test/max/bot/api/request_builders_test.rb
+- test/max/bot/api_send_test.rb
+- test/max/bot/api_test.rb
+- test/max/bot/attachments_test.rb
+- test/max/bot/client_test.rb
+- test/max/bot/errors_test.rb
+- test/max/bot/http_test.rb
+- test/max/bot/json_test.rb
+- test/max/bot/update_helpers_test.rb
+- test/max/bot/webhook_test.rb
+- test/test_helper.rb
+homepage: https://github.com/Syabr/max_bot
 licenses:
 - MIT
 metadata: {}
@@ -39,5 +129,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Max messenger bot
+summary: Ruby client for the MAX messenger Bot API
 test_files: []