GitLab

It is much easier for developers to refer to different states via constants defined on CallBehaviour.

this is the first step towards eliminating call state from client code, such as openvoice.
eventually developer to be able to query call_behaviour or some similar concept, such as call, for its states.

disabld end-to-end test until we resolve leaking prism session issue - now ci build should not break for running out of license

Basically taking James M.'s oo-branch by delegating parsing of presence to subclasses (such as Hangup, Offer, etc.).

I've added parsing for RecordingHangupComplete event and corrected some missing :from parameters.  Also corrected a bug in parsing offer where presence_from and presence_to were overrode by super.

Now we can almost get rid of Rayo::Parser class.

Invoking #incoming with a set of arguments that include one or more nils can cause odd problems: if the call jid is nil, for example, then the event might not be handled by the handler.  Failing fast should prevent these simple mistakes from slipping through the net.

The examples weren't realistic because the call wasn't being answered before it was being acted upon.

The previous incarnation of the test wasn't doing what was intended.  It was stuck waiting for a result from the answer command because the call_jid of the handler didn't match the call_jid of the answer result iq.  In addition, the expectation that hangup shouldn't be called *at all* was incorrect: we actually expect it to be called *once*.

* We have to answer the call before we can record it.
* I aliased recording_result_iq as component_result_iq to remove a little duplication.
* I introduced recording_stop_result_iq to make the record_call_spec tests a little clearer.

*NOTE* I replaced another 'result_iq' with 'answer_result_iq' that should've been replaced in 73cfe452.

Sending a 'stop' command to a 'say' component that's already finished causes all subsequent commands to fail.

We can avoid this by tracking which components are 'active', by storing IDs when they start and removing them when we receive the event that indicates they finish. Any stop command for a component which is no longer active is ignored.

This is significant when you want to 'stop' the say command.

There may be other instances in Connfu (and other projects) where we have used a `result_iq` instead of a proper `say_result_iq`; we'll investigate this in a separate commit.

We suspect that this should be true of *any* hangup event, but this specific need was driven from Openvoice.

Since the `presence_from` attribute of the recording hangup contains the recording component ID, we need to make the call jid recognition in `finish!` a bit more sophisticated.

It's worth noting that any projects testing code that uses a timeout on `wait_for` will need to stub `EM.add_timer` using their mocking framework of choice.

Instead of calling continue on a handler instance directly (which is hard to reach in tests), we now have the handler watch for "Timeout" pseudo-events, which are far easier to send to the handler (e.g. via `Connfu.event_processor.handle_event`).

Previously, record_for only wait_for RecordingStopComplete event and does not return if hangup occurs before maximum length is reached.  It is now wait_for RecordingHangupComplete event as well.

Otherwise, despite the script having already continued, the timer block would fire and we'd continue arbitrarily. Kaboom!

Merge branch 'master' of github.com:zlu/play

We're using EventMachine.add_timer which provides a single-shot mechanism for executing a block after a given elapsed time.

When the timeout occurs execution will continue with the `wait_for` method returning `nil`.

We need this in Openvoice because we will need to implement round-robin dialling ourselves; Tropo/Rayo does not provide a built-in mechanism for timing-out dialled calls that have not answered.

The first of these assertions was not testing anything, because both sides of the assertion were nil.

It's better to use string literals in the expected values rather than repeating the implementation in the test.

We created a need for this in e4322700, but didn't test it. Sozzo.