twilio-ruby 5.10.7 → 7.6.2

data/cluster/cluster_oauth_spec.rb

@@ -0,0 +1,19 @@
+require 'rspec/matchers'
+require 'twilio-ruby'
+require './lib/twilio-ruby/credential/client_credential_provider'
+
+describe 'Cluster Test' do
+  before(:each) do
+    @account_sid = ENV['TWILIO_ACCOUNT_SID']
+    @client_secret = ENV['TWILIO_CLIENT_SECRET']
+    @client_id = ENV['TWILIO_CLIENT_ID']
+    @message_sid = ENV['TWILIO_MESSAGE_SID']
+    @credential = Twilio::REST::ClientCredentialProvider.new(@client_id, @client_secret)
+    @client = Twilio::REST::Client.new(@account_sid).credential_provider(@credential)
+  end
+
+  it 'can fetch a message' do
+    response = @client.messages(@message_sid).fetch
+    expect(response).to_not be_nil
+  end
+end

data/cluster/cluster_orgs_spec.rb

@@ -0,0 +1,40 @@
+require 'rspec/matchers'
+require 'twilio-ruby'
+require './lib/twilio-ruby/credential/client_credential_provider'
+
+describe 'Cluster Test' do
+  before(:each) do
+    @client_secret = ENV['TWILIO_ORGS_CLIENT_SECRET']
+    @client_id = ENV['TWILIO_ORGS_CLIENT_ID']
+    @org_sid = ENV['TWILIO_ORG_SID']
+    @user_sid = ENV['TWILIO_USER_SID']
+    @account_sid = ENV['TWILIO_ORGS_ACCOUNT_SID']
+    @credential = Twilio::REST::ClientCredentialProvider.new(@client_id, @client_secret)
+    @client = Twilio::REST::Client.new.credential_provider(@credential)
+  end
+
+  it 'can list accounts' do
+    response = @client.preview_iam.organizations(@org_sid).accounts.list
+    expect(response).to_not be_nil
+  end
+
+  it 'can fetch specific account' do
+    response = @client.preview_iam.organizations(@org_sid).accounts(@account_sid).fetch
+    expect(response).to_not be_nil
+  end
+
+  it 'can access role assignments list' do
+    response = @client.preview_iam.organizations(@org_sid).role_assignments.list(scope: @account_sid)
+    expect(response).to_not be_nil
+  end
+
+  it 'can get user list' do
+    response = @client.preview_iam.organizations(@org_sid).users.list
+    expect(response).to_not be_nil
+  end
+
+  it 'can get single user' do
+    response = @client.preview_iam.organizations(@org_sid).users(@user_sid).fetch
+    expect(response).to_not be_nil
+  end
+end

data/cluster/cluster_spec.rb

@@ -0,0 +1,75 @@
+require 'rspec/matchers'
+require 'twilio-ruby'
+
+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

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/examples/public_oauth.rb

@@ -0,0 +1,13 @@
+require 'twilio-ruby'
+require 'twilio-ruby/credential/client_credential_provider'
+
+credential_provider = Twilio::REST::ClientCredentialProvider.new(ENV['CLIENT_ID'], ENV['CLIENT_SECRET'])
+# passing account sid is not mandatory
+client = Twilio::REST::Client.new(ENV['ACCOUNT_SID']).credential_provider(credential_provider)
+
+# send messages
+client.messages.create(
+  from: ENV['TWILIO_PHONE_NUMBER'],
+  to: ENV['PHONE_NUMBER'],
+  body: 'Hello from Ruby!'
+)

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/auth_strategy/auth_strategy.rb

@@ -0,0 +1,19 @@
+module Twilio
+  module REST
+    class AuthStrategy
+      attr_accessor :auth_type
+
+      def initialize(auth_type)
+        @auth_type = auth_type
+      end
+
+      def auth_string
+        raise NotImplementedError, 'Subclasses must implement this method'
+      end
+
+      def requires_authentication
+        raise NotImplementedError, 'Subclasses must implement this method'
+      end
+    end
+  end
+end

data/lib/twilio-ruby/auth_strategy/no_auth_strategy.rb

@@ -0,0 +1,17 @@
+module Twilio
+  module REST
+    class NoAuthStrategy < AuthStrategy
+      def initialize
+        super(AuthType::NONE)
+      end
+
+      def auth_string
+        ''
+      end
+
+      def requires_authentication
+        false
+      end
+    end
+  end
+end

data/lib/twilio-ruby/auth_strategy/token_auth_strategy.rb

