twilio-ruby 3.12.2 → 3.12.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OWM4YzFhOGQ2NjI1N2Q3NmQ1YjE0YzNlNDkxNjg5NTUzMzYzNzI4Mg==
+    YTAxY2JmOWY5NjY3MTMyNTA1ZTVhMWE1NmMyZmIxYzI3NjNhYWVlYw==
   data.tar.gz: !binary |-
-    NGZjMjdmZTFjMWE4YzhlYWJjNGQ4NTkzMTkzMjY2NDgyMDIwYWRjMw==
+    NTQwYTVkMDFhMGUzNzAyMzE0NGQyN2U2YmJiMWQ5ZmE2NzZkZjVmNg==
 SHA512:
   metadata.gz: !binary |-
-    MTQ2NDhjZDVhOTc0NTJlYjRkY2FlZTEzMDc1ZmQ5NzM1M2QxNWM0YmU2OThm
-    NzRiNzQzNTA1NWU4YzlhMmE3ZDkxNDJlMzJlOWEwYzcyZmVlYTdhODZlY2Mz
-    Mzc1ZDk5MzQxODQzNzY5MTY1ZTE0NzkyNGRkZmU3YjcyNGRhOGM=
+    ZjY4MTY2ZmRlY2M0YzJhMzA3OTMxMTBlZmEwZjlkNzgxNWJmMTRiODQ4NDRh
+    OWUxYjEwOWQ5MDczNGI3MTEwZGM3ZmZkNWM5YzU1ZjNiY2NjZGI0ZTIwZTBl
+    N2JiOGQ1YTE5YTE0MDNkYWVjMjI3ZDRhMmQ3YzJhMmFiZGZlZDg=
   data.tar.gz: !binary |-
-    NWM5NTE2Y2U0ZmUwNWFjOWQ2MmRjYWUzMWNjYmIxMDc5ZmM0YmQ4ZTQxZjQz
-    MWU2NTU3YjM4OWI5OWNiMjM1MTkzY2VlNmU4Y2I4NDMwZmM3NjA4MWEwNDQx
-    ZDdmMzcxYzU5YTA1MTI2NTIxZTViYTgzYmNlMjY4MzQ1ZGJhZTQ=
+    YTA2ZWZhZDdiZDRiOWYwY2MxOThjM2RlNDkyMzZjOWUyNWI0ZjI5ZTQ3Mjc3
+    NjAxOWNjMjFlNmVhMWE3OGM5YzExNTJjNWNmNGUzMDFlMGZlYTRjMTk3MGZk
+    MDNlYTUxYzkwNDRiMWVjNDY1YjY3OGVlZjU5NDAwMWMxN2YwNTU=

data/CHANGES.md

@@ -1,6 +1,13 @@
 twilio-ruby changelog
 =====================
 
+Version 3.12.3
+--------------
+
+Released September 23, 2014
+
+- Added block configure syntax
+
 Version 3.12.2
 --------------
 

data/README.md

@@ -42,6 +42,15 @@ auth_token = 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'
 
 # set up a client to talk to the Twilio REST API
 @client = Twilio::REST::Client.new account_sid, auth_token
+
+# alternatively, you can preconfigure the client like so
+Twilio.configure do |config|
+  config.account_sid = account_sid
+  config.auth_token = auth_token
+end
+
+# and then you can create a new client without parameters
+@client = Twilio::REST::Client.new
 ```
 
 ### Send an SMS

data/docs/usage/basics.rst

@@ -27,6 +27,19 @@ Once you have your credentials, you can create create a new :class:`Client` and
 
     @client = Twilio::REST::Client.new account_sid, auth_token
 
+You can also configure the client using the top level configure method, like so:
+
+.. code-block:: ruby
+
+    require 'twilio-ruby'
+
+    Twilio.configure do |config|
+      config.account_sid = "ACXXXXXXXXXXXXXXXXX"
+      config.auth_token = "YYYYYYYYYYYYYYYYYY"
+    end
+
+    @client = Twilio::REST::Client.new
+
 
 Listing Resources
 -------------------

data/docs/usage/token-generation.rst

@@ -17,11 +17,11 @@ security and authorization. The `Capability Token documentation
 <http://www.twilio.com/docs/tokens>`_ explains in depth the purpose and
 features of these tokens.
 
