twilio-ruby 4.13.0 → 5.40.0

data/spec/rest/client_spec.rb

@@ -1,277 +1,233 @@
 require 'spec_helper'
 
-describe Twilio::REST::Client do
-  describe 'config at class level' do
-    after(:each) do
-      Twilio.instance_variable_set('@configuration', nil)
-    end
+describe Twilio::REST::ObsoleteClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::ObsoleteClient.new }.to raise_error(Twilio::REST::ObsoleteError)
+  end
+end
 
-    it 'should set the account sid and auth token with a config block' do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      end
+describe Twilio::REST::BaseClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::BaseClient.new }.to raise_error(Twilio::REST::ObsoleteError)
+  end
+end
 
-      client = Twilio::REST::Client.new
-      expect(client.account_sid).to eq('someSid')
-      expect(client.instance_variable_get('@auth_token')).to eq('someToken')
-    end
+describe Twilio::REST::IpMessagingClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::IpMessagingClient.new }.to raise_error(Twilio::REST::ObsoleteError)
+  end
+end
 
-    it 'should overwrite account sid and auth token if passed to initializer' do
+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'
       end
+    end
 
-      client = Twilio::REST::Client.new 'otherSid', 'otherToken'
-      expect(client.account_sid).to eq('otherSid')
-      expect(client.instance_variable_get('@auth_token')).to eq('otherToken')
+    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')
     end
 
-    it 'should overwrite the account sid if only the sid is given' do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
+    it 'uses the arguments over global configuration' do
+      @client = Twilio::REST::Client.new('myUser', 'myPassword', nil, 'myRegion', 'myClient')
+      @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')
+    end
+
+    class MyVersion < Twilio::REST::Version
+      def initialize(domain)
+        super
+        @version = 'v1'
       end
+    end
 
-      client = Twilio::REST::Client.new 'otherSid'
-      expect(client.account_sid).to eq('otherSid')
-      expect(client.instance_variable_get('@auth_token')).to eq('someToken')
+    class MyDomain < Twilio::REST::Domain
+      def initialize(client)
+        super
+        @host = 'twilio.com'
+        @base_url = 'https://twilio.com'
+        @port = 443
+      end
     end
+  end
 
-    it 'should allow options after setting up auth with config' do
+  context 'validation' do
+    before do
       Twilio.configure do |config|
         config.account_sid = 'someSid'
         config.auth_token = 'someToken'
+        config.http_client = 'someClient'
+        config.region = nil
+        config.edge = nil
       end
-
-      client = Twilio::REST::Client.new :host => 'api.faketwilio.com'
-
-      connection = client.instance_variable_get('@connection')
-      expect(connection.address).to eq('api.faketwilio.com')
     end
 
-    it 'should throw an argument error if the sid and token isn\'t set' do
-      expect { Twilio::REST::Client.new }.to raise_error(ArgumentError)
+    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 'should throw an argument error if only the account_sid is set' do
-      expect { Twilio::REST::Client.new 'someSid' }.to raise_error(ArgumentError)
+    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
-  end
-
-  it 'should not raise an error if the response body is empty' do
-    FakeWeb.register_uri(:any, %r/api\.twilio\.com/, body: '')
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    Twilio::REST::IncomingPhoneNumber.new('/phone_number', twilio).delete
-  end
-
-  it 'should not raise an error if the response body is nil' do
-    response = double(:response, body: nil)
-    connection = double(:connection, request: response)
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    twilio.instance_variable_set(:@connection, connection)
-    Twilio::REST::IncomingPhoneNumber.new('/phone_number', twilio).delete
-  end
-
-  it 'should set up a new client instance with the given sid and token' do
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    expect(twilio.account_sid).to eq('someSid')
-    expect(twilio.instance_variable_get('@auth_token')).to eq('someToken')
-  end
-
-  it 'should set up the proper default http ssl connection' do
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.address).to eq('api.twilio.com')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-  end
-
-  it 'should set up the requested ssl verification ca_file if provided' do
-    twilio = Twilio::REST::Client.new(
-      'someSid', 'someToken', ssl_ca_file: '/path/to/ca/file'
-    )
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.ca_file).to eq('/path/to/ca/file')
-  end
-
-  it 'should set up the proper http ssl connection when a different ' \
-     'domain is given' do
-    twilio = Twilio::REST::Client.new(
-      'someSid', 'someToken', host: 'api.faketwilio.com'
-    )
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.address).to eq('api.faketwilio.com')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-  end
-
-  it 'should adjust the open and read timeouts on the underlying Net::HTTP ' \
-     'object when asked' do
-    timeout = rand(30)
-    twilio = Twilio::REST::Client.new('someSid', 'someToken', timeout: timeout)
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-    expect(connection.open_timeout).to eq(timeout)
-    expect(connection.read_timeout).to eq(timeout)
-  end
-
-  it 'should set up the proper http ssl connection when a proxy_host is ' \
-     'given' do
-    twilio = Twilio::REST::Client.new(
-      'someSid',
-      'someToken',
-      host: 'api.faketwilio.com',
-      proxy_addr: 'localhost'
-    )
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.proxy?).to eq(true)
-    expect(connection.proxy_address).to eq('localhost')
-    expect(connection.proxy_port).to eq(80)
-    expect(connection.address).to eq('api.faketwilio.com')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-  end
-
-  it 'should set up the proper http ssl connection when a proxy_host and ' \
-     'proxy_port are given' do
-    twilio = Twilio::REST::Client.new(
-      'someSid',
-      'someToken',
-      host: 'api.faketwilio.com',
-      proxy_addr: 'localhost',
-      proxy_port: 13128
-    )
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.proxy?).to eq(true)
-    expect(connection.proxy_address).to eq('localhost')
-    expect(connection.proxy_port).to eq(13128)
-    expect(connection.address).to eq('api.faketwilio.com')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-  end
-
-  it 'should set up an accounts resources object' do
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    expect(twilio).to respond_to(:accounts)
-    expect(twilio.accounts.instance_variable_get('@path')).to eq(
-      '/2010-04-01/Accounts'
-    )
-  end
 
