twilio-ruby 3.11.5 → 3.12.3

data/lib/twilio-ruby.rb

@@ -5,10 +5,12 @@ require 'multi_json'
 require 'cgi'
 require 'openssl'
 require 'base64'
+require 'forwardable'
 require 'jwt'
 
 require 'twilio-ruby/version' unless defined?(Twilio::VERSION)
 require 'twilio-ruby/util'
+require 'twilio-ruby/util/configuration'
 require 'twilio-ruby/util/request_validator'
 require 'twilio-ruby/util/capability'
 require 'twilio-ruby/twiml/response'
@@ -19,6 +21,8 @@ require 'twilio-ruby/rest/instance_resource'
 require 'twilio-ruby/rest/sandbox'
 require 'twilio-ruby/rest/accounts'
 require 'twilio-ruby/rest/calls'
+require 'twilio-ruby/rest/call_feedback'
+require 'twilio-ruby/rest/call_feedback_summary'
 require 'twilio-ruby/rest/sms'
 require 'twilio-ruby/rest/sms/short_codes'
 require 'twilio-ruby/rest/sms/messages'
@@ -56,3 +60,24 @@ require 'twilio-ruby/rest/recordings'
 require 'twilio-ruby/rest/transcriptions'
 require 'twilio-ruby/rest/notifications'
 require 'twilio-ruby/rest/client'
+require 'rack/twilio_webhook_authentication'
+
+module Twilio
+  extend SingleForwardable
+
+  def_delegators :configuration, :account_sid, :auth_token
+
+  ##
+  # Pre-configure with account SID and auth token so that you don't need to
+  # pass them to various initializers each time.
+  def self.configure(&block)
+    yield configuration
+  end
+
+  ##
+  # Returns an existing or instantiates a new configuration object.
+  def self.configuration
+    @configuration ||= Util::Configuration.new
+  end
+  private_class_method :configuration
+end

data/spec/rack/twilio_webhook_authentication_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'rack/mock'
+
+describe Rack::TwilioWebhookAuthentication do
+  before do
+    @app = lambda {|env| [200, {'Content-Type' => 'text/plain'}, ['Hello']] }
+  end
+
+  describe 'new' do
+    it 'should initialize with an app, auth token and a path' do
+      expect {
+        Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/)
+      }.not_to raise_error
+    end
+
+    it 'should initialize with an app, auth token and paths' do
+      expect {
+        Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/, /\/sms/)
+      }.not_to raise_error
+    end
+  end
+
+  describe 'calling against one path' do
+    before do
+      @middleware = Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/)
+    end
+
+    it 'should not intercept when the path doesn\'t match' do
+      expect(Twilio::Util::RequestValidator).to_not receive(:validate)
+      request = Rack::MockRequest.env_for('/sms')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    end
+
+    it 'should allow a request through if it validates' do
+      expect_any_instance_of(Twilio::Util::RequestValidator).to receive(:validate).and_return(true)
+      request = Rack::MockRequest.env_for('/voice')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    end
+
+    it 'should short circuit a request to 403 if it does not validate' do
+      expect_any_instance_of(Twilio::Util::RequestValidator).to receive(:validate).and_return(false)
+      request = Rack::MockRequest.env_for('/voice')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(403)
+    end
+  end
+
+  describe 'calling against many paths' do
+    before do
+      @middleware = Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/, /\/sms/)
+    end
+
+    it 'should not intercept when the path doesn\'t match' do
+      expect(Twilio::Util::RequestValidator).to_not receive(:validate)
+      request = Rack::MockRequest.env_for('icesms')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    end
+
+    it 'shold allow a request through if it validates' do
+      expect_any_instance_of(Twilio::Util::RequestValidator).to receive(:validate).and_return(true)
+      request = Rack::MockRequest.env_for('/sms')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    end
+
+    it 'should short circuit a request to 403 if it does not validate' do
+      expect_any_instance_of(Twilio::Util::RequestValidator).to receive(:validate).and_return(false)
+      request = Rack::MockRequest.env_for('/sms')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(403)
+    end
+  end
+end

data/spec/rest/account_spec.rb

@@ -7,52 +7,52 @@ describe Twilio::REST::Account do
   end
 
   it 'sets up incoming phone numbers resources object' do
-    @account.should respond_to(:incoming_phone_numbers)
-    @account.incoming_phone_numbers.instance_variable_get('@path').should == 'someUri/IncomingPhoneNumbers'
+    expect(@account).to respond_to(:incoming_phone_numbers)
+    expect(@account.incoming_phone_numbers.instance_variable_get('@path')).to eq('someUri/IncomingPhoneNumbers')
   end
 
   it 'sets up an available phone numbers resources object' do
