ruby-asterisk 0.2.0 → 1.0.0

data/spec/ruby-asterisk/ami/reactor_spec.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ruby-asterisk/ami/reactor'
+require 'ruby-asterisk/ami/promise'
+require 'support/mock_ami_server'
+require 'timeout'
+
+RSpec.describe RubyAsterisk::AMI::Reactor do
+  # ── shared mock server setup ───────────────────────────────────────────────
+
+  let(:events_received) { [] }
+  let(:on_event)        { ->(evt) { events_received << evt } }
+
+  def build_reactor
+    described_class.new('localhost', @port, on_event: on_event)
+  end
+
+  # Track Thread count before each example to assert no leaks after.
+  let(:thread_count_before) { Thread.list.count(&:alive?) }
+
+  # ── start / stop ─────────────────────────────────────────────────────────
+
+  describe 'start and stop lifecycle' do
+    before do
+      @server_thread, @port = MockAMIServer.start
+      thread_count_before # capture before reactor is started
+    end
+
+    after { @server_thread&.kill }
+
+    it 'starts without error and returns self' do
+      reactor = build_reactor
+      expect(reactor.start).to be(reactor)
+      reactor.stop
+    end
+
+    it 'both threads are dead after stop' do
+      reactor = build_reactor
+      reactor.start
+      writer_thread = reactor.instance_variable_get(:@writer_thread)
+      reader_thread = reactor.instance_variable_get(:@reader_thread)
+      reactor.stop
+      expect(writer_thread).not_to be_alive
+      expect(reader_thread).not_to be_alive
+    end
+
+    it 'can be stopped twice without error' do
+      reactor = build_reactor
+      reactor.start
+      expect do
+        reactor.stop
+        reactor.stop
+      end.not_to raise_error
+    end
+
+    # #stop closes the socket from the writer thread while the reader thread sits
+    # in readpartial: that must surface as a clean shutdown, never as a disconnect
+    # notification or a rejected promise.
+    describe 'deliberate stop' do
+      let(:disconnects) { Thread::Queue.new }
+      let(:pending_promise) do
+        RubyAsterisk::AMI::Promise.new(action_id: 'stop-race', command_type: 'Ping', timeout: 1)
+      end
+
+      def stopped_reactor
+        reactor = described_class.new('localhost', @port, on_disconnect: -> { disconnects << :called })
+        reactor.start
+        reactor.register_promise('stop-race', pending_promise)
+        reactor.send_command("Action: Ping\r\nActionID: stop-race\r\n\r\n")
+        reactor.stop
+        reactor
+      end
+
+      it 'does not notify a disconnect nor reject pending promises' do
+        stopped_reactor
+
+        expect(disconnects).to be_empty
+        expect(pending_promise).not_to be_resolved
+      end
+
+      # Replays what the reader thread does when it is scheduled only after the
+      # socket has already been closed and cleared: no notification either way.
+      it 'stays silent when the reader loop runs after the socket is gone' do
+        reactor = stopped_reactor
+
+        reactor.send(:reader_loop)
+
+        expect(disconnects).to be_empty
+        expect(pending_promise).not_to be_resolved
+      end
+    end
+  end
+
+  # ── command delivery ──────────────────────────────────────────────────────
+
+  describe 'command delivery' do
+    let(:received_commands) { Thread::Queue.new }
+
+    before do
+      @server_thread, @port = MockAMIServer.start do |sock|
+        while (line = sock.gets)
+          received_commands << line.chomp unless line.strip.empty?
+        end
+      end
+    end
+
+    after do
+      @reactor&.stop
+      @server_thread&.kill
+    end
+
+    it 'delivers a command string to the server socket' do
+      @reactor = build_reactor
+      @reactor.start
+      @reactor.send_command("Action: Ping\r\nActionID: test1\r\n\r\n")
+
+      line = Timeout.timeout(2) { received_commands.pop }
+      expect(line).to eq('Action: Ping')
+    end
+
+    it 'delivers multiple commands in order' do
+      @reactor = build_reactor
+      @reactor.start
+
+      3.times do |i|
+        @reactor.send_command("Action: Ping\r\nActionID: order#{i}\r\n\r\n")
+      end
+
+      action_ids = []
+      3.times do
+        loop do
+          line = Timeout.timeout(2) { received_commands.pop }
+          if line.start_with?('ActionID:')
+            action_ids << line.split(': ', 2).last
+            break
+          end
+        end
+      end
+
+      expect(action_ids).to eq(%w[order0 order1 order2])
+    end
+  end
+
+  # ── Promise resolution ────────────────────────────────────────────────────
+
+  describe 'Promise resolution' do
+    before do
+      @server_thread, @port = MockAMIServer.start do |sock|
+        while (chunk = sock.gets)
+          next unless chunk.strip.empty?
+
+          # Echo a successful response for every command received
+          sock.print "Response: Success\r\nActionID: #{@last_action_id}\r\nPing: Pong\r\n\r\n"
+        end
+      end
+
+      @action_id_queue = Thread::Queue.new
+
+      # Custom mock: capture ActionID as it arrives
+      begin
+        @server_thread.kill
+      rescue StandardError
+        nil
+      end
+      @server_thread, @port = MockAMIServer.start do |sock|
+        buf = +''
+        while (line = sock.gets)
+          buf << line
+          last_id = Regexp.last_match(1) if line =~ /ActionID: (\S+)/
+          next unless line.strip.empty? && last_id
+
+          sock.print "Response: Success\r\nActionID: #{last_id}\r\nPing: Pong\r\n\r\n"
+          last_id = nil
+          buf.clear
+        end
+      end
+    end
+
+    after do
+      @reactor&.stop
+      @server_thread&.kill
+    end
+
+    it 'resolves the Promise when a matching response arrives' do
+      @reactor = build_reactor
+      @reactor.start
+
+      promise = RubyAsterisk::AMI::Promise.new(
+        action_id: 'p1', command_type: 'Ping', timeout: 3
+      )
+      @reactor.register_promise('p1', promise)
+      @reactor.send_command("Action: Ping\r\nActionID: p1\r\n\r\n")
+
+      expect(promise.resolved?).to be false
+      response = promise.value(3)
+      expect(response).not_to be_nil
+      expect(promise.resolved?).to be true
+    end
+
+    it 'resolves multiple in-flight Promises independently' do
+      @reactor = build_reactor
+      @reactor.start
+
+      promises = (1..5).map do |i|
+        p = RubyAsterisk::AMI::Promise.new(
+          action_id: "multi#{i}", command_type: 'Ping', timeout: 3
+        )
+        @reactor.register_promise("multi#{i}", p)
+        @reactor.send_command("Action: Ping\r\nActionID: multi#{i}\r\n\r\n")
+        p
+      end
+
+      promises.each do |p|
+        expect { p.value(3) }.not_to raise_error
+      end
+    end
+  end
+
+  # ── Event delivery ────────────────────────────────────────────────────────
+
+  describe 'event delivery' do
+    before do
+      @server_thread, @port = MockAMIServer.start do |sock|
+        100.times do |i|
+          sock.print "Event: TestEvent\r\nSequence: #{i}\r\n\r\n"
+        end
+        begin
+          sock.gets
+        rescue StandardError
+          nil
+        end
+      end
+    end
+
+    after do
+      @reactor&.stop
+      @server_thread&.kill
+    end
+
+    it 'delivers 100 events to the on_event callback' do
+      @reactor = build_reactor
+      @reactor.start
+
+      Timeout.timeout(3) do
+        sleep 0.05 until events_received.size >= 100
+      end
+
+      expect(events_received.size).to eq(100)
+      sequences = events_received.map { |e| e.headers['Sequence'].to_i }
+      expect(sequences).to eq((0...100).to_a)
+    end
+  end
+
+  # ── Promise rejection on disconnect ──────────────────────────────────────
+
+  describe 'Promise rejection on disconnect' do
+    before do
+      @server_thread, @port = MockAMIServer.start do |sock|
+        sock.gets
+      rescue StandardError
+        nil
+        # accept but never respond
+      end
+    end
+
+    after { @server_thread&.kill }
+
+    it 'rejects all pending Promises when stop is called' do
+      @reactor = build_reactor
+      @reactor.start
+
+      promises = (1..5).map do |i|
+        p = RubyAsterisk::AMI::Promise.new(
+          action_id: "pend#{i}", command_type: 'Ping', timeout: 5
+        )
+        @reactor.register_promise("pend#{i}", p)
+        p
+      end
+
+      # Stop reactor while promises are still pending
+      @reactor.stop
+      @reactor.reject_all_promises(RuntimeError.new('Client disconnected'))
+
+      promises.each do |p|
+        expect { p.value(0.1) }.to raise_error(RuntimeError, /disconnected/i)
+      end
+    end
+  end
+end

