twilio-ruby 3.11.5 → 4.0.0

data/spec/task_router_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Twilio::TaskRouter::Capability do
+  describe 'with a capability' do
+    before :each do
+      @capability = Twilio::TaskRouter::Capability.new 'AC123', 'foobar', 'WS456', 'WK789'
+    end
+
+    it 'should return a valid jwt when #generate_token is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies']).not_to be_nil
+      expect(decoded['iss']).not_to be_nil
+      expect(decoded['exp']).not_to be_nil
+    end
+
+    it 'should properly set the iss key in the payload' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['iss']).to eq('AC123')
+    end
+
+    it 'should properly set exp based on the default 1-hour ttl' do
+      seconds = Time.now.to_i
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + 3600)
+    end
+
+    it 'should properly set exp based on the ttl arg to #generate_token' do
+      seconds = Time.now.to_i
+      ttl = rand 10000
+      token = @capability.generate_token ttl
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + ttl)
+    end
+
+    it 'should allow websocket operations and activity list fetches by default' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(3)
+      get_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WK789',
+        "method" => 'GET',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][0]).to eq(get_policy)
+      post_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WK789',
+        "method" => 'POST',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][1]).to eq(post_policy)
+
+      activities_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Activities',
+        'method' => 'GET',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][2]).to eq(activities_policy)
+    end
+
+    it 'should add a policy when #allow_worker_activity_updates is called' do
+      @capability.allow_worker_activity_updates
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(4)
+      activity_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789',
+        'method' => 'POST',
+        'query_filter' => {},
+        'post_filter' => {'ActivitySid' => {'required' => true}},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(activity_policy)
+    end
+
+    it 'should add a policy when #allow_worker_fetch_attributes is called' do
+      @capability.allow_worker_fetch_attributes
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(4)
+      worker_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789',
+        'method' => 'GET',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(worker_policy)
+    end
+
+    it 'should add a policy when #allow_task_reservation_updates is called' do
+      @capability.allow_task_reservation_updates
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(4)
+      task_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Tasks/**',
+        'method' => 'POST',
+        'query_filter' => {},
+        'post_filter' => {'ReservationStatus' => {'required' => true}},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(task_policy)
+    end
+  end
+end

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 = JWT.decode token, 'myAuthToken'
-    decoded['scope'].should_not be_nil
-    decoded['iss'].should_not be_nil
-    decoded['exp'].should_not 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 = JWT.decode token, 'myAuthToken'
-    decoded['iss'].should == '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 = JWT.decode token, 'myAuthToken'
-    decoded['exp'].should == 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 = JWT.decode token, 'myAuthToken'
-    decoded['exp'].should == 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 = JWT.decode token, 'myAuthToken'
-    queries(decoded['scope']).should == [['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 = JWT.decode token, 'myAuthToken'
-    queries(decoded['scope']).should == [
-      ['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 = JWT.decode token, 'myAuthToken'
-    queries(decoded['scope']).should == [['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 = JWT.decode token, 'myAuthToken'
-    queries(decoded['scope']).should == [['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 = JWT.decode token, 'myAuthToken'
-    queries(decoded['scope']).should == [
-      ['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 = JWT.decode token, 'myAuthToken'
-    queries(decoded['scope']).should == [["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 = JWT.decode token, 'myAuthToken'
-    scopes = queries(decoded['scope'])
-    scopes.shift.should == ["incoming", {"clientName"=>"andrew"}]
-    scope = scopes.shift
-    scope.first.should == 'outgoing'
-    Rack::Utils.parse_query(scope.last['appParams']).should == {'key' => 'a value', 'foo' => 'bar/baz'}
-    scope.last["clientName"].should == "andrew"
-    scope.last["appSid"].should == "myAppSid"
-    scopes.should 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 = JWT.decode token, 'myAuthToken'
-    scopes = queries(decoded['scope'])
-    scopes.shift.should == ["incoming", {"clientName"=>"andrew"}]
-    scope = scopes.shift
-    scope.first.should == 'outgoing'
-    Rack::Utils.parse_query(scope.last['appParams']).should == {'key' => 'a value', 'foo' => 'bar/baz'}
-    scope.last["clientName"].should == "andrew"
-    scope.last["appSid"].should == "myAppSid"
-    scopes.should 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/client_config_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Twilio::Util::ClientConfig do
+  Twilio::Util::ClientConfig::DEFAULTS.each do |attribute, value|
+    it "sets an attribute with a default value" do
+      config = Twilio::Util::ClientConfig.new
+      expect(config.send(attribute)).to eq(value)
+    end
+
+    it "can update the value for the attribute" do
+      config = Twilio::Util::ClientConfig.new
+      config.send("#{attribute}=", "blah")
+      expect(config.send(attribute)).to eq("blah")
+    end
+
+    it "can set the value from a hash in the initializer" do
+      config = Twilio::Util::ClientConfig.new(attribute => 'blah')
+      expect(config.send(attribute)).to eq("blah")
+    end
+  end
+end

data/spec/util/configuration_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+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
@@ -34,7 +62,7 @@ describe Twilio::Util::RequestValidator do
       'ApplicationSid' => 'AP44efecad51364e80b133bb7c07eb8204'
     }
     signature = 'oVb2kXoVy8GEfwBDjR8bk/ZZ6eA='
-    validator.validate(url, params, signature).should == true
+    expect(validator.validate(url, params, signature)).to eq(true)
   end
 
   it 'should properly validate a Twilio SMS request' do
@@ -60,6 +88,6 @@ describe Twilio::Util::RequestValidator do
       'SmsSid' => 'SM2003cbd5e6a3701999aa3e5f20ff2787'
     }
     signature = 'mxeiv65lEe0b8L6LdVw2jgJi8yw='
-    validator.validate(url, params, signature).should == true
+    expect(validator.validate(url, params, signature)).to eq(true)
   end
-end
+end

data/spec/util/url_encode_spec.rb

@@ -5,8 +5,8 @@ describe Twilio::Util do
 
   it 'should parse a Date object' do
     today = Time.now
-    url = url_encode({'DateSent>' => today})
+    url = url_encode('DateSent>' => today)
 
-    url.should == "DateSent%3E=#{today.strftime('%Y-%m-%d')}"
+    expect(url).to eq("DateSent%3E=#{today.strftime('%Y-%m-%d')}")
   end
 end

data/twilio-ruby.gemspec

@@ -1,33 +1,34 @@
-require './lib/twilio-ruby/version'
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'twilio-ruby/version'
 
-Gem::Specification.new do |s|
-  s.name = 'twilio-ruby'
-  s.version = Twilio::VERSION
-  s.author = 'Andrew Benton'
-  s.email = 'andrew@twilio.com'
+Gem::Specification.new do |spec|
+  spec.name          = 'twilio-ruby'
+  spec.version       = Twilio::VERSION
+  spec.authors       = ['Andrew Benton']
+  spec.email         = ['andrew@twilio.com']
+  spec.summary       = 'A simple library for communicating with the Twilio REST API, building TwiML, and generating Twilio Client Capability Tokens'
+  spec.description   = 'A simple library for communicating with the Twilio REST API, building TwiML, and generating Twilio Client Capability Tokens'
+  spec.homepage      = 'http://github.com/twilio/twilio-ruby'
+  spec.license       = 'MIT'
 
-  s.description = 'A simple library for communicating with the Twilio REST API, building TwiML, and generating Twilio Client Capability Tokens'
-  s.summary = 'A simple library for communicating with the Twilio REST API, building TwiML, and generating Twilio Client Capability Tokens'
-  s.homepage = 'http://github.com/twilio/twilio-ruby'
-  s.license = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 1.9.3'
+  spec.extra_rdoc_files = ['README.md', 'LICENSE.md']
+  spec.rdoc_options = ['--line-numbers', '--inline-source', '--title', 'twilio-ruby', '--main', 'README.md']
 
-  s.platform = Gem::Platform::RUBY
-  s.require_paths = %w[lib]
-  s.files = `git ls-files`.split("\n")
-  s.test_files = Dir['spec/**/*.rb']
-
-  s.add_dependency('multi_json', '>= 1.3.0')
-  s.add_dependency('builder', '>= 2.1.2')
-  s.add_dependency('jwt', '>= 0.1.2')
-  s.add_dependency('jruby-openssl') if RUBY_PLATFORM == 'java'
+  spec.add_dependency('multi_json', '>= 1.3.0')
+  spec.add_dependency('builder', '>= 2.1.2')
+  spec.add_dependency('jwt', '~> 1.0')
+  spec.add_dependency('jruby-openssl') if RUBY_PLATFORM == 'java'
   # Workaround for RBX <= 2.2.1, should be fixed in next version
-  s.add_dependency('rubysl') if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-
-  s.add_development_dependency 'rake',    '~> 0.9.0'
-  s.add_development_dependency 'rspec',   '~> 2.6.0'
-  s.add_development_dependency 'fakeweb', '~> 1.3.0'
-  s.add_development_dependency 'rack',    '~> 1.3.0'
+  spec.add_dependency('rubysl') if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
 
-  s.extra_rdoc_files = ['README.md', 'LICENSE']
-  s.rdoc_options = ['--line-numbers', '--inline-source', '--title', 'twilio-ruby', '--main', 'README.md']
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.extra_rdoc_files = ['README.md', 'LICENSE.md']
+  spec.rdoc_options = ['--line-numbers', '--inline-source', '--title', 'twilio-ruby', '--main', 'README.md']
 end