twilio-ruby 3.11.5 → 5.0.0

data/spec/jwt/client_capability_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Twilio::JWT::ClientCapability do
+  describe 'initialization' do
+    it 'should initialize without optionals' do
+      clientCapability = Twilio::JWT::ClientCapability.new 'accountSid', 'authToken'
+      expect(clientCapability.instance_variable_get('@account_sid')).to eq('accountSid')
+      expect(clientCapability.instance_variable_get('@auth_token')).to eq('authToken')
+      expect(clientCapability.instance_variable_get('@client_name')).to be_nil
+      expect(clientCapability.instance_variable_get('@scopes')).to eq([])
+    end
+  end
+
+  describe 'ClientCapability scopes' do
+    before :each do
+      @clientCapability = Twilio::JWT::ClientCapability.new 'accountSid', 'authToken'
+    end
+
+    it 'no capabilities' do
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq('')
+    end
+
+    it 'OutgoingClientScope sans params, client name' do
+      @outgoingScope = Twilio::JWT::ClientCapability::OutgoingClientScope.new('test-application-sid')
+      @clientCapability.add_scope(@outgoingScope)
+      escope = 'scope:client:outgoing?appSid=test-application-sid'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'OutgoingClientScope with client-name' do
+      @outgoingScope = Twilio::JWT::ClientCapability::OutgoingClientScope.new('test-application-sid', 'test-client-name')
+      @clientCapability.add_scope(@outgoingScope)
+      escope = 'scope:client:outgoing?appSid=test-application-sid&clientName=test-client-name'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'OutgoingClientScope with params' do
+      @outgoingScope = Twilio::JWT::ClientCapability::OutgoingClientScope.new('test-application-sid', nil, {'params_key'=>'param_value'})
+      @clientCapability.add_scope(@outgoingScope)
+      escope = 'scope:client:outgoing?appSid=test-application-sid&appParams=params_key%3Dparam_value'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'IncomingClientScope' do
+      @incomingScope = Twilio::JWT::ClientCapability::IncomingClientScope.new('test-client-name')
+      @clientCapability.add_scope(@incomingScope)
+      escope = 'scope:client:incoming?clientName=test-client-name'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'EventStreamScope sans filters' do
+      @eventStreamScope = Twilio::JWT::ClientCapability::EventStreamScope.new
+      @clientCapability.add_scope(@eventStreamScope)
+      escope = 'scope:stream:subscribe?path=%2F2010-04-01%2FEvents'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'EventStreamScope with filters' do
+      @eventStreamScope = Twilio::JWT::ClientCapability::EventStreamScope.new({'param_key'=>'param_value'})
+      @clientCapability.add_scope(@eventStreamScope)
+      escope = 'scope:stream:subscribe?path=%2F2010-04-01%2FEvents&params=param_key%3Dparam_value'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'OutgoingClientScope and IncomingClientScope' do
+      @outgoingScope = Twilio::JWT::ClientCapability::OutgoingClientScope.new('test-application-sid')
+      @clientCapability.add_scope(@outgoingScope)
+      @incomingScope = Twilio::JWT::ClientCapability::IncomingClientScope.new('test-client-name')
+      @clientCapability.add_scope(@incomingScope)
+      escope = 'scope:client:outgoing?appSid=test-application-sid scope:client:incoming?clientName=test-client-name'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'complete payload' do
+      @incomingScope = Twilio::JWT::ClientCapability::IncomingClientScope.new('test-client-name')
+      @clientCapability.add_scope(@incomingScope)
+      payload, _ = ::JWT.decode(@clientCapability.to_s, 'authToken', true, { algorithm: 'HS256' })
+      escope = 'scope:client:incoming?clientName=test-client-name'
+      expect(payload['iss']).to eq('accountSid')
+      expect(payload['scope']).to eq(escope)
+      expect(payload['exp']).to be > Time.now.to_i
+      expect(payload['nbf']).to be <= Time.now.to_i
+    end
+  end
+
+  describe 'ClientCapability constructor with scopes' do
+    it 'Valid scopes in constructor' do
+      @incomingScope = Twilio::JWT::ClientCapability::IncomingClientScope.new('test-client-name')
+      @clientCapability = Twilio::JWT::ClientCapability.new 'accountSid', 'authToken', scopes: [@incomingScope]
+      escope = 'scope:client:incoming?clientName=test-client-name'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+  end
+end
+
+describe Twilio::JWT::Scope do
+  it 'Scope raise exception' do
+    class DummyScope
+      include Twilio::JWT::Scope
+    end
+    @dummyScope = DummyScope.new
+    expect { @dummyScope._generate_payload }.to raise_error(RuntimeError)
+  end
+end