data/spec/ruby-asterisk/ami_client_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ruby-asterisk/ami/client'
+require 'support/mock_ami_server'
+
+# Constant to avoid CollectionLiteralInLoop
+NEWLINES = ["\r\n", "\n"].freeze
+
+RSpec.describe RubyAsterisk::AMI::Client do
+  before do
+    # Start server that responds to Login and Ping
+    @server_thread, @port = MockAMIServer.start do |client|
+      buffer = +''
+      while (line = client.gets)
+        buffer << line
+        next unless NEWLINES.include?(line)
+
+        # Request complete
+        if buffer =~ /ActionID: (.*?)\s/
+          action_id = Regexp.last_match(1)
+          if buffer.include?('Action: Login')
+            client.print "Response: Success\r\nActionID: #{action_id}\r\nMessage: Authentication accepted\r\n\r\n"
+          elsif buffer.include?('Action: Ping')
+            client.print "Response: Success\r\nActionID: #{action_id}\r\nPing: Pong\r\n\r\n"
+          end
+        end
+        buffer.clear
+      end
+    end
+  end
+
+  after do
+    @server_thread&.kill
+  end
+
+  let(:client) { described_class.new(host: 'localhost', port: @port) }
+
+  describe '#connect' do
+    it 'connects successfully' do
+      expect(client.connect).to be true
+      expect(client.connected).to be true
+      client.disconnect
+    end
+  end
+
+  describe '#login' do
+    it 'logs in and returns a Promise that resolves to a successful Response' do
+      promise = client.login(username: 'admin', secret: 'secret')
+      expect(promise).to be_a(RubyAsterisk::AMI::Promise)
+      response = promise.value(2)
+      expect(response.success).to be true
+      client.disconnect
+    end
+  end
+
+  describe '#ping' do
+    it 'returns a Promise that resolves to a successful Response' do
+      client.connect
+      promise = client.ping
+      expect(promise).to be_a(RubyAsterisk::AMI::Promise)
+      response = promise.value(2)
+      expect(response).not_to be_nil
+      expect(response.success).to be true
+      client.disconnect
+    end
+  end
+end

