switest 0.5.1 → 0.7.0

data/lib/switest/events.rb

@@ -1,85 +1,36 @@
 # frozen_string_literal: true
 
 module Switest
-  # Custom EventEmitter with guard support for conditional event handling.
-  # Supports hash equality, regex, array membership, and proc guards.
+  # Lightweight one-shot event emitter with guard support for conditional
+  # event handling. Supports hash equality, regex, array membership, and
+  # proc guards.
+  #
+  # Used for routing inbound call offers from Client to Agent.listen_for_call.
   class Events
     def initialize
       @handlers = Hash.new { |h, k| h[k] = [] }
-      @handler_id = 0
-      @mutex = Mutex.new
-    end
-
-    # Register a permanent event handler with optional guards
-    # @param event [Symbol] Event name
-    # @param guards [Hash] Guard conditions (hash equality, regex, array, or proc)
-    # @return [Integer] Handler ID for later removal
-    def on(event, guards = {}, &block)
-      @mutex.synchronize do
-        @handler_id += 1
-        @handlers[event] << {
-          id: @handler_id,
-          guards: guards,
-          callback: block,
-          once: false
-        }
-        @handler_id
-      end
     end
 
     # Register a one-time event handler with optional guards
-    # @param event [Symbol] Event name
-    # @param guards [Hash] Guard conditions
-    # @return [Integer] Handler ID
     def once(event, guards = {}, &block)
-      @mutex.synchronize do
-        @handler_id += 1
-        @handlers[event] << {
-          id: @handler_id,
-          guards: guards,
-          callback: block,
-          once: true
-        }
-        @handler_id
-      end
+      @handlers[event] << { guards: guards, callback: block }
     end
 
-    # Emit an event, triggering all matching handlers
-    # @param event [Symbol] Event name
-    # @param data [Hash] Event data to pass to handlers
+    # Emit an event, triggering and removing all matching handlers
     def emit(event, data = {})
-      handlers_to_call = []
-      handlers_to_remove = []
-
-      @mutex.synchronize do
-        @handlers[event].each do |handler|
-          if guards_match?(handler[:guards], data)
-            handlers_to_call << handler
-            handlers_to_remove << handler[:id] if handler[:once]
-          end
-        end
-      end
+      matched = []
+      remaining = []
 
-      handlers_to_call.each { |handler| handler[:callback].call(data) }
-
-      @mutex.synchronize do
-        handlers_to_remove.each do |id|
-          @handlers[event].reject! { |h| h[:id] == id }
-        end
-      end
-    end
-
-    # Remove handler(s) for an event
-    # @param event [Symbol] Event name
-    # @param handler_id [Integer, nil] Specific handler ID, or nil to remove all
-    def off(event, handler_id = nil)
-      @mutex.synchronize do
-        if handler_id
-          @handlers[event].reject! { |h| h[:id] == handler_id }
+      @handlers[event].each do |handler|
+        if guards_match?(handler[:guards], data)
+          matched << handler
         else
-          @handlers.delete(event)
+          remaining << handler
         end
       end
+
+      @handlers[event] = remaining
+      matched.each { |handler| handler[:callback].call(data) }
     end
 
     private

data/lib/switest/{esl/from_parser.rb → from_parser.rb}

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 module Switest
-  module ESL
-    # Parses a `from` string into FreeSWITCH channel variables,
+  # Parses a `from` string into FreeSWITCH channel variables,
     # replicating mod_rayo's parse_dial_from() behavior.
     #
     # Algorithm (matching mod_rayo):
@@ -100,6 +99,5 @@ module Switest
 
         vars
       end
-    end
   end
 end

data/lib/switest/scenario.rb

@@ -1,16 +1,24 @@
 # frozen_string_literal: true
 
 require "minitest/test"
-require "concurrent"
+require "async"
 
 module Switest
   class Scenario < Minitest::Test
+    include Assertions
+
     # Make Agent accessible to subclasses
     Agent = Switest::Agent
 