-:class:`TwilioCapability` is responsible for the creation of these capability
-tokens. You'll need your Twilio AccountSid and AuthToken.
+:class:`Twilio::Util::Capability` is responsible for the creation of these
+capability tokens. You'll need your Twilio AccountSid and AuthToken.
 
 .. code-block:: ruby
-    
+
     require 'twilio-ruby'
 
     # Find these values at twilio.com/user/account
@@ -30,6 +30,21 @@ tokens. You'll need your Twilio AccountSid and AuthToken.
 
     @capability = Twilio::Util::Capability.new account_sid, auth_token
 
+You can also configure capability tokens using the top level configure method,
+like so:
+
+.. code-block:: ruby
+
+    require 'twilio-ruby'
+
+    Twilio.configure do |config|
+      config.account_sid = "ACXXXXXXXXXXXXXXXXX"
+      config.auth_token = "YYYYYYYYYYYYYYYYYY"
+    end
+
+    @capability = Twilio::Util::Capability.new
+
+
 
 Allow Incoming Connections
 ==============================

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'
@@ -59,3 +61,23 @@ 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/lib/twilio-ruby/rest/client.rb

@@ -85,7 +85,8 @@ module Twilio
 
       ##
       # Instantiate a new HTTP client to talk to Twilio. The parameters
-      # +account_sid+ and +auth_token+ are required and used to generate the
+      # +account_sid+ and +auth_token+ are required, unless you have configured
+      # them already using the block configure syntax, and used to generate the
       # HTTP basic auth header in each request. The +options+ parameter is a
       # hash of connection configuration options. the following keys are
       # supported:
@@ -148,9 +149,16 @@ module Twilio
       #
       # The number of times to retry a request that has failed before throwing
       # an exception. Defaults to one.