data/spec/ruby-asterisk/ari/client_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'ruby-asterisk/error'
+require 'ruby-asterisk/ari/client'
+
+RSpec.describe RubyAsterisk::ARI::Client do
+  let(:base_url) { 'http://localhost:8088' }
+  let(:api_key) { 'asterisk_api_key' }
+  let(:app_name) { 'stasis_app' }
+
+  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
+  let(:test_conn) do
+    Faraday.new do |conn|
+      conn.adapter :test, stubs
+    end
+  end
+
+  subject(:client) { described_class.new(base_url, api_key, app_name) }
+
+  before do
+    client.instance_variable_set(:@connection, test_conn)
+  end
+
+  describe '#initialize' do
+    it 'stores base_url' do
+      expect(client.base_url).to eq(base_url)
+    end
+
+    it 'stores app_name' do
+      expect(client.app_name).to eq(app_name)
+    end
+  end
+
+  describe '#get' do
+    context 'when the request succeeds' do
+      before do
+        stubs.get('/ari/channels') do
+          [200, { 'Content-Type' => 'application/json' }, '[{"id":"12345"}]']
+        end
+      end
+
+      it 'returns parsed JSON' do
+        result = client.get('/ari/channels')
+        expect(result).to eq([{ 'id' => '12345' }])
+      end
+    end
+
+    context 'when the server returns 404' do
+      before do
+        stubs.get('/ari/channels/missing') do
+          [404, { 'Content-Type' => 'application/json' }, '{"message":"Channel not found"}']
+        end
+      end
+
+      it 'raises RubyAsterisk::Error' do
+        expect { client.get('/ari/channels/missing') }.to raise_error(RubyAsterisk::Error)
+      end
+    end
+
+    context 'when the server returns 500' do
+      before do
+        stubs.get('/ari/channels') do
+          [500, { 'Content-Type' => 'application/json' }, '{"message":"Internal Server Error"}']
+        end
+      end
+
+      it 'raises RubyAsterisk::Error' do
+        expect { client.get('/ari/channels') }.to raise_error(RubyAsterisk::Error)
+      end
+    end
+  end
+
+  describe '#post' do
+    context 'when the request succeeds' do
+      before do
+        stubs.post('/ari/channels') do
+          [200, { 'Content-Type' => 'application/json' }, '{"id":"new_channel"}']
+        end
+      end
+
+      it 'returns parsed JSON' do
+        result = client.post('/ari/channels', { endpoint: 'SIP/alice' })
+        expect(result).to eq({ 'id' => 'new_channel' })
+      end
+    end
+
+    context 'when the server returns 400' do
+      before do
+        stubs.post('/ari/channels') do
+          [400, { 'Content-Type' => 'application/json' }, '{"message":"Missing parameter"}']
+        end
+      end
+
+      it 'raises RubyAsterisk::Error with the server message' do
+        expect { client.post('/ari/channels', {}) }.to raise_error(RubyAsterisk::Error, 'Missing parameter')
+      end
+    end
+  end
+
+  describe '#delete' do
+    context 'when the request succeeds' do
+      before do
+        stubs.delete('/ari/channels/12345') do
+          [204, {}, '']
+        end
+      end
+
+      it 'returns nil for an empty body' do
+        result = client.delete('/ari/channels/12345')
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when the server returns 404' do
+      before do
+        stubs.delete('/ari/channels/missing') do
+          [404, { 'Content-Type' => 'application/json' }, '{"message":"Channel not found"}']
+        end
+      end
+
+      it 'raises RubyAsterisk::Error' do
+        expect { client.delete('/ari/channels/missing') }.to raise_error(RubyAsterisk::Error)
+      end
+    end
+  end
+
+  describe '#channels' do
+    it 'returns a Collection for Channel resources' do
+      expect(client.channels).to be_a(RubyAsterisk::ARI::Resources::Collection)
+    end
+  end
+
+  describe '#bridges' do
+    it 'returns a Collection for Bridge resources' do
+      expect(client.bridges).to be_a(RubyAsterisk::ARI::Resources::Collection)
+    end
+  end
+
+  describe '#playbacks' do
+    it 'returns a Collection for Playback resources' do
+      expect(client.playbacks).to be_a(RubyAsterisk::ARI::Resources::Collection)
+    end
+  end
+
+  describe '#endpoints' do
+    it 'returns a Collection for Endpoint resources' do
+      expect(client.endpoints).to be_a(RubyAsterisk::ARI::Resources::Collection)
+    end
+  end
+
+  describe '#asterisk_info' do
+    let(:info_payload) do
+      { 'build' => { 'os' => 'Linux' }, 'system' => { 'entity_id' => 'asterisk' } }.to_json
+    end
+
+    before do
+      stubs.get('/ari/asterisk/info') do
+        [200, { 'Content-Type' => 'application/json' }, info_payload]
+      end
+    end
+
+    it 'performs GET /ari/asterisk/info and returns parsed data' do
+      result = client.asterisk_info
+      expect(result).to be_a(Hash)
+      expect(result).to have_key('build')
+    end
+  end
+end

