twilio-test-toolkit-alt 3.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c73f30d2fade63714f50f0756b88fd508a9dcba4
+  data.tar.gz: 43b953b75d0478315ca8fe526193792fb22c8087
+SHA512:
+  metadata.gz: 14e466adab316ebb363c53746af1641fe6e9310316f64357910369becb3800763f6a9c01ed5ab8851e58d383f23664c979cd8ea7c0360efd51988acc132bff8a
+  data.tar.gz: daac1ceb3d2906f5170bd7078f2238bab695f086fd0822003b65c1051902392b7273a661b91977e34138a48b470d49d751ab60410e8460d00cc7c081b234b3e4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,265 @@
+twilio-test-toolkit
+===================
+
+Twilio Test Toolkit (TTT) makes RSpec integration tests for Twilio phone callbacks easy to write and understand.
+
+When you initiate a [phone call with Twilio](http://www.twilio.com/docs/api/rest/making-calls), you must POST either a URL or an ApplicationSid that is configured with a URL. Twilio then POSTs to your URL, and you're expected to return a 200 OK and a valid [TwiML](http://www.twilio.com/docs/api/twiml) response. That response can be any valid TwiML - speak something, gather keystrokes, redirect, etc. 
+
+Although it's pretty easy to test individual controller actions with the existing RSpec gem, testing more complex scenarios that use many controller actions (or controllers) is syntax-heavy and usually repetitive. TTT exists to make these larger scale integration tests easy and fun to write. TTT emulates the Twilio end of the Twilo phone callbacks, and allows to to emulate a user listening for a specific Say element, pressing keys on their phone, etc. With TTT, you can test your whole phone system built on Twilio.
+
+For instance, let's say you have a controller that handles inbound Twilio calls and asks the user to enter an account number, then a PIN code, and then finally makes a menu selection. With TTT, you can just do this:
+
+	@call = ttt_call(some_controller_action_path, from_number, to_number)
+	
+	@call.should have_say("Welcome to AwesomeCo.")
+	@call.within_gather do |gather|
+		gather.should have_say("Please enter your account number, followed by the pound sign.")
+		gather.press "12345678"
+	end
+	
+	@call.current_path.should == some_other_controller_action_path
+	@call.within_gather do |gather|
+		gather.should have_say("Please enter your 4 digit PIN code.")
+		gather.press "9876"
+	end
+	
+	@call.current_path.should == yet_another_controller_action_path
+	@call.should have_say "Please choose from one of the following menu options"
+
+TTT was originally built to handle testing a complex, large-scale phone tree system. Without TTT, it was necessary to do lots of deployments to staging to test how the controller actions worked together, and there wasn't a good automated way to verify any new changes. When new functionality was introduced, TTT tests were written for the full project, and everything that worked in TTT worked great the first time it was pushed to staging. It's a great timesaver.
+
+What's supported
+================
+
+TTT supports most of the more common Twilio scenarios:
+
+* Checking for Say elements and their content
+* Checking for Play elements and their content
+* Taking action on Gather elements and querying their contents
+* Following and querying redirects
+* Dial and Hangup
+
+TTT doesn't yet support (but you should contribute them!)
+
+* Queue
+* Any of the other conference calling features
+	
+What's required
+================
+
+TTT depends on [Capybara](https://github.com/jnicklas/capybara). It uses Capybara's session object to make requests to your controllers. 
+
+TTT expects your controller actions to behave like well-behaved Twilio callbacks. That is, you need to respond to XML-formatted requests, and need to respond with a 200 OK. Twilio will not follow 301 or 302 redirects properly, and neither will TTT (see below for more details). 
+
+TTT has been tested with RSpec on Rails, and limited testing has been done with Sinatra. It might work on other test frameworks or other Rack-based frameworks. Feel free to submit pull requests to improve compatibility with these.
+
+If it works with Twilio, it should work with TTT. If not, open an issue/pull request.
+
+Getting started
+================
+
+First, get RSpec and Capybara working for your project. Then, you'll need to add this to your gemfile:
+
+	group :test do
+		...
+		gem 'twilio-test-toolkit'
+		...
+	end
+
+Since TTT is test-only code, it should be in the :test group.
+
+You'll have to make one more change in spec/spec_helper.rb. If you are using Capybara 1.x, do this:
+
+	RSpec.configure do |config|
+		...
+		# Configure Twilio Test Toolkit
+	  	config.include TwilioTestToolkit::DSL, :type => :request
+		...
+	end
+
+For Capybara 2.0, the "requests" directory is now called "features", so you need this instead:
+
+	RSpec.configure do |config|
+		...
+		# Configure Twilio Test Toolkit
+	  	config.include TwilioTestToolkit::DSL, :type => :feature
+		...
+	end
+
+This line is required in order to get TTT's DSL to work with your tests.
+
+Finally, since TTT deals with integration tests, you should write your tests in spec/requests (or whatever directory you've configured for this type of test).
+
+How to use
+================
+
+This section describes how to use TTT and its basic functionality.
+
+ttt_call
+-------------
+
+The *ttt_call* method is the main entry point for working with TTT. You call this method to initiate a "Twilio phone call" to your controller actions. TTT simulates Twilio's behavior by making requests to your action with the expected Twilio parameters (From, To, CallSid, etc). 
+
+*ttt_call* has three required parameters and an options hash:
+
+	@call = ttt_call(action_path, from_number, to_number, options = {})
+	
+* **action_path**. Where to make your request.  By default this will be a POST, but you can override it with the options hash.
+* **from_number**. What to fill params[:From] with. If you don't care about this value, you can pass a blank one, as this is only used to pass along to your actions.
+* **to_number**. What to fill params[:To] with.
+
+Options are:
+
+* **method** . Specify the http method of the initial request. By default this will be :post.
+* **call_sid**. Specify an optional fixed value to be passed as params[:CallSid]. This is useful if you are expecting a specific SID. For instance, a common pattern is to initiate a call, store the SID in your database, and look up the call when you get the callback. If you don't pass a SID, TTT will generate one for you that's just a UUID.
+* **is_machine**. Controls params[:AnsweredBy]. See Twilio's documentation for more information on how Twilio uses this.
+* **direction**. Controls params[:Direction]. Should be: inbound, outbound-api, or outbound-dial
+* **called**. Controls params[:Called]. This is present in a REST API-initiated call.
+* **call_status**. Controls params[:CallStatus]. Defaults to `in-progress`. See [help article](https://www.twilio.com/help/faq/voice/what-do-the-call-statuses-mean) on call statuses.
+
+*ttt_call* returns a *TwilioTestToolkit::CallInProgress* object, which is a descendent of *TwilioTestToolkit::CallScope*. You'll want to save this object as it's how you interact with TTT.
+
+It's worth noting that TTT won't pass any of the parameters you need to [validate that a request comes from Twilio](http://www.twilio.com/docs/security). Most people seem to only do this check in production, so if that applies to you, this won't be an issue. If you do this check in dev and test, you might want to consider submitting a pull request with a fix.
+
+Getting call information
+--------------
+
+You can use the CallInProgress object returned from *ttt_call* to inspect some basic properties about the call:
+
+	@call.sid			# Returns the SID of the call
+	@call.initial_path	# Returns the path that you used to start the call (the first parameter to ttt_call)
+	@call.from_number	# Returns the from number
+	@call.to_number		# Returns the to number
+	@call.is_machine	# Returns the answering machine state (passed to ttt_call)
+	@call.direction   # Returns the direction of the call (inbound, outbound-api, outbound-dial)
+	@call.called      # Returns the Called number in the case of an outbound-api call
+
+Call scopes
+--------------
+
+The CallInProgress object returned from *ttt_call* is a descendent of CallScope. A CallScope represents a scope within a call. For instance, the root TwiML Response element is a scope. A Gather within that is a scope. 
+	
+For instance, let's say you have TwiML like this:
+	
+	<Response>
+		<Say>Foo</Say>
+		<Gather action="baz">
+			<Say>Bar</Say>
+		</Gather>
+	</Response>
+	
+The scope referred to by the CallInProgress object is the Response object. Only items that directly descend from this scope are seen by TTT. That is, the say for "Foo" is in the scope, but the say for "Bar" is not. The Gather is its own scope, and it contains the say for "Bar". TTT intentionally restricts you to accessing only what's in your scope because it helps you enforce a more rigid structure in your call, and allows you to handle multiple Gathers or similar in a given TwiML markup.
+
+CallScope has some properties that are also useful:
+
+	@call.current_path		# Returns the current path that the call is on.
+	@call.response_xml		# Returns the raw XML response that your action returned to TTT
+	@call.root_call			# Returns the original CallInProgress returned from ttt_call.
+
+Inspecting the contents of the call
+--------------
+
+A common thing you'll want to do is inspect the various Say elements, and check for control elements like Dial and Hangup. 
+	
+	@call.has_say?("Foo")	# Returns true if there's a <Say> in the current scope 
+							# that contains the text. Partial matches are OK, but 
+							# the call is case sensitive.
+	@call.has_dial?("911")	# Returns true if there's a <Dial> in the current scope 
+							# for the number. Partial matches are OK.
+	@call.has_hangup?		# Returns true if there's a <Hangup> in the current scope.
+
+You can check the existence of any element by using the `#has_foo?` pattern
+where `foo` is your element. Pass in an optional string to check that the string
+is found in the element's inner text:
+
+	@call.has_sms?("Please make sure you foo the bar.")
+
+You can also check that a given attribute exists on any element using
+a `#has_bar_on_foo?` pattern:
+
+	@call.has_from_on_sms?("+18885551234")
+
+Or for camel case attributes you can do either of the following:
+
+	@call.has_finishOnKey_on_record?("#")
+	@call.has_finish_on_key_on_record?("#")
+
+These methods are available on any CallScope.
+	
+Gathers
+--------------
+
+Gathers are used to collect digits from the caller (e.g. "press 1 to speak with a representative, press 2 to cancel"). Twilio handles Gathers by speaking the contents of the Gather and waiting for a digit or digits to be pressed. If nothing is pressed, it continues with the script. If something is pressed, it aborts processing the current script and makes a request with the digits (via params[:Digits]) to the path specified by the action attribute.  If no method is specified in the options, this will be a post TTT handles Gathers in a similar way.
+
+You can only interact with a gather by calling *within_gather*:
+
+	@call.within_gather do |gather|
+		gather.should have_say("Enter your account number")
+		gather.press "12345"
+	end
+
+*within_gather* creates a new CallScope and passes it to the yielded parameter (gather in the example above). *within_gather* will fail if there is no Gather element in the current scope. 
+	
+You can verify the existence of a Gather in the current scope with:
+	
+	@call.has_gather?		# Returns true if the current scope has a gather.
+	
+Within a gather CallScope, you can use the following methods:
+	
+	@call.gather?			# Returns true if the current scope **is** a gather. Compare with the has_gather? method.
+	@call.gather_action		# Returns the value of the action attribute for the gather.
+	@call.press("1")		# Simulates pressing the specified digits.
+
+You can also use other CallScope methods (e.g. *has_say?* and similar.)
+
+The *press* method has a few caveats worth knowing. It's only callable once per gather - when you call it, TTT will immediately call the gather's action. There is no way to simulate pressing buttons slowly, and you don't really need to do this anyways - Twilio doesn't care and just passes them all at once. *press* simply fills out the value of params[:Digits] and calls your method, just like Twilio does.
+
+Although you can technically pass whatever you want to *press*, in practice Twilio only sends digits and #. Still it's probably a good idea to test garbage data in this parameter with your actions, so TTT doesn't get in your way if you want to call press with "UNICORNSANDPONIES" as a parameter.
+
+TTT doesn't attempt to validate your TwiML, so it's worth knowing that Gather only allows Say, Pause, and Play as child elements. Nested Gathers are not supported.
+	
+Redirects
+--------------
+
+The Redirect element is used to tell Twilio to call a different page. It differs from a standard 301 or 302 redirect (created by a *redirect_to*) in that the 301/302 redirects don't support a POST, and if you try a *redirect_to* within a Twilio action, Twilio will fail and your caller will get the dreaded "I'm sorry, an application error has occurred" message. Because Twilio doesn't support 301/302 redirects, TTT doesn't either, and if you use one, TTT will complain.
+	
+There are several methods you can use within a CallScope related to redirects:
+
+	@call.has_redirect?					# Returns true if there's a <Redirect> element in the current scope.
+	@call.has_redirect_to?(path)		# Returns true if there's a <Redirect> element to the specified path
+	 									# in the current scope.
+	@call.follow_redirect				# Follows the <Redirect> in the current scope and returns a new 
+										# CallScope object. The original scope is not modified.
+	@call.follow_redirect! 				# Follows the <Redirect> in the current scope and updates the scope 
+										# to the new path. 
+	
+Although it's allowed by TwiML (as of this writing), multiple Redirects in a scope aren't effectively allowed, as only the first one will ever be used. Thus, TTT only looks at the first Redirect it finds in the given scope.
+	
+Contributing
+================
+
+TTT is pretty basic, but it should work for most people's needs. You might consider helping to improve it. Some things that could be done:
+
+* Support more Twilio functionality
+* Build more stringent checks into says and plays - e.g. verify that there's enough of a pause between sentences.
+* Build checks to make sure that numbers, dates, and other special text is spoken properly (e.g. "one two three" instead of "one hundred twenty three").
+* Build checks to validate the correctness of your TwiML.
+* Refactor wonky code (there's probably some in there somewhere)
+* Write more tests. There are basic tests, but more involved ones might be nice
+* Add support as needed for other test frameworks or Rack-based frameworks
+
+Contributions are welcome and encouraged. The usual deal applies - fork a branch, add tests, add your changes, submit a pull request. If I haven't done anything with your pull request in a reasonable amount of time, ping me on Twitter or email and I'll get on it.
+
+Running Tests
+----------------
+
+	bundle install
+	cd spec/dummy
+	bundle exec rake db:create
+	cd ../..
+	bundle exec rspec
+
+Credits
+================
+
+TTT was put together by Jack Nichols [@jmongol](http://twitter.com/jmongol). MIT license.

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TwilioTestToolkit'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/twilio-test-toolkit.rb

@@ -0,0 +1,4 @@
+module TwilioTestToolkit
+  require "uuidtools"
+  require 'twilio-test-toolkit/dsl'  
+end

data/lib/twilio-test-toolkit/call_in_progress.rb

@@ -0,0 +1,48 @@
+require "twilio-test-toolkit/call_scope"
+
+module TwilioTestToolkit
+  # Models a call
+  class CallInProgress < CallScope
+    attr_reader :options
+    attr_reader :sid, :initial_path, :http_method
+    attr_reader :from_number, :to_number
+    attr_reader :is_machine, :called, :direction
+
+    # Initiate a call. Options:
+    # * :method - specify the http method of the initial api call
+    # * :call_sid - specify an optional fixed value to be passed as params[:CallSid]
+    # * :is_machine - controls params[:AnsweredBy]
+    def initialize(initial_path, from_number, to_number, options = {})
+      default_options = {
+        :method     => :post,
+        :direction  => 'inbound',
+        :is_machine => false
+      }
+
+      @options = default_options.merge(options)
+
+      # Save our variables for later
+      @initial_path = initial_path
+      @from_number  = from_number
+      @to_number    = to_number
+      @is_machine   = @options[:is_machine]
+      @called       = @options[:called]
+      @direction    = @options[:direction]
+      @http_method  = @options[:method]
+
+      # Generate an initial call SID if we don't have one
+      if (options[:call_sid].nil?)
+        @sid = UUIDTools::UUID.random_create.to_s
+      else
+        @sid = options[:call_sid]
+      end
+
+      # We are the root call
+      self.root_call = self
+
+      # Create the request
+      request_for_twiml!(@initial_path, @options)
+    end
+
+  end
+end

data/lib/twilio-test-toolkit/call_scope.rb

@@ -0,0 +1,247 @@
+module TwilioTestToolkit
+  # Models a scope within a call.
+  class CallScope
+
+    # Note that el is case sensitive and must match the desired
+    # TwiML element. eg. Play (correct) vs play (incorrect).
+    def self.has_element(el, options = {})
+      define_method "has_#{el.downcase}?" do |inner = nil|
+        return has_element?(el, inner, options)
+      end
+    end
+
+    # method_missing? will take care of most cases, but for elements
+    # where the preference is to have exact matching, just add a
+    # definition like:
+    #
+    # has_element "Foo", :exact_inner_match => true
+    has_element "Play", :exact_inner_match => true
+
+    # Stuff for redirects
+    def has_redirect_to?(url)
+      el = get_redirect_node
+      return false if el.nil?
+      return normalize_redirect_path(el.text) == normalize_redirect_path(url)
+    end
+
+    def follow_redirect(options = {})
+      el = get_redirect_node
+      raise "No redirect" if el.nil?
+
+      return CallScope.from_request(self, el.text, { :method =>el[:method]}.merge(options))
+    end
+
+    def follow_redirect!(options = {})
+      el = get_redirect_node
+      raise "No redirect" if el.nil?
+
+      request_for_twiml!(normalize_redirect_path(el.text), { :method => el[:method] }.merge(options))
+    end
+
+    # Stuff for gatherers
+    def gather?
+      @xml.name == "Gather"
+    end
+
+    def gather_action
+      raise "Not a gather" unless gather?
+      return @xml["action"]
+    end
+
+    def gather_method
+      raise "Not a gather" unless gather?
+      return @xml["method"]
+    end
+
+    def gather_finish_on_key
+      raise "Not a gather" unless gather?
+      return @xml["finishOnKey"] || '#' # '#' is the default finish key if not specified
+    end
+
+    def press(digits)
+      raise "Not a gather" unless gather?
+
+      # Fetch the path and then post
+      path = gather_action
+
+      # Update the root call
+      root_call.request_for_twiml!(path, :digits => digits, :method => gather_method, :finish_on_key => gather_finish_on_key)
+    end
+
+    # Make this easier to support TwiML elements...
+    def method_missing(meth, *args, &block)
+      # support any check for a given attribute on a given element
+      #
+      # eg. has_action_on_dial?, has_method_on_sip?, etc.
+      #
+      # Attribute-checking appears to be case-sensitive, which x means:
+      #
+      # has_finishOnKey_on_record?("#")
+      #
+      # I'm not crazy about this mixed case, so we can also do a more
+      # Rubyish way:
+      #
+      # has_finish_on_key_on_record?("#")
+      #
+      if meth.to_s =~ /^ha(s|ve)_([a-zA-Z_]+)_on_([a-zA-Z]+)\?$/
+        has_attr_on_element?($3, $2, *args, &block)
+
+      # support any check for the existence of a given element
+      # with an optional check on the inner_text.
+      elsif meth.to_s =~ /^ha(s|ve)_([a-zA-Z]+)\?$/
+        has_element?($2, *args, &block)
+
+      # get a given element node
+      elsif meth.to_s =~ /^get_([a-z]+)_node$/
+        get_element_node($1, *args, &block)
+
+      # run a block within a given node context
+      elsif meth.to_s =~ /^within_([a-z]+)$/
+        within_element($1, *args, &block)
+
+      else
+        super # You *must* call super if you don't handle the
+              # method, otherwise you'll mess up Ruby's method
+              # lookup.
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.match(/^(has_|have_|get_[a-z]+_node|within_)/) || super
+    end
+
+    # Some basic accessors
+    def current_path
+      @current_path
+    end
+
+    def response_xml
+      @response_xml
+    end
+
+    def root_call
+      @root_call
+    end
+
+    private
+      def formatted_digits(digits, options = {})
+        if digits.nil?
+          ''
+        elsif options[:finish_on_key]
+          digits.to_s.split(options[:finish_on_key])[0]
+        else
+          digits
+        end
+      end
+
+      def get_element_node(el)
+        el[0] = el[0,1].upcase
+        @xml.at_xpath(el)
+      end
+
+      # Within element returns a scope that's tied to the specified element
+      def within_element(el, &block)
+        element_node = get_element_node(el)
+
+        raise "No el in scope" if element_node.nil?
+        yield(CallScope.from_xml(self, element_node))
+      end
+
+      def has_attr_on_element?(el, attr, value)
+        el[0] = el[0,1].upcase
+        # convert snake case to lower camelCase
+        if attr.match(/_/)
+          attr = camel_case_lower(attr)
+        end
+
+        attr_on_el = @xml.xpath(el).attribute(attr)
+        !!attr_on_el && attr_on_el.value == value
+      end
+
+      def has_element?(el, inner = nil, options = {})
+        el[0] = el[0,1].upcase
+        return !(@xml.at_xpath(el).nil?) if inner.nil?
+
+        @xml.xpath(el).each do |s|
+          if !options[:exact_inner_match].nil? && options[:exact_inner_match] == true
+            return true if s.inner_text.strip == inner
+          else
+            return true if s.inner_text.include?(inner)
+          end
+        end
+
+        return false
+      end
+
+      def camel_case_lower(subject)
+        subject.split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
+      end
+
+    protected
+      # New object creation
+      def self.from_xml(parent, xml)
+        new_scope = CallScope.new
+        new_scope.send(:set_xml, xml)
+        new_scope.send(:root_call=, parent.root_call)
+        return new_scope
+      end
+
+      def set_xml(xml)
+        @xml = xml
+      end
+
+      # Create a new object from a post. Options:
+      # * :method - the http method of the request, defaults to :post
+      # * :digits - becomes params[:Digits], defaults to ""
+      def self.from_request(parent, path, options = {})
+        new_scope = CallScope.new
+        new_scope.send(:root_call=, parent.root_call)
+        new_scope.send(:request_for_twiml!, path, options)
+        return new_scope
+      end
+
+      def normalize_redirect_path(path)
+        p = path
+
+        # Strip off ".xml" off of the end of any path
+        p = path[0...path.length - ".xml".length] if path.downcase.match(/\.xml$/)
+        return p
+      end
+
+      # Post and update the scope. Options:
+      # :digits - becomes params[:Digits], optional (becomes "")
+      # :is_machine - becomes params[:AnsweredBy], defaults to false / human
+      # :called - becomes params[:Called], like when the REST API is used to initiate a call
+      # :direction - becomes params[:Direction]. Should be inbound, outbound-api, or outbound-dial
+      def request_for_twiml!(path, options = {})
+        @current_path = normalize_redirect_path(path)
+
+        # Post the query
+        rack_test_session_wrapper = Capybara.current_session.driver
+        @response = rack_test_session_wrapper.send(options[:method].downcase || :post, @current_path,
+          :format => :xml,
+          :CallSid => @root_call.sid,
+          :From => @root_call.from_number,
+          :Digits => formatted_digits(options[:digits].to_s, :finish_on_key => options[:finish_on_key]),
+          :To => @root_call.to_number,
+          :AnsweredBy => (options[:is_machine] ? "machine" : "human"),
+          :CallStatus => options.fetch(:call_status, "in-progress"),
+          :Called => options.fetch(:called, ""),
+          :Direction => options[:direction].nil? ? "inbound" : options[:direction]
+        )
+
+        # All Twilio responses must be a success.
+        raise "Bad response: #{@response.status}" unless @response.status == 200
+
+        # Load the xml
+        data = @response.body
+        @response_xml = Nokogiri::XML.parse(data)
+        set_xml(@response_xml.at_xpath("Response"))
+      end
+
+      # Parent call control
+      def root_call=(val)
+        @root_call = val
+      end
+  end
+end