twilio-ruby 5.48.0 → 5.66.2

data/spec/rest/client_spec.rb

@@ -1,255 +0,0 @@
-require 'spec_helper'
-require 'logger'
-
-describe Twilio::REST::ObsoleteClient do
-  it 'raise an exception' do
-    expect { Twilio::REST::ObsoleteClient.new }.to raise_error(Twilio::REST::ObsoleteError)
-  end
-end
-
-describe Twilio::REST::BaseClient do
-  it 'raise an exception' do
-    expect { Twilio::REST::BaseClient.new }.to raise_error(Twilio::REST::ObsoleteError)
-  end
-end
-
-describe Twilio::REST::IpMessagingClient do
-  it 'raise an exception' do
-    expect { Twilio::REST::IpMessagingClient.new }.to raise_error(Twilio::REST::ObsoleteError)
-  end
-end
-
-describe Twilio::REST::LookupsClient do
-  it 'raise an exception' do
-    expect { Twilio::REST::LookupsClient.new }.to raise_error(Twilio::REST::ObsoleteError)
-  end
-end
-
-describe Twilio::REST::MonitorClient do
-  it 'raise an exception' do
-    expect { Twilio::REST::MonitorClient.new }.to raise_error(Twilio::REST::ObsoleteError)
-  end
-end
-
-describe Twilio::REST::PricingClient do
-  it 'raise an exception' do
-    expect { Twilio::REST::PricingClient.new }.to raise_error(Twilio::REST::ObsoleteError)
-  end
-end
-
-describe Twilio::REST::TaskRouterClient do
-  it 'raise an exception' do
-    expect { Twilio::REST::TaskRouterClient.new }.to raise_error(Twilio::REST::ObsoleteError)
-  end
-end
-
-describe Twilio::REST::TrunkingClient do
-  it 'raise an exception' do
-    expect { Twilio::REST::TrunkingClient.new }.to raise_error(Twilio::REST::ObsoleteError)
-  end
-end
-
-describe Twilio::REST::Client do
-  context 'configuration' do
-    before do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-        config.http_client = 'someClient'
-        config.region = 'someRegion'
-        config.edge = 'someEdge'
-        config.logger = 'someLogger'
-      end
-    end
-
-    it 'uses the global configuration by default' do
-      @client = Twilio::REST::Client.new
-      expect(@client.account_sid).to eq('someSid')
-      expect(@client.auth_token).to eq('someToken')
-      expect(@client.http_client).to eq('someClient')
-      expect(@client.region).to eq('someRegion')
-      expect(@client.edge).to eq('someEdge')
-      expect(@client.logger).to eq('someLogger')
-    end
-
-    it 'uses the arguments over global configuration' do
-      @client = Twilio::REST::Client.new('myUser', 'myPassword', nil, 'myRegion', 'myClient', 'myLogger')
-      @client.edge = 'myEdge'
-      expect(@client.account_sid).to eq('myUser')
-      expect(@client.auth_token).to eq('myPassword')
-      expect(@client.http_client).to eq('myClient')
-      expect(@client.region).to eq('myRegion')
-      expect(@client.edge).to eq('myEdge')
-      expect(@client.logger).to eq('myLogger')
-    end
-
-    class MyVersion < Twilio::REST::Version
-      def initialize(domain)
-        super
-        @version = 'v1'
-      end
-    end
-
-    class MyDomain < Twilio::REST::Domain
-      def initialize(client)
-        super
-        @host = 'twilio.com'
-        @base_url = 'https://twilio.com'
-        @port = 443
-      end
-    end
-  end
-
-  context 'validation' do
-    before :all do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-        config.http_client = 'someClient'
-        config.region = nil
-        config.edge = nil
-        config.logger = nil
-      end
-    end
-
-    it 'successfully validates the working SSL certificate' do
-      @holodeck.mock Twilio::Response.new(200, '')
-      expect { @client.validate_ssl_certificate }.not_to raise_error
-    end
-
-    it 'fails to validate broken SSL certificates' do
-      @holodeck.mock Twilio::Response.new(504, '')
-      expect { @client.validate_ssl_certificate }.to raise_error(Twilio::REST::RestError)
-    end
-
-    it 'translates bad request error params' do
-      @domain = MyDomain.new(@client)
-      @version = MyVersion.new(@domain)
-      @error_message = '{
-                          "code": 20001,
-                          "message": "Bad request",
-                          "more_info": "https://www.twilio.com/docs/errors/20001",
-                          "status": 400,
-                          "details": {
-                              "foo":"bar"
-                      }}'
-      @holodeck.mock Twilio::Response.new(400, @error_message)
-      expect {
-        @version.fetch('GET', 'http://foobar.com')
-      }.to raise_error { |error|
-        expect(error).to be_a(Twilio::REST::RestError)
-        expect(error.status_code).to eq(400)
-        expect(error.code).to eq(20_001)
-        expect(error.details).to eq({ 'foo' => 'bar' })
-        expect(error.error_message).to eq('Bad request')
-        expect(error.more_info).to eq('https://www.twilio.com/docs/errors/20001')
-      }
-    end
-  end
-
-  context 'logging' do
-    it 'logs the call details' do
-      @client.logger = Logger.new(STDOUT)
-      @holodeck.mock Twilio::Response.new(200, {})
-      expect {
-        @client.request('host', 'port', 'GET', 'http://foobar.com')
-      }.to output(/Host:foobar.com/).to_stdout_from_any_process
-    end
-
-    it 'does not log when the logger instance is not passed' do
-      @holodeck.mock Twilio::Response.new(200, {})
-      expect {
-        @client.request('host', 'port', 'GET', 'http://foobar.com')
-      }.to_not output(/Host:foobar.com/).to_stdout_from_any_process
-    end
-  end
-
-  describe '#build_uri' do
-    before(:all) do
-      Twilio.configure do |config|
-        config.account_sid = 'username'
-        config.auth_token = 'password'
-        config.region = nil
-        config.edge = nil
-      end
-    end
-
-    context 'no region or edge in url' do
-      it "doesn't set region or edge" do
-        @client = Twilio::REST::Client.new
-        expect(@client.build_uri('https://api.twilio.com')).to eq('https://api.twilio.com')
-      end
-
-      it 'uses the default region if edge set' do
-        @client = Twilio::REST::Client.new
-        @client.edge = 'edge'
-        expect(@client.build_uri('https://api.twilio.com')).to eq('https://api.edge.us1.twilio.com')
-      end
-
-      it 'sets region' do
-        @client = Twilio::REST::Client.new
-        @client.region = 'region'
-        expect(@client.build_uri('https://api.twilio.com')).to eq('https://api.region.twilio.com')
-      end
-
-      it 'sets region and edge' do
-        @client = Twilio::REST::Client.new
-        @client.region = 'region'
-        @client.edge = 'edge'
-        expect(@client.build_uri('https://api.twilio.com')).to eq('https://api.edge.region.twilio.com')
-      end
-    end
-
-    context 'region in url' do
-      it 'uses url region' do
-        @client = Twilio::REST::Client.new
-        expect(@client.build_uri('https://api.urlRegion.twilio.com')).to eq('https://api.urlRegion.twilio.com')
-      end
-
-      it 'uses client edge and url region' do
-        @client = Twilio::REST::Client.new
-        @client.edge = 'edge'
-        expect(@client.build_uri('https://api.urlRegion.twilio.com')).to eq('https://api.edge.urlRegion.twilio.com')
-      end
-
-      it 'prefers client region' do
-        @client = Twilio::REST::Client.new
-        @client.region = 'region'
-        expect(@client.build_uri('https://api.urlRegion.twilio.com')).to eq('https://api.region.twilio.com')
-      end
-
-      it 'uses client edge and prefers client region' do
-        @client = Twilio::REST::Client.new
-        @client.region = 'region'
-        @client.edge = 'edge'
-        expect(@client.build_uri('https://api.urlRegion.twilio.com')).to eq('https://api.edge.region.twilio.com')
-      end
-    end
-
-    context 'region and edge in url' do
-      it 'uses url region and edge' do
-        @client = Twilio::REST::Client.new
-        expect(@client.build_uri('https://api.urlEdge.urlRegion.twilio.com')).to eq('https://api.urlEdge.urlRegion.twilio.com')
-      end
-
-      it 'prefers client edge' do
-        @client = Twilio::REST::Client.new
-        @client.edge = 'edge'
-        expect(@client.build_uri('https://api.urlEdge.urlRegion.twilio.com')).to eq('https://api.edge.urlRegion.twilio.com')
-      end
-
-      it 'prefers client region' do
-        @client = Twilio::REST::Client.new
-        @client.region = 'region'
-        expect(@client.build_uri('https://api.urlEdge.urlRegion.twilio.com')).to eq('https://api.urlEdge.region.twilio.com')
-      end
-
-      it 'prefers client region and edge' do
-        @client = Twilio::REST::Client.new
-        @client.region = 'region'
-        @client.edge = 'edge'
-        expect(@client.build_uri('https://api.urlEdge.urlRegion.twilio.com')).to eq('https://api.edge.region.twilio.com')
-      end
-    end
-  end
-end