-      def initialize(account_sid, auth_token, options={})
-        @account_sid, @auth_token = account_sid.strip, auth_token.strip
+      def initialize(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
         @config = DEFAULTS.merge! options
+
+        @account_sid = args[0] || Twilio.account_sid
+        @auth_token = args[1] || Twilio.auth_token
+        if @account_sid.nil? || @auth_token.nil?
+          raise ArgumentError, 'Account SID and auth token are required'
+        end
+
         set_up_connection
         set_up_subresources
       end

data/lib/twilio-ruby/util/capability.rb

@@ -4,9 +4,12 @@ module Twilio
 
       include Twilio::Util
 
-      def initialize(account_sid, auth_token)
-        @account_sid = account_sid
-        @auth_token = auth_token
+      def initialize(account_sid = nil, auth_token = nil)
+        @account_sid = account_sid || Twilio.account_sid
+        @auth_token = auth_token || Twilio.auth_token
+        if @account_sid.nil? || @auth_token.nil?
+          raise ArgumentError, 'Account SID and auth token are required'
+        end
         @capabilities = []
       end
 

data/lib/twilio-ruby/util/configuration.rb

@@ -0,0 +1,7 @@
+module Twilio
+  module Util
+    class Configuration
+      attr_accessor :account_sid, :auth_token
+    end
+  end
+end

data/lib/twilio-ruby/util/request_validator.rb

@@ -2,8 +2,9 @@ module Twilio
   module Util
     class RequestValidator
 
-      def initialize(auth_token)
-        @auth_token = auth_token
+      def initialize(auth_token = nil)
+        @auth_token = auth_token || Twilio.auth_token
+        raise ArgumentError, 'Auth token is required' if @auth_token.nil?
       end
 
       def validate(url, params, signature)

data/lib/twilio-ruby/version.rb

@@ -1,3 +1,3 @@
 module Twilio
-  VERSION = '3.12.2'
+  VERSION = '3.12.3'
 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')

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

data/spec/util/capability_spec.rb

@@ -1,137 +1,186 @@
 require 'spec_helper'
 
 describe Twilio::Util::Capability do
-  before :each do
-    @capability = Twilio::Util::Capability.new 'myAccountSid', 'myAuthToken'
-  end
+  describe 'config' do
+    after(:each) do
+      Twilio.instance_variable_set('@configuration', nil)
+    end
 
-  def queries(q)
-    q.scan(/scope:client:(incoming|outgoing)\?(\S+)/).map{|(type, query)| [type, Rack::Utils.parse_query(query)]}
-  end
+    it 'should set the account sid and auth token from a configuration block' do
+      Twilio.configure do |config|
+        config.account_sid = 'someSid'
+        config.auth_token = 'someToken'
+      end
 
-  it 'should return a valid jwt when #generate is called' do
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    expect(decoded['scope']).not_to be_nil
-    expect(decoded['iss']).not_to be_nil
-    expect(decoded['exp']).not_to be_nil
-  end
+      capability = Twilio::Util::Capability.new
+      expect(capability.instance_variable_get('@account_sid')).to eq('someSid')
+      expect(capability.instance_variable_get('@auth_token')).to eq('someToken')
+    end
 
-  it 'should properly set the iss key in the payload' do
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    expect(decoded['iss']).to eq('myAccountSid')
-  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
 
-  it 'should properly set the exp key based on the default hour ttl' do
-    seconds = Time.now.to_i
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    expect(decoded['exp']).to eq(seconds + 3600)
-  end
+      capability = Twilio::Util::Capability.new'otherSid', 'otherToken'
+      expect(capability.instance_variable_get('@account_sid')).to eq('otherSid')
+      expect(capability.instance_variable_get('@auth_token')).to eq('otherToken')
+    end
 
-  it 'should properly set the exp key based on the ttl passed to #generate' do
-    ttl = rand 10000
-    seconds = Time.now.to_i
-    token = @capability.generate ttl
-    decoded, header = JWT.decode token, 'myAuthToken'
-    expect(decoded['exp']).to eq(seconds + ttl)
-  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
 
-  it 'should generate a proper incoming client scope string' do
-    @capability.allow_client_incoming 'andrew'
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    expect(queries(decoded['scope'])).to eq([['incoming', {'clientName' => 'andrew'}]])
-  end
+      capability = Twilio::Util::Capability.new 'otherSid'
+      expect(capability.instance_variable_get('@account_sid')).to eq('otherSid')
+      expect(capability.instance_variable_get('@auth_token')).to eq('someToken')
+    end
 
-  it 'should generate multiple proper incoming client scope strings' do
-    @capability.allow_client_incoming 'andrew'
-    @capability.allow_client_incoming 'bridget'
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    expect(queries(decoded['scope'])).to eq([
-      ['incoming', {'clientName' => 'andrew'}],
-      ['incoming', {'clientName' => 'bridget'}]
-    ])
-  end
+    it 'should throw an argument error if the sid and token isn\'t set' do
+      expect { Twilio::Util::Capability.new }.to raise_error(ArgumentError)
+    end
 
-  it 'should generate a proper outgoing client scope string' do
-    @capability.allow_client_outgoing 'myAppSid'
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    expect(queries(decoded['scope'])).to eq([['outgoing', {'appSid' => 'myAppSid'}]])
+    it 'should throw an argument error if only the account_sid is set' do
+      expect { Twilio::Util::Capability.new 'someSid' }.to raise_error(ArgumentError)
+    end
   end
 
-  it 'should generate a proper outgoing client scope string with parameters' do
-    app_params_hash = {'key' => 'a value', :foo => 'bar/baz'}
-    @capability.allow_client_outgoing 'myAppSid', app_params_hash
-    app_params = @capability.instance_eval {url_encode(app_params_hash)}
-    params_hash = {'appSid' => 'myAppSid', 'appParams' => app_params}
-    @capability.instance_eval {url_encode(params_hash)}
-    token = @capability.generate
-    decoded, header= JWT.decode token, 'myAuthToken'
-    expect(queries(decoded['scope'])).to eq([['outgoing', params_hash]])
-  end
+  describe 'with a capability' do
+    before :each do
+      @capability = Twilio::Util::Capability.new 'myAccountSid', 'myAuthToken'
+    end
 
-  it 'should generate a proper outgoing client scope string based on the ' +
-       'client name when calling #allow_client_incoming first' do
-    @capability.allow_client_incoming 'andrew'
-    @capability.allow_client_outgoing 'myAppSid'
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    expect(queries(decoded['scope'])).to eq([
-      ['incoming', {'clientName' => 'andrew'}],
-      ['outgoing', {'clientName' => 'andrew', 'appSid' => 'myAppSid'}]
-    ])
-  end
+    def queries(q)
+      q.scan(/scope:client:(incoming|outgoing)\?(\S+)/).map{|(type, query)| [type, Rack::Utils.parse_query(query)]}
+    end
 
-  it 'should generate a proper outgoing client scope string based on the ' +
-       'client name when calling #allow_client_incoming second' do
-    @capability.allow_client_outgoing 'myAppSid'
-    @capability.allow_client_incoming 'andrew'
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    expect(queries(decoded['scope'])).to eq([["incoming", {"clientName"=>"andrew"}], ["outgoing", {"clientName"=>"andrew", "appSid"=>"myAppSid"}]])
-  end
+    it 'should return a valid jwt when #generate is called' do
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(decoded['scope']).not_to be_nil
+      expect(decoded['iss']).not_to be_nil
+      expect(decoded['exp']).not_to be_nil
+    end
 
-  it 'should generate a proper outgoing client scope string with parameters ' +
-       'and a client name when calling #allow_client_incoming first' do
-    @capability.allow_client_incoming 'andrew'
-    app_params_hash = {'key' => 'a value', :foo => 'bar/baz'}
-    @capability.allow_client_outgoing 'myAppSid', app_params_hash
-    app_params = @capability.instance_eval {url_encode(app_params_hash)}
-    params_hash = {'appSid' => 'myAppSid', 'appParams' => app_params, 'clientName' => 'andrew'}
-    @capability.instance_eval {url_encode(params_hash)}
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    scopes = queries(decoded['scope'])
-    expect(scopes.shift).to eq(["incoming", {"clientName"=>"andrew"}])
-    scope = scopes.shift
-    expect(scope.first).to eq('outgoing')
-    expect(Rack::Utils.parse_query(scope.last['appParams'])).to eq({'key' => 'a value', 'foo' => 'bar/baz'})
-    expect(scope.last["clientName"]).to eq("andrew")
-    expect(scope.last["appSid"]).to eq("myAppSid")
-    expect(scopes).to be_empty
-  end
+    it 'should properly set the iss key in the payload' do
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(decoded['iss']).to eq('myAccountSid')
+    end
+
+    it 'should properly set the exp key based on the default hour ttl' do
+      seconds = Time.now.to_i
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(decoded['exp']).to eq(seconds + 3600)
+    end
+
+    it 'should properly set the exp key based on the ttl passed to #generate' do
+      ttl = rand 10000
+      seconds = Time.now.to_i
+      token = @capability.generate ttl
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(decoded['exp']).to eq(seconds + ttl)
+    end
+
+    it 'should generate a proper incoming client scope string' do
+      @capability.allow_client_incoming 'andrew'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([['incoming', {'clientName' => 'andrew'}]])
+    end
+
+    it 'should generate multiple proper incoming client scope strings' do
+      @capability.allow_client_incoming 'andrew'
+      @capability.allow_client_incoming 'bridget'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([
+        ['incoming', {'clientName' => 'andrew'}],
+        ['incoming', {'clientName' => 'bridget'}]
+      ])
+    end
+
+    it 'should generate a proper outgoing client scope string' do
+      @capability.allow_client_outgoing 'myAppSid'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([['outgoing', {'appSid' => 'myAppSid'}]])
+    end
+
+    it 'should generate a proper outgoing client scope string with parameters' do
+      app_params_hash = {'key' => 'a value', :foo => 'bar/baz'}
+      @capability.allow_client_outgoing 'myAppSid', app_params_hash
+      app_params = @capability.instance_eval {url_encode(app_params_hash)}
+      params_hash = {'appSid' => 'myAppSid', 'appParams' => app_params}
+      @capability.instance_eval {url_encode(params_hash)}
+      token = @capability.generate
+      decoded, header= JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([['outgoing', params_hash]])
+    end
+
+    it 'should generate a proper outgoing client scope string based on the ' +
+         'client name when calling #allow_client_incoming first' do
+      @capability.allow_client_incoming 'andrew'
+      @capability.allow_client_outgoing 'myAppSid'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([
+        ['incoming', {'clientName' => 'andrew'}],
+        ['outgoing', {'clientName' => 'andrew', 'appSid' => 'myAppSid'}]
+      ])
+    end
+
+    it 'should generate a proper outgoing client scope string based on the ' +
+         'client name when calling #allow_client_incoming second' do
+      @capability.allow_client_outgoing 'myAppSid'
+      @capability.allow_client_incoming 'andrew'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([["incoming", {"clientName"=>"andrew"}], ["outgoing", {"clientName"=>"andrew", "appSid"=>"myAppSid"}]])
+    end
+
+    it 'should generate a proper outgoing client scope string with parameters ' +
+         'and a client name when calling #allow_client_incoming first' do
+      @capability.allow_client_incoming 'andrew'
+      app_params_hash = {'key' => 'a value', :foo => 'bar/baz'}
+      @capability.allow_client_outgoing 'myAppSid', app_params_hash
+      app_params = @capability.instance_eval {url_encode(app_params_hash)}
+      params_hash = {'appSid' => 'myAppSid', 'appParams' => app_params, 'clientName' => 'andrew'}
+      @capability.instance_eval {url_encode(params_hash)}
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      scopes = queries(decoded['scope'])
+      expect(scopes.shift).to eq(["incoming", {"clientName"=>"andrew"}])
+      scope = scopes.shift
+      expect(scope.first).to eq('outgoing')
+      expect(Rack::Utils.parse_query(scope.last['appParams'])).to eq({'key' => 'a value', 'foo' => 'bar/baz'})
+      expect(scope.last["clientName"]).to eq("andrew")
+      expect(scope.last["appSid"]).to eq("myAppSid")
+      expect(scopes).to be_empty
+    end
 
-  it 'should generate a proper outgoing client scope string with parameters ' +
-       'and a client name when calling #allow_client_incoming second' do
-    app_params_hash = {'key' => 'a value', :foo => 'bar/baz'}
-    @capability.allow_client_outgoing 'myAppSid', app_params_hash
-    @capability.allow_client_incoming 'andrew'
-    app_params = @capability.instance_eval {url_encode(app_params_hash)}
-    params_hash = {'appSid' => 'myAppSid', 'appParams' => app_params, 'clientName' => 'andrew'}
-    @capability.instance_eval {url_encode(params_hash)}
-    token = @capability.generate
-    decoded, header = JWT.decode token, 'myAuthToken'
-    scopes = queries(decoded['scope'])
-    expect(scopes.shift).to eq(["incoming", {"clientName"=>"andrew"}])
-    scope = scopes.shift
-    expect(scope.first).to eq('outgoing')
-    expect(Rack::Utils.parse_query(scope.last['appParams'])).to eq({'key' => 'a value', 'foo' => 'bar/baz'})
-    expect(scope.last["clientName"]).to eq("andrew")
-    expect(scope.last["appSid"]).to eq("myAppSid")
-    expect(scopes).to be_empty
+    it 'should generate a proper outgoing client scope string with parameters ' +
+         'and a client name when calling #allow_client_incoming second' do
+      app_params_hash = {'key' => 'a value', :foo => 'bar/baz'}
+      @capability.allow_client_outgoing 'myAppSid', app_params_hash
+      @capability.allow_client_incoming 'andrew'
+      app_params = @capability.instance_eval {url_encode(app_params_hash)}
+      params_hash = {'appSid' => 'myAppSid', 'appParams' => app_params, 'clientName' => 'andrew'}
+      @capability.instance_eval {url_encode(params_hash)}
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      scopes = queries(decoded['scope'])
+      expect(scopes.shift).to eq(["incoming", {"clientName"=>"andrew"}])
+      scope = scopes.shift
+      expect(scope.first).to eq('outgoing')
+      expect(Rack::Utils.parse_query(scope.last['appParams'])).to eq({'key' => 'a value', 'foo' => 'bar/baz'})
+      expect(scope.last["clientName"]).to eq("andrew")
+      expect(scope.last["appSid"]).to eq("myAppSid")
+      expect(scopes).to be_empty
+    end
   end
 end

data/spec/util/configuration_spec.rb

@@ -0,0 +1,13 @@
+describe Twilio::Util::Configuration do
+  it 'should have an account sid attribute' do
+    config = Twilio::Util::Configuration.new
+    config.account_sid = 'someSid'
+    expect(config.account_sid).to eq('someSid')
+  end
+
+  it 'should have an auth token attribute' do
+    config = Twilio::Util::Configuration.new
+    config.auth_token = 'someToken'
+    expect(config.auth_token).to eq('someToken')
+  end
+end

data/spec/util/request_validator_spec.rb

@@ -1,6 +1,34 @@
 require 'spec_helper'
 
 describe Twilio::Util::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::Util::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::Util::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::Util::RequestValidator.new }.to raise_error(ArgumentError)