+    # Run each test inside an async reactor so that fibers, conditions,
+    # and async I/O work transparently for users extending Scenario.
+    def run(...)
+      Sync { super }
+    end
+
     def setup
       @events = Events.new
-      @client = ESL::Client.new
+      @client = Client.new
       @client.start
 
       # Route inbound calls through events system
@@ -20,7 +28,7 @@ module Switest
           from: call.from,
           call: call,
           headers: call.headers,
-          profile: call.headers["variable_sofia_profile_name"]
+          profile: call.headers[:variable_sofia_profile_name]
         })
       end
 
@@ -37,54 +45,5 @@ module Switest
     def hangup_all(cause: "NORMAL_CLEARING", timeout: 5)
       @client&.hangup_all(cause: cause, timeout: timeout)
     end
-
-    # Assertions
-    def assert_call(agent, timeout: 5)
-      success = agent.wait_for_call(timeout: timeout)
-      assert success, "Expected agent to receive a call within #{timeout} seconds"
-    end
-
-    def assert_no_call(agent, timeout: 2)
-      sleep timeout
-      refute agent.call?, "Expected agent to not have received a call"
-    end
-
-    def assert_answered(agent, timeout: 5)
-      assert agent.call?, "Agent has no call"
-      success = agent.wait_for_answer(timeout: timeout)
-      assert success, "Expected call to be answered within #{timeout} seconds"
-    end
-
-    def assert_bridged(agent, timeout: 5)
-      assert agent.call?, "Agent has no call"
-      success = agent.wait_for_bridge(timeout: timeout)
-      assert success, "Expected call to be bridged within #{timeout} seconds"
-    end
-
-    def assert_hungup(agent, timeout: 5)
-      assert agent.call?, "Agent has no call"
-      success = agent.wait_for_end(timeout: timeout)
-      assert success, "Expected call to be hung up within #{timeout} seconds"
-    end
-
-    def assert_not_hungup(agent, timeout: 2)
-      assert agent.call?, "Agent has no call"
-      sleep timeout
-      refute agent.ended?, "Expected call to still be active"
-    end
-
-    def assert_dtmf(agent, expected_dtmf, timeout: 5, after: 1, &block)
-      assert agent.call?, "Agent has no call"
-
-      if block
-        agent.flush_dtmf
-        Concurrent::ScheduledTask.execute(after) { block.call }
-        received = agent.receive_dtmf(count: expected_dtmf.length, timeout: timeout + after)
-      else
-        received = agent.receive_dtmf(count: expected_dtmf.length, timeout: timeout)
-      end
-
-      assert_equal expected_dtmf, received, "Expected DTMF '#{expected_dtmf}' but received '#{received}'"
-    end
   end
 end

data/lib/switest/session.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "librevox"
+require "async/promise"
+
+module Switest
+  # Inbound ESL session built on librevox.
+  #
+  # A single connection to FreeSWITCH that handles both commands and events
+  # (filtered by UUID). Events are dispatched to Call objects via the
+  # call_registry. Unknown CHANNEL_PARK events trigger the offer_handler for
+  # inbound call detection.
+  #
+  # Class-level state (call_registry, offer_handler, connection_promise) is used
+  # because librevox instantiates Session internally — we cannot inject
+  # dependencies via the constructor. Client sets these before starting the
+  # connection and clears them on stop.
+  class Session < Librevox::Listener::Inbound
+    class << self
+      attr_accessor :call_registry      # { uuid => Call }
+      attr_accessor :offer_handler      # Proc for inbound call offers
+      attr_accessor :connection_promise  # Async::Promise resolved when connected
+    end
+
+    def connection_completed
+      self.class.connection_promise&.resolve(self)
+    end
+
+    def on_event(event)
+      uuid = event.content[:unique_id]
+      call = self.class.call_registry&.[](uuid)
+
+      case event.event
+      when "CHANNEL_CALLSTATE", "CHANNEL_HANGUP_COMPLETE", "DTMF"
+        call&.handle_event(event)
+      when "CHANNEL_PARK"
+        if call
+          call.handle_event(event)
+        else
+          self.class.offer_handler&.call(event)
+        end
+      end
+    end
+
+    def bgapi(cmd)
+      send_message("bgapi #{cmd}")
+    end
+  end
+end