-    @account.should respond_to(:available_phone_numbers)
-    @account.available_phone_numbers.instance_variable_get('@path').should == 'someUri/AvailablePhoneNumbers'
+    expect(@account).to respond_to(:available_phone_numbers)
+    expect(@account.available_phone_numbers.instance_variable_get('@path')).to eq('someUri/AvailablePhoneNumbers')
   end
 
   it 'sets up an outgoing caller ids resources object' do
-    @account.should respond_to(:outgoing_caller_ids)
-    @account.outgoing_caller_ids.instance_variable_get('@path').should == 'someUri/OutgoingCallerIds'
+    expect(@account).to respond_to(:outgoing_caller_ids)
+    expect(@account.outgoing_caller_ids.instance_variable_get('@path')).to eq('someUri/OutgoingCallerIds')
   end
 
   it 'sets up a calls resources object' do
-    @account.should respond_to(:calls)
-    @account.calls.instance_variable_get('@path').should == 'someUri/Calls'
+    expect(@account).to respond_to(:calls)
+    expect(@account.calls.instance_variable_get('@path')).to eq('someUri/Calls')
   end
 
   it 'sets up a conferences resources object' do
-    @account.should respond_to(:conferences)
-    @account.conferences.instance_variable_get('@path').should == 'someUri/Conferences'
+    expect(@account).to respond_to(:conferences)
+    expect(@account.conferences.instance_variable_get('@path')).to eq('someUri/Conferences')
   end
 
   it 'sets up a queues resources object' do
-    @account.should respond_to(:queues)
-    @account.queues.instance_variable_get('@path').should == 'someUri/Queues'
+    expect(@account).to respond_to(:queues)
+    expect(@account.queues.instance_variable_get('@path')).to eq('someUri/Queues')
   end
 
   it 'sets up a sms resource object' do
-    @account.should respond_to(:sms)
-    @account.sms.instance_variable_get('@path').should == 'someUri/SMS'
+    expect(@account).to respond_to(:sms)
+    expect(@account.sms.instance_variable_get('@path')).to eq('someUri/SMS')
   end
 
   it 'sets up a recordings resources object' do
-    @account.should respond_to(:recordings)
-    @account.recordings.instance_variable_get('@path').should == 'someUri/Recordings'
+    expect(@account).to respond_to(:recordings)
+    expect(@account.recordings.instance_variable_get('@path')).to eq('someUri/Recordings')
   end
 
   it 'sets up a transcriptions resources object' do
-    @account.should respond_to(:transcriptions)
-    @account.transcriptions.instance_variable_get('@path').should == 'someUri/Transcriptions'
+    expect(@account).to respond_to(:transcriptions)
+    expect(@account.transcriptions.instance_variable_get('@path')).to eq('someUri/Transcriptions')
   end
 
   it 'sets up a notifications resources object' do
-    @account.should respond_to(:notifications)
-    @account.notifications.instance_variable_get('@path').should == 'someUri/Notifications'
+    expect(@account).to respond_to(:notifications)
+    expect(@account.notifications.instance_variable_get('@path')).to eq('someUri/Notifications')
   end
 end

data/spec/rest/call_feedback_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Twilio::REST::Feedback do
+  before do
+    @call = Twilio::REST::Call.new('someUri', 'someClient')
+  end
+
+  it 'sets up a feedback resources object' do
+    expect(@call).to respond_to(:feedback)
+    expect(@call.feedback.instance_variable_get('@path')).to eq('someUri/Feedback')
+  end
+end

data/spec/rest/call_feedback_summary_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Twilio::REST::FeedbackSummary do
+  it 'creates a feedback summary object' do
+    calls = Twilio::REST::Calls.new('someUri', 'someClient')
+    expect(calls).to respond_to(:feedback_summary)
+    expect(calls.feedback_summary.instance_variable_get('@path')).to eq('someUri/FeedbackSummary')
+  end
+end

data/spec/rest/call_spec.rb

@@ -7,12 +7,12 @@ describe Twilio::REST::Call do
   end
 
   it 'sets up a recordings resources object' do
-    @call.should respond_to(:recordings)
-    @call.recordings.instance_variable_get('@path').should == 'someUri/Recordings'
+    expect(@call).to respond_to(:recordings)
+    expect(@call.recordings.instance_variable_get('@path')).to eq('someUri/Recordings')
   end
 
   it 'sets up a notifications resources object' do
-    @call.should respond_to(:notifications)
-    @call.notifications.instance_variable_get('@path').should == 'someUri/Notifications'
+    expect(@call).to respond_to(:notifications)
+    expect(@call.notifications.instance_variable_get('@path')).to eq('someUri/Notifications')
   end
 end

