ruby-asterisk 0.2.0 → 1.0.0

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'ruby-asterisk/ari/client'
+
+RSpec.describe RubyAsterisk::ARI::Resources::Endpoint do
+  let(:client) { instance_double(RubyAsterisk::ARI::Client) }
+  let(:data) do
+    { 'technology' => 'SIP', 'resource' => 'alice', 'state' => 'online' }
+  end
+
+  subject(:endpoint) { described_class.new(data, client) }
+
+  describe '#technology' do
+    it 'returns the technology from data' do
+      expect(endpoint.technology).to eq('SIP')
+    end
+  end
+
+  describe '#resource' do
+    it 'returns the resource from data' do
+      expect(endpoint.resource).to eq('alice')
+    end
+  end
+
+  describe '#state' do
+    it 'returns the state from data' do
+      expect(endpoint.state).to eq('online')
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'ruby-asterisk/ari/client'
+
+RSpec.describe RubyAsterisk::ARI::Resources::Playback do
+  let(:client) { instance_double(RubyAsterisk::ARI::Client) }
+  let(:data) { { 'id' => 'playback-789' } }
+
+  subject(:playback) { described_class.new(data, client) }
+
+  describe '#id' do
+    it 'returns the playback id from data' do
+      expect(playback.id).to eq('playback-789')
+    end
+  end
+
+  describe '#stop' do
+    it 'deletes the playback' do
+      allow(client).to receive(:delete).with('/ari/playbacks/playback-789').and_return(nil)
+      playback.stop
+      expect(client).to have_received(:delete).with('/ari/playbacks/playback-789')
+    end
+  end
+
+  describe '#control' do
+    it 'posts the operation to the control endpoint' do
+      body = { operation: 'pause' }
+      allow(client).to receive(:post).with('/ari/playbacks/playback-789/control', body).and_return(nil)
+      playback.control('pause')
+      expect(client).to have_received(:post).with('/ari/playbacks/playback-789/control', body)
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/mock_ari_websocket_server'
+
+RSpec.describe RubyAsterisk::ARI::WebSocket, 'integration' do
+  let(:server) { MockAriWebSocketServer.new }
+  let(:base_url) { "http://127.0.0.1:#{server.port}" }
+  let(:logger) { Logger.new(File::NULL) }
+
+  after do
+    @websocket&.disconnect
+    server.stop
+  end
+
+  def connect(options = {})
+    opened = Queue.new
+    defaults = { logger: logger, reconnect_delay: 0.1 }
+    @websocket = described_class.new(base_url, 'api_key', 'test_app', defaults.merge(options))
+    yield @websocket if block_given?
+    @websocket.connect { opened << true }
+    MockAriWebSocketServer.pop(opened)
+    @websocket
+  end
+
+  it 'completes the handshake and fires the on_connect callback' do
+    websocket = connect
+
+    expect(websocket.connected?).to be(true)
+  end
+
+  it 'dispatches server events to registered callbacks' do
+    received = Queue.new
+    connect { |ws| ws.on('StasisStart') { |data| received << data } }
+
+    server.broadcast('type' => 'StasisStart', 'channel' => { 'id' => '42' })
+
+    event = MockAriWebSocketServer.pop(received)
+    expect(event).to eq('type' => 'StasisStart', 'channel' => { 'id' => '42' })
+  end
+
+  it 'sends messages to the server' do
+    websocket = connect
+
+    expect(websocket.send_message?({ 'type' => 'ping' })).to be(true)
+    expect(MockAriWebSocketServer.pop(server.messages)).to eq('{"type":"ping"}')
+  end
+
+  it 'sends pings at the configured interval' do
+    connect(ping_interval: 0.1)
+
+    expect(MockAriWebSocketServer.pop(server.pings)).not_to be_nil
+  end
+
+  it 'reconnects automatically after a connection drop' do
+    received = Queue.new
+    connect { |ws| ws.on('StasisStart') { |data| received << data } }
+    MockAriWebSocketServer.pop(server.connections) # first handshake
+
+    server.drop_clients
+    MockAriWebSocketServer.pop(server.connections) # second handshake
+
+    server.broadcast('type' => 'StasisStart')
+    expect(MockAriWebSocketServer.pop(received)).to eq('type' => 'StasisStart')
+  end
+
+  it 'does not reconnect when auto_reconnect is disabled' do
+    websocket = connect(auto_reconnect: false)
+    thread = websocket.instance_variable_get(:@connection_thread)
+
+    server.drop_clients
+
+    expect(thread.join(2)).to eq(thread)
+    expect(websocket.connected?).to be(false)
+  end
+
+  it 'stops cleanly on disconnect' do
+    websocket = connect
+    thread = websocket.instance_variable_get(:@connection_thread)
+
+    websocket.disconnect
+
+    expect(websocket.connected?).to be(false)
+    expect(thread.alive?).to be(false)
+  end
+end

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

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubyAsterisk::ARI::WebSocket do
+  let(:base_url) { 'http://localhost:8088' }
+  let(:api_key) { 'asterisk_api_key' }
+  let(:app_name) { 'stasis_app' }
+  let(:logger) { instance_double(Logger, info: nil, warn: nil, error: nil, debug: nil) }
+
+  subject(:websocket) { described_class.new(base_url, api_key, app_name, logger: logger) }
+
+  describe '#initialize' do
+    it 'sets the base_url' do
+      expect(websocket.instance_variable_get(:@base_url)).to eq(base_url)
+    end
+
+    it 'sets the app_name' do
+      expect(websocket.app_name).to eq(app_name)
+    end
+
+    it 'initializes callbacks as empty hash' do
+      expect(websocket.callbacks).to eq({})
+    end
+
+    it 'sets connected to false' do
+      expect(websocket.connected).to be(false)
+    end
+
+    it 'sets auto_reconnect to true by default' do
+      expect(websocket.instance_variable_get(:@should_reconnect)).to be(true)
+    end
+
+    it 'allows disabling auto_reconnect' do
+      ws = described_class.new(base_url, api_key, app_name, auto_reconnect: false)
+      expect(ws.instance_variable_get(:@should_reconnect)).to be(false)
+    end
+
+    it 'uses default ping interval' do
+      expect(websocket.instance_variable_get(:@ping_interval)).to eq(described_class::PING_INTERVAL)
+    end
+
+    it 'allows custom ping interval' do
+      ws = described_class.new(base_url, api_key, app_name, ping_interval: 60)
+      expect(ws.instance_variable_get(:@ping_interval)).to eq(60)
+    end
+  end
+
+  describe '#on' do
+    it 'registers a callback for an event type' do
+      callback = proc { |data| puts data }
+      websocket.on('StasisStart', &callback)
+
+      expect(websocket.callbacks['StasisStart']).to include(callback)
+    end
+
+    it 'allows multiple callbacks for the same event' do
+      callback1 = proc { |data| puts data }
+      callback2 = proc { |data| puts data }
+
+      websocket.on('StasisStart', &callback1)
+      websocket.on('StasisStart', &callback2)
+
+      expect(websocket.callbacks['StasisStart']).to include(callback1, callback2)
+    end
+
+    it 'converts symbol event types to strings' do
+      callback = proc { |data| puts data }
+      websocket.on(:StasisStart, &callback)
+
+      expect(websocket.callbacks['StasisStart']).to include(callback)
+    end
+
+    it 'returns self for method chaining' do
+      result = websocket.on('StasisStart') { |data| puts data }
+      expect(result).to eq(websocket)
+    end
+  end
+
+  describe '#connected?' do
+    context 'when not connected' do
+      it 'returns false' do
+        expect(websocket.connected?).to be(false)
+      end
+    end
+
+    context 'when connected flag is true but no driver' do
+      before do
+        websocket.instance_variable_set(:@connected, true)
+      end
+
+      it 'returns false' do
+        expect(websocket.connected?).to be(false)
+      end
+    end
+
+    context 'when connected with an open driver' do
+      let(:driver) { instance_double(WebSocket::Driver::Client, state: :open) }
+
+      before do
+        websocket.instance_variable_set(:@connected, true)
+        websocket.instance_variable_set(:@driver, driver)
+      end
+
+      it 'returns true' do
+        expect(websocket.connected?).to be(true)
+      end
+    end
+  end
+
+  describe '#send_message?' do
+    context 'when not connected' do
+      it 'returns false' do
+        expect(websocket.send_message?('test')).to be(false)
+      end
+    end
+
+    context 'when connected' do
+      let(:driver) { instance_double(WebSocket::Driver::Client, state: :open, text: true) }
+
+      before do
+        websocket.instance_variable_set(:@connected, true)
+        websocket.instance_variable_set(:@driver, driver)
+      end
+
+      it 'sends string message' do
+        websocket.send_message?('test message')
+        expect(driver).to have_received(:text).with('test message')
+      end
+
+      it 'converts hash to JSON' do
+        websocket.send_message?({ type: 'test', data: 'value' })
+        expect(driver).to have_received(:text).with('{"type":"test","data":"value"}')
+      end
+
+      it 'returns true' do
+        expect(websocket.send_message?('test')).to be(true)
+      end
+
+      it 'returns false when the write raises IOError' do
+        allow(driver).to receive(:text).and_raise(IOError)
+        expect(websocket.send_message?('test')).to be(false)
+      end
+    end
+  end
+
+  describe '#disconnect' do
+    let(:driver) { instance_double(WebSocket::Driver::Client, state: :open, close: nil) }
+    let(:socket) { instance_double(TCPSocket, close: nil) }
+
+    before do
+      websocket.instance_variable_set(:@driver, driver)
+      websocket.instance_variable_set(:@socket, socket)
+      websocket.instance_variable_set(:@connected, true)
+    end
+
+    it 'sets should_reconnect to false' do
+      websocket.disconnect
+      expect(websocket.instance_variable_get(:@should_reconnect)).to be(false)
+    end
+
+    it 'stops the ping timer' do
+      websocket.disconnect
+      expect(websocket.instance_variable_get(:@ping_token)).to be_nil
+      expect(websocket.instance_variable_get(:@ping_thread)).to be_nil
+    end
+
+    it 'sends a close frame' do
+      websocket.disconnect
+      expect(driver).to have_received(:close)
+    end
+
+    it 'closes the socket' do
+      websocket.disconnect
+      expect(socket).to have_received(:close)
+    end
+
+    it 'sets connected to false' do
+      websocket.disconnect
+      expect(websocket.connected).to be(false)
+    end
+
+    it 'logs disconnection' do
+      websocket.disconnect
+      expect(logger).to have_received(:info).with('WebSocket disconnected')
+    end
+
+    it 'returns self' do
+      expect(websocket.disconnect).to eq(websocket)
+    end
+  end
+
+  describe 'private #build_url' do
+    it 'builds WebSocket URL with ws scheme for http' do
+      url = websocket.send(:build_url)
+      expect(url).to eq("ws://#{api_key}:@localhost:8088/ari/events?app=#{app_name}")
+    end
+
+    it 'builds WebSocket URL with wss scheme for https' do
+      ws = described_class.new('https://localhost:8089', api_key, app_name)
+      url = ws.send(:build_url)
+      expect(url).to eq("wss://#{api_key}:@localhost:8089/ari/events?app=#{app_name}")
+    end
+
+    it 'includes app name in query string' do
+      url = websocket.send(:build_url)
+      expect(url).to include("app=#{app_name}")
+    end
+  end
+
+  describe 'private #dispatch_event' do
+    let(:event_data) { { 'type' => 'StasisStart', 'channel' => { 'id' => '123' } } }
+
+    it 'calls registered callback for event type' do
+      called = false
+      received_data = nil
+
+      websocket.on('StasisStart') do |data|
+        called = true
+        received_data = data
+      end
+
+      websocket.send(:dispatch_event, 'StasisStart', event_data)
+
+      expect(called).to be(true)
+      expect(received_data).to eq(event_data)
+    end
+
+    it 'calls multiple callbacks for the same event' do
+      call_count = 0
+
+      websocket.on('StasisStart') { call_count += 1 }
+      websocket.on('StasisStart') { call_count += 1 }
+
+      websocket.send(:dispatch_event, 'StasisStart', event_data)
+
+      expect(call_count).to eq(2)
+    end
+
+    it 'calls wildcard callbacks for any event' do
+      called = false
+      received_data = nil
+
+      websocket.on('*') do |data|
+        called = true
+        received_data = data
+      end
+
+      websocket.send(:dispatch_event, 'StasisStart', event_data)
+
+      expect(called).to be(true)
+      expect(received_data).to eq(event_data)
+    end
+
+    it 'logs errors in callbacks but does not raise' do
+      websocket.on('StasisStart') { raise 'Callback error' }
+
+      expect { websocket.send(:dispatch_event, 'StasisStart', event_data) }.not_to raise_error
+      expect(logger).to have_received(:error).with(/Error in event handler/)
+    end
+
+    it 'does not call callbacks for different event types' do
+      called = false
+      websocket.on('ChannelHangup') { called = true }
+
+      websocket.send(:dispatch_event, 'StasisStart', event_data)
+
+      expect(called).to be(false)
+    end
+  end
+
+  describe 'private #handle_message' do
+    let(:event_json) { '{"type":"StasisStart","channel":{"id":"123"}}' }
+    let(:event) { double('WebSocket::Driver::MessageEvent', data: event_json) }
+
+    it 'parses JSON and dispatches event' do
+      called = false
+      websocket.on('StasisStart') { called = true }
+
+      websocket.send(:handle_message, event)
+
+      expect(called).to be(true)
+    end
+
+    it 'logs received event' do
+      websocket.send(:handle_message, event)
+      expect(logger).to have_received(:debug).with('Received event: StasisStart')
+    end
+
+    it 'logs error for invalid JSON' do
+      invalid_event = double('WebSocket::Driver::MessageEvent', data: 'invalid json')
+
+      websocket.send(:handle_message, invalid_event)
+
+      expect(logger).to have_received(:error).with(/Failed to parse message/)
+    end
+  end
+
+  describe 'private #handle_open' do
+    let(:driver) { instance_double(WebSocket::Driver::Client) }
+    let(:connect_callback) { proc { |ws| } }
+
+    before do
+      websocket.instance_variable_set(:@driver, driver)
+      websocket.instance_variable_set(:@on_connect_callback, connect_callback)
+      allow(websocket).to receive(:start_ping_timer)
+    end
+
+    it 'sets connected to true' do
+      websocket.send(:handle_open)
+      expect(websocket.connected).to be(true)
+    end
+
+    it 'resets reconnect attempts' do
+      websocket.instance_variable_set(:@reconnect_attempts, 5)
+      websocket.send(:handle_open)
+      expect(websocket.instance_variable_get(:@reconnect_attempts)).to eq(0)
+    end
+
+    it 'logs successful connection' do
+      websocket.send(:handle_open)
+      expect(logger).to have_received(:info).with('WebSocket connected successfully')
+    end
+
+    it 'starts ping timer' do
+      websocket.send(:handle_open)
+      expect(websocket).to have_received(:start_ping_timer)
+    end
+
+    it 'calls on_connect callback' do
+      expect(connect_callback).to receive(:call).with(websocket)
+      websocket.send(:handle_open)
+    end
+  end
+
+  describe 'private #handle_close' do
+    let(:event) { double('WebSocket::Driver::CloseEvent', code: 1000, reason: 'Normal closure') }
+
+    before do
+      websocket.instance_variable_set(:@connected, true)
+      allow(websocket).to receive(:stop_ping_timer)
+      allow(websocket).to receive(:close_socket)
+    end
+
+    it 'sets connected to false' do
+      websocket.send(:handle_close, event)
+      expect(websocket.connected).to be(false)
+    end
+
+    it 'stops ping timer' do
+      websocket.send(:handle_close, event)
+      expect(websocket).to have_received(:stop_ping_timer)
+    end
+
+    it 'logs close event' do
+      websocket.send(:handle_close, event)
+      expect(logger).to have_received(:warn).with(/WebSocket closed/)
+    end
+
+    it 'closes the socket so the read loop unblocks' do
+      websocket.send(:handle_close, event)
+      expect(websocket).to have_received(:close_socket)
+    end
+  end
+
+  describe 'private #handle_error' do
+    let(:event) { double('WebSocket::Driver::ProtocolError', message: 'Connection failed') }
+
+    it 'logs error message' do
+      websocket.send(:handle_error, event)
+      expect(logger).to have_received(:error).with('WebSocket error: Connection failed')
+    end
+  end
+end

