ruby-asterisk 0.1.0 → 1.0.0

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

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