twilio-ruby 5.0.0.rc21 → 5.0.0.rc22

data/lib/twilio-ruby/version.rb

@@ -1,3 +1,3 @@
 module Twilio
-  VERSION = '5.0.0.rc21'
+  VERSION = '5.0.0.rc22'
 end

data/spec/holodeck/hologram.rb

@@ -1,4 +1,3 @@
-require 'json'
 require 'uri'
 
 class Hologram

data/spec/jwt/access_token_spec.rb

@@ -1,192 +1,136 @@
 require 'spec_helper'
 
 describe Twilio::JWT::AccessToken do
-
-  it 'should generate a token for no grants' do
-    scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123','secret'
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['nbf']).to be_nil
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(0)
-  end
-
-  it 'should generate a nbf' do
-    now = Time.now.to_i - 1
-    scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123','secret'
-    scat.identity = 'abc'
-    scat.nbf = now
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['nbf']).not_to be_nil
-    expect(payload['nbf']).to eq(now)
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['identity']).to eq('abc')
-  end
-
-  it 'should be able to add endpoint grants' do
-    scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123','secret'
-
-    grant = Twilio::JWT::AccessToken::IpMessagingGrant.new
-    grant.push_credential_sid = 'CR123'
-    grant.deployment_role_sid = 'DR123'
-    grant.service_sid = 'IS123'
-    grant.endpoint_id = 'EP123'
-    scat.add_grant(grant)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['ip_messaging']).not_to be_nil
-    expect(payload['grants']['ip_messaging']['service_sid']).to eq('IS123')
-    expect(payload['grants']['ip_messaging']['endpoint_id']).to eq('EP123')
-    expect(payload['grants']['ip_messaging']['push_credential_sid']).to eq('CR123')
-    expect(payload['grants']['ip_messaging']['deployment_role_sid']).to eq('DR123')
+  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' 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')
+    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::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
+        ip_messaging_grant = Twilio::JWT::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
+
+      it 'Voice grant' do
+        voice_grant = Twilio::JWT::VoiceGrant.new
+        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']['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::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
+        conversation_grant = Twilio::JWT::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
+
+      it 'Room grant' do
+        room_grant = Twilio::JWT::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::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::VideoGrant.new
+        room_grant.room = 'RM123'
+        @scat.add_grant(room_grant)
+        task_router_grant = Twilio::JWT::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
 
-  it 'should be able to add Sync grants' do
-    scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123','secret'
-    scat.identity = "brodawg"
-
-    grant = Twilio::JWT::AccessToken::SyncGrant.new
-    grant.service_sid = 'IS123'
-    grant.endpoint_id = 'EP123'
-    scat.add_grant(grant)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(2)
-    expect(payload['grants']['identity']).to eq("brodawg")
-    expect(payload['grants']['data_sync']).not_to be_nil
-    expect(payload['grants']['data_sync']['service_sid']).to eq('IS123')
-    expect(payload['grants']['data_sync']['endpoint_id']).to eq('EP123')
-  end
 
-  it 'should add rest grants' do
-    scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123','secret'
-    scat.add_grant(Twilio::JWT::AccessToken::VideoGrant.new)
-    scat.add_grant(Twilio::JWT::AccessToken::IpMessagingGrant.new)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(2)
-    expect(payload['grants']['video']).not_to be_nil
-    expect(payload['grants']['ip_messaging']).not_to be_nil
-  end
 
-  it 'should add programmable voice grant' do
-    scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123','secret'
-    pvg = Twilio::JWT::AccessToken::VoiceGrant.new
-    pvg.outgoing_application_sid = 'AP123'
-    pvg.outgoing_application_params = { :foo => 'bar' }
-
-    scat.add_grant(pvg)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['voice']).not_to be_nil
-    expect(payload['grants']['voice']['outgoing']['application_sid']).to eq('AP123')
-    expect(payload['grants']['voice']['outgoing']['params']['foo']).to eq('bar')
-  end
 
-  it 'should add video grant' do
-    scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123','secret'
-    vg = Twilio::JWT::AccessToken::VideoGrant.new
-    vg.room = 'room'
-
-    scat.add_grant(vg)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['video']).not_to be_nil
-    expect(payload['grants']['video']['room']).to eq('room')
-  end
 