-  it 'should set up an account object with the given sid' do
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    expect(twilio).to respond_to(:account)
-    expect(twilio.account.instance_variable_get('@path')).to eq(
-      '/2010-04-01/Accounts/someSid'
-    )
-  end
-
-  [
-      :sandbox, :available_phone_numbers, :incoming_phone_numbers,
-      :calls, :outgoing_caller_ids, :conferences, :sms, :recordings,
-      :transcriptions, :notifications, :applications, :connect_apps,
-      :authorized_connect_apps, :queues, :usage, :messages, :media, :sip
-  ].each do |method|
-    it "should delegate the client method #{method} to the account object" do
-      client = Twilio::REST::Client.new('someSid', 'someToken')
-      expect(client).to respond_to(method)
-      expect(client.send(method)).to eq(client.account.send(method))
+    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
 
-  it 'should throw an argument error if the workspace_sid is not set' do
-    expect { Twilio::REST::TaskRouterClient.new 'someSid', 'someToken' }.to raise_error(ArgumentError)
-  end
-
-  it 'should have its host set to taskrouter.twilio.com' do
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    connection = client.instance_variable_get('@connection')
-    expect(connection.address).to eq('taskrouter.twilio.com')
-  end
-
-  it 'should have task queue statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:task_queue_statistics)
-    expect(client.task_queue_statistics('someSid').instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/TaskQueues/someSid/Statistics')
-  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
 
-  it 'should have task queues statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{"meta": {"key": "task_queues_statistics"}, "task_queues_statistics": [{"task_queue_sid": "WQ123"}]}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:task_queues_statistics)
-    expect(client.task_queues_statistics[0].task_queue_sid).to eq('WQ123')
-  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 'should have worker statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:worker_statistics)
-    expect(client.worker_statistics('someSid').instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/Workers/someSid/Statistics')
-  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 'should have workers statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workers_statistics)
-    expect(client.workers_statistics.instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/Workers/Statistics')
-  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 'should have workflow statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workflow_statistics)
-    expect(client.workflow_statistics('someSid').instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/Workflows/someSid/Statistics')
-  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
 
-  it 'should have workspace statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workspace_statistics)
-    expect(client.workspace_statistics.instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/Statistics')
-  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 'should set up a workspaces resource object' do
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workspaces)
-    expect(client.workspaces.instance_variable_get('@path')).to eq('/v1/Workspaces')
-  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 'should set up a workspace resource object' do
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workspace)
-    expect(client.workspace.instance_variable_get('@path')).to eq('/v1/Workspaces/someSid')
-  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
 
-  [
-      :activities, :tasks, :task_queues, :workers, :workflows
-  ].each do |method|
-    it "should delegate the client method #{method} to the workspace object" do
-      client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-      expect(client).to respond_to(method)
-      expect(client.send(method)).to eq(client.workspace.send(method))
+      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
-  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
 
-describe Twilio::REST::PricingClient do
-  it 'should have its host set to pricing.twilio.com' do
-    client = Twilio::REST::PricingClient.new('sid', 'token')
-    connection = client.instance_variable_get('@connection')
-    expect(connection.address).to eq('pricing.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 'should set up a voice resource object' do
-    client = Twilio::REST::PricingClient.new('sid', 'token')
-    expect(client).to respond_to(:voice)
-  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 'should set up a phone numbers resource object' do
-    client = Twilio::REST::PricingClient.new('sid', 'token')
-    expect(client).to respond_to(:phone_numbers)
+      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

@@ -0,0 +1,125 @@
+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

@@ -3,13 +3,36 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'bundler'
 Bundler.setup
 
-Dir.glob(File.expand_path("../support/**/*.rb", __FILE__), &method(:require))
+Dir.glob(File.expand_path('../support/**/*.rb', __FILE__), &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 +1,2 @@
 require 'fakeweb'
-FakeWeb.allow_net_connect = false
+FakeWeb.allow_net_connect = false

data/spec/twilio_spec.rb

@@ -3,13 +3,15 @@ describe Twilio do
     Twilio.instance_variable_set('@configuration', nil)
   end
 
-  it 'should set the account sid and auth token with a config block' do
+  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