data/spec/rest/client_spec.rb

@@ -1,6 +1,65 @@
 require 'spec_helper'
 
 describe Twilio::REST::Client do
+  describe 'config at class level' do
+    after(:each) do
+      Twilio.instance_variable_set('@configuration', nil)
+    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
+
+      client = Twilio::REST::Client.new
+      expect(client.account_sid).to eq('someSid')
+      expect(client.instance_variable_get('@auth_token')).to eq('someToken')
+    end
+
+    it 'should overwrite account sid and auth token if passed to initializer' do
+      Twilio.configure do |config|
+        config.account_sid = 'someSid'
+        config.auth_token = 'someToken'
+      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')
+    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'
+      end
+
+      client = Twilio::REST::Client.new 'otherSid'
+      expect(client.account_sid).to eq('otherSid')
+      expect(client.instance_variable_get('@auth_token')).to eq('someToken')
+    end
+
+    it 'should allow options after setting up auth with config' do
+      Twilio.configure do |config|
+        config.account_sid = 'someSid'
+        config.auth_token = 'someToken'
+      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)
+    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)
+    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')
@@ -17,84 +76,101 @@ describe Twilio::REST::Client do
 
   it 'should set up a new client instance with the given sid and token' do
     twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    twilio.account_sid.should == 'someSid'
-    twilio.instance_variable_get('@auth_token').should == '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')
-    connection.address.should == 'api.twilio.com'
-    connection.port.should == 443
-    connection.use_ssl?.should == true
+    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')
-    connection.ca_file.should == '/path/to/ca/file'
+    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')
-    connection.address.should == 'api.faketwilio.com'
-    connection.port.should == 443
-    connection.use_ssl?.should == true
+    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')
-    connection.port.should == 443
-    connection.use_ssl?.should == true
-    connection.open_timeout.should == timeout
-    connection.read_timeout.should == timeout
+    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')
-    connection.proxy?.should == true
-    connection.proxy_address.should == 'localhost'
-    connection.proxy_port.should == 80
-    connection.address.should == 'api.faketwilio.com'
-    connection.port.should == 443
-    connection.use_ssl?.should == true
+    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')
-    connection.proxy?.should == true
-    connection.proxy_address.should == 'localhost'
-    connection.proxy_port.should == 13128
-    connection.address.should == 'api.faketwilio.com'
-    connection.port.should == 443
-    connection.use_ssl?.should == true
+    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')
-    twilio.should respond_to(:accounts)
-    twilio.accounts.instance_variable_get('@path').should == '/2010-04-01/Accounts'
+    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')
-    twilio.should respond_to(:account)
-    twilio.account.instance_variable_get('@path').should == '/2010-04-01/Accounts/someSid'
+    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))
+    end
   end
 
   it 'should convert all parameter names to Twilio-style names' do
     twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    untwilified = {:sms_url => 'someUrl', 'voiceFallbackUrl' => 'anotherUrl',
-      'Status_callback' => 'yetAnotherUrl'}
-    twilified = {:SmsUrl => 'someUrl', :VoiceFallbackUrl => 'anotherUrl',
-      :StatusCallback => 'yetAnotherUrl'}
-    twilio.instance_eval do
-      twilify(untwilified).should == twilified
-    end
+    untwilified = {
+      :sms_url => 'someUrl',
+      'voiceFallbackUrl' => 'anotherUrl',
+      'Status_callback' => 'yetAnotherUrl'
+    }
+    twilified = {
+      :SmsUrl => 'someUrl',
+      :VoiceFallbackUrl => 'anotherUrl',
+      :StatusCallback => 'yetAnotherUrl'
+    }
+    expect(twilio.twilify(untwilified)).to eq(twilified)
   end
 end

data/spec/rest/conference_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Twilio::REST::Conference do
   it 'should set up a participants resources object' do
     conference = Twilio::REST::Conference.new('someUri', 'someClient')
-    conference.should respond_to(:participants)
-    conference.participants.instance_variable_get('@path').should == 'someUri/Participants'
+    expect(conference).to respond_to(:participants)
+    expect(conference.participants.instance_variable_get('@path')).to eq('someUri/Participants')
   end
 end

data/spec/rest/instance_resource_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Twilio::REST::InstanceResource do
   it 'should set up an internal reference to the uri and client' do
     resource = Twilio::REST::InstanceResource.new('some/uri', 'someClient')
-    resource.instance_variable_get('@path').should == 'some/uri'
-    resource.instance_variable_get('@client').should == 'someClient'
+    expect(resource.instance_variable_get('@path')).to eq('some/uri')
+    expect(resource.instance_variable_get('@client')).to eq('someClient')
   end
 
   it 'should set up object properties if passed' do
     params = {'SomeKey' => 'someValue'}
     resource = Twilio::REST::InstanceResource.new('uri', 'client', params)