data/spec/ruby-asterisk/ari/resources/bridge_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ruby-asterisk/ari/client'
+
+RSpec.describe RubyAsterisk::ARI::Resources::Bridge do
+  let(:client) { instance_double(RubyAsterisk::ARI::Client) }
+  let(:data) { { 'id' => 'bridge-456' } }
+
+  subject(:bridge) { described_class.new(data, client) }
+
+  describe '#id' do
+    it 'returns the bridge id from data' do
+      expect(bridge.id).to eq('bridge-456')
+    end
+  end
+
+  describe '#add_channel' do
+    it 'posts to the addChannel endpoint with the channel id' do
+      body = { channel: 'channel-123' }
+      allow(client).to receive(:post).with('/ari/bridges/bridge-456/addChannel', body).and_return(nil)
+      bridge.add_channel('channel-123')
+      expect(client).to have_received(:post).with('/ari/bridges/bridge-456/addChannel', body)
+    end
+  end
+
+  describe '#remove_channel' do
+    it 'posts to the removeChannel endpoint with the channel id' do
+      body = { channel: 'channel-123' }
+      allow(client).to receive(:post).with('/ari/bridges/bridge-456/removeChannel', body).and_return(nil)
+      bridge.remove_channel('channel-123')
+      expect(client).to have_received(:post).with('/ari/bridges/bridge-456/removeChannel', body)
+    end
+  end
+
+  describe '#destroy' do
+    it 'deletes the bridge' do
+      allow(client).to receive(:delete).with('/ari/bridges/bridge-456').and_return(nil)
+      bridge.destroy
+      expect(client).to have_received(:delete).with('/ari/bridges/bridge-456')
+    end
+  end
+end

