ruby-asterisk 0.1.0 → 1.0.0

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ruby-asterisk/ami/parser'
+
+RSpec.describe RubyAsterisk::AMI::Parser do
+  # Helper: push chunks into a buffer, drain, collect yielded messages.
+  def drain_chunks(*chunks)
+    buffer = +''
+    msgs   = []
+    chunks.each do |chunk|
+      buffer << chunk
+      described_class.drain(buffer) { |m| msgs << m }
+    end
+    msgs
+  end
+
+  # ── parse_headers ───────────────────────────────────────────────────────────
+
+  describe '.parse_headers' do
+    it 'parses key-value lines' do
+      raw = "Response: Success\r\nActionID: abc\r\nMessage: OK\r\n"
+      h = described_class.parse_headers(raw)
+      expect(h['Response']).to eq('Success')
+      expect(h['ActionID']).to eq('abc')
+      expect(h['Message']).to eq('OK')
+    end
+
+    it 'trims leading/trailing whitespace from values' do
+      h = described_class.parse_headers("Response: Success\r\nMessage:  hello world  \r\n")
+      expect(h['Message']).to eq('hello world')
+    end
+
+    it 'preserves colons inside values' do
+      h = described_class.parse_headers("Event: NewExten\r\nAppData: SIP/101:60\r\n")
+      expect(h['AppData']).to eq('SIP/101:60')
+    end
+
+    it 'skips lines without a colon separator (e.g. AMI welcome banner)' do
+      h = described_class.parse_headers("Asterisk Call Manager/1.1\nResponse: Success\r\n")
+      expect(h.keys).to eq(['Response'])
+    end
+
+    it 'returns a frozen hash with frozen keys and values' do
+      h = described_class.parse_headers("Response: OK\r\nActionID: x\r\n")
+      expect(h).to be_frozen
+      h.each_key   { |k| expect(k).to be_frozen }
+      h.each_value { |v| expect(v).to be_frozen }
+    end
+  end
+
+  # ── drain / split-packet reassembly ─────────────────────────────────────────
+
+  describe '.drain — split-packet reassembly' do
+    it 'assembles a Response split across two chunks' do
+      msgs = drain_chunks(
+        "Response: Success\r\nActionID: abc123\r\n",
+        "Message: OK\r\n\r\n"
+      )
+      expect(msgs.size).to eq(1)
+      expect(msgs.first[:type]).to eq(:response)
+      expect(msgs.first[:action_id]).to eq('abc123')
+      expect(msgs.first[:headers]['Message']).to eq('OK')
+    end
+
+    it 'assembles an Event split across three chunks' do
+      msgs = drain_chunks(
+        'Event: Han',
+        "gup\r\nChannel: SIP/",
+        "101\r\n\r\n"
+      )
+      expect(msgs.size).to eq(1)
+      expect(msgs.first[:type]).to eq(:event)
+      expect(msgs.first[:event].name).to eq('Hangup')
+      expect(msgs.first[:event].headers['Channel']).to eq('SIP/101')
+    end
+
+    it 'emits nothing until the delimiter arrives' do
+      msgs = drain_chunks("Response: Success\r\nActionID: xyz\r\n")
+      expect(msgs).to be_empty
+    end
+
+    it 'emits the message once the delimiter arrives' do
+      msgs = drain_chunks(
+        "Response: Success\r\nActionID: xyz\r\n",
+        "\r\n"
+      )
+      expect(msgs.size).to eq(1)
+    end
+  end
+
+  # ── multiple messages in one chunk ─────────────────────────────────────────
+
+  describe '.drain — multiple messages in one chunk' do
+    it 'emits all messages when two complete messages arrive together' do
+      two_msgs =
+        "Response: Success\r\nActionID: r1\r\n\r\n" \
+        "Event: FullyBooted\r\nPrivilege: system,all\r\nStatus: Fully Booted\r\n\r\n"
+
+      msgs = drain_chunks(two_msgs)
+      expect(msgs.size).to eq(2)
+      expect(msgs[0][:type]).to eq(:response)
+      expect(msgs[0][:action_id]).to eq('r1')
+      expect(msgs[1][:type]).to eq(:event)
+      expect(msgs[1][:event].name).to eq('FullyBooted')
+    end
+
+    it 'handles ten back-to-back events in a single chunk' do
+      chunk = (1..10).map { |i| "Event: TestEvent\r\nSequence: #{i}\r\n\r\n" }.join
+      msgs  = drain_chunks(chunk)
+      expect(msgs.size).to eq(10)
+      sequences = msgs.map { |m| m[:event].headers['Sequence'].to_i }
+      expect(sequences).to eq((1..10).to_a)
+    end
+  end
+
+  # ── Response routing ────────────────────────────────────────────────────────
+
+  describe 'response routing' do
+    it 'sets action_id from the ActionID header' do
+      msgs = drain_chunks("Response: Success\r\nActionID: myid\r\n\r\n")
+      expect(msgs.first[:action_id]).to eq('myid')
+    end
+
+    it 'sets action_id to nil when no ActionID header is present' do
+      msgs = drain_chunks("Response: Follows\r\nPrivilege: Command\r\n\r\n")
+      expect(msgs.first[:type]).to eq(:response)
+      expect(msgs.first[:action_id]).to be_nil
+    end
+
+    it 'exposes a frozen raw string' do
+      msgs = drain_chunks("Response: Error\r\nActionID: f2\r\n\r\n")
+      expect(msgs.first[:raw]).to be_frozen
+    end
+  end
+
+  # ── Event routing ───────────────────────────────────────────────────────────
+
+  describe 'event routing' do
+    it 'creates a frozen Event object with the correct name and headers' do
+      msgs = drain_chunks("Event: Hangup\r\nChannel: SIP/200\r\nCause: 16\r\n\r\n")
+      event = msgs.first[:event]
+      expect(event).to be_a(RubyAsterisk::AMI::Event)
+      expect(event).to be_frozen
+      expect(event.name).to eq('Hangup')
+      expect(event.headers['Cause']).to eq('16')
+    end
+
+    it 'Event object exposes the raw AMI message string' do
+      raw_input = "Event: Hangup\r\nChannel: SIP/200\r\n\r\n"
+      msgs = drain_chunks(raw_input)
+      expect(msgs.first[:event].raw).to eq(raw_input)
+    end
+  end
+
+  # ── AMI welcome banner tolerance ────────────────────────────────────────────
+
+  describe 'AMI welcome banner tolerance' do
+    it 'ignores the banner and still parses the subsequent response' do
+      combined =
+        "Asterisk Call Manager/1.1\n" \
+        "Response: Success\r\nActionID: banner_test\r\n\r\n"
+
+      msgs = drain_chunks(combined)
+      expect(msgs.size).to eq(1)
+      expect(msgs.first[:type]).to eq(:response)
+      expect(msgs.first[:action_id]).to eq('banner_test')
+    end
+  end
+
+  # ── build_message ────────────────────────────────────────────────────────────
+
+  describe '.build_message' do
+    it 'returns nil for frames with no recognised Response/Event header' do
+      expect(described_class.build_message("Asterisk Call Manager/1.1\r\n\r\n")).to be_nil
+    end
+
+    it 'returns a frozen response hash' do
+      msg = described_class.build_message("Response: OK\r\nActionID: x\r\n\r\n")
+      expect(msg).to be_frozen
+      expect(msg[:type]).to eq(:response)
+    end
+
+    it 'returns a frozen event hash' do
+      msg = described_class.build_message("Event: Hangup\r\n\r\n")
+      expect(msg).to be_frozen
+      expect(msg[:type]).to eq(:event)
+    end
+  end
+end

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