twilio-ruby 4.6.1 → 6.9.0

data/spec/task_router_workspace_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::TaskRouter::Capability do
-  describe 'with a capability' do
-    before :each do
-      @capability = Twilio::TaskRouter::WorkspaceCapability.new 'AC123', 'foobar', 'WS456'
-    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
-      expect(decoded['account_sid']).to eq('AC123')
-      expect(decoded['workspace_sid']).to eq('WS456')
-      expect(decoded['channel']).to eq('WS456')
-    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 fetching the workspace 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/WS456',
-        "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/WS456',
-        "method" => 'POST',
-        "query_filter" => {},
-        "post_filter" => {},
-        "allow" => true
-      }
-      expect(decoded['policies'][1]).to eq(post_policy)
-
-      workspace_fetch_policy = {
-          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456',
-          'method' => 'GET',
-          'query_filter' => {},
-          'post_filter' => {},
-          'allow' => true
-      }
-      expect(decoded['policies'][2]).to eq(workspace_fetch_policy)
-    end
-
-    it 'should add a policy when #allow_fetch_subresources is called' do
-      token = @capability.generate_token
-      decoded, header = JWT.decode token, 'foobar'
-      policies_size = decoded['policies'].size
-
-      @capability.allow_fetch_subresources
-      token = @capability.generate_token
-      decoded, header = JWT.decode token, 'foobar'
-      workspace_fetch_policy = {
-        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/**',
-        'method' => 'GET',
-        'query_filter' => {},
-        'post_filter' => {},
-        'allow' => true
-      }
-      expect(decoded['policies'][-1]).to eq(workspace_fetch_policy)
-      expect(decoded['policies'].size).to eq(policies_size+1)
-    end
-
-    it 'should add a policy when #allow_update_subresources is called' do
-      token = @capability.generate_token
-      decoded, header = JWT.decode token, 'foobar'
-      policies_size = decoded['policies'].size
-
-      @capability.allow_updates_subresources
-      token = @capability.generate_token
-      decoded, header = JWT.decode token, 'foobar'
-      workspace_update_policy = {
-        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/**',
-        'method' => 'POST',
-        'query_filter' => {},
-        'post_filter' => {},
-        'allow' => true
-      }
-      expect(decoded['policies'][-1]).to eq(workspace_update_policy)
-      expect(decoded['policies'].size).to eq(policies_size+1)
-    end
-  end
-end

data/spec/twilio_spec.rb

@@ -1,15 +0,0 @@
-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,186 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::Util::Capability do
-  describe 'config' do
-    after(:each) do
-      Twilio.instance_variable_set('@configuration', nil)
-    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
-
-      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 overwrite account sid and auth token if passed to initializer' do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      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 overwrite the account sid if only the sid is given' do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      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 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 throw an argument error if only the account_sid is set' do
-      expect { Twilio::Util::Capability.new 'someSid' }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe 'with a capability' do
-    before :each do
-      @capability = Twilio::Util::Capability.new 'myAccountSid', 'myAuthToken'
-    end
-
-    def queries(q)
-      q.scan(/scope:client:(incoming|outgoing)\?(\S+)/).map{|(type, query)| [type, Rack::Utils.parse_query(query)]}
-    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 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
-    end
-  end
-end

data/spec/util/client_config_spec.rb

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

@@ -1,15 +0,0 @@
-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,113 +0,0 @@
-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
-
-  describe 'validations' do
-    let(:token) { '2bd9e9638872de601313dc77410d3b23' }
-
-    let(:validator) { Twilio::Util::RequestValidator.new token }
-
-    let(:voice_url) { 'http://twiliotests.heroku.com/validate/voice' }
-
-    let(:sms_url) { 'http://twiliotests.heroku.com/validate/sms' }
-
-    let(:voice_params) do
-      {
-        'ToState' => 'California',
-        'CalledState' => 'California',
-        'Direction' => 'inbound',
-        'FromState' => 'CA',
-        'AccountSid' => 'ACba8bc05eacf94afdae398e642c9cc32d',
-        'Caller' => '+14153595711',
-        'CallerZip' => '94108',
-        'CallerCountry' => 'US',
-        'From' => '+14153595711',
-        'FromCity' => 'SAN FRANCISCO',
-        'CallerCity' => 'SAN FRANCISCO',
-        'To' => '+14157669926',
-        'FromZip' => '94108',
-        'FromCountry' => 'US',
-        'ToCity' => '',
-        'CallStatus' => 'ringing',
-        'CalledCity' => '',
-        'CallerState' => 'CA',
-        'CalledZip' => '',
-        'ToZip' => '',
-        'ToCountry' => 'US',
-        'CallSid' => 'CA136d09cd59a3c0ec8dbff44da5c03f31',
-        'CalledCountry' => 'US',
-        'Called' => '+14157669926',
-        'ApiVersion' => '2010-04-01',
-        'ApplicationSid' => 'AP44efecad51364e80b133bb7c07eb8204'
-      }
-    end
-
-    let(:sms_params) do
-      {
-        'ToState' => 'CA',
-        'FromState' => 'CA',
-        'AccountSid' => 'ACba8bc05eacf94afdae398e642c9cc32d',
-        'SmsMessageSid' => 'SM2003cbd5e6a3701999aa3e5f20ff2787',
-        'Body' => 'Orly',
-        'From' => '+14159354345',
-        'FromCity' => 'SAN FRANCISCO',
-        'SmsStatus' => 'received',
-        'FromZip' => '94107',
-        'FromCountry' => 'US',
-        'To' => '+14158141819',
-        'ToCity' => 'SAN FRANCISCO',
-        'ToZip' => '94105',
-        'ToCountry' => 'US',
-        'ApiVersion' => '2010-04-01',
-        'SmsSid' => 'SM2003cbd5e6a3701999aa3e5f20ff2787'
-      }
-    end
-
-    it 'should validate an authentic Twilio Voice request' do
-      signature = 'oVb2kXoVy8GEfwBDjR8bk/ZZ6eA='
-      expect(validator.validate(voice_url, voice_params, signature)).to eq(true)
-    end
-
-    it 'should validate an authentic Twilio SMS request' do
-      signature = 'mxeiv65lEe0b8L6LdVw2jgJi8yw='
-      expect(validator.validate(sms_url, sms_params, signature)).to eq(true)
-    end
-
-    it 'should not validate a Twilio Voice request with wrong signature' do
-      signature = 'foo'
-      expect(validator.validate(voice_url, voice_params, signature)).to eq(false)
-    end
-
-    it 'should not validate a Twilio SMS request with wrong signature' do
-      signature = 'bar'
-      expect(validator.validate(sms_url, sms_params, signature)).to eq(false)
-    end
-  end
-end

data/spec/util/url_encode_spec.rb

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