data/spec/security/request_validator_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::Security::RequestValidator do
-  describe 'configuration' do
-    after(:each) do
-      Twilio.instance_variable_set('@configuration', nil)
-    end
-
-    it 'should set the auth token from a configuration block' do
-      Twilio.configure do |config|
-        config.auth_token = 'someToken'
-      end
-
-      validator = Twilio::Security::RequestValidator.new
-      expect(validator.instance_variable_get('@auth_token')).to eq('someToken')
-    end
-
-    it 'should overwrite the auth token if passed to initializer' do
-      Twilio.configure do |config|
-        config.auth_token = 'someToken'
-      end
-
-      validator = Twilio::Security::RequestValidator.new 'otherToken'
-      expect(validator.instance_variable_get('@auth_token')).to eq('otherToken')
-    end
-
-    it 'should throw an argument error if the auth token isn\'t set' do
-      expect { Twilio::Security::RequestValidator.new }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe 'validations' do
-    let(:token) { '12345' }
-
-    let(:validator) { Twilio::Security::RequestValidator.new token }
-
-    let(:url) { 'https://mycompany.com/myapp.php?foo=1&bar=2' }
-
-    let(:default_signature) { 'RSOYDt4T1cUTdK1PDd93/VVr8B8=' }
-
-    let(:body) { '{"property": "value", "boolean": true}' }
-
-    let(:body_hash) { '0a1ff7634d9ab3b95db5c9a2dfe9416e41502b283a80c7cf19632632f96e6620' }
-
-    let(:params) do
-      {
-        'From' => '+14158675309',
-        'To' => '+18005551212',
-        'CallSid' => 'CA1234567890ABCDE',
-        'Caller' => '+14158675309',
-        'Digits' => '1234'
-      }
-    end
-
-    it 'should build a correct signature' do
-      expect(validator.build_signature_for(url, params)).to eq(default_signature)
-    end
-    it 'should validate an authentic Twilio request' do
-      expect(validator.validate(url, params, default_signature)).to eq(true)
-    end
-
-    it 'should not validate a request with wrong signature' do
-      expect(validator.validate(url, params, 'fake_signature')).to eq(false)
-    end
-
-    it 'should hash body correctly' do
-      expect(validator.build_hash_for(body)).to eq(body_hash)
-    end
-
-    it 'should validate requests with body correctly' do
-      url_with_hash = "#{url}&bodySHA256=#{body_hash}"
-      expect(validator.validate(url_with_hash, body, 'a9nBmqA0ju/hNViExpshrM61xv4=')).to eq(true)
-    end
-
-    it 'should validate with no other GET parameters' do
-      url_with_hash = "https://mycompany.com/myapp.php?bodySHA256=#{body_hash}"
-      expect(validator.validate(url_with_hash, body, 'y77kIzt2vzLz71DgmJGsen2scGs=')).to eq(true)
-    end
-
-    it 'should fail validation with body but no signature' do
-      expect(validator.validate(url, body, default_signature)).to eq(false)
-    end
-
-    it 'should validate https urls with ports by stripping them' do
-      url_with_port = url.sub('.com', '.com:1234')
-      expect(validator.validate(url_with_port, params, default_signature)).to eq(true)
-    end
-
-    it 'should validate http urls with ports' do
-      http_url_with_port = url.sub('.com', '.com:1234')
-      http_url_with_port = http_url_with_port.sub('https', 'http')
-      signature = 'Zmvh+3yNM1Phv2jhDCwEM3q5ebU=' # hash of http url with port 1234
-      expect(validator.validate(http_url_with_port, params, signature)).to eq(true)
-    end
-
-    it 'should validate https urls without ports by adding standard port 443' do
-      signature = 'kvajT1Ptam85bY51eRf/AJRuM3w=' # hash of https url with port 443
-      expect(validator.validate(url, params, signature)).to eq(true)
-    end
-
-    it 'should validate http urls without ports by adding standard port 80' do
-      http_url = url.sub('https', 'http')
-      signature = '0ZXoZLH/DfblKGATFgpif+LLRf4=' # hash of http url with port 80
-      expect(validator.validate(http_url, params, signature)).to eq(true)
-    end
-
-    it 'should validate urls with credentials' do
-      url_with_creds = 'https://user:pass@mycompany.com/myapp.php?foo=1&bar=2'
-      signature = 'CukzLTc1tT5dXEDIHm/tKBanW10=' # expected hash of the url
-      expect(validator.validate(url_with_creds, params, signature)).to eq(true)
-    end
-
-    it 'should validate urls with just username' do
-      url_with_creds = 'https://user@mycompany.com/myapp.php?foo=1&bar=2'
-      signature = '2YRLlVAflCqxaNicjMpJcSTgzSs=' # expected hash of the url
-      expect(validator.validate(url_with_creds, params, signature)).to eq(true)
-    end
-
-    it 'should validate urls with credentials by adding port' do
-      url_with_creds = 'https://user:pass@mycompany.com/myapp.php?foo=1&bar=2'
-      signature = 'ZQFR1PTIZXF2MXB8ZnKCvnnA+rI=' # expected hash of the url with port 443
-      expect(validator.validate(url_with_creds, params, signature)).to eq(true)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,38 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'bundler'
-Bundler.setup
-
-Dir.glob(File.expand_path('../support/**/*.rb', __FILE__)).sort.each(&method(:require))
-
-require_relative './holodeck/holodeck.rb'
-require_relative './holodeck/hologram.rb'
-
-require 'twilio-ruby'
-require 'rack'
-require 'rspec/matchers'
-require 'equivalent-xml'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  config.before(:each) do
-    @client = Twilio::REST::Client.new('AC' + 'a' * 32, 'AUTHTOKEN')
-    @holodeck = Holodeck.new
-    @client.http_client = @holodeck
-  end
-end
-
-def account_sid
-  ENV['ACCOUNT_SID']
-end
-
-def auth_token
-  ENV['AUTH_TOKEN']
-end
-
-def parse(twiml_response)
-  Nokogiri::XML::Document.parse(twiml_response.to_s, &:noblanks)
-end

