twilio-ruby 5.31.1 → 7.1.0

data/advanced-examples/custom-http-client.md

@@ -0,0 +1,170 @@
+# Custom HTTP Clients for the Twilio Ruby Helper Library
+
+If you are working with the Twilio Ruby Helper Library, and you need to be able to modify the HTTP requests that the library makes to the Twilio servers, you’re in the right place. The most common need to alter the HTTP request is to connect and authenticate with an enterprise’s proxy server. We’ll provide sample code that you can drop right into your app to handle this use case.
+
+Connect and authenticate with a proxy server
+To connect and provide credentials to a proxy server that may be between your app and Twilio, you need a way to modify the HTTP requests that the Twilio helper library makes on your behalf to invoke the Twilio REST API.
+
+The Twilio Ruby helper library uses the [Faraday](https://rubygems.org/gems/faraday) gem under the hood to make the HTTP requests. The following example shows a typical request, without a custom `http_client`:
+
+```rb
+@client = Twilio::REST::Client.new(account_sid, auth_token)
+
+message = @client.messages
+  .create(
+    to: "+15558675310",
+    body: "Hey there!",
+    from: "+15017122661",
+  )
+```
+
+Out of the box, the helper library is creating a default `Twilio::Http::Client` for you, using the Twilio credentials you provide. However, you can create your own `Twilio::Http::Client`, and pass it to any Twilio REST API resource action you want.
+
+Here’s an example of sending an SMS message with a custom client:
+
+```rb
+# Download the helper library from https://www.twilio.com/docs/ruby/install
+require "rubygems"
+require "twilio-ruby"
+require "dotenv/load"
+
+# Custom HTTP Client
+require_relative "MyRequestClass"
+
+# Your Account Sid and Auth Token from twilio.com/console
+account_sid = ENV["ACCOUNT_SID"]
+auth_token = ENV["AUTH_TOKEN"]
+proxy_address = ENV["PROXY_ADDRESS"]
+proxy_protocol = ENV["PROXY_PROTOCOL"]
+proxy_port = ENV["PROXY_PORT"]
+
+my_request_client = MyRequestClass.new(proxy_protocol, proxy_address, proxy_port)
+
+@client = Twilio::REST::Client.new(account_sid, auth_token,
+                                   nil, nil, my_request_client)
+
+message = @client.messages
+  .create(
+    to: "+593978613041",
+    body: "RB This is the ship that made the Kesssssel Run in fourteen parsecs?",
+    from: "+13212855389",
+  )
+
+puts "Message SID: #{message.sid}"
+```
+
+## Create your custom TwilioRestClient
+
+When you take a closer look at the constructor for `Twilio::Http::Client`, you see that this class provides it to the Twilio helper library to make the necessary HTTP requests.
+
+## Call Twilio through the proxy server
+
+Now that we understand how all the components fit together, we can create our own `http_client` that can connect through a proxy server. To make this reusable, here’s a class that you can use to create this `http_client` whenever you need one.
+
+```rb
+class MyRequestClass
+  attr_accessor :adapter
+  attr_reader :timeout, :last_response, :last_request
+
+  def initialize(proxy_prot = nil, proxy_addr = nil, proxy_port = nil, timeout: nil)
+    @proxy_prot = proxy_prot
+    @proxy_addr = proxy_addr
+    @proxy_port = proxy_port
+    @timeout = timeout
+    @adapter = Faraday.default_adapter
+  end
+
+  def _request(request)
+    @connection = Faraday.new(url: request.host + ":" + request.port.to_s, ssl: { verify: true }) do |f|
+      f.options.params_encoder = Faraday::FlatParamsEncoder
+      f.request :url_encoded
+      f.adapter @adapter
+      f.headers = request.headers
+      f.basic_auth(request.auth[0], request.auth[1])
+      if @proxy_addr
+        f.proxy = "#{@proxy_prot}://#{@proxy_addr}:#{@proxy_port}"
+      end
+      f.options.open_timeout = request.timeout || @timeout
+      f.options.timeout = request.timeout || @timeout
+    end
+
+    @last_request = request
+    @last_response = nil
+    response = @connection.send(request.method.downcase.to_sym,
+                                request.url,
+                                request.method == "GET" ? request.params : request.data)
+
+    if response.body && !response.body.empty?
+      object = response.body
+    elsif response.status == 400
+      object = { message: "Bad request", code: 400 }.to_json
+    end
+
+    twilio_response = Twilio::Response.new(response.status, object, headers: response.headers)
+    @last_response = twilio_response
+
+    twilio_response
+  end
+
+  def request(host, port, method, url, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+    request = Twilio::Request.new(host, port, method, url, params, data, headers, auth, timeout)
+    _request(request)
+  end
+end
+```
+
+In this example, we are using some environment variables loaded at the program startup to retrieve various configuration settings:
+
+- Your Twilio Account Sid and Auth Token ([found here, in the Twilio console](https://console.twilio.com))
+- A proxy address in the form of `http://127.0.0.1:8888`
+
+These settings are located in a file like `.env` like so:
+
+```env
+ACCOUNT_SID=ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+AUTH_TOKEN= your_auth_token
+
+HTTPS_PROXY=https://127.0.0.1:8888
+HTTP_PROXY=http://127.0.0.1:8888
+```
+
+Here’s the full console program that sends a text message and shows how it all can work together. It loads the `.env` file.
+
+```rb
+# Download the helper library from https://www.twilio.com/docs/ruby/install
+require "rubygems"
+require "twilio-ruby"
+require "dotenv/load"
+
+# Custom HTTP Client
+require_relative "MyRequestClass"
+
+# Your Account Sid and Auth Token from twilio.com/console
+account_sid = ENV["ACCOUNT_SID"]
+auth_token = ENV["AUTH_TOKEN"]
+proxy_address = ENV["PROXY_ADDRESS"]
+proxy_protocol = ENV["PROXY_PROTOCOL"]
+proxy_port = ENV["PROXY_PORT"]
+
+my_request_client = MyRequestClass.new(proxy_protocol, proxy_address, proxy_port)
+
+@client = Twilio::REST::Client.new(account_sid, auth_token,
+                                   nil, nil, my_request_client)
+
+message = @client.messages
+  .create(
+    to: "+593978613041",
+    body: "RB This is the ship that made the Kesssssel Run in fourteen parsecs?",
+    from: "+13212855389",
+  )
+
+puts "Message SID: #{message.sid}"
+```
+
+## What else can this technique be used for?
+
+Now that you know how to inject your own `http_client` into the Twilio API request pipeline, you could use this technique to add custom HTTP headers and authorization to the requests (perhaps as required by an upstream proxy server).
+
+You could also implement your own `http_client` to mock the Twilio API responses so your unit and integration tests can run quickly without the need to make a connection to Twilio. In fact, there’s already an example online showing [how to do exactly that with Node.js and Prism](https://www.twilio.com/docs/openapi/mock-api-generation-with-twilio-openapi-spec).
+
+We can’t wait to see what you build!

data/cluster_spec.rb

@@ -0,0 +1,77 @@
+require 'rspec/matchers'
+require 'twilio-ruby'
+
+# rubocop:disable Metrics/BlockLength
+describe 'Cluster Test' do
+  before(:each) do
+    @account_sid = ENV['TWILIO_ACCOUNT_SID']
+    @secret = ENV['TWILIO_API_SECRET']
+    @api_key = ENV['TWILIO_API_KEY']
+    @to_number = ENV['TWILIO_TO_NUMBER']
+    @from_number = ENV['TWILIO_FROM_NUMBER']
+    @client = Twilio::REST::Client.new @api_key, @secret, @account_sid
+  end
+
+  it 'can send a text' do
+    message = @client.messages.create(
+      to: @to_number,
+      from: @from_number,
+      body: 'Cluster test message from twilio-ruby'
+    )
+    expect(message).to_not eq(nil)
+    expect(message.body.include?('Cluster test message from twilio-ruby')).to eq(true)
+    expect(message.from).to eq(@from_number)
+    expect(message.to).to eq(@to_number)
+  end
+
+  it 'can list numbers' do
+    phone_numbers = @client.incoming_phone_numbers.list
+    expect(phone_numbers).to_not eq(nil)
+    expect(phone_numbers).to_not match_array([])
+  end
+
+  it 'list a number' do
+    phone_numbers = @client.incoming_phone_numbers.list(phone_number: @from_number)
+    expect(phone_numbers).to_not eq(nil)
+    expect(phone_numbers[0].phone_number).to eq(@from_number)
+  end
+
+  it 'allows special characters for friendly and identity name' do
+    service = @client.chat.v2.services.create(friendly_name: 'service|friendly&name')
+    expect(service).to_not eq(nil)
+
+    user = @client.chat.v2.services(service.sid).users.create(identity: 'user|identity&string')
+    expect(user).to_not eq(nil)
+
+    is_user_deleted = @client.chat.v2.services(service.sid).users(user.sid).delete
+    expect(is_user_deleted).to eq(true)
+
+    is_service_deleted = @client.chat.v2.services(service.sid).delete
+    expect(is_service_deleted).to eq(true)
+  end
+
+  it 'test list params' do
+    sink_configuration = { 'destination' => 'http://example.org/webhook', 'method' => 'post',
+                           'batch_events' => false }
+    types = [{ 'type' => 'com.twilio.messaging.message.delivered' },
+             { 'type' => 'com.twilio.messaging.message.sent' }]
+
+    sink = @client.events.v1.sinks.create(
+      description: 'test sink ruby',
+      sink_configuration: sink_configuration,
+      sink_type: 'webhook'
+    )
+    expect(sink).to_not eq(nil)
+
+    subscription = @client.events.v1.subscriptions.create(
+      description: 'test subscription ruby',
+      types: types,
+      sink_sid: sink.sid
+    )
+    expect(subscription).to_not eq(nil)
+
+    expect(@client.events.v1.subscriptions(subscription.sid).delete).to eq(true)
+    expect(@client.events.v1.sinks(sink.sid).delete).to eq(true)
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/examples/examples.rb

@@ -69,7 +69,7 @@ puts @client.messages('SMXXXXXXXX').fetch.body
 @client.messages.create(
   from: '+14159341234',
   to: '+16105557069',
-  media_urls: 'http://example.com/media.png'
+  media_url: 'http://example.com/media.png'
 )
 
 ################ PHONE NUMBERS ################

data/lib/rack/twilio_webhook_authentication.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'rack/media_type'
+
 module Rack
   # Middleware that authenticates webhooks from Twilio using the request
   # validator.
@@ -19,6 +21,10 @@ module Rack
   # doesn't validate then the middleware responds immediately with a 403 status.
 
   class TwilioWebhookAuthentication
+    # Rack's FORM_DATA_MEDIA_TYPES can be modified to taste, so we're slightly
+    # more conservative in what we consider form data.
+    FORM_URLENCODED_MEDIA_TYPE = Rack::MediaType.type('application/x-www-form-urlencoded')
+
     def initialize(app, auth_token, *paths, &auth_token_lookup)
       @app = app
       @auth_token = auth_token
@@ -30,7 +36,7 @@ module Rack
       return @app.call(env) unless env['PATH_INFO'].match(@path_regex)
       request = Rack::Request.new(env)
       original_url = request.url
-      params = request.post? ? request.POST : {}
+      params = extract_params!(request)
       auth_token = @auth_token || get_auth_token(params['AccountSid'])
       validator = Twilio::Security::RequestValidator.new(auth_token)
       signature = env['HTTP_X_TWILIO_SIGNATURE'] || ''
@@ -44,5 +50,23 @@ module Rack
         ]
       end
     end
+
+    # Extract the params from the the request that we can use to determine the
+    # signature. This _may_ modify the passed in request since it may read/rewind
+    # the body.
+    def extract_params!(request)
+      return {} unless request.post?
+
+      if request.media_type == FORM_URLENCODED_MEDIA_TYPE
+        request.POST
+      else
+        request.body.rewind
+        body = request.body.read
+        request.body.rewind
+        body
+      end
+    end
+
+    private :extract_params!
   end
 end

data/lib/twilio-ruby/base/client_base.rb

@@ -0,0 +1,121 @@
+module Twilio
+  module REST
+    class ClientBase
+      # rubocop:disable Style/ClassVars
+      @@default_region = 'us1'
+      # rubocop:enable Style/ClassVars
+
+      attr_accessor :http_client, :username, :password, :account_sid, :auth_token, :region, :edge, :logger,
+                    :user_agent_extensions
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(username = nil, password = nil, account_sid = nil, region = nil, http_client = nil, logger = nil,
+                     user_agent_extensions = nil)
+        @username = username || Twilio.account_sid
+        @password = password || Twilio.auth_token
+        @region = region || Twilio.region
+        @edge = Twilio.edge
+        @account_sid = account_sid || @username
+        @auth_token = @password
+        @auth = [@username, @password]
+        @http_client = http_client || Twilio.http_client || Twilio::HTTP::Client.new
+        @logger = logger || Twilio.logger
+        @user_agent_extensions = user_agent_extensions || []
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      ##
+      # Makes a request to the Twilio API using the configured http client
+      # Authentication information is automatically added if none is provided
+      def request(host, port, method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil) # rubocop:disable Metrics/MethodLength
+        auth ||= @auth
+        headers = generate_headers(method, headers)
+        uri = build_uri(uri)
+
+        if @logger
+          @logger.debug('--BEGIN Twilio API Request--')
+          @logger.debug("Request Method: <#{method}>")
+
+          headers.each do |key, value|
+            @logger.debug("#{key}:#{value}") unless key.downcase == 'authorization'
+          end
+
+          url = URI(uri)
+          @logger.debug("Host:#{url.host}")
+          @logger.debug("Path:#{url.path}")
+          @logger.debug("Query:#{url.query}")
+          @logger.debug("Request Params:#{params}")
+        end
+
+        response = @http_client.request(
+          host,
+          port,
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if @logger
+          @logger.debug("Response Status Code:#{response.status_code}")
+          @logger.debug("Response Headers:#{response.headers}")
+          @logger.debug('--END TWILIO API REQUEST--')
+        end
+
+        response
+      end
+
+      ##
+      # Build the final request uri
+      def build_uri(uri)
+        return uri if @region.nil? && @edge.nil?
+
+        parsed_url = URI(uri)
+        pieces = parsed_url.host.split('.')
+        product = pieces[0]
+        domain = pieces[-2, 2]
+        new_edge = @edge
+        new_region = @region
+
+        case pieces.length
+        when 4
+          new_region ||= pieces[1]
+        when 5
+          new_edge ||= pieces[1]
+          new_region ||= pieces[2]
+        end
+
+        new_region = @@default_region if !new_edge.nil? && new_region.nil?
+
+        parsed_url.host = [product, new_edge, new_region, domain].reject(&:nil?).join('.')
+        parsed_url.to_s
+      end
+
+      ##
+      # Validate the SSL certificates for the Twilio API
+      def validate_ssl_certificate
+        response = request('tls-test.twilio.com', '443', 'GET', 'https://tls-test.twilio.com')
+        return unless response.status_code < 200 || response.status_code >= 300
+
+        raise RestError.new 'Unexpected response from certificate endpoint', response
+      end
+
+      def generate_headers(method, headers)
+        ruby_config = RbConfig::CONFIG
+        headers['User-Agent'] =
+          "twilio-ruby/#{Twilio::VERSION} (#{ruby_config['host_os']} #{ruby_config['host_cpu']}) Ruby/#{RUBY_VERSION}"
+        headers['Accept-Charset'] = 'utf-8'
+
+        user_agent_extensions.each { |extension| headers['User-Agent'] += " #{extension}" }
+
+        headers['Content-Type'] = 'application/x-www-form-urlencoded' if method == 'POST' && !headers['Content-Type']
+
+        headers['Accept'] = 'application/json' unless headers['Accept']
+        headers
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/request.rb

@@ -32,7 +32,14 @@ module Twilio
       data = ''
       unless @data.nil? || @data.empty?
         data = @method.equal?('GET') ? "\n -G" : "\n"
-        data += @data.each.map { |key, value| "-d \"#{key}\"=\"#{value}\"" }.join("\n")
+        data += case @headers['Content-Type']
+                when 'application/x-www-form-urlencoded'
+                  @data.each.map { |key, value| "-d \"#{key}\"=\"#{value}\"" }.join("\n")
+                when 'application/json'
+                  "-d '#{JSON.generate(@data)}'"
+                else
+                  @data.each.map { |key, value| "-d \"#{key}\"=\"#{value}\"" }.join("\n")
+                end
       end
 
       "#{auth} #{@method} #{@url}#{params}#{data}#{headers}"

data/lib/twilio-ruby/framework/{error.rb → rest/error.rb}

@@ -3,33 +3,21 @@
 module Twilio
   module REST
     class TwilioError < StandardError
-      # @deprecated all errors that have a body are now 'Twilio::RestError's
-      def body
-        warn "'Twilio::REST::TwilioError#body' has been deprecated. No 'TwilioError' objects are raised with a body."
-        nil
-      end
     end
 
     class RestError < TwilioError
-      attr_reader :message, :response, :code, :status_code, :detail, :more_info, :error_message
+      attr_reader :message, :response, :code, :status_code, :details, :more_info, :error_message
 
       def initialize(message, response)
         @status_code = response.status_code
         @code = response.body.fetch('code', @status_code)
-        @detail = response.body.fetch('detail', nil)
+        @details = response.body.fetch('details', nil)
         @error_message = response.body.fetch('message', nil)
         @more_info = response.body.fetch('more_info', nil)
         @message = format_message(message)
         @response = response
       end
 
-      # @deprecated use #response instead
-      def body
-        warn 'This error used to be a "Twilio::REST::TwilioError" but is now a "Twilio::REST::RestError". ' \
-             'Please use #response instead of #body.'
-        @response
-      end
-
       def to_s
         message
       end
@@ -39,7 +27,7 @@ module Twilio
       def format_message(initial_message)
         message = "[HTTP #{status_code}] #{code} : #{initial_message}"
         message += "\n#{error_message}" if error_message
-        message += "\n#{detail}" if detail
+        message += "\n#{details}" if details
         message += "\n#{more_info}" if more_info
         message + "\n\n"
       end

data/lib/twilio-ruby/framework/{version.rb → rest/version.rb}

@@ -57,7 +57,7 @@ module Twilio
         Twilio::REST::RestError.new(header, response)
       end
 
-      def fetch(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+      def fetch(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
         response = request(
           method,
           uri,
@@ -68,7 +68,8 @@ module Twilio
           timeout
         )
 
-        if response.status_code < 200 || response.status_code >= 300
+        # Note that 3XX response codes are allowed for fetches.
+        if response.status_code < 200 || response.status_code >= 400
           raise exception(response, 'Unable to fetch record')
         end
 
@@ -93,7 +94,7 @@ module Twilio
         response.body
       end
 
-      def delete(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+      def delete(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
         response = request(
           method,
           uri,
@@ -112,22 +113,17 @@ module Twilio
       end
 
       def read_limits(limit = nil, page_size = nil)
-        page_limit = nil
-
-        unless limit.nil?
-          # If there is no user-specified page_size, pick the most network efficient size
+        unless limit.nil? || page_size
           page_size = limit
-          page_limit = (limit / page_size.to_f).ceil
         end
 
         {
           limit: limit || nil,
-          page_size: page_size || nil,
-          page_limit: page_limit
+          page_size: page_size || nil
         }
       end
 
-      def page(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+      def page(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
         request(
           method,
           uri,

data/lib/twilio-ruby/http/http_client.rb

@@ -6,35 +6,59 @@ module Twilio
   module HTTP
     class Client
       attr_accessor :adapter
-      attr_reader :timeout, :last_response, :last_request
+      attr_reader :timeout, :last_response, :last_request, :connection
 
       def initialize(proxy_prot = nil, proxy_addr = nil, proxy_port = nil, proxy_user = nil, proxy_pass = nil,
-                     ssl_ca_file = nil, timeout: nil)
+                     timeout: nil)
         @proxy_prot = proxy_prot
         @proxy_path = "#{proxy_addr}:#{proxy_port}" if proxy_addr && proxy_port
         @proxy_auth = "#{proxy_user}:#{proxy_pass}@" if proxy_pass && proxy_user
-        @ssl_ca_file = ssl_ca_file
         @timeout = timeout
         @adapter = Faraday.default_adapter
+        @configure_connection_blocks = []
       end
 
-      def _request(request)
+      def configure_connection(&block)
+        raise ArgumentError, "#{__method__} must be given a block!" unless block_given?
+
+        @configure_connection_blocks << block
+        nil
+      end
+
+      def _request(request) # rubocop:disable Metrics/MethodLength
+        middle_ware = case request.headers['Content-Type']
+                      when 'application/json'
+                        :json
+                      when 'application/x-www-form-urlencoded'
+                        :url_encoded
+                      else
+                        :url_encoded
+                      end
         @connection = Faraday.new(url: request.host + ':' + request.port.to_s, ssl: { verify: true }) do |f|
           f.options.params_encoder = Faraday::FlatParamsEncoder
-          f.request :url_encoded
-          f.adapter @adapter
+          f.request(middle_ware)
           f.headers = request.headers
-          f.basic_auth(request.auth[0], request.auth[1])
+          if Faraday::VERSION.start_with?('2.')
+            f.request(:authorization, :basic, request.auth[0], request.auth[1])
+          else
+            f.request(:basic_auth, request.auth[0], request.auth[1])
+          end
           f.proxy = "#{@proxy_prot}://#{@proxy_auth}#{@proxy_path}" if @proxy_prot && @proxy_path
           f.options.open_timeout = request.timeout || @timeout
           f.options.timeout = request.timeout || @timeout
+          f.params = request.params.nil? ? {} : request.params
+
+          @configure_connection_blocks.each { |block| block.call(f) }
+          f.adapter @adapter
         end
 
         @last_request = request
         @last_response = nil
 
         response = send(request)
-        if response.body && !response.body.empty?
+        if (500..599).include?(response.status)
+          object = { message: "Server error (#{response.status})", code: response.status }.to_json
+        elsif response.body && !response.body.empty?
           object = response.body
         elsif response.status == 400
           object = { message: 'Bad request', code: 400 }.to_json
@@ -49,7 +73,7 @@ module Twilio
       def send(request)
         @connection.send(request.method.downcase.to_sym,
                          request.url,
-                         request.method == 'GET' ? request.params : request.data)
+                         request.data)
       rescue Faraday::Error => e
         raise Twilio::REST::TwilioError, e
       end

data/lib/twilio-ruby/http.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, 'http/**/*.rb')].sort.each do |file|
+  require file
+end