data/lib/switest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Switest
-  VERSION = "0.5.1"
+  VERSION = "0.7.0"
 end

data/lib/switest.rb

@@ -2,14 +2,14 @@
 
 require_relative "switest/version"
 require_relative "switest/configuration"
-require_relative "switest/case_insensitive_hash"
 require_relative "switest/events"
-require_relative "switest/esl/escaper"
-require_relative "switest/esl/event"
-require_relative "switest/esl/connection"
-require_relative "switest/esl/call"
-require_relative "switest/esl/client"
+require_relative "switest/escaper"
+require_relative "switest/from_parser"
+require_relative "switest/session"
+require_relative "switest/call"
+require_relative "switest/client"
 require_relative "switest/agent"
+require_relative "switest/assertions"
 require_relative "switest/scenario"
 
 module Switest

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switest
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Relatel A/S
@@ -11,19 +11,19 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby
+  name: librevox
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +56,15 @@ files:
 - README.md
 - lib/switest.rb
 - lib/switest/agent.rb
-- lib/switest/case_insensitive_hash.rb
+- lib/switest/assertions.rb
+- lib/switest/call.rb
+- lib/switest/client.rb
 - lib/switest/configuration.rb
-- lib/switest/esl/call.rb
-- lib/switest/esl/client.rb
-- lib/switest/esl/connection.rb
-- lib/switest/esl/escaper.rb
-- lib/switest/esl/event.rb
-- lib/switest/esl/from_parser.rb
+- lib/switest/escaper.rb
 - lib/switest/events.rb
+- lib/switest/from_parser.rb
 - lib/switest/scenario.rb
+- lib/switest/session.rb
 - lib/switest/version.rb
 homepage: https://github.com/relatel/switest
 licenses:

data/lib/switest/case_insensitive_hash.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Switest
-  # Hash subclass with case-insensitive key lookup
-  class CaseInsensitiveHash < Hash
-    def self.from(hash)
-      new.merge!(hash)
-    end
-
-    def [](key)
-      return super if key?(key)
-      key_downcase = key.downcase
-      found_key = keys.find { |k| k.downcase == key_downcase }
-      found_key ? super(found_key) : nil
-    end
-  end
-end