data/spec/jwt/task_router_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe 'TaskRouter ' do
+  def check_policy(method, url, policy, post_filter: {}, query_filter: {}, allow: true)
+    expect(policy['url']).to eq(url)
+    expect(policy['method']).to eq(method)
+    expect(policy['post_filter']).to eq(post_filter)
+    expect(policy['query_filter']).to eq(query_filter)
+    expect(policy['allow']).to eq(allow)
+  end
+
+  describe Twilio::JWT::TaskRouterCapability do
+    describe 'token initialization' do
+      before :each do
+        @taskRouterCapability = Twilio::JWT::TaskRouterCapability.new 'AC123', 'secret', 'WS456', 'CI123'
+      end
+
+      it 'generate default' do
+        token = @taskRouterCapability.to_s
+        payload, _ = JWT.decode token, 'secret'
+        expect(payload['iss']).to eq('AC123')
+        expect(payload['workspace_sid']).to eq('WS456')
+        expect(payload['policies']).not_to be_nil
+        expect(payload['policies'].size).to eq(2)
+      end
+
+      it 'add policy' do
+        @policy = Twilio::JWT::TaskRouterCapability::Policy.new(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.workspace('WK123'), 'GET', true)
+        @taskRouterCapability.add_policy(@policy)
+        token = @taskRouterCapability.to_s
+        payload, _ = JWT.decode token, 'secret'
+        expect(payload['policies']).not_to be_nil
+        expect(payload['policies'].size).to eq(3)
+        check_policy('GET', 'https://taskrouter.twilio.com/v1/Workspaces/WK123', payload['policies'][0])
+        check_policy('GET', 'https://event-bridge.twilio.com/v1/wschannels/AC123/CI123', payload['policies'][1])
+        check_policy('POST', 'https://event-bridge.twilio.com/v1/wschannels/AC123/CI123', payload['policies'][2])
+      end
+    end
+  end
+
+  describe Twilio::JWT::TaskRouterCapability::Policy do
+    describe 'policy' do
+      it 'initialize' do
+        @policy = Twilio::JWT::TaskRouterCapability::Policy.new('test-url',
+                                                                'GET',
+                                                                true,
+                                                                { 'test-post-key' => 'test-post-value' },
+                                                                'test-query-key' => 'test-query-value')
+
+        payload = Hash[@policy._generate_payload.map { |k, v| [k.to_s, v] }]
+        check_policy('GET',
+                     'test-url',
+                     payload,
+                     post_filter: { 'test-post-key' => 'test-post-value' },
+                     query_filter: { 'test-query-key' => 'test-query-value' },
+                     allow: true)
+      end
+    end
+
+    describe Twilio::JWT::TaskRouterCapability::TaskRouterUtils do
+      describe 'urls' do
+        it 'workspaces' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.workspaces).to eq(expected_url)
+        end
+
+        it 'workspace' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.workspace('WK123')).to eq(expected_url)
+        end
+
+        it 'all_workspaces' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/**'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.all_workspaces).to eq(expected_url)
+        end
+
+        it 'tasks' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Tasks'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.tasks('WK123')).to eq(expected_url)
+        end
+
+        it 'task' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Tasks/TK123'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.task('WK123', 'TK123')).to eq(expected_url)
+        end
+
+        it 'all_tasks' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Tasks/**'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.all_tasks('WK123')).to eq(expected_url)
+        end
+
+        it 'task_queues' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/TaskQueues'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.task_queues('WK123')).to eq(expected_url)
+        end
+
+        it 'task_queue' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/TaskQueues/WQ123'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.task_queue('WK123', 'WQ123')).to eq(expected_url)
+        end
+
+        it 'all_task_queues' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/TaskQueues/**'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.all_task_queues('WK123')).to eq(expected_url)
+        end
+
+        it 'activities' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/AT123/Activities'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.activities('AT123')).to eq(expected_url)
+        end
+
+        it 'activity' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Activities/AT123'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.activity('WK123', 'AT123')).to eq(expected_url)
+        end
+
+        it 'all_activities' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Activities/**'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.all_activities('WK123')).to eq(expected_url)
+        end
+
+        it 'workers' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Workers'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.workers('WK123')).to eq(expected_url)
+        end
+
+        it 'worker' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Workers/WT123'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.worker('WK123', 'WT123')).to eq(expected_url)
+        end
+
+        it 'all_workers' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Workers/**'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.all_workers('WK123')).to eq(expected_url)
+        end
+
+        it 'reservations' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Workers/WT123/Reservations'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.reservations('WK123', 'WT123')).to eq(expected_url)
+        end
+
+        it 'reservation' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Workers/WT123/Reservations/RS123'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.reservation('WK123', 'WT123', 'RS123')).to eq(expected_url)
+        end
+
+        it 'all_reservations' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Workers/WT123/Reservations/**'
+          expect(Twilio::JWT::TaskRouterCapability::TaskRouterUtils.all_reservations('WK123', 'WT123')).to eq(expected_url)
+        end
+      end
+
+      describe 'default policies' do
+        it 'default web_socket_policies' do
+          @policies = Twilio::JWT::TaskRouterCapability::TaskRouterUtils.web_socket_policies('AC123', 'CI123')
+          get, post = @policies.map(&:_generate_payload)
+          check_policy('GET', 'https://event-bridge.twilio.com/v1/wschannels/AC123/CI123', Hash[get.map { |k, v| [k.to_s, v] }])
+          check_policy('POST', 'https://event-bridge.twilio.com/v1/wschannels/AC123/CI123', Hash[post.map { |k, v| [k.to_s, v] }])
+        end
+
+        it 'default worker policies' do
+          @policies = Twilio::JWT::TaskRouterCapability::TaskRouterUtils.worker_policies('WK123', 'WT123')
+          payload = @policies.map(&:_generate_payload)
+          check_policy('GET', 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Activities', Hash[payload[0].map { |k, v| [k.to_s, v] }])
+          check_policy('GET', 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Tasks/**', Hash[payload[1].map { |k, v| [k.to_s, v] }])
+          check_policy('GET', 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Workers/WT123/Reservations/**', Hash[payload[2].map { |k, v| [k.to_s, v] }])
+          check_policy('GET', 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Workers/WT123', Hash[payload[3].map { |k, v| [k.to_s, v] }])
+        end
+      end
+    end
+  end
+end

data/spec/rack/twilio_webhook_authentication_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'rack/mock'
+
+describe Rack::TwilioWebhookAuthentication do
+  before do
+    @app = ->(_env) { [200, { 'Content-Type' => 'text/plain' }, ['Hello']] }
+  end
+
+  describe 'new' do
+    it 'should initialize with an app, auth token and a path' do
+      expect do
+        Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/)
+      end.not_to raise_error
+    end
+
+    it 'should initialize with an app, auth token and paths' do
+      expect do
+        Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/, /\/sms/)
+      end.not_to raise_error
+    end
+
+    it 'should initialize with an app, dynamic token and paths' do
+      expect do
+        Rack::TwilioWebhookAuthentication.new(@app, nil, /\/voice/, /\/sms/)
+      end.not_to raise_error
+    end
+  end
+
+  describe 'calling against one path with dynamic auth token' do
+    it 'should allow a request through if it validates' do
+      auth_token = 'qwerty'
+      account_sid = 12_345
+      expect_any_instance_of(Rack::Request).to receive(:post?).and_return(true)
+      expect_any_instance_of(Rack::Request).to receive(:POST).and_return({ 'AccountSid' => account_sid })
+      @middleware = Rack::TwilioWebhookAuthentication.new(@app, nil, /\/voice/) { |asid| auth_token }
+      request_validator = double('RequestValidator')
+      expect(Twilio::Security::RequestValidator).to receive(:new).with(auth_token).and_return(request_validator)
+      expect(request_validator).to receive(:validate).and_return(true)
+      request = Rack::MockRequest.env_for('/voice')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    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::Security::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::Security::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::Security::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::Security::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::Security::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::Security::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/security/request_validator_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Twilio::Security::RequestValidator do
+  describe 'configuration' do
+    after(:each) do
+      Twilio.instance_variable_set('@configuration', nil)
+    end
+
+    it 'should set the auth token from a configuration block' do
+      Twilio.configure do |config|
+        config.auth_token = 'someToken'
+      end
+
+      validator = Twilio::Security::RequestValidator.new
+      expect(validator.instance_variable_get('@auth_token')).to eq('someToken')
+    end
+
+    it 'should overwrite the auth token if passed to initializer' do
+      Twilio.configure do |config|
+        config.auth_token = 'someToken'
+      end
+
+      validator = Twilio::Security::RequestValidator.new 'otherToken'
+      expect(validator.instance_variable_get('@auth_token')).to eq('otherToken')
+    end
+
+    it 'should throw an argument error if the auth token isn\'t set' do
+      expect { Twilio::Security::RequestValidator.new }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'validations' do
+    let(:token) { '2bd9e9638872de601313dc77410d3b23' }
+
+    let(:validator) { Twilio::Security::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/spec_helper.rb

@@ -1,6 +1,32 @@
-$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_relative './holodeck/holodeck.rb'
+require_relative './holodeck/hologram.rb'
+
 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
+
+  config.before(:each) do
+    @client = Twilio::REST::Client.new('AC' + 'a' * 32, 'AUTHTOKEN')
+    @holodeck = Holodeck.new
+    @client.http_client = @holodeck
+  end
+end
+
+def account_sid
+  ENV['ACCOUNT_SID']
+end
+
+def auth_token
+  ENV['AUTH_TOKEN']
+end

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

data/spec/twiml/messaging_response_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Twilio::TwiML::MessagingResponse do
+  context 'Testing Response' do
+    it 'should allow empty response' do
+      r = Twilio::TwiML::MessagingResponse.new
+      expect(r.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response/>')
+    end
+
+    it 'should allow populated response' do
+      r = Twilio::TwiML::MessagingResponse.new
+      r.message(body: 'Hello')
+      r.redirect('example.com')
+
+      expect(r.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response><Message>Hello</Message><Redirect>example.com</Redirect></Response>')
+    end
+
+    it 'should allow chaining' do
+      r = Twilio::TwiML::MessagingResponse.new.message(body: 'Hello').redirect('example.com')
+
+      expect(r.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response><Message>Hello</Message><Redirect>example.com</Redirect></Response>')
+    end
+
+    it 'should allow nesting' do
+      r = Twilio::TwiML::MessagingResponse.new
+      r.message(body: 'Hello') do |m|
+        m.media('foobar')
+      end
+
+      expect(r.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response><Message>Hello<Media>foobar</Media></Message></Response>')
+    end
+
+    it 'should allow nesting and chaining' do
+      r = Twilio::TwiML::MessagingResponse.new
+      r.message(body: 'Hello') do |m|
+        m.media('foobar')
+      end
+
+      r.redirect('example.com')
+
+      expect(r.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response><Message>Hello<Media>foobar</Media></Message><Redirect>example.com</Redirect></Response>')
+    end
+
+    it 'should allow nesting from the initializer' do
+      response = Twilio::TwiML::MessagingResponse.new do |r|
+        r.message(body: 'Hello')
+        r.redirect('example.com')
+      end
+      expect(response.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response><Message>Hello</Message><Redirect>example.com</Redirect></Response>')
+    end
+  end
+
+  context 'Testing Message' do
+    it 'should allow a body' do
+      r = Twilio::TwiML::MessagingResponse.new
+      r.message(body: 'Hello')
+
+      expect(r.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response><Message>Hello</Message></Response>')
+    end
+
+    it 'should allow appending Body' do
+      b = Twilio::TwiML::Body.new('Hello World')
+
+      r = Twilio::TwiML::MessagingResponse.new
+      r.append(b)
+
+      expect(r.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response><Body>Hello World</Body></Response>')
+    end
+
+    it 'should allow appending Body and Media' do
+      b = Twilio::TwiML::Body.new('Hello World')
+      m = Twilio::TwiML::Media.new('hey.jpg')
+
+      r = Twilio::TwiML::MessagingResponse.new
+      r.append(b)
+      r.append(m)
+
+      expect(r.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response><Body>Hello World</Body><Media>hey.jpg</Media></Response>')
+    end
+  end
+
+  context 'Testing Redirect' do
+    it 'should allow MessagingResponse.redirect' do
+      r = Twilio::TwiML::MessagingResponse.new
+      r.redirect('example.com')
+
+      expect(r.to_s).to eq('<?xml version="1.0" encoding="UTF-8"?><Response><Redirect>example.com</Redirect></Response>')
+    end
+  end
+end