@@ -0,0 +1,39 @@
+require_relative 'auth_strategy'
+require_relative './../credential/auth_type'
+require 'jwt'
+module Twilio
+  module REST
+    class TokenAuthStrategy < AuthStrategy
+      attr_accessor :token_manager, :token, :lock
+
+      def initialize(token_manager)
+        super(AuthType::ORGS_TOKEN)
+        @token = nil
+        @token_manager = token_manager
+        @lock = Mutex.new
+      end
+
+      def auth_string
+        token = fetch_token
+        "Bearer #{token}"
+      end
+
+      def fetch_token
+        @lock.synchronize do
+          @token = @token_manager.fetch_access_token if @token.nil? || token_expired? || @token == ''
+          return @token
+        end
+      end
+
+      def token_expired?
+        decoded_token = ::JWT.decode(@token, nil, false)
+        exp = decoded_token[0]['exp']
+        Time.at(exp) < Time.now
+      end
+
+      def requires_authentication
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+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, :credentials
+
+      # 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
+
+      def credential_provider(credential_provider = nil)
+        @credentials = credential_provider
+        self
+      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
+
+        auth = @credentials.to_auth_strategy.auth_string unless @credentials.nil?
+
+        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}" }
+
+        if ['POST', 'PUT'].include?(method) && !headers['Content-Type']
+          headers['Content-Type'] =
+            'application/x-www-form-urlencoded'
+        end
+
+        headers['Accept'] = 'application/json' unless headers['Accept']
+        headers
+      end
+    end
+  end
+end

data/lib/twilio-ruby/credential/auth_type.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    class AuthType
+      BASIC = 'basic'
+      ORGS_TOKEN = 'orgs_token'
+      API_KEY = 'api_key'
+      NOAUTH = 'noauth'
+      CLIENT_CREDENTIALS = 'client_credentials'
+
+      def to_s
+        name
+      end
+    end
+  end
+end

data/lib/twilio-ruby/credential/client_credential_provider.rb

@@ -0,0 +1,28 @@
+require_relative 'credential_provider'
+require_relative 'auth_type'
+require_relative './../http/client_token_manager'
+require_relative './../auth_strategy/token_auth_strategy'
+module Twilio
+  module REST
+    class ClientCredentialProvider < CredentialProvider
+      attr_accessor :grant_type, :client_id, :client_secret, :orgs_token, :auth_strategy
+
+      def initialize(client_id, client_secret, orgs_token = nil)
+        super(AuthType::ORGS_TOKEN)
+        raise ArgumentError, 'client_id and client_secret are required' if client_id.nil? || client_secret.nil?
+
+        @grant_type = 'client_credentials'
+        @client_id = client_id
+        @client_secret = client_secret
+        @orgs_token = orgs_token
+        @auth_strategy = nil
+      end
+
+      def to_auth_strategy
+        @orgs_token = ClientTokenManager.new(@grant_type, @client_id, @client_secret) if @orgs_token.nil?
+        @auth_strategy = TokenAuthStrategy.new(@orgs_token) if @auth_strategy.nil?
+        @auth_strategy
+      end
+    end
+  end
+end

data/lib/twilio-ruby/credential/credential_provider.rb

@@ -0,0 +1,11 @@
+module Twilio
+  module REST
+    class CredentialProvider
+      attr_accessor :auth_type
+
+      def initialize(auth_type)
+        @auth_type = auth_type
+      end
+    end
+  end
+end

data/lib/twilio-ruby/credential/orgs_credential_provider.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'credential_provider'
+require_relative 'auth_type'
+require_relative './../http/org_token_manager'
+require_relative './../auth_strategy/token_auth_strategy'
+module Twilio
+  module REST
+    class OrgsCredentialProvider < CredentialProvider
+      attr_accessor :grant_type, :client_id, :client_secret, :orgs_token, :auth_strategy
+
+      def initialize(client_id, client_secret, orgs_token = nil)
+        super(AuthType::ORGS_TOKEN)
+        raise ArgumentError, 'client_id and client_secret are required' if client_id.nil? || client_secret.nil?
+
+        @grant_type = 'client_credentials'
+        @client_id = client_id
+        @client_secret = client_secret
+        @orgs_token = orgs_token
+        @auth_strategy = nil
+      end
+
+      def to_auth_strategy
+        @orgs_token = OrgTokenManager.new(@grant_type, @client_id, @client_secret) if @orgs_token.nil?
+        @auth_strategy = TokenAuthStrategy.new(@orgs_token) if @auth_strategy.nil?
+        @auth_strategy
+      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/{domain.rb → rest/domain.rb}

@@ -18,9 +18,8 @@ module Twilio
 
       def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
         url = uri.match(/^http/) ? uri : absolute_url(uri)
-
         @client.request(
-          @host,
+          @base_url,
           @port,
           method,
           url,

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/{page.rb → rest/page.rb}

@@ -38,6 +38,7 @@ module Twilio
       end
 
       def load_page(payload)
+        return payload['Resources'] if payload['Resources']
         if payload['meta'] && payload['meta']['key']
           return payload[payload['meta']['key']]
         else

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,