twilio-ruby 4.13.0 → 5.6.4

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

@@ -3,38 +3,38 @@ require 'rack/mock'
 
 describe Rack::TwilioWebhookAuthentication do
   before do
-    @app = lambda {|env| [200, {'Content-Type' => 'text/plain'}, ['Hello']] }
+    @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 {
+      expect do
         Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/)
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it 'should initialize with an app, auth token and paths' do
-      expect {
+      expect do
         Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/, /\/sms/)
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it 'should initialize with an app, dynamic token and paths' do
-      expect {
+      expect do
         Rack::TwilioWebhookAuthentication.new(@app, nil, /\/voice/, /\/sms/)
-      }.not_to raise_error
+      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 = 12345
+      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}
+      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::Util::RequestValidator).to receive(:new).with(auth_token).and_return(request_validator)
+      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)
@@ -44,20 +44,18 @@ describe Rack::TwilioWebhookAuthentication do
 
   describe 'calling against one path' do
     before do
-      @middleware = Rack::TwilioWebhookAuthentication.new(
-        @app, 'ABC', /\/voice/
-      )
+      @middleware = Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/)
     end
 
     it 'should not intercept when the path doesn\'t match' do
-      expect(Twilio::Util::RequestValidator).to_not receive(:validate)
+      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::Util::RequestValidator).to(
+      expect_any_instance_of(Twilio::Security::RequestValidator).to(
         receive(:validate).and_return(true)
       )
       request = Rack::MockRequest.env_for('/voice')
@@ -66,7 +64,7 @@ describe Rack::TwilioWebhookAuthentication do
     end
 
     it 'should short circuit a request to 403 if it does not validate' do
-      expect_any_instance_of(Twilio::Util::RequestValidator).to(
+      expect_any_instance_of(Twilio::Security::RequestValidator).to(
         receive(:validate).and_return(false)
       )
       request = Rack::MockRequest.env_for('/voice')
@@ -77,20 +75,18 @@ describe Rack::TwilioWebhookAuthentication do
 
   describe 'calling against many paths' do
     before do
-      @middleware = Rack::TwilioWebhookAuthentication.new(
-        @app, 'ABC', /\/voice/, /\/sms/
-      )
+      @middleware = Rack::TwilioWebhookAuthentication.new(@app, 'ABC', /\/voice/, /\/sms/)
     end
 
     it 'should not intercept when the path doesn\'t match' do
-      expect(Twilio::Util::RequestValidator).to_not receive(:validate)
+      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::Util::RequestValidator).to(
+      expect_any_instance_of(Twilio::Security::RequestValidator).to(
         receive(:validate).and_return(true)
       )
       request = Rack::MockRequest.env_for('/sms')
@@ -99,7 +95,7 @@ describe Rack::TwilioWebhookAuthentication do
     end
 
     it 'should short circuit a request to 403 if it does not validate' do
-      expect_any_instance_of(Twilio::Util::RequestValidator).to(
+      expect_any_instance_of(Twilio::Security::RequestValidator).to(
         receive(:validate).and_return(false)
       )
       request = Rack::MockRequest.env_for('/sms')

data/spec/rest/client_spec.rb

@@ -1,277 +1,49 @@
 require 'spec_helper'
 
-describe Twilio::REST::Client do
-  describe 'config at class level' do
-    after(:each) do
-      Twilio.instance_variable_set('@configuration', nil)
-    end
-
-    it 'should set the account sid and auth token with a config block' do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      end
-
-      client = Twilio::REST::Client.new
-      expect(client.account_sid).to eq('someSid')
-      expect(client.instance_variable_get('@auth_token')).to eq('someToken')
-    end
-
-    it 'should overwrite account sid and auth token if passed to initializer' do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      end
-
-      client = Twilio::REST::Client.new 'otherSid', 'otherToken'
-      expect(client.account_sid).to eq('otherSid')
-      expect(client.instance_variable_get('@auth_token')).to eq('otherToken')
-    end
-
-    it 'should overwrite the account sid if only the sid is given' do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      end
-
-      client = Twilio::REST::Client.new 'otherSid'
-      expect(client.account_sid).to eq('otherSid')
-      expect(client.instance_variable_get('@auth_token')).to eq('someToken')
-    end
-
-    it 'should allow options after setting up auth with config' do
-      Twilio.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      end
-
-      client = Twilio::REST::Client.new :host => 'api.faketwilio.com'
-
-      connection = client.instance_variable_get('@connection')
-      expect(connection.address).to eq('api.faketwilio.com')
-    end
-
-    it 'should throw an argument error if the sid and token isn\'t set' do
-      expect { Twilio::REST::Client.new }.to raise_error(ArgumentError)
-    end
-
-    it 'should throw an argument error if only the account_sid is set' do
-      expect { Twilio::REST::Client.new 'someSid' }.to raise_error(ArgumentError)
-    end
-  end
-
-  it 'should not raise an error if the response body is empty' do
-    FakeWeb.register_uri(:any, %r/api\.twilio\.com/, body: '')
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    Twilio::REST::IncomingPhoneNumber.new('/phone_number', twilio).delete
-  end
-
-  it 'should not raise an error if the response body is nil' do
-    response = double(:response, body: nil)
-    connection = double(:connection, request: response)
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    twilio.instance_variable_set(:@connection, connection)
-    Twilio::REST::IncomingPhoneNumber.new('/phone_number', twilio).delete
-  end
-
-  it 'should set up a new client instance with the given sid and token' do
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    expect(twilio.account_sid).to eq('someSid')
-    expect(twilio.instance_variable_get('@auth_token')).to eq('someToken')
-  end
-
-  it 'should set up the proper default http ssl connection' do
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.address).to eq('api.twilio.com')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-  end
-
-  it 'should set up the requested ssl verification ca_file if provided' do
-    twilio = Twilio::REST::Client.new(
-      'someSid', 'someToken', ssl_ca_file: '/path/to/ca/file'
-    )
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.ca_file).to eq('/path/to/ca/file')
-  end
-
-  it 'should set up the proper http ssl connection when a different ' \
-     'domain is given' do
-    twilio = Twilio::REST::Client.new(
-      'someSid', 'someToken', host: 'api.faketwilio.com'
-    )
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.address).to eq('api.faketwilio.com')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-  end
-
-  it 'should adjust the open and read timeouts on the underlying Net::HTTP ' \
-     'object when asked' do
-    timeout = rand(30)
-    twilio = Twilio::REST::Client.new('someSid', 'someToken', timeout: timeout)
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-    expect(connection.open_timeout).to eq(timeout)
-    expect(connection.read_timeout).to eq(timeout)
-  end
-
-  it 'should set up the proper http ssl connection when a proxy_host is ' \
-     'given' do
-    twilio = Twilio::REST::Client.new(
-      'someSid',
-      'someToken',
-      host: 'api.faketwilio.com',
-      proxy_addr: 'localhost'
-    )
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.proxy?).to eq(true)
-    expect(connection.proxy_address).to eq('localhost')
-    expect(connection.proxy_port).to eq(80)
-    expect(connection.address).to eq('api.faketwilio.com')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-  end
-
-  it 'should set up the proper http ssl connection when a proxy_host and ' \
-     'proxy_port are given' do
-    twilio = Twilio::REST::Client.new(
-      'someSid',
-      'someToken',
-      host: 'api.faketwilio.com',
-      proxy_addr: 'localhost',
-      proxy_port: 13128
-    )
-    connection = twilio.instance_variable_get('@connection')
-    expect(connection.proxy?).to eq(true)
-    expect(connection.proxy_address).to eq('localhost')
-    expect(connection.proxy_port).to eq(13128)
-    expect(connection.address).to eq('api.faketwilio.com')
-    expect(connection.port).to eq(443)
-    expect(connection.use_ssl?).to eq(true)
-  end
-
-  it 'should set up an accounts resources object' do
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    expect(twilio).to respond_to(:accounts)
-    expect(twilio.accounts.instance_variable_get('@path')).to eq(
-      '/2010-04-01/Accounts'
-    )
-  end
-
-  it 'should set up an account object with the given sid' do
-    twilio = Twilio::REST::Client.new('someSid', 'someToken')
-    expect(twilio).to respond_to(:account)
-    expect(twilio.account.instance_variable_get('@path')).to eq(
-      '/2010-04-01/Accounts/someSid'
-    )
-  end
-
-  [
-      :sandbox, :available_phone_numbers, :incoming_phone_numbers,
-      :calls, :outgoing_caller_ids, :conferences, :sms, :recordings,
-      :transcriptions, :notifications, :applications, :connect_apps,
-      :authorized_connect_apps, :queues, :usage, :messages, :media, :sip
-  ].each do |method|
-    it "should delegate the client method #{method} to the account object" do
-      client = Twilio::REST::Client.new('someSid', 'someToken')
-      expect(client).to respond_to(method)
-      expect(client.send(method)).to eq(client.account.send(method))
-    end
-  end
-
-  it 'should throw an argument error if the workspace_sid is not set' do
-    expect { Twilio::REST::TaskRouterClient.new 'someSid', 'someToken' }.to raise_error(ArgumentError)
-  end
-
-  it 'should have its host set to taskrouter.twilio.com' do
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    connection = client.instance_variable_get('@connection')
-    expect(connection.address).to eq('taskrouter.twilio.com')
-  end
-
-  it 'should have task queue statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:task_queue_statistics)
-    expect(client.task_queue_statistics('someSid').instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/TaskQueues/someSid/Statistics')
-  end
-
-  it 'should have task queues statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{"meta": {"key": "task_queues_statistics"}, "task_queues_statistics": [{"task_queue_sid": "WQ123"}]}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:task_queues_statistics)
-    expect(client.task_queues_statistics[0].task_queue_sid).to eq('WQ123')
-  end
-
-  it 'should have worker statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:worker_statistics)
-    expect(client.worker_statistics('someSid').instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/Workers/someSid/Statistics')
-  end
-
-  it 'should have workers statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workers_statistics)
-    expect(client.workers_statistics.instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/Workers/Statistics')
-  end
-
-  it 'should have workflow statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workflow_statistics)
-    expect(client.workflow_statistics('someSid').instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/Workflows/someSid/Statistics')
+describe Twilio::REST::ObsoleteClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::ObsoleteClient.new }.to raise_error(Twilio::REST::ObsoleteError)
   end
+end
 
-  it 'should have workspace statistics resource' do
-    FakeWeb.register_uri(:get, %r/taskrouter\.twilio\.com/, body: '{}')
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workspace_statistics)
-    expect(client.workspace_statistics.instance_variable_get('@path')).to eq('/v1/Workspaces/someSid/Statistics')
+describe Twilio::REST::BaseClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::BaseClient.new }.to raise_error(Twilio::REST::ObsoleteError)
   end
+end
 
-  it 'should set up a workspaces resource object' do
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workspaces)
-    expect(client.workspaces.instance_variable_get('@path')).to eq('/v1/Workspaces')
+describe Twilio::REST::IpMessagingClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::IpMessagingClient.new }.to raise_error(Twilio::REST::ObsoleteError)
   end