-  it 'should be able to add conversations grant' do
-    scat = Twilio::JWT::AccessToken.new 'AC123', 'SK123','secret'
-    cg = Twilio::JWT::AccessToken::ConversationsGrant.new
-    cg.configuration_profile_sid = 'VSxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
-    scat.add_grant(cg)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['rtc']).not_to be_nil
-    expect(payload['grants']['rtc']['configuration_profile_sid']).to eq('VSxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
-  end
 
-end

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::OutgoingClientScope.new('test-application-sid')
+      @clientCapability.add_scope(@outgoingScope)
+      escope = 'scope:client:outgoing?appSid%3Dtest-application-sid'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'OutgoingClientScope with client-name' do
+      @outgoingScope = Twilio::JWT::OutgoingClientScope.new('test-application-sid', 'test-client-name')
+      @clientCapability.add_scope(@outgoingScope)
+      escope = 'scope:client:outgoing?appSid%3Dtest-application-sid%26clientName%3Dtest-client-name'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'OutgoingClientScope with params' do
+      @outgoingScope = Twilio::JWT::OutgoingClientScope.new('test-application-sid', nil, {'params_key'=>'param_value'})
+      @clientCapability.add_scope(@outgoingScope)
+      escope = 'scope:client:outgoing?appSid%3Dtest-application-sid%26appParams%3Dparams_key%3Dparam_value'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'IncomingClientScope' do
+      @incomingScope = Twilio::JWT::IncomingClientScope.new('test-client-name')
+      @clientCapability.add_scope(@incomingScope)
+      escope = 'scope:client:incoming?clientName%3Dtest-client-name'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'EventStreamScope sans filters' do
+      @eventStreamScope = Twilio::JWT::EventStreamScope.new
+      @clientCapability.add_scope(@eventStreamScope)
+      escope = 'scope:stream:subscribe?path%3D%2F2010-04-01%2FEvents'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'EventStreamScope with filters' do
+      @eventStreamScope = Twilio::JWT::EventStreamScope.new({'param_key'=>'param_value'})
+      @clientCapability.add_scope(@eventStreamScope)
+      escope = 'scope:stream:subscribe?param_key%3Dparam_value%26path%3D%2F2010-04-01%2FEvents'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'OutgoingClientScope and IncomingClientScope' do
+      @outgoingScope = Twilio::JWT::OutgoingClientScope.new('test-application-sid')
+      @clientCapability.add_scope(@outgoingScope)
+      @incomingScope = Twilio::JWT::IncomingClientScope.new('test-client-name')
+      @clientCapability.add_scope(@incomingScope)
+      escope = 'scope:client:outgoing?appSid%3Dtest-application-sid scope:client:incoming?clientName%3Dtest-client-name'
+      expect(@clientCapability.__send__(:_generate_payload)[:scope]).to eq(escope)
+    end
+
+    it 'complete payload' do
+      @incomingScope = Twilio::JWT::IncomingClientScope.new('test-client-name')
+      @clientCapability.add_scope(@incomingScope)
+      payload, _ = ::JWT.decode @clientCapability.to_s, 'authToken', true, {:algorithm=>'HS256'}
+      escope = 'scope:client:incoming?clientName%3Dtest-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::IncomingClientScope.new('test-client-name')
+      @clientCapability = Twilio::JWT::ClientCapability.new 'accountSid', 'authToken', scopes: [@incomingScope]
+      escope = 'scope:client:incoming?clientName%3Dtest-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,110 +1,177 @@
 require 'spec_helper'
 
-describe Twilio::JWT::TaskRouterCapability do
-  describe 'with a capability' do
-    before :each do
-      @capability = Twilio::JWT::TaskRouterCapability.new 'AC123', 'foobar', 'WS456', 'WS456'
-    end
+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
 
-    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
+  describe Twilio::JWT::TaskRouterCapability do
+    describe 'token initialization' do
+      before :each do
+        @taskRouterCapability = Twilio::JWT::TaskRouterCapability.new 'AC123', 'secret', 'WS456', 'CI123'
+      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 '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 '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)
+      it 'add policy' do
+        @policy = Twilio::JWT::Policy.new(Twilio::JWT::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
 
-    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
+  describe Twilio::JWT::Policy do
+    describe 'policy' do
+      it 'initialize' do
+        @policy = Twilio::JWT::Policy.new('test-url',
+                                          'GET',
+                                          true,
+                                          {'test-post-key'=>'test-post-value'},
+                                          {'test-query-key'=>'test-query-value'}
+        )
 
-    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)
+        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
 
-    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
+    describe Twilio::JWT::TaskRouterUtils do
+      describe 'urls' do
+
+        it 'workspaces' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces'
+          expect(Twilio::JWT::TaskRouterUtils.workspaces).to eq(expected_url)
+        end
+
+        it 'workspace' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123'
+          expect(Twilio::JWT::TaskRouterUtils.workspace('WK123')).to eq(expected_url)
+        end
+
+        it 'all_workspaces' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/**'
+          expect(Twilio::JWT::TaskRouterUtils.all_workspaces).to eq(expected_url)
+        end
+
+        it 'tasks' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/Tasks'
+          expect(Twilio::JWT::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::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::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::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::TaskRouterUtils.task_queue('WK123', 'WQ123')).to eq(expected_url)
+        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)
+        it 'all_task_queues' do
+          expected_url = 'https://taskrouter.twilio.com/v1/Workspaces/WK123/TaskQueues/**'
+          expect(Twilio::JWT::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::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::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::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::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::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::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::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::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::TaskRouterUtils.all_reservations('WK123', 'WT123')).to eq(expected_url)
+        end
+
+      end
+
+      describe 'default policies' do
+        it 'default web_socket_policies' do
+          @policies = Twilio::JWT::TaskRouterUtils.web_socket_policies('AC123', 'CI123')
+          get, post = @policies.map{|policy| policy._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::TaskRouterUtils.worker_policies('WK123', 'WT123')
+          payload = @policies.map{|policy| policy._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
+end
+
+