data/spec/ruby-asterisk/immutability_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Immutability of value objects' do
+  describe RubyAsterisk::Request do
+    subject { RubyAsterisk::Request.new('Originate', { 'Channel' => '1234', 'Context' => 'test' }) }
+
+    it 'is frozen' do
+      subject.should be_frozen
+    end
+
+    it 'has a frozen action' do
+      subject.action.should be_frozen
+    end
+
+    it 'has a frozen action_id' do
+      subject.action_id.should be_frozen
+    end
+
+    it 'has a frozen parameters hash' do
+      subject.parameters.should be_frozen
+    end
+
+    it 'has frozen parameter keys and values' do
+      subject.parameters.each do |key, value|
+        key.should be_frozen
+        value.should be_frozen
+      end
+    end
+
+    it 'raises FrozenError when attempting to modify instance variables' do
+      -> { subject.instance_variable_set(:@action, 'Login') }.should raise_error(FrozenError)
+    end
+
+    it 'raises FrozenError when attempting to modify parameters' do
+      -> { subject.parameters['NewKey'] = 'val' }.should raise_error(FrozenError)
+    end
+
+    it 'does not expose writer methods' do
+      subject.respond_to?(:action=).should be false
+      subject.respond_to?(:parameters=).should be false
+      subject.respond_to?(:action_id=).should be false
+    end
+
+    it 'does not expose response_data' do
+      subject.respond_to?(:response_data).should be false
+      subject.respond_to?(:response_data=).should be false
+    end
+  end
+
+  describe RubyAsterisk::Response do
+    let(:raw_response) do
+      "Response: Success\nActionID: 123\nMessage: Authentication accepted\n\n"
+    end
+    subject { RubyAsterisk::Response.new('Login', raw_response) }
+
+    it 'is frozen' do
+      subject.should be_frozen
+    end
+
+    it 'has a frozen type' do
+      subject.type.should be_frozen
+    end
+
+    it 'has a frozen action_id' do
+      subject.action_id.should be_frozen
+    end
+
+    it 'has a frozen message' do
+      subject.message.should be_frozen
+    end
+
+    it 'has a frozen raw_response' do
+      subject.raw_response.should be_frozen
+      subject.raw_response.each do |element|
+        element.should be_frozen
+      end
+    end
+
+    it 'has frozen data' do
+      subject.data.should be_frozen
+    end
+
+    it 'raises FrozenError when attempting to modify instance variables' do
+      -> { subject.instance_variable_set(:@type, 'Other') }.should raise_error(FrozenError)
+    end
+
+    it 'does not expose writer methods' do
+      subject.respond_to?(:type=).should be false
+      subject.respond_to?(:action_id=).should be false
+      subject.respond_to?(:message=).should be false
+      subject.respond_to?(:data=).should be false
+      subject.respond_to?(:raw_response=).should be false
+    end
+
+    context 'with parsed data containing nested structures' do
+      let(:raw_response) do
+        "Event: CoreShowChannel\nActionID: 839\nChannel: SIP/test\nCallerIDnum: 123\n\n" \
+          "Event: CoreShowChannelsComplete\nActionID: 839\n\n"
+      end
+      subject { RubyAsterisk::Response.new('CoreShowChannels', raw_response) }
+
+      it 'has deeply frozen data structures' do
+        subject.data.should be_frozen
+        subject.data[:channels].should be_frozen
+        subject.data[:channels].each do |channel|
+          channel.should be_frozen
+          channel.each do |key, value|
+            key.should be_frozen
+            value.should be_frozen
+          end
+        end
+      end
+
+      it 'raises FrozenError when attempting to modify nested data' do
+        -> { subject.data[:channels] << {} }.should raise_error(FrozenError)
+      end
+    end
+  end
+
+  describe RubyAsterisk::ResponseBuilder do
+    it 'builds a frozen Response' do
+      builder = RubyAsterisk::ResponseBuilder.new
+      builder.type = 'Login'
+      builder.raw_response = "Response: Success\nActionID: 123\n\n"
+      response = builder.build
+      response.should be_frozen
+    end
+
+    it 'raises ArgumentError when type is missing' do
+      builder = RubyAsterisk::ResponseBuilder.new
+      builder.raw_response = "Response: Success\n\n"
+      -> { builder.build }.should raise_error(ArgumentError, 'type is required')
+    end
+
+    it 'raises ArgumentError when raw_response is missing' do
+      builder = RubyAsterisk::ResponseBuilder.new
+      builder.type = 'Login'
+      -> { builder.build }.should raise_error(ArgumentError, 'raw_response is required')
+    end
+
+    it 'is not frozen itself' do
+      builder = RubyAsterisk::ResponseBuilder.new
+      builder.should_not be_frozen
+    end
+  end
+end