twilio-ruby 5.74.0 → 7.10.1

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/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/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/rest/api_v1_version.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'error'
+
+module Twilio
+  module REST
+    class ApiV1Version < Version
+      attr_accessor :api_version
+
+      def initialize(domain, version)
+        super(domain)
+        @version = version.version
+        @api_version = 'v1'
+      end
+
+      def exception(response, _)
+        RestErrorV10.new(response.body)
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/rest/domain.rb

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

data/lib/twilio-ruby/framework/rest/error.rb

@@ -3,11 +3,6 @@
 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
@@ -23,13 +18,6 @@ module Twilio
         @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
@@ -47,5 +35,32 @@ module Twilio
 
     class ObsoleteError < StandardError
     end
+
+    class RestErrorV10 < TwilioError
+      attr_accessor :code, :message, :http_status_code, :params, :user_error
+
+      def initialize(response)
+        @code = response['code']
+        @message = response['message']
+        @http_status_code = response['httpsStatusCode']
+        @params = response['params']
+        @user_error = response['userError']
+      end
+
+      def to_s
+        message
+      end
+
+      private
+
+      def format_message(initial_message)
+        message_response = "[HTTP #{status_code}] #{code} : #{initial_message}"
+        message_response += "\n#{message}" if message
+        message_response += "\n#{http_status_code}" if http_status_code
+        message_response += "\n#{params}" if params
+        message_response += "\n#{user_error}" if user_error
+        message_response + "\n\n"
+      end
+    end
   end
 end

data/lib/twilio-ruby/framework/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/rest/page_metadata.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    # Page Base Class
+    class PageMetadata
+      META_KEYS = [
+        'end',
+        'first_page_uri',
+        'next_page_uri',
+        'last_page_uri',
+        'page',
+        'page_size',
+        'previous_page_uri',
+        'total',
+        'num_pages',
+        'start',
+        'uri'
+      ].freeze
+
+      def initialize(version, response)
+        payload = process_response(response)
+
+        @version = version
+        @payload = payload
+        @solution = {}
+        @records = payload
+      end
+
+      def process_response(response)
+        return response if response.status_code == 200
+
+        raise Twilio::REST::RestError.new('Unable to fetch page', response)
+      end
+
+      def get_key(payload)
+        return 'Resources' if payload['Resources']
+
+        return payload['meta']['key'] if payload['meta'] && payload['meta']['key']
+
+        keys = payload.keys
+        key = keys - META_KEYS
+        return key.first if key.size == 1
+
+        raise Twilio::REST::TwilioError, 'Page Records can not be deserialized'
+      end
+
+      def previous_page_url
+        # rubocop:disable Layout/LineLength
+        return @version.domain.absolute_url(URI.parse(@payload['meta']['previous_page_url']).request_uri) if @payload['meta'] && @payload['meta']['previous_page_url']
+        # rubocop:enable Layout/LineLength
+        return @version.domain.absolute_url(@payload['previous_page_uri']) if @payload['previous_page_uri']
+
+        nil
+      end
+
+      def next_page_url
+        # rubocop:disable Layout/LineLength
+        return @version.domain.absolute_url(URI.parse(@payload.body['meta']['next_page_url']).request_uri) if @payload.body['meta'] && @payload.body['meta']['next_page_url']
+        # rubocop:enable Layout/LineLength
+        return @version.domain.absolute_url(@payload.body['next_page_uri']) if @payload.body['next_page_uri']
+
+        nil
+      end
+
+      def previous_page
+        return nil unless previous_page_url
+
+        @version.domain.request('GET', previous_page_url)
+      end
+
+      def next_page
+        return nil unless next_page_url
+
+        @version.domain.request('GET', next_page_url)
+      end
+
+      def to_s
+        '#<PageMetadata>'
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/rest/resource.rb

@@ -19,5 +19,21 @@ module Twilio
         @version = version
       end
     end
+
+    class InstanceResourceMetadata
+      def initialize(payload, headers, status_code)
+        @payload = payload
+        @headers = headers
+        @status_code = status_code
+      end
+    end
+
+    class InstanceListResource
+      def initialize(version, headers, status_code)
+        @version = version
+        @headers = headers
+        @status_code = status_code
+      end
+    end
   end
 end

data/lib/twilio-ruby/framework/rest/token_page.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    class TokenPage < Page
+      attr_accessor :key, :page_size, :url
+
+      def initialize(version, response)
+        super(version, response)
+
+        @client = @version.domain.client.http_client
+        @url = ''
+        if @client.last_request
+          full_url = @client.last_request.url
+          uri = URI.parse(full_url)
+          @url = uri.path
+          @params = @client.last_request.params
+        end
+        @page_size = @payload['meta'] && @payload['meta']['pageSize']
+        @next_token = @payload['meta'] && @payload['meta']['nextToken']
+        @previous_token = @payload['meta'] && @payload['meta']['previousToken']
+      end
+
+      def previous_token
+        @payload['meta'] && @payload['meta']['previousToken']
+      end
+
+      def previous_page
+        cached_url = previous_page_url
+        return nil unless cached_url
+
+        response = @version.domain.request('GET', cached_url, @params)
+
+        self.class.new(@version, response, @solution)
+      end
+
+      def next_token
+        @payload['meta'] && @payload['meta']['nextToken']
+      end
+
+      def previous_page_url
+        return nil if previous_token.nil?
+
+        @params['pageToken'] = previous_token
+        @version.domain.absolute_url(@url)
+      end
+
+      def next_page_url
+        token = next_token
+        return nil if token.nil? || token.to_s.empty?
+
+        @params['pageToken'] = token
+        @version.domain.absolute_url(@url)
+      end
+
+      def next_page
+        cached_url = next_page_url
+        return nil unless cached_url
+
+        response = @version.domain.request('GET', cached_url, @params)
+
+        self.class.new(@version, response, @solution)
+      end
+
+      def load_page(payload)
+        @key ||= payload['meta'] && payload['meta']['key']
+        return @payload[@key] if @key && @payload[@key]
+
+        raise Twilio::REST::TwilioError, 'Page Records can not be deserialized'
+      end
+    end
+  end
+end