+end
 
-  it 'should set up a workspace resource object' do
-    client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-    expect(client).to respond_to(:workspace)
-    expect(client.workspace.instance_variable_get('@path')).to eq('/v1/Workspaces/someSid')
+describe Twilio::REST::LookupsClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::LookupsClient.new }.to raise_error(Twilio::REST::ObsoleteError)
   end
+end
 
-  [
-      :activities, :tasks, :task_queues, :workers, :workflows
-  ].each do |method|
-    it "should delegate the client method #{method} to the workspace object" do
-      client = Twilio::REST::TaskRouterClient.new('someSid', 'someToken', 'someSid')
-      expect(client).to respond_to(method)
-      expect(client.send(method)).to eq(client.workspace.send(method))
-    end
+describe Twilio::REST::MonitorClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::MonitorClient.new }.to raise_error(Twilio::REST::ObsoleteError)
   end
-
 end
 
 describe Twilio::REST::PricingClient do
-  it 'should have its host set to pricing.twilio.com' do
-    client = Twilio::REST::PricingClient.new('sid', 'token')
-    connection = client.instance_variable_get('@connection')
-    expect(connection.address).to eq('pricing.twilio.com')
+  it 'raise an exception' do
+    expect { Twilio::REST::PricingClient.new }.to raise_error(Twilio::REST::ObsoleteError)
   end