+    end
+  end
+
   it 'should properly validate a Twilio Voice request' do
     token = '2bd9e9638872de601313dc77410d3b23'
     validator = Twilio::Util::RequestValidator.new token
@@ -62,4 +90,4 @@ describe Twilio::Util::RequestValidator do
     signature = 'mxeiv65lEe0b8L6LdVw2jgJi8yw='
     expect(validator.validate(url, params, signature)).to eq(true)
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twilio-ruby
 version: !ruby/object:Gem::Version
-  version: 3.12.2
+  version: 3.12.3
 platform: ruby
 authors:
 - Andrew Benton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-29 00:00:00.000000000 Z
+date: 2014-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -175,6 +175,7 @@ files:
 - lib/twilio-ruby/twiml/response.rb
 - lib/twilio-ruby/util.rb
 - lib/twilio-ruby/util/capability.rb
+- lib/twilio-ruby/util/configuration.rb
 - lib/twilio-ruby/util/request_validator.rb
 - lib/twilio-ruby/version.rb
 - spec/rack/twilio_webhook_authentication_spec.rb
@@ -191,7 +192,9 @@ files:
 - spec/rest/recording_spec.rb
 - spec/spec_helper.rb
 - spec/support/fakeweb.rb
+- spec/twilio_spec.rb
 - spec/util/capability_spec.rb
+- spec/util/configuration_spec.rb
 - spec/util/request_validator_spec.rb
 - spec/util/url_encode_spec.rb
 - twilio-ruby.gemspec
@@ -241,6 +244,8 @@ test_files:
 - spec/rest/recording_spec.rb
 - spec/spec_helper.rb
 - spec/support/fakeweb.rb
+- spec/twilio_spec.rb
 - spec/util/capability_spec.rb
+- spec/util/configuration_spec.rb
 - spec/util/request_validator_spec.rb
 - spec/util/url_encode_spec.rb