Add tests for stasis_broadcast modules

Tests parallel broadcast to multiple ARI applications and verifies
first-claim-wins semantics, CallBroadcast and CallClaimed event
generation, and proper channel control transfer to the claiming app.

The test:
- Originates a channel that calls StasisBroadcast()
- Verifies CallBroadcast event is sent to multiple apps
- Claims the channel via POST /ari/events/claim
- Verifies CallClaimed event is sent
- Confirms channel enters Stasis in the claiming app"

Author: danieldonoghue

tests/rest_api/stasis_broadcast/configs/extensions.conf

@@ -0,0 +1,4 @@
+[default]
+exten => broadcast,1,NoOp()
+    same => n,StasisBroadcast(,5000)
+    same => n,Hangup()

tests/rest_api/stasis_broadcast/run-test

@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+'''Test Stasis broadcast and claim functionality'''
+
+import sys
+import logging
+
+sys.path.append("lib/python")
+
+from twisted.internet import reactor
+from asterisk.test_case import TestCase
+
+LOGGER = logging.getLogger(__name__)
+
+TEST_TIMEOUT = 30
+
+
+class StasisBroadcastTest(TestCase):
+    """Test case for Stasis broadcast functionality"""
+
+    def __init__(self):
+        """Constructor"""
+        super(StasisBroadcastTest, self).__init__()
+        self.broadcast_received = False
+        self.claim_received = False
+        self.channel_id = None
+        self.create_asterisk()
+
+    def ami_connect(self, ami):
+        """Called when AMI connects - originate the test call"""
+        super(StasisBroadcastTest, self).ami_connect(ami)
+
+        LOGGER.info("AMI connected, originating call")
+        ami.originate(
+            channel="Local/broadcast@default",
+            application="Echo"
+        ).addErrback(self.handle_originate_failure)
+
+    def ari_on_start(self, event):
+        """Called when a StasisStart event is received"""
+        LOGGER.info("StasisStart received: %s" % event)
+        self.channel_id = event['channel']['id']
+        # Test passes when we get StasisStart after claim
+        if self.claim_received:
+            LOGGER.info("Test complete - channel entered Stasis after claim")
+            self.stop_reactor()
+
+    def ari_on_broadcast(self, event):
+        """Called when a CallBroadcast event is received"""
+        LOGGER.info("CallBroadcast received: %s" % event)
+        self.broadcast_received = True
+        self.channel_id = event['channel']['id']
+
+        # Attempt to claim the channel via POST /ari/events/claim
+        ari = self.ari.userDefines['app']
+        d = ari.post('events', 'claim',
+                     channel_id=self.channel_id,
+                     app='testsuite-app1')
+        d.addCallback(self.claim_success)
+        d.addErrback(self.claim_failure)
+
+    def ari_on_claimed(self, event):
+        """Called when a CallClaimed event is received"""
+        LOGGER.info("CallClaimed received: %s" % event)
+        self.claim_received = True
+        # Wait for StasisStart to arrive after claim
+
+    def claim_success(self, result):
+        """Claim succeeded"""
+        LOGGER.info("Claim request succeeded")
+
+    def claim_failure(self, reason):
+        """Claim failed"""
+        LOGGER.error("Claim request failed: %s" % reason)
+        self.stop_reactor()
+
+    def handle_originate_failure(self, reason):
+        """Called if originate fails"""
+        LOGGER.error("Originate failed: %s" % reason)
+        self.stop_reactor()
+
+    def run(self):
+        """Run the test"""
+        super(StasisBroadcastTest, self).run()
+        self.create_ami_factory()
+
+        # Set timeout
+        reactor.callLater(TEST_TIMEOUT, self.timeout_test)
+
+    def timeout_test(self):
+        """Called if test times out"""
+        LOGGER.error("Test timed out")
+        self.stop_reactor()
+
+
+def main():
+    """Main entry point"""
+    test = StasisBroadcastTest()
+    test.start_asterisk()
+    reactor.run()
+    test.stop_asterisk()
+
+    if not test.passed:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main() or 0)

tests/rest_api/stasis_broadcast/test-config.yaml

@@ -0,0 +1,57 @@
+testinfo:
+    summary: 'Test Stasis broadcast and claim functionality'
+    description: |
+        Tests that channels can be broadcast to multiple ARI applications
+        and that first-claim-wins semantics work correctly. Verifies
+        CallBroadcast and CallClaimed events are generated.
+
+test-modules:
+    test-object:
+        config-section: test-object-config
+        typename: 'ari.AriOriginateTestObject'
+    modules:
+        -
+            config-section: ari-config
+            typename: 'ari.WebSocketEventModule'
+
+test-object-config:
+    stop-on-end: False
+
+ari-config:
+    apps: 'testsuite-app1,testsuite-app2'
+    events:
+        -
+            conditions:
+                match:
+                    type: 'StasisStart'
+                    application: 'testsuite-app1'
+            count: 0
+        -
+            conditions:
+                match:
+                    type: 'CallBroadcast'
+            count: '>0'
+        -
+            conditions:
+                match:
+                    type: 'CallClaimed'
+            count: 1
+        -
+            conditions:
+                match:
+                    type: 'StasisStart'
+            count: 1
+
+properties:
+    dependencies:
+        - python: 'autobahn.websocket'
+        - python: 'requests'
+        - python: 'twisted'
+        - python: 'starpy'
+        - asterisk: 'res_ari_channels'
+        - asterisk: 'res_ari_events'
+        - asterisk: 'res_stasis_broadcast'
+        - asterisk: 'app_stasis_broadcast'
+    tags:
+        - ARI
+        - stasis