+end
 
-  it 'should set up a voice resource object' do
-    client = Twilio::REST::PricingClient.new('sid', 'token')
-    expect(client).to respond_to(:voice)
+describe Twilio::REST::TaskRouterClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::TaskRouterClient.new }.to raise_error(Twilio::REST::ObsoleteError)
   end
+end
 
-  it 'should set up a phone numbers resource object' do
-    client = Twilio::REST::PricingClient.new('sid', 'token')
-    expect(client).to respond_to(:phone_numbers)
+describe Twilio::REST::TrunkingClient do
+  it 'raise an exception' do
+    expect { Twilio::REST::TrunkingClient.new }.to raise_error(Twilio::REST::ObsoleteError)
   end
 end

data/spec/{util → security}/request_validator_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Twilio::Util::RequestValidator do
+describe Twilio::Security::RequestValidator do
   describe 'configuration' do
     after(:each) do
       Twilio.instance_variable_set('@configuration', nil)
@@ -11,7 +11,7 @@ describe Twilio::Util::RequestValidator do
         config.auth_token = 'someToken'
       end
 
-      validator = Twilio::Util::RequestValidator.new
+      validator = Twilio::Security::RequestValidator.new
       expect(validator.instance_variable_get('@auth_token')).to eq('someToken')
     end
 
@@ -20,19 +20,19 @@ describe Twilio::Util::RequestValidator do
         config.auth_token = 'someToken'
       end
 
-      validator = Twilio::Util::RequestValidator.new 'otherToken'
+      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::Util::RequestValidator.new }.to raise_error(ArgumentError)
+      expect { Twilio::Security::RequestValidator.new }.to raise_error(ArgumentError)
     end
   end
 
   describe 'validations' do
     let(:token) { '2bd9e9638872de601313dc77410d3b23' }
 
-    let(:validator) { Twilio::Util::RequestValidator.new token }
+    let(:validator) { Twilio::Security::RequestValidator.new token }
 
     let(:voice_url) { 'http://twiliotests.heroku.com/validate/voice' }
 

data/spec/spec_helper.rb

@@ -3,7 +3,10 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'bundler'
 Bundler.setup
 
-Dir.glob(File.expand_path("../support/**/*.rb", __FILE__), &method(:require))
+Dir.glob(File.expand_path('../support/**/*.rb', __FILE__), &method(:require))
+
+require_relative './holodeck/holodeck.rb'
+require_relative './holodeck/hologram.rb'
 
 require 'twilio-ruby'
 require 'rack'
@@ -12,4 +15,18 @@ 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