data/spec/ruby-asterisk/ari/resources/channel_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'ruby-asterisk/ari/client'
+
+RSpec.describe RubyAsterisk::ARI::Resources::Channel do
+  let(:client) { instance_double(RubyAsterisk::ARI::Client) }
+  let(:data) { { 'id' => 'channel-123' } }
+
+  subject(:channel) { described_class.new(data, client) }
+
+  describe '#id' do
+    it 'returns the channel id from data' do
+      expect(channel.id).to eq('channel-123')
+    end
+  end
+
+  describe '#ring' do
+    it 'posts to the ring endpoint' do
+      allow(client).to receive(:post).with('/ari/channels/channel-123/ring').and_return(nil)
+      channel.ring
+      expect(client).to have_received(:post).with('/ari/channels/channel-123/ring')
+    end
+  end
+
+  describe '#answer' do
+    it 'posts to the answer endpoint' do
+      allow(client).to receive(:post).with('/ari/channels/channel-123/answer').and_return(nil)
+      channel.answer
+      expect(client).to have_received(:post).with('/ari/channels/channel-123/answer')
+    end
+  end
+
+  describe '#hangup' do
+    it 'deletes the channel' do
+      allow(client).to receive(:delete).with('/ari/channels/channel-123').and_return(nil)
+      channel.hangup
+      expect(client).to have_received(:delete).with('/ari/channels/channel-123')
+    end
+  end
+
+  describe '#play' do
+    let(:expected_body) { { media: 'sound:hello-world' } }
+
+    it 'posts to the play endpoint with the media parameter' do
+      allow(client).to receive(:post).with('/ari/channels/channel-123/play', expected_body).and_return({})
+      channel.play('sound:hello-world')
+      expect(client).to have_received(:post).with('/ari/channels/channel-123/play', expected_body)
+    end
+
+    it 'merges additional params into the request body' do
+      body = { media: 'sound:hello-world', lang: 'en' }
+      allow(client).to receive(:post).with('/ari/channels/channel-123/play', body).and_return({})
+      channel.play('sound:hello-world', { lang: 'en' })
+      expect(client).to have_received(:post).with('/ari/channels/channel-123/play', body)
+    end
+  end
+end

data/spec/ruby-asterisk/ari/resources/collection_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'ruby-asterisk/ari/client'
+
+RSpec.describe RubyAsterisk::ARI::Resources::Collection do
+  let(:client) { instance_double(RubyAsterisk::ARI::Client) }
+  let(:resource_class) { RubyAsterisk::ARI::Resources::Channel }
+
+  subject(:collection) { described_class.new(resource_class, '/ari/channels', client) }
+
+  describe '#get' do
+    let(:channel_data) { { 'id' => 'channel-123' } }
+
+    before do
+      allow(client).to receive(:get).with('/ari/channels/channel-123').and_return(channel_data)
+    end
+
+    it 'fetches the resource by id' do
+      collection.get('channel-123')
+      expect(client).to have_received(:get).with('/ari/channels/channel-123')
+    end
+
+    it 'returns the resource wrapped in the correct class' do
+      result = collection.get('channel-123')
+      expect(result).to be_a(RubyAsterisk::ARI::Resources::Channel)
+    end
+
+    it 'passes the client to the resource' do
+      result = collection.get('channel-123')
+      expect(result.client).to eq(client)
+    end
+
+    it 'passes the data to the resource' do
+      result = collection.get('channel-123')
+      expect(result.data).to eq(channel_data)
+    end
+  end
+
+  describe '#list' do
+    let(:channels_data) { [{ 'id' => 'ch-1' }, { 'id' => 'ch-2' }] }
+
+    before do
+      allow(client).to receive(:get).with('/ari/channels', {}).and_return(channels_data)
+    end
+
+    it 'fetches the full list of resources' do
+      collection.list
+      expect(client).to have_received(:get).with('/ari/channels', {})
+    end
+
+    it 'returns an array of wrapped resources' do
+      result = collection.list
+      expect(result).to all(be_a(RubyAsterisk::ARI::Resources::Channel))
+    end
+
+    it 'returns the correct number of resources' do
+      expect(collection.list.size).to eq(2)
+    end
+
+    it 'accepts query params' do
+      allow(client).to receive(:get).with('/ari/channels', { state: 'Up' }).and_return(channels_data)
+      collection.list({ state: 'Up' })
+      expect(client).to have_received(:get).with('/ari/channels', { state: 'Up' })
+    end
+  end
+end