twilio-ruby 5.48.0 → 5.66.2

data/spec/jwt/access_token_spec.rb

@@ -1,159 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::JWT::AccessToken do
-  describe 'access_token functionality ' do
-    it 'should generate a token for no grants' do
-      scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123', 'secret'
-      payload, _ = JWT.decode scat.to_s, 'secret'
-      expect(payload['sub']).to eq('AC123')
-      expect(payload['iss']).to eq('SK123')
-      expect(payload['exp']).to be > Time.now.to_i
-      expect(payload['jti']).to start_with payload['iss']
-      expect(payload['nbf']).to be <= Time.now.to_i
-      expect(payload['grants']).not_to be_nil
-      expect(payload['grants'].count).to eq(0)
-    end
-
-    it 'should add the proper headers without region' do
-      scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123', 'secret'
-      _, headers = JWT.decode scat.to_s, 'secret'
-      expect(headers['cty']).to eq('twilio-fpa;v=1')
-      expect(headers['twr']).to be_nil
-    end
-
-    it 'should add the proper headers with region' do
-      scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123', 'secret', region: 'foo'
-      _, headers = JWT.decode scat.to_s, 'secret'
-      expect(headers['cty']).to eq('twilio-fpa;v=1')
-      expect(headers['twr']).to eq('foo')
-    end
-
-    it 'identity should exist in the grants' do
-      scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123', 'secret', identity: 'test-identity'
-      payload, _ = JWT.decode scat.to_s, 'secret'
-      expect(payload['grants']).to eq({'identity' => 'test-identity'})
-    end
-
-    it 'grants during initialization' do
-      room_grant = Twilio::JWT::AccessToken::VideoGrant.new
-      room_grant.room = 'RM123'
-      grants = [room_grant]
-      scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123', 'secret', grants
-      payload, _ = JWT.decode scat.to_s, 'secret'
-      expect(payload['grants'].count).to eq(1)
-      expect(payload['grants']['video']['room']).to eq('RM123')
-    end
-
-    describe 'all the grants' do
-      before :each do
-        @scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123', 'secret'
-      end
-
-      it 'IpMessaging grant' do
-        Gem::Deprecate.skip_during do
-          ip_messaging_grant = Twilio::JWT::AccessToken::IpMessagingGrant.new
-          ip_messaging_grant.service_sid = 'SS123'
-          ip_messaging_grant.endpoint_id = 'EP123'
-          ip_messaging_grant.deployment_role_sid = 'DR123'
-          ip_messaging_grant.push_credential_sid = 'PC123'
-          @scat.add_grant(ip_messaging_grant)
-          payload, _ = JWT.decode @scat.to_s, 'secret'
-          expect(payload['grants'].count).to eq(1)
-          expect(payload['grants']['ip_messaging']['service_sid']).to eq('SS123')
-          expect(payload['grants']['ip_messaging']['endpoint_id']).to eq('EP123')
-          expect(payload['grants']['ip_messaging']['push_credential_sid']).to eq('PC123')
-          expect(payload['grants']['ip_messaging']['deployment_role_sid']).to eq('DR123')
-        end
-      end
-
-      it 'Chat grant' do
-        chat_grant = Twilio::JWT::AccessToken::ChatGrant.new
-        chat_grant.service_sid = 'SS123'
-        chat_grant.endpoint_id = 'EP123'
-        chat_grant.deployment_role_sid = 'DR123'
-        chat_grant.push_credential_sid = 'PC123'
-        @scat.add_grant(chat_grant)
-        payload, _ = JWT.decode @scat.to_s, 'secret'
-        expect(payload['grants'].count).to eq(1)
-        expect(payload['grants']['chat']['service_sid']).to eq('SS123')
-        expect(payload['grants']['chat']['endpoint_id']).to eq('EP123')
-        expect(payload['grants']['chat']['push_credential_sid']).to eq('PC123')
-        expect(payload['grants']['chat']['deployment_role_sid']).to eq('DR123')
-      end
-
-      it 'Voice grant' do
-        voice_grant = Twilio::JWT::AccessToken::VoiceGrant.new
-        voice_grant.incoming_allow = true
-        voice_grant.outgoing_application_sid = 'AP123'
-        voice_grant.outgoing_application_params = {:foo => 'bar'}
-        voice_grant.push_credential_sid = 'PC123'
-        voice_grant.endpoint_id = 'EP123'
-        @scat.add_grant(voice_grant)
-        payload, _ = JWT.decode @scat.to_s, 'secret'
-        expect(payload['grants'].count).to eq(1)
-        expect(payload['grants']['voice']['incoming']['allow']).to eq(true)
-        expect(payload['grants']['voice']['outgoing']['application_sid']).to eq('AP123')
-        expect(payload['grants']['voice']['outgoing']['params']['foo']).to eq('bar')
-        expect(payload['grants']['voice']['push_credential_sid']).to eq('PC123')
-        expect(payload['grants']['voice']['endpoint_id']).to eq('EP123')
-      end
-
-      it 'Sync grant' do
-        sync_grant = Twilio::JWT::AccessToken::SyncGrant.new
-        sync_grant.service_sid = 'SS123'
-        sync_grant.endpoint_id = 'EP123'
-        @scat.add_grant(sync_grant)
-        payload, _ = JWT.decode @scat.to_s, 'secret'
-        expect(payload['grants'].count).to eq(1)
-        expect(payload['grants']['data_sync']['service_sid']).to eq('SS123')
-        expect(payload['grants']['data_sync']['endpoint_id']).to eq('EP123')
-      end
-
-      it 'Conversations grant' do
-        Gem::Deprecate.skip_during do
-          conversation_grant = Twilio::JWT::AccessToken::ConversationsGrant.new
-          conversation_grant.configuration_profile_sid = 'VS123'
-          @scat.add_grant(conversation_grant)
-          payload, _ = JWT.decode @scat.to_s, 'secret'
-          expect(payload['grants'].count).to eq(1)
-          expect(payload['grants']['rtc']['configuration_profile_sid']).to eq('VS123')
-        end
-      end
-
-      it 'Room grant' do
-        room_grant = Twilio::JWT::AccessToken::VideoGrant.new
-        room_grant.room = 'RM123'
-        @scat.add_grant(room_grant)
-        payload, _ = JWT.decode @scat.to_s, 'secret'
-        expect(payload['grants'].count).to eq(1)
-        expect(payload['grants']['video']['room']).to eq('RM123')
-      end
-
-      it 'TaskRouter grant' do
-        task_router_grant = Twilio::JWT::AccessToken::TaskRouterGrant.new
-        task_router_grant.workspace_sid = 'WS123'
-        task_router_grant.worker_sid = 'WK123'
-        task_router_grant.role = 'worker'
-        @scat.add_grant(task_router_grant)
-        payload, _ = JWT.decode @scat.to_s, 'secret'
-        expect(payload['grants'].count).to eq(1)
-        expect(payload['grants']['task_router']['workspace_sid']).to eq('WS123')
-        expect(payload['grants']['task_router']['worker_sid']).to eq('WK123')
-        expect(payload['grants']['task_router']['role']).to eq('worker')
-      end
-
-      it 'multiple grants' do
-        room_grant = Twilio::JWT::AccessToken::VideoGrant.new
-        room_grant.room = 'RM123'
-        @scat.add_grant(room_grant)
-        task_router_grant = Twilio::JWT::AccessToken::TaskRouterGrant.new
-        task_router_grant.workspace_sid = 'WS123'
-        @scat.add_grant(task_router_grant)
-        payload, _ = JWT.decode @scat.to_s, 'secret'
-        expect(payload['grants'].count).to eq(2)
-        expect(payload['grants']['video']).not_to be_nil
-        expect(payload['grants']['task_router']).not_to be_nil
-      end
-    end
-  end
-end

data/spec/jwt/client_capability_spec.rb

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

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

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