-    resource.some_key.should == 'someValue'
+    expect(resource.some_key).to eq('someValue')
   end
 end

data/spec/rest/message_spec.rb

@@ -6,7 +6,7 @@ describe Twilio::REST::Message do
   end
 
   it 'sets up a media resources object' do
-    @message.should respond_to(:media)
-    @message.media.instance_variable_get('@path').should == 'someUri/Media'
+    expect(@message).to respond_to(:media)
+    expect(@message.media.instance_variable_get('@path')).to eq('someUri/Media')
   end
 end

data/spec/rest/numbers_spec.rb

@@ -7,18 +7,18 @@ describe Twilio::REST::Country do
   end
 
   it 'sets up a local resources object' do
-    @country.should respond_to(:local)
-    @country.local.instance_variable_get('@path').should == 'someUri/Local'
+    expect(@country).to respond_to(:local)
+    expect(@country.local.instance_variable_get('@path')).to eq('someUri/Local')
   end
 
   it 'sets up a toll_free resources object' do
-    @country.should respond_to(:toll_free)
-    @country.toll_free.instance_variable_get('@path').should == 'someUri/TollFree'
+    expect(@country).to respond_to(:toll_free)
+    expect(@country.toll_free.instance_variable_get('@path')).to eq('someUri/TollFree')
   end
 
   it 'sets up a mobile resources object' do
-    @country.should respond_to(:mobile)
-    @country.mobile.instance_variable_get('@path').should == 'someUri/Mobile'
+    expect(@country).to respond_to(:mobile)
+    expect(@country.mobile.instance_variable_get('@path')).to eq('someUri/Mobile')
   end
 
 end
@@ -30,17 +30,17 @@ describe Twilio::REST::NumberType do
   end
 
   it 'sets up a local resources object' do
-    @incoming_phone_numbers.should respond_to(:local)
-    @incoming_phone_numbers.local.instance_variable_get('@path').should == 'someUri/Local'
+    expect(@incoming_phone_numbers).to respond_to(:local)
+    expect(@incoming_phone_numbers.local.instance_variable_get('@path')).to eq('someUri/Local')
   end
 
   it 'sets up a toll_free resources object' do
-    @incoming_phone_numbers.should respond_to(:toll_free)
-    @incoming_phone_numbers.toll_free.instance_variable_get('@path').should == 'someUri/TollFree'
+    expect(@incoming_phone_numbers).to respond_to(:toll_free)
+    expect(@incoming_phone_numbers.toll_free.instance_variable_get('@path')).to eq('someUri/TollFree')
   end
 
   it 'sets up a mobile resources object' do
-    @incoming_phone_numbers.should respond_to(:mobile)
-    @incoming_phone_numbers.mobile.instance_variable_get('@path').should == 'someUri/Mobile'
+    expect(@incoming_phone_numbers).to respond_to(:mobile)
+    expect(@incoming_phone_numbers.mobile.instance_variable_get('@path')).to eq('someUri/Mobile')
   end
 end

data/spec/rest/queue_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Twilio::REST::Queue do
   it 'should set up a members resources object' do
     queue = Twilio::REST::Queue.new('someUri', 'someClient')
-    queue.should respond_to(:members)
-    queue.members.instance_variable_get('@path').should == 'someUri/Members'
+    expect(queue).to respond_to(:members)
+    expect(queue.members.instance_variable_get('@path')).to eq('someUri/Members')
   end
 end

data/spec/rest/recording_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Twilio::REST::Recording do
   it 'should set up a transcriptions resources object' do
     call = Twilio::REST::Recording.new('someUri', 'someClient')
-    call.should respond_to(:transcriptions)
-    call.transcriptions.instance_variable_get('@path').should == 'someUri/Transcriptions'
+    expect(call).to respond_to(:transcriptions)
+    expect(call.transcriptions.instance_variable_get('@path')).to eq('someUri/Transcriptions')
   end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,15 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'bundler'
+Bundler.setup
+
+Dir.glob(File.expand_path("../support/**/*.rb", __FILE__), &method(:require))
+
 require 'twilio-ruby'
-require 'fakeweb'
 require 'rack'
 
-FakeWeb.allow_net_connect = false
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/support/fakeweb.rb

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

data/spec/twilio_spec.rb

@@ -0,0 +1,15 @@
+describe Twilio do
+  after(:each) do
+    Twilio.instance_variable_set('@configuration', nil)
+  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
+
+    expect(Twilio.account_sid).to eq('someSid')
+    expect(Twilio.auth_token).to eq('someToken')
+  end
+end