data/lib/switest/esl/call.rb

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent"
-
-module Switest
-  module ESL
-    class Call
-      attr_reader :id, :to, :from, :headers, :direction
-      attr_reader :start_time, :answer_time, :end_time, :end_reason
-      attr_reader :state
-
-      def initialize(id:, connection:, direction:, to: nil, from: nil, headers: {})
-        @id = id
-        @connection = connection
-        @direction = direction  # :inbound or :outbound
-        @to = to
-        @from = from
-        @headers = Switest::CaseInsensitiveHash.from(headers)
-
-        @state = :offered
-        @start_time = Time.now
-        @answer_time = nil
-        @end_time = nil
-        @end_reason = nil
-
-        @bridged = false
-        @dtmf_buffer = Queue.new
-        @callbacks = { answer: [], bridge: [], end: [] }
-        @mutex = Mutex.new
-
-        @answered_latch = Concurrent::CountDownLatch.new(1)
-        @bridged_latch = Concurrent::CountDownLatch.new(1)
-        @ended_latch = Concurrent::CountDownLatch.new(1)
-      end
-
-      # State queries
-      def alive?
-        @state != :ended
-      end
-
-      def active?
-        @state == :answered
-      end
-
-      def answered?
-        @state == :answered || (@state == :ended && @answer_time)
-      end
-
-      def ended?
-        @state == :ended
-      end
-
-      def bridged?
-        @bridged
-      end
-
-      def inbound?
-        @direction == :inbound
-      end
-
-      def outbound?
-        @direction == :outbound
-      end
-
-      # Actions
-      def answer(wait: 5)
-        return unless @state == :offered && inbound?
-        sendmsg("execute", "answer")
-        return unless wait
-        wait_for_answer(timeout: wait)
-      end
-
-      def hangup(cause = "NORMAL_CLEARING", wait: 5)
-        return if ended?
-        msg = +"sendmsg #{@id}\n"
-        msg << "call-command: hangup\n"
-        msg << "hangup-cause: #{cause}"
-        @connection.send_command(msg)
-        return unless wait
-        wait_for_end(timeout: wait)
-      end
-
-      def reject(reason = :decline, wait: 5)
-        return unless @state == :offered && inbound?
-        cause = case reason
-                when :busy then "USER_BUSY"
-                when :decline then "CALL_REJECTED"
-                else "CALL_REJECTED"
-                end
-        hangup(cause, wait: wait)
-      end
-
-      def play_audio(url, wait: true)
-        sendmsg("execute", "playback", url, event_lock: wait)
-      end
-
-      def send_dtmf(digits, wait: true)
-        play_audio("tone_stream://d=200;w=250;#{digits}", wait: wait)
-      end
-
-      def flush_dtmf
-        @dtmf_buffer.clear
-      end
-
-      def receive_dtmf(count: 1, timeout: 5)
-        digits = String.new
-        deadline = Time.now + timeout
-
-        count.times do
-          remaining = deadline - Time.now
-          break if remaining <= 0
-
-          begin
-            digit = @dtmf_buffer.pop(timeout: remaining)
-            digits << digit if digit
-          rescue ThreadError
-            break # Timeout
-          end
-        end
-
-        digits
-      end
-
-      # Callbacks
-      def on_answer(&block)
-        @mutex.synchronize { @callbacks[:answer] << block }
-      end
-
-      def on_bridge(&block)
-        @mutex.synchronize { @callbacks[:bridge] << block }
-      end
-
-      def on_end(&block)
-        @mutex.synchronize { @callbacks[:end] << block }
-      end
-
-      # Blocking waits
-      def wait_for_answer(timeout: 5)
-        @answered_latch.wait(timeout)
-        answered?
-      end
-
-      def wait_for_bridge(timeout: 5)
-        @bridged_latch.wait(timeout)
-        bridged?
-      end
-
-      def wait_for_end(timeout: 5)
-        @ended_latch.wait(timeout)
-        ended?
-      end
-
-      # Internal state updates (called by Client)
-      def handle_answer
-        @mutex.synchronize do
-          return if @state == :ended
-          @state = :answered
-          @answer_time = Time.now
-        end
-        @answered_latch.count_down
-        fire_callbacks(:answer)
-      end
-
-      def handle_bridge
-        @mutex.synchronize do
-          return if @state == :ended
-          @bridged = true
-        end
-        @bridged_latch.count_down
-        fire_callbacks(:bridge)
-      end
-
-      def handle_hangup(cause, headers = {})
-        @mutex.synchronize do
-          return if @state == :ended
-          @state = :ended
-          @end_time = Time.now
-          @end_reason = cause
-          @headers.merge!(headers)
-        end
-        @answered_latch.count_down  # Release any waiting threads
-        @bridged_latch.count_down
-        @ended_latch.count_down
-        fire_callbacks(:end)
-      end
-
-      def handle_dtmf(digit)
-        @dtmf_buffer.push(digit)
-      end
-
-      private
-
-      def sendmsg(command, app = nil, arg = nil, event_lock: false)
-        msg = +"sendmsg #{@id}\n"
-        msg << "call-command: #{command}\n"
-        msg << "execute-app-name: #{app}\n" if app
-        msg << "execute-app-arg: #{arg}\n" if arg
-        msg << "event-lock: true\n" if event_lock
-        @connection.send_command(msg.chomp)
-      end
-
-
-      def fire_callbacks(type)
-        callbacks = @mutex.synchronize { @callbacks[type].dup }
-        callbacks.each { |cb| cb.call(self) }
-      end
-    end
-  end
-end