data/spec/support/fakeweb.rb

@@ -1,2 +0,0 @@
-require 'fakeweb'
-FakeWeb.allow_net_connect = false

data/spec/twilio_spec.rb

@@ -1,17 +0,0 @@
-describe Twilio do
-  after(:each) do
-    Twilio.instance_variable_set('@configuration', nil)
-  end
-
-  it 'should set the configuration with a config block' do
-    Twilio.configure do |config|
-      config.account_sid = 'someSid'
-      config.auth_token = 'someToken'
-      config.http_client = 'someClient'
-    end
-
-    expect(Twilio.account_sid).to eq('someSid')
-    expect(Twilio.auth_token).to eq('someToken')
-    expect(Twilio.http_client).to eq('someClient')
-  end
-end

data/spec/twiml/messaging_response_spec.rb

@@ -1,235 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::TwiML::MessagingResponse do
-  context 'Testing Response' do
-    it 'should allow empty response' do
-      expected_doc = parse <<-XML
-        <Response/>
-      XML
-      response = Twilio::TwiML::MessagingResponse.new.to_s
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow using to_xml instead of to_s' do
-      expected_doc = parse <<-XML
-        <Response/>
-      XML
-      response = Twilio::TwiML::MessagingResponse.new.to_xml
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow comments' do
-      twiml = Twilio::TwiML::MessagingResponse.new
-      twiml.comment 'This is awesome'
-      expect(twiml.to_xml).to match(/<!--This is awesome-->/)
-    end
-
-    it 'should allow text nodes' do
-      expected_doc = parse <<-XML
-        <Response>Look no tags</Response>
-      XML
-      twiml = Twilio::TwiML::MessagingResponse.new
-      twiml.add_text 'Look no tags'
-      expect(parse(twiml)).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow generic child nodes' do
-      expected_doc = parse <<-XML
-        <Response>
-          <message tag="global">
-            <bold>Hello</bold>
-          </alexa>
-        </Response>
-      XML
-
-      twiml = Twilio::TwiML::MessagingResponse.new
-      twiml.add_child('message', tag: 'global') do |custom|
-        custom.add_child('bold', 'Hello')
-      end
-
-      expect(parse(twiml)).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow mixed text and generic nodes' do
-      expected_doc = parse <<-XML
-        <Response>
-          before
-          <Child>content</Child>
-          after
-        </Response>
-      XML
-
-      twiml = Twilio::TwiML::MessagingResponse.new
-      twiml.add_text('before')
-           .add_child('Child', 'content')
-           .add_text('after')
-
-      expect(parse(twiml)).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow populated response' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Message>Hello</Message>
-          <Redirect>example.com</Redirect>
-        </Response>
-      XML
-      response = Twilio::TwiML::MessagingResponse.new
-      response.message(body: 'Hello')
-      response.redirect('example.com')
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow chaining' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Message>Hello</Message>
-          <Redirect>example.com</Redirect>
-        </Response>
-      XML
-      response = Twilio::TwiML::MessagingResponse.new.message(body: 'Hello').redirect('example.com')
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow nesting' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Message>
-            Hello
-            <Media>foobar</Media>
-          </Message>
-        </Response>
-      XML
-      response = Twilio::TwiML::MessagingResponse.new
-      response.message(body: 'Hello') do |message|
-        message.media('foobar')
-      end
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow nesting and chaining' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Message>
-            Hello
-            <Media>foobar</Media>
-          </Message>
-          <Redirect>example.com</Redirec>
-        </Response>
-      XML
-      response = Twilio::TwiML::MessagingResponse.new
-      response.message(body: 'Hello') do |message|
-        message.media('foobar')
-      end
-
-      response.redirect('example.com')
-
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow nesting from the initializer' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Message>Hello</Message>
-          <Redirect>example.com</Redirec>
-        </Response>
-      XML
-      response = Twilio::TwiML::MessagingResponse.new do |res|
-        res.message(body: 'Hello')
-        res.redirect('example.com')
-      end
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-  end
-
-  context 'Testing Message' do
-    it 'should allow a body' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Message>Hello</Message>
-        </Response>
-      XML
-      response = Twilio::TwiML::MessagingResponse.new
-      response.message(body: 'Hello')
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow appending Body' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Message><Body>Hello World</Body></Message>
-        </Response>
-      XML
-      body = Twilio::TwiML::Body.new('Hello World')
-      message = Twilio::TwiML::Message.new
-
-      response = Twilio::TwiML::MessagingResponse.new
-      message.append(body)
-      response.append(message)
-
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow appending Body and Media' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Message>
-            <Body>Hello World</Body>
-            <Media>hey.jpg</Media>
-          </Message>
-        </Response>
-      XML
-      body = Twilio::TwiML::Body.new('Hello World')
-      media = Twilio::TwiML::Media.new('hey.jpg')
-      message = Twilio::TwiML::Message.new
-
-      response = Twilio::TwiML::MessagingResponse.new
-      message.append(body)
-      message.append(media)
-      response.append(message)
-
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-
-    it 'should allow and preserve new lines in messages' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Message>Hello
-World
-          </Message>
-        </Response>
-      XML
-
-      response = Twilio::TwiML::MessagingResponse.new
-      response.message(body: "Hello\nWorld")
-
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-  end
-
-  context 'Testing Redirect' do
-    it 'should allow MessagingResponse.redirect' do
-      expected_doc = parse <<-XML
-        <Response>
-          <Redirect>example.com</Redirect>
-        </Response>
-      XML
-      response = Twilio::TwiML::MessagingResponse.new
-      response.redirect('example.com')
-
-      doc = parse(response)
-      expect(doc).to be_equivalent_to(expected_doc).respecting_element_order
-    end
-  end
-end